rbnacl-libsodium 0.7.0 → 1.0.0

data/vendor/libsodium/test/default/sign.c

@@ -1,23 +1,14 @@
-#include <stdio.h>
-#include <string.h>
 
 #define TEST_NAME "sign"
 #include "cmptest.h"
 
-#define KEYPAIR_SEED "1@ABCFGHLOPRSTUWabcdefghiklmnopq"
-
-#define crypto_sign_SECRETKEYBYTES_WITHOUT_PK \
-    (crypto_sign_SECRETKEYBYTES - crypto_sign_PUBLICKEYBYTES)
-
-static const unsigned char keypair_seed[] = {
-    0x42, 0x11, 0x51, 0xa4, 0x59, 0xfa, 0xea, 0xde,
-    0x3d, 0x24, 0x71, 0x15, 0xf9, 0x4a, 0xed, 0xae,
-    0x42, 0x31, 0x81, 0x24, 0x09, 0x5a, 0xfa, 0xbe,
-    0x4d, 0x14, 0x51, 0xa5, 0x59, 0xfa, 0xed, 0xee
-};
+static const unsigned char keypair_seed[]
+    = { 0x42, 0x11, 0x51, 0xa4, 0x59, 0xfa, 0xea, 0xde, 0x3d, 0x24, 0x71,
+        0x15, 0xf9, 0x4a, 0xed, 0xae, 0x42, 0x31, 0x81, 0x24, 0x09, 0x5a,
+        0xfa, 0xbe, 0x4d, 0x14, 0x51, 0xa5, 0x59, 0xfa, 0xed, 0xee };
 
 typedef struct TestData_ {
-    const unsigned char  sk[crypto_sign_SECRETKEYBYTES_WITHOUT_PK];
+    const unsigned char  sk[crypto_sign_SEEDBYTES];
     const unsigned char  pk[crypto_sign_PUBLICKEYBYTES];
     const unsigned char  sig[crypto_sign_BYTES];
     const char          *m;
@@ -1052,27 +1043,29 @@ static TestData test_data[] = {
 
 int main(void)
 {
-    unsigned char      extracted_seed[crypto_sign_ed25519_SEEDBYTES];
-    unsigned char      extracted_pk[crypto_sign_ed25519_PUBLICKEYBYTES];
-    unsigned char      sig[crypto_sign_BYTES];
-    unsigned char      sm[1024 + crypto_sign_BYTES];
-    unsigned char      m[1024];
-    unsigned char      skpk[crypto_sign_SECRETKEYBYTES];
-    unsigned char      pk[crypto_sign_PUBLICKEYBYTES];
-    unsigned char      sk[crypto_sign_SECRETKEYBYTES];
-    char               pk_hex[crypto_sign_PUBLICKEYBYTES * 2 + 1];
-    char               sk_hex[crypto_sign_SECRETKEYBYTES * 2 + 1];
+    unsigned char extracted_seed[crypto_sign_ed25519_SEEDBYTES];
+    unsigned char extracted_pk[crypto_sign_ed25519_PUBLICKEYBYTES];
+    unsigned char sig[crypto_sign_BYTES];
+    unsigned char sm[1024 + crypto_sign_BYTES];
+    unsigned char m[1024];
+    unsigned char skpk[crypto_sign_SECRETKEYBYTES];
+    unsigned char pk[crypto_sign_PUBLICKEYBYTES];
+    unsigned char sk[crypto_sign_SECRETKEYBYTES];
+    char          pk_hex[crypto_sign_PUBLICKEYBYTES * 2 + 1];
+    char          sk_hex[crypto_sign_SECRETKEYBYTES * 2 + 1];
     unsigned long long siglen;
     unsigned long long smlen;
     unsigned long long mlen;
-    unsigned int       i;
+    unsigned int i;
+    unsigned int j;
 
+    memset(sig, 0, sizeof sig);
     for (i = 0U; i < (sizeof test_data) / (sizeof test_data[0]); i++) {
-        memcpy(skpk, test_data[i].sk, crypto_sign_SECRETKEYBYTES_WITHOUT_PK);
-        memcpy(skpk + crypto_sign_SECRETKEYBYTES_WITHOUT_PK,
-               test_data[i].pk, crypto_sign_PUBLICKEYBYTES);
-        if (crypto_sign(sm, &smlen,
-                        (const unsigned char *) test_data[i].m, i, skpk) != 0) {
+        memcpy(skpk, test_data[i].sk, crypto_sign_SEEDBYTES);
+        memcpy(skpk + crypto_sign_SEEDBYTES, test_data[i].pk,
+               crypto_sign_PUBLICKEYBYTES);
+        if (crypto_sign(sm, &smlen, (const unsigned char *)test_data[i].m, i,
+                        skpk) != 0) {
             printf("crypto_sign() failure: [%u]\n", i);
             continue;
         }
@@ -1084,7 +1077,7 @@ int main(void)
             printf("crypto_sign_open() failure: [%u]\n", i);
             continue;
         }
-        if (memcmp(test_data[i].m, m, (size_t) mlen) != 0) {
+        if (memcmp(test_data[i].m, m, (size_t)mlen) != 0) {
             printf("message verification failure: [%u]\n", i);
             continue;
         }
@@ -1096,12 +1089,12 @@ int main(void)
         if (crypto_sign_open(m, &mlen, sm, i % crypto_sign_BYTES,
                              test_data[i].pk) == 0) {
             printf("short signed message verifies: [%u]\n",
-                   i  % crypto_sign_BYTES);
+                   i % crypto_sign_BYTES);
             continue;
         }
         if (crypto_sign_detached(sig, &siglen,
-                                 (const unsigned char *) test_data[i].m,
-                                 i, skpk) != 0) {
+                                 (const unsigned char *)test_data[i].m, i, skpk)
+            != 0) {
             printf("detached signature failed: [%u]\n", i);
             continue;
         }
@@ -1114,7 +1107,7 @@ int main(void)
             continue;
         }
         if (crypto_sign_verify_detached(sig,
-                                        (const unsigned char *) test_data[i].m,
+                                        (const unsigned char *)test_data[i].m,
                                         i, test_data[i].pk) != 0) {
             printf("detached signature verification failed: [%u]\n", i);
             continue;
@@ -1122,6 +1115,37 @@ int main(void)
     }
     printf("%u tests\n", i);
 
+    i--;
+
+    memcpy(sm, test_data[i].m, i);
+    if (crypto_sign(sm, &smlen, sm, i, skpk) != 0) {
+        printf("crypto_sign() with overlap failed\n");
+    }
+    if (crypto_sign_open(sm, &mlen, sm, smlen, test_data[i].pk) != 0) {
+        printf("crypto_sign_open() with overlap failed\n");
+    }
+    if (memcmp(test_data[i].m, sm, (size_t)mlen) != 0) {
+        printf("crypto_sign_open() with overlap failed (content)\n");
+    }
+
+    for (j = 1U; j < 8U; j++) {
+        sig[63] ^= (j << 5);
+        if (crypto_sign_verify_detached(sig,
+                                        (const unsigned char *)test_data[i].m,
+                                        i, test_data[i].pk) != -1) {
+            printf("detached signature verification should have failed\n");
+            continue;
+        }
+        sig[63] ^= (j << 5);
+    }
+
+    memset(pk, 0, sizeof pk);
+    if (crypto_sign_verify_detached(sig,
+                                    (const unsigned char *)test_data[i].m,
+                                    i, pk) != -1) {
+        printf("detached signature verification should have failed\n");
+    }
+
     if (crypto_sign_keypair(pk, sk) != 0) {
         printf("crypto_sign_keypair() failure\n");
     }
@@ -1130,13 +1154,12 @@ int main(void)
         return -1;
     }
     crypto_sign_ed25519_sk_to_seed(extracted_seed, sk);
-    if (memcmp(extracted_seed, keypair_seed,
-               crypto_sign_ed25519_SEEDBYTES) != 0) {
+    if (memcmp(extracted_seed, keypair_seed, crypto_sign_ed25519_SEEDBYTES)
+        != 0) {
         printf("crypto_sign_ed25519_sk_to_seed() failure\n");
     }
     crypto_sign_ed25519_sk_to_pk(extracted_pk, sk);
-    if (memcmp(extracted_pk, pk,
-               crypto_sign_ed25519_PUBLICKEYBYTES) != 0) {
+    if (memcmp(extracted_pk, pk, crypto_sign_ed25519_PUBLICKEYBYTES) != 0) {
         printf("crypto_sign_ed25519_sk_to_pk() failure\n");
     }
     sodium_bin2hex(pk_hex, sizeof pk_hex, pk, sizeof pk);
@@ -1145,5 +1168,17 @@ int main(void)
     printf("pk: [%s]\n", pk_hex);
     printf("sk: [%s]\n", sk_hex);
 
+    assert(crypto_sign_bytes() > 0U);
+    assert(crypto_sign_seedbytes() > 0U);
+    assert(crypto_sign_publickeybytes() > 0U);
+    assert(crypto_sign_secretkeybytes() > 0U);
+    assert(strcmp(crypto_sign_primitive(), "ed25519") == 0);
+    assert(crypto_sign_bytes() == crypto_sign_ed25519_bytes());
+    assert(crypto_sign_seedbytes() == crypto_sign_ed25519_seedbytes());
+    assert(crypto_sign_publickeybytes()
+           == crypto_sign_ed25519_publickeybytes());
+    assert(crypto_sign_secretkeybytes()
+           == crypto_sign_ed25519_secretkeybytes());
+
     return 0;
 }

data/vendor/libsodium/test/default/sodium_core.c

@@ -1,11 +1,14 @@
-#include <stdio.h>
 
 #define TEST_NAME "sodium_core"
 #include "cmptest.h"
 
 int main(void)
 {
-  printf ("%d\n", sodium_init());
+    printf("%d\n", sodium_init());
 
-  return 0;
+    (void)sodium_runtime_has_neon();
+    (void)sodium_runtime_has_sse2();
+    (void)sodium_runtime_has_sse3();
+
+    return 0;
 }

data/vendor/libsodium/test/default/sodium_utils.c

@@ -1,35 +1,64 @@
-#include <stdio.h>
-#include <string.h>
 
 #define TEST_NAME "sodium_utils"
 #include "cmptest.h"
 
 int main(void)
 {
-  unsigned char buf1[1000];
-  unsigned char buf2[1000];
-  char          buf3[33];
-  unsigned char buf4[4];
-  const char   *hex;
-  size_t        bin_len;
-
-  randombytes(buf1, sizeof buf1);
-  memcpy(buf2, buf1, sizeof buf2);
-  printf("%d\n", sodium_memcmp(buf1, buf2, sizeof buf1));
-  sodium_memzero(buf1, 0U);
-  printf("%d\n", sodium_memcmp(buf1, buf2, sizeof buf1));
-  sodium_memzero(buf1, sizeof buf1 / 2);
-  printf("%d\n", sodium_memcmp(buf1, buf2, sizeof buf1));
-  printf("%d\n", sodium_memcmp(buf1, buf2, 0U));
-  sodium_memzero(buf2, sizeof buf2 / 2);
-  printf("%d\n", sodium_memcmp(buf1, buf2, sizeof buf1));
-  printf("%s\n", sodium_bin2hex(buf3, 33U,
-                                (const unsigned char *)
-                                "0123456789ABCDEF", 16U));
-  hex = "Cafe : 6942";
-  sodium_hex2bin(buf4, sizeof buf4, hex, strlen(hex), ": ", &bin_len, NULL);
-  printf("%lu:%02x%02x%02x%02x\n", (unsigned long) bin_len,
-         buf4[0], buf4[1], buf4[2], buf4[3]);
-
-  return 0;
+    unsigned char buf1[1000];
+    unsigned char buf2[1000];
+    char buf3[33];
+    unsigned char buf4[4];
+    const char *hex;
+    const char *hex_end;
+    size_t bin_len;
+
+    randombytes_buf(buf1, sizeof buf1);
+    memcpy(buf2, buf1, sizeof buf2);
+    printf("%d\n", sodium_memcmp(buf1, buf2, sizeof buf1));
+    sodium_memzero(buf1, 0U);
+    printf("%d\n", sodium_memcmp(buf1, buf2, sizeof buf1));
+    sodium_memzero(buf1, sizeof buf1 / 2);
+    printf("%d\n", sodium_memcmp(buf1, buf2, sizeof buf1));
+    printf("%d\n", sodium_memcmp(buf1, buf2, 0U));
+    sodium_memzero(buf2, sizeof buf2 / 2);
+    printf("%d\n", sodium_memcmp(buf1, buf2, sizeof buf1));
+    printf("%s\n",
+           sodium_bin2hex(buf3, 33U, (const unsigned char *)"0123456789ABCDEF",
+                          16U));
+    hex = "Cafe : 6942";
+    sodium_hex2bin(buf4, sizeof buf4, hex, strlen(hex), ": ", &bin_len, &hex_end);
+    printf("%lu:%02x%02x%02x%02x\n", (unsigned long)bin_len, buf4[0], buf4[1],
+           buf4[2], buf4[3]);
+    printf("dt1: %ld\n", (long) (hex_end - hex));
+
+    hex = "Cafe : 6942";
+    sodium_hex2bin(buf4, sizeof buf4, hex, strlen(hex), ": ", &bin_len, NULL);
+    printf("%lu:%02x%02x%02x%02x\n", (unsigned long)bin_len, buf4[2], buf4[3],
+           buf4[2], buf4[3]);
+
+    hex = "deadbeef";
+    if (sodium_hex2bin(buf1, 1U, hex, 8U, NULL, &bin_len, &hex_end) != -1) {
+        printf("sodium_hex2bin() overflow not detected\n");
+    }
+    printf("dt2: %ld\n", (long) (hex_end - hex));
+
+    hex = "de:ad:be:eff";
+    if (sodium_hex2bin(buf1, 4U, hex, 12U, ":", &bin_len, &hex_end) != -1) {
+        printf("sodium_hex2bin() with an odd input length and a short output buffer\n");
+    }
+    printf("dt3: %ld\n", (long) (hex_end - hex));
+
+    hex = "de:ad:be:eff";
+    if (sodium_hex2bin(buf1, sizeof buf1, hex, 12U, ":", &bin_len, &hex_end) != 0) {
+        printf("sodium_hex2bin() with an odd input length\n");
+    }
+    printf("dt4: %ld\n", (long) (hex_end - hex));
+
+    hex = "de:ad:be:eff";
+    if (sodium_hex2bin(buf1, sizeof buf1, hex, 13U, ":", &bin_len, &hex_end) != 0) {
+        printf("sodium_hex2bin() with an odd input length\n");
+    }
+    printf("dt5: %ld\n", (long) (hex_end - hex));
+
+    return 0;
 }

data/vendor/libsodium/test/default/sodium_utils.exp

@@ -5,3 +5,9 @@
 0
 30313233343536373839414243444546
 4:cafe6942
+dt1: 11
+4:69426942
+dt2: 2
+dt3: 11
+dt4: 11
+dt5: 11

data/vendor/libsodium/test/default/sodium_utils2.c

@@ -3,15 +3,11 @@
 
 #include <limits.h>
 #include <signal.h>
-#include <string.h>
-#include <stdio.h>
-#include <string.h>
 
 #define TEST_NAME "sodium_utils2"
 #include "cmptest.h"
 
-static void
-segv_handler(int sig)
+static void segv_handler(int sig)
 {
     printf("Intentional segfault / bus error caught\n");
     printf("OK\n");
@@ -27,16 +23,22 @@ segv_handler(int sig)
     exit(0);
 }
 
-int
-main(void)
+int main(void)
 {
-    void         *buf;
-    size_t        size;
-    unsigned int  i;
+    void *buf;
+    size_t size;
+    unsigned int i;
 
+    if (sodium_malloc(SIZE_MAX - 1U) != NULL) {
+        return 1;
+    }
     if (sodium_allocarray(SIZE_MAX / 2U + 1U, SIZE_MAX / 2U) != NULL) {
         return 1;
     }
+    buf = sodium_allocarray(1000U, 50U);
+    memset(buf, 0, 50000U);
+    sodium_free(buf);
+
     sodium_free(sodium_malloc(0U));
     sodium_free(NULL);
     for (i = 0U; i < 10000U; i++) {
@@ -61,7 +63,7 @@ main(void)
     buf = sodium_malloc(size);
     sodium_mprotect_readonly(buf);
     sodium_mprotect_readwrite(buf);
-    sodium_memzero(((unsigned char *) buf) + size, 1U);
+    sodium_memzero(((unsigned char *)buf) + size, 1U);
     sodium_mprotect_noaccess(buf);
     sodium_free(buf);
     printf("Overflow not caught\n");

data/vendor/libsodium/test/default/sodium_utils3.c

@@ -3,15 +3,11 @@
 
 #include <limits.h>
 #include <signal.h>
-#include <string.h>
-#include <stdio.h>
-#include <string.h>
 
 #define TEST_NAME "sodium_utils3"
 #include "cmptest.h"
 
-static void
-segv_handler(int sig)
+static void segv_handler(int sig)
 {
     printf("Intentional segfault / bus error caught\n");
     printf("OK\n");
@@ -27,11 +23,10 @@ segv_handler(int sig)
     exit(0);
 }
 
-int
-main(void)
+int main(void)
 {
-    void   *buf;
-    size_t  size;
+    void *buf;
+    size_t size;
 
 #ifdef SIGSEGV
     signal(SIGSEGV, segv_handler);
@@ -46,7 +41,7 @@ main(void)
     buf = sodium_malloc(size);
     sodium_mprotect_noaccess(buf);
     sodium_mprotect_readwrite(buf);
-    sodium_memzero(((unsigned char *) buf) - 8, 8U);
+    sodium_memzero(((unsigned char *)buf) - 8, 8U);
     sodium_mprotect_readonly(buf);
     sodium_free(buf);
     printf("Underflow not caught\n");

data/vendor/libsodium/test/default/sodium_version.c

@@ -1,13 +1,12 @@
-#include <stdio.h>
 
 #define TEST_NAME "sodium_version"
 #include "cmptest.h"
 
 int main(void)
 {
-  printf ("%d\n", sodium_version_string() != NULL);
-  printf ("%d\n", sodium_library_version_major() > 0);
-  printf ("%d\n", sodium_library_version_minor() >= 0);
+    printf("%d\n", sodium_version_string() != NULL);
+    printf("%d\n", sodium_library_version_major() > 0);
+    printf("%d\n", sodium_library_version_minor() >= 0);
 
-  return 0;
+    return 0;
 }

data/vendor/libsodium/test/default/stream.c

@@ -1,20 +1,15 @@
-#include <stdio.h>
 
 #define TEST_NAME "stream"
 #include "cmptest.h"
 
-unsigned char firstkey[32] = {
- 0x1b,0x27,0x55,0x64,0x73,0xe9,0x85,0xd4
-,0x62,0xcd,0x51,0x19,0x7a,0x9a,0x46,0xc7
-,0x60,0x09,0x54,0x9e,0xac,0x64,0x74,0xf2
-,0x06,0xc4,0xee,0x08,0x44,0xf6,0x83,0x89
-} ;
+unsigned char firstkey[32]
+    = { 0x1b, 0x27, 0x55, 0x64, 0x73, 0xe9, 0x85, 0xd4, 0x62, 0xcd, 0x51,
+        0x19, 0x7a, 0x9a, 0x46, 0xc7, 0x60, 0x09, 0x54, 0x9e, 0xac, 0x64,
+        0x74, 0xf2, 0x06, 0xc4, 0xee, 0x08, 0x44, 0xf6, 0x83, 0x89 };
 
-unsigned char nonce[24] = {
- 0x69,0x69,0x6e,0xe9,0x55,0xb6,0x2b,0x73
-,0xcd,0x62,0xbd,0xa8,0x75,0xfc,0x73,0xd6
-,0x82,0x19,0xe0,0x03,0x6b,0x7a,0x0b,0x37
-} ;
+unsigned char nonce[24] = { 0x69, 0x69, 0x6e, 0xe9, 0x55, 0xb6, 0x2b, 0x73,
+                            0xcd, 0x62, 0xbd, 0xa8, 0x75, 0xfc, 0x73, 0xd6,
+                            0x82, 0x19, 0xe0, 0x03, 0x6b, 0x7a, 0x0b, 0x37 };
 
 unsigned char output[4194304];
 
@@ -22,9 +17,20 @@ unsigned char h[32];
 
 int main(void)
 {
-  int i;
-  crypto_stream_xsalsa20(output,4194304,nonce,firstkey);
-  crypto_hash_sha256(h,output,sizeof output);
-  for (i = 0;i < 32;++i) printf("%02x",h[i]); printf("\n");
-  return 0;
+    int i;
+
+    crypto_stream(output, 4194304, nonce, firstkey);
+    crypto_hash_sha256(h, output, sizeof output);
+
+    for (i = 0; i < 32; ++i)
+        printf("%02x", h[i]);
+    printf("\n");
+
+    assert(crypto_stream_keybytes() > 0U);
+    assert(crypto_stream_noncebytes() > 0U);
+    assert(strcmp(crypto_stream_primitive(), "xsalsa20") == 0);
+    assert(crypto_stream_keybytes() == crypto_stream_xsalsa20_keybytes());
+    assert(crypto_stream_noncebytes() == crypto_stream_xsalsa20_noncebytes());
+
+    return 0;
 }