This is an automated email from the ASF dual-hosted git repository.
xiaoxiang781216 pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/nuttx-apps.git
The following commit(s) were added to refs/heads/master by this push:
new 499352fb0 testing/drivers/hash: Add unaligned buffer size test
499352fb0 is described below
commit 499352fb0c2de46113001ab8abd1194531969c30
Author: Peter Barada <[email protected]>
AuthorDate: Tue Jun 2 19:42:55 2026 -0400
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 <[email protected]>
---
testing/drivers/crypto/Kconfig | 29 ++++++
testing/drivers/crypto/hash.c | 207 +++++++++++++++++++++++++++++++++++++++--
2 files changed, 230 insertions(+), 6 deletions(-)
diff --git a/testing/drivers/crypto/Kconfig b/testing/drivers/crypto/Kconfig
index 83d10889b..4ceea2738 100644
--- a/testing/drivers/crypto/Kconfig
+++ b/testing/drivers/crypto/Kconfig
@@ -36,6 +36,10 @@ config TESTING_CRYPTO_HASH_HUGE_BLOCK
bool "hash huge block crypto test"
default y
+config TESTING_CRYPTO_HASH_UNALIGNED_BUFFER_SIZE
+ bool "hash unaligned buffer size test"
+ default y
+
config TESTING_CRYPTO_HASH_DISABLE_MD5
bool "disable md5 tests"
default n
@@ -56,6 +60,31 @@ config TESTING_CRYPTO_HASH_DISABLE_SHA512
bool "disable sha512 tests"
default n
+config TESTING_CRYPTO_HASH_DISABLE_UNALIGNED_MD5
+ bool "disable unaligned md5 tests"
+ depends on !TESTING_CRYPTO_HASH_DISABLE_MD5
+ default n
+
+config TESTING_CRYPTO_HASH_DISABLE_UNALIGNED_SHA1
+ bool "disable unaligned sha1 tests"
+ depends on !TESTING_CRYPTO_HASH_DISABLE_SHA1
+ default n
+
+config TESTING_CRYPTO_HASH_DISABLE_UNALIGNED_SHA224
+ bool "disable unaligned sha224 tests"
+ depends on !TESTING_CRYPTO_HASH_DISABLE_SHA224
+ default n
+
+config TESTING_CRYPTO_HASH_DISABLE_UNALIGNED_SHA256
+ bool "disable unaligned sha256 tests"
+ depends on !TESTING_CRYPTO_HASH_DISABLE_SHA256
+ default n
+
+config TESTING_CRYPTO_HASH_DISABLE_UNALIGNED_SHA512
+ bool "disable unaligned sha512 tests"
+ depends on !TESTING_CRYPTO_HASH_DISABLE_SHA512
+ default n
+
endif
config TESTING_CRYPTO_CRC32
diff --git a/testing/drivers/crypto/hash.c b/testing/drivers/crypto/hash.c
index 1638bed70..afa7e94fe 100644
--- a/testing/drivers/crypto/hash.c
+++ b/testing/drivers/crypto/hash.c
@@ -295,6 +295,69 @@ static const unsigned char sha512_huge_block_result[64] =
# 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)
@@ -382,7 +445,7 @@ static int syshash_finish(FAR crypto_context *ctx, FAR
unsigned char *out)
static int match(const unsigned char *a, const unsigned char *b, size_t len)
{
- int i;
+ unsigned int i;
if (memcmp(a, b, len) == 0)
{
@@ -469,6 +532,69 @@ static void report_huge_block_success(const char
*hash_type,
}
#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
****************************************************************************/
@@ -489,12 +615,21 @@ int main(void)
#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];
- unsigned char buf[1024];
int ret = 0;
- int i;
+ 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);
@@ -779,8 +914,6 @@ int main(void)
#endif
#ifdef CONFIG_TESTING_CRYPTO_HASH_HUGE_BLOCK
- unsigned char *huge_block;
- uint32_t huge_block_size = HASH_HUGE_BLOCK_SIZE;
/* Loop trying to allocate a huge block, cutting requested
* size in half until success.
*/
@@ -807,6 +940,7 @@ int main(void)
if (ret != 0)
{
printf("md5 huge block test failed\n");
+ goto err;
}
else
{
@@ -824,6 +958,7 @@ int main(void)
if (ret != 0)
{
printf("sha1 huge block test failed\n");
+ goto err;
}
else
{
@@ -841,6 +976,7 @@ int main(void)
if (ret != 0)
{
printf("sha224 huge block test failed\n");
+ goto err;
}
else
{
@@ -858,6 +994,7 @@ int main(void)
if (ret != 0)
{
printf("sha256 huge block test failed\n");
+ goto err;
}
else
{
@@ -875,6 +1012,7 @@ int main(void)
if (ret != 0)
{
printf("sha512 huge block test failed\n");
+ goto err;
}
else
{
@@ -883,10 +1021,67 @@ int main(void)
}
# endif
- free(huge_block);
+#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
