File Manager

003 File Manager

Current Path: /usr/src/sys/contrib/libsodium/test/default

usr / src / sys / contrib / libsodium / test / default /

📁 ..
📄 Makefile.am(13.38 KB)
📄 aead_aes256gcm.c(145.82 KB)
📄 aead_aes256gcm.exp(3 B)
📄 aead_chacha20poly1305.c(14.76 KB)
📄 aead_chacha20poly1305.exp(2.35 KB)
📄 aead_xchacha20poly1305.c(8.09 KB)
📄 aead_xchacha20poly1305.exp(1.95 KB)
📄 auth.c(2.88 KB)
📄 auth.exp(1.12 KB)
📄 auth2.c(1.08 KB)
📄 auth2.exp(164 B)
📄 auth3.c(1.25 KB)
📄 auth3.exp(2 B)
📄 auth5.c(954 B)
📄 auth6.c(449 B)
📄 auth6.exp(328 B)
📄 auth7.c(1010 B)
📄 box.c(4.42 KB)
📄 box.exp(1.47 KB)
📄 box2.c(3.31 KB)
📄 box2.exp(1.31 KB)
📄 box7.c(1.53 KB)
📄 box8.c(1.7 KB)
📄 box_easy.c(2.83 KB)
📄 box_easy.exp(908 B)
📄 box_easy2.c(5.42 KB)
📄 box_easy2.exp(15 B)
📄 box_seal.c(1.2 KB)
📄 box_seal.exp(11 B)
📄 box_seed.c(839 B)
📄 box_seed.exp(328 B)
📄 chacha20.c(7.63 KB)
📄 chacha20.exp(20.19 KB)
📄 cmptest.h(4.22 KB)
📄 codecs.c(11.08 KB)
📄 codecs.exp(367 B)
📄 core1.c(1.18 KB)
📄 core1.exp(164 B)
📄 core2.c(1.19 KB)
📄 core2.exp(164 B)
📄 core3.c(3.19 KB)
📄 core3.exp(195 B)
📄 core4.c(981 B)
📄 core4.exp(264 B)
📄 core5.c(908 B)
📄 core5.exp(164 B)
📄 core6.c(1.31 KB)
📄 core6.exp(164 B)
📄 core_ed25519.c(5.44 KB)
📄 core_ed25519.exp(3 B)
📄 ed25519_convert.c(3.4 KB)
📄 ed25519_convert.exp(167 B)
📄 generichash.c(144.45 KB)
📄 generichash.exp(4.25 KB)
📄 generichash2.c(2.41 KB)
📄 generichash2.exp(4.13 KB)
📄 generichash3.c(7.17 KB)
📄 generichash3.exp(5.51 KB)
📄 hash.c(1.47 KB)
📄 hash.exp(388 B)
📄 hash2.exp(129 B)
📄 hash3.c(335 B)
📄 hash3.exp(129 B)
📄 index.html.tpl(2.67 KB)
📄 kdf.c(2.31 KB)
📄 kdf.exp(5.97 KB)
📄 keygen.c(2.62 KB)
📄 keygen.exp(14 B)
📄 kx.c(6.21 KB)
📄 kx.exp(478 B)
📄 metamorphic.c(5.48 KB)
📄 metamorphic.exp(3 B)
📄 misuse.c(3.67 KB)
📄 nacl-test-wrapper.sh(771 B)
📄 onetimeauth.c(2.32 KB)
📄 onetimeauth.exp(164 B)
📄 onetimeauth2.c(1.38 KB)
📄 onetimeauth2.exp(2 B)
📄 onetimeauth7.c(948 B)
📄 pre.js.inc(563 B)
📄 pwhash_argon2i.c(21.74 KB)
📄 pwhash_argon2i.exp(3.03 KB)
📄 pwhash_argon2id.c(25.18 KB)
📄 pwhash_argon2id.exp(3.61 KB)
📄 pwhash_scrypt.c(18.31 KB)
📄 pwhash_scrypt.exp(4.53 KB)
📄 pwhash_scrypt_ll.c(1.68 KB)
📄 pwhash_scrypt_ll.exp(714 B)
📄 randombytes.c(4 KB)
📄 randombytes.exp(220 B)
📄 scalarmult.c(2.42 KB)
📄 scalarmult.exp(260 B)
📄 scalarmult2.c(794 B)
📄 scalarmult2.exp(164 B)
📄 scalarmult5.c(1.18 KB)
📄 scalarmult5.exp(164 B)
📄 scalarmult6.c(1.51 KB)
📄 scalarmult6.exp(164 B)
📄 scalarmult7.c(909 B)
📄 scalarmult7.exp(2 B)
📄 scalarmult_ed25519.c(3.4 KB)
📄 scalarmult_ed25519.exp(3 B)
📄 secretbox.c(3.5 KB)
📄 secretbox.exp(1.47 KB)
📄 secretbox2.c(2.37 KB)
📄 secretbox2.exp(672 B)
📄 secretbox7.c(1.05 KB)
📄 secretbox8.c(1.2 KB)
📄 secretbox_easy.c(4.44 KB)
📄 secretbox_easy.exp(4.02 KB)
📄 secretbox_easy2.c(2.54 KB)
📄 secretbox_easy2.exp(10 B)
📄 secretstream.c(11.43 KB)
📄 secretstream.exp(3 B)
📄 shorthash.c(968 B)
📄 shorthash.exp(1.06 KB)
📄 sign.c(2.65 MB)
📄 sign.exp(512 B)
📄 siphashx24.c(1.02 KB)
📄 siphashx24.exp(2.06 KB)
📄 sodium_core.c(936 B)
📄 sodium_core.exp(17 B)
📄 sodium_utils.c(6.41 KB)
📄 sodium_utils.exp(550 B)
📄 sodium_utils2.c(2.22 KB)
📄 sodium_utils2.exp(46 B)
📄 sodium_utils3.c(1.35 KB)
📄 sodium_utils3.exp(43 B)
📄 sodium_version.c(387 B)
📄 sodium_version.exp(6 B)
📄 stream.c(2.33 KB)
📄 stream.exp(8.57 KB)
📄 stream2.c(1.48 KB)
📄 stream2.exp(130 B)
📄 stream3.c(979 B)
📄 stream3.exp(164 B)
📄 stream4.c(2.02 KB)
📄 stream4.exp(672 B)
📄 verify1.c(2.05 KB)
📄 verify1.exp(6 B)
📄 wintest.bat(1.34 KB)
📄 xchacha20.c(25.49 KB)
📄 xchacha20.exp(482 B)

