Commit a1afe274 authored by David Sterba's avatar David Sterba Committed by Herbert Xu

crypto: testmgr - add test vectors for blake2b

Test vectors for blake2b with various digest sizes. As the algorithm is
the same up to the digest calculation, the key and input data length is
distributed in a way that tests all combinanions of the two over the
digest sizes.

Based on the suggestion from Eric, the following input sizes are tested
[0, 1, 7, 15, 64, 247, 256], where blake2b blocksize is 128, so the
padded and the non-padded input buffers are tested.

          blake2b-160  blake2b-256  blake2b-384  blake2b-512
         ---------------------------------------------------
len=0   | klen=0       klen=1       klen=32      klen=64
len=1   | klen=32      klen=64      klen=0       klen=1
len=7   | klen=64      klen=0       klen=1       klen=32
len=15  | klen=1       klen=32      klen=64      klen=0
len=64  | klen=0       klen=1       klen=32      klen=64
len=247 | klen=32      klen=64      klen=0       klen=1
len=256 | klen=64      klen=0       klen=1       klen=32

Where key:

- klen=0: empty key
- klen=1: 1 byte value 0x42, 'B'
- klen=32: first 32 bytes of the default key, sequence 00..1f
- klen=64: default key, sequence 00..3f

The unkeyed vectors are ordered before keyed, as this is required by
testmgr.

