Aksal/nuttx-apps
1
0
Fork 1
mirror of https://github.com/apache/nuttx-apps.git synced 2026-08-02 12:49:03 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
nuttx-apps/testing/drivers/crypto/hash.c
Peter Barada 499352fb0c testing/drivers/hash: Add unaligned buffer size test 
Add hash testing of unaligned buffer sizes via multiple call to
ioctl(CIOCCRYPT) in a single session with buffer sizes incrementally
increasing from zero size to 255 (with monotoncially increasing
byte value data) to force all sizes to be handled by cryptodev
implementations.

Signed-off-by: Peter Barada <peter.barada@gmail.com>
2026-06-10 16:42:13 +08:00

1101 lines
29 KiB
C
Raw Blame History

/****************************************************************************
* apps/testing/drivers/crypto/hash.c
*
* SPDX-License-Identifier: ISC
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <err.h>
#include <stdio.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/param.h>
#include <crypto/cryptodev.h>
#ifndef CONFIG_TESTING_CRYPTO_HASH_DISABLE_MD5
# include <crypto/md5.h>
#endif
#ifndef CONFIG_TESTING_CRYPTO_HASH_DISABLE_SHA1
# include <crypto/sha1.h>
#endif
#if !defined(CONFIG_TESTING_CRYPTO_HASH_DISABLE_SHA224) || \
!defined(CONFIG_TESTING_CRYPTO_HASH_DISABLE_SHA256) || \
!defined(CONFIG_TESTING_CRYPTO_HASH_DISABLE_SHA512)
# include <crypto/sha2.h>
#endif
#ifdef CONFIG_TESTING_CRYPTO_HASH_HUGE_BLOCK
# define HASH_HUGE_BLOCK_SIZE (600 * 1024) /* size hash was done over */
#endif
typedef struct crypto_context
{
int fd;
int crypto_fd;
struct session_op session;
struct crypt_op cryp;
}
crypto_context;
typedef struct tb
{
FAR char *data;
int datalen;
}
tb;
#ifndef CONFIG_TESTING_CRYPTO_HASH_DISABLE_MD5
tb md5_testcase[] =
{
{
"",
0,
},
{
"a",
1,
},
{
"abc",
3,
},
{
"message digest",
14,
},
{
"abcdefghijklmnopqrstuvwxyz",
26,
},
{
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
62,
},
{
"123456789012345678901234567890123456789"
"01234567890123456789012345678901234567890",
80,
}
};
#endif
#if !defined(CONFIG_TESTING_CRYPTO_HASH_DISABLE_SHA1) \
|| !defined(CONFIG_TESTING_CRYPTO_HASH_DISABLE_SHA224) \
|| !defined(CONFIG_TESTING_CRYPTO_HASH_DISABLE_SHA256)
tb sha_testcase[] =
{
{
"abc",
3,
},
{
"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
56,
},
{
"",
1000,
}
};
#endif
#ifndef CONFIG_TESTING_CRYPTO_HASH_DISABLE_SHA512
tb sha512_testcase[] =
{
{
"abc",
3,
},
{
"abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnh"
"ijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu",
112,
},
{
"",
1000,
}
};
#endif
#ifndef CONFIG_TESTING_CRYPTO_HASH_DISABLE_MD5
/* RFC 1321 test vectors */
static const unsigned char md5_result[7][16] =
{
{ 0xd4, 0x1d, 0x8c, 0xd9, 0x8f, 0x00, 0xb2, 0x04,
0xe9, 0x80, 0x09, 0x98, 0xec, 0xf8, 0x42, 0x7e },
{ 0x0c, 0xc1, 0x75, 0xb9, 0xc0, 0xf1, 0xb6, 0xa8,
0x31, 0xc3, 0x99, 0xe2, 0x69, 0x77, 0x26, 0x61 },
{ 0x90, 0x01, 0x50, 0x98, 0x3c, 0xd2, 0x4f, 0xb0,
0xd6, 0x96, 0x3f, 0x7d, 0x28, 0xe1, 0x7f, 0x72 },
{ 0xf9, 0x6b, 0x69, 0x7d, 0x7c, 0xb7, 0x93, 0x8d,
0x52, 0x5a, 0x2f, 0x31, 0xaa, 0xf1, 0x61, 0xd0 },
{ 0xc3, 0xfc, 0xd3, 0xd7, 0x61, 0x92, 0xe4, 0x00,
0x7d, 0xfb, 0x49, 0x6c, 0xca, 0x67, 0xe1, 0x3b },
{ 0xd1, 0x74, 0xab, 0x98, 0xd2, 0x77, 0xd9, 0xf5,
0xa5, 0x61, 0x1c, 0x2c, 0x9f, 0x41, 0x9d, 0x9f },
{ 0x57, 0xed, 0xf4, 0xa2, 0x2b, 0xe3, 0xc9, 0x55,
0xac, 0x49, 0xda, 0x2e, 0x21, 0x07, 0xb6, 0x7a }
};
#endif
#ifndef CONFIG_TESTING_CRYPTO_HASH_DISABLE_SHA1
/* FIPS-180-1 test vectors */
static const unsigned char sha1_result[3][20] =
{
{ 0xa9, 0x99, 0x3e, 0x36, 0x47, 0x06, 0x81, 0x6a, 0xba, 0x3e,
0x25, 0x71, 0x78, 0x50, 0xc2, 0x6c, 0x9c, 0xd0, 0xd8, 0x9d },
{ 0x84, 0x98, 0x3e, 0x44, 0x1c, 0x3b, 0xd2, 0x6e, 0xba, 0xae,
0x4a, 0xa1, 0xf9, 0x51, 0x29, 0xe5, 0xe5, 0x46, 0x70, 0xf1 },
{ 0x34, 0xaa, 0x97, 0x3c, 0xd4, 0xc4, 0xda, 0xa4, 0xf6, 0x1e,
0xeb, 0x2b, 0xdb, 0xad, 0x27, 0x31, 0x65, 0x34, 0x01, 0x6f }
};
#endif
#ifndef CONFIG_TESTING_CRYPTO_HASH_DISABLE_SHA224
/* Calculated using sha224sum */
static const unsigned char sha224_result[3][28] =
{
{ 0x23, 0x09, 0x7d, 0x22, 0x34, 0x05, 0xd8, 0x22,
0x86, 0x42, 0xa4, 0x77, 0xbd, 0xa2, 0x55, 0xb3,
0x2a, 0xad, 0xbc, 0xe4, 0xbd, 0xa0, 0xb3, 0xf7,
0xe3, 0x6c, 0x9d, 0xa7 },
{ 0x75, 0x38, 0x8b, 0x16, 0x51, 0x27, 0x76, 0xcc,
0x5d, 0xba, 0x5d, 0xa1, 0xfd, 0x89, 0x01, 0x50,
0xb0, 0xc6, 0x45, 0x5c, 0xb4, 0xf5, 0x8b, 0x19,
0x52, 0x52, 0x25, 0x25 },
{ 0x20, 0x79, 0x46, 0x55, 0x98, 0x0c, 0x91, 0xd8,
0xbb, 0xb4, 0xc1, 0xea, 0x97, 0x61, 0x8a, 0x4b,
0xf0, 0x3f, 0x42, 0x58, 0x19, 0x48, 0xb2, 0xee,
0x4e, 0xe7, 0xad, 0x67 }
};
#endif
#ifndef CONFIG_TESTING_CRYPTO_HASH_DISABLE_SHA256
/* FIPS-180-2 test vectors */
static const unsigned char sha256_result[3][32] =
{
{ 0xba, 0x78, 0x16, 0xbf, 0x8f, 0x01, 0xcf, 0xea,
0x41, 0x41, 0x40, 0xde, 0x5d, 0xae, 0x22, 0x23,
0xb0, 0x03, 0x61, 0xa3, 0x96, 0x17, 0x7a, 0x9c,
0xb4, 0x10, 0xff, 0x61, 0xf2, 0x00, 0x15, 0xad },
{ 0x24, 0x8d, 0x6a, 0x61, 0xd2, 0x06, 0x38, 0xb8,
0xe5, 0xc0, 0x26, 0x93, 0x0c, 0x3e, 0x60, 0x39,
0xa3, 0x3c, 0xe4, 0x59, 0x64, 0xff, 0x21, 0x67,
0xf6, 0xec, 0xed, 0xd4, 0x19, 0xdb, 0x06, 0xc1 },
{ 0xcd, 0xc7, 0x6e, 0x5c, 0x99, 0x14, 0xfb, 0x92,
0x81, 0xa1, 0xc7, 0xe2, 0x84, 0xd7, 0x3e, 0x67,
0xf1, 0x80, 0x9a, 0x48, 0xa4, 0x97, 0x20, 0x0e,
0x04, 0x6d, 0x39, 0xcc, 0xc7, 0x11, 0x2c, 0xd0 }
};
#endif
#ifndef CONFIG_TESTING_CRYPTO_HASH_DISABLE_SHA512
/* FIPS-180-2 test vectors */
static const unsigned char sha512_result[3][64] =
{
{ 0xdd, 0xaf, 0x35, 0xa1, 0x93, 0x61, 0x7a, 0xba,
0xcc, 0x41, 0x73, 0x49, 0xae, 0x20, 0x41, 0x31,
0x12, 0xe6, 0xfa, 0x4e, 0x89, 0xa9, 0x7e, 0xa2,
0x0a, 0x9e, 0xee, 0xe6, 0x4b, 0x55, 0xd3, 0x9a,
0x21, 0x92, 0x99, 0x2a, 0x27, 0x4f, 0xc1, 0xa8,
0x36, 0xba, 0x3c, 0x23, 0xa3, 0xfe, 0xeb, 0xbd,
0x45, 0x4d, 0x44, 0x23, 0x64, 0x3c, 0xe8, 0x0e,
0x2a, 0x9a, 0xc9, 0x4f, 0xa5, 0x4c, 0xa4, 0x9f },
{ 0x8e, 0x95, 0x9b, 0x75, 0xda, 0xe3, 0x13, 0xda,
0x8c, 0xf4, 0xf7, 0x28, 0x14, 0xfc, 0x14, 0x3f,
0x8f, 0x77, 0x79, 0xc6, 0xeb, 0x9f, 0x7f, 0xa1,
0x72, 0x99, 0xae, 0xad, 0xb6, 0x88, 0x90, 0x18,
0x50, 0x1d, 0x28, 0x9e, 0x49, 0x00, 0xf7, 0xe4,
0x33, 0x1b, 0x99, 0xde, 0xc4, 0xb5, 0x43, 0x3a,
0xc7, 0xd3, 0x29, 0xee, 0xb6, 0xdd, 0x26, 0x54,
0x5e, 0x96, 0xe5, 0x5b, 0x87, 0x4b, 0xe9, 0x09 },
{ 0xe7, 0x18, 0x48, 0x3d, 0x0c, 0xe7, 0x69, 0x64,
0x4e, 0x2e, 0x42, 0xc7, 0xbc, 0x15, 0xb4, 0x63,
0x8e, 0x1f, 0x98, 0xb1, 0x3b, 0x20, 0x44, 0x28,
0x56, 0x32, 0xa8, 0x03, 0xaf, 0xa9, 0x73, 0xeb,
0xde, 0x0f, 0xf2, 0x44, 0x87, 0x7e, 0xa6, 0x0a,
0x4c, 0xb0, 0x43, 0x2c, 0xe5, 0x77, 0xc3, 0x1b,
0xeb, 0x00, 0x9c, 0x5c, 0x2c, 0x49, 0xaa, 0x2e,
0x4e, 0xad, 0xb2, 0x17, 0xad, 0x8c, 0xc0, 0x9b }
};
#endif
#ifdef CONFIG_TESTING_CRYPTO_HASH_HUGE_BLOCK
# ifndef CONFIG_TESTING_CRYPTO_HASH_DISABLE_MD5
static const unsigned char md5_huge_block_result[16] =
{
0xef, 0x6d, 0xcc, 0xc8, 0xe1, 0xcc, 0x7f, 0x08,
0xc2, 0x71, 0xd4, 0xc4, 0xe0, 0x13, 0xa3, 0x9b
};
# endif
# ifndef CONFIG_TESTING_CRYPTO_HASH_DISABLE_SHA1
static const unsigned char sha1_huge_block_result[20] =
{
0xf2, 0x35, 0x65, 0x81, 0x79, 0x4d, 0xac, 0x20, 0x79, 0x7b,
0xff, 0x38, 0xee, 0x2b, 0xdc, 0x44, 0x24, 0xd3, 0xf0, 0x4a
};
# endif
# ifndef CONFIG_TESTING_CRYPTO_HASH_DISABLE_SHA224
static const unsigned char sha224_huge_block_result[28] =
{
0xff, 0x42, 0x9e, 0x92, 0x94, 0xce, 0x0a, 0x31,
0xd2, 0x80, 0xc6, 0xad, 0x27, 0x3f, 0x8f, 0xd5,
0xa9, 0x8a, 0xe7, 0x6b, 0xd1, 0xd4, 0x67, 0xc7,
0xc1, 0x91, 0xc4, 0x78
};
# endif
# ifndef CONFIG_TESTING_CRYPTO_HASH_DISABLE_SHA256
static const unsigned char sha256_huge_block_result[32] =
{
0x79, 0xb1, 0xf2, 0x65, 0x7e, 0x33, 0x25, 0xff,
0x16, 0xdb, 0x5d, 0x3c, 0x65, 0xa4, 0x7b, 0x78,
0x0d, 0xd5, 0xa1, 0x45, 0xb5, 0x30, 0xe0, 0x91,
0x54, 0x01, 0x40, 0x0c, 0xff, 0x35, 0x1d, 0xd3
};
# endif
# ifndef CONFIG_TESTING_CRYPTO_HASH_DISABLE_SHA512
static const unsigned char sha512_huge_block_result[64] =
{
0xa4, 0x3a, 0x66, 0xe8, 0xf7, 0x59, 0x95, 0x6d,
0x09, 0x55, 0xdd, 0xad, 0x84, 0x7c, 0xd5, 0xe7,
0xd2, 0xbe, 0xac, 0x49, 0xa9, 0x4b, 0xa3, 0x72,
0xe1, 0x92, 0xa0, 0x70, 0x83, 0x17, 0x85, 0x5e,
0x90, 0x9e, 0x1d, 0x91, 0x6a, 0x93, 0xd9, 0xae,
0xb8, 0x1a, 0x43, 0xb5, 0x51, 0x53, 0x10, 0xf1,
0xce, 0x3a, 0xcf, 0xb6, 0x9c, 0x8b, 0x6e, 0x07,
0x13, 0xca, 0xe1, 0x94, 0x3c, 0x41, 0x50, 0xcc
};
# endif
#endif
#ifdef CONFIG_TESTING_CRYPTO_HASH_UNALIGNED_BUFFER_SIZE
# ifndef CONFIG_TESTING_CRYPTO_HASH_DISABLE_MD5
static const unsigned char md5_unaligned_block_result[16] =
{
/* md5sum of 32640 monotonically increasing bytes from 0x00 */
0x18, 0x8a, 0x1f, 0x86, 0x80, 0x37, 0x39, 0x2a,
0x36, 0xf7, 0x25, 0xb1, 0x98, 0x5b, 0xda, 0xcc
};
# endif
# ifndef CONFIG_TESTING_CRYPTO_HASH_DISABLE_SHA1
static const unsigned char sha1_unaligned_block_result[20] =
{
/* sha1sum 32640 monotonically increasing bytes from 0x00 */
0x5b, 0xec, 0x9f, 0x44, 0xe4, 0x21, 0xe4, 0xf2,
0x41, 0x86, 0xd0, 0x89, 0x45, 0xf1, 0xa8, 0x11,
0x1d, 0xaa, 0x93, 0x51,
};
# endif
# ifndef CONFIG_TESTING_CRYPTO_HASH_DISABLE_SHA224
static const unsigned char sha224_unaligned_block_result[28] =
{
/* sha224sum of 32640 monotonically increasing bytes from 0x00 */
0x90, 0xad, 0x7d, 0x0e, 0x75, 0x60, 0xec, 0xcd,
0xcc, 0x90, 0x02, 0xfb, 0x74, 0xa3, 0xfb, 0x54,
0xbf, 0xcc, 0xca, 0x48, 0x23, 0x1c, 0x9f, 0xcc,
0x25, 0x29, 0xff, 0xd6
};
# endif
# ifndef CONFIG_TESTING_CRYPTO_HASH_DISABLE_SHA256
static const unsigned char sha256_unaligned_block_result[32] =
{
/* sha256sum of 32640 monotonically increasing bytes from 0x00 */
0x6b, 0x5e, 0x17, 0xc4, 0x05, 0x5d, 0xac, 0xdf,
0xc2, 0xff, 0x9e, 0x54, 0xdc, 0x21, 0xee, 0x75,
0x16, 0x97, 0xb2, 0x78, 0xc7, 0xdd, 0x64, 0x26,
0x70, 0xf6, 0xa2, 0xf2, 0xcb, 0x3b, 0x8e, 0x12
};
# endif
# ifndef CONFIG_TESTING_CRYPTO_HASH_DISABLE_SHA512
static const unsigned char sha512_unaligned_block_result[64] =
{
/* sha512sum of 32640 monotonically increasing bytes from 0x00 */
0xfb, 0x03, 0xde, 0x53, 0x92, 0xc6, 0xc5, 0x17,
0x09, 0x10, 0x6c, 0x12, 0x9c, 0xc4, 0x6e, 0x79,
0x37, 0xdd, 0x53, 0x4e, 0x49, 0xa1, 0x8e, 0x27,
0x6d, 0xfd, 0xfb, 0x9c, 0xfa, 0xf7, 0xf4, 0x22,
0x98, 0xfe, 0xd5, 0x9e, 0x5c, 0x89, 0x4e, 0xf9,
0x1a, 0xf7, 0x40, 0x04, 0x0a, 0x49, 0x9e, 0x2a,
0x4e, 0x4d, 0xe6, 0xac, 0x1a, 0xa4, 0x5b, 0xb9,
0x15, 0x10, 0x0d, 0x37, 0x40, 0x8e, 0x8c, 0x29
};
# endif
#endif
static void syshash_free(FAR crypto_context *ctx)
{
if (ctx->crypto_fd != 0)
{
close(ctx->crypto_fd);
ctx->crypto_fd = 0;
}
if (ctx->fd != 0)
{
close(ctx->fd);
ctx->fd = 0;
}
}
static int syshash_init(FAR crypto_context *ctx)
{
memset(ctx, 0, sizeof(crypto_context));
if ((ctx->fd = open("/dev/crypto", O_RDWR, 0)) < 0)
{
warn("CRIOGET");
syshash_free(ctx);
return 1;
}
if (ioctl(ctx->fd, CRIOGET, &ctx->crypto_fd) == -1)
{
warn("CRIOGET");
syshash_free(ctx);
return 1;
}
return 0;
}
static int syshash_start(FAR crypto_context *ctx, int mac)
{
ctx->session.mac = mac;
if (ioctl(ctx->crypto_fd, CIOCGSESSION, &ctx->session) == -1)
{
warn("CIOCGSESSION");
syshash_free(ctx);
return 1;
}
ctx->cryp.ses = ctx->session.ses;
return 0;
}
static int syshash_update(FAR crypto_context *ctx, FAR const char *s,
size_t len)
{
ctx->cryp.op = COP_ENCRYPT;
ctx->cryp.flags |= COP_FLAG_UPDATE;
ctx->cryp.src = (caddr_t) s;
ctx->cryp.len = len;
if (ioctl(ctx->crypto_fd, CIOCCRYPT, &ctx->cryp) == -1)
{
warn("CIOCCRYPT");
return 1;
}
return 0;
}
static int syshash_finish(FAR crypto_context *ctx, FAR unsigned char *out)
{
ctx->cryp.flags = 0;
ctx->cryp.mac = (caddr_t) out;
if (ioctl(ctx->crypto_fd, CIOCCRYPT, &ctx->cryp) == -1)
{
warn("CIOCCRYPT");
return 1;
}
if (ioctl(ctx->crypto_fd, CIOCFSESSION, &ctx->session.ses) == -1)
{
warn("CIOCFSESSION");
return 1;
};
return 0;
}
static int match(const unsigned char *a, const unsigned char *b, size_t len)
{
unsigned int i;
if (memcmp(a, b, len) == 0)
{
return 0;
}
warnx("hash mismatch");
for (i = 0; i < len; i++)
{
printf("%02x", a[i]);
}
printf("\n");
for (i = 0; i < len; i++)
{
printf("%02x", b[i]);
}
printf("\n");
return 1;
}
#ifdef CONFIG_TESTING_CRYPTO_HASH_HUGE_BLOCK
static int testing_hash_huge_block(crypto_context *ctx, int op,
FAR const unsigned char *block, size_t block_size,
FAR const unsigned char *result, size_t reslen)
{
unsigned char output[64];
size_t offset;
size_t buf_size;
int ret = 0;
ret = syshash_start(ctx, op);
if (ret != 0)
{
return ret;
}
/* Huge block tests results were calculated over
* HASH_HUGE_BLOCK_SIZE bytes containing all 'a's.
* If buffer block size isn't that size, repeatedly
* pass buffer into syshash_update() to hash total of
* HASH_HUGE_BLOCK_SIZE bytes of data.
*/
offset = 0;
while (offset < HASH_HUGE_BLOCK_SIZE)
{
buf_size = HASH_HUGE_BLOCK_SIZE - offset;
if (buf_size > block_size)
{
buf_size = block_size;
}
ret = syshash_update(ctx, (char *)block, buf_size);
if (ret != 0)
{
return ret;
}
offset += block_size;
}
ret = syshash_finish(ctx, output);
if (ret != 0)
{
return ret;
}
return match(result, output, reslen);
}
static void report_huge_block_success(const char *hash_type,
uint32_t block_size, uint32_t total_bytes)
{
int npasses;
npasses = (total_bytes + (block_size - 1))
/ block_size;
printf("%s huge block test success(%u passes over"
" %" PRIu32 " bytes to hash %" PRIu32 " bytes)\n",
hash_type, npasses, block_size, total_bytes);
}
#endif
#ifdef CONFIG_TESTING_CRYPTO_HASH_UNALIGNED_BUFFER_SIZE
/* Test unaligned buffer sizes.
* Starting with hashing a zero-length buffer, increase buffer
* size by one byte and hash increasingly larger buffers until
* size reaches 255 bytes (for a total of 32640 bytes).
* At same time buffer data starts from 0x00 and monotonically
* increases (across buffer boundaries) so that the hash is
* performed over 32640 monotonically increasing bytes
* starting with 0x00.
*/
static int testing_hash_unaligned_buffer_size(const char *test,
crypto_context *ctx, int op,
FAR const unsigned char *result, size_t reslen)
{
unsigned char block[256];
unsigned char output[64];
unsigned char byte = 0;
unsigned int block_size;
unsigned int idx;
int ret;
ret = syshash_start(ctx, op);
if (ret != 0)
{
return ret;
}
for (block_size = 0; block_size < 256 ; ++block_size)
{
for (idx = 0; idx < block_size; ++idx)
{
block[idx] = byte++;
}
ret = syshash_update(ctx, (char *)block, block_size);
if (ret < 0)
{
return ret;
}
}
ret = syshash_finish(ctx, output);
if (ret != 0)
{
return ret;
}
ret = match(result, output, reslen);
if (ret)
{
printf("%s unaligned buffer size match failed\n", test);
}
else
{
printf("%s unaligned buffer size match success\n", test);
}
return ret;
}
#endif
/****************************************************************************
* Public Functions
****************************************************************************/
int main(void)
{
#ifndef CONFIG_TESTING_CRYPTO_HASH_DISABLE_MD5
crypto_context md5_ctx;
#endif
#ifndef CONFIG_TESTING_CRYPTO_HASH_DISABLE_SHA1
crypto_context sha1_ctx;
#endif
#ifndef CONFIG_TESTING_CRYPTO_HASH_DISABLE_SHA224
crypto_context sha2_224_ctx;
#endif
#ifndef CONFIG_TESTING_CRYPTO_HASH_DISABLE_SHA256
crypto_context sha2_256_ctx;
#endif
#ifndef CONFIG_TESTING_CRYPTO_HASH_DISABLE_SHA512
crypto_context sha2_512_ctx;
#endif
#ifdef CONFIG_TESTING_CRYPTO_HASH_HUGE_BLOCK
unsigned char *huge_block = NULL;
uint32_t huge_block_size = HASH_HUGE_BLOCK_SIZE;
#endif
unsigned char output[64];
int ret = 0;
unsigned int i;
#if !defined(CONFIG_TESTING_CRYPTO_HASH_DISABLE_SHA1) \
|| !defined(CONFIG_TESTING_CRYPTO_HASH_DISABLE_SHA224) \
|| !defined(CONFIG_TESTING_CRYPTO_HASH_DISABLE_SHA256) \
|| !defined(CONFIG_TESTING_CRYPTO_HASH_DISABLE_SHA512)
unsigned char buf[1024];
int j;
#endif
#ifndef CONFIG_TESTING_CRYPTO_HASH_DISABLE_MD5
ret += syshash_init(&md5_ctx);
#endif
#ifndef CONFIG_TESTING_CRYPTO_HASH_DISABLE_SHA1
ret += syshash_init(&sha1_ctx);
#endif
#ifndef CONFIG_TESTING_CRYPTO_HASH_DISABLE_SHA224
ret += syshash_init(&sha2_224_ctx);
#endif
#ifndef CONFIG_TESTING_CRYPTO_HASH_DISABLE_SHA256
ret += syshash_init(&sha2_256_ctx);
#endif
#ifndef CONFIG_TESTING_CRYPTO_HASH_DISABLE_SHA512
ret += syshash_init(&sha2_512_ctx);
#endif
if (ret != 0)
{
printf("syshash init failed\n");
}
#ifndef CONFIG_TESTING_CRYPTO_HASH_DISABLE_MD5
for (i = 0; i < nitems(md5_testcase); i++)
{
ret = syshash_start(&md5_ctx, CRYPTO_MD5);
if (ret != 0)
{
printf("syshash md5 start failed\n");
goto err;
}
ret = syshash_update(&md5_ctx, md5_testcase[i].data,
md5_testcase[i].datalen);
if (ret)
{
printf("syshash md5 update failed\n");
goto err;
}
ret = syshash_finish(&md5_ctx, output);
if (ret)
{
printf("syshash md5 finish failed\n");
goto err;
}
ret = match(md5_result[i], output, MD5_DIGEST_LENGTH);
if (ret)
{
printf("match md5 failed\n");
goto err;
}
else
{
printf("hash md5 success\n");
}
}
#endif
#ifndef CONFIG_TESTING_CRYPTO_HASH_DISABLE_SHA1
for (i = 0; i < nitems(sha_testcase); i++)
{
ret = syshash_start(&sha1_ctx, CRYPTO_SHA1);
if (ret != 0)
{
printf("syshash sha1 start failed\n");
goto err;
}
if (i == 2)
{
memset(buf, 'a', sha_testcase[i].datalen);
for (j = 0; j < 1000; j++)
{
ret = syshash_update(&sha1_ctx, (char *)buf,
sha_testcase[i].datalen);
if (ret)
{
break;
}
}
}
else
{
ret = syshash_update(&sha1_ctx, sha_testcase[i].data,
sha_testcase[i].datalen);
}
if (ret)
{
printf("sha1 update failed\n");
goto err;
}
ret = syshash_finish(&sha1_ctx, output);
if (ret)
{
printf("sha1 finish failed\n");
goto err;
}
ret = match((unsigned char *)sha1_result[i],
(unsigned char *)output,
SHA1_DIGEST_LENGTH);
if (ret)
{
printf("match sha1 failed\n");
goto err;
}
else
{
printf("hash sha1 success\n");
}
}
#endif
#ifndef CONFIG_TESTING_CRYPTO_HASH_DISABLE_SHA224
for (i = 0; i < nitems(sha_testcase); i++)
{
ret = syshash_start(&sha2_224_ctx, CRYPTO_SHA2_224);
if (ret != 0)
{
printf("sha224 start failed\n");
goto err;
}
if (i == 2)
{
memset(buf, 'a', sha_testcase[i].datalen);
for (j = 0; j < 1000; j++)
{
ret = syshash_update(&sha2_224_ctx, (char *)buf,
sha_testcase[i].datalen);
if (ret)
{
break;
}
}
}
else
{
ret = syshash_update(&sha2_224_ctx, sha_testcase[i].data,
sha_testcase[i].datalen);
}
if (ret)
{
printf("sha224 update failed\n");
goto err;
}
ret = syshash_finish(&sha2_224_ctx, output);
if (ret)
{
printf("sha224 finish failed\n");
}
ret = match((unsigned char *)sha224_result[i],
(unsigned char *)output,
SHA224_DIGEST_LENGTH);
if (ret)
{
printf("match sha224 failed\n");
}
else
{
printf("hash sha224 success\n");
}
}
#endif
#ifndef CONFIG_TESTING_CRYPTO_HASH_DISABLE_SHA256
for (i = 0; i < nitems(sha_testcase); i++)
{
ret = syshash_start(&sha2_256_ctx, CRYPTO_SHA2_256);
if (ret != 0)
{
printf("sha256 start failed\n");
goto err;
}
if (i == 2)
{
memset(buf, 'a', sha_testcase[i].datalen);
for (j = 0; j < 1000; j++)
{
ret = syshash_update(&sha2_256_ctx, (char *)buf,
sha_testcase[i].datalen);
if (ret)
{
break;
}
}
}
else
{
ret = syshash_update(&sha2_256_ctx, sha_testcase[i].data,
sha_testcase[i].datalen);
}
if (ret)
{
printf("sha256 update failed\n");
goto err;
}
ret = syshash_finish(&sha2_256_ctx, output);
if (ret)
{
printf("sha256 finish failed\n");
}
ret = match((unsigned char *)sha256_result[i],
(unsigned char *)output,
SHA256_DIGEST_LENGTH);
if (ret)
{
printf("match sha256 failed\n");
}
else
{
printf("hash sha256 success\n");
}
}
#endif
#ifndef CONFIG_TESTING_CRYPTO_HASH_DISABLE_SHA512
for (i = 0; i < nitems(sha512_testcase); i++)
{
ret = syshash_start(&sha2_512_ctx, CRYPTO_SHA2_512);
if (ret != 0)
{
printf("sha512 start failed\n");
goto err;
}
if (i == 2)
{
memset(buf, 'a', sha512_testcase[i].datalen);
for (j = 0; j < 1000; j++)
{
ret = syshash_update(&sha2_512_ctx, (char *)buf,
sha512_testcase[i].datalen);
if (ret)
{
break;
}
}
}
else
{
ret = syshash_update(&sha2_512_ctx, sha512_testcase[i].data,
sha512_testcase[i].datalen);
}
if (ret)
{
printf("sha512 update failed\n");
goto err;
}
ret = syshash_finish(&sha2_512_ctx, output);
if (ret)
{
printf("sha512 finish failed\n");
goto err;
}
ret = match((unsigned char *)sha512_result[i],
(unsigned char *)output,
SHA512_DIGEST_LENGTH);
if (ret)
{
printf("match sha512 failed\n");
goto err;
}
else
{
printf("hash sha512 success\n");
}
}
#endif
#ifdef CONFIG_TESTING_CRYPTO_HASH_HUGE_BLOCK
/* Loop trying to allocate a huge block, cutting requested
* size in half until success.
*/
do
{
huge_block = (unsigned char *)malloc(huge_block_size);
huge_block_size /= 2;
}
while (!huge_block && (huge_block_size > 1));
if (huge_block == NULL)
{
printf("huge block test no memory\n");
goto err;
}
memset(huge_block, 'a', huge_block_size);
# ifndef CONFIG_TESTING_CRYPTO_HASH_DISABLE_MD5
ret = testing_hash_huge_block(&md5_ctx, CRYPTO_MD5,
huge_block, huge_block_size,
md5_huge_block_result,
MD5_DIGEST_LENGTH);
if (ret != 0)
{
printf("md5 huge block test failed\n");
goto err;
}
else
{
report_huge_block_success("md5", huge_block_size,
HASH_HUGE_BLOCK_SIZE);
}
# endif
# ifndef CONFIG_TESTING_CRYPTO_HASH_DISABLE_SHA1
ret = testing_hash_huge_block(&sha1_ctx, CRYPTO_SHA1,
huge_block, huge_block_size,
sha1_huge_block_result,
SHA1_DIGEST_LENGTH);
if (ret != 0)
{
printf("sha1 huge block test failed\n");
goto err;
}
else
{
report_huge_block_success("sha1", huge_block_size,
HASH_HUGE_BLOCK_SIZE);
}
#endif
# ifndef CONFIG_TESTING_CRYPTO_HASH_DISABLE_SHA224
ret = testing_hash_huge_block(&sha2_224_ctx, CRYPTO_SHA2_224,
huge_block, huge_block_size,
sha224_huge_block_result,
SHA224_DIGEST_LENGTH);
if (ret != 0)
{
printf("sha224 huge block test failed\n");
goto err;
}
else
{
report_huge_block_success("sha224", huge_block_size,
HASH_HUGE_BLOCK_SIZE);
}
# endif
# ifndef CONFIG_TESTING_CRYPTO_HASH_DISABLE_SHA256
ret = testing_hash_huge_block(&sha2_256_ctx, CRYPTO_SHA2_256,
huge_block, huge_block_size,
sha256_huge_block_result,
SHA256_DIGEST_LENGTH);
if (ret != 0)
{
printf("sha256 huge block test failed\n");
goto err;
}
else
{
report_huge_block_success("sha256", huge_block_size,
HASH_HUGE_BLOCK_SIZE);
}
# endif
# ifndef CONFIG_TESTING_CRYPTO_HASH_DISABLE_SHA512
ret = testing_hash_huge_block(&sha2_512_ctx, CRYPTO_SHA2_512,
huge_block, huge_block_size,
sha512_huge_block_result,
SHA512_DIGEST_LENGTH);
if (ret != 0)
{
printf("sha512 huge block test failed\n");
goto err;
}
else
{
report_huge_block_success("sha512", huge_block_size,
HASH_HUGE_BLOCK_SIZE);
}
# endif
#endif
#ifdef CONFIG_TESTING_CRYPTO_HASH_UNALIGNED_BUFFER_SIZE
# ifndef CONFIG_TESTING_CRYPTO_HASH_DISABLE_MD5
ret = testing_hash_unaligned_buffer_size("md5", &md5_ctx, CRYPTO_MD5,
md5_unaligned_block_result,
MD5_DIGEST_LENGTH);
if (ret < 0)
{
goto err;
}
# endif
# ifndef CONFIG_TESTING_CRYPTO_HASH_DISABLE_SHA1
ret = testing_hash_unaligned_buffer_size("sha1", &sha1_ctx, CRYPTO_SHA1,
sha1_unaligned_block_result,
SHA1_DIGEST_LENGTH);
if (ret < 0)
{
goto err;
}
# endif
# ifndef CONFIG_TESTING_CRYPTO_HASH_DISABLE_SHA224
ret = testing_hash_unaligned_buffer_size("sha244", &sha2_224_ctx,
CRYPTO_SHA2_224,
sha224_unaligned_block_result,
SHA224_DIGEST_LENGTH);
if (ret < 0)
{
goto err;
}
# endif
# ifndef CONFIG_TESTING_CRYPTO_HASH_DISABLE_SHA256
ret = testing_hash_unaligned_buffer_size("sha256", &sha2_256_ctx,
CRYPTO_SHA2_256,
sha256_unaligned_block_result,
SHA256_DIGEST_LENGTH);
if (ret < 0)
{
goto err;
}
# endif
# ifndef CONFIG_TESTING_CRYPTO_HASH_DISABLE_SHA512
ret = testing_hash_unaligned_buffer_size("sha512", &sha2_512_ctx,
CRYPTO_SHA2_512,
sha512_unaligned_block_result,
SHA512_DIGEST_LENGTH);
if (ret < 0)
{
goto err;
}
# endif
#endif
err:
#ifdef CONFIG_TESTING_CRYPTO_HASH_HUGE_BLOCK
free(huge_block);
#endif
#ifndef CONFIG_TESTING_CRYPTO_HASH_DISABLE_MD5
syshash_free(&md5_ctx);
#endif
#ifndef CONFIG_TESTING_CRYPTO_HASH_DISABLE_SHA1
syshash_free(&sha1_ctx);
#endif
#ifndef CONFIG_TESTING_CRYPTO_HASH_DISABLE_SHA224
syshash_free(&sha2_224_ctx);
#endif
#ifndef CONFIG_TESTING_CRYPTO_HASH_DISABLE_SHA256
syshash_free(&sha2_256_ctx);
#endif
#ifndef CONFIG_TESTING_CRYPTO_HASH_DISABLE_SHA512
syshash_free(&sha2_512_ctx);
#endif
return 0;
}
Reference in a new issue View git blame Copy permalink