Return a fatal error if application data is encountered during shutdown
[openssl.git] / test / drbgtest.h
1 /*
2  * Copyright 2011-2017 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the OpenSSL license (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 /*
11  * Known answer tests for SP800-90 DRBG CTR mode.
12  */
13
14
15 /*
16  * AES-128 use df PR
17  */
18 static const unsigned char aes_128_use_df_pr_entropyinput[] = {
19     0x61, 0x52, 0x7c, 0xe3, 0x23, 0x7d, 0x0a, 0x07, 0x10, 0x0c, 0x50, 0x33,
20     0xc8, 0xdb, 0xff, 0x12
21 };
22 static const unsigned char aes_128_use_df_pr_nonce[] = {
23     0x51, 0x0d, 0x85, 0x77, 0xed, 0x22, 0x97, 0x28
24 };
25 static const unsigned char aes_128_use_df_pr_personalizationstring[] = {
26     0x59, 0x9f, 0xbb, 0xcd, 0xd5, 0x25, 0x69, 0xb5, 0xcb, 0xb5, 0x03, 0xfe,
27     0xd7, 0xd7, 0x01, 0x67
28 };
29 static const unsigned char aes_128_use_df_pr_additionalinput[] = {
30     0xef, 0x88, 0x76, 0x01, 0xaf, 0x3c, 0xfe, 0x8b, 0xaf, 0x26, 0x06, 0x9e,
31     0x9a, 0x47, 0x08, 0x76
32 };
33 static const unsigned char aes_128_use_df_pr_entropyinputpr[] = {
34     0xe2, 0x76, 0xf9, 0xf6, 0x3a, 0xba, 0x10, 0x9f, 0xbf, 0x47, 0x0e, 0x51,
35     0x09, 0xfb, 0xa3, 0xb6
36 };
37 static const unsigned char aes_128_use_df_pr_int_returnedbits[] = {
38     0xd4, 0x98, 0x8a, 0x46, 0x80, 0x4c, 0xdb, 0xa3, 0x59, 0x02, 0x57, 0x52,
39     0x66, 0x1c, 0xea, 0x5b
40 };
41 static const unsigned char aes_128_use_df_pr_additionalinput2[] = {
42     0x88, 0x8c, 0x91, 0xd6, 0xbe, 0x56, 0x6e, 0x08, 0x9a, 0x62, 0x2b, 0x11,
43     0x3f, 0x5e, 0x31, 0x06
44 };
45 static const unsigned char aes_128_use_df_pr_entropyinputpr2[] = {
46     0xc0, 0x5c, 0x6b, 0x98, 0x01, 0x0d, 0x58, 0x18, 0x51, 0x18, 0x96, 0xae,
47     0xa7, 0xe3, 0xa8, 0x67
48 };
49 static const unsigned char aes_128_use_df_pr_returnedbits[] = {
50     0xcf, 0x01, 0xac, 0x22, 0x31, 0x06, 0x8e, 0xfc, 0xce, 0x56, 0xea, 0x24,
51     0x0f, 0x38, 0x43, 0xc6
52 };
53
54
55 /*
56  * AES-128 use df no PR
57  */
58 static const unsigned char aes_128_use_df_entropyinput[] = {
59     0x1f, 0x8e, 0x34, 0x82, 0x0c, 0xb7, 0xbe, 0xc5, 0x01, 0x3e, 0xd0, 0xa3,
60     0x9d, 0x7d, 0x1c, 0x9b
61 };
62 static const unsigned char aes_128_use_df_nonce[] = {
63     0xd5, 0x4d, 0xbd, 0x4a, 0x93, 0x7f, 0xb8, 0x96,
64 };
65 static const unsigned char aes_128_use_df_personalizationstring[] = {
66     0xab, 0xd6, 0x3f, 0x04, 0xfe, 0x27, 0x6b, 0x2d, 0xd7, 0xc3, 0x1c, 0xf3,
67     0x38, 0x66, 0xba, 0x1b
68 };
69 static const unsigned char aes_128_use_df_additionalinput[] = {
70     0xfe, 0xf4, 0x09, 0xa8, 0xb7, 0x73, 0x27, 0x9c, 0x5f, 0xa7, 0xea, 0x46,
71     0xb5, 0xe2, 0xb2, 0x41
72 };
73 static const unsigned char aes_128_use_df_int_returnedbits[] = {
74     0x42, 0xe4, 0x4e, 0x7b, 0x27, 0xdd, 0xcb, 0xbc, 0x0a, 0xcf, 0xa6, 0x67,
75     0xe7, 0x57, 0x11, 0xb4
76 };
77 static const unsigned char aes_128_use_df_entropyinputreseed[] = {
78     0x14, 0x26, 0x69, 0xd9, 0xf3, 0x65, 0x03, 0xd6, 0x6b, 0xb9, 0x44, 0x0b,
79     0xc7, 0xc4, 0x9e, 0x39
80 };
81 static const unsigned char aes_128_use_df_additionalinputreseed[] = {
82     0x55, 0x2e, 0x60, 0x9a, 0x05, 0x72, 0x8a, 0xa8, 0xef, 0x22, 0x81, 0x5a,
83     0xc8, 0x93, 0xfa, 0x84
84 };
85 static const unsigned char aes_128_use_df_additionalinput2[] = {
86     0x3c, 0x40, 0xc8, 0xc4, 0x16, 0x0c, 0x21, 0xa4, 0x37, 0x2c, 0x8f, 0xa5,
87     0x06, 0x0c, 0x15, 0x2c
88 };
89 static const unsigned char aes_128_use_df_returnedbits[] = {
90     0xe1, 0x3e, 0x99, 0x98, 0x86, 0x67, 0x0b, 0x63, 0x7b, 0xbe, 0x3f, 0x88,
91     0x46, 0x81, 0xc7, 0x19
92 };
93
94
95 /*
96  * AES-192 use df PR
97  */
98 static const unsigned char aes_192_use_df_pr_entropyinput[] = {
99     0x2b, 0x4e, 0x8b, 0xe1, 0xf1, 0x34, 0x80, 0x56, 0x81, 0xf9, 0x74, 0xec,
100     0x17, 0x44, 0x2a, 0xf1, 0x14, 0xb0, 0xbf, 0x97, 0x39, 0xb7, 0x04, 0x7d
101 };
102 static const unsigned char aes_192_use_df_pr_nonce[] = {
103     0xd6, 0x9d, 0xeb, 0x14, 0x4e, 0x6c, 0x30, 0x1e, 0x39, 0x55, 0x73, 0xd0,
104     0xd1, 0x80, 0x78, 0xfa
105 };
106 static const unsigned char aes_192_use_df_pr_personalizationstring[] = {
107     0xfc, 0x43, 0x4a, 0xf8, 0x9a, 0x55, 0xb3, 0x53, 0x83, 0xe2, 0x18, 0x16,
108     0x0c, 0xdc, 0xcd, 0x5e, 0x4f, 0xa0, 0x03, 0x01, 0x2b, 0x9f, 0xe4, 0xd5,
109     0x7d, 0x49, 0xf0, 0x41, 0x9e, 0x3d, 0x99, 0x04
110 };
111 static const unsigned char aes_192_use_df_pr_additionalinput[] = {
112     0x5e, 0x9f, 0x49, 0x6f, 0x21, 0x8b, 0x1d, 0x32, 0xd5, 0x84, 0x5c, 0xac,
113     0xaf, 0xdf, 0xe4, 0x79, 0x9e, 0xaf, 0xa9, 0x82, 0xd0, 0xf8, 0x4f, 0xcb,
114     0x69, 0x10, 0x0a, 0x7e, 0x81, 0x57, 0xb5, 0x36
115 };
116 static const unsigned char aes_192_use_df_pr_entropyinputpr[] = {
117     0xd4, 0x81, 0x0c, 0xd7, 0x66, 0x39, 0xec, 0x42, 0x53, 0x87, 0x41, 0xa5,
118     0x1e, 0x7d, 0x80, 0x91, 0x8e, 0xbb, 0xed, 0xac, 0x14, 0x02, 0x1a, 0xd5,
119 };
120 static const unsigned char aes_192_use_df_pr_int_returnedbits[] = {
121     0xdf, 0x1d, 0x39, 0x45, 0x7c, 0x9b, 0xc6, 0x2b, 0x7d, 0x8c, 0x93, 0xe9,
122     0x19, 0x30, 0x6b, 0x67
123 };
124 static const unsigned char aes_192_use_df_pr_additionalinput2[] = {
125     0x00, 0x71, 0x27, 0x4e, 0xd3, 0x14, 0xf1, 0x20, 0x7f, 0x4a, 0x41, 0x32,
126     0x2a, 0x97, 0x11, 0x43, 0x8f, 0x4a, 0x15, 0x7b, 0x9b, 0x51, 0x79, 0xda,
127     0x49, 0x3d, 0xde, 0xe8, 0xbc, 0x93, 0x91, 0x99
128 };
129 static const unsigned char aes_192_use_df_pr_entropyinputpr2[] = {
130     0x90, 0xee, 0x76, 0xa1, 0x45, 0x8d, 0xb7, 0x40, 0xb0, 0x11, 0xbf, 0xd0,
131     0x65, 0xd7, 0x3c, 0x7c, 0x4f, 0x20, 0x3f, 0x4e, 0x11, 0x9d, 0xb3, 0x5e,
132 };
133 static const unsigned char aes_192_use_df_pr_returnedbits[] = {
134     0x24, 0x3b, 0x20, 0xa4, 0x37, 0x66, 0xba, 0x72, 0x39, 0x3f, 0xcf, 0x3c,
135     0x7e, 0x1a, 0x2b, 0x83
136 };
137
138
139 /*
140  * AES-192 use df no PR
141  */
142 static const unsigned char aes_192_use_df_entropyinput[] = {
143     0x8d, 0x74, 0xa4, 0x50, 0x1a, 0x02, 0x68, 0x0c, 0x2a, 0x69, 0xc4, 0x82,
144     0x3b, 0xbb, 0xda, 0x0e, 0x7f, 0x77, 0xa3, 0x17, 0x78, 0x57, 0xb2, 0x7b,
145 };
146 static const unsigned char aes_192_use_df_nonce[] = {
147     0x75, 0xd5, 0x1f, 0xac, 0xa4, 0x8d, 0x42, 0x78, 0xd7, 0x69, 0x86, 0x9d,
148     0x77, 0xd7, 0x41, 0x0e
149 };
150 static const unsigned char aes_192_use_df_personalizationstring[] = {
151     0x4e, 0x33, 0x41, 0x3c, 0x9c, 0xc2, 0xd2, 0x53, 0xaf, 0x90, 0xea, 0xcf,
152     0x19, 0x50, 0x1e, 0xe6, 0x6f, 0x63, 0xc8, 0x32, 0x22, 0xdc, 0x07, 0x65,
153     0x9c, 0xd3, 0xf8, 0x30, 0x9e, 0xed, 0x35, 0x70
154 };
155 static const unsigned char aes_192_use_df_additionalinput[] = {
156     0x5d, 0x8b, 0x8c, 0xc1, 0xdf, 0x0e, 0x02, 0x78, 0xfb, 0x19, 0xb8, 0x69,
157     0x78, 0x4e, 0x9c, 0x52, 0xbc, 0xc7, 0x20, 0xc9, 0xe6, 0x5e, 0x77, 0x22,
158     0x28, 0x3d, 0x0c, 0x9e, 0x68, 0xa8, 0x45, 0xd7
159 };
160 static const unsigned char aes_192_use_df_int_returnedbits[] = {
161     0xd5, 0xe7, 0x08, 0xc5, 0x19, 0x99, 0xd5, 0x31, 0x03, 0x0a, 0x74, 0xb6,
162     0xb7, 0xed, 0xe9, 0xea
163 };
164 static const unsigned char aes_192_use_df_entropyinputreseed[] = {
165     0x9c, 0x26, 0xda, 0xf1, 0xac, 0xd9, 0x5a, 0xd6, 0xa8, 0x65, 0xf5, 0x02,
166     0x8f, 0xdc, 0xa2, 0x09, 0x54, 0xa6, 0xe2, 0xa4, 0xde, 0x32, 0xe0, 0x01,
167 };
168 static const unsigned char aes_192_use_df_additionalinputreseed[] = {
169     0x9b, 0x90, 0xb0, 0x3a, 0x0e, 0x3a, 0x80, 0x07, 0x4a, 0xf4, 0xda, 0x76,
170     0x28, 0x30, 0x3c, 0xee, 0x54, 0x1b, 0x94, 0x59, 0x51, 0x43, 0x56, 0x77,
171     0xaf, 0x88, 0xdd, 0x63, 0x89, 0x47, 0x06, 0x65
172 };
173 static const unsigned char aes_192_use_df_additionalinput2[] = {
174     0x3c, 0x11, 0x64, 0x7a, 0x96, 0xf5, 0xd8, 0xb8, 0xae, 0xd6, 0x70, 0x4e,
175     0x16, 0x96, 0xde, 0xe9, 0x62, 0xbc, 0xee, 0x28, 0x2f, 0x26, 0xa6, 0xf0,
176     0x56, 0xef, 0xa3, 0xf1, 0x6b, 0xa1, 0xb1, 0x77
177 };
178 static const unsigned char aes_192_use_df_returnedbits[] = {
179     0x0b, 0xe2, 0x56, 0x03, 0x1e, 0xdb, 0x2c, 0x6d, 0x7f, 0x1b, 0x15, 0x58,
180     0x1a, 0xf9, 0x13, 0x28
181 };
182
183
184 /*
185  * AES-256 use df PR
186  */
187 static const unsigned char aes_256_use_df_pr_entropyinput[] = {
188     0x61, 0x68, 0xfc, 0x1a, 0xf0, 0xb5, 0x95, 0x6b, 0x85, 0x09, 0x9b, 0x74,
189     0x3f, 0x13, 0x78, 0x49, 0x3b, 0x85, 0xec, 0x93, 0x13, 0x3b, 0xa9, 0x4f,
190     0x96, 0xab, 0x2c, 0xe4, 0xc8, 0x8f, 0xdd, 0x6a
191 };
192 static const unsigned char aes_256_use_df_pr_nonce[] = {
193     0xad, 0xd2, 0xbb, 0xba, 0xb7, 0x65, 0x89, 0xc3, 0x21, 0x6c, 0x55, 0x33,
194     0x2b, 0x36, 0xff, 0xa4
195 };
196 static const unsigned char aes_256_use_df_pr_personalizationstring[] = {
197     0x6e, 0xca, 0xe7, 0x20, 0x72, 0xd3, 0x84, 0x5a, 0x32, 0xd3, 0x4b, 0x24,
198     0x72, 0xc4, 0x63, 0x2b, 0x9d, 0x12, 0x24, 0x0c, 0x23, 0x26, 0x8e, 0x83,
199     0x16, 0x37, 0x0b, 0xd1, 0x06, 0x4f, 0x68, 0x6d
200 };
201 static const unsigned char aes_256_use_df_pr_additionalinput[] = {
202     0x7e, 0x08, 0x4a, 0xbb, 0xe3, 0x21, 0x7c, 0xc9, 0x23, 0xd2, 0xf8, 0xb0,
203     0x73, 0x98, 0xba, 0x84, 0x74, 0x23, 0xab, 0x06, 0x8a, 0xe2, 0x22, 0xd3,
204     0x7b, 0xce, 0x9b, 0xd2, 0x4a, 0x76, 0xb8, 0xde
205 };
206 static const unsigned char aes_256_use_df_pr_entropyinputpr[] = {
207     0x0b, 0x23, 0xaf, 0xdf, 0xf1, 0x62, 0xd7, 0xd3, 0x43, 0x97, 0xf8, 0x77,
208     0x04, 0xa8, 0x42, 0x20, 0xbd, 0xf6, 0x0f, 0xc1, 0x17, 0x2f, 0x9f, 0x54,
209     0xbb, 0x56, 0x17, 0x86, 0x68, 0x0e, 0xba, 0xa9
210 };
211 static const unsigned char aes_256_use_df_pr_int_returnedbits[] = {
212     0x31, 0x8e, 0xad, 0xaf, 0x40, 0xeb, 0x6b, 0x74, 0x31, 0x46, 0x80, 0xc7,
213     0x17, 0xab, 0x3c, 0x7a
214 };
215 static const unsigned char aes_256_use_df_pr_additionalinput2[] = {
216     0x94, 0x6b, 0xc9, 0x9f, 0xab, 0x8d, 0xc5, 0xec, 0x71, 0x88, 0x1d, 0x00,
217     0x8c, 0x89, 0x68, 0xe4, 0xc8, 0x07, 0x77, 0x36, 0x17, 0x6d, 0x79, 0x78,
218     0xc7, 0x06, 0x4e, 0x99, 0x04, 0x28, 0x29, 0xc3
219 };
220 static const unsigned char aes_256_use_df_pr_entropyinputpr2[] = {
221     0xbf, 0x6c, 0x59, 0x2a, 0x0d, 0x44, 0x0f, 0xae, 0x9a, 0x5e, 0x03, 0x73,
222     0xd8, 0xa6, 0xe1, 0xcf, 0x25, 0x61, 0x38, 0x24, 0x86, 0x9e, 0x53, 0xe8,
223     0xa4, 0xdf, 0x56, 0xf4, 0x06, 0x07, 0x9c, 0x0f
224 };
225 static const unsigned char aes_256_use_df_pr_returnedbits[] = {
226     0x22, 0x4a, 0xb4, 0xb8, 0xb6, 0xee, 0x7d, 0xb1, 0x9e, 0xc9, 0xf9, 0xa0,
227     0xd9, 0xe2, 0x97, 0x00
228 };
229
230
231 /*
232  * AES-256 use df no PR
233  */
234 static const unsigned char aes_256_use_df_entropyinput[] = {
235     0xa5, 0x3e, 0x37, 0x10, 0x17, 0x43, 0x91, 0x93, 0x59, 0x1e, 0x47, 0x50,
236     0x87, 0xaa, 0xdd, 0xd5, 0xc1, 0xc3, 0x86, 0xcd, 0xca, 0x0d, 0xdb, 0x68,
237     0xe0, 0x02, 0xd8, 0x0f, 0xdc, 0x40, 0x1a, 0x47
238 };
239 static const unsigned char aes_256_use_df_nonce[] = {
240     0xa9, 0x4d, 0xa5, 0x5a, 0xfd, 0xc5, 0x0c, 0xe5, 0x1c, 0x9a, 0x3b, 0x8a,
241     0x4c, 0x44, 0x84, 0x40
242 };
243 static const unsigned char aes_256_use_df_personalizationstring[] = {
244     0x8b, 0x52, 0xa2, 0x4a, 0x93, 0xc3, 0x4e, 0xa7, 0x1e, 0x1c, 0xa7, 0x05,
245     0xeb, 0x82, 0x9b, 0xa6, 0x5d, 0xe4, 0xd4, 0xe0, 0x7f, 0xa3, 0xd8, 0x6b,
246     0x37, 0x84, 0x5f, 0xf1, 0xc7, 0xd5, 0xf6, 0xd2
247 };
248 static const unsigned char aes_256_use_df_additionalinput[] = {
249     0x20, 0xf4, 0x22, 0xed, 0xf8, 0x5c, 0xa1, 0x6a, 0x01, 0xcf, 0xbe, 0x5f,
250     0x8d, 0x6c, 0x94, 0x7f, 0xae, 0x12, 0xa8, 0x57, 0xdb, 0x2a, 0xa9, 0xbf,
251     0xc7, 0xb3, 0x65, 0x81, 0x80, 0x8d, 0x0d, 0x46
252 };
253 static const unsigned char aes_256_use_df_int_returnedbits[] = {
254     0x4e, 0x44, 0xfd, 0xf3, 0x9e, 0x29, 0xa2, 0xb8, 0x0f, 0x5d, 0x6c, 0xe1,
255     0x28, 0x0c, 0x3b, 0xc1
256 };
257 static const unsigned char aes_256_use_df_entropyinputreseed[] = {
258     0xdd, 0x40, 0xe5, 0x98, 0x7b, 0x27, 0x16, 0x73, 0x15, 0x68, 0xd2, 0x76,
259     0xbf, 0x0c, 0x67, 0x15, 0x75, 0x79, 0x03, 0xd3, 0xde, 0xde, 0x91, 0x46,
260     0x42, 0xdd, 0xd4, 0x67, 0xc8, 0x79, 0xc8, 0x1e
261 };
262 static const unsigned char aes_256_use_df_additionalinputreseed[] = {
263     0x7f, 0xd8, 0x1f, 0xbd, 0x2a, 0xb5, 0x1c, 0x11, 0x5d, 0x83, 0x4e, 0x99,
264     0xf6, 0x5c, 0xa5, 0x40, 0x20, 0xed, 0x38, 0x8e, 0xd5, 0x9e, 0xe0, 0x75,
265     0x93, 0xfe, 0x12, 0x5e, 0x5d, 0x73, 0xfb, 0x75
266 };
267 static const unsigned char aes_256_use_df_additionalinput2[] = {
268     0xcd, 0x2c, 0xff, 0x14, 0x69, 0x3e, 0x4c, 0x9e, 0xfd, 0xfe, 0x26, 0x0d,
269     0xe9, 0x86, 0x00, 0x49, 0x30, 0xba, 0xb1, 0xc6, 0x50, 0x57, 0x77, 0x2a,
270     0x62, 0x39, 0x2c, 0x3b, 0x74, 0xeb, 0xc9, 0x0d
271 };
272 static const unsigned char aes_256_use_df_returnedbits[] = {
273     0x4f, 0x78, 0xbe, 0xb9, 0x4d, 0x97, 0x8c, 0xe9, 0xd0, 0x97, 0xfe, 0xad,
274     0xfa, 0xfd, 0x35, 0x5e
275 };
276
277
278 /*
279  * AES-128 no df PR
280  */
281 static const unsigned char aes_128_no_df_pr_entropyinput[] = {
282     0x9a, 0x25, 0x65, 0x10, 0x67, 0xd5, 0xb6, 0x6b, 0x70, 0xa1, 0xb3, 0xa4,
283     0x43, 0x95, 0x80, 0xc0, 0x84, 0x0a, 0x79, 0xb0, 0x88, 0x74, 0xf2, 0xbf,
284     0x31, 0x6c, 0x33, 0x38, 0x0b, 0x00, 0xb2, 0x5a
285 };
286 static const unsigned char aes_128_no_df_pr_nonce[] = {
287     0x78, 0x47, 0x6b, 0xf7, 0x90, 0x8e, 0x87, 0xf1,
288 };
289 static const unsigned char aes_128_no_df_pr_personalizationstring[] = {
290     0xf7, 0x22, 0x1d, 0x3a, 0xbe, 0x1d, 0xca, 0x32, 0x1b, 0xbd, 0x87, 0x0c,
291     0x51, 0x24, 0x19, 0xee, 0xa3, 0x23, 0x09, 0x63, 0x33, 0x3d, 0xa8, 0x0c,
292     0x1c, 0xfa, 0x42, 0x89, 0xcc, 0x6f, 0xa0, 0xa8
293 };
294 static const unsigned char aes_128_no_df_pr_additionalinput[] = {
295     0xc9, 0xe0, 0x80, 0xbf, 0x8c, 0x45, 0x58, 0x39, 0xff, 0x00, 0xab, 0x02,
296     0x4c, 0x3e, 0x3a, 0x95, 0x9b, 0x80, 0xa8, 0x21, 0x2a, 0xee, 0xba, 0x73,
297     0xb1, 0xd9, 0xcf, 0x28, 0xf6, 0x8f, 0x9b, 0x12
298 };
299 static const unsigned char aes_128_no_df_pr_entropyinputpr[] = {
300     0x4c, 0xa8, 0xc5, 0xf0, 0x59, 0x9e, 0xa6, 0x8d, 0x26, 0x53, 0xd7, 0x8a,
301     0xa9, 0xd8, 0xf7, 0xed, 0xb2, 0xf9, 0x12, 0x42, 0xe1, 0xe5, 0xbd, 0xe7,
302     0xe7, 0x1d, 0x74, 0x99, 0x00, 0x9d, 0x31, 0x3e
303 };
304 static const unsigned char aes_128_no_df_pr_int_returnedbits[] = {
305     0xe2, 0xac, 0x20, 0xf0, 0x80, 0xe7, 0xbc, 0x7e, 0x9c, 0x7b, 0x65, 0x71,
306     0xaf, 0x19, 0x32, 0x16
307 };
308 static const unsigned char aes_128_no_df_pr_additionalinput2[] = {
309     0x32, 0x7f, 0x38, 0x8b, 0x73, 0x0a, 0x78, 0x83, 0xdc, 0x30, 0xbe, 0x9f,
310     0x10, 0x1f, 0xf5, 0x1f, 0xca, 0x00, 0xb5, 0x0d, 0xd6, 0x9d, 0x60, 0x83,
311     0x51, 0x54, 0x7d, 0x38, 0x23, 0x3a, 0x52, 0x50
312 };
313 static const unsigned char aes_128_no_df_pr_entropyinputpr2[] = {
314     0x18, 0x61, 0x53, 0x56, 0xed, 0xed, 0xd7, 0x20, 0xfb, 0x71, 0x04, 0x7a,
315     0xb2, 0xac, 0xc1, 0x28, 0xcd, 0xf2, 0xc2, 0xfc, 0xaa, 0xb1, 0x06, 0x07,
316     0xe9, 0x46, 0x95, 0x02, 0x48, 0x01, 0x78, 0xf9
317 };
318 static const unsigned char aes_128_no_df_pr_returnedbits[] = {
319     0x29, 0xc8, 0x1b, 0x15, 0xb1, 0xd1, 0xc2, 0xf6, 0x71, 0x86, 0x68, 0x33,
320     0x57, 0x82, 0x33, 0xaf
321 };
322
323
324 /*
325  * AES-128 no df no PR
326  */
327 static const unsigned char aes_128_no_df_entropyinput[] = {
328     0xc9, 0xc5, 0x79, 0xbc, 0xe8, 0xc5, 0x19, 0xd8, 0xbc, 0x66, 0x73, 0x67,
329     0xf6, 0xd3, 0x72, 0xaa, 0xa6, 0x16, 0xb8, 0x50, 0xb7, 0x47, 0x3a, 0x42,
330     0xab, 0xf4, 0x16, 0xb2, 0x96, 0xd2, 0xb6, 0x60
331 };
332 static const unsigned char aes_128_no_df_nonce[] = {
333     0x5f, 0xbf, 0x97, 0x0c, 0x4b, 0xa4, 0x87, 0x13,
334 };
335 static const unsigned char aes_128_no_df_personalizationstring[] = {
336     0xce, 0xfb, 0x7b, 0x3f, 0xd4, 0x6b, 0x29, 0x0d, 0x69, 0x06, 0xff, 0xbb,
337     0xf2, 0xe5, 0xc6, 0x6c, 0x0a, 0x10, 0xa0, 0xcf, 0x1a, 0x48, 0xc7, 0x8b,
338     0x3c, 0x16, 0x88, 0xed, 0x50, 0x13, 0x81, 0xce
339 };
340 static const unsigned char aes_128_no_df_additionalinput[] = {
341     0x4b, 0x22, 0x46, 0x18, 0x02, 0x7b, 0xd2, 0x1b, 0x22, 0x42, 0x7c, 0x37,
342     0xd9, 0xf6, 0xe8, 0x9b, 0x12, 0x30, 0x5f, 0xe9, 0x90, 0xe8, 0x08, 0x24,
343     0x4f, 0x06, 0x66, 0xdb, 0x19, 0x2b, 0x13, 0x95
344 };
345 static const unsigned char aes_128_no_df_int_returnedbits[] = {
346     0x2e, 0x96, 0x70, 0x64, 0xfa, 0xdf, 0xdf, 0x57, 0xb5, 0x82, 0xee, 0xd6,
347     0xed, 0x3e, 0x65, 0xc2
348 };
349 static const unsigned char aes_128_no_df_entropyinputreseed[] = {
350     0x26, 0xc0, 0x72, 0x16, 0x3a, 0x4b, 0xb7, 0x99, 0xd4, 0x07, 0xaf, 0x66,
351     0x62, 0x36, 0x96, 0xa4, 0x51, 0x17, 0xfa, 0x07, 0x8b, 0x17, 0x5e, 0xa1,
352     0x2f, 0x3c, 0x10, 0xe7, 0x90, 0xd0, 0x46, 0x00
353 };
354 static const unsigned char aes_128_no_df_additionalinputreseed[] = {
355     0x83, 0x39, 0x37, 0x7b, 0x02, 0x06, 0xd2, 0x12, 0x13, 0x8d, 0x8b, 0xf2,
356     0xf0, 0xf6, 0x26, 0xeb, 0xa4, 0x22, 0x7b, 0xc2, 0xe7, 0xba, 0x79, 0xe4,
357     0x3b, 0x77, 0x5d, 0x4d, 0x47, 0xb2, 0x2d, 0xb4
358 };
359 static const unsigned char aes_128_no_df_additionalinput2[] = {
360     0x0b, 0xb9, 0x67, 0x37, 0xdb, 0x83, 0xdf, 0xca, 0x81, 0x8b, 0xf9, 0x3f,
361     0xf1, 0x11, 0x1b, 0x2f, 0xf0, 0x61, 0xa6, 0xdf, 0xba, 0xa3, 0xb1, 0xac,
362     0xd3, 0xe6, 0x09, 0xb8, 0x2c, 0x6a, 0x67, 0xd6
363 };
364 static const unsigned char aes_128_no_df_returnedbits[] = {
365     0x1e, 0xa7, 0xa4, 0xe4, 0xe1, 0xa6, 0x7c, 0x69, 0x9a, 0x44, 0x6c, 0x36,
366     0x81, 0x37, 0x19, 0xd4
367 };
368
369
370 /*
371  * AES-192 no df PR
372  */
373 static const unsigned char aes_192_no_df_pr_entropyinput[] = {
374     0x9d, 0x2c, 0xd2, 0x55, 0x66, 0xea, 0xe0, 0xbe, 0x18, 0xb7, 0x76, 0xe7,
375     0x73, 0x35, 0xd8, 0x1f, 0xad, 0x3a, 0xe3, 0x81, 0x0e, 0x92, 0xd0, 0x61,
376     0xc9, 0x12, 0x26, 0xf6, 0x1c, 0xdf, 0xfe, 0x47, 0xaa, 0xfe, 0x7d, 0x5a,
377     0x17, 0x1f, 0x8d, 0x9a
378 };
379 static const unsigned char aes_192_no_df_pr_nonce[] = {
380     0x44, 0x82, 0xed, 0xe8, 0x4c, 0x28, 0x5a, 0x14, 0xff, 0x88, 0x8d, 0x19,
381     0x61, 0x5c, 0xee, 0x0f
382 };
383 static const unsigned char aes_192_no_df_pr_personalizationstring[] = {
384     0x47, 0xd7, 0x9b, 0x99, 0xaa, 0xcb, 0xe7, 0xd2, 0x57, 0x66, 0x2c, 0xe1,
385     0x78, 0xd6, 0x2c, 0xea, 0xa3, 0x23, 0x5f, 0x2a, 0xc1, 0x3a, 0xf0, 0xa4,
386     0x20, 0x3b, 0xfa, 0x07, 0xd5, 0x05, 0x02, 0xe4, 0x57, 0x01, 0xb6, 0x10,
387     0x57, 0x2e, 0xe7, 0x55
388 };
389 static const unsigned char aes_192_no_df_pr_additionalinput[] = {
390     0x4b, 0x74, 0x0b, 0x40, 0xce, 0x6b, 0xc2, 0x6a, 0x24, 0xb4, 0xf3, 0xad,
391     0x7a, 0xa5, 0x7a, 0xa2, 0x15, 0xe2, 0xc8, 0x61, 0x15, 0xc6, 0xb7, 0x85,
392     0x69, 0x11, 0xad, 0x7b, 0x14, 0xd2, 0xf6, 0x12, 0xa1, 0x95, 0x5d, 0x3f,
393     0xe2, 0xd0, 0x0c, 0x2f
394 };
395 static const unsigned char aes_192_no_df_pr_entropyinputpr[] = {
396     0x0c, 0x9c, 0xad, 0x05, 0xee, 0xae, 0x48, 0x23, 0x89, 0x59, 0xa1, 0x94,
397     0xd7, 0xd8, 0x75, 0xd5, 0x54, 0x93, 0xc7, 0x4a, 0xd9, 0x26, 0xde, 0xeb,
398     0xba, 0xb0, 0x7e, 0x30, 0x1d, 0x5f, 0x69, 0x40, 0x9c, 0x3b, 0x17, 0x58,
399     0x1d, 0x30, 0xb3, 0x78
400 };
401 static const unsigned char aes_192_no_df_pr_int_returnedbits[] = {
402     0xf7, 0x93, 0xb0, 0x6d, 0x77, 0x83, 0xd5, 0x38, 0x01, 0xe1, 0x52, 0x40,
403     0x7e, 0x3e, 0x0c, 0x26
404 };
405 static const unsigned char aes_192_no_df_pr_additionalinput2[] = {
406     0xbc, 0x4b, 0x37, 0x44, 0x1c, 0xc5, 0x45, 0x5f, 0x8f, 0x51, 0x62, 0x8a,
407     0x85, 0x30, 0x1d, 0x7c, 0xe4, 0xcf, 0xf7, 0x44, 0xce, 0x32, 0x3e, 0x57,
408     0x95, 0xa4, 0x2a, 0xdf, 0xfd, 0x9e, 0x38, 0x41, 0xb3, 0xf6, 0xc5, 0xee,
409     0x0c, 0x4b, 0xee, 0x6e
410 };
411 static const unsigned char aes_192_no_df_pr_entropyinputpr2[] = {
412     0xec, 0xaf, 0xf6, 0x4f, 0xb1, 0xa0, 0x54, 0xb5, 0x5b, 0xe3, 0x46, 0xb0,
413     0x76, 0x5a, 0x7c, 0x3f, 0x7b, 0x94, 0x69, 0x21, 0x51, 0x02, 0xe5, 0x9f,
414     0x04, 0x59, 0x02, 0x98, 0xc6, 0x43, 0x2c, 0xcc, 0x26, 0x4c, 0x87, 0x6b,
415     0x8e, 0x0a, 0x83, 0xdf
416 };
417 static const unsigned char aes_192_no_df_pr_returnedbits[] = {
418     0x74, 0x45, 0xfb, 0x53, 0x84, 0x96, 0xbe, 0xff, 0x15, 0xcc, 0x41, 0x91,
419     0xb9, 0xa1, 0x21, 0x68
420 };
421
422
423 /*
424  * AES-192 no df no PR
425  */
426 static const unsigned char aes_192_no_df_entropyinput[] = {
427     0x3c, 0x7d, 0xb5, 0xe0, 0x54, 0xd9, 0x6e, 0x8c, 0xa9, 0x86, 0xce, 0x4e,
428     0x6b, 0xaf, 0xeb, 0x2f, 0xe7, 0x75, 0xe0, 0x8b, 0xa4, 0x3b, 0x07, 0xfe,
429     0xbe, 0x33, 0x75, 0x93, 0x80, 0x27, 0xb5, 0x29, 0x47, 0x8b, 0xc7, 0x28,
430     0x94, 0xc3, 0x59, 0x63
431 };
432 static const unsigned char aes_192_no_df_nonce[] = {
433     0x43, 0xf1, 0x7d, 0xb8, 0xc3, 0xfe, 0xd0, 0x23, 0x6b, 0xb4, 0x92, 0xdb,
434     0x29, 0xfd, 0x45, 0x71
435 };
436 static const unsigned char aes_192_no_df_personalizationstring[] = {
437     0x9f, 0x24, 0x29, 0x99, 0x9e, 0x01, 0xab, 0xe9, 0x19, 0xd8, 0x23, 0x08,
438     0xb7, 0xd6, 0x7e, 0x8c, 0xc0, 0x9e, 0x7f, 0x6e, 0x5b, 0x33, 0x20, 0x96,
439     0x0b, 0x23, 0x2c, 0xa5, 0x6a, 0xf8, 0x1b, 0x04, 0x26, 0xdb, 0x2e, 0x2b,
440     0x3b, 0x88, 0xce, 0x35
441 };
442 static const unsigned char aes_192_no_df_additionalinput[] = {
443     0x94, 0xe9, 0x7c, 0x3d, 0xa7, 0xdb, 0x60, 0x83, 0x1f, 0x98, 0x3f, 0x0b,
444     0x88, 0x59, 0x57, 0x51, 0x88, 0x9f, 0x76, 0x49, 0x9f, 0xa6, 0xda, 0x71,
445     0x1d, 0x0d, 0x47, 0x16, 0x63, 0xc5, 0x68, 0xe4, 0x5d, 0x39, 0x69, 0xb3,
446     0x3e, 0xbe, 0xd4, 0x8e
447 };
448 static const unsigned char aes_192_no_df_int_returnedbits[] = {
449     0xf9, 0xd7, 0xad, 0x69, 0xab, 0x8f, 0x23, 0x56, 0x70, 0x17, 0x4f, 0x2a,
450     0x45, 0xe7, 0x4a, 0xc5
451 };
452 static const unsigned char aes_192_no_df_entropyinputreseed[] = {
453     0xa6, 0x71, 0x6a, 0x3d, 0xba, 0xd1, 0xe8, 0x66, 0xa6, 0xef, 0xb2, 0x0e,
454     0xa8, 0x9c, 0xaa, 0x4e, 0xaf, 0x17, 0x89, 0x50, 0x00, 0xda, 0xa1, 0xb1,
455     0x0b, 0xa4, 0xd9, 0x35, 0x89, 0xc8, 0xe5, 0xb0, 0xd9, 0xb7, 0xc4, 0x33,
456     0x9b, 0xcb, 0x7e, 0x75
457 };
458 static const unsigned char aes_192_no_df_additionalinputreseed[] = {
459     0x27, 0x21, 0xfc, 0xc2, 0xbd, 0xf3, 0x3c, 0xce, 0xc3, 0xca, 0xc1, 0x01,
460     0xe0, 0xff, 0x93, 0x12, 0x7d, 0x54, 0x42, 0xe3, 0x9f, 0x03, 0xdf, 0x27,
461     0x04, 0x07, 0x3c, 0x53, 0x7f, 0xa8, 0x66, 0xc8, 0x97, 0x4b, 0x61, 0x40,
462     0x5d, 0x7a, 0x25, 0x79
463 };
464 static const unsigned char aes_192_no_df_additionalinput2[] = {
465     0x2d, 0x8e, 0x16, 0x5d, 0x0b, 0x9f, 0xeb, 0xaa, 0xd6, 0xec, 0x28, 0x71,
466     0x7c, 0x0b, 0xc1, 0x1d, 0xd4, 0x44, 0x19, 0x47, 0xfd, 0x1d, 0x7c, 0xe5,
467     0xf3, 0x27, 0xe1, 0xb6, 0x72, 0x0a, 0xe0, 0xec, 0x0e, 0xcd, 0xef, 0x1a,
468     0x91, 0x6a, 0xe3, 0x5f
469 };
470 static const unsigned char aes_192_no_df_returnedbits[] = {
471     0xe5, 0xda, 0xb8, 0xe0, 0x63, 0x59, 0x5a, 0xcc, 0x3d, 0xdc, 0x9f, 0xe8,
472     0x66, 0x67, 0x2c, 0x92
473 };
474
475
476 /*
477  * AES-256 no df PR
478  */
479 static const unsigned char aes_256_no_df_pr_entropyinput[] = {
480     0x15, 0xc7, 0x5d, 0xcb, 0x41, 0x4b, 0x16, 0x01, 0x3a, 0xd1, 0x44, 0xe8,
481     0x22, 0x32, 0xc6, 0x9c, 0x3f, 0xe7, 0x43, 0xf5, 0x9a, 0xd3, 0xea, 0xf2,
482     0xd7, 0x4e, 0x6e, 0x6a, 0x55, 0x73, 0x40, 0xef, 0x89, 0xad, 0x0d, 0x03,
483     0x96, 0x7e, 0x78, 0x81, 0x2f, 0x91, 0x1b, 0x44, 0xb0, 0x02, 0xba, 0x1c,
484 };
485 static const unsigned char aes_256_no_df_pr_nonce[] = {
486     0xdc, 0xe4, 0xd4, 0x27, 0x7a, 0x90, 0xd7, 0x99, 0x43, 0xa1, 0x3c, 0x30,
487     0xcc, 0x4b, 0xee, 0x2e
488 };
489 static const unsigned char aes_256_no_df_pr_personalizationstring[] = {
490     0xe3, 0xe6, 0xb9, 0x11, 0xe4, 0x7a, 0xa4, 0x40, 0x6b, 0xf8, 0x73, 0xf7,
491     0x7e, 0xec, 0xc7, 0xb9, 0x97, 0xbf, 0xf8, 0x25, 0x7b, 0xbe, 0x11, 0x9b,
492     0x5b, 0x6a, 0x0c, 0x2e, 0x2b, 0x01, 0x51, 0xcd, 0x41, 0x4b, 0x6b, 0xac,
493     0x31, 0xa8, 0x0b, 0xf7, 0xe6, 0x59, 0x42, 0xb8, 0x03, 0x0c, 0xf8, 0x06,
494 };
495 static const unsigned char aes_256_no_df_pr_additionalinput[] = {
496     0x6a, 0x9f, 0x00, 0x91, 0xae, 0xfe, 0xcf, 0x84, 0x99, 0xce, 0xb1, 0x40,
497     0x6d, 0x5d, 0x33, 0x28, 0x84, 0xf4, 0x8c, 0x63, 0x4c, 0x7e, 0xbd, 0x2c,
498     0x80, 0x76, 0xee, 0x5a, 0xaa, 0x15, 0x07, 0x31, 0xd8, 0xbb, 0x8c, 0x69,
499     0x9d, 0x9d, 0xbc, 0x7e, 0x49, 0xae, 0xec, 0x39, 0x6b, 0xd1, 0x1f, 0x7e,
500 };
501 static const unsigned char aes_256_no_df_pr_entropyinputpr[] = {
502     0xf3, 0xb9, 0x75, 0x9c, 0xbd, 0x88, 0xea, 0xa2, 0x50, 0xad, 0xd6, 0x16,
503     0x1a, 0x12, 0x3c, 0x86, 0x68, 0xaf, 0x6f, 0xbe, 0x19, 0xf2, 0xee, 0xcc,
504     0xa5, 0x70, 0x84, 0x53, 0x50, 0xcb, 0x9f, 0x14, 0xa9, 0xe5, 0xee, 0xb9,
505     0x48, 0x45, 0x40, 0xe2, 0xc7, 0xc9, 0x9a, 0x74, 0xff, 0x8c, 0x99, 0x1f,
506 };
507 static const unsigned char aes_256_no_df_pr_int_returnedbits[] = {
508     0x2e, 0xf2, 0x45, 0x4c, 0x62, 0x2e, 0x0a, 0xb9, 0x6b, 0xa2, 0xfd, 0x56,
509     0x79, 0x60, 0x93, 0xcf
510 };
511 static const unsigned char aes_256_no_df_pr_additionalinput2[] = {
512     0xaf, 0x69, 0x20, 0xe9, 0x3b, 0x37, 0x9d, 0x3f, 0xb4, 0x80, 0x02, 0x7a,
513     0x25, 0x7d, 0xb8, 0xde, 0x71, 0xc5, 0x06, 0x0c, 0xb4, 0xe2, 0x8f, 0x35,
514     0xd8, 0x14, 0x0d, 0x7f, 0x76, 0x63, 0x4e, 0xb5, 0xee, 0xe9, 0x6f, 0x34,
515     0xc7, 0x5f, 0x56, 0x14, 0x4a, 0xe8, 0x73, 0x95, 0x5b, 0x1c, 0xb9, 0xcb,
516 };
517 static const unsigned char aes_256_no_df_pr_entropyinputpr2[] = {
518     0xe5, 0xb0, 0x2e, 0x7e, 0x52, 0x30, 0xe3, 0x63, 0x82, 0xb6, 0x44, 0xd3,
519     0x25, 0x19, 0x05, 0x24, 0x9a, 0x9f, 0x5f, 0x27, 0x6a, 0x29, 0xab, 0xfa,
520     0x07, 0xa2, 0x42, 0x0f, 0xc5, 0xa8, 0x94, 0x7c, 0x17, 0x7b, 0x85, 0x83,
521     0x0c, 0x25, 0x0e, 0x63, 0x0b, 0xe9, 0x12, 0x60, 0xcd, 0xef, 0x80, 0x0f,
522 };
523 static const unsigned char aes_256_no_df_pr_returnedbits[] = {
524     0x5e, 0xf2, 0x26, 0xef, 0x9f, 0x58, 0x5d, 0xd5, 0x4a, 0x10, 0xfe, 0xa7,
525     0x2d, 0x5f, 0x4a, 0x46
526 };
527
528
529 /*
530  * AES-256 no df no PR
531  */
532 static const unsigned char aes_256_no_df_entropyinput[] = {
533     0xfb, 0xcf, 0x1b, 0x61, 0x16, 0x89, 0x78, 0x23, 0xf5, 0xd8, 0x96, 0xe3,
534     0x4e, 0x64, 0x0b, 0x29, 0x9a, 0x3f, 0xf8, 0xa5, 0xed, 0xf2, 0xfe, 0xdb,
535     0x16, 0xca, 0x7f, 0x10, 0xfa, 0x5e, 0x18, 0x76, 0x2c, 0x63, 0x5e, 0x96,
536     0xcf, 0xb3, 0xd6, 0xfc, 0xaf, 0x99, 0x39, 0x28, 0x9c, 0x61, 0xe8, 0xb3,
537 };
538 static const unsigned char aes_256_no_df_nonce[] = {
539     0x12, 0x96, 0xf0, 0x52, 0xf3, 0x8d, 0x81, 0xcf, 0xde, 0x86, 0xf2, 0x99,
540     0x43, 0x96, 0xb9, 0xf0
541 };
542 static const unsigned char aes_256_no_df_personalizationstring[] = {
543     0x63, 0x0d, 0x78, 0xf5, 0x90, 0x8e, 0x32, 0x47, 0xb0, 0x4d, 0x37, 0x60,
544     0x09, 0x96, 0xbc, 0xbf, 0x97, 0x7a, 0x62, 0x14, 0x45, 0xbd, 0x8d, 0xcc,
545     0x69, 0xfb, 0x03, 0xe1, 0x80, 0x1c, 0xc7, 0xe2, 0x2a, 0xf9, 0x37, 0x3f,
546     0x66, 0x4d, 0x62, 0xd9, 0x10, 0xe0, 0xad, 0xc8, 0x9a, 0xf0, 0xa8, 0x6d,
547 };
548 static const unsigned char aes_256_no_df_additionalinput[] = {
549     0x36, 0xc6, 0x13, 0x60, 0xbb, 0x14, 0xad, 0x22, 0xb0, 0x38, 0xac, 0xa6,
550     0x18, 0x16, 0x93, 0x25, 0x86, 0xb7, 0xdc, 0xdc, 0x36, 0x98, 0x2b, 0xf9,
551     0x68, 0x33, 0xd3, 0xc6, 0xff, 0xce, 0x8d, 0x15, 0x59, 0x82, 0x76, 0xed,
552     0x6f, 0x8d, 0x49, 0x74, 0x2f, 0xda, 0xdc, 0x1f, 0x17, 0xd0, 0xde, 0x17,
553 };
554 static const unsigned char aes_256_no_df_int_returnedbits[] = {
555     0x16, 0x2f, 0x8e, 0x3f, 0x21, 0x7a, 0x1c, 0x20, 0x56, 0xd1, 0x92, 0xf6,
556     0xd2, 0x25, 0x75, 0x0e
557 };
558 static const unsigned char aes_256_no_df_entropyinputreseed[] = {
559     0x91, 0x79, 0x76, 0xee, 0xe0, 0xcf, 0x9e, 0xc2, 0xd5, 0xd4, 0x23, 0x9b,
560     0x12, 0x8c, 0x7e, 0x0a, 0xb7, 0xd2, 0x8b, 0xd6, 0x7c, 0xa3, 0xc6, 0xe5,
561     0x0e, 0xaa, 0xc7, 0x6b, 0xae, 0x0d, 0xfa, 0x53, 0x06, 0x79, 0xa1, 0xed,
562     0x4d, 0x6a, 0x0e, 0xd8, 0x9d, 0xbe, 0x1b, 0x31, 0x93, 0x7b, 0xec, 0xfb,
563 };
564 static const unsigned char aes_256_no_df_additionalinputreseed[] = {
565     0xd2, 0x46, 0x50, 0x22, 0x10, 0x14, 0x63, 0xf7, 0xea, 0x0f, 0xb9, 0x7e,
566     0x0d, 0xe1, 0x94, 0x07, 0xaf, 0x09, 0x44, 0x31, 0xea, 0x64, 0xa4, 0x18,
567     0x5b, 0xf9, 0xd8, 0xc2, 0xfa, 0x03, 0x47, 0xc5, 0x39, 0x43, 0xd5, 0x3b,
568     0x62, 0x86, 0x64, 0xea, 0x2c, 0x73, 0x8c, 0xae, 0x9d, 0x98, 0x98, 0x29,
569 };
570 static const unsigned char aes_256_no_df_additionalinput2[] = {
571     0x8c, 0xab, 0x18, 0xf8, 0xc3, 0xec, 0x18, 0x5c, 0xb3, 0x1e, 0x9d, 0xbe,
572     0x3f, 0x03, 0xb4, 0x00, 0x98, 0x9d, 0xae, 0xeb, 0xf4, 0x94, 0xf8, 0x42,
573     0x8f, 0xe3, 0x39, 0x07, 0xe1, 0xc9, 0xad, 0x0b, 0x1f, 0xed, 0xc0, 0xba,
574     0xf6, 0xd1, 0xec, 0x27, 0x86, 0x7b, 0xd6, 0x55, 0x9b, 0x60, 0xa5, 0xc6,
575 };
576 static const unsigned char aes_256_no_df_returnedbits[] = {
577     0xef, 0xd2, 0xd8, 0x5c, 0xdc, 0x62, 0x25, 0x9f, 0xaa, 0x1e, 0x2c, 0x67,
578     0xf6, 0x02, 0x32, 0xe2
579 };