CC: Eric Biggers <ebiggers@kernel.org>
Signed-off-by: default avatarDavid Sterba <dsterba@suse.com>
Signed-off-by: default avatarHerbert Xu <herbert@gondor.apana.org.au>
parent 91d68933
...@@ -4022,6 +4022,34 @@ static const struct alg_test_desc alg_test_descs[] = { ...@@ -4022,6 +4022,34 @@ static const struct alg_test_desc alg_test_descs[] = {
.alg = "authenc(hmac(sha512),rfc3686(ctr(aes)))", .alg = "authenc(hmac(sha512),rfc3686(ctr(aes)))",
.test = alg_test_null, .test = alg_test_null,
.fips_allowed = 1, .fips_allowed = 1,
}, {
.alg = "blake2b-160",
.test = alg_test_hash,
.fips_allowed = 0,
.suite = {
.hash = __VECS(blake2b_160_tv_template)
}
}, {
.alg = "blake2b-256",
.test = alg_test_hash,
.fips_allowed = 0,
.suite = {
.hash = __VECS(blake2b_256_tv_template)
}
}, {
.alg = "blake2b-384",
.test = alg_test_hash,
.fips_allowed = 0,
.suite = {
.hash = __VECS(blake2b_384_tv_template)
}
}, {
.alg = "blake2b-512",
.test = alg_test_hash,
.fips_allowed = 0,
.suite = {
.hash = __VECS(blake2b_512_tv_template)
}
}, { }, {
.alg = "cbc(aes)", .alg = "cbc(aes)",
.test = alg_test_skcipher, .test = alg_test_skcipher,
......
...@@ -31942,4 +31942,311 @@ static const struct aead_testvec essiv_hmac_sha256_aes_cbc_tv_temp[] = { ...@@ -31942,4 +31942,311 @@ static const struct aead_testvec essiv_hmac_sha256_aes_cbc_tv_temp[] = {
}, },
}; };
static const char blake2b_ordered_sequence[] =
"\x00\x01\x02\x03\x04\x05\x06\x07"
"\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
"\x10\x11\x12\x13\x14\x15\x16\x17"
"\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f"
"\x20\x21\x22\x23\x24\x25\x26\x27"
"\x28\x29\x2a\x2b\x2c\x2d\x2e\x2f"
"\x30\x31\x32\x33\x34\x35\x36\x37"
"\x38\x39\x3a\x3b\x3c\x3d\x3e\x3f"
"\x40\x41\x42\x43\x44\x45\x46\x47"
"\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f"
"\x50\x51\x52\x53\x54\x55\x56\x57"
"\x58\x59\x5a\x5b\x5c\x5d\x5e\x5f"
"\x60\x61\x62\x63\x64\x65\x66\x67"
"\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f"
"\x70\x71\x72\x73\x74\x75\x76\x77"
"\x78\x79\x7a\x7b\x7c\x7d\x7e\x7f"
"\x80\x81\x82\x83\x84\x85\x86\x87"
"\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f"
"\x90\x91\x92\x93\x94\x95\x96\x97"
"\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f"
"\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7"
"\xa8\xa9\xaa\xab\xac\xad\xae\xaf"
"\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7"
"\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf"
"\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7"
"\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf"
"\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7"
"\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf"
"\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7"
"\xe8\xe9\xea\xeb\xec\xed\xee\xef"
"\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7"
"\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff";
static const struct hash_testvec blake2b_160_tv_template[] = {{
.digest = (u8[]){ 0x33, 0x45, 0x52, 0x4a, 0xbf, 0x6b, 0xbe, 0x18,
0x09, 0x44, 0x92, 0x24, 0xb5, 0x97, 0x2c, 0x41,
0x79, 0x0b, 0x6c, 0xf2, },
}, {
.plaintext = blake2b_ordered_sequence,
.psize = 64,
.digest = (u8[]){ 0x11, 0xcc, 0x66, 0x61, 0xe9, 0x22, 0xb0, 0xe4,
0x07, 0xe0, 0xa5, 0x72, 0x49, 0xc3, 0x8d, 0x4f,
0xf7, 0x6d, 0x8e, 0xc8, },
}, {
.ksize = 32,
.key = blake2b_ordered_sequence,
.plaintext = blake2b_ordered_sequence,
.psize = 1,
.digest = (u8[]){ 0x31, 0xe3, 0xd9, 0xd5, 0x4e, 0x72, 0xd8, 0x0b,
0x2b, 0x3b, 0xd7, 0x6b, 0x82, 0x7a, 0x1d, 0xfb,
0x56, 0x2f, 0x79, 0x4c, },
}, {
.ksize = 64,
.key = blake2b_ordered_sequence,
.plaintext = blake2b_ordered_sequence,
.psize = 7,
.digest = (u8[]){ 0x28, 0x20, 0xd1, 0xbe, 0x7f, 0xcc, 0xc1, 0x62,
0xd9, 0x0d, 0x9a, 0x4b, 0x47, 0xd1, 0x5e, 0x04,
0x74, 0x2a, 0x53, 0x17, },
}, {
.ksize = 1,
.key = "B",
.plaintext = blake2b_ordered_sequence,
.psize = 15,
.digest = (u8[]){ 0x45, 0xe9, 0x95, 0xb6, 0xc4, 0xe8, 0x22, 0xea,
0xfe, 0xd2, 0x37, 0xdb, 0x46, 0xbf, 0xf1, 0x25,
0xd5, 0x03, 0x1d, 0x81, },
}, {
.ksize = 32,
.key = blake2b_ordered_sequence,
.plaintext = blake2b_ordered_sequence,
.psize = 247,
.digest = (u8[]){ 0x7e, 0xb9, 0xf2, 0x9b, 0x2f, 0xc2, 0x01, 0xd4,
0xb0, 0x4f, 0x08, 0x2b, 0x8e, 0xbd, 0x06, 0xef,
0x1c, 0xc4, 0x25, 0x95, },
}, {
.ksize = 64,
.key = blake2b_ordered_sequence,
.plaintext = blake2b_ordered_sequence,
.psize = 256,
.digest = (u8[]){ 0x6e, 0x35, 0x01, 0x70, 0xbf, 0xb6, 0xc4, 0xba,
0x33, 0x1b, 0xa6, 0xd3, 0xc2, 0x5d, 0xb4, 0x03,
0x95, 0xaf, 0x29, 0x16, },
}};
static const struct hash_testvec blake2b_256_tv_template[] = {{
.plaintext = blake2b_ordered_sequence,
.psize = 7,
.digest = (u8[]){ 0x9d, 0xf1, 0x4b, 0x72, 0x48, 0x76, 0x4a, 0x86,
0x91, 0x97, 0xc3, 0x5e, 0x39, 0x2d, 0x2a, 0x6d,
0x6f, 0xdc, 0x5b, 0x79, 0xd5, 0x97, 0x29, 0x79,
0x20, 0xfd, 0x3f, 0x14, 0x91, 0xb4, 0x42, 0xd2, },
}, {
.plaintext = blake2b_ordered_sequence,
.psize = 256,
.digest = (u8[]){ 0x39, 0xa7, 0xeb, 0x9f, 0xed, 0xc1, 0x9a, 0xab,
0xc8, 0x34, 0x25, 0xc6, 0x75, 0x5d, 0xd9, 0x0e,
0x6f, 0x9d, 0x0c, 0x80, 0x49, 0x64, 0xa1, 0xf4,
0xaa, 0xee, 0xa3, 0xb9, 0xfb, 0x59, 0x98, 0x35, },
}, {
.ksize = 1,
.key = "B",
.digest = (u8[]){ 0xc3, 0x08, 0xb1, 0xbf, 0xe4, 0xf9, 0xbc, 0xb4,
0x75, 0xaf, 0x3f, 0x59, 0x6e, 0xae, 0xde, 0x6a,
0xa3, 0x8e, 0xb5, 0x94, 0xad, 0x30, 0xf0, 0x17,
0x1c, 0xfb, 0xd8, 0x3e, 0x8a, 0xbe, 0xed, 0x9c, },
}, {
.ksize = 64,
.key = blake2b_ordered_sequence,
.plaintext = blake2b_ordered_sequence,
.psize = 1,
.digest = (u8[]){ 0x34, 0x75, 0x8b, 0x64, 0x71, 0x35, 0x62, 0x82,
0x97, 0xfb, 0x09, 0xc7, 0x93, 0x0c, 0xd0, 0x4e,
0x95, 0x28, 0xe5, 0x66, 0x91, 0x12, 0xf5, 0xb1,
0x31, 0x84, 0x93, 0xe1, 0x4d, 0xe7, 0x7e, 0x55, },
}, {
.ksize = 32,
.key = blake2b_ordered_sequence,
.plaintext = blake2b_ordered_sequence,
.psize = 15,
.digest = (u8[]){ 0xce, 0x74, 0xa9, 0x2e, 0xe9, 0x40, 0x3d, 0xa2,
0x11, 0x4a, 0x99, 0x25, 0x7a, 0x34, 0x5d, 0x35,
0xdf, 0x6a, 0x48, 0x79, 0x2a, 0x93, 0x93, 0xff,
0x1f, 0x3c, 0x39, 0xd0, 0x71, 0x1f, 0x20, 0x7b, },
}, {
.ksize = 1,
.key = "B",
.plaintext = blake2b_ordered_sequence,
.psize = 64,
.digest = (u8[]){ 0x2e, 0x84, 0xdb, 0xa2, 0x5f, 0x0e, 0xe9, 0x52,
0x79, 0x50, 0x69, 0x9f, 0xf1, 0xfd, 0xfc, 0x9d,
0x89, 0x83, 0xa9, 0xb6, 0xa4, 0xd5, 0xfa, 0xb5,
0xbe, 0x35, 0x1a, 0x17, 0x8a, 0x2c, 0x7f, 0x7d, },
}, {
.ksize = 64,
.key = blake2b_ordered_sequence,
.plaintext = blake2b_ordered_sequence,
.psize = 247,
.digest = (u8[]){ 0x2e, 0x26, 0xf0, 0x09, 0x02, 0x65, 0x90, 0x09,
0xcc, 0xf5, 0x4c, 0x44, 0x74, 0x0e, 0xa0, 0xa8,
0x25, 0x4a, 0xda, 0x61, 0x56, 0x95, 0x7d, 0x3f,
0x6d, 0xc0, 0x43, 0x17, 0x95, 0x89, 0xcd, 0x9d, },
}};
static const struct hash_testvec blake2b_384_tv_template[] = {{
.plaintext = blake2b_ordered_sequence,
.psize = 1,
.digest = (u8[]){ 0xcc, 0x01, 0x08, 0x85, 0x36, 0xf7, 0x84, 0xf0,
0xbb, 0x76, 0x9e, 0x41, 0xc4, 0x95, 0x7b, 0x6d,
0x0c, 0xde, 0x1f, 0xcc, 0x8c, 0xf1, 0xd9, 0x1f,
0xc4, 0x77, 0xd4, 0xdd, 0x6e, 0x3f, 0xbf, 0xcd,
0x43, 0xd1, 0x69, 0x8d, 0x14, 0x6f, 0x34, 0x8b,
0x2c, 0x36, 0xa3, 0x39, 0x68, 0x2b, 0xec, 0x3f, },
}, {
.plaintext = blake2b_ordered_sequence,
.psize = 247,
.digest = (u8[]){ 0xc8, 0xf8, 0xf0, 0xa2, 0x69, 0xfa, 0xcc, 0x4d,
0x32, 0x5f, 0x13, 0x88, 0xca, 0x71, 0x99, 0x8f,
0xf7, 0x30, 0x41, 0x5d, 0x6e, 0x34, 0xb7, 0x6e,
0x3e, 0xd0, 0x46, 0xb6, 0xca, 0x30, 0x66, 0xb2,
0x6f, 0x0c, 0x35, 0x54, 0x17, 0xcd, 0x26, 0x1b,
0xef, 0x48, 0x98, 0xe0, 0x56, 0x7c, 0x05, 0xd2, },
}, {
.ksize = 32,
.key = blake2b_ordered_sequence,
.digest = (u8[]){ 0x15, 0x09, 0x7a, 0x90, 0x13, 0x23, 0xab, 0x0c,
0x0b, 0x43, 0x21, 0x9a, 0xb5, 0xc6, 0x0c, 0x2e,
0x7c, 0x57, 0xfc, 0xcc, 0x4b, 0x0f, 0xf0, 0x57,
0xb7, 0x9c, 0xe7, 0x0f, 0xe1, 0x57, 0xac, 0x37,
0x77, 0xd4, 0xf4, 0x2f, 0x03, 0x3b, 0x64, 0x09,
0x84, 0xa0, 0xb3, 0x24, 0xb7, 0xae, 0x47, 0x5e, },
}, {
.ksize = 1,
.key = "B",
.plaintext = blake2b_ordered_sequence,
.psize = 7,
.digest = (u8[]){ 0x0b, 0x82, 0x88, 0xca, 0x05, 0x2f, 0x1b, 0x15,
0xdc, 0xbb, 0x22, 0x27, 0x11, 0x6b, 0xf4, 0xd1,
0xe9, 0x8f, 0x1b, 0x0b, 0x58, 0x3f, 0x5e, 0x86,
0x80, 0x82, 0x6f, 0x8e, 0x54, 0xc1, 0x9f, 0x12,
0xcf, 0xe9, 0x56, 0xc1, 0xfc, 0x1a, 0x08, 0xb9,
0x4a, 0x57, 0x0a, 0x76, 0x3c, 0x15, 0x33, 0x18, },
}, {
.ksize = 64,
.key = blake2b_ordered_sequence,
.plaintext = blake2b_ordered_sequence,
.psize = 15,
.digest = (u8[]){ 0x4a, 0x81, 0x55, 0xb9, 0x79, 0x42, 0x8c, 0xc6,
0x4f, 0xfe, 0xca, 0x82, 0x3b, 0xb2, 0xf7, 0xbc,
0x5e, 0xfc, 0xab, 0x09, 0x1c, 0xd6, 0x3b, 0xe1,
0x50, 0x82, 0x3b, 0xde, 0xc7, 0x06, 0xee, 0x3b,
0x29, 0xce, 0xe5, 0x68, 0xe0, 0xff, 0xfa, 0xe1,
0x7a, 0xf1, 0xc0, 0xfe, 0x57, 0xf4, 0x60, 0x49, },
}, {
.ksize = 32,
.key = blake2b_ordered_sequence,
.plaintext = blake2b_ordered_sequence,
.psize = 64,
.digest = (u8[]){ 0x34, 0xbd, 0xe1, 0x99, 0x43, 0x9f, 0x82, 0x72,
0xe7, 0xed, 0x94, 0x9e, 0xe1, 0x84, 0xee, 0x82,
0xfd, 0x26, 0x23, 0xc4, 0x17, 0x8d, 0xf5, 0x04,
0xeb, 0xb7, 0xbc, 0xb8, 0xf3, 0x68, 0xb7, 0xad,
0x94, 0x8e, 0x05, 0x3f, 0x8a, 0x5d, 0x8d, 0x81,
0x3e, 0x88, 0xa7, 0x8c, 0xa2, 0xd5, 0xdc, 0x76, },
}, {
.ksize = 1,
.key = "B",
.plaintext = blake2b_ordered_sequence,
.psize = 256,
.digest = (u8[]){ 0x22, 0x14, 0xf4, 0xb0, 0x4c, 0xa8, 0xb5, 0x7d,
0xa7, 0x5c, 0x04, 0xeb, 0xd8, 0x8d, 0x04, 0x71,
0xc7, 0x3c, 0xc7, 0x6e, 0x8b, 0x20, 0x36, 0x40,
0x9d, 0xd0, 0x60, 0xc6, 0xe3, 0x0b, 0x6e, 0x50,
0xf5, 0xaf, 0xf5, 0xc6, 0x3b, 0xe3, 0x84, 0x6a,
0x93, 0x1b, 0x12, 0xd6, 0x18, 0x27, 0xba, 0x36, },
}};
static const struct hash_testvec blake2b_512_tv_template[] = {{
.plaintext = blake2b_ordered_sequence,
.psize = 15,
.digest = (u8[]){ 0x44, 0x4b, 0x24, 0x0f, 0xe3, 0xed, 0x86, 0xd0,
0xe2, 0xef, 0x4c, 0xe7, 0xd8, 0x51, 0xed, 0xde,
0x22, 0x15, 0x55, 0x82, 0xaa, 0x09, 0x14, 0x79,
0x7b, 0x72, 0x6c, 0xd0, 0x58, 0xb6, 0xf4, 0x59,
0x32, 0xe0, 0xe1, 0x29, 0x51, 0x68, 0x76, 0x52,
0x7b, 0x1d, 0xd8, 0x8f, 0xc6, 0x6d, 0x71, 0x19,
0xf4, 0xab, 0x3b, 0xed, 0x93, 0xa6, 0x1a, 0x0e,
0x2d, 0x2d, 0x2a, 0xea, 0xc3, 0x36, 0xd9, 0x58, },
}, {
.ksize = 64,
.key = blake2b_ordered_sequence,
.digest = (u8[]){ 0x10, 0xeb, 0xb6, 0x77, 0x00, 0xb1, 0x86, 0x8e,
0xfb, 0x44, 0x17, 0x98, 0x7a, 0xcf, 0x46, 0x90,
0xae, 0x9d, 0x97, 0x2f, 0xb7, 0xa5, 0x90, 0xc2,
0xf0, 0x28, 0x71, 0x79, 0x9a, 0xaa, 0x47, 0x86,
0xb5, 0xe9, 0x96, 0xe8, 0xf0, 0xf4, 0xeb, 0x98,
0x1f, 0xc2, 0x14, 0xb0, 0x05, 0xf4, 0x2d, 0x2f,
0xf4, 0x23, 0x34, 0x99, 0x39, 0x16, 0x53, 0xdf,
0x7a, 0xef, 0xcb, 0xc1, 0x3f, 0xc5, 0x15, 0x68, },
}, {
.ksize = 1,
.key = "B",
.plaintext = blake2b_ordered_sequence,
.psize = 1,
.digest = (u8[]){ 0xd2, 0x11, 0x31, 0x29, 0x3f, 0xea, 0xca, 0x72,
0x21, 0xe4, 0x06, 0x65, 0x05, 0x2a, 0xd1, 0x02,
0xc0, 0x8d, 0x7b, 0xf1, 0x09, 0x3c, 0xef, 0x88,
0xe1, 0x68, 0x0c, 0xf1, 0x3b, 0xa4, 0xe3, 0x03,
0xed, 0xa0, 0xe3, 0x60, 0x58, 0xa0, 0xdb, 0x52,
0x8a, 0x66, 0x43, 0x09, 0x60, 0x1a, 0xbb, 0x67,
0xc5, 0x84, 0x31, 0x40, 0xfa, 0xde, 0xc1, 0xd0,
0xff, 0x3f, 0x4a, 0x69, 0xd9, 0x92, 0x26, 0x86, },
}, {
.ksize = 32,
.key = blake2b_ordered_sequence,
.plaintext = blake2b_ordered_sequence,
.psize = 7,
.digest = (u8[]){ 0xa3, 0x3e, 0x50, 0xbc, 0xfb, 0xd9, 0xf0, 0x82,
0xa6, 0xd1, 0xdf, 0xaf, 0x82, 0xd0, 0xcf, 0x84,
0x9a, 0x25, 0x3c, 0xae, 0x6d, 0xb5, 0xaf, 0x01,
0xd7, 0xaf, 0xed, 0x50, 0xdc, 0xe2, 0xba, 0xcc,
0x8c, 0x38, 0xf5, 0x16, 0x89, 0x38, 0x86, 0xce,
0x68, 0x10, 0x63, 0x64, 0xa5, 0x79, 0x53, 0xb5,
0x2e, 0x8e, 0xbc, 0x0a, 0xce, 0x95, 0xc0, 0x1e,
0x69, 0x59, 0x1d, 0x3b, 0xd8, 0x19, 0x90, 0xd7, },
}, {
.ksize = 64,
.key = blake2b_ordered_sequence,
.plaintext = blake2b_ordered_sequence,
.psize = 64,
.digest = (u8[]){ 0x65, 0x67, 0x6d, 0x80, 0x06, 0x17, 0x97, 0x2f,
0xbd, 0x87, 0xe4, 0xb9, 0x51, 0x4e, 0x1c, 0x67,
0x40, 0x2b, 0x7a, 0x33, 0x10, 0x96, 0xd3, 0xbf,
0xac, 0x22, 0xf1, 0xab, 0xb9, 0x53, 0x74, 0xab,
0xc9, 0x42, 0xf1, 0x6e, 0x9a, 0xb0, 0xea, 0xd3,
0x3b, 0x87, 0xc9, 0x19, 0x68, 0xa6, 0xe5, 0x09,
0xe1, 0x19, 0xff, 0x07, 0x78, 0x7b, 0x3e, 0xf4,
0x83, 0xe1, 0xdc, 0xdc, 0xcf, 0x6e, 0x30, 0x22, },
}, {
.ksize = 1,
.key = "B",
.plaintext = blake2b_ordered_sequence,
.psize = 247,
.digest = (u8[]){ 0xc2, 0x96, 0x2c, 0x6b, 0x84, 0xff, 0xee, 0xea,
0x9b, 0xb8, 0x55, 0x2d, 0x6b, 0xa5, 0xd5, 0xe5,
0xbd, 0xb1, 0x54, 0xb6, 0x1e, 0xfb, 0x63, 0x16,
0x6e, 0x22, 0x04, 0xf0, 0x82, 0x7a, 0xc6, 0x99,
0xf7, 0x4c, 0xff, 0x93, 0x71, 0x57, 0x64, 0xd0,
0x08, 0x60, 0x39, 0x98, 0xb8, 0xd2, 0x2b, 0x4e,
0x81, 0x8d, 0xe4, 0x8f, 0xb2, 0x1e, 0x8f, 0x99,
0x98, 0xf1, 0x02, 0x9b, 0x4c, 0x7c, 0x97, 0x1a, },
}, {
.ksize = 32,
.key = blake2b_ordered_sequence,
.plaintext = blake2b_ordered_sequence,
.psize = 256,
.digest = (u8[]){ 0x0f, 0x32, 0x05, 0x09, 0xad, 0x9f, 0x25, 0xf7,
0xf2, 0x00, 0x71, 0xc9, 0x9f, 0x08, 0x58, 0xd1,
0x67, 0xc3, 0xa6, 0x2c, 0x0d, 0xe5, 0x7c, 0x15,
0x35, 0x18, 0x5a, 0x68, 0xc1, 0xca, 0x1c, 0x6e,
0x0f, 0xc4, 0xf6, 0x0c, 0x43, 0xe1, 0xb4, 0x3d,
0x28, 0xe4, 0xc7, 0xa1, 0xcf, 0x6b, 0x17, 0x4e,
0xf1, 0x5b, 0xb5, 0x53, 0xd4, 0xa7, 0xd0, 0x5b,
0xae, 0x15, 0x81, 0x15, 0xd0, 0x88, 0xa0, 0x3c, },
}};
#endif /* _CRYPTO_TESTMGR_H */ #endif /* _CRYPTO_TESTMGR_H */
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment