rbnacl-libsodium 1.0.3 → 1.0.4

data/vendor/libsodium/examples/box.c

@@ -0,0 +1,133 @@
+/*
+ * GraxRabble
+ * example programs for libsodium.
+ */
+
+#include <sodium.h> /* library header */
+
+#include "utils.h" /* utility functions shared by examples */
+
+/*
+ * Using public-key authenticated encryption, Bob can encrypt a
+ * confidential message specifically for Alice, using Alice's public
+ * key.
+ *
+ * Using Bob's public key, Alice can verify that the encrypted
+ * message was actually created by Bob and was not tampered with,
+ * before eventually decrypting it.
+ *
+ * Alice only needs Bob's public key, the nonce and the ciphertext.
+ * Bob should never ever share his secret key, even with Alice.
+ *
+ * And in order to send messages to Alice, Bob only needs Alice's
+ * public key. Alice should never ever share her secret key either,
+ * even with Bob.
+ *
+ * Alice can reply to Bob using the same system, without having to
+ * generate a distinct key pair.
+ *
+ * The nonce doesn't have to be confidential, but it should be used
+ * with just one invokation of crypto_box_open_easy() for a
+ * particular pair of public and secret keys.
+ *
+ * One easy way to generate a nonce is to use randombytes_buf(),
+ * considering the size of nonces the risk of any random collisions
+ * is negligible. For some applications, if you wish to use nonces to
+ * detect missing messages or to ignore replayed messages, it is also
+ * ok to use a simple incrementing counter as a nonce.
+ *
+ * When doing so you must ensure that the same value can never be
+ * re-used (for example you may have multiple threads or even hosts
+ * generating messages using the same key pairs).
+ *
+ * This system provides mutual authentication. However, a typical use
+ * case is to secure communications between a server, whose public
+ * key is known in advance, and clients connecting anonymously.
+ */
+static int
+box(void)
+{
+    unsigned char bob_pk[crypto_box_PUBLICKEYBYTES]; /* Bob's public key */
+    unsigned char bob_sk[crypto_box_SECRETKEYBYTES]; /* Bob's secret key */
+
+    unsigned char alice_pk[crypto_box_PUBLICKEYBYTES]; /* Alice's public key */
+    unsigned char alice_sk[crypto_box_SECRETKEYBYTES]; /* Alice's secret key */
+
+    unsigned char nonce[crypto_box_NONCEBYTES];
+    unsigned char message[MAX_INPUT_LEN];
+    unsigned char ciphertext[crypto_box_MACBYTES + MAX_INPUT_LEN];
+    size_t        message_len;
+    size_t        ciphertext_len;
+    int           ret;
+
+    puts("Example: crypto_box_easy\n");
+
+    puts("Generating keypairs...\n");
+    crypto_box_keypair(bob_pk, bob_sk);     /* generate Bob's keys */
+    crypto_box_keypair(alice_pk, alice_sk); /* generate Alice's keys */
+
+    puts("Bob");
+    printf("Public key: ");
+    print_hex(bob_pk, sizeof bob_pk);
+    printf("Secret key: ");
+    print_hex(bob_sk, sizeof bob_sk);
+
+    puts("Alice");
+    printf("Public key: ");
+    print_hex(alice_pk, sizeof alice_pk);
+    printf("Secret key: ");
+    print_hex(alice_sk, sizeof alice_sk);
+
+    /* nonce must be unique per (key, message) - it can be public and deterministic */
+    puts("Generating nonce...");
+    randombytes_buf(nonce, sizeof nonce);
+    printf("Nonce: ");
+    print_hex(nonce, sizeof nonce);
+
+    /* read input */
+    message_len = prompt_input("a message", (char*)message, sizeof message, 1);
+
+    print_hex(message, message_len);
+
+    /* encrypt and authenticate the message */
+    printf("Encrypting and authenticating with %s\n\n", crypto_box_primitive());
+    crypto_box_easy(ciphertext, message, message_len, nonce, alice_pk, bob_sk);
+    ciphertext_len = crypto_box_MACBYTES + message_len;
+
+    /* send the nonce and the ciphertext */
+    puts("Bob sends the nonce and the ciphertext...\n");
+    printf("Ciphertext len: %zu bytes - Original message length: %zu bytes\n",
+           ciphertext_len, message_len);
+    puts("Notice the prepended 16 byte authentication token\n");
+    printf("Nonce: ");
+    print_hex(nonce, sizeof nonce);
+    printf("Ciphertext: ");
+    print_hex(ciphertext, ciphertext_len);
+
+    /* decrypt the message */
+    puts("Alice verifies and decrypts the ciphertext...");
+    ret = crypto_box_open_easy(message, ciphertext, ciphertext_len, nonce, bob_pk,
+                               alice_sk);
+    print_hex(message, message_len);
+
+    print_verification(ret);
+    if (ret == 0) {
+        printf("Plaintext: ");
+        fwrite(message, 1U, message_len, stdout);
+        putchar('\n');
+    }
+    sodium_memzero(bob_sk, sizeof bob_sk); /* wipe sensitive data */
+    sodium_memzero(alice_sk, sizeof alice_sk);
+    sodium_memzero(message, sizeof message);
+    sodium_memzero(ciphertext, sizeof ciphertext);
+
+    return ret;
+}
+
+int
+main(void)
+{
+    init();
+
+    return box() != 0;
+}

