QPQ-AG/libsodium
12
0
Fork 0
mirror of https://github.com/jedisct1/libsodium.git synced 2026-08-25 08:37:13 +09:00
Code Issues Packages Projects Releases Wiki Activity

Consistent syle for the tests.

Browse Source
This commit is contained in:
Frank Denis
2014-09-14 11:32:55 -07:00
parent 0e559b94d5
commit 82bc039d6c
54 changed files with 947 additions and 980 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/default/aead_chacha20poly1305.c
+29 -37
View File
@@ -2,33 +2,28 @@
#define TEST_NAME "aead_chacha20poly1305"
#include "cmptest.h"
static unsigned char firstkey[crypto_aead_chacha20poly1305_KEYBYTES] = {
0x42, 0x90, 0xbc, 0xb1, 0x54, 0x17, 0x35, 0x31,
0xf3, 0x14, 0xaf, 0x57, 0xf3, 0xbe, 0x3b, 0x50,
0x06, 0xda, 0x37, 0x1e, 0xce, 0x27, 0x2a, 0xfa,
0x1b, 0x5d, 0xbd, 0xd1, 0x10, 0x0a, 0x10, 0x07
};
static unsigned char firstkey[crypto_aead_chacha20poly1305_KEYBYTES]
= { 0x42, 0x90, 0xbc, 0xb1, 0x54, 0x17, 0x35, 0x31, 0xf3, 0x14, 0xaf,
0x57, 0xf3, 0xbe, 0x3b, 0x50, 0x06, 0xda, 0x37, 0x1e, 0xce, 0x27,
0x2a, 0xfa, 0x1b, 0x5d, 0xbd, 0xd1, 0x10, 0x0a, 0x10, 0x07 };
static unsigned char m[10U] = {
0x86, 0xd0, 0x99, 0x74, 0x84, 0x0b, 0xde, 0xd2, 0xa5, 0xca
};
static unsigned char m[10U]
= { 0x86, 0xd0, 0x99, 0x74, 0x84, 0x0b, 0xde, 0xd2, 0xa5, 0xca };
static unsigned char nonce[crypto_aead_chacha20poly1305_NPUBBYTES] = {
0xcd, 0x7c, 0xf6, 0x7b, 0xe3, 0x9c, 0x79, 0x4a
};
static unsigned char nonce[crypto_aead_chacha20poly1305_NPUBBYTES]
= { 0xcd, 0x7c, 0xf6, 0x7b, 0xe3, 0x9c, 0x79, 0x4a };
static unsigned char ad[10U] = {
0x87, 0xe2, 0x29, 0xd4, 0x50, 0x08, 0x45, 0xa0, 0x79, 0xc0
};
static unsigned char ad[10U]
= { 0x87, 0xe2, 0x29, 0xd4, 0x50, 0x08, 0x45, 0xa0, 0x79, 0xc0 };
static unsigned char c[10U + crypto_aead_chacha20poly1305_ABYTES];
int main(void)
{
unsigned char m2[10U];
unsigned char m2[10U];
unsigned long long clen;
unsigned long long m2len;
size_t i;
size_t i;
crypto_aead_chacha20poly1305_encrypt(c, &clen, m, sizeof m, ad, sizeof ad,
NULL, nonce, firstkey);
@@ -36,16 +31,15 @@ int main(void)
printf("clen is not properly set\n");
}
for (i = 0U; i < sizeof c; ++i) {
printf(",0x%02x", (unsigned int) c[i]);
printf(",0x%02x", (unsigned int)c[i]);
if (i % 8 == 7) {
printf("\n");
}
}
printf("\n");
if (crypto_aead_chacha20poly1305_decrypt(m2, &m2len, NULL, c, sizeof c,
ad, sizeof ad,
nonce, firstkey) != 0) {
if (crypto_aead_chacha20poly1305_decrypt(m2, &m2len, NULL, c, sizeof c, ad,
sizeof ad, nonce, firstkey) != 0) {
printf("crypto_aead_chacha20poly1305_decrypt() failed\n");
}
if (m2len != sizeof c - crypto_aead_chacha20poly1305_abytes()) {
@@ -58,21 +52,20 @@ int main(void)
for (i = 0U; i < sizeof c; i++) {
c[i] ^= (i + 1U);
if (crypto_aead_chacha20poly1305_decrypt(m2, NULL, NULL, c, sizeof c,
ad, sizeof ad,
nonce, firstkey) == 0 ||
memcmp(m, m2, sizeof m) == 0) {
ad, sizeof ad, nonce, firstkey)
== 0 || memcmp(m, m2, sizeof m) == 0) {
printf("message can be forged\n");
}
c[i] ^= (i + 1U);
}
crypto_aead_chacha20poly1305_encrypt(c, &clen, m, sizeof m, NULL, 0U,
NULL, nonce, firstkey);
crypto_aead_chacha20poly1305_encrypt(c, &clen, m, sizeof m, NULL, 0U, NULL,
nonce, firstkey);
if (clen != sizeof m + crypto_aead_chacha20poly1305_abytes()) {
printf("clen is not properly set (adlen=0)\n");
}
for (i = 0U; i < sizeof c; ++i) {
printf(",0x%02x", (unsigned int) c[i]);
printf(",0x%02x", (unsigned int)c[i]);
if (i % 8 == 7) {
printf("\n");
}
@@ -80,8 +73,7 @@ int main(void)
printf("\n");
if (crypto_aead_chacha20poly1305_decrypt(m2, &m2len, NULL, c, sizeof c,
NULL, 0U,
nonce, firstkey) != 0) {
NULL, 0U, nonce, firstkey) != 0) {
printf("crypto_aead_chacha20poly1305_decrypt() failed (adlen=0)\n");
}
if (m2len != sizeof c - crypto_aead_chacha20poly1305_abytes()) {
@@ -91,16 +83,16 @@ int main(void)
printf("m != m2 (adlen=0)\n");
}
if (crypto_aead_chacha20poly1305_decrypt(m2, &m2len, NULL, c,
crypto_aead_chacha20poly1305_ABYTES / 2,
NULL, 0U,
nonce, firstkey) != -1) {
printf("crypto_aead_chacha20poly1305_decrypt() worked with a short ciphertext\n");
if (crypto_aead_chacha20poly1305_decrypt(
m2, &m2len, NULL, c, crypto_aead_chacha20poly1305_ABYTES / 2, NULL,
0U, nonce, firstkey) != -1) {
printf("crypto_aead_chacha20poly1305_decrypt() worked with a short "
"ciphertext\n");
}
if (crypto_aead_chacha20poly1305_decrypt(m2, &m2len, NULL, c, 0U,
NULL, 0U,
if (crypto_aead_chacha20poly1305_decrypt(m2, &m2len, NULL, c, 0U, NULL, 0U,
nonce, firstkey) != -1) {
printf("crypto_aead_chacha20poly1305_decrypt() worked with an empty ciphertext\n");
printf("crypto_aead_chacha20poly1305_decrypt() worked with an empty "
"ciphertext\n");
}
assert(crypto_aead_chacha20poly1305_keybytes() > 0U);
test/default/auth.c
+5 -4
View File
@@ -12,10 +12,11 @@ int main(void)
{
int i;
crypto_auth(a,c,sizeof c - 1U,key);
for (i = 0;i < 32;++i) {
printf(",0x%02x",(unsigned int) a[i]);
if (i % 8 == 7) printf("\n");
crypto_auth(a, c, sizeof c - 1U, key);
for (i = 0; i < 32; ++i) {
printf(",0x%02x", (unsigned int)a[i]);
if (i % 8 == 7)
printf("\n");
}
assert(crypto_auth_bytes() > 0U);
test/default/auth2.c
+15 -19
View File
@@ -3,22 +3,17 @@
#define TEST_NAME "auth2"
#include "cmptest.h"
unsigned char key[32] = {
0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08
,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10
,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18
,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,0x20
} ;
unsigned char key[32]
= { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16,
0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20 };
unsigned char c[50] = {
0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd
,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd
,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd
,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd
,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd
,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd
,0xcd,0xcd
} ;
unsigned char c[50]
= { 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd };
unsigned char a[32];
@@ -26,10 +21,11 @@ int main(void)
{
int i;
crypto_auth_hmacsha256(a,c,sizeof c,key);
for (i = 0;i < 32;++i) {
printf(",0x%02x",(unsigned int) a[i]);
if (i % 8 == 7) printf("\n");
crypto_auth_hmacsha256(a, c, sizeof c, key);
for (i = 0; i < 32; ++i) {
printf(",0x%02x", (unsigned int)a[i]);
if (i % 8 == 7)
printf("\n");
}
return 0;
}
test/default/auth3.c
+15 -22
View File
@@ -3,33 +3,26 @@
#define TEST_NAME "auth3"
#include "cmptest.h"
unsigned char key[32] = {
0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08
,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10
,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18
,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,0x20
} ;
unsigned char key[32]
= { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16,
0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20 };
unsigned char c[50] = {
0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd
,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd
,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd
,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd
,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd
,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd,0xcd
,0xcd,0xcd
} ;
unsigned char c[50]
= { 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd };
unsigned char a[32] = {
0x37,0x2e,0xfc,0xf9,0xb4,0x0b,0x35,0xc2
,0x11,0x5b,0x13,0x46,0x90,0x3d,0x2e,0xf4
,0x2f,0xce,0xd4,0x6f,0x08,0x46,0xe7,0x25
,0x7b,0xb1,0x56,0xd3,0xd7,0xb3,0x0d,0x3f
} ;
unsigned char a[32]
= { 0x37, 0x2e, 0xfc, 0xf9, 0xb4, 0x0b, 0x35, 0xc2, 0x11, 0x5b, 0x13,
0x46, 0x90, 0x3d, 0x2e, 0xf4, 0x2f, 0xce, 0xd4, 0x6f, 0x08, 0x46,
0xe7, 0x25, 0x7b, 0xb1, 0x56, 0xd3, 0xd7, 0xb3, 0x0d, 0x3f };
int main(void)
{
printf("%d\n",crypto_auth_hmacsha256_verify(a,c,sizeof c,key));
printf("%d\n", crypto_auth_hmacsha256_verify(a, c, sizeof c, key));
return 0;
}
test/default/auth5.c
+11 -11
View File
@@ -10,25 +10,25 @@ unsigned char a[32];
int main(void)
{
int clen;
size_t clen;
for (clen = 0;clen < 10000;++clen) {
randombytes(key,sizeof key);
randombytes(c,clen);
crypto_auth(a,c,clen,key);
if (crypto_auth_verify(a,c,clen,key) != 0) {
printf("fail %d\n",clen);
for (clen = 0; clen < 10000; ++clen) {
randombytes_buf(key, sizeof key);
randombytes_buf(c, clen);
crypto_auth(a, c, clen, key);
if (crypto_auth_verify(a, c, clen, key) != 0) {
printf("fail %d\n", clen);
return 100;
}
if (clen > 0) {
c[rand() % clen] += 1 + (rand() % 255);
if (crypto_auth_verify(a,c,clen,key) == 0) {
printf("forgery %d\n",clen);
if (crypto_auth_verify(a, c, clen, key) == 0) {
printf("forgery %d\n", clen);
return 100;
}
a[rand() % sizeof a] += 1 + (rand() % 255);
if (crypto_auth_verify(a,c,clen,key) == 0) {
printf("forgery %d\n",clen);
if (crypto_auth_verify(a, c, clen, key) == 0) {
printf("forgery %d\n", clen);
return 100;
}
}
test/default/auth6.c
+5 -4
View File
@@ -12,10 +12,11 @@ int main(void)
{
int i;
crypto_auth_hmacsha512(a,c,sizeof c - 1U,key);
for (i = 0;i < 64;++i) {
printf(",0x%02x",(unsigned int) a[i]);
if (i % 8 == 7) printf("\n");
crypto_auth_hmacsha512(a, c, sizeof c - 1U, key);
for (i = 0; i < 64; ++i) {
printf(",0x%02x", (unsigned int)a[i]);
if (i % 8 == 7)
printf("\n");
}
return 0;
}
test/default/auth7.c
+10 -10
View File
@@ -12,23 +12,23 @@ int main(void)
{
int clen;
for (clen = 0;clen < 10000;++clen) {
randombytes(key,sizeof key);
randombytes(c,clen);
crypto_auth_hmacsha512(a,c,clen,key);
if (crypto_auth_hmacsha512_verify(a,c,clen,key) != 0) {
printf("fail %d\n",clen);
for (clen = 0; clen < 10000; ++clen) {
randombytes_buf(key, sizeof key);
randombytes_buf(c, clen);
crypto_auth_hmacsha512(a, c, clen, key);
if (crypto_auth_hmacsha512_verify(a, c, clen, key) != 0) {
printf("fail %d\n", clen);
return 100;
}
if (clen > 0) {
c[rand() % clen] += 1 + (rand() % 255);
if (crypto_auth_hmacsha512_verify(a,c,clen,key) == 0) {
printf("forgery %d\n",clen);
if (crypto_auth_hmacsha512_verify(a, c, clen, key) == 0) {
printf("forgery %d\n", clen);
return 100;
}
a[rand() % sizeof a] += 1 + (rand() % 255);
if (crypto_auth_hmacsha512_verify(a,c,clen,key) == 0) {
printf("forgery %d\n",clen);
if (crypto_auth_hmacsha512_verify(a, c, clen, key) == 0) {
printf("forgery %d\n", clen);
return 100;
}
}
test/default/box.c
+47 -52
View File
@@ -2,50 +2,36 @@
#define TEST_NAME "box"
#include "cmptest.h"
unsigned char alicesk[32] = {
0x77,0x07,0x6d,0x0a,0x73,0x18,0xa5,0x7d
,0x3c,0x16,0xc1,0x72,0x51,0xb2,0x66,0x45
,0xdf,0x4c,0x2f,0x87,0xeb,0xc0,0x99,0x2a
,0xb1,0x77,0xfb,0xa5,0x1d,0xb9,0x2c,0x2a
} ;
unsigned char alicesk[32]
= { 0x77, 0x07, 0x6d, 0x0a, 0x73, 0x18, 0xa5, 0x7d, 0x3c, 0x16, 0xc1,
0x72, 0x51, 0xb2, 0x66, 0x45, 0xdf, 0x4c, 0x2f, 0x87, 0xeb, 0xc0,
0x99, 0x2a, 0xb1, 0x77, 0xfb, 0xa5, 0x1d, 0xb9, 0x2c, 0x2a };
unsigned char bobpk[32] = {
0xde,0x9e,0xdb,0x7d,0x7b,0x7d,0xc1,0xb4
,0xd3,0x5b,0x61,0xc2,0xec,0xe4,0x35,0x37
,0x3f,0x83,0x43,0xc8,0x5b,0x78,0x67,0x4d
,0xad,0xfc,0x7e,0x14,0x6f,0x88,0x2b,0x4f
} ;
unsigned char bobpk[32]
= { 0xde, 0x9e, 0xdb, 0x7d, 0x7b, 0x7d, 0xc1, 0xb4, 0xd3, 0x5b, 0x61,
0xc2, 0xec, 0xe4, 0x35, 0x37, 0x3f, 0x83, 0x43, 0xc8, 0x5b, 0x78,
0x67, 0x4d, 0xad, 0xfc, 0x7e, 0x14, 0x6f, 0x88, 0x2b, 0x4f };
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 };
// API requires first 32 bytes to be 0
unsigned char m[163] = {
0, 0, 0, 0, 0, 0, 0, 0
, 0, 0, 0, 0, 0, 0, 0, 0
, 0, 0, 0, 0, 0, 0, 0, 0
, 0, 0, 0, 0, 0, 0, 0, 0
,0xbe,0x07,0x5f,0xc5,0x3c,0x81,0xf2,0xd5
,0xcf,0x14,0x13,0x16,0xeb,0xeb,0x0c,0x7b
,0x52,0x28,0xc5,0x2a,0x4c,0x62,0xcb,0xd4
,0x4b,0x66,0x84,0x9b,0x64,0x24,0x4f,0xfc
,0xe5,0xec,0xba,0xaf,0x33,0xbd,0x75,0x1a
,0x1a,0xc7,0x28,0xd4,0x5e,0x6c,0x61,0x29
,0x6c,0xdc,0x3c,0x01,0x23,0x35,0x61,0xf4
,0x1d,0xb6,0x6c,0xce,0x31,0x4a,0xdb,0x31
,0x0e,0x3b,0xe8,0x25,0x0c,0x46,0xf0,0x6d
,0xce,0xea,0x3a,0x7f,0xa1,0x34,0x80,0x57
,0xe2,0xf6,0x55,0x6a,0xd6,0xb1,0x31,0x8a
,0x02,0x4a,0x83,0x8f,0x21,0xaf,0x1f,0xde
,0x04,0x89,0x77,0xeb,0x48,0xf5,0x9f,0xfd
,0x49,0x24,0xca,0x1c,0x60,0x90,0x2e,0x52
,0xf0,0xa0,0x89,0xbc,0x76,0x89,0x70,0x40
,0xe0,0x82,0xf9,0x37,0x76,0x38,0x48,0x64
,0x5e,0x07,0x05
} ;
unsigned char m[163]
= { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0xbe, 0x07, 0x5f, 0xc5,
0x3c, 0x81, 0xf2, 0xd5, 0xcf, 0x14, 0x13, 0x16, 0xeb, 0xeb, 0x0c, 0x7b,
0x52, 0x28, 0xc5, 0x2a, 0x4c, 0x62, 0xcb, 0xd4, 0x4b, 0x66, 0x84, 0x9b,
0x64, 0x24, 0x4f, 0xfc, 0xe5, 0xec, 0xba, 0xaf, 0x33, 0xbd, 0x75, 0x1a,
0x1a, 0xc7, 0x28, 0xd4, 0x5e, 0x6c, 0x61, 0x29, 0x6c, 0xdc, 0x3c, 0x01,
0x23, 0x35, 0x61, 0xf4, 0x1d, 0xb6, 0x6c, 0xce, 0x31, 0x4a, 0xdb, 0x31,
0x0e, 0x3b, 0xe8, 0x25, 0x0c, 0x46, 0xf0, 0x6d, 0xce, 0xea, 0x3a, 0x7f,
0xa1, 0x34, 0x80, 0x57, 0xe2, 0xf6, 0x55, 0x6a, 0xd6, 0xb1, 0x31, 0x8a,
0x02, 0x4a, 0x83, 0x8f, 0x21, 0xaf, 0x1f, 0xde, 0x04, 0x89, 0x77, 0xeb,
0x48, 0xf5, 0x9f, 0xfd, 0x49, 0x24, 0xca, 0x1c, 0x60, 0x90, 0x2e, 0x52,
0xf0, 0xa0, 0x89, 0xbc, 0x76, 0x89, 0x70, 0x40, 0xe0, 0x82, 0xf9, 0x37,
0x76, 0x38, 0x48, 0x64, 0x5e, 0x07, 0x05 };
unsigned char c[163];
@@ -53,10 +39,11 @@ int main(void)
{
int i;
crypto_box(c,m,163,nonce,bobpk,alicesk);
for (i = 16;i < 163;++i) {
printf(",0x%02x",(unsigned int) c[i]);
if (i % 8 == 7) printf("\n");
crypto_box(c, m, 163, nonce, bobpk, alicesk);
for (i = 16; i < 163; ++i) {
printf(",0x%02x", (unsigned int)c[i]);
if (i % 8 == 7)
printf("\n");
}
printf("\n");
@@ -69,14 +56,22 @@ int main(void)
assert(crypto_box_boxzerobytes() > 0U);
assert(crypto_box_macbytes() > 0U);
assert(strcmp(crypto_box_primitive(), "curve25519xsalsa20poly1305") == 0);
assert(crypto_box_curve25519xsalsa20poly1305_seedbytes() == crypto_box_seedbytes());
assert(crypto_box_curve25519xsalsa20poly1305_publickeybytes() == crypto_box_publickeybytes());
assert(crypto_box_curve25519xsalsa20poly1305_secretkeybytes() == crypto_box_secretkeybytes());
assert(crypto_box_curve25519xsalsa20poly1305_beforenmbytes() == crypto_box_beforenmbytes());
assert(crypto_box_curve25519xsalsa20poly1305_noncebytes() == crypto_box_noncebytes());
assert(crypto_box_curve25519xsalsa20poly1305_zerobytes() == crypto_box_zerobytes());
assert(crypto_box_curve25519xsalsa20poly1305_boxzerobytes() == crypto_box_boxzerobytes());
assert(crypto_box_curve25519xsalsa20poly1305_macbytes() == crypto_box_macbytes());
assert(crypto_box_curve25519xsalsa20poly1305_seedbytes()
== crypto_box_seedbytes());
assert(crypto_box_curve25519xsalsa20poly1305_publickeybytes()
== crypto_box_publickeybytes());
assert(crypto_box_curve25519xsalsa20poly1305_secretkeybytes()
== crypto_box_secretkeybytes());
assert(crypto_box_curve25519xsalsa20poly1305_beforenmbytes()
== crypto_box_beforenmbytes());
assert(crypto_box_curve25519xsalsa20poly1305_noncebytes()
== crypto_box_noncebytes());
assert(crypto_box_curve25519xsalsa20poly1305_zerobytes()
== crypto_box_zerobytes());
assert(crypto_box_curve25519xsalsa20poly1305_boxzerobytes()
== crypto_box_boxzerobytes());
assert(crypto_box_curve25519xsalsa20poly1305_macbytes()
== crypto_box_macbytes());
return 0;
}
test/default/box2.c
+31 -44
View File
@@ -2,50 +2,36 @@
#define TEST_NAME "box2"
#include "cmptest.h"
unsigned char bobsk[32] = {
0x5d,0xab,0x08,0x7e,0x62,0x4a,0x8a,0x4b
,0x79,0xe1,0x7f,0x8b,0x83,0x80,0x0e,0xe6
,0x6f,0x3b,0xb1,0x29,0x26,0x18,0xb6,0xfd
,0x1c,0x2f,0x8b,0x27,0xff,0x88,0xe0,0xeb
} ;
unsigned char bobsk[32]
= { 0x5d, 0xab, 0x08, 0x7e, 0x62, 0x4a, 0x8a, 0x4b, 0x79, 0xe1, 0x7f,
0x8b, 0x83, 0x80, 0x0e, 0xe6, 0x6f, 0x3b, 0xb1, 0x29, 0x26, 0x18,
0xb6, 0xfd, 0x1c, 0x2f, 0x8b, 0x27, 0xff, 0x88, 0xe0, 0xeb };
unsigned char alicepk[32] = {
0x85,0x20,0xf0,0x09,0x89,0x30,0xa7,0x54
,0x74,0x8b,0x7d,0xdc,0xb4,0x3e,0xf7,0x5a
,0x0d,0xbf,0x3a,0x0d,0x26,0x38,0x1a,0xf4
,0xeb,0xa4,0xa9,0x8e,0xaa,0x9b,0x4e,0x6a
} ;
unsigned char alicepk[32]
= { 0x85, 0x20, 0xf0, 0x09, 0x89, 0x30, 0xa7, 0x54, 0x74, 0x8b, 0x7d,
0xdc, 0xb4, 0x3e, 0xf7, 0x5a, 0x0d, 0xbf, 0x3a, 0x0d, 0x26, 0x38,
0x1a, 0xf4, 0xeb, 0xa4, 0xa9, 0x8e, 0xaa, 0x9b, 0x4e, 0x6a };
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 };
// API requires first 16 bytes to be 0
unsigned char c[163] = {
0, 0, 0, 0, 0, 0, 0, 0
, 0, 0, 0, 0, 0, 0, 0, 0
,0xf3,0xff,0xc7,0x70,0x3f,0x94,0x00,0xe5
,0x2a,0x7d,0xfb,0x4b,0x3d,0x33,0x05,0xd9
,0x8e,0x99,0x3b,0x9f,0x48,0x68,0x12,0x73
,0xc2,0x96,0x50,0xba,0x32,0xfc,0x76,0xce
,0x48,0x33,0x2e,0xa7,0x16,0x4d,0x96,0xa4
,0x47,0x6f,0xb8,0xc5,0x31,0xa1,0x18,0x6a
,0xc0,0xdf,0xc1,0x7c,0x98,0xdc,0xe8,0x7b
,0x4d,0xa7,0xf0,0x11,0xec,0x48,0xc9,0x72
,0x71,0xd2,0xc2,0x0f,0x9b,0x92,0x8f,0xe2
,0x27,0x0d,0x6f,0xb8,0x63,0xd5,0x17,0x38
,0xb4,0x8e,0xee,0xe3,0x14,0xa7,0xcc,0x8a
,0xb9,0x32,0x16,0x45,0x48,0xe5,0x26,0xae
,0x90,0x22,0x43,0x68,0x51,0x7a,0xcf,0xea
,0xbd,0x6b,0xb3,0x73,0x2b,0xc0,0xe9,0xda
,0x99,0x83,0x2b,0x61,0xca,0x01,0xb6,0xde
,0x56,0x24,0x4a,0x9e,0x88,0xd5,0xf9,0xb3
,0x79,0x73,0xf6,0x22,0xa4,0x3d,0x14,0xa6
,0x59,0x9b,0x1f,0x65,0x4c,0xb4,0x5a,0x74
,0xe3,0x55,0xa5
} ;
unsigned char c[163]
= { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0xf3, 0xff, 0xc7, 0x70, 0x3f, 0x94, 0x00, 0xe5,
0x2a, 0x7d, 0xfb, 0x4b, 0x3d, 0x33, 0x05, 0xd9, 0x8e, 0x99, 0x3b, 0x9f,
0x48, 0x68, 0x12, 0x73, 0xc2, 0x96, 0x50, 0xba, 0x32, 0xfc, 0x76, 0xce,
0x48, 0x33, 0x2e, 0xa7, 0x16, 0x4d, 0x96, 0xa4, 0x47, 0x6f, 0xb8, 0xc5,
0x31, 0xa1, 0x18, 0x6a, 0xc0, 0xdf, 0xc1, 0x7c, 0x98, 0xdc, 0xe8, 0x7b,
0x4d, 0xa7, 0xf0, 0x11, 0xec, 0x48, 0xc9, 0x72, 0x71, 0xd2, 0xc2, 0x0f,
0x9b, 0x92, 0x8f, 0xe2, 0x27, 0x0d, 0x6f, 0xb8, 0x63, 0xd5, 0x17, 0x38,
0xb4, 0x8e, 0xee, 0xe3, 0x14, 0xa7, 0xcc, 0x8a, 0xb9, 0x32, 0x16, 0x45,
0x48, 0xe5, 0x26, 0xae, 0x90, 0x22, 0x43, 0x68, 0x51, 0x7a, 0xcf, 0xea,
0xbd, 0x6b, 0xb3, 0x73, 0x2b, 0xc0, 0xe9, 0xda, 0x99, 0x83, 0x2b, 0x61,
0xca, 0x01, 0xb6, 0xde, 0x56, 0x24, 0x4a, 0x9e, 0x88, 0xd5, 0xf9, 0xb3,
0x79, 0x73, 0xf6, 0x22, 0xa4, 0x3d, 0x14, 0xa6, 0x59, 0x9b, 0x1f, 0x65,
0x4c, 0xb4, 0x5a, 0x74, 0xe3, 0x55, 0xa5 };
unsigned char m[163];
@@ -53,10 +39,11 @@ int main(void)
{
int i;
if (crypto_box_open(m,c,163,nonce,alicepk,bobsk) == 0) {
for (i = 32;i < 163;++i) {
printf(",0x%02x",(unsigned int) m[i]);
if (i % 8 == 7) printf("\n");
if (crypto_box_open(m, c, 163, nonce, alicepk, bobsk) == 0) {
for (i = 32; i < 163; ++i) {
printf(",0x%02x", (unsigned int)m[i]);
if (i % 8 == 7)
printf("\n");
}
printf("\n");
}
test/default/box7.c
+10 -8
View File
@@ -16,14 +16,16 @@ int main(void)
size_t mlen;
size_t i;
for (mlen = 0;mlen < 1000 && mlen + crypto_box_ZEROBYTES < sizeof m;++mlen) {
crypto_box_keypair(alicepk,alicesk);
crypto_box_keypair(bobpk,bobsk);
randombytes(n,crypto_box_NONCEBYTES);
randombytes(m + crypto_box_ZEROBYTES,mlen);
crypto_box(c,m,mlen + crypto_box_ZEROBYTES,n,bobpk,alicesk);
if (crypto_box_open(m2,c,mlen + crypto_box_ZEROBYTES,n,alicepk,bobsk) == 0) {
for (i = 0;i < mlen + crypto_box_ZEROBYTES;++i) {
for (mlen = 0; mlen < 1000 && mlen + crypto_box_ZEROBYTES < sizeof m;
++mlen) {
crypto_box_keypair(alicepk, alicesk);
crypto_box_keypair(bobpk, bobsk);
randombytes_buf(n, crypto_box_NONCEBYTES);
randombytes_buf(m + crypto_box_ZEROBYTES, mlen);
crypto_box(c, m, mlen + crypto_box_ZEROBYTES, n, bobpk, alicesk);
if (crypto_box_open(m2, c, mlen + crypto_box_ZEROBYTES, n, alicepk,
bobsk) == 0) {
for (i = 0; i < mlen + crypto_box_ZEROBYTES; ++i) {
if (m2[i] != m[i]) {
printf("bad decryption\n");
break;
test/default/box8.c
+10 -8
View File
@@ -19,17 +19,19 @@ int main(void)
size_t i;
int caught;
for (mlen = 0;mlen < 1000 && mlen + crypto_box_ZEROBYTES < sizeof m;++mlen) {
crypto_box_keypair(alicepk,alicesk);
crypto_box_keypair(bobpk,bobsk);
randombytes(n,crypto_box_NONCEBYTES);
randombytes(m + crypto_box_ZEROBYTES,mlen);
crypto_box(c,m,mlen + crypto_box_ZEROBYTES,n,bobpk,alicesk);
for (mlen = 0; mlen < 1000 && mlen + crypto_box_ZEROBYTES < sizeof m;
++mlen) {
crypto_box_keypair(alicepk, alicesk);
crypto_box_keypair(bobpk, bobsk);
randombytes_buf(n, crypto_box_NONCEBYTES);
randombytes_buf(m + crypto_box_ZEROBYTES, mlen);
crypto_box(c, m, mlen + crypto_box_ZEROBYTES, n, bobpk, alicesk);
caught = 0;
while (caught < 10) {
c[rand() % (mlen + crypto_box_ZEROBYTES)] = rand();
if (crypto_box_open(m2,c,mlen + crypto_box_ZEROBYTES,n,alicepk,bobsk) == 0) {
for (i = 0;i < mlen + crypto_box_ZEROBYTES;++i) {
if (crypto_box_open(m2, c, mlen + crypto_box_ZEROBYTES, n, alicepk,
bobsk) == 0) {
for (i = 0; i < mlen + crypto_box_ZEROBYTES; ++i) {
if (m2[i] != m[i]) {
printf("forgery\n");
return 100;
test/default/box_easy.c
+26 -38
View File
@@ -2,45 +2,32 @@
#define TEST_NAME "box_easy"
#include "cmptest.h"
unsigned char alicesk[32] = {
0x77,0x07,0x6d,0x0a,0x73,0x18,0xa5,0x7d
,0x3c,0x16,0xc1,0x72,0x51,0xb2,0x66,0x45
,0xdf,0x4c,0x2f,0x87,0xeb,0xc0,0x99,0x2a
,0xb1,0x77,0xfb,0xa5,0x1d,0xb9,0x2c,0x2a
} ;
unsigned char alicesk[32]
= { 0x77, 0x07, 0x6d, 0x0a, 0x73, 0x18, 0xa5, 0x7d, 0x3c, 0x16, 0xc1,
0x72, 0x51, 0xb2, 0x66, 0x45, 0xdf, 0x4c, 0x2f, 0x87, 0xeb, 0xc0,
0x99, 0x2a, 0xb1, 0x77, 0xfb, 0xa5, 0x1d, 0xb9, 0x2c, 0x2a };
unsigned char bobpk[32] = {
0xde,0x9e,0xdb,0x7d,0x7b,0x7d,0xc1,0xb4
,0xd3,0x5b,0x61,0xc2,0xec,0xe4,0x35,0x37
,0x3f,0x83,0x43,0xc8,0x5b,0x78,0x67,0x4d
,0xad,0xfc,0x7e,0x14,0x6f,0x88,0x2b,0x4f
} ;
unsigned char bobpk[32]
= { 0xde, 0x9e, 0xdb, 0x7d, 0x7b, 0x7d, 0xc1, 0xb4, 0xd3, 0x5b, 0x61,
0xc2, 0xec, 0xe4, 0x35, 0x37, 0x3f, 0x83, 0x43, 0xc8, 0x5b, 0x78,
0x67, 0x4d, 0xad, 0xfc, 0x7e, 0x14, 0x6f, 0x88, 0x2b, 0x4f };
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 m[131] = {
0xbe,0x07,0x5f,0xc5,0x3c,0x81,0xf2,0xd5
,0xcf,0x14,0x13,0x16,0xeb,0xeb,0x0c,0x7b
,0x52,0x28,0xc5,0x2a,0x4c,0x62,0xcb,0xd4
,0x4b,0x66,0x84,0x9b,0x64,0x24,0x4f,0xfc
,0xe5,0xec,0xba,0xaf,0x33,0xbd,0x75,0x1a
,0x1a,0xc7,0x28,0xd4,0x5e,0x6c,0x61,0x29
,0x6c,0xdc,0x3c,0x01,0x23,0x35,0x61,0xf4
,0x1d,0xb6,0x6c,0xce,0x31,0x4a,0xdb,0x31
,0x0e,0x3b,0xe8,0x25,0x0c,0x46,0xf0,0x6d
,0xce,0xea,0x3a,0x7f,0xa1,0x34,0x80,0x57
,0xe2,0xf6,0x55,0x6a,0xd6,0xb1,0x31,0x8a
,0x02,0x4a,0x83,0x8f,0x21,0xaf,0x1f,0xde
,0x04,0x89,0x77,0xeb,0x48,0xf5,0x9f,0xfd
,0x49,0x24,0xca,0x1c,0x60,0x90,0x2e,0x52
,0xf0,0xa0,0x89,0xbc,0x76,0x89,0x70,0x40
,0xe0,0x82,0xf9,0x37,0x76,0x38,0x48,0x64
,0x5e,0x07,0x05
} ;
unsigned char m[131]
= { 0xbe, 0x07, 0x5f, 0xc5, 0x3c, 0x81, 0xf2, 0xd5, 0xcf, 0x14, 0x13, 0x16,
0xeb, 0xeb, 0x0c, 0x7b, 0x52, 0x28, 0xc5, 0x2a, 0x4c, 0x62, 0xcb, 0xd4,
0x4b, 0x66, 0x84, 0x9b, 0x64, 0x24, 0x4f, 0xfc, 0xe5, 0xec, 0xba, 0xaf,
0x33, 0xbd, 0x75, 0x1a, 0x1a, 0xc7, 0x28, 0xd4, 0x5e, 0x6c, 0x61, 0x29,
0x6c, 0xdc, 0x3c, 0x01, 0x23, 0x35, 0x61, 0xf4, 0x1d, 0xb6, 0x6c, 0xce,
0x31, 0x4a, 0xdb, 0x31, 0x0e, 0x3b, 0xe8, 0x25, 0x0c, 0x46, 0xf0, 0x6d,
0xce, 0xea, 0x3a, 0x7f, 0xa1, 0x34, 0x80, 0x57, 0xe2, 0xf6, 0x55, 0x6a,
0xd6, 0xb1, 0x31, 0x8a, 0x02, 0x4a, 0x83, 0x8f, 0x21, 0xaf, 0x1f, 0xde,
0x04, 0x89, 0x77, 0xeb, 0x48, 0xf5, 0x9f, 0xfd, 0x49, 0x24, 0xca, 0x1c,
0x60, 0x90, 0x2e, 0x52, 0xf0, 0xa0, 0x89, 0xbc, 0x76, 0x89, 0x70, 0x40,
0xe0, 0x82, 0xf9, 0x37, 0x76, 0x38, 0x48, 0x64, 0x5e, 0x07, 0x05 };
unsigned char c[147 + crypto_box_MACBYTES];
@@ -50,8 +37,9 @@ int main(void)
crypto_box_easy(c, m, 131, nonce, bobpk, alicesk);
for (i = 0; i < 131 + crypto_box_MACBYTES; ++i) {
printf(",0x%02x",(unsigned int) c[i]);
if (i % 8 == 7) printf("\n");
printf(",0x%02x", (unsigned int)c[i]);
if (i % 8 == 7)
printf("\n");
}
printf("\n");
return 0;
test/default/box_easy2.c
+3 -3
View File
@@ -19,12 +19,12 @@ int main(void)
crypto_box_keypair(alicepk, alicesk);
crypto_box_keypair(bobpk, bobsk);
mlen = (unsigned long long) randombytes_uniform((uint32_t) sizeof m);
mlen = (unsigned long long)randombytes_uniform((uint32_t)sizeof m);
randombytes_buf(m, mlen);
randombytes_buf(nonce, sizeof nonce);
crypto_box_easy(c, m, mlen, nonce, bobpk, alicesk);
if (crypto_box_open_easy(m2, c, mlen + crypto_box_MACBYTES,
nonce, alicepk, bobsk) != 0) {
if (crypto_box_open_easy(m2, c, mlen + crypto_box_MACBYTES, nonce, alicepk,
bobsk) != 0) {
printf("open() failed");
return 1;
}
test/default/box_seed.c
+12 -12
View File
@@ -2,12 +2,10 @@
#define TEST_NAME "box_seed"
#include "cmptest.h"
unsigned char seed[32] = {
0x77,0x07,0x6d,0x0a,0x73,0x18,0xa5,0x7d
,0x3c,0x16,0xc1,0x72,0x51,0xb2,0x66,0x45
,0xdf,0x4c,0x2f,0x87,0xeb,0xc0,0x99,0x2a
,0xb1,0x77,0xfb,0xa5,0x1d,0xb9,0x2c,0x2a
};
unsigned char seed[32]
= { 0x77, 0x07, 0x6d, 0x0a, 0x73, 0x18, 0xa5, 0x7d, 0x3c, 0x16, 0xc1,
0x72, 0x51, 0xb2, 0x66, 0x45, 0xdf, 0x4c, 0x2f, 0x87, 0xeb, 0xc0,
0x99, 0x2a, 0xb1, 0x77, 0xfb, 0xa5, 0x1d, 0xb9, 0x2c, 0x2a };
int main(void)
{
@@ -16,13 +14,15 @@ int main(void)
unsigned char pk[32];
crypto_box_seed_keypair(pk, sk, seed);
for (i = 0;i < 32;++i) {
printf(",0x%02x",(unsigned int) pk[i]);
if (i % 8 == 7) printf("\n");
for (i = 0; i < 32; ++i) {
printf(",0x%02x", (unsigned int)pk[i]);
if (i % 8 == 7)
printf("\n");
}
for (i = 0;i < 32;++i) {
printf(",0x%02x",(unsigned int) sk[i]);
if (i % 8 == 7) printf("\n");
for (i = 0; i < 32; ++i) {
printf(",0x%02x", (unsigned int)sk[i]);
if (i % 8 == 7)
printf("\n");
}
return 0;
}
test/default/chacha20.c
+17 -15
View File
@@ -7,26 +7,28 @@ static void tv(void)
static struct {
const char *key_hex;
const char *nonce_hex;
} tests[] = {
{"0000000000000000000000000000000000000000000000000000000000000000","0000000000000000"},
{"0000000000000000000000000000000000000000000000000000000000000001","0000000000000000"},
{"0000000000000000000000000000000000000000000000000000000000000000","0000000000000001"},
{"0000000000000000000000000000000000000000000000000000000000000000","0100000000000000"},
{"000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f","0001020304050607"}
};
} tests[]
= { { "0000000000000000000000000000000000000000000000000000000000000000",
"0000000000000000" },
{ "0000000000000000000000000000000000000000000000000000000000000001",
"0000000000000000" },
{ "0000000000000000000000000000000000000000000000000000000000000000",
"0000000000000001" },
{ "0000000000000000000000000000000000000000000000000000000000000000",
"0100000000000000" },
{ "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
"0001020304050607" } };
unsigned char key[crypto_stream_chacha20_KEYBYTES];
unsigned char nonce[crypto_stream_chacha20_NONCEBYTES];
unsigned char out[60];
char out_hex[60 * 2 + 1];
size_t i = 0U;
char out_hex[60 * 2 + 1];
size_t i = 0U;
do {
sodium_hex2bin((unsigned char *) key, sizeof key,
tests[i].key_hex, strlen(tests[i].key_hex),
NULL, NULL, NULL);
sodium_hex2bin(nonce, sizeof nonce,
tests[i].nonce_hex, strlen(tests[i].nonce_hex),
NULL, NULL, NULL);
sodium_hex2bin((unsigned char *)key, sizeof key, tests[i].key_hex,
strlen(tests[i].key_hex), NULL, NULL, NULL);
sodium_hex2bin(nonce, sizeof nonce, tests[i].nonce_hex,
strlen(tests[i].nonce_hex), NULL, NULL, NULL);
crypto_stream_chacha20(out, sizeof out, nonce, key);
sodium_bin2hex(out_hex, sizeof out_hex, out, sizeof out);
printf("[%s]\n", out_hex);
test/default/core1.c
+9 -13
View File
@@ -2,19 +2,15 @@
#define TEST_NAME "core1"
#include "cmptest.h"
unsigned char shared[32] = {
0x4a,0x5d,0x9d,0x5b,0xa4,0xce,0x2d,0xe1
,0x72,0x8e,0x3b,0xf4,0x80,0x35,0x0f,0x25
,0xe0,0x7e,0x21,0xc9,0x47,0xd1,0x9e,0x33
,0x76,0xf0,0x9b,0x3c,0x1e,0x16,0x17,0x42
} ;
unsigned char shared[32]
= { 0x4a, 0x5d, 0x9d, 0x5b, 0xa4, 0xce, 0x2d, 0xe1, 0x72, 0x8e, 0x3b,
0xf4, 0x80, 0x35, 0x0f, 0x25, 0xe0, 0x7e, 0x21, 0xc9, 0x47, 0xd1,
0x9e, 0x33, 0x76, 0xf0, 0x9b, 0x3c, 0x1e, 0x16, 0x17, 0x42 };
unsigned char zero[32] = { 0 };
unsigned char c[16] = {
0x65,0x78,0x70,0x61,0x6e,0x64,0x20,0x33
,0x32,0x2d,0x62,0x79,0x74,0x65,0x20,0x6b
} ;
unsigned char c[16] = { 0x65, 0x78, 0x70, 0x61, 0x6e, 0x64, 0x20, 0x33,
0x32, 0x2d, 0x62, 0x79, 0x74, 0x65, 0x20, 0x6b };
unsigned char firstkey[32];
@@ -22,14 +18,14 @@ int main(void)
{
int i;
crypto_core_hsalsa20(firstkey,zero,shared,c);
for (i = 0;i < 32;++i) {
crypto_core_hsalsa20(firstkey, zero, shared, c);
for (i = 0; i < 32; ++i) {
if (i > 0) {
printf(",");
} else {
printf(" ");
}
printf("0x%02x",(unsigned int) firstkey[i]);
printf("0x%02x", (unsigned int)firstkey[i]);
if (i % 8 == 7) {
printf("\n");
}
test/default/core2.c
+12 -17
View File
@@ -2,22 +2,17 @@
#define TEST_NAME "core2"
#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 nonceprefix[16] = {
0x69,0x69,0x6e,0xe9,0x55,0xb6,0x2b,0x73
,0xcd,0x62,0xbd,0xa8,0x75,0xfc,0x73,0xd6
} ;
unsigned char nonceprefix[16]
= { 0x69, 0x69, 0x6e, 0xe9, 0x55, 0xb6, 0x2b, 0x73,
0xcd, 0x62, 0xbd, 0xa8, 0x75, 0xfc, 0x73, 0xd6 };
unsigned char c[16] = {
0x65,0x78,0x70,0x61,0x6e,0x64,0x20,0x33
,0x32,0x2d,0x62,0x79,0x74,0x65,0x20,0x6b
} ;
unsigned char c[16] = { 0x65, 0x78, 0x70, 0x61, 0x6e, 0x64, 0x20, 0x33,
0x32, 0x2d, 0x62, 0x79, 0x74, 0x65, 0x20, 0x6b };
unsigned char secondkey[32];
@@ -25,14 +20,14 @@ int main(void)
{
int i;
crypto_core_hsalsa20(secondkey,nonceprefix,firstkey,c);
for (i = 0;i < 32;++i) {
crypto_core_hsalsa20(secondkey, nonceprefix, firstkey, c);
for (i = 0; i < 32; ++i) {
if (i > 0) {
printf(",");
} else {
printf(" ");
}
printf("0x%02x",(unsigned int) secondkey[i]);
printf("0x%02x", (unsigned int)secondkey[i]);
if (i % 8 == 7) {
printf("\n");
}
test/default/core3.c
+15 -19
View File
@@ -2,23 +2,18 @@
#define TEST_NAME "core3"
#include "cmptest.h"
unsigned char secondkey[32] = {
0xdc,0x90,0x8d,0xda,0x0b,0x93,0x44,0xa9
,0x53,0x62,0x9b,0x73,0x38,0x20,0x77,0x88
,0x80,0xf3,0xce,0xb4,0x21,0xbb,0x61,0xb9
,0x1c,0xbd,0x4c,0x3e,0x66,0x25,0x6c,0xe4
} ;
unsigned char secondkey[32]
= { 0xdc, 0x90, 0x8d, 0xda, 0x0b, 0x93, 0x44, 0xa9, 0x53, 0x62, 0x9b,
0x73, 0x38, 0x20, 0x77, 0x88, 0x80, 0xf3, 0xce, 0xb4, 0x21, 0xbb,
0x61, 0xb9, 0x1c, 0xbd, 0x4c, 0x3e, 0x66, 0x25, 0x6c, 0xe4 };
unsigned char noncesuffix[8] = {
0x82,0x19,0xe0,0x03,0x6b,0x7a,0x0b,0x37
} ;
unsigned char noncesuffix[8]
= { 0x82, 0x19, 0xe0, 0x03, 0x6b, 0x7a, 0x0b, 0x37 };
unsigned char c[16] = {
0x65,0x78,0x70,0x61,0x6e,0x64,0x20,0x33
,0x32,0x2d,0x62,0x79,0x74,0x65,0x20,0x6b
} ;
unsigned char c[16] = { 0x65, 0x78, 0x70, 0x61, 0x6e, 0x64, 0x20, 0x33,
0x32, 0x2d, 0x62, 0x79, 0x74, 0x65, 0x20, 0x6b };
unsigned char in[16] = { 0 } ;
unsigned char in[16] = { 0 };
unsigned char output[64 * 256 * 256];
@@ -29,16 +24,17 @@ int main(void)
int i;
long long pos = 0;
for (i = 0;i < 8;++i) in[i] = noncesuffix[i];
for (i = 0; i < 8; ++i)
in[i] = noncesuffix[i];
do {
do {
crypto_core_salsa20(output + pos,in,secondkey,c);
crypto_core_salsa20(output + pos, in, secondkey, c);
pos += 64;
} while (++in[8]);
} while (++in[9]);
crypto_hash_sha256(h,output,sizeof output);
for (i = 0;i < 32;++i) {
printf("%02x",h[i]);
crypto_hash_sha256(h, output, sizeof output);
for (i = 0; i < 32; ++i) {
printf("%02x", h[i]);
}
printf("\n");
assert(crypto_core_salsa20_outputbytes() > 0U);
test/default/core4.c
+10 -17
View File
@@ -2,22 +2,15 @@
#define TEST_NAME "core4"
#include "cmptest.h"
unsigned char k[32] = {
1, 2, 3, 4, 5, 6, 7, 8
, 9, 10, 11, 12, 13, 14, 15, 16
,201,202,203,204,205,206,207,208
,209,210,211,212,213,214,215,216
} ;
unsigned char k[32] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
12, 13, 14, 15, 16, 201, 202, 203, 204, 205, 206,
207, 208, 209, 210, 211, 212, 213, 214, 215, 216 };
unsigned char in[16] = {
101,102,103,104,105,106,107,108
,109,110,111,112,113,114,115,116
} ;
unsigned char in[16] = { 101, 102, 103, 104, 105, 106, 107, 108,
109, 110, 111, 112, 113, 114, 115, 116 };
unsigned char c[16] = {
101,120,112, 97,110,100, 32, 51
, 50, 45, 98,121,116,101, 32,107
} ;
unsigned char c[16] = { 101, 120, 112, 97, 110, 100, 32, 51,
50, 45, 98, 121, 116, 101, 32, 107 };
unsigned char out[64];
@@ -25,14 +18,14 @@ int main(void)
{
int i;
crypto_core_salsa20(out,in,k,c);
for (i = 0;i < 64;++i) {
crypto_core_salsa20(out, in, k, c);
for (i = 0; i < 64; ++i) {
if (i > 0) {
printf(",");
} else {
printf(" ");
}
printf("%3d",(unsigned int) out[i]);
printf("%3d", (unsigned int)out[i]);
if (i % 8 == 7) {
printf("\n");
}
test/default/core5.c
+11 -17
View File
@@ -2,22 +2,16 @@
#define TEST_NAME "core5"
#include "cmptest.h"
unsigned char k[32] = {
0xee,0x30,0x4f,0xca,0x27,0x00,0x8d,0x8c
,0x12,0x6f,0x90,0x02,0x79,0x01,0xd8,0x0f
,0x7f,0x1d,0x8b,0x8d,0xc9,0x36,0xcf,0x3b
,0x9f,0x81,0x96,0x92,0x82,0x7e,0x57,0x77
} ;
unsigned char k[32]
= { 0xee, 0x30, 0x4f, 0xca, 0x27, 0x00, 0x8d, 0x8c, 0x12, 0x6f, 0x90,
0x02, 0x79, 0x01, 0xd8, 0x0f, 0x7f, 0x1d, 0x8b, 0x8d, 0xc9, 0x36,
0xcf, 0x3b, 0x9f, 0x81, 0x96, 0x92, 0x82, 0x7e, 0x57, 0x77 };
unsigned char in[16] = {
0x81,0x91,0x8e,0xf2,0xa5,0xe0,0xda,0x9b
,0x3e,0x90,0x60,0x52,0x1e,0x4b,0xb3,0x52
} ;
unsigned char in[16] = { 0x81, 0x91, 0x8e, 0xf2, 0xa5, 0xe0, 0xda, 0x9b,
0x3e, 0x90, 0x60, 0x52, 0x1e, 0x4b, 0xb3, 0x52 };
unsigned char c[16] = {
101,120,112, 97,110,100, 32, 51
, 50, 45, 98,121,116,101, 32,107
} ;
unsigned char c[16] = { 101, 120, 112, 97, 110, 100, 32, 51,
50, 45, 98, 121, 116, 101, 32, 107 };
unsigned char out[32];
@@ -25,9 +19,9 @@ int main(void)
{
int i;
crypto_core_hsalsa20(out,in,k,c);
for (i = 0;i < 32;++i) {
printf(",0x%02x",(unsigned int) out[i]);
crypto_core_hsalsa20(out, in, k, c);
for (i = 0; i < 32; ++i) {
printf(",0x%02x", (unsigned int)out[i]);
if (i % 8 == 7) {
printf("\n");
}
test/default/core6.c
+24 -26
View File
@@ -2,49 +2,47 @@
#define TEST_NAME "core6"
#include "cmptest.h"
unsigned char k[32] = {
0xee,0x30,0x4f,0xca,0x27,0x00,0x8d,0x8c
,0x12,0x6f,0x90,0x02,0x79,0x01,0xd8,0x0f
,0x7f,0x1d,0x8b,0x8d,0xc9,0x36,0xcf,0x3b
,0x9f,0x81,0x96,0x92,0x82,0x7e,0x57,0x77
} ;
unsigned char k[32]
= { 0xee, 0x30, 0x4f, 0xca, 0x27, 0x00, 0x8d, 0x8c, 0x12, 0x6f, 0x90,
0x02, 0x79, 0x01, 0xd8, 0x0f, 0x7f, 0x1d, 0x8b, 0x8d, 0xc9, 0x36,
0xcf, 0x3b, 0x9f, 0x81, 0x96, 0x92, 0x82, 0x7e, 0x57, 0x77 };
unsigned char in[16] = {
0x81,0x91,0x8e,0xf2,0xa5,0xe0,0xda,0x9b
,0x3e,0x90,0x60,0x52,0x1e,0x4b,0xb3,0x52
} ;
unsigned char in[16] = { 0x81, 0x91, 0x8e, 0xf2, 0xa5, 0xe0, 0xda, 0x9b,
0x3e, 0x90, 0x60, 0x52, 0x1e, 0x4b, 0xb3, 0x52 };
unsigned char c[16] = {
101,120,112, 97,110,100, 32, 51
, 50, 45, 98,121,116,101, 32,107
} ;
unsigned char c[16] = { 101, 120, 112, 97, 110, 100, 32, 51,
50, 45, 98, 121, 116, 101, 32, 107 };
unsigned char out[64];
void print(unsigned char *x,unsigned char *y)
void print(unsigned char *x, unsigned char *y)
{
int i;
unsigned int borrow = 0;
for (i = 0;i < 4;++i) {
for (i = 0; i < 4; ++i) {
unsigned int xi = x[i];
unsigned int yi = y[i];
printf(",0x%02x",255 & (xi - yi - borrow));
printf(",0x%02x", 255 & (xi - yi - borrow));
borrow = (xi < yi + borrow);
}
}
int main(void)
{
crypto_core_salsa20(out,in,k,c);
print(out,c);
print(out + 20,c + 4); printf("\n");
print(out + 40,c + 8);
print(out + 60,c + 12); printf("\n");
print(out + 24,in);
print(out + 28,in + 4); printf("\n");
print(out + 32,in + 8);
print(out + 36,in + 12); printf("\n");
crypto_core_salsa20(out, in, k, c);
print(out, c);
print(out + 20, c + 4);
printf("\n");
print(out + 40, c + 8);
print(out + 60, c + 12);
printf("\n");
print(out + 24, in);
print(out + 28, in + 4);
printf("\n");
print(out + 32, in + 8);
print(out + 36, in + 12);
printf("\n");
return 0;
}
test/default/ed25519_convert.c
+16 -18
View File
@@ -2,31 +2,29 @@
#define TEST_NAME "ed25519_convert"
#include "cmptest.h"
static const unsigned char keypair_seed[crypto_sign_ed25519_SEEDBYTES] = {
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[crypto_sign_ed25519_SEEDBYTES]
= { 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 };
int main(void)
{
unsigned char ed25519_pk[crypto_sign_ed25519_PUBLICKEYBYTES];
unsigned char ed25519_skpk[crypto_sign_ed25519_SECRETKEYBYTES];
unsigned char curve25519_pk[crypto_scalarmult_curve25519_BYTES];
unsigned char curve25519_pk2[crypto_scalarmult_curve25519_BYTES];
unsigned char curve25519_sk[crypto_scalarmult_curve25519_BYTES];
char curve25519_pk_hex[crypto_scalarmult_curve25519_BYTES * 2 + 1];
char curve25519_sk_hex[crypto_scalarmult_curve25519_BYTES * 2 + 1];
unsigned int i;
unsigned char ed25519_pk[crypto_sign_ed25519_PUBLICKEYBYTES];
unsigned char ed25519_skpk[crypto_sign_ed25519_SECRETKEYBYTES];
unsigned char curve25519_pk[crypto_scalarmult_curve25519_BYTES];
unsigned char curve25519_pk2[crypto_scalarmult_curve25519_BYTES];
unsigned char curve25519_sk[crypto_scalarmult_curve25519_BYTES];
char curve25519_pk_hex[crypto_scalarmult_curve25519_BYTES * 2 + 1];
char curve25519_sk_hex[crypto_scalarmult_curve25519_BYTES * 2 + 1];
unsigned int i;
crypto_sign_ed25519_seed_keypair(ed25519_pk, ed25519_skpk, keypair_seed);
crypto_sign_ed25519_pk_to_curve25519(curve25519_pk, ed25519_pk);
crypto_sign_ed25519_sk_to_curve25519(curve25519_sk, ed25519_skpk);
sodium_bin2hex(curve25519_pk_hex, sizeof curve25519_pk_hex,
curve25519_pk, sizeof curve25519_pk);
sodium_bin2hex(curve25519_sk_hex, sizeof curve25519_sk_hex,
curve25519_sk, sizeof curve25519_sk);
sodium_bin2hex(curve25519_pk_hex, sizeof curve25519_pk_hex, curve25519_pk,
sizeof curve25519_pk);
sodium_bin2hex(curve25519_sk_hex, sizeof curve25519_sk_hex, curve25519_sk,
sizeof curve25519_sk);
printf("curve25519 pk: [%s]\n", curve25519_pk_hex);
printf("curve25519 sk: [%s]\n", curve25519_sk_hex);
test/default/generichash.c
+21 -15
View File
@@ -5,18 +5,19 @@
int main(void)
{
#define MAXLEN 64
unsigned char in[MAXLEN], out[crypto_generichash_BYTES_MAX], k[crypto_generichash_KEYBYTES_MAX];
size_t h,i,j;
unsigned char in[MAXLEN], out[crypto_generichash_BYTES_MAX],
k[crypto_generichash_KEYBYTES_MAX];
size_t h, i, j;
for(h = 0; h < crypto_generichash_KEYBYTES_MAX; ++h) k[h] = h;
for (h = 0; h < crypto_generichash_KEYBYTES_MAX; ++h)
k[h] = h;
for(i = 0; i < MAXLEN; ++i) {
in[i]=i;
crypto_generichash(out, 1 + i % crypto_generichash_BYTES_MAX,
in, i,
k, 1 + i % crypto_generichash_KEYBYTES_MAX);
for (j = 0;j < 1 + i % crypto_generichash_BYTES_MAX;++j) {
printf("%02x",(unsigned int) out[j]);
for (i = 0; i < MAXLEN; ++i) {
in[i] = i;
crypto_generichash(out, 1 + i % crypto_generichash_BYTES_MAX, in, i, k,
1 + i % crypto_generichash_KEYBYTES_MAX);
for (j = 0; j < 1 + i % crypto_generichash_BYTES_MAX; ++j) {
printf("%02x", (unsigned int)out[j]);
}
printf("\n");
}
@@ -32,12 +33,17 @@ int main(void)
assert(crypto_generichash_keybytes() >= crypto_generichash_keybytes_min());
assert(crypto_generichash_keybytes() <= crypto_generichash_keybytes_max());
assert(strcmp(crypto_generichash_primitive(), "blake2b") == 0);
assert(crypto_generichash_bytes_min() == crypto_generichash_blake2b_bytes_min());
assert(crypto_generichash_bytes_max() == crypto_generichash_blake2b_bytes_max());
assert(crypto_generichash_bytes_min()
== crypto_generichash_blake2b_bytes_min());
assert(crypto_generichash_bytes_max()
== crypto_generichash_blake2b_bytes_max());
assert(crypto_generichash_bytes() == crypto_generichash_blake2b_bytes());
assert(crypto_generichash_keybytes_min() == crypto_generichash_blake2b_keybytes_min());
assert(crypto_generichash_keybytes_max() == crypto_generichash_blake2b_keybytes_max());
assert(crypto_generichash_keybytes() == crypto_generichash_blake2b_keybytes());
assert(crypto_generichash_keybytes_min()
== crypto_generichash_blake2b_keybytes_min());
assert(crypto_generichash_keybytes_max()
== crypto_generichash_blake2b_keybytes_max());
assert(crypto_generichash_keybytes()
== crypto_generichash_blake2b_keybytes());
assert(crypto_generichash_blake2b_saltbytes() > 0U);
assert(crypto_generichash_blake2b_personalbytes() > 0U);
test/default/generichash2.c
+11 -8
View File
@@ -6,21 +6,24 @@ int main(void)
{
#define MAXLEN 64
crypto_generichash_state st;
unsigned char in[MAXLEN], out[crypto_generichash_BYTES_MAX], k[crypto_generichash_KEYBYTES_MAX];
size_t h,i,j;
unsigned char in[MAXLEN], out[crypto_generichash_BYTES_MAX],
k[crypto_generichash_KEYBYTES_MAX];
size_t h, i, j;
for(h = 0; h < crypto_generichash_KEYBYTES_MAX; ++h) k[h] = h;
for (h = 0; h < crypto_generichash_KEYBYTES_MAX; ++h)
k[h] = h;
for(i = 0; i < MAXLEN; ++i) {
in[i]=i;
for (i = 0; i < MAXLEN; ++i) {
in[i] = i;
crypto_generichash_init(&st, k, 1 + i % crypto_generichash_KEYBYTES_MAX,
1 + i % crypto_generichash_BYTES_MAX);
crypto_generichash_update(&st, in, i);
crypto_generichash_update(&st, in, i);
crypto_generichash_update(&st, in, i);
crypto_generichash_final(&st, out, 1 + i % crypto_generichash_BYTES_MAX);
for (j = 0;j < 1 + i % crypto_generichash_BYTES_MAX;++j) {
printf("%02x",(unsigned int) out[j]);
crypto_generichash_final(&st, out,
1 + i % crypto_generichash_BYTES_MAX);
for (j = 0; j < 1 + i % crypto_generichash_BYTES_MAX; ++j) {
printf("%02x", (unsigned int)out[j]);
}
printf("\n");
}
test/default/generichash3.c
+20 -17
View File
@@ -6,26 +6,29 @@ int main(void)
{
#define MAXLEN 64
crypto_generichash_blake2b_state st;
unsigned char salt[crypto_generichash_blake2b_SALTBYTES] = {
'5', 'b', '6', 'b', '4', '1', 'e', 'd', '9', 'b', '3', '4', '3', 'f', 'e', '0'
};
unsigned char personal[crypto_generichash_blake2b_PERSONALBYTES] = {
'5', '1', '2', '6', 'f', 'b', '2', 'a', '3', '7', '4', '0', '0', 'd', '2', 'a'
};
unsigned char in[MAXLEN], out[crypto_generichash_blake2b_BYTES_MAX], k[crypto_generichash_blake2b_KEYBYTES_MAX];
size_t h,i,j;
unsigned char salt[crypto_generichash_blake2b_SALTBYTES]
= { '5', 'b', '6', 'b', '4', '1', 'e', 'd',
'9', 'b', '3', '4', '3', 'f', 'e', '0' };
unsigned char personal[crypto_generichash_blake2b_PERSONALBYTES]
= { '5', '1', '2', '6', 'f', 'b', '2', 'a',
'3', '7', '4', '0', '0', 'd', '2', 'a' };
unsigned char in[MAXLEN], out[crypto_generichash_blake2b_BYTES_MAX],
k[crypto_generichash_blake2b_KEYBYTES_MAX];
size_t h, i, j;
for(h = 0; h < crypto_generichash_blake2b_KEYBYTES_MAX; ++h) k[h] = h;
for (h = 0; h < crypto_generichash_blake2b_KEYBYTES_MAX; ++h)
k[h] = h;
for(i = 0; i < MAXLEN; ++i) {
in[i]=i;
crypto_generichash_blake2b_init_salt_personal(&st, k, 1 + i % crypto_generichash_blake2b_KEYBYTES_MAX,
1 + i % crypto_generichash_blake2b_BYTES_MAX,
salt, personal);
for (i = 0; i < MAXLEN; ++i) {
in[i] = i;
crypto_generichash_blake2b_init_salt_personal(
&st, k, 1 + i % crypto_generichash_blake2b_KEYBYTES_MAX,
1 + i % crypto_generichash_blake2b_BYTES_MAX, salt, personal);
crypto_generichash_blake2b_update(&st, in, i);
crypto_generichash_blake2b_final(&st, out, 1 + i % crypto_generichash_blake2b_BYTES_MAX);
for (j = 0;j < 1 + i % crypto_generichash_blake2b_BYTES_MAX;++j) {
printf("%02x",(unsigned int) out[j]);
crypto_generichash_blake2b_final(
&st, out, 1 + i % crypto_generichash_blake2b_BYTES_MAX);
for (j = 0; j < 1 + i % crypto_generichash_blake2b_BYTES_MAX; ++j) {
printf("%02x", (unsigned int)out[j]);
}
printf("\n");
}
test/default/hash.c
+3 -3
View File
@@ -9,9 +9,9 @@ int main(void)
{
size_t i;
crypto_hash(h,x,sizeof x - 1U);
for (i = 0;i < crypto_hash_BYTES;++i) {
printf("%02x",(unsigned int) h[i]);
crypto_hash(h, x, sizeof x - 1U);
for (i = 0; i < crypto_hash_BYTES; ++i) {
printf("%02x", (unsigned int)h[i]);
}
printf("\n");
test/default/hash3.c
+3 -3
View File
@@ -9,9 +9,9 @@ int main(void)
{
size_t i;
crypto_hash(h,x,sizeof x - 1U);
for (i = 0;i < crypto_hash_BYTES;++i) {
printf("%02x",(unsigned int) h[i]);
crypto_hash(h, x, sizeof x - 1U);
for (i = 0; i < crypto_hash_BYTES; ++i) {
printf("%02x", (unsigned int)h[i]);
}
printf("\n");
test/default/onetimeauth.c
+23 -30
View File
@@ -2,32 +2,23 @@
#define TEST_NAME "onetimeauth"
#include "cmptest.h"
unsigned char rs[32] = {
0xee,0xa6,0xa7,0x25,0x1c,0x1e,0x72,0x91
,0x6d,0x11,0xc2,0xcb,0x21,0x4d,0x3c,0x25
,0x25,0x39,0x12,0x1d,0x8e,0x23,0x4e,0x65
,0x2d,0x65,0x1f,0xa4,0xc8,0xcf,0xf8,0x80
} ;
unsigned char rs[32]
= { 0xee, 0xa6, 0xa7, 0x25, 0x1c, 0x1e, 0x72, 0x91, 0x6d, 0x11, 0xc2,
0xcb, 0x21, 0x4d, 0x3c, 0x25, 0x25, 0x39, 0x12, 0x1d, 0x8e, 0x23,
0x4e, 0x65, 0x2d, 0x65, 0x1f, 0xa4, 0xc8, 0xcf, 0xf8, 0x80 };
unsigned char c[131] = {
0x8e,0x99,0x3b,0x9f,0x48,0x68,0x12,0x73
,0xc2,0x96,0x50,0xba,0x32,0xfc,0x76,0xce
,0x48,0x33,0x2e,0xa7,0x16,0x4d,0x96,0xa4
,0x47,0x6f,0xb8,0xc5,0x31,0xa1,0x18,0x6a
,0xc0,0xdf,0xc1,0x7c,0x98,0xdc,0xe8,0x7b
,0x4d,0xa7,0xf0,0x11,0xec,0x48,0xc9,0x72
,0x71,0xd2,0xc2,0x0f,0x9b,0x92,0x8f,0xe2
,0x27,0x0d,0x6f,0xb8,0x63,0xd5,0x17,0x38
,0xb4,0x8e,0xee,0xe3,0x14,0xa7,0xcc,0x8a
,0xb9,0x32,0x16,0x45,0x48,0xe5,0x26,0xae
,0x90,0x22,0x43,0x68,0x51,0x7a,0xcf,0xea
,0xbd,0x6b,0xb3,0x73,0x2b,0xc0,0xe9,0xda
,0x99,0x83,0x2b,0x61,0xca,0x01,0xb6,0xde
,0x56,0x24,0x4a,0x9e,0x88,0xd5,0xf9,0xb3
,0x79,0x73,0xf6,0x22,0xa4,0x3d,0x14,0xa6
,0x59,0x9b,0x1f,0x65,0x4c,0xb4,0x5a,0x74
,0xe3,0x55,0xa5
} ;
unsigned char c[131]
= { 0x8e, 0x99, 0x3b, 0x9f, 0x48, 0x68, 0x12, 0x73, 0xc2, 0x96, 0x50, 0xba,
0x32, 0xfc, 0x76, 0xce, 0x48, 0x33, 0x2e, 0xa7, 0x16, 0x4d, 0x96, 0xa4,
0x47, 0x6f, 0xb8, 0xc5, 0x31, 0xa1, 0x18, 0x6a, 0xc0, 0xdf, 0xc1, 0x7c,
0x98, 0xdc, 0xe8, 0x7b, 0x4d, 0xa7, 0xf0, 0x11, 0xec, 0x48, 0xc9, 0x72,
0x71, 0xd2, 0xc2, 0x0f, 0x9b, 0x92, 0x8f, 0xe2, 0x27, 0x0d, 0x6f, 0xb8,
0x63, 0xd5, 0x17, 0x38, 0xb4, 0x8e, 0xee, 0xe3, 0x14, 0xa7, 0xcc, 0x8a,
0xb9, 0x32, 0x16, 0x45, 0x48, 0xe5, 0x26, 0xae, 0x90, 0x22, 0x43, 0x68,
0x51, 0x7a, 0xcf, 0xea, 0xbd, 0x6b, 0xb3, 0x73, 0x2b, 0xc0, 0xe9, 0xda,
0x99, 0x83, 0x2b, 0x61, 0xca, 0x01, 0xb6, 0xde, 0x56, 0x24, 0x4a, 0x9e,
0x88, 0xd5, 0xf9, 0xb3, 0x79, 0x73, 0xf6, 0x22, 0xa4, 0x3d, 0x14, 0xa6,
0x59, 0x9b, 0x1f, 0x65, 0x4c, 0xb4, 0x5a, 0x74, 0xe3, 0x55, 0xa5 };
unsigned char a[16];
@@ -35,16 +26,18 @@ int main(void)
{
int i;
crypto_onetimeauth(a,c,131,rs);
for (i = 0;i < 16;++i) {
printf(",0x%02x",(unsigned int) a[i]);
if (i % 8 == 7) printf("\n");
crypto_onetimeauth(a, c, 131, rs);
for (i = 0; i < 16; ++i) {
printf(",0x%02x", (unsigned int)a[i]);
if (i % 8 == 7)
printf("\n");
}
assert(crypto_onetimeauth_bytes() > 0U);
assert(crypto_onetimeauth_keybytes() > 0U);
assert(strcmp(crypto_onetimeauth_primitive(), "poly1305") == 0);
assert(crypto_onetimeauth_poly1305_bytes() == crypto_onetimeauth_bytes());
assert(crypto_onetimeauth_poly1305_keybytes() == crypto_onetimeauth_keybytes());
assert(crypto_onetimeauth_poly1305_keybytes()
== crypto_onetimeauth_keybytes());
return 0;
}
test/default/onetimeauth2.c
+19 -30
View File
@@ -2,40 +2,29 @@
#define TEST_NAME "onetimeauth2"
#include "cmptest.h"
unsigned char rs[32] = {
0xee,0xa6,0xa7,0x25,0x1c,0x1e,0x72,0x91
,0x6d,0x11,0xc2,0xcb,0x21,0x4d,0x3c,0x25
,0x25,0x39,0x12,0x1d,0x8e,0x23,0x4e,0x65
,0x2d,0x65,0x1f,0xa4,0xc8,0xcf,0xf8,0x80
} ;
unsigned char rs[32]
= { 0xee, 0xa6, 0xa7, 0x25, 0x1c, 0x1e, 0x72, 0x91, 0x6d, 0x11, 0xc2,
0xcb, 0x21, 0x4d, 0x3c, 0x25, 0x25, 0x39, 0x12, 0x1d, 0x8e, 0x23,
0x4e, 0x65, 0x2d, 0x65, 0x1f, 0xa4, 0xc8, 0xcf, 0xf8, 0x80 };
unsigned char c[131] = {
0x8e,0x99,0x3b,0x9f,0x48,0x68,0x12,0x73
,0xc2,0x96,0x50,0xba,0x32,0xfc,0x76,0xce
,0x48,0x33,0x2e,0xa7,0x16,0x4d,0x96,0xa4
,0x47,0x6f,0xb8,0xc5,0x31,0xa1,0x18,0x6a
,0xc0,0xdf,0xc1,0x7c,0x98,0xdc,0xe8,0x7b
,0x4d,0xa7,0xf0,0x11,0xec,0x48,0xc9,0x72
,0x71,0xd2,0xc2,0x0f,0x9b,0x92,0x8f,0xe2
,0x27,0x0d,0x6f,0xb8,0x63,0xd5,0x17,0x38
,0xb4,0x8e,0xee,0xe3,0x14,0xa7,0xcc,0x8a
,0xb9,0x32,0x16,0x45,0x48,0xe5,0x26,0xae
,0x90,0x22,0x43,0x68,0x51,0x7a,0xcf,0xea
,0xbd,0x6b,0xb3,0x73,0x2b,0xc0,0xe9,0xda
,0x99,0x83,0x2b,0x61,0xca,0x01,0xb6,0xde
,0x56,0x24,0x4a,0x9e,0x88,0xd5,0xf9,0xb3
,0x79,0x73,0xf6,0x22,0xa4,0x3d,0x14,0xa6
,0x59,0x9b,0x1f,0x65,0x4c,0xb4,0x5a,0x74
,0xe3,0x55,0xa5
} ;
unsigned char c[131]
= { 0x8e, 0x99, 0x3b, 0x9f, 0x48, 0x68, 0x12, 0x73, 0xc2, 0x96, 0x50, 0xba,
0x32, 0xfc, 0x76, 0xce, 0x48, 0x33, 0x2e, 0xa7, 0x16, 0x4d, 0x96, 0xa4,
0x47, 0x6f, 0xb8, 0xc5, 0x31, 0xa1, 0x18, 0x6a, 0xc0, 0xdf, 0xc1, 0x7c,
0x98, 0xdc, 0xe8, 0x7b, 0x4d, 0xa7, 0xf0, 0x11, 0xec, 0x48, 0xc9, 0x72,
0x71, 0xd2, 0xc2, 0x0f, 0x9b, 0x92, 0x8f, 0xe2, 0x27, 0x0d, 0x6f, 0xb8,
0x63, 0xd5, 0x17, 0x38, 0xb4, 0x8e, 0xee, 0xe3, 0x14, 0xa7, 0xcc, 0x8a,
0xb9, 0x32, 0x16, 0x45, 0x48, 0xe5, 0x26, 0xae, 0x90, 0x22, 0x43, 0x68,
0x51, 0x7a, 0xcf, 0xea, 0xbd, 0x6b, 0xb3, 0x73, 0x2b, 0xc0, 0xe9, 0xda,
0x99, 0x83, 0x2b, 0x61, 0xca, 0x01, 0xb6, 0xde, 0x56, 0x24, 0x4a, 0x9e,
0x88, 0xd5, 0xf9, 0xb3, 0x79, 0x73, 0xf6, 0x22, 0xa4, 0x3d, 0x14, 0xa6,
0x59, 0x9b, 0x1f, 0x65, 0x4c, 0xb4, 0x5a, 0x74, 0xe3, 0x55, 0xa5 };
unsigned char a[16] = {
0xf3,0xff,0xc7,0x70,0x3f,0x94,0x00,0xe5
,0x2a,0x7d,0xfb,0x4b,0x3d,0x33,0x05,0xd9
} ;
unsigned char a[16] = { 0xf3, 0xff, 0xc7, 0x70, 0x3f, 0x94, 0x00, 0xe5,
0x2a, 0x7d, 0xfb, 0x4b, 0x3d, 0x33, 0x05, 0xd9 };
int main(void)
{
printf("%d\n",crypto_onetimeauth_verify(a,c,131,rs));
printf("%d\n", crypto_onetimeauth_verify(a, c, 131, rs));
return 0;
}
test/default/onetimeauth7.c
+10 -10
View File
@@ -12,23 +12,23 @@ int main(void)
{
int clen;
for (clen = 0;clen < 10000;++clen) {
randombytes(key,sizeof key);
randombytes(c,clen);
crypto_onetimeauth(a,c,clen,key);
if (crypto_onetimeauth_verify(a,c,clen,key) != 0) {
printf("fail %d\n",clen);
for (clen = 0; clen < 10000; ++clen) {
randombytes_buf(key, sizeof key);
randombytes_buf(c, clen);
crypto_onetimeauth(a, c, clen, key);
if (crypto_onetimeauth_verify(a, c, clen, key) != 0) {
printf("fail %d\n", clen);
return 100;
}
if (clen > 0) {
c[rand() % clen] += 1 + (rand() % 255);
if (crypto_onetimeauth_verify(a,c,clen,key) == 0) {
printf("forgery %d\n",clen);
if (crypto_onetimeauth_verify(a, c, clen, key) == 0) {
printf("forgery %d\n", clen);
return 100;
}
a[rand() % sizeof a] += 1 + (rand() % 255);
if (crypto_onetimeauth_verify(a,c,clen,key) == 0) {
printf("forgery %d\n",clen);
if (crypto_onetimeauth_verify(a, c, clen, key) == 0) {
printf("forgery %d\n", clen);
return 100;
}
}
test/default/pwhash.c
+151 -60
View File
@@ -5,42 +5,102 @@
static void tv(void)
{
static struct {
const char *passwd_hex;
unsigned long long passwdlen;
const char *salt_hex;
unsigned long long outlen;
unsigned long long opslimit;
size_t memlimit;
const char *passwd_hex;
unsigned long long passwdlen;
const char *salt_hex;
unsigned long long outlen;
unsigned long long opslimit;
size_t memlimit;
} tests[] = {
{"a347ae92bce9f80f6f595a4480fc9c2fe7e7d7148d371e9487d75f5c23008ffae065577a928febd9b1973a5a95073acdbeb6a030cfc0d79caa2dc5cd011cef02c08da232d76d52dfbca38ca8dcbd665b17d1665f7cf5fe59772ec909733b24de97d6f58d220b20c60d7c07ec1fd93c52c31020300c6c1facd77937a597c7a6", 127, "5541fbc995d5c197ba290346d2c559dedf405cf97e5f95482143202f9e74f5c2", 155, 481326, 7256678},
{"e125cee61c8cb7778d9e5ad0a6f5d978ce9f84de213a8556d9ffe202020ab4a6ed9074a4eb3416f9b168f137510f3a30b70b96cbfa219ff99f6c6eaffb15c06b60e00cc2890277f0fd3c622115772f7048adaebed86e", 86, "f1192dd5dc2368b9cd421338b22433455ee0a3699f9379a08b9650ea2c126f0d", 250, 535778, 7849083},
{"92263cbf6ac376499f68a4289d3bb59e5a22335eba63a32e6410249155b956b6a3b48d4a44906b18b897127300b375b8f834f1ceffc70880a885f47c33876717e392be57f7da3ae58da4fd1f43daa7e44bb82d3717af4319349c24cd31e46d295856b0441b6b289992a11ced1cc3bf3011604590244a3eb737ff221129215e4e4347f4915d41292b5173d196eb9add693be5319fdadc242906178bb6c0286c9b6ca6012746711f58c8c392016b2fdfc09c64f0f6b6ab7b", 183, "3b840e20e9555e9fb031c4ba1f1747ce25cc1d0ff664be676b9b4a90641ff194", 249, 311757, 7994791},
{"027b6d8e8c8c474e9b69c7d9ed4f9971e8e1ce2f6ba95048414c3970f0f09b70e3b6c5ae05872b3d8678705b7d381829c351a5a9c88c233569b35d6b0b809df44b6451a9c273f1150e2ef8a0b5437eb701e373474cd44b97ef0248ebce2ca0400e1b53f3d86221eca3f18eb45b702b9172440f774a82cbf1f6f525df30a6e293c873cce69bb078ed1f0d31e7f9b8062409f37f19f8550aae", 152, "eb2a3056a09ad2d7d7f975bcd707598f24cd32518cde3069f2e403b34bfee8a5", 5, 643464, 1397645},
{"4a857e2ee8aa9b6056f2424e84d24a72473378906ee04a46cb05311502d5250b82ad86b83c8f20a23dbb74f6da60b0b6ecffd67134d45946ac8ebfb3064294bc097d43ced68642bfb8bbbdd0f50b30118f5e", 82, "39d82eef32010b8b79cc5ba88ed539fbaba741100f2edbeca7cc171ffeabf258", 190, 758010, 5432947},
{"1845e375479537e9dd4f4486d5c91ac72775d66605eeb11a787b78a7745f1fd0052d526c67235dbae1b2a4d575a74cb551c8e9096c593a497aee74ba3047d911358ede57bc27c9ea1829824348daaab606217cc931dcb6627787bd6e4e5854f0e8", 97, "3ee91a805aa62cfbe8dce29a2d9a44373a5006f4a4ce24022aca9cecb29d1473", 212, 233177, 13101817},
{"c7b09aec680e7b42fedd7fc792e78b2f6c1bea8f4a884320b648f81e8cf515e8ba9dcfb11d43c4aae114c1734aa69ca82d44998365db9c93744fa28b63fd16000e8261cbbe083e7e2da1e5f696bde0834fe53146d7e0e35e7de9920d041f5a5621aabe02da3e2b09b405b77937efef3197bd5772e41fdb73fb5294478e45208063b5f58e089dbeb6d6342a909c1307b3fff5fe2cf4da56bdae50848f", 156, "039c056d933b475032777edbaffac50f143f64c123329ed9cf59e3b65d3f43b6", 178, 234753, 4886999},
{"8f3a06e2fd8711350a517bb12e31f3d3423e8dc0bb14aac8240fca0995938d59bb37bd0a7dfc9c9cc0705684b46612e8c8b1d6655fb0f9887562bb9899791a0250d1320f945eda48cdc20c233f40a5bb0a7e3ac5ad7250ce684f68fc0b8c9633bfd75aad116525af7bdcdbbdb4e00ab163fd4df08f243f12557e", 122, "90631f686a8c3dbc0703ffa353bc1fdf35774568ac62406f98a13ed8f47595fd", 55, 695191, 15738350},
{"b540beb016a5366524d4605156493f9874514a5aa58818cd0c6dfffaa9e90205f17b", 34, "44071f6d181561670bda728d43fb79b443bb805afdebaf98622b5165e01b15fb", 231, 78652, 6631659},
{"a14975c26c088755a8b715ff2528d647cd343987fcf4aa25e7194a8417fb2b4b3f7268da9f3182b4cfb22d138b2749d673a47ecc7525dd15a0a3c66046971784bb63d7eae24cc84f2631712075a10e10a96b0e0ee67c43e01c423cb9c44e5371017e9c496956b632158da3fe12addecb88912e6759bc37f9af2f45af72c5cae3b179ffb676a697de6ebe45cd4c16d4a9d642d29ddc0186a0a48cb6cd62bfc3dd229d313b301560971e740e2cf1f99a9a090a5b283f35475057e96d7064e2e0fc81984591068d55a3b4169f22cccb0745a2689407ea1901a0a766eb99", 220, "3d968b2752b8838431165059319f3ff8910b7b8ecb54ea01d3f54769e9d98daf", 167, 717248, 10784179},
};
char passwd[256];
{ "a347ae92bce9f80f6f595a4480fc9c2fe7e7d7148d371e9487d75f5c23008ffae0"
"65577a928febd9b1973a5a95073acdbeb6a030cfc0d79caa2dc5cd011cef02c08d"
"a232d76d52dfbca38ca8dcbd665b17d1665f7cf5fe59772ec909733b24de97d6f5"
"8d220b20c60d7c07ec1fd93c52c31020300c6c1facd77937a597c7a6",
127,
"5541fbc995d5c197ba290346d2c559dedf405cf97e5f95482143202f9e74f5c2",
155, 481326, 7256678 },
{ "e125cee61c8cb7778d9e5ad0a6f5d978ce9f84de213a8556d9ffe202020ab4a6ed"
"9074a4eb3416f9b168f137510f3a30b70b96cbfa219ff99f6c6eaffb15c06b60e0"
"0cc2890277f0fd3c622115772f7048adaebed86e",
86,
"f1192dd5dc2368b9cd421338b22433455ee0a3699f9379a08b9650ea2c126f0d",
250, 535778, 7849083 },
{ "92263cbf6ac376499f68a4289d3bb59e5a22335eba63a32e6410249155b956b6a3"
"b48d4a44906b18b897127300b375b8f834f1ceffc70880a885f47c33876717e392"
"be57f7da3ae58da4fd1f43daa7e44bb82d3717af4319349c24cd31e46d295856b0"
"441b6b289992a11ced1cc3bf3011604590244a3eb737ff221129215e4e4347f491"
"5d41292b5173d196eb9add693be5319fdadc242906178bb6c0286c9b6ca6012746"
"711f58c8c392016b2fdfc09c64f0f6b6ab7b",
183,
"3b840e20e9555e9fb031c4ba1f1747ce25cc1d0ff664be676b9b4a90641ff194",
249, 311757, 7994791 },
{ "027b6d8e8c8c474e9b69c7d9ed4f9971e8e1ce2f6ba95048414c3970f0f09b70e3"
"b6c5ae05872b3d8678705b7d381829c351a5a9c88c233569b35d6b0b809df44b64"
"51a9c273f1150e2ef8a0b5437eb701e373474cd44b97ef0248ebce2ca0400e1b53"
"f3d86221eca3f18eb45b702b9172440f774a82cbf1f6f525df30a6e293c873cce6"
"9bb078ed1f0d31e7f9b8062409f37f19f8550aae",
152,
"eb2a3056a09ad2d7d7f975bcd707598f24cd32518cde3069f2e403b34bfee8a5",
5, 643464, 1397645 },
{ "4a857e2ee8aa9b6056f2424e84d24a72473378906ee04a46cb05311502d5250b82"
"ad86b83c8f20a23dbb74f6da60b0b6ecffd67134d45946ac8ebfb3064294bc097d"
"43ced68642bfb8bbbdd0f50b30118f5e",
82,
"39d82eef32010b8b79cc5ba88ed539fbaba741100f2edbeca7cc171ffeabf258",
190, 758010, 5432947 },
{ "1845e375479537e9dd4f4486d5c91ac72775d66605eeb11a787b78a7745f1fd005"
"2d526c67235dbae1b2a4d575a74cb551c8e9096c593a497aee74ba3047d911358e"
"de57bc27c9ea1829824348daaab606217cc931dcb6627787bd6e4e5854f0e8",
97,
"3ee91a805aa62cfbe8dce29a2d9a44373a5006f4a4ce24022aca9cecb29d1473",
212, 233177, 13101817 },
{ "c7b09aec680e7b42fedd7fc792e78b2f6c1bea8f4a884320b648f81e8cf515e8ba"
"9dcfb11d43c4aae114c1734aa69ca82d44998365db9c93744fa28b63fd16000e82"
"61cbbe083e7e2da1e5f696bde0834fe53146d7e0e35e7de9920d041f5a5621aabe"
"02da3e2b09b405b77937efef3197bd5772e41fdb73fb5294478e45208063b5f58e"
"089dbeb6d6342a909c1307b3fff5fe2cf4da56bdae50848f",
156,
"039c056d933b475032777edbaffac50f143f64c123329ed9cf59e3b65d3f43b6",
178, 234753, 4886999 },
{ "8f3a06e2fd8711350a517bb12e31f3d3423e8dc0bb14aac8240fca0995938d59bb"
"37bd0a7dfc9c9cc0705684b46612e8c8b1d6655fb0f9887562bb9899791a0250d1"
"320f945eda48cdc20c233f40a5bb0a7e3ac5ad7250ce684f68fc0b8c9633bfd75a"
"ad116525af7bdcdbbdb4e00ab163fd4df08f243f12557e",
122,
"90631f686a8c3dbc0703ffa353bc1fdf35774568ac62406f98a13ed8f47595fd",
55, 695191, 15738350 },
{ "b540beb016a5366524d4605156493f9874514a5aa58818cd0c6dfffaa9e90205f1"
"7b",
34,
"44071f6d181561670bda728d43fb79b443bb805afdebaf98622b5165e01b15fb",
231, 78652, 6631659 },
{ "a14975c26c088755a8b715ff2528d647cd343987fcf4aa25e7194a8417fb2b4b3f"
"7268da9f3182b4cfb22d138b2749d673a47ecc7525dd15a0a3c66046971784bb63"
"d7eae24cc84f2631712075a10e10a96b0e0ee67c43e01c423cb9c44e5371017e9c"
"496956b632158da3fe12addecb88912e6759bc37f9af2f45af72c5cae3b179ffb6"
"76a697de6ebe45cd4c16d4a9d642d29ddc0186a0a48cb6cd62bfc3dd229d313b30"
"1560971e740e2cf1f99a9a090a5b283f35475057e96d7064e2e0fc81984591068d"
"55a3b4169f22cccb0745a2689407ea1901a0a766eb99",
220,
"3d968b2752b8838431165059319f3ff8910b7b8ecb54ea01d3f54769e9d98daf",
167, 717248, 10784179 },
};
char passwd[256];
unsigned char salt[crypto_pwhash_scryptsalsa208sha256_SALTBYTES];
unsigned char out[256];
char out_hex[256 * 2 + 1];
size_t i = 0U;
char out_hex[256 * 2 + 1];
size_t i = 0U;
do {
sodium_hex2bin((unsigned char *) passwd, sizeof passwd,
tests[i].passwd_hex, strlen(tests[i].passwd_hex),
NULL, NULL, NULL);
sodium_hex2bin(salt, sizeof salt,
tests[i].salt_hex, strlen(tests[i].salt_hex),
NULL, NULL, NULL);
if (crypto_pwhash_scryptsalsa208sha256(out, tests[i].outlen,
passwd, tests[i].passwdlen,
(const unsigned char *) salt,
tests[i].opslimit,
tests[i].memlimit) != 0) {
sodium_hex2bin((unsigned char *)passwd, sizeof passwd,
tests[i].passwd_hex, strlen(tests[i].passwd_hex), NULL,
NULL, NULL);
sodium_hex2bin(salt, sizeof salt, tests[i].salt_hex,
strlen(tests[i].salt_hex), NULL, NULL, NULL);
if (crypto_pwhash_scryptsalsa208sha256(
out, tests[i].outlen, passwd, tests[i].passwdlen,
(const unsigned char *)salt, tests[i].opslimit,
tests[i].memlimit) != 0) {
printf("pwhash failure\n");
}
sodium_bin2hex(out_hex, sizeof out_hex, out, tests[i].outlen);
@@ -51,26 +111,57 @@ static void tv(void)
static void tv2(void)
{
static struct {
const char *passwd;
const char *out;
const char *passwd;
const char *out;
} tests[] = {
{"^T5H$JYt39n%K*j:W]!1s?vg!:jGi]Ax?..l7[p0v:1jHTpla9;]bUN;?bWyCbtqg nrDFal+Jxl3,2`#^tFSu%v_+7iYse8-cCkNf!tD=KrW)", "$7$B6....1....75gBMAGwfFWZqBdyF3WdTQnWdUsuTiWjG1fF9c1jiSD$tc8RoB3.Em3/zNgMLWo2u00oGIoTyJv4fl3Fl8Tix72"},
{"bl72h6#y<':MFRZ>B IA1=NRkCKS%W8`1I.2uQxJN0g)N N aTt^4K!Iw5r H6;crDsv^a55j9tsk'/GqweZn;cdk6+F_St6:#*=?ZCD_lw>.", "$7$A6....3....Iahc6qM0.UQJHVgE4h9oa1/4OWlWLm9CCtfguvz6bQD$QnXCo3M7nIqtry2WKsUZ5gQ.mY0wAlJu.WUhtE8vF66"},
{"Py >e.5b+tLo@rL`dC2k@eJ&4eVl!W=JJ4+k&mAt@gt',FS1JjqKW3aq21:]^kna`mde7kVkN5NrpKUptu)@4*b&?BE_sJMG1=&@`3GBCV]Wg7xwgo7x3El", "$7$96..../....f6bEusKt79kK4wdYN0ki2nw4bJQ7P3rN6k3BSigsK/D$Dsvuw7vXj5xijmrb/NOhdgoyK/OiSIYv88cEtl9Cik7"},
{"2vj;Um]FKOL27oam(:Uo8+UmSTvb1FD*h?jk_,S=;RDgF-$Fjk?]9yvfxe@fN^!NN(Cuml?+2Raa", "$7$86....I....7XwIxLtCx4VphmFeUa6OGuGJrFaIaYzDiLNu/tyUPhD$U3q5GCEqCWxMwh.YQHDJrlg7FIZgViv9pcXE3h1vg61"},
{"CT=[9uUoGav,J`kU+348tA50ue#sL:ABZ3QgF+r[#vh:tTOiL>s8tv%,Jeo]jH/_4^i(*jD-_ku[9Ko[=86 06V", "$7$A6....2....R3.bjH6YS9wz9z8Jsj.3weGQ3J80ZZElGw2oVux1TP6$i5u6lFzXDHaIgYEICinLD6WNaovbiXP8SnLrDRdKgA9"},
{"J#wNn`hDgOpTHNI.w^1a70%f,.9V_m038H_JIJQln`vdWnn/rmILR?9H5g(+`;@H(2VosN9Fgk[WEjaBr'yB9Q19-imNa04[Mk5kvGcSn-TV", "$7$B6....1....Dj1y.4mF1J9XmT/6IDskYdCLaPFJTq9xcCwXQ1DpT92$92/hYfZLRq1nTLyIz.uc/dC6wLqwnsoqpkadrCXusm6"},
{"j4BS38Asa;p)[K+9TY!3YDj<LK-`nLVXQw9%*QfM", "$7$B6....1....5Ods8mojVwXJq4AywF/uI9BdMSiJ/zT8hQP/4cB68VC$nk4ExHNXJ802froj51/1wJTrSZvTIyyK7PecOxRRaz0"},
{"M.R>Qw+!qJb]>pP :_.9`dxM9k [eR7Y!yL-3)sNs[R,j_/^ TH=5ny'15>6UXWcQW^6D%XCsO[vN[%ReA-`tV1vW(Nt*0KVK#]45P_A", "$7$B6....1....D/eyk8N5y6Z8YVQEsw521cTx.9zzLuK7YDs1KMMh.o4$alfW8ZbsUWnXc.vqon2zoljVk24Tt1.IsCuo2KurvS2"},
{"K3S=KyH#)36_?]LxeR8QNKw6X=gFb'ai$C%29V* tyh^Wo$TN-#Q4qkmtTCf0LLb.^E$0uykkP", "$7$B6....1....CuBuU97xgAage8whp/JNKobo0TFbsORGVbfcQIefyP8$aqalP.XofGViB8EPLONqHma8vs1xc9uTIMYh9CgE.S8"},
{"Y0!?iQa9M%5ekffW(`", "$7$A6....1....TrXs5Zk6s8sWHpQgWDIXTR8kUU3s6Jc3s.DtdS8M2i4$a4ik5hGDN7foMuHOW.cp.CtX01UyCeO0.JAG.AHPpx5"},
};
{ "^T5H$JYt39n%K*j:W]!1s?vg!:jGi]Ax?..l7[p0v:1jHTpla9;]bUN;?bWyCbtqg "
"nrDFal+Jxl3,2`#^tFSu%v_+7iYse8-cCkNf!tD=KrW)",
"$7$B6....1....75gBMAGwfFWZqBdyF3WdTQnWdUsuTiWjG1fF9c1jiSD$tc8RoB3."
"Em3/zNgMLWo2u00oGIoTyJv4fl3Fl8Tix72" },
{ "bl72h6#y<':MFRZ>B IA1=NRkCKS%W8`1I.2uQxJN0g)N N aTt^4K!Iw5r "
"H6;crDsv^a55j9tsk'/GqweZn;cdk6+F_St6:#*=?ZCD_lw>.",
"$7$A6....3....Iahc6qM0.UQJHVgE4h9oa1/"
"4OWlWLm9CCtfguvz6bQD$QnXCo3M7nIqtry2WKsUZ5gQ.mY0wAlJu."
"WUhtE8vF66" },
{ "Py "
">e.5b+tLo@rL`dC2k@eJ&4eVl!W=JJ4+k&mAt@gt',FS1JjqKW3aq21:]^kna`"
"mde7kVkN5NrpKUptu)@4*b&?BE_sJMG1=&@`3GBCV]Wg7xwgo7x3El",
"$7$96..../....f6bEusKt79kK4wdYN0ki2nw4bJQ7P3rN6k3BSigsK/"
"D$Dsvuw7vXj5xijmrb/NOhdgoyK/OiSIYv88cEtl9Cik7" },
{ "2vj;Um]FKOL27oam(:Uo8+UmSTvb1FD*h?jk_,S=;RDgF-$Fjk?]9yvfxe@fN^!NN("
"Cuml?+2Raa",
"$7$86....I....7XwIxLtCx4VphmFeUa6OGuGJrFaIaYzDiLNu/"
"tyUPhD$U3q5GCEqCWxMwh.YQHDJrlg7FIZgViv9pcXE3h1vg61" },
{ "CT=[9uUoGav,J`kU+348tA50ue#sL:ABZ3QgF+r[#vh:tTOiL>s8tv%,Jeo]jH/"
"_4^i(*jD-_ku[9Ko[=86 06V",
"$7$A6....2....R3.bjH6YS9wz9z8Jsj.3weGQ3J80ZZElGw2oVux1TP6$"
"i5u6lFzXDHaIgYEICinLD6WNaovbiXP8SnLrDRdKgA9" },
{ "J#wNn`hDgOpTHNI.w^1a70%f,.9V_m038H_JIJQln`vdWnn/"
"rmILR?9H5g(+`;@H(2VosN9Fgk[WEjaBr'yB9Q19-imNa04[Mk5kvGcSn-TV",
"$7$B6....1....Dj1y.4mF1J9XmT/6IDskYdCLaPFJTq9xcCwXQ1DpT92$92/"
"hYfZLRq1nTLyIz.uc/dC6wLqwnsoqpkadrCXusm6" },
{ "j4BS38Asa;p)[K+9TY!3YDj<LK-`nLVXQw9%*QfM",
"$7$B6....1....5Ods8mojVwXJq4AywF/uI9BdMSiJ/zT8hQP/"
"4cB68VC$nk4ExHNXJ802froj51/1wJTrSZvTIyyK7PecOxRRaz0" },
{ "M.R>Qw+!qJb]>pP :_.9`dxM9k [eR7Y!yL-3)sNs[R,j_/^ "
"TH=5ny'15>6UXWcQW^6D%XCsO[vN[%ReA-`tV1vW(Nt*0KVK#]45P_A",
"$7$B6....1....D/"
"eyk8N5y6Z8YVQEsw521cTx.9zzLuK7YDs1KMMh.o4$alfW8ZbsUWnXc."
"vqon2zoljVk24Tt1.IsCuo2KurvS2" },
{ "K3S=KyH#)36_?]LxeR8QNKw6X=gFb'ai$C%29V* "
"tyh^Wo$TN-#Q4qkmtTCf0LLb.^E$0uykkP",
"$7$B6....1....CuBuU97xgAage8whp/"
"JNKobo0TFbsORGVbfcQIefyP8$aqalP."
"XofGViB8EPLONqHma8vs1xc9uTIMYh9CgE.S8" },
{ "Y0!?iQa9M%5ekffW(`",
"$7$A6....1....TrXs5Zk6s8sWHpQgWDIXTR8kUU3s6Jc3s.DtdS8M2i4$"
"a4ik5hGDN7foMuHOW.cp.CtX01UyCeO0.JAG.AHPpx5" },
};
size_t i = 0U;
do {
if (crypto_pwhash_scryptsalsa208sha256_str_verify(tests[i].out,
tests[i].passwd,
strlen(tests[i].passwd)) != 0) {
if (crypto_pwhash_scryptsalsa208sha256_str_verify(
tests[i].out, tests[i].passwd, strlen(tests[i].passwd)) != 0) {
printf("pwhash_str failure\n");
}
} while (++i < (sizeof tests) / (sizeof tests[0]));
@@ -82,39 +173,39 @@ static void tv2(void)
int main(void)
{
char str_out[crypto_pwhash_scryptsalsa208sha256_STRBYTES];
char str_out2[crypto_pwhash_scryptsalsa208sha256_STRBYTES];
unsigned char out[OUT_LEN];
char out_hex[OUT_LEN * 2 + 1];
const char *salt = "[<~A 32-bytes salt for scrypt~>]";
const char *passwd = "Correct Horse Battery Staple";
size_t i;
char str_out[crypto_pwhash_scryptsalsa208sha256_STRBYTES];
char str_out2[crypto_pwhash_scryptsalsa208sha256_STRBYTES];
unsigned char out[OUT_LEN];
char out_hex[OUT_LEN * 2 + 1];
const char *salt = "[<~A 32-bytes salt for scrypt~>]";
const char *passwd = "Correct Horse Battery Staple";
size_t i;
tv();
tv2();
if (crypto_pwhash_scryptsalsa208sha256_str(str_out, passwd, strlen(passwd),
OPSLIMIT, MEMLIMIT) != 0) {
OPSLIMIT, MEMLIMIT) != 0) {
printf("pwhash_str failure\n");
}
if (crypto_pwhash_scryptsalsa208sha256_str(str_out2, passwd, strlen(passwd),
OPSLIMIT, MEMLIMIT) != 0) {
OPSLIMIT, MEMLIMIT) != 0) {
printf("pwhash_str(2) failure\n");
}
if (strcmp(str_out, str_out2) == 0) {
printf("pwhash_str doesn't generate different salts\n");
}
if (crypto_pwhash_scryptsalsa208sha256_str_verify(str_out, passwd,
strlen(passwd)) != 0) {
strlen(passwd)) != 0) {
printf("pwhash_str_verify failure\n");
}
if (crypto_pwhash_scryptsalsa208sha256_str_verify(str_out, passwd,
strlen(passwd)) != 0) {
strlen(passwd)) != 0) {
printf("pwhash_str_verify failure\n");
}
for (i = 14U; i < sizeof str_out; i++) {
str_out[i]++;
if (crypto_pwhash_scryptsalsa208sha256_str_verify(str_out, passwd,
strlen(passwd)) == 0) {
if (crypto_pwhash_scryptsalsa208sha256_str_verify(
str_out, passwd, strlen(passwd)) == 0) {
printf("pwhash_str_verify(2) failure\n");
}
str_out[i]--;
test/default/pwhash_scrypt_ll.c
+30 -33
View File
@@ -6,47 +6,44 @@
static const char *password1 = "";
static const char *salt1 = "";
static uint64_t N1 = 16U;
static uint32_t r1 = 1U;
static uint32_t p1 = 1U;
static uint64_t N1 = 16U;
static uint32_t r1 = 1U;
static uint32_t p1 = 1U;
static const char *password2 = "password";
static const char *salt2 = "NaCl";
static uint64_t N2 = 1024U;
static uint32_t r2 = 8U;
static uint32_t p2 = 16U;
static uint64_t N2 = 1024U;
static uint32_t r2 = 8U;
static uint32_t p2 = 16U;
static const char *password3 = "pleaseletmein";
static const char *salt3 = "SodiumChloride";
static uint64_t N3 = 16384U;
static uint32_t r3 = 8U;
static uint32_t p3 = 1U;
static const char *salt3 = "SodiumChloride";
static uint64_t N3 = 16384U;
static uint32_t r3 = 8U;
static uint32_t p3 = 1U;
static void test_vector(const char *password, const char *salt,
uint64_t N, uint32_t r, uint32_t p)
static void test_vector(const char *password, const char *salt, uint64_t N,
uint32_t r, uint32_t p)
{
uint8_t data[64];
size_t i;
size_t olen = (sizeof data / sizeof data[0]);
size_t passwordLength = strlen(password);
size_t saltLenght = strlen(salt);
int lineitems = 0;
int lineitemsLimit = 15;
size_t i;
size_t olen = (sizeof data / sizeof data[0]);
size_t passwordLength = strlen(password);
size_t saltLenght = strlen(salt);
int lineitems = 0;
int lineitemsLimit = 15;
if (crypto_pwhash_scryptsalsa208sha256_ll((const uint8_t *) password,
passwordLength,
(const uint8_t *) salt,
saltLenght,
N, r, p, data, olen) != 0) {
printf("pwhash_scryptsalsa208sha256_ll([%s],[%s]) failure\n",
password, salt);
if (crypto_pwhash_scryptsalsa208sha256_ll(
(const uint8_t *)password, passwordLength, (const uint8_t *)salt,
saltLenght, N, r, p, data, olen) != 0) {
printf("pwhash_scryptsalsa208sha256_ll([%s],[%s]) failure\n", password,
salt);
return;
}
printf("scrypt('%s', '%s', %llu, %lu, %lu, %lu) =\n",
password, salt,
(unsigned long long) N, (unsigned long) r, (unsigned long) p,
(unsigned long) olen);
printf("scrypt('%s', '%s', %llu, %lu, %lu, %lu) =\n", password, salt,
(unsigned long long)N, (unsigned long)r, (unsigned long)p,
(unsigned long)olen);
for (i = 0; i < olen; ++i) {
printf("%02x%c", data[i], lineitems < lineitemsLimit ? ' ' : '\n');
@@ -56,9 +53,9 @@ static void test_vector(const char *password, const char *salt,
int main(void)
{
test_vector(password1, salt1, N1, r1, p1);
test_vector(password2, salt2, N2, r2, p2);
test_vector(password3, salt3, N3, r3, p3);
test_vector(password1, salt1, N1, r1, p1);
test_vector(password2, salt2, N2, r2, p2);
test_vector(password3, salt3, N3, r3, p3);
return 0;
return 0;
}
test/default/randombytes.c
+12 -6
View File
@@ -3,21 +3,27 @@
unsigned char x[65536];
unsigned long long freq[256];
int main(void)
static int nacl_tests(void)
{
unsigned long long i;
randombytes(x,sizeof x);
for (i = 0;i < 256;++i) {
randombytes(x, sizeof x);
for (i = 0; i < 256; ++i) {
freq[i] = 0;
}
for (i = 0;i < sizeof x;++i) {
++freq[255 & (int) x[i]];
for (i = 0; i < sizeof x; ++i) {
++freq[255 & (int)x[i]];
}
for (i = 0;i < 256;++i) {
for (i = 0; i < 256; ++i) {
if (!freq[i]) {
return 111;
}
}
}
int main(void)
{
nacl_tests();
return 0;
}
test/default/scalarmult.c
+9 -10
View File
@@ -2,12 +2,10 @@
#define TEST_NAME "scalarmult"
#include "cmptest.h"
unsigned char alicesk[32] = {
0x77,0x07,0x6d,0x0a,0x73,0x18,0xa5,0x7d
,0x3c,0x16,0xc1,0x72,0x51,0xb2,0x66,0x45
,0xdf,0x4c,0x2f,0x87,0xeb,0xc0,0x99,0x2a
,0xb1,0x77,0xfb,0xa5,0x1d,0xb9,0x2c,0x2a
} ;
unsigned char alicesk[32]
= { 0x77, 0x07, 0x6d, 0x0a, 0x73, 0x18, 0xa5, 0x7d, 0x3c, 0x16, 0xc1,
0x72, 0x51, 0xb2, 0x66, 0x45, 0xdf, 0x4c, 0x2f, 0x87, 0xeb, 0xc0,
0x99, 0x2a, 0xb1, 0x77, 0xfb, 0xa5, 0x1d, 0xb9, 0x2c, 0x2a };
unsigned char alicepk[32];
@@ -15,15 +13,15 @@ int main(void)
{
int i;
crypto_scalarmult_base(alicepk,alicesk);
crypto_scalarmult_base(alicepk, alicesk);
for (i = 0;i < 32;++i) {
for (i = 0; i < 32; ++i) {
if (i > 0) {
printf(",");
} else {
printf(" ");
}
printf("0x%02x",(unsigned int) alicepk[i]);
printf("0x%02x", (unsigned int)alicepk[i]);
if (i % 8 == 7) {
printf("\n");
}
@@ -32,7 +30,8 @@ int main(void)
assert(crypto_scalarmult_scalarbytes() > 0U);
assert(strcmp(crypto_scalarmult_primitive(), "curve25519") == 0);
assert(crypto_scalarmult_bytes() == crypto_scalarmult_curve25519_bytes());
assert(crypto_scalarmult_scalarbytes() == crypto_scalarmult_curve25519_scalarbytes());
assert(crypto_scalarmult_scalarbytes()
== crypto_scalarmult_curve25519_scalarbytes());
assert(crypto_scalarmult_bytes() == crypto_scalarmult_scalarbytes());
return 0;
test/default/scalarmult2.c
+7 -9
View File
@@ -2,12 +2,10 @@
#define TEST_NAME "scalarmult2"
#include "cmptest.h"
unsigned char bobsk[32] = {
0x5d,0xab,0x08,0x7e,0x62,0x4a,0x8a,0x4b
,0x79,0xe1,0x7f,0x8b,0x83,0x80,0x0e,0xe6
,0x6f,0x3b,0xb1,0x29,0x26,0x18,0xb6,0xfd
,0x1c,0x2f,0x8b,0x27,0xff,0x88,0xe0,0xeb
} ;
unsigned char bobsk[32]
= { 0x5d, 0xab, 0x08, 0x7e, 0x62, 0x4a, 0x8a, 0x4b, 0x79, 0xe1, 0x7f,
0x8b, 0x83, 0x80, 0x0e, 0xe6, 0x6f, 0x3b, 0xb1, 0x29, 0x26, 0x18,
0xb6, 0xfd, 0x1c, 0x2f, 0x8b, 0x27, 0xff, 0x88, 0xe0, 0xeb };
unsigned char bobpk[32];
@@ -15,15 +13,15 @@ int main(void)
{
int i;
crypto_scalarmult_base(bobpk,bobsk);
crypto_scalarmult_base(bobpk, bobsk);
for (i = 0;i < 32;++i) {
for (i = 0; i < 32; ++i) {
if (i > 0) {
printf(",");
} else {
printf(" ");
}
printf("0x%02x",(unsigned int) bobpk[i]);
printf("0x%02x", (unsigned int)bobpk[i]);
if (i % 8 == 7) {
printf("\n");
}
test/default/scalarmult5.c
+11 -15
View File
@@ -2,19 +2,15 @@
#define TEST_NAME "scalarmult5"
#include "cmptest.h"
unsigned char alicesk[32] = {
0x77,0x07,0x6d,0x0a,0x73,0x18,0xa5,0x7d
,0x3c,0x16,0xc1,0x72,0x51,0xb2,0x66,0x45
,0xdf,0x4c,0x2f,0x87,0xeb,0xc0,0x99,0x2a
,0xb1,0x77,0xfb,0xa5,0x1d,0xb9,0x2c,0x2a
} ;
unsigned char alicesk[32]
= { 0x77, 0x07, 0x6d, 0x0a, 0x73, 0x18, 0xa5, 0x7d, 0x3c, 0x16, 0xc1,
0x72, 0x51, 0xb2, 0x66, 0x45, 0xdf, 0x4c, 0x2f, 0x87, 0xeb, 0xc0,
0x99, 0x2a, 0xb1, 0x77, 0xfb, 0xa5, 0x1d, 0xb9, 0x2c, 0x2a };
unsigned char bobpk[32] = {
0xde,0x9e,0xdb,0x7d,0x7b,0x7d,0xc1,0xb4
,0xd3,0x5b,0x61,0xc2,0xec,0xe4,0x35,0x37
,0x3f,0x83,0x43,0xc8,0x5b,0x78,0x67,0x4d
,0xad,0xfc,0x7e,0x14,0x6f,0x88,0x2b,0x4f
} ;
unsigned char bobpk[32]
= { 0xde, 0x9e, 0xdb, 0x7d, 0x7b, 0x7d, 0xc1, 0xb4, 0xd3, 0x5b, 0x61,
0xc2, 0xec, 0xe4, 0x35, 0x37, 0x3f, 0x83, 0x43, 0xc8, 0x5b, 0x78,
0x67, 0x4d, 0xad, 0xfc, 0x7e, 0x14, 0x6f, 0x88, 0x2b, 0x4f };
unsigned char k[32];
@@ -22,15 +18,15 @@ int main(void)
{
int i;
crypto_scalarmult(k,alicesk,bobpk);
crypto_scalarmult(k, alicesk, bobpk);
for (i = 0;i < 32;++i) {
for (i = 0; i < 32; ++i) {
if (i > 0) {
printf(",");
} else {
printf(" ");
}
printf("0x%02x",(unsigned int) k[i]);
printf("0x%02x", (unsigned int)k[i]);
if (i % 8 == 7) {
printf("\n");
}
test/default/scalarmult6.c
+11 -15
View File
@@ -2,19 +2,15 @@
#define TEST_NAME "scalarmult6"
#include "cmptest.h"
unsigned char bobsk[32] = {
0x5d,0xab,0x08,0x7e,0x62,0x4a,0x8a,0x4b
,0x79,0xe1,0x7f,0x8b,0x83,0x80,0x0e,0xe6
,0x6f,0x3b,0xb1,0x29,0x26,0x18,0xb6,0xfd
,0x1c,0x2f,0x8b,0x27,0xff,0x88,0xe0,0xeb
} ;
unsigned char bobsk[32]
= { 0x5d, 0xab, 0x08, 0x7e, 0x62, 0x4a, 0x8a, 0x4b, 0x79, 0xe1, 0x7f,
0x8b, 0x83, 0x80, 0x0e, 0xe6, 0x6f, 0x3b, 0xb1, 0x29, 0x26, 0x18,
0xb6, 0xfd, 0x1c, 0x2f, 0x8b, 0x27, 0xff, 0x88, 0xe0, 0xeb };
unsigned char alicepk[32] = {
0x85,0x20,0xf0,0x09,0x89,0x30,0xa7,0x54
,0x74,0x8b,0x7d,0xdc,0xb4,0x3e,0xf7,0x5a
,0x0d,0xbf,0x3a,0x0d,0x26,0x38,0x1a,0xf4
,0xeb,0xa4,0xa9,0x8e,0xaa,0x9b,0x4e,0x6a
} ;
unsigned char alicepk[32]
= { 0x85, 0x20, 0xf0, 0x09, 0x89, 0x30, 0xa7, 0x54, 0x74, 0x8b, 0x7d,
0xdc, 0xb4, 0x3e, 0xf7, 0x5a, 0x0d, 0xbf, 0x3a, 0x0d, 0x26, 0x38,
0x1a, 0xf4, 0xeb, 0xa4, 0xa9, 0x8e, 0xaa, 0x9b, 0x4e, 0x6a };
unsigned char k[32];
@@ -22,15 +18,15 @@ int main(void)
{
int i;
crypto_scalarmult(k,bobsk,alicepk);
crypto_scalarmult(k, bobsk, alicepk);
for (i = 0;i < 32;++i) {
for (i = 0; i < 32; ++i) {
if (i > 0) {
printf(",");
} else {
printf(" ");
}
printf("0x%02x",(unsigned int) k[i]);
printf("0x%02x", (unsigned int)k[i]);
if (i % 8 == 7) {
printf("\n");
}
test/default/secretbox.c
+37 -43
View File
@@ -2,43 +2,31 @@
#define TEST_NAME "secretbox"
#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 };
// API requires first 32 bytes to be 0
unsigned char m[163] = {
0, 0, 0, 0, 0, 0, 0, 0
, 0, 0, 0, 0, 0, 0, 0, 0
, 0, 0, 0, 0, 0, 0, 0, 0
, 0, 0, 0, 0, 0, 0, 0, 0
,0xbe,0x07,0x5f,0xc5,0x3c,0x81,0xf2,0xd5
,0xcf,0x14,0x13,0x16,0xeb,0xeb,0x0c,0x7b
,0x52,0x28,0xc5,0x2a,0x4c,0x62,0xcb,0xd4
,0x4b,0x66,0x84,0x9b,0x64,0x24,0x4f,0xfc
,0xe5,0xec,0xba,0xaf,0x33,0xbd,0x75,0x1a
,0x1a,0xc7,0x28,0xd4,0x5e,0x6c,0x61,0x29
,0x6c,0xdc,0x3c,0x01,0x23,0x35,0x61,0xf4
,0x1d,0xb6,0x6c,0xce,0x31,0x4a,0xdb,0x31
,0x0e,0x3b,0xe8,0x25,0x0c,0x46,0xf0,0x6d
,0xce,0xea,0x3a,0x7f,0xa1,0x34,0x80,0x57
,0xe2,0xf6,0x55,0x6a,0xd6,0xb1,0x31,0x8a
,0x02,0x4a,0x83,0x8f,0x21,0xaf,0x1f,0xde
,0x04,0x89,0x77,0xeb,0x48,0xf5,0x9f,0xfd
,0x49,0x24,0xca,0x1c,0x60,0x90,0x2e,0x52
,0xf0,0xa0,0x89,0xbc,0x76,0x89,0x70,0x40
,0xe0,0x82,0xf9,0x37,0x76,0x38,0x48,0x64
,0x5e,0x07,0x05
} ;
unsigned char m[163]
= { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0xbe, 0x07, 0x5f, 0xc5,
0x3c, 0x81, 0xf2, 0xd5, 0xcf, 0x14, 0x13, 0x16, 0xeb, 0xeb, 0x0c, 0x7b,
0x52, 0x28, 0xc5, 0x2a, 0x4c, 0x62, 0xcb, 0xd4, 0x4b, 0x66, 0x84, 0x9b,
0x64, 0x24, 0x4f, 0xfc, 0xe5, 0xec, 0xba, 0xaf, 0x33, 0xbd, 0x75, 0x1a,
0x1a, 0xc7, 0x28, 0xd4, 0x5e, 0x6c, 0x61, 0x29, 0x6c, 0xdc, 0x3c, 0x01,
0x23, 0x35, 0x61, 0xf4, 0x1d, 0xb6, 0x6c, 0xce, 0x31, 0x4a, 0xdb, 0x31,
0x0e, 0x3b, 0xe8, 0x25, 0x0c, 0x46, 0xf0, 0x6d, 0xce, 0xea, 0x3a, 0x7f,
0xa1, 0x34, 0x80, 0x57, 0xe2, 0xf6, 0x55, 0x6a, 0xd6, 0xb1, 0x31, 0x8a,
0x02, 0x4a, 0x83, 0x8f, 0x21, 0xaf, 0x1f, 0xde, 0x04, 0x89, 0x77, 0xeb,
0x48, 0xf5, 0x9f, 0xfd, 0x49, 0x24, 0xca, 0x1c, 0x60, 0x90, 0x2e, 0x52,
0xf0, 0xa0, 0x89, 0xbc, 0x76, 0x89, 0x70, 0x40, 0xe0, 0x82, 0xf9, 0x37,
0x76, 0x38, 0x48, 0x64, 0x5e, 0x07, 0x05 };
unsigned char c[163];
@@ -46,10 +34,11 @@ int main(void)
{
int i;
crypto_secretbox(c,m,163,nonce,firstkey);
for (i = 16;i < 163;++i) {
printf(",0x%02x",(unsigned int) c[i]);
if (i % 8 == 7) printf("\n");
crypto_secretbox(c, m, 163, nonce, firstkey);
for (i = 16; i < 163; ++i) {
printf(",0x%02x", (unsigned int)c[i]);
if (i % 8 == 7)
printf("\n");
}
printf("\n");
@@ -59,11 +48,16 @@ int main(void)
assert(crypto_secretbox_boxzerobytes() > 0U);
assert(crypto_secretbox_macbytes() > 0U);
assert(strcmp(crypto_secretbox_primitive(), "xsalsa20poly1305") == 0);
assert(crypto_secretbox_keybytes() == crypto_secretbox_xsalsa20poly1305_keybytes());
assert(crypto_secretbox_noncebytes() == crypto_secretbox_xsalsa20poly1305_noncebytes());
assert(crypto_secretbox_zerobytes() == crypto_secretbox_xsalsa20poly1305_zerobytes());
assert(crypto_secretbox_boxzerobytes() == crypto_secretbox_xsalsa20poly1305_boxzerobytes());
assert(crypto_secretbox_macbytes() == crypto_secretbox_xsalsa20poly1305_macbytes());
assert(crypto_secretbox_keybytes()
== crypto_secretbox_xsalsa20poly1305_keybytes());
assert(crypto_secretbox_noncebytes()
== crypto_secretbox_xsalsa20poly1305_noncebytes());
assert(crypto_secretbox_zerobytes()
== crypto_secretbox_xsalsa20poly1305_zerobytes());
assert(crypto_secretbox_boxzerobytes()
== crypto_secretbox_xsalsa20poly1305_boxzerobytes());
assert(crypto_secretbox_macbytes()
== crypto_secretbox_xsalsa20poly1305_macbytes());
return 0;
}
test/default/secretbox2.c
+27 -38
View File
@@ -2,43 +2,31 @@
#define TEST_NAME "secretbox2"
#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 };
// API requires first 16 bytes to be 0
unsigned char c[163] = {
0, 0, 0, 0, 0, 0, 0, 0
, 0, 0, 0, 0, 0, 0, 0, 0
,0xf3,0xff,0xc7,0x70,0x3f,0x94,0x00,0xe5
,0x2a,0x7d,0xfb,0x4b,0x3d,0x33,0x05,0xd9
,0x8e,0x99,0x3b,0x9f,0x48,0x68,0x12,0x73
,0xc2,0x96,0x50,0xba,0x32,0xfc,0x76,0xce
,0x48,0x33,0x2e,0xa7,0x16,0x4d,0x96,0xa4
,0x47,0x6f,0xb8,0xc5,0x31,0xa1,0x18,0x6a
,0xc0,0xdf,0xc1,0x7c,0x98,0xdc,0xe8,0x7b
,0x4d,0xa7,0xf0,0x11,0xec,0x48,0xc9,0x72
,0x71,0xd2,0xc2,0x0f,0x9b,0x92,0x8f,0xe2
,0x27,0x0d,0x6f,0xb8,0x63,0xd5,0x17,0x38
,0xb4,0x8e,0xee,0xe3,0x14,0xa7,0xcc,0x8a
,0xb9,0x32,0x16,0x45,0x48,0xe5,0x26,0xae
,0x90,0x22,0x43,0x68,0x51,0x7a,0xcf,0xea
,0xbd,0x6b,0xb3,0x73,0x2b,0xc0,0xe9,0xda
,0x99,0x83,0x2b,0x61,0xca,0x01,0xb6,0xde
,0x56,0x24,0x4a,0x9e,0x88,0xd5,0xf9,0xb3
,0x79,0x73,0xf6,0x22,0xa4,0x3d,0x14,0xa6
,0x59,0x9b,0x1f,0x65,0x4c,0xb4,0x5a,0x74
,0xe3,0x55,0xa5
} ;
unsigned char c[163]
= { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0xf3, 0xff, 0xc7, 0x70, 0x3f, 0x94, 0x00, 0xe5,
0x2a, 0x7d, 0xfb, 0x4b, 0x3d, 0x33, 0x05, 0xd9, 0x8e, 0x99, 0x3b, 0x9f,
0x48, 0x68, 0x12, 0x73, 0xc2, 0x96, 0x50, 0xba, 0x32, 0xfc, 0x76, 0xce,
0x48, 0x33, 0x2e, 0xa7, 0x16, 0x4d, 0x96, 0xa4, 0x47, 0x6f, 0xb8, 0xc5,
0x31, 0xa1, 0x18, 0x6a, 0xc0, 0xdf, 0xc1, 0x7c, 0x98, 0xdc, 0xe8, 0x7b,
0x4d, 0xa7, 0xf0, 0x11, 0xec, 0x48, 0xc9, 0x72, 0x71, 0xd2, 0xc2, 0x0f,
0x9b, 0x92, 0x8f, 0xe2, 0x27, 0x0d, 0x6f, 0xb8, 0x63, 0xd5, 0x17, 0x38,
0xb4, 0x8e, 0xee, 0xe3, 0x14, 0xa7, 0xcc, 0x8a, 0xb9, 0x32, 0x16, 0x45,
0x48, 0xe5, 0x26, 0xae, 0x90, 0x22, 0x43, 0x68, 0x51, 0x7a, 0xcf, 0xea,
0xbd, 0x6b, 0xb3, 0x73, 0x2b, 0xc0, 0xe9, 0xda, 0x99, 0x83, 0x2b, 0x61,
0xca, 0x01, 0xb6, 0xde, 0x56, 0x24, 0x4a, 0x9e, 0x88, 0xd5, 0xf9, 0xb3,
0x79, 0x73, 0xf6, 0x22, 0xa4, 0x3d, 0x14, 0xa6, 0x59, 0x9b, 0x1f, 0x65,
0x4c, 0xb4, 0x5a, 0x74, 0xe3, 0x55, 0xa5 };
unsigned char m[163];
@@ -46,10 +34,11 @@ int main(void)
{
int i;
if (crypto_secretbox_open(m,c,163,nonce,firstkey) == 0) {
for (i = 32;i < 163;++i) {
printf(",0x%02x",(unsigned int) m[i]);
if (i % 8 == 7) printf("\n");
if (crypto_secretbox_open(m, c, 163, nonce, firstkey) == 0) {
for (i = 32; i < 163; ++i) {
printf(",0x%02x", (unsigned int)m[i]);
if (i % 8 == 7)
printf("\n");
}
printf("\n");
}
test/default/secretbox7.c
+9 -7
View File
@@ -13,13 +13,15 @@ int main(void)
size_t mlen;
size_t i;
for (mlen = 0;mlen < 1000 && mlen + crypto_secretbox_ZEROBYTES < sizeof m;++mlen) {
randombytes(k,crypto_secretbox_KEYBYTES);
randombytes(n,crypto_secretbox_NONCEBYTES);
randombytes(m + crypto_secretbox_ZEROBYTES,mlen);
crypto_secretbox(c,m,mlen + crypto_secretbox_ZEROBYTES,n,k);
if (crypto_secretbox_open(m2,c,mlen + crypto_secretbox_ZEROBYTES,n,k) == 0) {
for (i = 0;i < mlen + crypto_secretbox_ZEROBYTES;++i) {
for (mlen = 0; mlen < 1000 && mlen + crypto_secretbox_ZEROBYTES < sizeof m;
++mlen) {
randombytes_buf(k, crypto_secretbox_KEYBYTES);
randombytes_buf(n, crypto_secretbox_NONCEBYTES);
randombytes_buf(m + crypto_secretbox_ZEROBYTES, mlen);
crypto_secretbox(c, m, mlen + crypto_secretbox_ZEROBYTES, n, k);
if (crypto_secretbox_open(m2, c, mlen + crypto_secretbox_ZEROBYTES, n,
k) == 0) {
for (i = 0; i < mlen + crypto_secretbox_ZEROBYTES; ++i) {
if (m2[i] != m[i]) {
printf("bad decryption\n");
break;
test/default/secretbox8.c
+9 -7
View File
@@ -16,16 +16,18 @@ int main(void)
size_t i;
int caught;
for (mlen = 0;mlen < 1000 && mlen + crypto_secretbox_ZEROBYTES < sizeof m;++mlen) {
randombytes(k,crypto_secretbox_KEYBYTES);
randombytes(n,crypto_secretbox_NONCEBYTES);
randombytes(m + crypto_secretbox_ZEROBYTES,mlen);
crypto_secretbox(c,m,mlen + crypto_secretbox_ZEROBYTES,n,k);
for (mlen = 0; mlen < 1000 && mlen + crypto_secretbox_ZEROBYTES < sizeof m;
++mlen) {
randombytes_buf(k, crypto_secretbox_KEYBYTES);
randombytes_buf(n, crypto_secretbox_NONCEBYTES);
randombytes_buf(m + crypto_secretbox_ZEROBYTES, mlen);
crypto_secretbox(c, m, mlen + crypto_secretbox_ZEROBYTES, n, k);
caught = 0;
while (caught < 10) {
c[rand() % (mlen + crypto_secretbox_ZEROBYTES)] = rand();
if (crypto_secretbox_open(m2,c,mlen + crypto_secretbox_ZEROBYTES,n,k) == 0) {
for (i = 0;i < mlen + crypto_secretbox_ZEROBYTES;++i) {
if (crypto_secretbox_open(m2, c, mlen + crypto_secretbox_ZEROBYTES,
n, k) == 0) {
for (i = 0; i < mlen + crypto_secretbox_ZEROBYTES; ++i) {
if (m2[i] != m[i]) {
printf("forgery\n");
return 100;
test/default/secretbox_easy.c
+31 -39
View File
@@ -2,38 +2,27 @@
#define TEST_NAME "secretbox_easy"
#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 m[131] = {
0xbe,0x07,0x5f,0xc5,0x3c,0x81,0xf2,0xd5
,0xcf,0x14,0x13,0x16,0xeb,0xeb,0x0c,0x7b
,0x52,0x28,0xc5,0x2a,0x4c,0x62,0xcb,0xd4
,0x4b,0x66,0x84,0x9b,0x64,0x24,0x4f,0xfc
,0xe5,0xec,0xba,0xaf,0x33,0xbd,0x75,0x1a
,0x1a,0xc7,0x28,0xd4,0x5e,0x6c,0x61,0x29
,0x6c,0xdc,0x3c,0x01,0x23,0x35,0x61,0xf4
,0x1d,0xb6,0x6c,0xce,0x31,0x4a,0xdb,0x31
,0x0e,0x3b,0xe8,0x25,0x0c,0x46,0xf0,0x6d
,0xce,0xea,0x3a,0x7f,0xa1,0x34,0x80,0x57
,0xe2,0xf6,0x55,0x6a,0xd6,0xb1,0x31,0x8a
,0x02,0x4a,0x83,0x8f,0x21,0xaf,0x1f,0xde
,0x04,0x89,0x77,0xeb,0x48,0xf5,0x9f,0xfd
,0x49,0x24,0xca,0x1c,0x60,0x90,0x2e,0x52
,0xf0,0xa0,0x89,0xbc,0x76,0x89,0x70,0x40
,0xe0,0x82,0xf9,0x37,0x76,0x38,0x48,0x64
,0x5e,0x07,0x05
} ;
unsigned char m[131]
= { 0xbe, 0x07, 0x5f, 0xc5, 0x3c, 0x81, 0xf2, 0xd5, 0xcf, 0x14, 0x13, 0x16,
0xeb, 0xeb, 0x0c, 0x7b, 0x52, 0x28, 0xc5, 0x2a, 0x4c, 0x62, 0xcb, 0xd4,
0x4b, 0x66, 0x84, 0x9b, 0x64, 0x24, 0x4f, 0xfc, 0xe5, 0xec, 0xba, 0xaf,
0x33, 0xbd, 0x75, 0x1a, 0x1a, 0xc7, 0x28, 0xd4, 0x5e, 0x6c, 0x61, 0x29,
0x6c, 0xdc, 0x3c, 0x01, 0x23, 0x35, 0x61, 0xf4, 0x1d, 0xb6, 0x6c, 0xce,
0x31, 0x4a, 0xdb, 0x31, 0x0e, 0x3b, 0xe8, 0x25, 0x0c, 0x46, 0xf0, 0x6d,
0xce, 0xea, 0x3a, 0x7f, 0xa1, 0x34, 0x80, 0x57, 0xe2, 0xf6, 0x55, 0x6a,
0xd6, 0xb1, 0x31, 0x8a, 0x02, 0x4a, 0x83, 0x8f, 0x21, 0xaf, 0x1f, 0xde,
0x04, 0x89, 0x77, 0xeb, 0x48, 0xf5, 0x9f, 0xfd, 0x49, 0x24, 0xca, 0x1c,
0x60, 0x90, 0x2e, 0x52, 0xf0, 0xa0, 0x89, 0xbc, 0x76, 0x89, 0x70, 0x40,
0xe0, 0x82, 0xf9, 0x37, 0x76, 0x38, 0x48, 0x64, 0x5e, 0x07, 0x05 };
unsigned char c[147 + crypto_secretbox_MACBYTES];
unsigned char mac[crypto_secretbox_MACBYTES];
@@ -43,20 +32,23 @@ int main(void)
size_t i;
crypto_secretbox_easy(c, m, 131, nonce, firstkey);
for (i = 0;i < 131 + crypto_secretbox_MACBYTES; ++i) {
printf(",0x%02x",(unsigned int) c[i]);
if (i % 8 == 7) printf("\n");
for (i = 0; i < 131 + crypto_secretbox_MACBYTES; ++i) {
printf(",0x%02x", (unsigned int)c[i]);
if (i % 8 == 7)
printf("\n");
}
printf("\n");
crypto_secretbox_detached(c, mac, m, 131, nonce, firstkey);
for (i = 0;i < crypto_secretbox_MACBYTES; ++i) {
printf(",0x%02x",(unsigned int) mac[i]);
if (i % 8 == 7) printf("\n");
for (i = 0; i < crypto_secretbox_MACBYTES; ++i) {
printf(",0x%02x", (unsigned int)mac[i]);
if (i % 8 == 7)
printf("\n");
}
for (i = 0;i < 131; ++i) {
printf(",0x%02x",(unsigned int) c[i]);
if (i % 8 == 7) printf("\n");
for (i = 0; i < 131; ++i) {
printf(",0x%02x", (unsigned int)c[i]);
if (i % 8 == 7)
printf("\n");
}
return 0;
}
test/default/secretbox_easy2.c
+3 -3
View File
@@ -15,12 +15,12 @@ int main(void)
unsigned long long i;
randombytes_buf(k, sizeof k);
mlen = (unsigned long long) randombytes_uniform((uint32_t) sizeof m);
mlen = (unsigned long long)randombytes_uniform((uint32_t)sizeof m);
randombytes_buf(m, mlen);
randombytes_buf(nonce, sizeof nonce);
crypto_secretbox_easy(c, m, mlen, nonce, k);
crypto_secretbox_open_easy(m2, c, mlen + crypto_secretbox_MACBYTES,
nonce, k);
crypto_secretbox_open_easy(m2, c, mlen + crypto_secretbox_MACBYTES, nonce,
k);
printf("%d\n", memcmp(m, m2, mlen));
for (i = 0; i < mlen + crypto_secretbox_MACBYTES - 1; i++) {
test/default/shorthash.c
+12 -8
View File
@@ -5,22 +5,26 @@
int main(void)
{
#define MAXLEN 64
unsigned char in[MAXLEN], out[crypto_shorthash_BYTES], k[crypto_shorthash_KEYBYTES];
size_t i,j;
unsigned char in[MAXLEN], out[crypto_shorthash_BYTES],
k[crypto_shorthash_KEYBYTES];
size_t i, j;
for( i = 0; i < crypto_shorthash_KEYBYTES; ++i ) k[i] = i;
for (i = 0; i < crypto_shorthash_KEYBYTES; ++i)
k[i] = i;
for(i=0;i<MAXLEN;++i) {
in[i]=i;
crypto_shorthash( out, in, i, k );
for (j = 0;j < crypto_shorthash_BYTES;++j) printf("%02x",(unsigned int) out[j]);
for (i = 0; i < MAXLEN; ++i) {
in[i] = i;
crypto_shorthash(out, in, i, k);
for (j = 0; j < crypto_shorthash_BYTES; ++j)
printf("%02x", (unsigned int)out[j]);
printf("\n");
}
assert(crypto_shorthash_bytes() > 0);
assert(crypto_shorthash_keybytes() > 0);
assert(strcmp(crypto_shorthash_primitive(), "siphash24") == 0);
assert(crypto_shorthash_bytes() == crypto_shorthash_siphash24_bytes());
assert(crypto_shorthash_keybytes() == crypto_shorthash_siphash24_keybytes());
assert(crypto_shorthash_keybytes()
== crypto_shorthash_siphash24_keybytes());
return 0;
}
test/default/sign.c
+31 -32
View File
@@ -2,12 +2,10 @@
#define TEST_NAME "sign"
#include "cmptest.h"
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_SEEDBYTES];
@@ -1045,27 +1043,27 @@ 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;
for (i = 0U; i < (sizeof test_data) / (sizeof test_data[0]); i++) {
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) {
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;
}
@@ -1077,7 +1075,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;
}
@@ -1089,12 +1087,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;
}
@@ -1107,7 +1105,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;
@@ -1123,13 +1121,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,8 +1142,10 @@ int main(void)
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());
assert(crypto_sign_publickeybytes()
== crypto_sign_ed25519_publickeybytes());
assert(crypto_sign_secretkeybytes()
== crypto_sign_ed25519_secretkeybytes());
return 0;
}
test/default/sodium_core.c
+4 -4
View File
@@ -4,11 +4,11 @@
int main(void)
{
printf ("%d\n", sodium_init());
printf("%d\n", sodium_init());
(void) sodium_runtime_has_neon();
(void) sodium_runtime_has_sse2();
(void) sodium_runtime_has_sse3();
(void)sodium_runtime_has_neon();
(void)sodium_runtime_has_sse2();
(void)sodium_runtime_has_sse3();
return 0;
}
test/default/sodium_utils.c
+24 -24
View File
@@ -4,30 +4,30 @@
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;
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]);
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, NULL);
printf("%lu:%02x%02x%02x%02x\n", (unsigned long)bin_len, buf4[0], buf4[1],
buf4[2], buf4[3]);
return 0;
return 0;
}
test/default/sodium_utils2.c
+6 -8
View File
@@ -7,8 +7,7 @@
#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");
@@ -24,12 +23,11 @@ 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_allocarray(SIZE_MAX / 2U + 1U, SIZE_MAX / 2U) != NULL) {
return 1;
@@ -58,7 +56,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");
test/default/sodium_utils3.c
+5 -7
View File
@@ -7,8 +7,7 @@
#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");
@@ -24,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);
@@ -43,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");
test/default/sodium_version.c
+3 -3
View File
@@ -4,9 +4,9 @@
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;
}
test/default/stream.c
+12 -14
View File
@@ -2,18 +2,14 @@
#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];
@@ -23,10 +19,12 @@ int main(void)
{
int i;
crypto_stream(output,4194304,nonce,firstkey);
crypto_hash_sha256(h,output,sizeof output);
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");
for (i = 0; i < 32; ++i)
printf("%02x", h[i]);
printf("\n");
assert(crypto_stream_keybytes() > 0U);
assert(crypto_stream_noncebytes() > 0U);
test/default/stream2.c
+11 -12
View File
@@ -2,16 +2,13 @@
#define TEST_NAME "stream2"
#include "cmptest.h"
unsigned char secondkey[32] = {
0xdc,0x90,0x8d,0xda,0x0b,0x93,0x44,0xa9
,0x53,0x62,0x9b,0x73,0x38,0x20,0x77,0x88
,0x80,0xf3,0xce,0xb4,0x21,0xbb,0x61,0xb9
,0x1c,0xbd,0x4c,0x3e,0x66,0x25,0x6c,0xe4
} ;
unsigned char secondkey[32]
= { 0xdc, 0x90, 0x8d, 0xda, 0x0b, 0x93, 0x44, 0xa9, 0x53, 0x62, 0x9b,
0x73, 0x38, 0x20, 0x77, 0x88, 0x80, 0xf3, 0xce, 0xb4, 0x21, 0xbb,
0x61, 0xb9, 0x1c, 0xbd, 0x4c, 0x3e, 0x66, 0x25, 0x6c, 0xe4 };
unsigned char noncesuffix[8] = {
0x82,0x19,0xe0,0x03,0x6b,0x7a,0x0b,0x37
} ;
unsigned char noncesuffix[8]
= { 0x82, 0x19, 0xe0, 0x03, 0x6b, 0x7a, 0x0b, 0x37 };
unsigned char output[4194304];
@@ -20,9 +17,11 @@ unsigned char h[32];
int main(void)
{
int i;
crypto_stream_salsa20(output,4194304,noncesuffix,secondkey);
crypto_hash_sha256(h,output,sizeof output);
for (i = 0;i < 32;++i) printf("%02x",h[i]); printf("\n");
crypto_stream_salsa20(output, 4194304, noncesuffix, secondkey);
crypto_hash_sha256(h, output, sizeof output);
for (i = 0; i < 32; ++i)
printf("%02x", h[i]);
printf("\n");
assert(crypto_stream_salsa20_keybytes() > 0U);
assert(crypto_stream_salsa20_noncebytes() > 0U);
test/default/stream3.c
+12 -15
View File
@@ -2,18 +2,14 @@
#define TEST_NAME "stream3"
#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 rs[32];
@@ -21,11 +17,12 @@ int main(void)
{
int i;
crypto_stream(rs,32,nonce,firstkey);
crypto_stream(rs, 32, nonce, firstkey);
for (i = 0;i < 32;++i) {
printf(",0x%02x",(unsigned int) rs[i]);
if (i % 8 == 7) printf("\n");
for (i = 0; i < 32; ++i) {
printf(",0x%02x", (unsigned int)rs[i]);
if (i % 8 == 7)
printf("\n");
}
return 0;
}
test/default/stream4.c
+27 -38
View File
@@ -2,42 +2,30 @@
#define TEST_NAME "stream4"
#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 m[163] = {
0, 0, 0, 0, 0, 0, 0, 0
, 0, 0, 0, 0, 0, 0, 0, 0
, 0, 0, 0, 0, 0, 0, 0, 0
, 0, 0, 0, 0, 0, 0, 0, 0
,0xbe,0x07,0x5f,0xc5,0x3c,0x81,0xf2,0xd5
,0xcf,0x14,0x13,0x16,0xeb,0xeb,0x0c,0x7b
,0x52,0x28,0xc5,0x2a,0x4c,0x62,0xcb,0xd4
,0x4b,0x66,0x84,0x9b,0x64,0x24,0x4f,0xfc
,0xe5,0xec,0xba,0xaf,0x33,0xbd,0x75,0x1a
,0x1a,0xc7,0x28,0xd4,0x5e,0x6c,0x61,0x29
,0x6c,0xdc,0x3c,0x01,0x23,0x35,0x61,0xf4
,0x1d,0xb6,0x6c,0xce,0x31,0x4a,0xdb,0x31
,0x0e,0x3b,0xe8,0x25,0x0c,0x46,0xf0,0x6d
,0xce,0xea,0x3a,0x7f,0xa1,0x34,0x80,0x57
,0xe2,0xf6,0x55,0x6a,0xd6,0xb1,0x31,0x8a
,0x02,0x4a,0x83,0x8f,0x21,0xaf,0x1f,0xde
,0x04,0x89,0x77,0xeb,0x48,0xf5,0x9f,0xfd
,0x49,0x24,0xca,0x1c,0x60,0x90,0x2e,0x52
,0xf0,0xa0,0x89,0xbc,0x76,0x89,0x70,0x40
,0xe0,0x82,0xf9,0x37,0x76,0x38,0x48,0x64
,0x5e,0x07,0x05
} ;
unsigned char m[163]
= { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0xbe, 0x07, 0x5f, 0xc5,
0x3c, 0x81, 0xf2, 0xd5, 0xcf, 0x14, 0x13, 0x16, 0xeb, 0xeb, 0x0c, 0x7b,
0x52, 0x28, 0xc5, 0x2a, 0x4c, 0x62, 0xcb, 0xd4, 0x4b, 0x66, 0x84, 0x9b,
0x64, 0x24, 0x4f, 0xfc, 0xe5, 0xec, 0xba, 0xaf, 0x33, 0xbd, 0x75, 0x1a,
0x1a, 0xc7, 0x28, 0xd4, 0x5e, 0x6c, 0x61, 0x29, 0x6c, 0xdc, 0x3c, 0x01,
0x23, 0x35, 0x61, 0xf4, 0x1d, 0xb6, 0x6c, 0xce, 0x31, 0x4a, 0xdb, 0x31,
0x0e, 0x3b, 0xe8, 0x25, 0x0c, 0x46, 0xf0, 0x6d, 0xce, 0xea, 0x3a, 0x7f,
0xa1, 0x34, 0x80, 0x57, 0xe2, 0xf6, 0x55, 0x6a, 0xd6, 0xb1, 0x31, 0x8a,
0x02, 0x4a, 0x83, 0x8f, 0x21, 0xaf, 0x1f, 0xde, 0x04, 0x89, 0x77, 0xeb,
0x48, 0xf5, 0x9f, 0xfd, 0x49, 0x24, 0xca, 0x1c, 0x60, 0x90, 0x2e, 0x52,
0xf0, 0xa0, 0x89, 0xbc, 0x76, 0x89, 0x70, 0x40, 0xe0, 0x82, 0xf9, 0x37,
0x76, 0x38, 0x48, 0x64, 0x5e, 0x07, 0x05 };
unsigned char c[163];
@@ -45,11 +33,12 @@ int main(void)
{
int i;
crypto_stream_xor(c,m,163,nonce,firstkey);
crypto_stream_xor(c, m, 163, nonce, firstkey);
for (i = 32;i < 163;++i) {
printf(",0x%02x",(unsigned int) c[i]);
if (i % 8 == 7) printf("\n");
for (i = 32; i < 163; ++i) {
printf(",0x%02x", (unsigned int)c[i]);
if (i % 8 == 7)
printf("\n");
}
printf("\n");