![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tests.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [truecrypt] / truecrypt / common|
Return to tests.c CVS log | Up to [truecrypt] / truecrypt / common |
1.1.1.5 root 1: /*
1.1.1.7 root 2: Legal Notice: Some portions of the source code contained in this file were
3: derived from the source code of Encryption for the Masses 2.02a, which is
4: Copyright (c) 1998-2000 Paul Le Roux and which is governed by the 'License
5: Agreement for Encryption for the Masses'. Modifications and additions to
1.1.1.14! root 6: the original source code (contained in this file) and all other portions
! 7: of this file are Copyright (c) 2003-2009 TrueCrypt Developers Association
! 8: and are governed by the TrueCrypt License 2.8 the full text of which is
! 9: contained in the file License.txt included in TrueCrypt binary and source
! 10: code distribution packages. */
1.1 root 11:
12: #include "Tcdefs.h"
13: #include "Crc.h"
14: #include "Crypto.h"
1.1.1.5 root 15: #include "Common/Endian.h"
1.1 root 16: #include "Tests.h"
1.1.1.7 root 17: #include "Xts.h"
1.1.1.5 root 18: #include <string.h>
1.1 root 19: #include "Pkcs5.h"
20:
1.1.1.7 root 21: typedef struct {
22: unsigned __int8 key1[32];
23: unsigned __int8 key2[32];
24: unsigned __int8 dataUnitNo[8];
25: unsigned int blockNo;
26: unsigned __int8 plaintext[ENCRYPTION_DATA_UNIT_SIZE];
27: unsigned __int8 ciphertext[ENCRYPTION_DATA_UNIT_SIZE];
28: } XTS_TEST;
29:
30: #define XTS_TEST_COUNT 5
31:
32: XTS_TEST XTS_vectors[XTS_TEST_COUNT] = {
33: /* XTS-AES-256 */
34: {
35: // IEEE 1619 - Vector 10
36:
37: { 0x27, 0x18, 0x28, 0x18, 0x28, 0x45, 0x90, 0x45, 0x23, 0x53, 0x60, 0x28, 0x74, 0x71, 0x35, 0x26, 0x62, 0x49, 0x77, 0x57, 0x24, 0x70, 0x93, 0x69, 0x99, 0x59, 0x57, 0x49, 0x66, 0x96, 0x76, 0x27 },
38: { 0x31, 0x41, 0x59, 0x26, 0x53, 0x58, 0x97, 0x93, 0x23, 0x84, 0x62, 0x64, 0x33, 0x83, 0x27, 0x95, 0x02, 0x88, 0x41, 0x97, 0x16, 0x93, 0x99, 0x37, 0x51, 0x05, 0x82, 0x09, 0x74, 0x94, 0x45, 0x92 },
39: { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff },
40: 0,
41: {
42: 0x00, 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,
43: 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
44: 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
45: 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
46: 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
47: 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
48: 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
49: 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
50: 0x00, 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,
51: 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
52: 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
53: 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
54: 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
55: 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
56: 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
57: 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
58: },
59: {
60: 0x1c, 0x3b, 0x3a, 0x10, 0x2f, 0x77, 0x03, 0x86, 0xe4, 0x83, 0x6c, 0x99, 0xe3, 0x70, 0xcf, 0x9b, 0xea, 0x00, 0x80, 0x3f, 0x5e, 0x48, 0x23, 0x57, 0xa4, 0xae, 0x12, 0xd4, 0x14, 0xa3, 0xe6, 0x3b,
61: 0x5d, 0x31, 0xe2, 0x76, 0xf8, 0xfe, 0x4a, 0x8d, 0x66, 0xb3, 0x17, 0xf9, 0xac, 0x68, 0x3f, 0x44, 0x68, 0x0a, 0x86, 0xac, 0x35, 0xad, 0xfc, 0x33, 0x45, 0xbe, 0xfe, 0xcb, 0x4b, 0xb1, 0x88, 0xfd,
62: 0x57, 0x76, 0x92, 0x6c, 0x49, 0xa3, 0x09, 0x5e, 0xb1, 0x08, 0xfd, 0x10, 0x98, 0xba, 0xec, 0x70, 0xaa, 0xa6, 0x69, 0x99, 0xa7, 0x2a, 0x82, 0xf2, 0x7d, 0x84, 0x8b, 0x21, 0xd4, 0xa7, 0x41, 0xb0,
63: 0xc5, 0xcd, 0x4d, 0x5f, 0xff, 0x9d, 0xac, 0x89, 0xae, 0xba, 0x12, 0x29, 0x61, 0xd0, 0x3a, 0x75, 0x71, 0x23, 0xe9, 0x87, 0x0f, 0x8a, 0xcf, 0x10, 0x00, 0x02, 0x08, 0x87, 0x89, 0x14, 0x29, 0xca,
64: 0x2a, 0x3e, 0x7a, 0x7d, 0x7d, 0xf7, 0xb1, 0x03, 0x55, 0x16, 0x5c, 0x8b, 0x9a, 0x6d, 0x0a, 0x7d, 0xe8, 0xb0, 0x62, 0xc4, 0x50, 0x0d, 0xc4, 0xcd, 0x12, 0x0c, 0x0f, 0x74, 0x18, 0xda, 0xe3, 0xd0,
65: 0xb5, 0x78, 0x1c, 0x34, 0x80, 0x3f, 0xa7, 0x54, 0x21, 0xc7, 0x90, 0xdf, 0xe1, 0xde, 0x18, 0x34, 0xf2, 0x80, 0xd7, 0x66, 0x7b, 0x32, 0x7f, 0x6c, 0x8c, 0xd7, 0x55, 0x7e, 0x12, 0xac, 0x3a, 0x0f,
66: 0x93, 0xec, 0x05, 0xc5, 0x2e, 0x04, 0x93, 0xef, 0x31, 0xa1, 0x2d, 0x3d, 0x92, 0x60, 0xf7, 0x9a, 0x28, 0x9d, 0x6a, 0x37, 0x9b, 0xc7, 0x0c, 0x50, 0x84, 0x14, 0x73, 0xd1, 0xa8, 0xcc, 0x81, 0xec,
67: 0x58, 0x3e, 0x96, 0x45, 0xe0, 0x7b, 0x8d, 0x96, 0x70, 0x65, 0x5b, 0xa5, 0xbb, 0xcf, 0xec, 0xc6, 0xdc, 0x39, 0x66, 0x38, 0x0a, 0xd8, 0xfe, 0xcb, 0x17, 0xb6, 0xba, 0x02, 0x46, 0x9a, 0x02, 0x0a,
68: 0x84, 0xe1, 0x8e, 0x8f, 0x84, 0x25, 0x20, 0x70, 0xc1, 0x3e, 0x9f, 0x1f, 0x28, 0x9b, 0xe5, 0x4f, 0xbc, 0x48, 0x14, 0x57, 0x77, 0x8f, 0x61, 0x60, 0x15, 0xe1, 0x32, 0x7a, 0x02, 0xb1, 0x40, 0xf1,
69: 0x50, 0x5e, 0xb3, 0x09, 0x32, 0x6d, 0x68, 0x37, 0x8f, 0x83, 0x74, 0x59, 0x5c, 0x84, 0x9d, 0x84, 0xf4, 0xc3, 0x33, 0xec, 0x44, 0x23, 0x88, 0x51, 0x43, 0xcb, 0x47, 0xbd, 0x71, 0xc5, 0xed, 0xae,
70: 0x9b, 0xe6, 0x9a, 0x2f, 0xfe, 0xce, 0xb1, 0xbe, 0xc9, 0xde, 0x24, 0x4f, 0xbe, 0x15, 0x99, 0x2b, 0x11, 0xb7, 0x7c, 0x04, 0x0f, 0x12, 0xbd, 0x8f, 0x6a, 0x97, 0x5a, 0x44, 0xa0, 0xf9, 0x0c, 0x29,
71: 0xa9, 0xab, 0xc3, 0xd4, 0xd8, 0x93, 0x92, 0x72, 0x84, 0xc5, 0x87, 0x54, 0xcc, 0xe2, 0x94, 0x52, 0x9f, 0x86, 0x14, 0xdc, 0xd2, 0xab, 0xa9, 0x91, 0x92, 0x5f, 0xed, 0xc4, 0xae, 0x74, 0xff, 0xac,
72: 0x6e, 0x33, 0x3b, 0x93, 0xeb, 0x4a, 0xff, 0x04, 0x79, 0xda, 0x9a, 0x41, 0x0e, 0x44, 0x50, 0xe0, 0xdd, 0x7a, 0xe4, 0xc6, 0xe2, 0x91, 0x09, 0x00, 0x57, 0x5d, 0xa4, 0x01, 0xfc, 0x07, 0x05, 0x9f,
73: 0x64, 0x5e, 0x8b, 0x7e, 0x9b, 0xfd, 0xef, 0x33, 0x94, 0x30, 0x54, 0xff, 0x84, 0x01, 0x14, 0x93, 0xc2, 0x7b, 0x34, 0x29, 0xea, 0xed, 0xb4, 0xed, 0x53, 0x76, 0x44, 0x1a, 0x77, 0xed, 0x43, 0x85,
74: 0x1a, 0xd7, 0x7f, 0x16, 0xf5, 0x41, 0xdf, 0xd2, 0x69, 0xd5, 0x0d, 0x6a, 0x5f, 0x14, 0xfb, 0x0a, 0xab, 0x1c, 0xbb, 0x4c, 0x15, 0x50, 0xbe, 0x97, 0xf7, 0xab, 0x40, 0x66, 0x19, 0x3c, 0x4c, 0xaa,
75: 0x77, 0x3d, 0xad, 0x38, 0x01, 0x4b, 0xd2, 0x09, 0x2f, 0xa7, 0x55, 0xc8, 0x24, 0xbb, 0x5e, 0x54, 0xc4, 0xf3, 0x6f, 0xfd, 0xa9, 0xfc, 0xea, 0x70, 0xb9, 0xc6, 0xe6, 0x93, 0xe1, 0x48, 0xc1, 0x51
76: }
77: },
78: {
79: // IEEE 1619 - Vector 11
80:
81: { 0x27, 0x18, 0x28, 0x18, 0x28, 0x45, 0x90, 0x45, 0x23, 0x53, 0x60, 0x28, 0x74, 0x71, 0x35, 0x26, 0x62, 0x49, 0x77, 0x57, 0x24, 0x70, 0x93, 0x69, 0x99, 0x59, 0x57, 0x49, 0x66, 0x96, 0x76, 0x27 },
82: { 0x31, 0x41, 0x59, 0x26, 0x53, 0x58, 0x97, 0x93, 0x23, 0x84, 0x62, 0x64, 0x33, 0x83, 0x27, 0x95, 0x02, 0x88, 0x41, 0x97, 0x16, 0x93, 0x99, 0x37, 0x51, 0x05, 0x82, 0x09, 0x74, 0x94, 0x45, 0x92 },
83: { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff },
84: 0,
85: {
86: 0x00, 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,
87: 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
88: 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
89: 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
90: 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
91: 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
92: 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
93: 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
94: 0x00, 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,
95: 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
96: 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
97: 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
98: 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
99: 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
100: 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
101: 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
102: },
103: {
104: 0x77, 0xa3, 0x12, 0x51, 0x61, 0x8a, 0x15, 0xe6, 0xb9, 0x2d, 0x1d, 0x66, 0xdf, 0xfe, 0x7b, 0x50, 0xb5, 0x0b, 0xad, 0x55, 0x23, 0x05, 0xba, 0x02, 0x17, 0xa6, 0x10, 0x68, 0x8e, 0xff, 0x7e, 0x11,
105: 0xe1, 0xd0, 0x22, 0x54, 0x38, 0xe0, 0x93, 0x24, 0x2d, 0x6d, 0xb2, 0x74, 0xfd, 0xe8, 0x01, 0xd4, 0xca, 0xe0, 0x6f, 0x20, 0x92, 0xc7, 0x28, 0xb2, 0x47, 0x85, 0x59, 0xdf, 0x58, 0xe8, 0x37, 0xc2,
106: 0x46, 0x9e, 0xe4, 0xa4, 0xfa, 0x79, 0x4e, 0x4b, 0xbc, 0x7f, 0x39, 0xbc, 0x02, 0x6e, 0x3c, 0xb7, 0x2c, 0x33, 0xb0, 0x88, 0x8f, 0x25, 0xb4, 0xac, 0xf5, 0x6a, 0x2a, 0x98, 0x04, 0xf1, 0xce, 0x6d,
107: 0x3d, 0x6e, 0x1d, 0xc6, 0xca, 0x18, 0x1d, 0x4b, 0x54, 0x61, 0x79, 0xd5, 0x55, 0x44, 0xaa, 0x77, 0x60, 0xc4, 0x0d, 0x06, 0x74, 0x15, 0x39, 0xc7, 0xe3, 0xcd, 0x9d, 0x2f, 0x66, 0x50, 0xb2, 0x01,
108: 0x3f, 0xd0, 0xee, 0xb8, 0xc2, 0xb8, 0xe3, 0xd8, 0xd2, 0x40, 0xcc, 0xae, 0x2d, 0x4c, 0x98, 0x32, 0x0a, 0x74, 0x42, 0xe1, 0xc8, 0xd7, 0x5a, 0x42, 0xd6, 0xe6, 0xcf, 0xa4, 0xc2, 0xec, 0xa1, 0x79,
109: 0x8d, 0x15, 0x8c, 0x7a, 0xec, 0xdf, 0x82, 0x49, 0x0f, 0x24, 0xbb, 0x9b, 0x38, 0xe1, 0x08, 0xbc, 0xda, 0x12, 0xc3, 0xfa, 0xf9, 0xa2, 0x11, 0x41, 0xc3, 0x61, 0x3b, 0x58, 0x36, 0x7f, 0x92, 0x2a,
110: 0xaa, 0x26, 0xcd, 0x22, 0xf2, 0x3d, 0x70, 0x8d, 0xae, 0x69, 0x9a, 0xd7, 0xcb, 0x40, 0xa8, 0xad, 0x0b, 0x6e, 0x27, 0x84, 0x97, 0x3d, 0xcb, 0x60, 0x56, 0x84, 0xc0, 0x8b, 0x8d, 0x69, 0x98, 0xc6,
111: 0x9a, 0xac, 0x04, 0x99, 0x21, 0x87, 0x1e, 0xbb, 0x65, 0x30, 0x1a, 0x46, 0x19, 0xca, 0x80, 0xec, 0xb4, 0x85, 0xa3, 0x1d, 0x74, 0x42, 0x23, 0xce, 0x8d, 0xdc, 0x23, 0x94, 0x82, 0x8d, 0x6a, 0x80,
112: 0x47, 0x0c, 0x09, 0x2f, 0x5b, 0xa4, 0x13, 0xc3, 0x37, 0x8f, 0xa6, 0x05, 0x42, 0x55, 0xc6, 0xf9, 0xdf, 0x44, 0x95, 0x86, 0x2b, 0xbb, 0x32, 0x87, 0x68, 0x1f, 0x93, 0x1b, 0x68, 0x7c, 0x88, 0x8a,
113: 0xbf, 0x84, 0x4d, 0xfc, 0x8f, 0xc2, 0x83, 0x31, 0xe5, 0x79, 0x92, 0x8c, 0xd1, 0x2b, 0xd2, 0x39, 0x0a, 0xe1, 0x23, 0xcf, 0x03, 0x81, 0x8d, 0x14, 0xde, 0xdd, 0xe5, 0xc0, 0xc2, 0x4c, 0x8a, 0xb0,
114: 0x18, 0xbf, 0xca, 0x75, 0xca, 0x09, 0x6f, 0x2d, 0x53, 0x1f, 0x3d, 0x16, 0x19, 0xe7, 0x85, 0xf1, 0xad, 0xa4, 0x37, 0xca, 0xb9, 0x2e, 0x98, 0x05, 0x58, 0xb3, 0xdc, 0xe1, 0x47, 0x4a, 0xfb, 0x75,
115: 0xbf, 0xed, 0xbf, 0x8f, 0xf5, 0x4c, 0xb2, 0x61, 0x8e, 0x02, 0x44, 0xc9, 0xac, 0x0d, 0x3c, 0x66, 0xfb, 0x51, 0x59, 0x8c, 0xd2, 0xdb, 0x11, 0xf9, 0xbe, 0x39, 0x79, 0x1a, 0xbe, 0x44, 0x7c, 0x63,
116: 0x09, 0x4f, 0x7c, 0x45, 0x3b, 0x7f, 0xf8, 0x7c, 0xb5, 0xbb, 0x36, 0xb7, 0xc7, 0x9e, 0xfb, 0x08, 0x72, 0xd1, 0x70, 0x58, 0xb8, 0x3b, 0x15, 0xab, 0x08, 0x66, 0xad, 0x8a, 0x58, 0x65, 0x6c, 0x5a,
117: 0x7e, 0x20, 0xdb, 0xdf, 0x30, 0x8b, 0x24, 0x61, 0xd9, 0x7c, 0x0e, 0xc0, 0x02, 0x4a, 0x27, 0x15, 0x05, 0x52, 0x49, 0xcf, 0x3b, 0x47, 0x8d, 0xdd, 0x47, 0x40, 0xde, 0x65, 0x4f, 0x75, 0xca, 0x68,
118: 0x6e, 0x0d, 0x73, 0x45, 0xc6, 0x9e, 0xd5, 0x0c, 0xdc, 0x2a, 0x8b, 0x33, 0x2b, 0x1f, 0x88, 0x24, 0x10, 0x8a, 0xc9, 0x37, 0xeb, 0x05, 0x05, 0x85, 0x60, 0x8e, 0xe7, 0x34, 0x09, 0x7f, 0xc0, 0x90,
119: 0x54, 0xfb, 0xff, 0x89, 0xee, 0xae, 0xea, 0x79, 0x1f, 0x4a, 0x7a, 0xb1, 0xf9, 0x86, 0x82, 0x94, 0xa4, 0xf9, 0xe2, 0x7b, 0x42, 0xaf, 0x81, 0x00, 0xcb, 0x9d, 0x59, 0xce, 0xf9, 0x64, 0x58, 0x03
120: }
121: },
122: {
123: // IEEE 1619 - Vector 12
124:
125: { 0x27, 0x18, 0x28, 0x18, 0x28, 0x45, 0x90, 0x45, 0x23, 0x53, 0x60, 0x28, 0x74, 0x71, 0x35, 0x26, 0x62, 0x49, 0x77, 0x57, 0x24, 0x70, 0x93, 0x69, 0x99, 0x59, 0x57, 0x49, 0x66, 0x96, 0x76, 0x27 },
126: { 0x31, 0x41, 0x59, 0x26, 0x53, 0x58, 0x97, 0x93, 0x23, 0x84, 0x62, 0x64, 0x33, 0x83, 0x27, 0x95, 0x02, 0x88, 0x41, 0x97, 0x16, 0x93, 0x99, 0x37, 0x51, 0x05, 0x82, 0x09, 0x74, 0x94, 0x45, 0x92 },
127: { 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff },
128: 0,
129: {
130: 0x00, 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,
131: 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
132: 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
133: 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
134: 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
135: 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
136: 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
137: 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
138: 0x00, 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,
139: 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
140: 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
141: 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
142: 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
143: 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
144: 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
145: 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
146: },
147: {
148: 0xe3, 0x87, 0xaa, 0xa5, 0x8b, 0xa4, 0x83, 0xaf, 0xa7, 0xe8, 0xeb, 0x46, 0x97, 0x78, 0x31, 0x7e, 0xcf, 0x4c, 0xf5, 0x73, 0xaa, 0x9d, 0x4e, 0xac, 0x23, 0xf2, 0xcd, 0xf9, 0x14, 0xe4, 0xe2, 0x00,
149: 0xa8, 0xb4, 0x90, 0xe4, 0x2e, 0xe6, 0x46, 0x80, 0x2d, 0xc6, 0xee, 0x2b, 0x47, 0x1b, 0x27, 0x81, 0x95, 0xd6, 0x09, 0x18, 0xec, 0xec, 0xb4, 0x4b, 0xf7, 0x99, 0x66, 0xf8, 0x3f, 0xab, 0xa0, 0x49,
150: 0x92, 0x98, 0xeb, 0xc6, 0x99, 0xc0, 0xc8, 0x63, 0x47, 0x15, 0xa3, 0x20, 0xbb, 0x4f, 0x07, 0x5d, 0x62, 0x2e, 0x74, 0xc8, 0xc9, 0x32, 0x00, 0x4f, 0x25, 0xb4, 0x1e, 0x36, 0x10, 0x25, 0xb5, 0xa8,
151: 0x78, 0x15, 0x39, 0x1f, 0x61, 0x08, 0xfc, 0x4a, 0xfa, 0x6a, 0x05, 0xd9, 0x30, 0x3c, 0x6b, 0xa6, 0x8a, 0x12, 0x8a, 0x55, 0x70, 0x5d, 0x41, 0x59, 0x85, 0x83, 0x2f, 0xde, 0xaa, 0xe6, 0xc8, 0xe1,
152: 0x91, 0x10, 0xe8, 0x4d, 0x1b, 0x1f, 0x19, 0x9a, 0x26, 0x92, 0x11, 0x9e, 0xdc, 0x96, 0x13, 0x26, 0x58, 0xf0, 0x9d, 0xa7, 0xc6, 0x23, 0xef, 0xce, 0xc7, 0x12, 0x53, 0x7a, 0x3d, 0x94, 0xc0, 0xbf,
153: 0x5d, 0x7e, 0x35, 0x2e, 0xc9, 0x4a, 0xe5, 0x79, 0x7f, 0xdb, 0x37, 0x7d, 0xc1, 0x55, 0x11, 0x50, 0x72, 0x1a, 0xdf, 0x15, 0xbd, 0x26, 0xa8, 0xef, 0xc2, 0xfc, 0xaa, 0xd5, 0x68, 0x81, 0xfa, 0x9e,
154: 0x62, 0x46, 0x2c, 0x28, 0xf3, 0x0a, 0xe1, 0xce, 0xac, 0xa9, 0x3c, 0x34, 0x5c, 0xf2, 0x43, 0xb7, 0x3f, 0x54, 0x2e, 0x20, 0x74, 0xa7, 0x05, 0xbd, 0x26, 0x43, 0xbb, 0x9f, 0x7c, 0xc7, 0x9b, 0xb6,
155: 0xe7, 0x09, 0x1e, 0xa6, 0xe2, 0x32, 0xdf, 0x0f, 0x9a, 0xd0, 0xd6, 0xcf, 0x50, 0x23, 0x27, 0x87, 0x6d, 0x82, 0x20, 0x7a, 0xbf, 0x21, 0x15, 0xcd, 0xac, 0xf6, 0xd5, 0xa4, 0x8f, 0x6c, 0x18, 0x79,
156: 0xa6, 0x5b, 0x11, 0x5f, 0x0f, 0x8b, 0x3c, 0xb3, 0xc5, 0x9d, 0x15, 0xdd, 0x8c, 0x76, 0x9b, 0xc0, 0x14, 0x79, 0x5a, 0x18, 0x37, 0xf3, 0x90, 0x1b, 0x58, 0x45, 0xeb, 0x49, 0x1a, 0xdf, 0xef, 0xe0,
157: 0x97, 0xb1, 0xfa, 0x30, 0xa1, 0x2f, 0xc1, 0xf6, 0x5b, 0xa2, 0x29, 0x05, 0x03, 0x15, 0x39, 0x97, 0x1a, 0x10, 0xf2, 0xf3, 0x6c, 0x32, 0x1b, 0xb5, 0x13, 0x31, 0xcd, 0xef, 0xb3, 0x9e, 0x39, 0x64,
158: 0xc7, 0xef, 0x07, 0x99, 0x94, 0xf5, 0xb6, 0x9b, 0x2e, 0xdd, 0x83, 0xa7, 0x1e, 0xf5, 0x49, 0x97, 0x1e, 0xe9, 0x3f, 0x44, 0xea, 0xc3, 0x93, 0x8f, 0xcd, 0xd6, 0x1d, 0x01, 0xfa, 0x71, 0x79, 0x9d,
159: 0xa3, 0xa8, 0x09, 0x1c, 0x4c, 0x48, 0xaa, 0x9e, 0xd2, 0x63, 0xff, 0x07, 0x49, 0xdf, 0x95, 0xd4, 0x4f, 0xef, 0x6a, 0x0b, 0xb5, 0x78, 0xec, 0x69, 0x45, 0x6a, 0xa5, 0x40, 0x8a, 0xe3, 0x2c, 0x7a,
160: 0xf0, 0x8a, 0xd7, 0xba, 0x89, 0x21, 0x28, 0x7e, 0x3b, 0xbe, 0xe3, 0x1b, 0x76, 0x7b, 0xe0, 0x6a, 0x0e, 0x70, 0x5c, 0x86, 0x4a, 0x76, 0x91, 0x37, 0xdf, 0x28, 0x29, 0x22, 0x83, 0xea, 0x81, 0xa2,
161: 0x48, 0x02, 0x41, 0xb4, 0x4d, 0x99, 0x21, 0xcd, 0xbe, 0xc1, 0xbc, 0x28, 0xdc, 0x1f, 0xda, 0x11, 0x4b, 0xd8, 0xe5, 0x21, 0x7a, 0xc9, 0xd8, 0xeb, 0xaf, 0xa7, 0x20, 0xe9, 0xda, 0x4f, 0x9a, 0xce,
162: 0x23, 0x1c, 0xc9, 0x49, 0xe5, 0xb9, 0x6f, 0xe7, 0x6f, 0xfc, 0x21, 0x06, 0x3f, 0xdd, 0xc8, 0x3a, 0x6b, 0x86, 0x79, 0xc0, 0x0d, 0x35, 0xe0, 0x95, 0x76, 0xa8, 0x75, 0x30, 0x5b, 0xed, 0x5f, 0x36,
163: 0xed, 0x24, 0x2c, 0x89, 0x00, 0xdd, 0x1f, 0xa9, 0x65, 0xbc, 0x95, 0x0d, 0xfc, 0xe0, 0x9b, 0x13, 0x22, 0x63, 0xa1, 0xee, 0xf5, 0x2d, 0xd6, 0x88, 0x8c, 0x30, 0x9f, 0x5a, 0x7d, 0x71, 0x28, 0x26
164: }
165: },
166: {
167: // IEEE 1619 - Vector 13
168:
169: { 0x27, 0x18, 0x28, 0x18, 0x28, 0x45, 0x90, 0x45, 0x23, 0x53, 0x60, 0x28, 0x74, 0x71, 0x35, 0x26, 0x62, 0x49, 0x77, 0x57, 0x24, 0x70, 0x93, 0x69, 0x99, 0x59, 0x57, 0x49, 0x66, 0x96, 0x76, 0x27 },
170: { 0x31, 0x41, 0x59, 0x26, 0x53, 0x58, 0x97, 0x93, 0x23, 0x84, 0x62, 0x64, 0x33, 0x83, 0x27, 0x95, 0x02, 0x88, 0x41, 0x97, 0x16, 0x93, 0x99, 0x37, 0x51, 0x05, 0x82, 0x09, 0x74, 0x94, 0x45, 0x92 },
171: { 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff },
172: 0,
173: {
174: 0x00, 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,
175: 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
176: 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
177: 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
178: 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
179: 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
180: 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
181: 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
182: 0x00, 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,
183: 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
184: 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
185: 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
186: 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
187: 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
188: 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
189: 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
190: },
191: {
192: 0xbf, 0x53, 0xd2, 0xda, 0xde, 0x78, 0xe8, 0x22, 0xa4, 0xd9, 0x49, 0xa9, 0xbc, 0x67, 0x66, 0xb0, 0x1b, 0x06, 0xa8, 0xef, 0x70, 0xd2, 0x67, 0x48, 0xc6, 0xa7, 0xfc, 0x36, 0xd8, 0x0a, 0xe4, 0xc5,
193: 0x52, 0x0f, 0x7c, 0x4a, 0xb0, 0xac, 0x85, 0x44, 0x42, 0x4f, 0xa4, 0x05, 0x16, 0x2f, 0xef, 0x5a, 0x6b, 0x7f, 0x22, 0x94, 0x98, 0x06, 0x36, 0x18, 0xd3, 0x9f, 0x00, 0x03, 0xcb, 0x5f, 0xb8, 0xd1,
194: 0xc8, 0x6b, 0x64, 0x34, 0x97, 0xda, 0x1f, 0xf9, 0x45, 0xc8, 0xd3, 0xbe, 0xde, 0xca, 0x4f, 0x47, 0x97, 0x02, 0xa7, 0xa7, 0x35, 0xf0, 0x43, 0xdd, 0xb1, 0xd6, 0xaa, 0xad, 0xe3, 0xc4, 0xa0, 0xac,
195: 0x7c, 0xa7, 0xf3, 0xfa, 0x52, 0x79, 0xbe, 0xf5, 0x6f, 0x82, 0xcd, 0x7a, 0x2f, 0x38, 0x67, 0x2e, 0x82, 0x48, 0x14, 0xe1, 0x07, 0x00, 0x30, 0x0a, 0x05, 0x5e, 0x16, 0x30, 0xb8, 0xf1, 0xcb, 0x0e,
196: 0x91, 0x9f, 0x5e, 0x94, 0x20, 0x10, 0xa4, 0x16, 0xe2, 0xbf, 0x48, 0xcb, 0x46, 0x99, 0x3d, 0x3c, 0xb6, 0xa5, 0x1c, 0x19, 0xba, 0xcf, 0x86, 0x47, 0x85, 0xa0, 0x0b, 0xc2, 0xec, 0xff, 0x15, 0xd3,
197: 0x50, 0x87, 0x5b, 0x24, 0x6e, 0xd5, 0x3e, 0x68, 0xbe, 0x6f, 0x55, 0xbd, 0x7e, 0x05, 0xcf, 0xc2, 0xb2, 0xed, 0x64, 0x32, 0x19, 0x8a, 0x64, 0x44, 0xb6, 0xd8, 0xc2, 0x47, 0xfa, 0xb9, 0x41, 0xf5,
198: 0x69, 0x76, 0x8b, 0x5c, 0x42, 0x93, 0x66, 0xf1, 0xd3, 0xf0, 0x0f, 0x03, 0x45, 0xb9, 0x61, 0x23, 0xd5, 0x62, 0x04, 0xc0, 0x1c, 0x63, 0xb2, 0x2c, 0xe7, 0x8b, 0xaf, 0x11, 0x6e, 0x52, 0x5e, 0xd9,
199: 0x0f, 0xde, 0xa3, 0x9f, 0xa4, 0x69, 0x49, 0x4d, 0x38, 0x66, 0xc3, 0x1e, 0x05, 0xf2, 0x95, 0xff, 0x21, 0xfe, 0xa8, 0xd4, 0xe6, 0xe1, 0x3d, 0x67, 0xe4, 0x7c, 0xe7, 0x22, 0xe9, 0x69, 0x8a, 0x1c,
200: 0x10, 0x48, 0xd6, 0x8e, 0xbc, 0xde, 0x76, 0xb8, 0x6f, 0xcf, 0x97, 0x6e, 0xab, 0x8a, 0xa9, 0x79, 0x02, 0x68, 0xb7, 0x06, 0x8e, 0x01, 0x7a, 0x8b, 0x9b, 0x74, 0x94, 0x09, 0x51, 0x4f, 0x10, 0x53,
201: 0x02, 0x7f, 0xd1, 0x6c, 0x37, 0x86, 0xea, 0x1b, 0xac, 0x5f, 0x15, 0xcb, 0x79, 0x71, 0x1e, 0xe2, 0xab, 0xe8, 0x2f, 0x5c, 0xf8, 0xb1, 0x3a, 0xe7, 0x30, 0x30, 0xef, 0x5b, 0x9e, 0x44, 0x57, 0xe7,
202: 0x5d, 0x13, 0x04, 0xf9, 0x88, 0xd6, 0x2d, 0xd6, 0xfc, 0x4b, 0x94, 0xed, 0x38, 0xba, 0x83, 0x1d, 0xa4, 0xb7, 0x63, 0x49, 0x71, 0xb6, 0xcd, 0x8e, 0xc3, 0x25, 0xd9, 0xc6, 0x1c, 0x00, 0xf1, 0xdf,
203: 0x73, 0x62, 0x7e, 0xd3, 0x74, 0x5a, 0x5e, 0x84, 0x89, 0xf3, 0xa9, 0x5c, 0x69, 0x63, 0x9c, 0x32, 0xcd, 0x6e, 0x1d, 0x53, 0x7a, 0x85, 0xf7, 0x5c, 0xc8, 0x44, 0x72, 0x6e, 0x8a, 0x72, 0xfc, 0x00,
204: 0x77, 0xad, 0x22, 0x00, 0x0f, 0x1d, 0x50, 0x78, 0xf6, 0xb8, 0x66, 0x31, 0x8c, 0x66, 0x8f, 0x1a, 0xd0, 0x3d, 0x5a, 0x5f, 0xce, 0xd5, 0x21, 0x9f, 0x2e, 0xab, 0xbd, 0x0a, 0xa5, 0xc0, 0xf4, 0x60,
205: 0xd1, 0x83, 0xf0, 0x44, 0x04, 0xa0, 0xd6, 0xf4, 0x69, 0x55, 0x8e, 0x81, 0xfa, 0xb2, 0x4a, 0x16, 0x79, 0x05, 0xab, 0x4c, 0x78, 0x78, 0x50, 0x2a, 0xd3, 0xe3, 0x8f, 0xdb, 0xe6, 0x2a, 0x41, 0x55,
206: 0x6c, 0xec, 0x37, 0x32, 0x57, 0x59, 0x53, 0x3c, 0xe8, 0xf2, 0x5f, 0x36, 0x7c, 0x87, 0xbb, 0x55, 0x78, 0xd6, 0x67, 0xae, 0x93, 0xf9, 0xe2, 0xfd, 0x99, 0xbc, 0xbc, 0x5f, 0x2f, 0xbb, 0xa8, 0x8c,
207: 0xf6, 0x51, 0x61, 0x39, 0x42, 0x0f, 0xcf, 0xf3, 0xb7, 0x36, 0x1d, 0x86, 0x32, 0x2c, 0x4b, 0xd8, 0x4c, 0x82, 0xf3, 0x35, 0xab, 0xb1, 0x52, 0xc4, 0xa9, 0x34, 0x11, 0x37, 0x3a, 0xaa, 0x82, 0x20
208: }
209: },
210: {
211: // IEEE 1619 - Vector 14
212:
213: /* This vector must always be the last one in XTS_vectors[] because TestSectorBufEncryption() relies on it. */
214:
215: { 0x27, 0x18, 0x28, 0x18, 0x28, 0x45, 0x90, 0x45, 0x23, 0x53, 0x60, 0x28, 0x74, 0x71, 0x35, 0x26, 0x62, 0x49, 0x77, 0x57, 0x24, 0x70, 0x93, 0x69, 0x99, 0x59, 0x57, 0x49, 0x66, 0x96, 0x76, 0x27 },
216: { 0x31, 0x41, 0x59, 0x26, 0x53, 0x58, 0x97, 0x93, 0x23, 0x84, 0x62, 0x64, 0x33, 0x83, 0x27, 0x95, 0x02, 0x88, 0x41, 0x97, 0x16, 0x93, 0x99, 0x37, 0x51, 0x05, 0x82, 0x09, 0x74, 0x94, 0x45, 0x92 },
217: { 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff },
218: 0,
219: {
220: 0x00, 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,
221: 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
222: 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
223: 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
224: 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
225: 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
226: 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
227: 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
228: 0x00, 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,
229: 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
230: 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
231: 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
232: 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
233: 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
234: 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
235: 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
236: },
237: {
238: 0x64, 0x49, 0x7e, 0x5a, 0x83, 0x1e, 0x4a, 0x93, 0x2c, 0x09, 0xbe, 0x3e, 0x53, 0x93, 0x37, 0x6d, 0xaa, 0x59, 0x95, 0x48, 0xb8, 0x16, 0x03, 0x1d, 0x22, 0x4b, 0xbf, 0x50, 0xa8, 0x18, 0xed, 0x23,
239: 0x50, 0xea, 0xe7, 0xe9, 0x60, 0x87, 0xc8, 0xa0, 0xdb, 0x51, 0xad, 0x29, 0x0b, 0xd0, 0x0c, 0x1a, 0xc1, 0x62, 0x08, 0x57, 0x63, 0x5b, 0xf2, 0x46, 0xc1, 0x76, 0xab, 0x46, 0x3b, 0xe3, 0x0b, 0x80,
240: 0x8d, 0xa5, 0x48, 0x08, 0x1a, 0xc8, 0x47, 0xb1, 0x58, 0xe1, 0x26, 0x4b, 0xe2, 0x5b, 0xb0, 0x91, 0x0b, 0xbc, 0x92, 0x64, 0x71, 0x08, 0x08, 0x94, 0x15, 0xd4, 0x5f, 0xab, 0x1b, 0x3d, 0x26, 0x04,
241: 0xe8, 0xa8, 0xef, 0xf1, 0xae, 0x40, 0x20, 0xcf, 0xa3, 0x99, 0x36, 0xb6, 0x68, 0x27, 0xb2, 0x3f, 0x37, 0x1b, 0x92, 0x20, 0x0b, 0xe9, 0x02, 0x51, 0xe6, 0xd7, 0x3c, 0x5f, 0x86, 0xde, 0x5f, 0xd4,
242: 0xa9, 0x50, 0x78, 0x19, 0x33, 0xd7, 0x9a, 0x28, 0x27, 0x2b, 0x78, 0x2a, 0x2e, 0xc3, 0x13, 0xef, 0xdf, 0xcc, 0x06, 0x28, 0xf4, 0x3d, 0x74, 0x4c, 0x2d, 0xc2, 0xff, 0x3d, 0xcb, 0x66, 0x99, 0x9b,
243: 0x50, 0xc7, 0xca, 0x89, 0x5b, 0x0c, 0x64, 0x79, 0x1e, 0xea, 0xa5, 0xf2, 0x94, 0x99, 0xfb, 0x1c, 0x02, 0x6f, 0x84, 0xce, 0x5b, 0x5c, 0x72, 0xba, 0x10, 0x83, 0xcd, 0xdb, 0x5c, 0xe4, 0x54, 0x34,
244: 0x63, 0x16, 0x65, 0xc3, 0x33, 0xb6, 0x0b, 0x11, 0x59, 0x3f, 0xb2, 0x53, 0xc5, 0x17, 0x9a, 0x2c, 0x8d, 0xb8, 0x13, 0x78, 0x2a, 0x00, 0x48, 0x56, 0xa1, 0x65, 0x30, 0x11, 0xe9, 0x3f, 0xb6, 0xd8,
245: 0x76, 0xc1, 0x83, 0x66, 0xdd, 0x86, 0x83, 0xf5, 0x34, 0x12, 0xc0, 0xc1, 0x80, 0xf9, 0xc8, 0x48, 0x59, 0x2d, 0x59, 0x3f, 0x86, 0x09, 0xca, 0x73, 0x63, 0x17, 0xd3, 0x56, 0xe1, 0x3e, 0x2b, 0xff,
246: 0x3a, 0x9f, 0x59, 0xcd, 0x9a, 0xeb, 0x19, 0xcd, 0x48, 0x25, 0x93, 0xd8, 0xc4, 0x61, 0x28, 0xbb, 0x32, 0x42, 0x3b, 0x37, 0xa9, 0xad, 0xfb, 0x48, 0x2b, 0x99, 0x45, 0x3f, 0xbe, 0x25, 0xa4, 0x1b,
247: 0xf6, 0xfe, 0xb4, 0xaa, 0x0b, 0xef, 0x5e, 0xd2, 0x4b, 0xf7, 0x3c, 0x76, 0x29, 0x78, 0x02, 0x54, 0x82, 0xc1, 0x31, 0x15, 0xe4, 0x01, 0x5a, 0xac, 0x99, 0x2e, 0x56, 0x13, 0xa3, 0xb5, 0xc2, 0xf6,
248: 0x85, 0xb8, 0x47, 0x95, 0xcb, 0x6e, 0x9b, 0x26, 0x56, 0xd8, 0xc8, 0x81, 0x57, 0xe5, 0x2c, 0x42, 0xf9, 0x78, 0xd8, 0x63, 0x4c, 0x43, 0xd0, 0x6f, 0xea, 0x92, 0x8f, 0x28, 0x22, 0xe4, 0x65, 0xaa,
249: 0x65, 0x76, 0xe9, 0xbf, 0x41, 0x93, 0x84, 0x50, 0x6c, 0xc3, 0xce, 0x3c, 0x54, 0xac, 0x1a, 0x6f, 0x67, 0xdc, 0x66, 0xf3, 0xb3, 0x01, 0x91, 0xe6, 0x98, 0x38, 0x0b, 0xc9, 0x99, 0xb0, 0x5a, 0xbc,
250: 0xe1, 0x9d, 0xc0, 0xc6, 0xdc, 0xc2, 0xdd, 0x00, 0x1e, 0xc5, 0x35, 0xba, 0x18, 0xde, 0xb2, 0xdf, 0x1a, 0x10, 0x10, 0x23, 0x10, 0x83, 0x18, 0xc7, 0x5d, 0xc9, 0x86, 0x11, 0xa0, 0x9d, 0xc4, 0x8a,
251: 0x0a, 0xcd, 0xec, 0x67, 0x6f, 0xab, 0xdf, 0x22, 0x2f, 0x07, 0xe0, 0x26, 0xf0, 0x59, 0xb6, 0x72, 0xb5, 0x6e, 0x5c, 0xbc, 0x8e, 0x1d, 0x21, 0xbb, 0xd8, 0x67, 0xdd, 0x92, 0x72, 0x12, 0x05, 0x46,
252: 0x81, 0xd7, 0x0e, 0xa7, 0x37, 0x13, 0x4c, 0xdf, 0xce, 0x93, 0xb6, 0xf8, 0x2a, 0xe2, 0x24, 0x23, 0x27, 0x4e, 0x58, 0xa0, 0x82, 0x1c, 0xc5, 0x50, 0x2e, 0x2d, 0x0a, 0xb4, 0x58, 0x5e, 0x94, 0xde,
253: 0x69, 0x75, 0xbe, 0x5e, 0x0b, 0x4e, 0xfc, 0xe5, 0x1c, 0xd3, 0xe7, 0x0c, 0x25, 0xa1, 0xfb, 0xbb, 0xd6, 0x09, 0xd2, 0x73, 0xad, 0x5b, 0x0d, 0x59, 0x63, 0x1c, 0x53, 0x1f, 0x6a, 0x0a, 0x57, 0xb9
254: }
255: } }; // XTS_TEST XTS_vectors[]
256:
257:
258: BOOL XTSAesTest (PCRYPTO_INFO ci)
259: {
260: unsigned __int8 p[ENCRYPTION_DATA_UNIT_SIZE];
261: UINT64_STRUCT dataUnitNo;
262: int i;
263:
264: for (i = 0; i < XTS_TEST_COUNT; i++)
265: {
266: ci->ea = EAGetByName ("AES");
267: if (ci->ea == 0)
268: return FALSE;
269:
270: ci->mode = XTS;
271:
272: if (EAInit (ci->ea, XTS_vectors[i].key1, ci->ks) != ERR_SUCCESS)
273: return FALSE;
274:
275: memcpy (&ci->k2, XTS_vectors[i].key2, sizeof (XTS_vectors[i].key2));
276:
277: if (!EAInitMode (ci))
278: return FALSE;
279:
280: memcpy (p, XTS_vectors[i].plaintext, sizeof (p));
281:
282: dataUnitNo.Value = BE64 (*((unsigned __int64 *) XTS_vectors[i].dataUnitNo));
283:
284: EncryptBufferXTS (p, sizeof (p), &dataUnitNo, XTS_vectors[i].blockNo, (unsigned char *) (ci->ks), (unsigned char *) ci->ks2, AES);
285:
286: if (memcmp (XTS_vectors[i].ciphertext, p, sizeof (p)) != 0)
287: return FALSE;
288: }
289:
290: return TRUE;
291: }
292:
1.1.1.6 root 293: /* Blowfish Test Vectors (deprecated/legacy) */
1.1 root 294:
295: /* Blowfish test vectors from www.counterpane.com/blowfish.html */
296:
297: #define BF_TEST_COUNT 34
298:
299: typedef struct {
300: unsigned char key[8];
301: unsigned char plaintext[8];
302: unsigned char ciphertext[8];
303: } BF_TEST;
304:
1.1.1.13 root 305: #pragma warning(disable:4295)
306:
1.1 root 307: BF_TEST bf_ecb_vectors[BF_TEST_COUNT] = {
308: "\x00\x00\x00\x00\x00\x00\x00\x00","\x00\x00\x00\x00\x00\x00\x00\x00","\x4E\xF9\x97\x45\x61\x98\xDD\x78",
309: "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF","\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF","\x51\x86\x6F\xD5\xB8\x5E\xCB\x8A",
310: "\x30\x00\x00\x00\x00\x00\x00\x00","\x10\x00\x00\x00\x00\x00\x00\x01","\x7D\x85\x6F\x9A\x61\x30\x63\xF2",
311: "\x11\x11\x11\x11\x11\x11\x11\x11","\x11\x11\x11\x11\x11\x11\x11\x11","\x24\x66\xDD\x87\x8B\x96\x3C\x9D",
312: "\x01\x23\x45\x67\x89\xAB\xCD\xEF","\x11\x11\x11\x11\x11\x11\x11\x11","\x61\xF9\xC3\x80\x22\x81\xB0\x96",
313: "\x11\x11\x11\x11\x11\x11\x11\x11","\x01\x23\x45\x67\x89\xAB\xCD\xEF","\x7D\x0C\xC6\x30\xAF\xDA\x1E\xC7",
314: "\x00\x00\x00\x00\x00\x00\x00\x00","\x00\x00\x00\x00\x00\x00\x00\x00","\x4E\xF9\x97\x45\x61\x98\xDD\x78",
315: "\xFE\xDC\xBA\x98\x76\x54\x32\x10","\x01\x23\x45\x67\x89\xAB\xCD\xEF","\x0A\xCE\xAB\x0F\xC6\xA0\xA2\x8D",
316: "\x7C\xA1\x10\x45\x4A\x1A\x6E\x57","\x01\xA1\xD6\xD0\x39\x77\x67\x42","\x59\xC6\x82\x45\xEB\x05\x28\x2B",
317: "\x01\x31\xD9\x61\x9D\xC1\x37\x6E","\x5C\xD5\x4C\xA8\x3D\xEF\x57\xDA","\xB1\xB8\xCC\x0B\x25\x0F\x09\xA0",
318: "\x07\xA1\x13\x3E\x4A\x0B\x26\x86","\x02\x48\xD4\x38\x06\xF6\x71\x72","\x17\x30\xE5\x77\x8B\xEA\x1D\xA4",
319: "\x38\x49\x67\x4C\x26\x02\x31\x9E","\x51\x45\x4B\x58\x2D\xDF\x44\x0A","\xA2\x5E\x78\x56\xCF\x26\x51\xEB",
320: "\x04\xB9\x15\xBA\x43\xFE\xB5\xB6","\x42\xFD\x44\x30\x59\x57\x7F\xA2","\x35\x38\x82\xB1\x09\xCE\x8F\x1A",
321: "\x01\x13\xB9\x70\xFD\x34\xF2\xCE","\x05\x9B\x5E\x08\x51\xCF\x14\x3A","\x48\xF4\xD0\x88\x4C\x37\x99\x18",
322: "\x01\x70\xF1\x75\x46\x8F\xB5\xE6","\x07\x56\xD8\xE0\x77\x47\x61\xD2","\x43\x21\x93\xB7\x89\x51\xFC\x98",
323: "\x43\x29\x7F\xAD\x38\xE3\x73\xFE","\x76\x25\x14\xB8\x29\xBF\x48\x6A","\x13\xF0\x41\x54\xD6\x9D\x1A\xE5",
324: "\x07\xA7\x13\x70\x45\xDA\x2A\x16","\x3B\xDD\x11\x90\x49\x37\x28\x02","\x2E\xED\xDA\x93\xFF\xD3\x9C\x79",
325: "\x04\x68\x91\x04\xC2\xFD\x3B\x2F","\x26\x95\x5F\x68\x35\xAF\x60\x9A","\xD8\x87\xE0\x39\x3C\x2D\xA6\xE3",
326: "\x37\xD0\x6B\xB5\x16\xCB\x75\x46","\x16\x4D\x5E\x40\x4F\x27\x52\x32","\x5F\x99\xD0\x4F\x5B\x16\x39\x69",
327: "\x1F\x08\x26\x0D\x1A\xC2\x46\x5E","\x6B\x05\x6E\x18\x75\x9F\x5C\xCA","\x4A\x05\x7A\x3B\x24\xD3\x97\x7B",
328: "\x58\x40\x23\x64\x1A\xBA\x61\x76","\x00\x4B\xD6\xEF\x09\x17\x60\x62","\x45\x20\x31\xC1\xE4\xFA\xDA\x8E",
329: "\x02\x58\x16\x16\x46\x29\xB0\x07","\x48\x0D\x39\x00\x6E\xE7\x62\xF2","\x75\x55\xAE\x39\xF5\x9B\x87\xBD",
330: "\x49\x79\x3E\xBC\x79\xB3\x25\x8F","\x43\x75\x40\xC8\x69\x8F\x3C\xFA","\x53\xC5\x5F\x9C\xB4\x9F\xC0\x19",
331: "\x4F\xB0\x5E\x15\x15\xAB\x73\xA7","\x07\x2D\x43\xA0\x77\x07\x52\x92","\x7A\x8E\x7B\xFA\x93\x7E\x89\xA3",
332: "\x49\xE9\x5D\x6D\x4C\xA2\x29\xBF","\x02\xFE\x55\x77\x81\x17\xF1\x2A","\xCF\x9C\x5D\x7A\x49\x86\xAD\xB5",
333: "\x01\x83\x10\xDC\x40\x9B\x26\xD6","\x1D\x9D\x5C\x50\x18\xF7\x28\xC2","\xD1\xAB\xB2\x90\x65\x8B\xC7\x78",
334: "\x1C\x58\x7F\x1C\x13\x92\x4F\xEF","\x30\x55\x32\x28\x6D\x6F\x29\x5A","\x55\xCB\x37\x74\xD1\x3E\xF2\x01",
335: "\x01\x01\x01\x01\x01\x01\x01\x01","\x01\x23\x45\x67\x89\xAB\xCD\xEF","\xFA\x34\xEC\x48\x47\xB2\x68\xB2",
336: "\x1F\x1F\x1F\x1F\x0E\x0E\x0E\x0E","\x01\x23\x45\x67\x89\xAB\xCD\xEF","\xA7\x90\x79\x51\x08\xEA\x3C\xAE",
337: "\xE0\xFE\xE0\xFE\xF1\xFE\xF1\xFE","\x01\x23\x45\x67\x89\xAB\xCD\xEF","\xC3\x9E\x07\x2D\x9F\xAC\x63\x1D",
338: "\x00\x00\x00\x00\x00\x00\x00\x00","\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF","\x01\x49\x33\xE0\xCD\xAF\xF6\xE4",
339: "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF","\x00\x00\x00\x00\x00\x00\x00\x00","\xF2\x1E\x9A\x77\xB7\x1C\x49\xBC",
340: "\x01\x23\x45\x67\x89\xAB\xCD\xEF","\x00\x00\x00\x00\x00\x00\x00\x00","\x24\x59\x46\x88\x57\x54\x36\x9A",
341: "\xFE\xDC\xBA\x98\x76\x54\x32\x10","\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF","\x6B\x5C\x5A\x9C\x5D\x9E\x0A\x5A"
342: };
343:
344:
345: #define TRIPLEDES_TEST_COUNT 1
346:
347: typedef struct {
348: unsigned char key[24];
349: unsigned char plaintext[8];
350: unsigned char ciphertext[8];
351: } TRIPLEDES_TEST;
352:
353: TRIPLEDES_TEST tripledes_vectors[TRIPLEDES_TEST_COUNT] = {
354: 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98,
355: 0x76, 0x54, 0x32, 0x10, 0x89, 0xab, 0xcd, 0xef, 0x01, 0x23, 0x45, 0x67,
356:
357: 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xe7,
358:
359: 0xde, 0x0b, 0x7c, 0x06, 0xae, 0x5e, 0x0e, 0xd5
360: };
361:
1.1.1.6 root 362: /* CAST-128 Test Vectors from RFC2144 (deprecated/legacy) */
1.1 root 363:
364: #define CAST_TEST_COUNT 1
365:
366: typedef struct {
367: unsigned char key[16];
368: unsigned char plaintext[8];
369: unsigned char ciphertext[8];
370: } CAST_TEST;
371:
372:
373: CAST_TEST cast_ecb_vectors[CAST_TEST_COUNT] = {
374: "\x01\x23\x45\x67\x12\x34\x56\x78\x23\x45\x67\x89\x34\x56\x78\x9A",
375: "\x01\x23\x45\x67\x89\xAB\xCD\xEF",
376: "\x23\x8B\x4F\xE5\x84\x7E\x44\xB2"
377: };
378:
379: // AES ECB test vectors FIPS-197
380:
381: #define AES_TEST_COUNT 1
382:
383: typedef struct {
384: unsigned char key[32];
385: unsigned char plaintext[16];
386: unsigned char ciphertext[16];
387: } AES_TEST;
388:
389: AES_TEST aes_ecb_vectors[AES_TEST_COUNT] = {
390: 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,
391: 0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,
392:
393: 0x00,0x11,0x22,0x33,0x44,0x55,0x66,0x77,0x88,0x99,0xaa,0xbb,0xcc,0xdd,0xee,0xff,
394:
395: 0x8e,0xa2,0xb7,0xca,0x51,0x67,0x45,0xbf,0xea,0xfc,0x49,0x90,0x4b,0x49,0x60,0x89
396: };
397:
398: // Serpent ECB test vectors
399:
400: #define SERPENT_TEST_COUNT 1
401:
402: typedef struct {
403: unsigned char key[32];
404: unsigned char plaintext[16];
405: unsigned char ciphertext[16];
406: } SERPENT_TEST;
407:
408: SERPENT_TEST serpent_vectors[SERPENT_TEST_COUNT] = {
409: 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
410: 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
411:
412: 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
413: 0xde, 0x26, 0x9f, 0xf8, 0x33, 0xe4, 0x32, 0xb8, 0x5b, 0x2e, 0x88, 0xd2, 0x70, 0x1c, 0xe7, 0x5c
414: };
415:
416: // Twofish ECB test vectors
417:
418: #define TWOFISH_TEST_COUNT 1
419:
420: typedef struct {
421: unsigned char key[32];
422: unsigned char plaintext[16];
423: unsigned char ciphertext[16];
424: } TWOFISH_TEST;
425:
426: TWOFISH_TEST twofish_vectors[TWOFISH_TEST_COUNT] = {
427: 0xD4, 0x3B, 0xB7, 0x55, 0x6E, 0xA3, 0x2E, 0x46, 0xF2, 0xA2, 0x82, 0xB7, 0xD4, 0x5B, 0x4E, 0x0D,
428: 0x57, 0xFF, 0x73, 0x9D, 0x4D, 0xC9, 0x2C, 0x1B, 0xD7, 0xFC, 0x01, 0x70, 0x0C, 0xC8, 0x21, 0x6F,
429:
430: 0x90, 0xAF, 0xE9, 0x1B, 0xB2, 0x88, 0x54, 0x4F, 0x2C, 0x32, 0xDC, 0x23, 0x9B, 0x26, 0x35, 0xE6,
431: 0x6C, 0xB4, 0x56, 0x1C, 0x40, 0xBF, 0x0A, 0x97, 0x05, 0x93, 0x1C, 0xB6, 0xD4, 0x08, 0xE7, 0xFA
432: };
433:
1.1.1.7 root 434: /* Test vectors from FIPS 198a, RFC 4231, RFC 2104, RFC 2202, and other sources. */
435:
436: char *hmac_sha512_test_keys[] =
437: {
438: "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b",
439: "Jefe",
440: "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa",
441: "\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",
442: "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa",
443: "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa",
444: };
445:
446: char *hmac_sha512_test_data[] =
447: {
448: "Hi There",
449: "what do ya want for nothing?",
450: "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd",
451: "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd",
452: "Test Using Larger Than Block-Size Key - Hash Key First",
453: "This is a test using a larger than block-size key and a larger than block-size data. The key needs to be hashed before being used by the HMAC algorithm.",
454: };
455:
456: char *hmac_sha512_test_vectors[] =
457: {
458: "\x87\xaa\x7c\xde\xa5\xef\x61\x9d\x4f\xf0\xb4\x24\x1a\x1d\x6c\xb0\x23\x79\xf4\xe2\xce\x4e\xc2\x78\x7a\xd0\xb3\x05\x45\xe1\x7c\xde\xda\xa8\x33\xb7\xd6\xb8\xa7\x02\x03\x8b\x27\x4e\xae\xa3\xf4\xe4\xbe\x9d\x91\x4e\xeb\x61\xf1\x70\x2e\x69\x6c\x20\x3a\x12\x68\x54",
459: "\x16\x4b\x7a\x7b\xfc\xf8\x19\xe2\xe3\x95\xfb\xe7\x3b\x56\xe0\xa3\x87\xbd\x64\x22\x2e\x83\x1f\xd6\x10\x27\x0c\xd7\xea\x25\x05\x54\x97\x58\xbf\x75\xc0\x5a\x99\x4a\x6d\x03\x4f\x65\xf8\xf0\xe6\xfd\xca\xea\xb1\xa3\x4d\x4a\x6b\x4b\x63\x6e\x07\x0a\x38\xbc\xe7\x37",
460: "\xfa\x73\xb0\x08\x9d\x56\xa2\x84\xef\xb0\xf0\x75\x6c\x89\x0b\xe9\xb1\xb5\xdb\xdd\x8e\xe8\x1a\x36\x55\xf8\x3e\x33\xb2\x27\x9d\x39\xbf\x3e\x84\x82\x79\xa7\x22\xc8\x06\xb4\x85\xa4\x7e\x67\xc8\x07\xb9\x46\xa3\x37\xbe\xe8\x94\x26\x74\x27\x88\x59\xe1\x32\x92\xfb",
461: "\xb0\xba\x46\x56\x37\x45\x8c\x69\x90\xe5\xa8\xc5\xf6\x1d\x4a\xf7\xe5\x76\xd9\x7f\xf9\x4b\x87\x2d\xe7\x6f\x80\x50\x36\x1e\xe3\xdb\xa9\x1c\xa5\xc1\x1a\xa2\x5e\xb4\xd6\x79\x27\x5c\xc5\x78\x80\x63\xa5\xf1\x97\x41\x12\x0c\x4f\x2d\xe2\xad\xeb\xeb\x10\xa2\x98\xdd",
462: "\x80\xb2\x42\x63\xc7\xc1\xa3\xeb\xb7\x14\x93\xc1\xdd\x7b\xe8\xb4\x9b\x46\xd1\xf4\x1b\x4a\xee\xc1\x12\x1b\x01\x37\x83\xf8\xf3\x52\x6b\x56\xd0\x37\xe0\x5f\x25\x98\xbd\x0f\xd2\x21\x5d\x6a\x1e\x52\x95\xe6\x4f\x73\xf6\x3f\x0a\xec\x8b\x91\x5a\x98\x5d\x78\x65\x98",
463: "\xe3\x7b\x6a\x77\x5d\xc8\x7d\xba\xa4\xdf\xa9\xf9\x6e\x5e\x3f\xfd\xde\xbd\x71\xf8\x86\x72\x89\x86\x5d\xf5\xa3\x2d\x20\xcd\xc9\x44\xb6\x02\x2c\xac\x3c\x49\x82\xb1\x0d\x5e\xeb\x55\xc3\xe4\xde\x15\x13\x46\x76\xfb\x6d\xe0\x44\x60\x65\xc9\x74\x40\xfa\x8c\x6a\x58",
464: };
1.1 root 465:
466: char *hmac_sha1_test_keys[] =
467: {
1.1.1.7 root 468: // Deprecated/legacy
1.1 root 469: "\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",
470: "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b",
471: "Jefe",
472: "\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA"
473: };
474:
475: char *hmac_sha1_test_data[] =
476: {
1.1.1.7 root 477: // Deprecated/legacy
1.1 root 478: "Sample #3",
479: "Hi There",
480: "what do ya want for nothing?",
481: "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
482: "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
483: "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
484: };
485:
486: char *hmac_sha1_test_vectors[] =
487: {
1.1.1.7 root 488: // Deprecated/legacy
1.1 root 489: "\xbc\xf4\x1e\xab\x8b\xb2\xd8\x02\xf3\xd0\x5c\xaf\x7c\xb0\x92\xec\xf8\xd1\xa3\xaa",
490: "\xb6\x17\x31\x86\x55\x05\x72\x64\xe2\x8b\xc0\xb6\xfb\x37\x8c\x8e\xf1\x46\xbe\x00",
491: "\xef\xfc\xdf\x6a\xe5\xeb\x2f\xa2\xd2\x74\x16\xd5\xf1\x84\xdf\x9c\x25\x9a\x7c\x79",
492: "\x12\x5d\x73\x42\xb9\xac\x11\xcd\x91\xa3\x9a\xf4\x8a\xa1\x7b\x4f\x63\xf1\x75\xd3"
493: };
494:
495: char *hmac_ripemd160_test_keys[] =
496: {
497: "\x00\x11\x22\x33\x44\x55\x66\x77\x88\x99\xaa\xbb\xcc\xdd\xee\xff\x01\x23\x45\x67",
498: "\x01\x23\x45\x67\x89\xab\xcd\xef\xfe\xdc\xba\x98\x76\x54\x32\x10\x00\x11\x22\x33",
499: };
500:
501: char *hmac_ripemd160_test_data[] =
502: {
503: "message digest",
504: "12345678901234567890123456789012345678901234567890123456789012345678901234567890",
505: };
506:
507: char *hmac_ripemd160_test_vectors[] =
508: {
509: "\xf8\x36\x62\xcc\x8d\x33\x9c\x22\x7e\x60\x0f\xcd\x63\x6c\x57\xd2\x57\x1b\x1c\x34",
510: "\x85\xf1\x64\x70\x3e\x61\xa6\x31\x31\xbe\x7e\x45\x95\x8e\x07\x94\x12\x39\x04\xf9",
511: };
512:
513: char *hmac_whirlpool_test_key =
514: {
515: "\x00\x11\x22\x33\x44\x55\x66\x77\x88\x99\xAA\xBB\xCC\xDD\xEE\xFF\x01\x23\x45\x67\x89\xAB\xCD\xEF\x00\x11\x22\x33\x44\x55\x66\x77\x88\x99\xAA\xBB\xCC\xDD\xEE\xFF\x01\x23\x45\x67\x89\xAB\xCD\xEF\x00\x11\x22\x33\x44\x55\x66\x77\x88\x99\xAA\xBB\xCC\xDD\xEE\xFF"
516: };
517:
518: char *hmac_whirlpool_test_data =
519: {
520: "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
521: };
522:
523: char *hmac_whirlpool_test_vectors =
524: {
525: "\x03\x91\xd2\x80\x00\xb6\x62\xbb\xb8\xe6\x23\x3e\xe8\x6c\xf2\xb2\x84\x74\x4c\x73"
526: "\x8b\x58\x00\xba\x28\x12\xed\x52\x6f\xe3\x15\x3a\xb1\xba\xe7\xe2\x36\xbe\x96\x54"
527: "\x49\x3f\x19\xfa\xce\xa6\x44\x1f\x60\xf5\xf0\x18\x93\x09\x11\xa5\xe5\xce\xd8\xf2"
528: "\x6a\xbf\xa4\x02"
529: };
530:
531: unsigned char ks_tmp[MAX_EXPANDED_KEY];
532:
1.1.1.7 root 533: void CipherInit2(int cipher, void* key, void* ks, int key_len)
1.1 root 534: {
535: switch (cipher)
536: {
537: case BLOWFISH:
1.1.1.6 root 538: /* Deprecated/legacy */
1.1.1.10 root 539: BlowfishSetKey (ks, key_len, key);
1.1 root 540: break;
541:
542: case AES:
543: CipherInit(cipher,key,ks);
544: break;
545:
546: case CAST:
1.1.1.6 root 547: /* Deprecated/legacy */
1.1 root 548: CipherInit(cipher,key,ks);
549: break;
550:
551: case SERPENT:
552: CipherInit(cipher,key,ks);
553: break;
554:
555: case TRIPLEDES:
1.1.1.6 root 556: /* Deprecated/legacy */
1.1 root 557: CipherInit(cipher,key,ks);
558: break;
559:
560: case TWOFISH:
561: CipherInit(cipher,key,ks);
562: break;
1.1.1.7 root 563:
564: default:
565: /* Unknown/wrong ID */
566: TC_THROW_FATAL_EXCEPTION;
1.1 root 567: }
568: }
569:
570:
1.1.1.7 root 571: /* Deprecated/legacy */
1.1.1.2 root 572: typedef struct {
573: unsigned __int8 key1[32];
574: unsigned __int8 key2[16];
575: unsigned __int8 index[16];
576: unsigned __int8 plaintext[16];
577: unsigned __int8 ciphertext[16];
578: } LRW_TEST;
1.1 root 579:
1.1.1.2 root 580: #define LRW_TEST_COUNT 2
1.1 root 581:
1.1.1.7 root 582: /* Deprecated/legacy */
1.1.1.2 root 583: LRW_TEST lrw_vectors[LRW_TEST_COUNT] = {
1.1 root 584: {
1.1.1.2 root 585: { 0xf8, 0xd4, 0x76, 0xff, 0xd6, 0x46, 0xee, 0x6c, 0x23, 0x84, 0xcb, 0x1c, 0x77, 0xd6, 0x19, 0x5d,
586: 0xfe, 0xf1, 0xa9, 0xf3, 0x7b, 0xbc, 0x8d, 0x21, 0xa7, 0x9c, 0x21, 0xf8, 0xcb, 0x90, 0x02, 0x89 },
587: { 0xa8, 0x45, 0x34, 0x8e, 0xc8, 0xc5, 0xb5, 0xf1, 0x26, 0xf5, 0x0e, 0x76, 0xfe, 0xfd, 0x1b, 0x1e },
588: { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 },
589: { 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46 },
590: { 0xbd, 0x06, 0xb8, 0xe1, 0xdb, 0x98, 0x89, 0x9e, 0xc4, 0x98, 0xe4, 0x91, 0xcf, 0x1c, 0x70, 0x2b }
591: },
592: {
593: { 0xfb, 0x76, 0x15, 0xb2, 0x3d, 0x80, 0x89, 0x1d, 0xd4, 0x70, 0x98, 0x0b, 0xc7, 0x95, 0x84, 0xc8,
594: 0xb2, 0xfb, 0x64, 0xce, 0x60, 0x97, 0x87, 0x8d, 0x17, 0xfc, 0xe4, 0x5a, 0x49, 0xe8, 0x30, 0xb7 },
595: { 0x6e, 0x78, 0x17, 0xe7, 0x2d, 0x5e, 0x12, 0xd4, 0x60, 0x64, 0x04, 0x7a, 0xf1, 0x2f, 0x9e, 0x0c },
596: { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00 },
597: { 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46 },
598: { 0x5b, 0x90, 0x8e, 0xc1, 0xab, 0xdd, 0x67, 0x5f, 0x3d, 0x69, 0x8a, 0x95, 0x53, 0xc8, 0x9c, 0xe5 }
599: }
600: };
1.1 root 601:
602:
1.1.1.2 root 603: BOOL LRWAesTest (PCRYPTO_INFO ci)
604: {
1.1.1.7 root 605: /* Deprecated/legacy */
606:
1.1.1.2 root 607: unsigned __int8 p[16];
608: int i;
1.1 root 609:
1.1.1.2 root 610: for (i = 0; i < LRW_TEST_COUNT; i++)
611: {
612: ci->ea = EAGetByName ("AES");
613: if (ci->ea == 0)
1.1.1.7 root 614: return FALSE;
1.1.1.2 root 615:
616: ci->mode = LRW;
1.1 root 617:
1.1.1.7 root 618: if (EAInit (ci->ea, lrw_vectors[i].key1, ci->ks) != ERR_SUCCESS)
1.1 root 619: return FALSE;
620:
1.1.1.7 root 621: memcpy (&ci->k2, lrw_vectors[i].key2, sizeof (lrw_vectors[i].key2));
1.1.1.2 root 622: if (!EAInitMode (ci))
1.1 root 623: return FALSE;
624:
1.1.1.2 root 625: memcpy (p, lrw_vectors[i].plaintext, sizeof (p));
1.1 root 626:
1.1.1.2 root 627: EncryptBufferLRW128 (p, sizeof (p), BE64(((unsigned __int64 *)(lrw_vectors[i].index))[1]), ci);
1.1 root 628:
1.1.1.2 root 629: if (memcmp (lrw_vectors[i].ciphertext, p, sizeof (p)) != 0)
1.1 root 630: return FALSE;
1.1.1.2 root 631: }
632:
633: return TRUE;
634: }
635:
636:
637: BOOL TestSectorBufEncryption (PCRYPTO_INFO ci)
638: {
1.1.1.7 root 639: unsigned char buf [ENCRYPTION_DATA_UNIT_SIZE * 4];
1.1.1.2 root 640: unsigned int i;
641: char name[64];
642: unsigned __int32 crc;
1.1.1.7 root 643: UINT64_STRUCT unitNo;
1.1.1.13 root 644: uint32 nbrUnits;
1.1.1.7 root 645: unsigned __int64 writeOffset;
646: int testCase = 0;
647: int nTestsPerformed = 0;
648:
649: static unsigned char key1[] =
650: {
651: 0x27, 0x18, 0x28, 0x18, 0x28, 0x45, 0x90, 0x45, 0x23, 0x53, 0x60, 0x28, 0x74, 0x71, 0x35, 0x26, 0x62, 0x49, 0x77, 0x57, 0x24, 0x70, 0x93, 0x69, 0x99, 0x59, 0x57, 0x49, 0x66, 0x96, 0x76, 0x27,
652: 0x31, 0x41, 0x59, 0x26, 0x53, 0x58, 0x97, 0x93, 0x23, 0x84, 0x62, 0x64, 0x33, 0x83, 0x27, 0x95, 0x02, 0x88, 0x41, 0x97, 0x16, 0x93, 0x99, 0x37, 0x51, 0x05, 0x82, 0x09, 0x74, 0x94, 0x45, 0x92,
653: 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13
654: };
655:
656: if (!TestLegacySectorBufEncryption (ci))
657: return FALSE;
658:
659:
660: /* Encryption/decryption of data units (typically, volume data sectors) */
661:
662: nbrUnits = sizeof (buf) / ENCRYPTION_DATA_UNIT_SIZE;
663:
664: ci->mode = XTS; // Other modes of operation are tested in TestLegacySectorBufEncryption()
665:
666: /* The buffer can accommodate 4 data units and we'll test 4 cases by "scrolling". The data unit 0xFFFFFFFFFF
667: will "move" from the start of the buffer to its end. For a 512-byte data unit, the byte offset 562949953420800
668: corresponds to the data unit 0xFFFFFFFFFF. */
1.1.1.13 root 669: for (writeOffset = 562949953420800ULL;
670: writeOffset > 562949953420800ULL - nbrUnits * ENCRYPTION_DATA_UNIT_SIZE;
1.1.1.7 root 671: writeOffset -= ENCRYPTION_DATA_UNIT_SIZE)
672: {
673: unitNo.Value = writeOffset / ENCRYPTION_DATA_UNIT_SIZE;
674:
675: // Test all EAs that support this mode of operation
676: for (ci->ea = EAGetFirst (); ci->ea != 0; ci->ea = EAGetNext (ci->ea))
677: {
678: if (!EAIsModeSupported (ci->ea, ci->mode))
679: continue;
680:
681: EAGetName (name, ci->ea);
682:
683: if (EAInit (ci->ea, key1, ci->ks) != ERR_SUCCESS)
684: return FALSE;
685:
686: for (i = 0; i < sizeof (ci->k2); i++)
687: ci->k2[i] = (unsigned char) i;
688:
689: memcpy (&ci->k2, XTS_vectors[XTS_TEST_COUNT-1].key2, sizeof (XTS_vectors[XTS_TEST_COUNT-1].key2));
690:
691: if (!EAInitMode (ci))
692: return FALSE;
693:
694: // Each data unit will contain the same plaintext
695: for (i = 0; i < nbrUnits; i++)
696: {
697: memcpy ((unsigned char *) buf + i * ENCRYPTION_DATA_UNIT_SIZE,
698: XTS_vectors[XTS_TEST_COUNT-1].plaintext,
699: ENCRYPTION_DATA_UNIT_SIZE);
700: }
701:
702: EncryptDataUnits (buf, &unitNo, nbrUnits, ci);
703:
704: crc = GetCrc32 (buf, sizeof (buf));
705:
706: if (strcmp (name, "AES") == 0)
707: {
708: // Verify the ciphertext of the "moving" data unit using the IEEE test vector #14
709: if (memcmp (XTS_vectors[XTS_TEST_COUNT-1].ciphertext,
710: (unsigned char *) buf + testCase * ENCRYPTION_DATA_UNIT_SIZE,
711: ENCRYPTION_DATA_UNIT_SIZE) != 0)
712: {
713: return FALSE;
714: }
715:
716: // CRC of all data units in the buffer for each test case
717: switch (testCase)
718: {
719: case 0:
720: if (crc != 0x888f2990)
721: return FALSE;
722: nTestsPerformed++;
723: break;
724: case 1:
725: if (crc != 0xea28ea34)
726: return FALSE;
727: nTestsPerformed++;
728: break;
729: case 2:
730: if (crc != 0xe058f5a2)
731: return FALSE;
732: nTestsPerformed++;
733: break;
734: case 3:
735: if (crc != 0x10473dc9)
736: return FALSE;
737: nTestsPerformed++;
738: break;
739: }
740: }
741: else if (strcmp (name, "Serpent") == 0)
742: {
743: switch (testCase)
744: {
745: case 0:
746: if (crc != 0x7edfecb3)
747: return FALSE;
748: nTestsPerformed++;
749: break;
750: case 1:
751: if (crc != 0x357baaaa)
752: return FALSE;
753: nTestsPerformed++;
754: break;
755: case 2:
756: if (crc != 0xc7b9fca5)
757: return FALSE;
758: nTestsPerformed++;
759: break;
760: case 3:
761: if (crc != 0xb5263e0c)
762: return FALSE;
763: nTestsPerformed++;
764: break;
765: }
766: }
767: else if (strcmp (name, "Twofish") == 0)
768: {
769: switch (testCase)
770: {
771: case 0:
772: if (crc != 0x91525124)
773: return FALSE;
774: nTestsPerformed++;
775: break;
776: case 1:
777: if (crc != 0x2895cc47)
778: return FALSE;
779: nTestsPerformed++;
780: break;
781: case 2:
782: if (crc != 0x6bee346d)
783: return FALSE;
784: nTestsPerformed++;
785: break;
786: case 3:
787: if (crc != 0xb1c45759)
788: return FALSE;
789: nTestsPerformed++;
790: break;
791: }
792: }
793: else if (strcmp (name, "AES-Twofish") == 0)
794: {
795: switch (testCase)
796: {
797: case 0:
798: if (crc != 0x6cea7fa2)
799: return FALSE;
800: nTestsPerformed++;
801: break;
802: case 1:
803: if (crc != 0x69052c4c)
804: return FALSE;
805: nTestsPerformed++;
806: break;
807: case 2:
808: if (crc != 0x88db8de5)
809: return FALSE;
810: nTestsPerformed++;
811: break;
812: case 3:
813: if (crc != 0xf16fd8c5)
814: return FALSE;
815: nTestsPerformed++;
816: break;
817: }
818: }
819: else if (strcmp (name, "AES-Twofish-Serpent") == 0)
820: {
821: switch (testCase)
822: {
823: case 0:
824: if (crc != 0xa2d7d82a)
825: return FALSE;
826: nTestsPerformed++;
827: break;
828: case 1:
829: if (crc != 0xdbf76412)
830: return FALSE;
831: nTestsPerformed++;
832: break;
833: case 2:
834: if (crc != 0xdf0ea03e)
835: return FALSE;
836: nTestsPerformed++;
837: break;
838: case 3:
839: if (crc != 0xdadedff7)
840: return FALSE;
841: nTestsPerformed++;
842: break;
843: }
844: }
845: else if (strcmp (name, "Serpent-AES") == 0)
846: {
847: switch (testCase)
848: {
849: case 0:
850: if (crc != 0x6dd133b3)
851: return FALSE;
852: nTestsPerformed++;
853: break;
854: case 1:
855: if (crc != 0x0e5717d2)
856: return FALSE;
857: nTestsPerformed++;
858: break;
859: case 2:
860: if (crc != 0x39f83cd9)
861: return FALSE;
862: nTestsPerformed++;
863: break;
864: case 3:
865: if (crc != 0x8a79fa2c)
866: return FALSE;
867: nTestsPerformed++;
868: break;
869: }
870: }
871: else if (strcmp (name, "Serpent-Twofish-AES") == 0)
872: {
873: switch (testCase)
874: {
875: case 0:
876: if (crc != 0xe536daf8)
877: return FALSE;
878: nTestsPerformed++;
879: break;
880: case 1:
881: if (crc != 0x3ae89e7f)
882: return FALSE;
883: nTestsPerformed++;
884: break;
885: case 2:
886: if (crc != 0x2cc1301a)
887: return FALSE;
888: nTestsPerformed++;
889: break;
890: case 3:
891: if (crc != 0xcac7bdc7)
892: return FALSE;
893: nTestsPerformed++;
894: break;
895: }
896: }
897: else if (strcmp (name, "Twofish-Serpent") == 0)
898: {
899: switch (testCase)
900: {
901: case 0:
902: if (crc != 0x2686c859)
903: return FALSE;
904: nTestsPerformed++;
905: break;
906: case 1:
907: if (crc != 0x8a201780)
908: return FALSE;
909: nTestsPerformed++;
910: break;
911: case 2:
912: if (crc != 0x8dd13796)
913: return FALSE;
914: nTestsPerformed++;
915: break;
916: case 3:
917: if (crc != 0xe95196cb)
918: return FALSE;
919: nTestsPerformed++;
920: break;
921: }
922: }
923:
924: if (crc == 0x9f5edd58)
925: return FALSE;
926:
927: DecryptDataUnits (buf, &unitNo, nbrUnits, ci);
928:
929: if (GetCrc32 (buf, sizeof (buf)) != 0x9f5edd58)
930: return FALSE;
931:
932: nTestsPerformed++;
933: }
934: testCase++;
935: }
936:
937: /* Encryption/decryption of a buffer (typically, a volume header) */
938:
939: nbrUnits = sizeof (buf) / ENCRYPTION_DATA_UNIT_SIZE;
940:
941: // Test all EAs that support this mode of operation
942: for (ci->ea = EAGetFirst (); ci->ea != 0; ci->ea = EAGetNext (ci->ea))
943: {
944: if (!EAIsModeSupported (ci->ea, ci->mode))
945: continue;
946:
947: EAGetName (name, ci->ea);
948:
949: if (EAInit (ci->ea, key1, ci->ks) != ERR_SUCCESS)
950: return FALSE;
951:
952: memcpy (&ci->k2, XTS_vectors[XTS_TEST_COUNT-1].key2, sizeof (XTS_vectors[XTS_TEST_COUNT-1].key2));
953:
954: if (!EAInitMode (ci))
955: return FALSE;
956:
957: // Each data unit will contain the same plaintext
958: for (i = 0; i < nbrUnits; i++)
959: {
960: memcpy ((unsigned char *) buf + i * ENCRYPTION_DATA_UNIT_SIZE,
961: XTS_vectors[XTS_TEST_COUNT-1].plaintext,
962: ENCRYPTION_DATA_UNIT_SIZE);
963: }
964:
965: EncryptBuffer (buf, sizeof (buf), ci);
966:
967: crc = GetCrc32 (buf, sizeof (buf));
968:
969: if (strcmp (name, "AES") == 0)
970: {
971: if (crc != 0x33b91fab)
972: return FALSE;
973: nTestsPerformed++;
974: }
975: else if (strcmp (name, "Serpent") == 0)
976: {
977: if (crc != 0x3494d480)
978: return FALSE;
979: nTestsPerformed++;
980: }
981: else if (strcmp (name, "Twofish") == 0)
982: {
983: if (crc != 0xc4d65b46)
984: return FALSE;
985: nTestsPerformed++;
986: }
987: else if (strcmp (name, "AES-Twofish") == 0)
988: {
989: if (crc != 0x14ce7385)
990: return FALSE;
991: nTestsPerformed++;
992: }
993: else if (strcmp (name, "AES-Twofish-Serpent") == 0)
994: {
995: if (crc != 0x0ec81bf7)
996: return FALSE;
997: nTestsPerformed++;
998: }
999: else if (strcmp (name, "Serpent-AES") == 0)
1000: {
1001: if (crc != 0x42f919ad)
1002: return FALSE;
1003: nTestsPerformed++;
1004: }
1005: else if (strcmp (name, "Serpent-Twofish-AES") == 0)
1006: {
1007: if (crc != 0x208d5c58)
1008: return FALSE;
1009: nTestsPerformed++;
1010: }
1011: else if (strcmp (name, "Twofish-Serpent") == 0)
1012: {
1013: if (crc != 0xbe78cec1)
1014: return FALSE;
1015: nTestsPerformed++;
1016: }
1017:
1018: if (crc == 0x9f5edd58)
1019: return FALSE;
1020:
1021: DecryptBuffer (buf, sizeof (buf), ci);
1022:
1023: if (GetCrc32 (buf, sizeof (buf)) != 0x9f5edd58)
1024: return FALSE;
1025:
1026: nTestsPerformed++;
1027: }
1028:
1029: return (nTestsPerformed == 80);
1030: }
1031:
1032:
1033: BOOL TestLegacySectorBufEncryption (PCRYPTO_INFO ci)
1034: {
1035: unsigned char buf [ENCRYPTION_DATA_UNIT_SIZE * 2];
1036: unsigned int i;
1037: char name[64];
1038: unsigned __int32 crc;
1039: UINT64_STRUCT unitNo;
1.1.1.13 root 1040: uint32 nbrUnits;
1.1.1.2 root 1041: int blockSize;
1042: BOOL lrw64InitDone = FALSE;
1043: BOOL lrw128InitDone = FALSE;
1.1.1.7 root 1044: int nTestsPerformed = 0;
1045:
1046: unitNo.Value = 0x0234567890ABCDEFull;
1047: nbrUnits = sizeof (buf) / ENCRYPTION_DATA_UNIT_SIZE;
1.1 root 1048:
1.1.1.2 root 1049: for (i = 0; i < sizeof (buf); i++)
1050: buf[i] = (unsigned char) i;
1051:
1.1.1.7 root 1052: for (i = 0; i < sizeof (ci->k2); i++)
1053: ci->k2[i] = (unsigned char) i;
1.1.1.2 root 1054:
1055: // Test all EAs
1056: for (ci->ea = EAGetFirst (); ci->ea != 0; ci->ea = EAGetNext (ci->ea))
1057: {
1058: EAGetName (name, ci->ea);
1059: blockSize = CipherGetBlockSize (EAGetFirstCipher (ci->ea));
1060:
1061: if (EAInit (ci->ea, (unsigned char *)buf, ci->ks) == ERR_CIPHER_INIT_FAILURE)
1.1 root 1062: return FALSE;
1.1.1.2 root 1063:
1.1.1.11 root 1064: // Test all deprecated modes of operation
1.1.1.2 root 1065: for (ci->mode = EAGetFirstMode (ci->ea);
1066: ci->mode != 0;
1067: ci->mode = EAGetNextMode (ci->ea, ci->mode))
1068: {
1.1.1.11 root 1069: // Skip modes that are not deprecated
1.1.1.7 root 1070: if (ci->mode == XTS)
1.1.1.11 root 1071: continue;
1.1.1.7 root 1072:
1.1.1.2 root 1073: if (ci->mode == LRW
1074: && (blockSize == 8 && !lrw64InitDone || blockSize == 16 && !lrw128InitDone ))
1075: {
1076: if (!EAInitMode (ci))
1077: return FALSE;
1078:
1.1.1.7 root 1079: if (blockSize == 8)
1.1.1.2 root 1080: lrw64InitDone = TRUE;
1081: else if (blockSize == 16)
1082: lrw128InitDone = TRUE;
1083: }
1084:
1.1.1.7 root 1085: EncryptDataUnits (buf, &unitNo, nbrUnits, ci);
1086: crc = GetCrc32 (buf, sizeof (buf));
1.1.1.2 root 1087:
1088: switch (ci->mode)
1089: {
1.1.1.7 root 1090: case LRW: // Deprecated/legacy
1091: if (strcmp (name, "AES") == 0)
1092: {
1093: if (crc != 0x5237acf9)
1094: return FALSE;
1095: nTestsPerformed++;
1096: }
1097: else if (strcmp (name, "Blowfish") == 0) // Deprecated/legacy
1098: {
1099: if (crc != 0xf94d5300)
1100: return FALSE;
1101: nTestsPerformed++;
1102: }
1103: else if (strcmp (name, "CAST5") == 0) // Deprecated/legacy
1104: {
1105: if (crc != 0x33971e82)
1106: return FALSE;
1107: nTestsPerformed++;
1108: }
1109: else if (strcmp (name, "Serpent") == 0)
1110: {
1111: if (crc != 0x7fb86805)
1112: return FALSE;
1113: nTestsPerformed++;
1114: }
1115: else if (strcmp (name, "Triple DES") == 0) // Deprecated/legacy
1116: {
1117: if (crc != 0x2b20bb84)
1118: return FALSE;
1119: nTestsPerformed++;
1120: }
1121: else if (strcmp (name, "Twofish") == 0)
1122: {
1123: if (crc != 0xa9de0f0b)
1124: return FALSE;
1125: nTestsPerformed++;
1126: }
1127: else if (strcmp (name, "AES-Twofish") == 0)
1128: {
1129: if (crc != 0x4ed0fd80)
1130: return FALSE;
1131: nTestsPerformed++;
1132: }
1133: else if (strcmp (name, "AES-Twofish-Serpent") == 0)
1134: {
1135: if (crc != 0xea04b3cf)
1136: return FALSE;
1137: nTestsPerformed++;
1138: }
1139: else if (strcmp (name, "Serpent-AES") == 0)
1140: {
1141: if (crc != 0x0d33596a)
1142: return FALSE;
1143: nTestsPerformed++;
1144: }
1145: else if (strcmp (name, "Serpent-Twofish-AES") == 0)
1146: {
1147: if (crc != 0x2845d0e3)
1148: return FALSE;
1149: nTestsPerformed++;
1150: }
1151: else if (strcmp (name, "Twofish-Serpent") == 0)
1152: {
1153: if (crc != 0xca65c5cd)
1154: return FALSE;
1155: nTestsPerformed++;
1156: }
1.1.1.2 root 1157: break;
1158:
1.1.1.6 root 1159: case CBC: // Deprecated/legacy
1160: case INNER_CBC: // Deprecated/legacy
1161: case OUTER_CBC: // Deprecated/legacy
1.1.1.7 root 1162: if (strcmp (name, "AES") == 0)
1163: {
1164: if (crc != 0x2274f53d)
1165: return FALSE;
1166: nTestsPerformed++;
1167: }
1168: else if (strcmp (name, "Blowfish") == 0) // Deprecated/legacy
1169: {
1170: if (crc != 0x033899a1)
1171: return FALSE;
1172: nTestsPerformed++;
1173: }
1174: else if (strcmp (name, "CAST5") == 0) // Deprecated/legacy
1175: {
1176: if (crc != 0x331cecc7)
1177: return FALSE;
1178: nTestsPerformed++;
1179: }
1180: else if (strcmp (name, "Serpent") == 0)
1181: {
1182: if (crc != 0x42dff3d4)
1183: return FALSE;
1184: nTestsPerformed++;
1185: }
1186: else if (strcmp (name, "Triple DES") == 0) // Deprecated/legacy
1187: {
1188: if (crc != 0xfe497d0c)
1189: return FALSE;
1190: nTestsPerformed++;
1191: }
1192: else if (strcmp (name, "AES-Blowfish") == 0) // Deprecated/legacy
1193: {
1194: if (crc != 0xa7a80c84)
1195: return FALSE;
1196: nTestsPerformed++;
1197: }
1198: else if (strcmp (name, "AES-Blowfish-Serpent") == 0) // Deprecated/legacy
1199: {
1200: if (crc != 0xa0584562)
1201: return FALSE;
1202: nTestsPerformed++;
1203: }
1204: else if (strcmp (name, "AES-Twofish") == 0)
1205: {
1206: if (crc != 0x3c226444)
1207: return FALSE;
1208: nTestsPerformed++;
1209: }
1210: else if (strcmp (name, "AES-Twofish-Serpent") == 0)
1211: {
1212: if (crc != 0x5e5e77fd)
1213: return FALSE;
1214: nTestsPerformed++;
1215: }
1216: else if (strcmp (name, "Serpent-AES") == 0)
1217: {
1218: if (crc != 0x57c612d5)
1219: return FALSE;
1220: nTestsPerformed++;
1221: }
1222: else if (strcmp (name, "Serpent-Twofish-AES") == 0)
1223: {
1224: if (crc != 0x081e045a)
1225: return FALSE;
1226: nTestsPerformed++;
1227: }
1228: else if (strcmp (name, "Twofish-Serpent") == 0)
1229: {
1230: if (crc != 0xa7b659f3)
1231: return FALSE;
1232: nTestsPerformed++;
1233: }
1.1.1.2 root 1234: break;
1235: }
1236:
1237: if (crc == 0xb70b4c26)
1238: return FALSE;
1239:
1.1.1.7 root 1240: DecryptDataUnits (buf, &unitNo, nbrUnits, ci);
1.1.1.2 root 1241:
1.1.1.7 root 1242: if (GetCrc32 (buf, sizeof (buf)) != 0xb70b4c26)
1.1.1.2 root 1243: return FALSE;
1244:
1.1.1.7 root 1245: nTestsPerformed++;
1246:
1247: EncryptBuffer (buf, sizeof (buf), ci);
1248: crc = GetCrc32 (buf, sizeof (buf));
1.1.1.2 root 1249:
1250: switch (ci->mode)
1251: {
1.1.1.7 root 1252: case LRW: // Deprecated/legacy
1253: if (strcmp (name, "AES") == 0)
1254: {
1255: if (crc != 0x5ae1e3d8)
1256: return FALSE;
1257: nTestsPerformed++;
1258: }
1259: else if (strcmp (name, "Blowfish") == 0) // Deprecated/legacy
1260: {
1261: if (crc != 0x2738426f)
1262: return FALSE;
1263: nTestsPerformed++;
1264: }
1265: else if (strcmp (name, "AES-Twofish-Serpent") == 0)
1266: {
1267: if (crc != 0x14f2948a)
1268: return FALSE;
1269: nTestsPerformed++;
1270: }
1.1.1.2 root 1271: break;
1272:
1.1.1.6 root 1273: case CBC: // Deprecated/legacy
1274: case INNER_CBC: // Deprecated/legacy
1275: case OUTER_CBC: // Deprecated/legacy
1.1.1.7 root 1276: if (strcmp (name, "AES") == 0)
1277: {
1278: if (crc != 0x960f740e)
1279: return FALSE;
1280: nTestsPerformed++;
1281: }
1282: else if (strcmp (name, "Blowfish") == 0) // Deprecated/legacy
1283: {
1284: if (crc != 0x7e1cfabb)
1285: return FALSE;
1286: nTestsPerformed++;
1287: }
1288: else if (strcmp (name, "CAST5") == 0) // Deprecated/legacy
1289: {
1290: if (crc != 0xeaae21c8)
1291: return FALSE;
1292: nTestsPerformed++;
1293: }
1294: else if (strcmp (name, "Serpent") == 0)
1295: {
1296: if (crc != 0xa8139d62)
1297: return FALSE;
1298: nTestsPerformed++;
1299: }
1300: else if (strcmp (name, "Triple DES") == 0) // Deprecated/legacy
1301: {
1302: if (crc != 0xecf5d7d0)
1303: return FALSE;
1304: nTestsPerformed++;
1305: }
1306: else if (strcmp (name, "AES-Blowfish") == 0) // Deprecated/legacy
1307: {
1308: if (crc != 0xb70171b6)
1309: return FALSE;
1310: nTestsPerformed++;
1311: }
1312: else if (strcmp (name, "AES-Blowfish-Serpent") == 0) // Deprecated/legacy
1313: {
1314: if (crc != 0x1e749a87)
1315: return FALSE;
1316: nTestsPerformed++;
1317: }
1318: else if (strcmp (name, "AES-Twofish") == 0)
1319: {
1320: if (crc != 0xb4b8bb9b)
1321: return FALSE;
1322: nTestsPerformed++;
1323: }
1324: else if (strcmp (name, "AES-Twofish-Serpent") == 0)
1325: {
1326: if (crc != 0x76b6c1cb)
1327: return FALSE;
1328: nTestsPerformed++;
1329: }
1330: else if (strcmp (name, "Serpent-AES") == 0)
1331: {
1332: if (crc != 0x634f12ed)
1333: return FALSE;
1334: nTestsPerformed++;
1335: }
1336: else if (strcmp (name, "Serpent-Twofish-AES") == 0)
1337: {
1338: if (crc != 0xe54bc1b9)
1339: return FALSE;
1340: nTestsPerformed++;
1341: }
1342: else if (strcmp (name, "Twofish-Serpent") == 0)
1343: {
1344: if (crc != 0x21cdb382)
1345: return FALSE;
1346: nTestsPerformed++;
1347: }
1.1.1.2 root 1348: break;
1349: }
1350:
1351: if (crc == 0xb70b4c26)
1352: return FALSE;
1353:
1.1.1.7 root 1354: DecryptBuffer (buf, sizeof (buf), ci);
1.1.1.2 root 1355:
1.1.1.7 root 1356: if (GetCrc32 (buf, sizeof (buf)) != 0xb70b4c26)
1.1.1.2 root 1357: return FALSE;
1.1.1.7 root 1358:
1359: nTestsPerformed++;
1.1.1.2 root 1360: }
1.1 root 1361: }
1.1.1.7 root 1362: return (nTestsPerformed == 86);
1.1 root 1363: }
1364:
1365:
1366: BOOL AutoTestAlgorithms (void)
1367: {
1.1.1.2 root 1368: PCRYPTO_INFO ci;
1.1 root 1369: char key[32];
1370: unsigned char tmp[16];
1371: BOOL bFailed = FALSE;
1372: int i;
1373:
1.1.1.2 root 1374: ci = crypto_open ();
1375: if (!ci)
1376: return FALSE;
1377:
1378: memset (ci, 0, sizeof (*ci));
1379:
1.1.1.6 root 1380: /* Blowfish (deprecated/legacy) */
1.1 root 1381:
1382: for (i=0;i<BF_TEST_COUNT;i++)
1.1.1.10 root 1383: {
1.1 root 1384: memcpy(key, bf_ecb_vectors[i].key, 8);
1385: memcpy(tmp, bf_ecb_vectors[i].plaintext, 8);
1386: CipherInit2(BLOWFISH, key, ks_tmp, 8);
1.1.1.10 root 1387:
1388: ((uint32 *)tmp)[0] = BE32 (((uint32 *)tmp)[0]);
1389: ((uint32 *)tmp)[1] = BE32 (((uint32 *)tmp)[1]);
1390:
1391: BlowfishEncryptLE (tmp,tmp,(BF_KEY *)ks_tmp,1);
1392: BlowfishEncryptLE (tmp,tmp,(BF_KEY *)ks_tmp,0);
1393: BlowfishEncryptLE (tmp,tmp,(BF_KEY *)ks_tmp,1);
1394:
1395: ((uint32 *)tmp)[0] = BE32 (((uint32 *)tmp)[0]);
1396: ((uint32 *)tmp)[1] = BE32 (((uint32 *)tmp)[1]);
1397:
1.1 root 1398: if (memcmp(bf_ecb_vectors[i].ciphertext,tmp,8)!=0)
1399: break;
1400: }
1401:
1.1.1.10 root 1402: if (i != BF_TEST_COUNT)
1.1 root 1403: bFailed = TRUE;
1404:
1.1.1.6 root 1405: /* CAST5 (deprecated/legacy) */
1.1 root 1406:
1407: for (i=0;i<CAST_TEST_COUNT;i++)
1408: {
1409: int cipher = CAST;
1410: memcpy(key, cast_ecb_vectors[i].key, 16);
1411: memcpy(tmp, cast_ecb_vectors[i].plaintext, 8);
1412: CipherInit2(cipher, key, ks_tmp, 16);
1.1.1.10 root 1413:
1414: EncipherBlock(cipher, tmp, ks_tmp);
1415: DecipherBlock(cipher, tmp, ks_tmp);
1.1 root 1416: EncipherBlock(cipher, tmp, ks_tmp);
1.1.1.10 root 1417:
1.1 root 1418: if (memcmp(cast_ecb_vectors[i].ciphertext, tmp,8)!=0)
1419: break;
1420: }
1421:
1422: if (i!=CAST_TEST_COUNT)
1423: bFailed = TRUE;
1424:
1425:
1.1.1.6 root 1426: /* Triple DES (TECB, EDE) - deprecated/legacy */
1.1 root 1427:
1428: for (i = 0; i < TRIPLEDES_TEST_COUNT; i++)
1429: {
1430: int cipher = TRIPLEDES;
1431: memcpy(key, tripledes_vectors[i].key, sizeof(tripledes_vectors->key));
1432: memcpy(tmp, tripledes_vectors[i].plaintext, sizeof(tripledes_vectors->plaintext));
1.1.1.10 root 1433:
1.1 root 1434: CipherInit(cipher, key, ks_tmp);
1435:
1436: EncipherBlock(cipher, tmp, ks_tmp);
1437: if (memcmp(tripledes_vectors[i].ciphertext, tmp, sizeof(tripledes_vectors->ciphertext)) != 0)
1438: break;
1439:
1440: DecipherBlock(cipher, tmp, ks_tmp);
1441: if (memcmp(tripledes_vectors[i].plaintext, tmp, sizeof(tripledes_vectors->plaintext)) != 0)
1442: break;
1443: }
1444: if (i != TRIPLEDES_TEST_COUNT)
1445: bFailed = TRUE;
1446:
1447:
1448: /* AES */
1449:
1450: for (i = 0; i < AES_TEST_COUNT; i++)
1451: {
1452: int cipher = AES;
1453: memcpy(key, aes_ecb_vectors[i].key, 32);
1454: memcpy(tmp, aes_ecb_vectors[i].plaintext, 16);
1455: CipherInit(cipher, key, ks_tmp);
1456:
1457: EncipherBlock(cipher, tmp, ks_tmp);
1458: if (memcmp(aes_ecb_vectors[i].ciphertext, tmp, 16) != 0)
1459: break;
1460:
1461: DecipherBlock(cipher, tmp, ks_tmp);
1462: if (memcmp(aes_ecb_vectors[i].plaintext, tmp, 16) != 0)
1463: break;
1464: }
1465: if (i != AES_TEST_COUNT)
1466: bFailed = TRUE;
1467:
1468:
1469: /* Serpent */
1470:
1471: for (i = 0; i < SERPENT_TEST_COUNT; i++)
1472: {
1473: int cipher = SERPENT;
1474: memcpy(key, serpent_vectors[i].key, 32);
1475: memcpy(tmp, serpent_vectors[i].plaintext, 16);
1476: CipherInit(cipher, key, ks_tmp);
1477:
1478: EncipherBlock(cipher, tmp, ks_tmp);
1479: if (memcmp(serpent_vectors[i].ciphertext, tmp, 16) != 0)
1480: break;
1481:
1482: DecipherBlock(cipher, tmp, ks_tmp);
1483: if (memcmp(serpent_vectors[i].plaintext, tmp, 16) != 0)
1484: break;
1485: }
1486: if (i != SERPENT_TEST_COUNT)
1487: bFailed = TRUE;
1488:
1489:
1490: /* Twofish */
1491:
1492: for (i = 0; i < TWOFISH_TEST_COUNT; i++)
1493: {
1494: int cipher = TWOFISH;
1495: memcpy(key, twofish_vectors[i].key, 32);
1496: memcpy(tmp, twofish_vectors[i].plaintext, 16);
1497: CipherInit(cipher, key, ks_tmp);
1498:
1499: EncipherBlock(cipher, tmp, ks_tmp);
1500: if (memcmp(twofish_vectors[i].ciphertext, tmp, 16) != 0)
1501: break;
1502:
1503: DecipherBlock(cipher, tmp, ks_tmp);
1504: if (memcmp(twofish_vectors[i].plaintext, tmp, 16) != 0)
1505: break;
1506: }
1507: if (i != TWOFISH_TEST_COUNT)
1508: bFailed = TRUE;
1509:
1510:
1511: /* PKCS #5 and HMACs */
1512: if (!test_pkcs5 ())
1513: bFailed = TRUE;
1514:
1515: /* CRC-32 */
1516: if (!crc32_selftests ())
1517: bFailed = TRUE;
1518:
1.1.1.2 root 1519: /* GF multiplicator */
1520: #if 0
1521: if (!GfMulSelfTest ())
1522: bFailed = TRUE;
1523: #endif
1524:
1.1.1.7 root 1525: /* XTS-AES */
1526: if (!XTSAesTest (ci))
1527: bFailed = TRUE;
1528:
1529: /* LRW-AES (deprecated/legacy) */
1.1.1.2 root 1530: if (!LRWAesTest (ci))
1531: bFailed = TRUE;
1532:
1.1.1.7 root 1533: /* Sector and buffer related algorithms */
1.1.1.2 root 1534: if (!TestSectorBufEncryption (ci))
1.1 root 1535: bFailed = TRUE;
1536:
1.1.1.2 root 1537: crypto_close (ci);
1.1 root 1538: return !bFailed;
1539: }
1540:
1.1.1.7 root 1541: BOOL test_hmac_sha512 ()
1542: {
1543: unsigned int i;
1544: int nTestsPerformed = 0;
1545:
1546: for (i = 0; i < sizeof (hmac_sha512_test_data) / sizeof(char *); i++)
1547: {
1548: char digest[SHA512_DIGESTSIZE];
1.1.1.13 root 1549: hmac_sha512 (hmac_sha512_test_keys[i], (int) strlen (hmac_sha512_test_keys[i]), hmac_sha512_test_data[i], (int) strlen (hmac_sha512_test_data[i]), digest, SHA512_DIGESTSIZE);
1.1.1.7 root 1550: if (memcmp (digest, hmac_sha512_test_vectors[i], SHA512_DIGESTSIZE) != 0)
1551: return FALSE;
1552: else
1553: nTestsPerformed++;
1554: }
1555:
1556: return (nTestsPerformed == 6);
1557: }
1558:
1.1 root 1559: BOOL test_hmac_sha1 ()
1560: {
1.1.1.7 root 1561: // Deprecated/legacy
1562:
1563: int nTestsPerformed = 0;
1.1 root 1564: int i;
1565:
1566: for (i = 0; i < 3; i++)
1567: {
1568: char digest[SHA1_DIGESTSIZE];
1.1.1.13 root 1569: hmac_sha1 (hmac_sha1_test_keys[i], (int) strlen (hmac_sha1_test_keys[i]), hmac_sha1_test_data[i], (int) strlen (hmac_sha1_test_data[i]), digest, SHA1_DIGESTSIZE);
1.1 root 1570: if (memcmp (digest, hmac_sha1_test_vectors[i], SHA1_DIGESTSIZE) != 0)
1571: return FALSE;
1.1.1.7 root 1572: else
1573: nTestsPerformed++;
1.1 root 1574: }
1575:
1.1.1.7 root 1576: return (nTestsPerformed == 3);
1.1 root 1577: }
1578:
1579: BOOL test_hmac_ripemd160 ()
1580: {
1.1.1.7 root 1581: int nTestsPerformed = 0;
1.1 root 1582: unsigned int i;
1.1.1.7 root 1583:
1.1 root 1584: for (i = 0; i < sizeof (hmac_ripemd160_test_data) / sizeof(char *); i++)
1585: {
1586: char digest[RIPEMD160_DIGESTSIZE];
1.1.1.13 root 1587: hmac_ripemd160 (hmac_ripemd160_test_keys[i], RIPEMD160_DIGESTSIZE, hmac_ripemd160_test_data[i], (int) strlen (hmac_ripemd160_test_data[i]), digest);
1.1 root 1588: if (memcmp (digest, hmac_ripemd160_test_vectors[i], RIPEMD160_DIGESTSIZE) != 0)
1589: return FALSE;
1.1.1.7 root 1590: else
1591: nTestsPerformed++;
1.1 root 1592: }
1593:
1.1.1.7 root 1594: return (nTestsPerformed == 2);
1.1 root 1595: }
1596:
1597: BOOL test_hmac_whirlpool ()
1598: {
1599: unsigned char digest[WHIRLPOOL_DIGESTSIZE];
1600:
1.1.1.13 root 1601: hmac_whirlpool (hmac_whirlpool_test_key, 64, hmac_whirlpool_test_data, (int) strlen (hmac_whirlpool_test_data), digest, WHIRLPOOL_DIGESTSIZE);
1.1 root 1602: if (memcmp (digest, hmac_whirlpool_test_vectors, WHIRLPOOL_DIGESTSIZE) != 0)
1603: return FALSE;
1604:
1605: return TRUE;
1606: }
1607:
1608: BOOL test_pkcs5 ()
1609: {
1.1.1.7 root 1610: char dk[144];
1.1 root 1611:
1.1.1.7 root 1612: /* HMAC-SHA-512 tests */
1613: if (!test_hmac_sha512())
1614: return FALSE;
1615:
1616: /* HMAC-SHA-1 tests (deprecated/legacy) */
1.1 root 1617: if (test_hmac_sha1() == FALSE)
1618: return FALSE;
1619:
1620: /* HMAC-RIPEMD-160 tests */
1621: if (test_hmac_ripemd160() == FALSE)
1622: return FALSE;
1623:
1624: /* HMAC-Whirlpool tests */
1625: if (test_hmac_whirlpool() == FALSE)
1626: return FALSE;
1627:
1.1.1.7 root 1628: /* PKCS-5 test 1 with HMAC-SHA-512 used as the PRF */
1629: derive_key_sha512 ("password", 8, "\x12\x34\x56\x78", 4, 5, dk, 4);
1630: if (memcmp (dk, "\x13\x64\xae\xf8", 4) != 0)
1631: return FALSE;
1632:
1633: /* PKCS-5 test 2 with HMAC-SHA-512 used as the PRF (derives a key longer than the underlying
1634: hash output size and block size) */
1635: derive_key_sha512 ("password", 8, "\x12\x34\x56\x78", 4, 5, dk, 144);
1636: if (memcmp (dk, "\x13\x64\xae\xf8\x0d\xf5\x57\x6c\x30\xd5\x71\x4c\xa7\x75\x3f\xfd\x00\xe5\x25\x8b\x39\xc7\x44\x7f\xce\x23\x3d\x08\x75\xe0\x2f\x48\xd6\x30\xd7\x00\xb6\x24\xdb\xe0\x5a\xd7\x47\xef\x52\xca\xa6\x34\x83\x47\xe5\xcb\xe9\x87\xf1\x20\x59\x6a\xe6\xa9\xcf\x51\x78\xc6\xb6\x23\xa6\x74\x0d\xe8\x91\xbe\x1a\xd0\x28\xcc\xce\x16\x98\x9a\xbe\xfb\xdc\x78\xc9\xe1\x7d\x72\x67\xce\xe1\x61\x56\x5f\x96\x68\xe6\xe1\xdd\xf4\xbf\x1b\x80\xe0\x19\x1c\xf4\xc4\xd3\xdd\xd5\xd5\x57\x2d\x83\xc7\xa3\x37\x87\xf4\x4e\xe0\xf6\xd8\x6d\x65\xdc\xa0\x52\xa3\x13\xbe\x81\xfc\x30\xbe\x7d\x69\x58\x34\xb6\xdd\x41\xc6", 144) != 0)
1637: return FALSE;
1638:
1639: /* PKCS-5 test 1 with HMAC-SHA-1 (deprecated/legacy) used as the PRF (derives a key longer than the underlying hash) */
1640: derive_key_sha1 ("password", 8, "\x12\x34\x56\x78", 4, 5, dk, 48);
1641: if (memcmp (dk, "\x5c\x75\xce\xf0\x1a\x96\x0d\xf7\x4c\xb6\xb4\x9b\x9e\x38\xe6\xb5\x3b\x11\x80\xe3\x2f\xf7\xe0\xdd\xaa\xca\x8f\x81\x27\xf6\x9f\x4f\x1d\xc8\x2f\x48\x2d\xdb\x1a\x0a\xca\x90\xcb\x80\xb9\x2e\x90\x9e", 48) != 0)
1642: return FALSE;
1643:
1644: /* PKCS-5 test 2 with HMAC-SHA-1 (deprecated/legacy) used as the PRF */
1.1 root 1645: derive_key_sha1 ("password", 8, "\x12\x34\x56\x78", 4, 5, dk, 4);
1646: if (memcmp (dk, "\x5c\x75\xce\xf0", 4) != 0)
1647: return FALSE;
1648:
1.1.1.7 root 1649: #if 0 // This test is disabled because it uses 1200 iterations (to prevent startup slowdown)
1650: /* PKCS-5 test 3 with HMAC-SHA-1 (deprecated/legacy) used as the PRF */
1651: derive_key_sha1 ("password", 8, "ATHENA.MIT.EDUraeburn", 21, 1200, dk, 16);
1652: if (memcmp (dk, "\x5c\x08\xeb\x61\xfd\xf7\x1e\x4e\x4e\xc3\xcf\x6b\xa1\xf5\x51\x2b", 16) != 0)
1653: return FALSE;
1654: #endif
1655:
1656: /* PKCS-5 test 1 with HMAC-RIPEMD-160 used as the PRF */
1.1 root 1657: derive_key_ripemd160 ("password", 8, "\x12\x34\x56\x78", 4, 5, dk, 4);
1658: if (memcmp (dk, "\x7a\x3d\x7c\x03", 4) != 0)
1659: return FALSE;
1660:
1.1.1.7 root 1661: /* PKCS-5 test 2 with HMAC-RIPEMD-160 used as the PRF (derives a key longer than the underlying hash) */
1662: derive_key_ripemd160 ("password", 8, "\x12\x34\x56\x78", 4, 5, dk, 48);
1663: if (memcmp (dk, "\x7a\x3d\x7c\x03\xe7\x26\x6b\xf8\x3d\x78\xfb\x29\xd2\x64\x1f\x56\xea\xf0\xe5\xf5\xcc\xc4\x3a\x31\xa8\x84\x70\xbf\xbd\x6f\x8e\x78\x24\x5a\xc0\x0a\xf6\xfa\xf0\xf6\xe9\x00\x47\x5f\x73\xce\xe1\x43", 48) != 0)
1664: return FALSE;
1665:
1666: /* PKCS-5 test 1 with HMAC-Whirlpool used as the PRF */
1.1 root 1667: derive_key_whirlpool ("password", 8, "\x12\x34\x56\x78", 4, 5, dk, 4);
1668: if (memcmp (dk, "\x50\x7c\x36\x6f", 4) != 0)
1669: return FALSE;
1670:
1.1.1.7 root 1671: /* PKCS-5 test 2 with HMAC-Whirlpool used as the PRF (derives a key longer than the underlying hash) */
1672: derive_key_whirlpool ("password", 8, "\x12\x34\x56\x78", 4, 5, dk, 96);
1673: if (memcmp (dk, "\x50\x7c\x36\x6f\xee\x10\x2e\x9a\xe2\x8a\xd5\x82\x72\x7d\x27\x0f\xe8\x4d\x7f\x68\x7a\xcf\xb5\xe7\x43\x67\xaa\x98\x93\x52\x2b\x09\x6e\x42\xdf\x2c\x59\x4a\x91\x6d\x7e\x10\xae\xb2\x1a\x89\x8f\xb9\x8f\xe6\x31\xa9\xd8\x9f\x98\x26\xf4\xda\xcd\x7d\x65\x65\xde\x10\x95\x91\xb4\x84\x26\xae\x43\xa1\x00\x5b\x1e\xb8\x38\x97\xa4\x1e\x4b\xd2\x65\x64\xbc\xfa\x1f\x35\x85\xdb\x4f\x97\x65\x6f\xbd\x24", 96) != 0)
1674: return FALSE;
1675:
1.1 root 1676: return TRUE;
1677: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.