kevin/libsodium
1
Fork 0
mirror of https://github.com/jedisct1/libsodium.git synced 2024-12-28 22:21:15 -07:00
Code Releases Wiki Activity
d227affc63
libsodium/test/default/auth.c

142 lines
5.0 KiB
C
Raw Normal View History

One more test
2013-01-20 16:25:22 -07:00
Include cmptest.h in all tests
2013-01-20 16:55:10 -07:00
#define TEST_NAME "auth"
#include "cmptest.h"
One more test
2013-01-20 16:25:22 -07:00
/* "Test Case 2" from RFC 4231 */
Mark everything as static in tests
2015-11-23 08:07:13 -07:00
static unsigned char key[32] = "Jefe";
Indentx
2017-02-23 03:15:29 -07:00
static unsigned char c[] = "what do ya want for nothing?";
One more test
2013-01-20 16:25:22 -07:00
Test hmacsha512 with keys larger than the block size
2014-09-16 14:59:19 -07:00
/* Hacker manifesto */
Indentx
2017-02-23 03:15:29 -07:00
static unsigned char key2[] =
"Another one got caught today, it's all over the papers. \"Teenager "
"Arrested in Computer Crime Scandal\", \"Hacker Arrested after Bank "
"Tampering\"... Damn kids. They're all alike.";
Test hmacsha512 with keys larger than the block size
2014-09-16 14:59:19 -07:00
Mark everything as static in tests
2015-11-23 08:07:13 -07:00
static unsigned char a[crypto_auth_BYTES];
static unsigned char a2[crypto_auth_hmacsha512_BYTES];
Relax most __attribute__ ((nonnull)) to allow 0-length inputs to be NULL. Justifications: - crypto_(auth|hash|generichash|onetimeauth|shorthash)*: it's legal to hash or HMAC a 0-length message - crypto_box*: it's legal to encrypt a 0-length message - crypto_sign*: it's legal to sign a 0-length message - utils: comparing two 0-length byte arrays is legal memzero on a 0-length byte array is a no-op converting an empty hex string to binary results in an empty binary string converting an empty binary string to hex results in an empty hex string converting an empty b64 string to binary results in an empty binary string converting an empty binary string to b64 results in an empty b64 string sodium_add / sodium_sub on zero-length arrays is a no-op For the functions declared in utils.h, I moved the logic into private functions that have the __attribute__ ((nonnull)) check, but they are only called when the corresponding length argument is non-0. I didn't do this for the hash/box/sign functions since it would have been a lot more work and quite a large refactor.
2019-02-02 14:47:31 -07:00
static unsigned char a3[crypto_auth_hmacsha512_BYTES];
One more test
2013-01-20 16:25:22 -07:00
Indentx
2017-02-23 03:15:29 -07:00
int
main(void)
One more test
2013-01-20 16:25:22 -07:00
{
Test hmacsha512 with keys larger than the block size
2014-09-16 14:59:19 -07:00
crypto_auth_hmacsha512_state st;
Use the right state type for the auth256 test
2017-07-24 14:04:23 -07:00
crypto_auth_hmacsha256_state st256;
Relax most __attribute__ ((nonnull)) to allow 0-length inputs to be NULL. Justifications: - crypto_(auth|hash|generichash|onetimeauth|shorthash)*: it's legal to hash or HMAC a 0-length message - crypto_box*: it's legal to encrypt a 0-length message - crypto_sign*: it's legal to sign a 0-length message - utils: comparing two 0-length byte arrays is legal memzero on a 0-length byte array is a no-op converting an empty hex string to binary results in an empty binary string converting an empty binary string to hex results in an empty hex string converting an empty b64 string to binary results in an empty binary string converting an empty binary string to b64 results in an empty b64 string sodium_add / sodium_sub on zero-length arrays is a no-op For the functions declared in utils.h, I moved the logic into private functions that have the __attribute__ ((nonnull)) check, but they are only called when the corresponding length argument is non-0. I didn't do this for the hash/box/sign functions since it would have been a lot more work and quite a large refactor.
2019-02-02 14:47:31 -07:00
crypto_auth_hmacsha512256_state st512_256;
Indentx
2017-02-23 03:15:29 -07:00
size_t i;
Include header files commonly used by the tests to cmptest.h
2014-09-13 14:11:12 -07:00
Add statebytes for crypto_hmac_*
2015-01-23 15:08:49 -07:00
assert(crypto_auth_hmacsha512_statebytes() ==
sizeof(crypto_auth_hmacsha512_state));
Consistent syle for the tests.
2014-09-14 11:32:55 -07:00
crypto_auth(a, c, sizeof c - 1U, key);
Test hmacsha512 with keys larger than the block size
2014-09-16 14:59:19 -07:00
for (i = 0; i < sizeof a; ++i) {
Indentx
2017-02-23 03:15:29 -07:00
printf(",0x%02x", (unsigned int) a[i]);
Consistent syle for the tests.
2014-09-14 11:32:55 -07:00
if (i % 8 == 7)
printf("\n");
Make the tests a little bit more readable
2014-09-14 10:34:16 -07:00
}
Test hmacsha512 with keys larger than the block size
2014-09-16 14:59:19 -07:00
printf("\n");
crypto_auth_hmacsha512_init(&st, key, sizeof key);
crypto_auth_hmacsha512_update(&st, c, 1U);
crypto_auth_hmacsha512_update(&st, c, sizeof c - 2U);
crypto_auth_hmacsha512_final(&st, a2);
for (i = 0; i < sizeof a2; ++i) {
Indentx
2017-02-23 03:15:29 -07:00
printf(",0x%02x", (unsigned int) a2[i]);
Test hmacsha512 with keys larger than the block size
2014-09-16 14:59:19 -07:00
if (i % 8 == 7)
printf("\n");
}
printf("\n");
crypto_auth_hmacsha512_init(&st, key2, sizeof key2);
crypto_auth_hmacsha512_update(&st, c, 1U);
crypto_auth_hmacsha512_update(&st, c, sizeof c - 2U);
crypto_auth_hmacsha512_final(&st, a2);
for (i = 0; i < sizeof a2; ++i) {
Indentx
2017-02-23 03:15:29 -07:00
printf(",0x%02x", (unsigned int) a2[i]);
Test hmacsha512 with keys larger than the block size
2014-09-16 14:59:19 -07:00
if (i % 8 == 7)
printf("\n");
}
Include header files commonly used by the tests to cmptest.h
2014-09-13 14:11:12 -07:00
Test crypto_auth_hmacsha256_*()
2017-07-24 13:08:07 -07:00
memset(a2, 0, sizeof a2);
Use the right state type for the auth256 test
2017-07-24 14:04:23 -07:00
crypto_auth_hmacsha256_init(&st256, key2, sizeof key2);
Use a guard page instead of NULL for opt arguments in tests
2018-12-24 07:02:59 -07:00
crypto_auth_hmacsha256_update(&st256, guard_page, 0U);
Use the right state type for the auth256 test
2017-07-24 14:04:23 -07:00
crypto_auth_hmacsha256_update(&st256, c, 1U);
crypto_auth_hmacsha256_update(&st256, c, sizeof c - 2U);
crypto_auth_hmacsha256_final(&st256, a2);
Test crypto_auth_hmacsha256_*()
2017-07-24 13:08:07 -07:00
for (i = 0; i < sizeof a2; ++i) {
printf(",0x%02x", (unsigned int) a2[i]);
if (i % 8 == 7)
printf("\n");
}
Fix tests, use guard page instead of NULL because of Wasm
2019-02-09 12:47:24 -07:00
/* Empty message tests: HMAC-SHA512 */
Relax most __attribute__ ((nonnull)) to allow 0-length inputs to be NULL. Justifications: - crypto_(auth|hash|generichash|onetimeauth|shorthash)*: it's legal to hash or HMAC a 0-length message - crypto_box*: it's legal to encrypt a 0-length message - crypto_sign*: it's legal to sign a 0-length message - utils: comparing two 0-length byte arrays is legal memzero on a 0-length byte array is a no-op converting an empty hex string to binary results in an empty binary string converting an empty binary string to hex results in an empty hex string converting an empty b64 string to binary results in an empty binary string converting an empty binary string to b64 results in an empty b64 string sodium_add / sodium_sub on zero-length arrays is a no-op For the functions declared in utils.h, I moved the logic into private functions that have the __attribute__ ((nonnull)) check, but they are only called when the corresponding length argument is non-0. I didn't do this for the hash/box/sign functions since it would have been a lot more work and quite a large refactor.
2019-02-02 14:47:31 -07:00
memset(a2, 0, sizeof a2);
crypto_auth_hmacsha512_init(&st, key, sizeof key);
crypto_auth_hmacsha512_final(&st, a2);
memset(a3, 0, sizeof a3);
crypto_auth_hmacsha512_init(&st, key, sizeof key);
crypto_auth_hmacsha512_update(&st, a2, 0U);
crypto_auth_hmacsha512_final(&st, a3);
assert(sodium_memcmp(a2, a3, sizeof a2) == 0);
memset(a3, 0, sizeof a3);
crypto_auth_hmacsha512_init(&st, key, sizeof key);
Fix tests, use guard page instead of NULL because of Wasm
2019-02-09 12:47:24 -07:00
crypto_auth_hmacsha512_update(&st, guard_page, 0U);
Relax most __attribute__ ((nonnull)) to allow 0-length inputs to be NULL. Justifications: - crypto_(auth|hash|generichash|onetimeauth|shorthash)*: it's legal to hash or HMAC a 0-length message - crypto_box*: it's legal to encrypt a 0-length message - crypto_sign*: it's legal to sign a 0-length message - utils: comparing two 0-length byte arrays is legal memzero on a 0-length byte array is a no-op converting an empty hex string to binary results in an empty binary string converting an empty binary string to hex results in an empty hex string converting an empty b64 string to binary results in an empty binary string converting an empty binary string to b64 results in an empty b64 string sodium_add / sodium_sub on zero-length arrays is a no-op For the functions declared in utils.h, I moved the logic into private functions that have the __attribute__ ((nonnull)) check, but they are only called when the corresponding length argument is non-0. I didn't do this for the hash/box/sign functions since it would have been a lot more work and quite a large refactor.
2019-02-02 14:47:31 -07:00
crypto_auth_hmacsha512_final(&st, a3);
assert(sodium_memcmp(a2, a3, sizeof a2) == 0);
Fix tests, use guard page instead of NULL because of Wasm
2019-02-09 12:47:24 -07:00
/* Empty message tests: HMAC-SHA512-256 */
Relax most __attribute__ ((nonnull)) to allow 0-length inputs to be NULL. Justifications: - crypto_(auth|hash|generichash|onetimeauth|shorthash)*: it's legal to hash or HMAC a 0-length message - crypto_box*: it's legal to encrypt a 0-length message - crypto_sign*: it's legal to sign a 0-length message - utils: comparing two 0-length byte arrays is legal memzero on a 0-length byte array is a no-op converting an empty hex string to binary results in an empty binary string converting an empty binary string to hex results in an empty hex string converting an empty b64 string to binary results in an empty binary string converting an empty binary string to b64 results in an empty b64 string sodium_add / sodium_sub on zero-length arrays is a no-op For the functions declared in utils.h, I moved the logic into private functions that have the __attribute__ ((nonnull)) check, but they are only called when the corresponding length argument is non-0. I didn't do this for the hash/box/sign functions since it would have been a lot more work and quite a large refactor.
2019-02-02 14:47:31 -07:00
memset(a2, 0, sizeof a2);
crypto_auth_hmacsha512256_init(&st512_256, key, sizeof key);
crypto_auth_hmacsha512256_final(&st512_256, a2);
memset(a3, 0, sizeof a3);
crypto_auth_hmacsha512256_init(&st512_256, key, sizeof key);
crypto_auth_hmacsha512256_update(&st512_256, a2, 0U);
crypto_auth_hmacsha512256_final(&st512_256, a3);
assert(sodium_memcmp(a2, a3, sizeof a2) == 0);
memset(a3, 0, sizeof a3);
crypto_auth_hmacsha512256_init(&st512_256, key, sizeof key);
Fix tests, use guard page instead of NULL because of Wasm
2019-02-09 12:47:24 -07:00
crypto_auth_hmacsha512256_update(&st512_256, guard_page, 0U);
Relax most __attribute__ ((nonnull)) to allow 0-length inputs to be NULL. Justifications: - crypto_(auth|hash|generichash|onetimeauth|shorthash)*: it's legal to hash or HMAC a 0-length message - crypto_box*: it's legal to encrypt a 0-length message - crypto_sign*: it's legal to sign a 0-length message - utils: comparing two 0-length byte arrays is legal memzero on a 0-length byte array is a no-op converting an empty hex string to binary results in an empty binary string converting an empty binary string to hex results in an empty hex string converting an empty b64 string to binary results in an empty binary string converting an empty binary string to b64 results in an empty b64 string sodium_add / sodium_sub on zero-length arrays is a no-op For the functions declared in utils.h, I moved the logic into private functions that have the __attribute__ ((nonnull)) check, but they are only called when the corresponding length argument is non-0. I didn't do this for the hash/box/sign functions since it would have been a lot more work and quite a large refactor.
2019-02-02 14:47:31 -07:00
crypto_auth_hmacsha512256_final(&st512_256, a3);
assert(sodium_memcmp(a2, a3, sizeof a2) == 0);
Fix tests, use guard page instead of NULL because of Wasm
2019-02-09 12:47:24 -07:00
/* Empty message tests: HMAC-SHA256 */
Relax most __attribute__ ((nonnull)) to allow 0-length inputs to be NULL. Justifications: - crypto_(auth|hash|generichash|onetimeauth|shorthash)*: it's legal to hash or HMAC a 0-length message - crypto_box*: it's legal to encrypt a 0-length message - crypto_sign*: it's legal to sign a 0-length message - utils: comparing two 0-length byte arrays is legal memzero on a 0-length byte array is a no-op converting an empty hex string to binary results in an empty binary string converting an empty binary string to hex results in an empty hex string converting an empty b64 string to binary results in an empty binary string converting an empty binary string to b64 results in an empty b64 string sodium_add / sodium_sub on zero-length arrays is a no-op For the functions declared in utils.h, I moved the logic into private functions that have the __attribute__ ((nonnull)) check, but they are only called when the corresponding length argument is non-0. I didn't do this for the hash/box/sign functions since it would have been a lot more work and quite a large refactor.
2019-02-02 14:47:31 -07:00
memset(a2, 0, sizeof a2);
crypto_auth_hmacsha256_init(&st256, key, sizeof key);
crypto_auth_hmacsha256_final(&st256, a2);
memset(a3, 0, sizeof a3);
crypto_auth_hmacsha256_init(&st256, key, sizeof key);
crypto_auth_hmacsha256_update(&st256, a2, 0U);
crypto_auth_hmacsha256_final(&st256, a3);
assert(sodium_memcmp(a2, a3, sizeof a2) == 0);
memset(a3, 0, sizeof a3);
crypto_auth_hmacsha256_init(&st256, key, sizeof key);
Fix tests, use guard page instead of NULL because of Wasm
2019-02-09 12:47:24 -07:00
crypto_auth_hmacsha256_update(&st256, guard_page, 0U);
Relax most __attribute__ ((nonnull)) to allow 0-length inputs to be NULL. Justifications: - crypto_(auth|hash|generichash|onetimeauth|shorthash)*: it's legal to hash or HMAC a 0-length message - crypto_box*: it's legal to encrypt a 0-length message - crypto_sign*: it's legal to sign a 0-length message - utils: comparing two 0-length byte arrays is legal memzero on a 0-length byte array is a no-op converting an empty hex string to binary results in an empty binary string converting an empty binary string to hex results in an empty hex string converting an empty b64 string to binary results in an empty binary string converting an empty binary string to b64 results in an empty b64 string sodium_add / sodium_sub on zero-length arrays is a no-op For the functions declared in utils.h, I moved the logic into private functions that have the __attribute__ ((nonnull)) check, but they are only called when the corresponding length argument is non-0. I didn't do this for the hash/box/sign functions since it would have been a lot more work and quite a large refactor.
2019-02-02 14:47:31 -07:00
crypto_auth_hmacsha256_final(&st256, a3);
assert(sodium_memcmp(a2, a3, sizeof a2) == 0);
Fix tests, use guard page instead of NULL because of Wasm
2019-02-09 12:47:24 -07:00
/* --- */
Make the tests a little bit more readable
2014-09-14 10:34:16 -07:00
assert(crypto_auth_bytes() > 0U);
assert(crypto_auth_keybytes() > 0U);
assert(strcmp(crypto_auth_primitive(), "hmacsha512256") == 0);
assert(crypto_auth_hmacsha256_bytes() > 0U);
assert(crypto_auth_hmacsha256_keybytes() > 0U);
assert(crypto_auth_hmacsha512_bytes() > 0U);
assert(crypto_auth_hmacsha512_keybytes() > 0U);
assert(crypto_auth_hmacsha512256_bytes() == crypto_auth_bytes());
assert(crypto_auth_hmacsha512256_keybytes() == crypto_auth_keybytes());
Add tests for custom randombytes_uniform. Check for crypto_auth_hmacsha512256_statebytes() presence.
2015-05-09 06:54:18 -07:00
assert(crypto_auth_hmacsha512256_statebytes() >=
crypto_auth_hmacsha512256_keybytes());
Add statebytes for crypto_hmac_*
2015-01-23 15:08:49 -07:00
assert(crypto_auth_hmacsha256_statebytes() ==
sizeof(crypto_auth_hmacsha256_state));
assert(crypto_auth_hmacsha512_statebytes() ==
sizeof(crypto_auth_hmacsha512_state));
Make the tests a little bit more readable
2014-09-14 10:34:16 -07:00
return 0;
One more test
2013-01-20 16:25:22 -07:00
}
Copy Permalink