Editing: kx.c

#define TEST_NAME "kx"
#include "cmptest.h"

static const unsigned char small_order_p[crypto_scalarmult_BYTES] = {
    0xe0, 0xeb, 0x7a, 0x7c, 0x3b, 0x41, 0xb8, 0xae, 0x16, 0x56, 0xe3,
    0xfa, 0xf1, 0x9f, 0xc4, 0x6a, 0xda, 0x09, 0x8d, 0xeb, 0x9c, 0x32,
    0xb1, 0xfd, 0x86, 0x62, 0x05, 0x16, 0x5f, 0x49, 0xb8, 0x00
};

static void
tv_kx(void)
{
    unsigned char *seed;
    unsigned char *client_pk, *client_sk;
    unsigned char *client_rx, *client_tx;
    unsigned char *server_pk, *server_sk;
    unsigned char *server_rx, *server_tx;
    char           hex[65];
    int            i;

seed = (unsigned char *) sodium_malloc(crypto_kx_SEEDBYTES);
    for (i = 0; i < crypto_kx_SEEDBYTES; i++) {
        seed[i] = (unsigned char) i;
    }
    client_pk = (unsigned char *) sodium_malloc(crypto_kx_PUBLICKEYBYTES);
    client_sk = (unsigned char *) sodium_malloc(crypto_kx_SECRETKEYBYTES);
    crypto_kx_seed_keypair(client_pk, client_sk, seed);

sodium_bin2hex(hex, sizeof hex, client_pk, crypto_kx_PUBLICKEYBYTES);
    printf("client_pk: [%s]\n", hex);
    sodium_bin2hex(hex, sizeof hex, client_sk, crypto_kx_SECRETKEYBYTES);
    printf("client_sk: [%s]\n", hex);

server_pk = (unsigned char *) sodium_malloc(crypto_kx_PUBLICKEYBYTES);
    server_sk = (unsigned char *) sodium_malloc(crypto_kx_SECRETKEYBYTES);
    crypto_kx_keypair(server_pk, server_sk);

client_rx = (unsigned char *) sodium_malloc(crypto_kx_SESSIONKEYBYTES);
    client_tx = (unsigned char *) sodium_malloc(crypto_kx_SESSIONKEYBYTES);

assert(crypto_kx_client_session_keys(client_rx, client_tx,
                                         client_pk, client_sk,
                                         small_order_p) == -1);
    if (crypto_kx_client_session_keys(client_rx, client_tx,
                                      client_pk, client_sk, server_pk) != 0) {
        printf("crypto_kx_client_session_keys() failed\n");
    }

server_rx = (unsigned char *) sodium_malloc(crypto_kx_SESSIONKEYBYTES);
    server_tx = (unsigned char *) sodium_malloc(crypto_kx_SESSIONKEYBYTES);

assert(crypto_kx_server_session_keys(server_rx, server_tx,
                                         server_pk, server_sk,
                                         small_order_p) == -1);
    if (crypto_kx_server_session_keys(server_rx, server_tx,
                                      server_pk, server_sk, client_pk) != 0) {
        printf("crypto_kx_server_session_keys() failed\n");
    }
    if (memcmp(server_rx, client_tx, crypto_kx_SESSIONKEYBYTES) != 0 ||
        memcmp(server_tx, client_rx, crypto_kx_SESSIONKEYBYTES) != 0) {
        printf("client session keys != server session keys\n");
    }

sodium_increment(client_pk, crypto_kx_PUBLICKEYBYTES);
    if (crypto_kx_server_session_keys(server_rx, server_tx,
                                      server_pk, server_sk, client_pk) != 0) {
        printf("crypto_kx_server_session_keys() failed\n");
    }
    if (memcmp(server_rx, client_tx, crypto_kx_SESSIONKEYBYTES) == 0 &&
        memcmp(server_tx, client_rx, crypto_kx_SESSIONKEYBYTES) == 0) {
        printf("peer's public key is ignored\n");
    }

crypto_kx_keypair(client_pk, client_sk);
    if (crypto_kx_server_session_keys(server_rx, server_tx,
                                      server_pk, server_sk, client_pk) != 0) {
        printf("crypto_kx_server_session_keys() failed\n");
    }
    if (memcmp(server_rx, client_tx, crypto_kx_SESSIONKEYBYTES) == 0 ||
        memcmp(server_tx, client_rx, crypto_kx_SESSIONKEYBYTES) == 0) {
        printf("session keys are constant\n");
    }

crypto_kx_seed_keypair(client_pk, client_sk, seed);
    sodium_increment(seed, crypto_kx_SEEDBYTES);
    crypto_kx_seed_keypair(server_pk, server_sk, seed);
    if (crypto_kx_server_session_keys(server_rx, server_tx,
                                      server_pk, server_sk, client_pk) != 0) {
        printf("crypto_kx_server_session_keys() failed\n");
    }
    sodium_bin2hex(hex, sizeof hex, server_rx, crypto_kx_SESSIONKEYBYTES);
    printf("server_rx: [%s]\n", hex);
    sodium_bin2hex(hex, sizeof hex, server_tx, crypto_kx_SESSIONKEYBYTES);
    printf("server_tx: [%s]\n", hex);

if (crypto_kx_client_session_keys(client_rx, client_tx,
                                      client_pk, client_sk, server_pk) != 0) {
        printf("crypto_kx_client_session_keys() failed\n");
    }
    sodium_bin2hex(hex, sizeof hex, client_rx, crypto_kx_SESSIONKEYBYTES);
    printf("client_rx: [%s]\n", hex);
    sodium_bin2hex(hex, sizeof hex, client_tx, crypto_kx_SESSIONKEYBYTES);
    printf("client_tx: [%s]\n", hex);

randombytes_buf(client_rx, crypto_kx_SESSIONKEYBYTES);
    randombytes_buf(client_tx, crypto_kx_SESSIONKEYBYTES);
    randombytes_buf(server_rx, crypto_kx_SESSIONKEYBYTES);
    randombytes_buf(server_tx, crypto_kx_SESSIONKEYBYTES);
    if (crypto_kx_client_session_keys(client_rx, NULL,
                                      client_pk, client_sk, server_pk) != 0 ||
        crypto_kx_client_session_keys(NULL, client_tx,
                                      client_pk, client_sk, server_pk) != 0 ||
        crypto_kx_server_session_keys(server_rx, NULL,
                                      server_pk, server_sk, client_pk) != 0 ||
        crypto_kx_server_session_keys(NULL, server_tx,
                                      server_pk, server_sk, client_pk) != 0) {
        printf("failure when one of the pointers happens to be NULL");
    }
    assert(memcmp(client_rx, client_tx, crypto_kx_SESSIONKEYBYTES) == 0);
    assert(memcmp(client_tx, server_rx, crypto_kx_SESSIONKEYBYTES) == 0);
    assert(memcmp(server_rx, server_tx, crypto_kx_SESSIONKEYBYTES) == 0);

sodium_free(client_rx);
    sodium_free(client_tx);
    sodium_free(server_rx);
    sodium_free(server_tx);
    sodium_free(server_sk);
    sodium_free(server_pk);
    sodium_free(client_sk);
    sodium_free(client_pk);
    sodium_free(seed);

assert(strcmp(crypto_kx_primitive(), crypto_kx_PRIMITIVE) == 0);
    assert(crypto_kx_publickeybytes() == crypto_kx_PUBLICKEYBYTES);
    assert(crypto_kx_secretkeybytes() == crypto_kx_SECRETKEYBYTES);
    assert(crypto_kx_seedbytes() == crypto_kx_SEEDBYTES);
    assert(crypto_kx_sessionkeybytes() == crypto_kx_SESSIONKEYBYTES);

printf("tv_kx: ok\n");
}

int
main(void)
{
    tv_kx();

return 0;
}

003 File Manager

Editing: kx.c

Upload File

Create Folder