data/vendor/libsodium/examples/box_detached.c

@@ -0,0 +1,132 @@
+/*
+ * GraxRabble
+ * example programs for libsodium.
+ */
+
+#include <sodium.h> /* library header */
+
+#include "utils.h" /* utility functions shared by examples */
+
+/*
+ * Using public-key authenticated encryption, Bob can encrypt a
+ * confidential message specifically for Alice, using Alice's public
+ * key.
+ *
+ * Using Bob's public key, Alice can verify that the encrypted
+ * message was actually created by Bob and was not tampered with,
+ * before eventually decrypting it.
+ *
+ * Alice only needs Bob's public key, the nonce and the ciphertext.
+ * Bob should never ever share his secret key, even with Alice.
+ *
+ * And in order to send messages to Alice, Bob only needs Alice's
+ * public key. Alice should never ever share her secret key either,
+ * even with Bob.
+ *
+ * Alice can reply to Bob using the same system, without having to
+ * generate a distinct key pair.
+ *
+ * The nonce doesn't have to be confidential, but it should be used
+ * with just one invokation of crypto_box_open_easy() for a
+ * particular pair of public and secret keys.
+ *
+ * One easy way to generate a nonce is to use randombytes_buf(),
+ * considering the size of nonces the risk of any random collisions
+ * is negligible. For some applications, if you wish to use nonces to
+ * detect missing messages or to ignore replayed messages, it is also
+ * ok to use a simple incrementing counter as a nonce.
+ *
+ * When doing so you must ensure that the same value can never be
+ * re-used (for example you may have multiple threads or even hosts
+ * generating messages using the same key pairs).
+ *
+ * This system provides mutual authentication. However, a typical use
+ * case is to secure communications between a server, whose public
+ * key is known in advance, and clients connecting anonymously.
+ */
+static int
+box_detached(void)
+{
+    unsigned char bob_pk[crypto_box_PUBLICKEYBYTES]; /* Bob's public key */
+    unsigned char bob_sk[crypto_box_SECRETKEYBYTES]; /* Bob's secret key */
+
+    unsigned char alice_pk[crypto_box_PUBLICKEYBYTES]; /* Alice's public key */
+    unsigned char alice_sk[crypto_box_SECRETKEYBYTES]; /* Alice's secret key */
+
+    unsigned char nonce[crypto_box_NONCEBYTES];
+    unsigned char message[MAX_INPUT_LEN];
+    unsigned char mac[crypto_box_MACBYTES];
+    unsigned char ciphertext[MAX_INPUT_LEN];
+    size_t        message_len;
+    int           ret;
+
+    puts("Example: crypto_box_detached\n");
+
+    puts("Generating keypairs...\n");
+    crypto_box_keypair(bob_pk, bob_sk);     /* generate Bob's keys */
+    crypto_box_keypair(alice_pk, alice_sk); /* generate Alice's keys */
+
+    puts("Bob");
+    printf("Public key: ");
+    print_hex(bob_pk, sizeof bob_pk);
+    printf("Secret key: ");
+    print_hex(bob_sk, sizeof bob_sk);
+
+    puts("Alice");
+    printf("Public key: ");
+    print_hex(alice_pk, sizeof alice_pk);
+    printf("Secret key: ");
+    print_hex(alice_sk, sizeof alice_sk);
+
+    /* nonce must be unique per (key, message) - it can be public and deterministic */
+    puts("Generating nonce...");
+    randombytes_buf(nonce, sizeof nonce);
+    printf("Nonce: ");
+    print_hex(nonce, sizeof nonce);
+
+    /* read input */
+    message_len = prompt_input("a message", (char*)message, sizeof message, 1);
+
+    print_hex(message, message_len);
+
+    /* encrypt and authenticate the message */
+    printf("Encrypting and authenticating with %s\n\n", crypto_box_primitive());
+    crypto_box_detached(ciphertext, mac, message, message_len, nonce,
+                        alice_pk, bob_sk);
+
+    /* send the nonce, the MAC and the ciphertext */
+    puts("Bob sends the nonce, the MAC and the ciphertext...\n");
+    printf("Nonce: ");
+    print_hex(nonce, sizeof nonce);
+    printf("MAC: ");
+    print_hex(mac, sizeof mac);
+    printf("Ciphertext: ");
+    print_hex(ciphertext, message_len);
+
+    /* decrypt the message */
+    puts("Alice verifies the MAC and decrypts the ciphertext...");
+    ret = crypto_box_open_detached(message, ciphertext, mac, message_len, nonce,
+                                   bob_pk, alice_sk);
+    print_hex(message, message_len);
+
+    print_verification(ret);
+    if (ret == 0) {
+        printf("Plaintext: ");
+        fwrite(message, 1U, message_len, stdout);
+        putchar('\n');
+    }
+    sodium_memzero(bob_sk, sizeof bob_sk); /* wipe sensitive data */
+    sodium_memzero(alice_sk, sizeof alice_sk);
+    sodium_memzero(message, sizeof message);
+    sodium_memzero(ciphertext, sizeof ciphertext);
+
+    return ret;
+}
+
+int
+main(void)
+{
+    init();
+
+    return box_detached() != 0;
+}

data/vendor/libsodium/examples/generichash.c

@@ -0,0 +1,80 @@
+/*
+ * GraxRabble
+ * example programs for libsodium.
+ */
+
+#include <sodium.h> /* library header */
+
+#include "utils.h" /* utility functions shared by examples */
+
+/*
+ * This function computes a fixed-length fingerprint for an arbitrary long message.
+ *
+ * Sample use cases:
+ *
+ * File integrity checking
+ * Creating unique identifiers to index arbitrary long data
+ *
+ * The crypto_generichash() function puts a fingerprint of the
+ * message in whose length is inlen bytes into out. The output size
+ * can be chosen by the application.
+ *
+ * The minimum recommended output size is crypto_generichash_BYTES.
+ * This size makes it practically impossible for two messages to
+ * produce the same fingerprint.
+ *
+ * But for specific use cases, the size can be any value between
+ * crypto_generichash_BYTES_MIN (included) and
+ * crypto_generichash_BYTES_MAX (included).
+ *
+ * key can be NULL and keylen can be 0. In this case, a message will
+ * always have the same fingerprint, similar to the MD5 or SHA-1
+ * functions for which crypto_generichash() is a faster and more
+ * secure alternative.
+ *
+ * But a key can also be specified. A message will always have the
+ * same fingerprint for a given key, but different keys used to hash
+ * the same message are very likely to produce distinct fingerprints.
+ *
+ * In particular, the key can be used to make sure that different
+ * applications generate different fingerprints even if they process
+ * the same data.
+ *
+ * The recommended key size is crypto_generichash_KEYBYTES bytes.
+ *
+ * However, the key size can by any value between
+ * crypto_generichash_KEYBYTES_MIN (included) and
+ * crypto_generichash_KEYBYTES_MAX (included).
+ */
+void
+generichash(void)
+{
+    unsigned char key[crypto_generichash_KEYBYTES_MAX];
+    unsigned char hash[crypto_generichash_BYTES];
+    unsigned char message[MAX_INPUT_LEN];
+    size_t        message_len;
+    size_t        key_len;
+
+    puts("Example: crypto_generichash\n");
+
+    key_len = prompt_input("a key", (char*)key, sizeof key, 1);
+    message_len = prompt_input("a message", (char*)message, sizeof message, 1);
+
+    printf("Hashing message with %s\n", crypto_generichash_primitive());
+    if (crypto_generichash(hash, sizeof hash, message, message_len,
+                           key, key_len) != 0) {
+        puts("Couldn't hash the message, probably due to the key length");
+    } else {
+        printf("Hash: ");
+        print_hex(hash, sizeof hash);
+    }
+}
+
+int
+main(void)
+{
+    init();
+    generichash();
+
+    return 0;
+}

data/vendor/libsodium/examples/generichash_stream.c

@@ -0,0 +1,58 @@
+/*
+ * GraxRabble
+ * example programs for libsodium.
+ */
+
+#include <sodium.h> /* library header */
+
+#include "utils.h" /* utility functions shared by examples */
+
+/*
+ * Streaming variant of generic hash. This has the ability to hash
+ * data in chunks at a time and compute the same result as hashing
+ * all of the data at once.
+ */
+void
+generichash_stream(void)
+{
+    unsigned char            key[crypto_generichash_KEYBYTES_MAX];
+    unsigned char            hash[crypto_generichash_BYTES];
+    unsigned char            message_part[MAX_INPUT_LEN];
+    crypto_generichash_state state;
+    size_t                   message_part_len;
+
+    puts("Example: crypto_generichashstream\n");
+
+    prompt_input("a key", (char*)key, sizeof key, 1);
+
+    printf("Hashing message with %s\n", crypto_generichash_primitive());
+
+    /* initialize the stream */
+    if (crypto_generichash_init(&state, key, sizeof key, sizeof hash) != 0) {
+        puts("Couldn't hash the message, probably due to the key length");
+        exit(EXIT_FAILURE);
+    }
+
+    for(;;) {
+        message_part_len = prompt_input("the next part of the message",
+                                        (char*)message_part, sizeof message_part, 1);
+        if (message_part_len == 0)
+            break;
+
+        /* keep appending data */
+        crypto_generichash_update(&state, message_part, message_part_len);
+    }
+    crypto_generichash_final(&state, hash, sizeof hash);
+
+    printf("Hash: ");
+    print_hex(hash, sizeof hash);
+}
+
+int
+main(void)
+{
+    init();
+    generichash_stream();
+
+    return 0;
+}

data/vendor/libsodium/examples/shorthash.c

@@ -0,0 +1,58 @@
+/*
+ * GraxRabble
+ * example programs for libsodium.
+ */
+
+#include <sodium.h> /* library header */
+
+#include "utils.h" /* utility functions shared by examples */
+
+/*
+ * Many applications and programming language implementations were
+ * recently found to be vulnerable to denial-of-service attacks when
+ * a hash function with weak security guarantees, such as Murmurhash
+ * 3, was used to construct a hash table.
+ *
+ * In order to address this, Sodium provides the crypto_shorthash()
+ * function, which outputs short but unpredictable (without knowing
+ * the secret key) values suitable for picking a list in a hash table
+ * for a given key.
+ *
+ * This function is optimized for short inputs.
+ *
+ * The output of this function is only 64 bits. Therefore, it should
+ * not be considered collision-resistant.
+ *
+ * Use cases:
+ *
+ * - Hash tables
+ * - Probabilistic data structures such as Bloom filters
+ * - Integrity checking in interactive protocols
+ */
+void
+shorthash(void)
+{
+    unsigned char key[crypto_shorthash_KEYBYTES];
+    unsigned char hash[crypto_shorthash_BYTES];
+    unsigned char message[MAX_INPUT_LEN];
+    size_t        message_len;
+
+    puts("Example: crypto_shorthash\n");
+
+    prompt_input("a key", (char*)key, sizeof key, 0);
+    message_len = prompt_input("a message", (char*)message, sizeof message, 1);
+
+    printf("Hashing the message with %s\n", crypto_shorthash_primitive());
+    crypto_shorthash(hash, message, message_len, key);
+    printf("Hash: ");
+    print_hex(hash, sizeof hash);
+}
+
+int
+main(void)
+{
+    init();
+    shorthash();
+
+    return 0;
+}