1 /*****************************************************************************
2 Copyright (c) 2017-2018, Intel Corporation
4 Redistribution and use in source and binary forms, with or without
5 modification, are permitted provided that the following conditions are met:
7 * Redistributions of source code must retain the above copyright notice,
8 this list of conditions and the following disclaimer.
9 * Redistributions in binary form must reproduce the above copyright
10 notice, this list of conditions and the following disclaimer in the
11 documentation and/or other materials provided with the distribution.
12 * Neither the name of Intel Corporation nor the names of its contributors
13 may be used to endorse or promote products derived from this software
14 without specific prior written permission.
16 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
17 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
19 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
20 FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
22 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
23 CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24 OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
25 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 *****************************************************************************/
33 #include <intel-ipsec-mb.h>
34 #include "gcm_ctr_vectors_test.h"
37 int ccm_test(const enum arch_type arch
, struct MB_MGR
*mb_mgr
);
40 * Test vectors from https://tools.ietf.org/html/rfc3610
44 * =============== Packet Vector #1 ==================
45 * AES Key = C0 C1 C2 C3 C4 C5 C6 C7 C8 C9 CA CB CC CD CE CF
46 * Nonce = 00 00 00 03 02 01 00 A0 A1 A2 A3 A4 A5
47 * Total packet length = 31. [Input with 8 cleartext header octets]
48 * 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
49 * 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E
50 * CBC IV in: 59 00 00 00 03 02 01 00 A0 A1 A2 A3 A4 A5 00 17
51 * CBC IV out:EB 9D 55 47 73 09 55 AB 23 1E 0A 2D FE 4B 90 D6
52 * After xor: EB 95 55 46 71 0A 51 AE 25 19 0A 2D FE 4B 90 D6 [hdr]
53 * After AES: CD B6 41 1E 3C DC 9B 4F 5D 92 58 B6 9E E7 F0 91
54 * After xor: C5 BF 4B 15 30 D1 95 40 4D 83 4A A5 8A F2 E6 86 [msg]
55 * After AES: 9C 38 40 5E A0 3C 1B C9 04 B5 8B 40 C7 6C A2 EB
56 * After xor: 84 21 5A 45 BC 21 05 C9 04 B5 8B 40 C7 6C A2 EB [msg]
57 * After AES: 2D C6 97 E4 11 CA 83 A8 60 C2 C4 06 CC AA 54 2F
58 * CBC-MAC : 2D C6 97 E4 11 CA 83 A8
59 * CTR Start: 01 00 00 00 03 02 01 00 A0 A1 A2 A3 A4 A5 00 01
60 * CTR[0001]: 50 85 9D 91 6D CB 6D DD E0 77 C2 D1 D4 EC 9F 97
61 * CTR[0002]: 75 46 71 7A C6 DE 9A FF 64 0C 9C 06 DE 6D 0D 8F
62 * CTR[MAC ]: 3A 2E 46 C8 EC 33 A5 48
63 * Total packet length = 39. [Authenticated and Encrypted Output]
64 * 00 01 02 03 04 05 06 07 58 8C 97 9A 61 C6 63 D2
65 * F0 66 D0 C2 C0 F9 89 80 6D 5F 6B 61 DA C3 84 17
66 * E8 D1 2C FD F9 26 E0
68 static const uint8_t keys_01
[] = {
69 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
70 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF
72 static const uint8_t nonce_01
[] = {
73 0x00, 0x00, 0x00, 0x03, 0x02, 0x01, 0x00, 0xA0,
74 0xA1, 0xA2, 0xA3, 0xA4, 0xA5
76 static const uint8_t packet_in_01
[] = {
77 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
78 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
79 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
80 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E
82 static const uint8_t packet_out_01
[] = {
83 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
84 0x58, 0x8C, 0x97, 0x9A, 0x61, 0xC6, 0x63, 0xD2,
85 0xF0, 0x66, 0xD0, 0xC2, 0xC0, 0xF9, 0x89, 0x80,
86 0x6D, 0x5F, 0x6B, 0x61, 0xDA, 0xC3, 0x84, 0x17,
87 0xE8, 0xD1, 0x2C, 0xFD, 0xF9, 0x26, 0xE0
89 #define clear_len_01 8
93 * =============== Packet Vector #2 ==================
94 * AES Key = C0 C1 C2 C3 C4 C5 C6 C7 C8 C9 CA CB CC CD CE CF
95 * Nonce = 00 00 00 04 03 02 01 A0 A1 A2 A3 A4 A5
96 * Total packet length = 32. [Input with 8 cleartext header octets]
97 * 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
98 * 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F
99 * CBC IV in: 59 00 00 00 04 03 02 01 A0 A1 A2 A3 A4 A5 00 18
100 * CBC IV out:F0 C2 54 D3 CA 03 E2 39 70 BD 24 A8 4C 39 9E 77
101 * After xor: F0 CA 54 D2 C8 00 E6 3C 76 BA 24 A8 4C 39 9E 77 [hdr]
102 * After AES: 48 DE 8B 86 28 EA 4A 40 00 AA 42 C2 95 BF 4A 8C
103 * After xor: 40 D7 81 8D 24 E7 44 4F 10 BB 50 D1 81 AA 5C 9B [msg]
104 * After AES: 0F 89 FF BC A6 2B C2 4F 13 21 5F 16 87 96 AA 33
105 * After xor: 17 90 E5 A7 BA 36 DC 50 13 21 5F 16 87 96 AA 33 [msg]
106 * After AES: F7 B9 05 6A 86 92 6C F3 FB 16 3D C4 99 EF AA 11
107 * CBC-MAC : F7 B9 05 6A 86 92 6C F3
108 * CTR Start: 01 00 00 00 04 03 02 01 A0 A1 A2 A3 A4 A5 00 01
109 * CTR[0001]: 7A C0 10 3D ED 38 F6 C0 39 0D BA 87 1C 49 91 F4
110 * CTR[0002]: D4 0C DE 22 D5 F9 24 24 F7 BE 9A 56 9D A7 9F 51
111 * CTR[MAC ]: 57 28 D0 04 96 D2 65 E5
112 * Total packet length = 40. [Authenticated and Encrypted Output]
113 * 00 01 02 03 04 05 06 07 72 C9 1A 36 E1 35 F8 CF
114 * 29 1C A8 94 08 5C 87 E3 CC 15 C4 39 C9 E4 3A 3B
115 * A0 91 D5 6E 10 40 09 16
117 static const uint8_t keys_02
[] = {
118 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
119 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF
121 static const uint8_t nonce_02
[] = {
122 0x00, 0x00, 0x00, 0x04, 0x03, 0x02, 0x01, 0xA0,
123 0xA1, 0xA2, 0xA3, 0xA4, 0xA5
125 static const uint8_t packet_in_02
[] = {
126 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
127 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
128 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
129 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F
131 static const uint8_t packet_out_02
[] = {
132 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
133 0x72, 0xC9, 0x1A, 0x36, 0xE1, 0x35, 0xF8, 0xCF,
134 0x29, 0x1C, 0xA8, 0x94, 0x08, 0x5C, 0x87, 0xE3,
135 0xCC, 0x15, 0xC4, 0x39, 0xC9, 0xE4, 0x3A, 0x3B,
136 0xA0, 0x91, 0xD5, 0x6E, 0x10, 0x40, 0x09, 0x16
138 #define clear_len_02 8
139 #define auth_len_02 8
142 * =============== Packet Vector #3 ==================
143 * AES Key = C0 C1 C2 C3 C4 C5 C6 C7 C8 C9 CA CB CC CD CE CF
144 * Nonce = 00 00 00 05 04 03 02 A0 A1 A2 A3 A4 A5
145 * Total packet length = 33. [Input with 8 cleartext header octets]
146 * 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
147 * 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F
149 * CBC IV in: 59 00 00 00 05 04 03 02 A0 A1 A2 A3 A4 A5 00 19
150 * CBC IV out:6F 8A 12 F7 BF 8D 4D C5 A1 19 6E 95 DF F0 B4 27
151 * After xor: 6F 82 12 F6 BD 8E 49 C0 A7 1E 6E 95 DF F0 B4 27 [hdr]
152 * After AES: 37 E9 B7 8C C2 20 17 E7 33 80 43 0C BE F4 28 24
153 * After xor: 3F E0 BD 87 CE 2D 19 E8 23 91 51 1F AA E1 3E 33 [msg]
154 * After AES: 90 CA 05 13 9F 4D 4E CF 22 6F E9 81 C5 9E 2D 40
155 * After xor: 88 D3 1F 08 83 50 50 D0 02 6F E9 81 C5 9E 2D 40 [msg]
156 * After AES: 73 B4 67 75 C0 26 DE AA 41 03 97 D6 70 FE 5F B0
157 * CBC-MAC : 73 B4 67 75 C0 26 DE AA
158 * CTR Start: 01 00 00 00 05 04 03 02 A0 A1 A2 A3 A4 A5 00 01
159 * CTR[0001]: 59 B8 EF FF 46 14 73 12 B4 7A 1D 9D 39 3D 3C FF
160 * CTR[0002]: 69 F1 22 A0 78 C7 9B 89 77 89 4C 99 97 5C 23 78
161 * CTR[MAC ]: 39 6E C0 1A 7D B9 6E 6F
162 * Total packet length = 41. [Authenticated and Encrypted Output]
163 * 00 01 02 03 04 05 06 07 51 B1 E5 F4 4A 19 7D 1D
164 * A4 6B 0F 8E 2D 28 2A E8 71 E8 38 BB 64 DA 85 96
165 * 57 4A DA A7 6F BD 9F B0 C5
167 static const uint8_t keys_03
[] = {
168 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
169 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF
171 static const uint8_t nonce_03
[] = {
172 0x00, 0x00, 0x00, 0x05, 0x04, 0x03, 0x02, 0xA0,
173 0xA1, 0xA2, 0xA3, 0xA4, 0xA5
175 static const uint8_t packet_in_03
[] = {
176 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
177 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
178 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
179 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
182 static const uint8_t packet_out_03
[] = {
183 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
184 0x51, 0xB1, 0xE5, 0xF4, 0x4A, 0x19, 0x7D, 0x1D,
185 0xA4, 0x6B, 0x0F, 0x8E, 0x2D, 0x28, 0x2A, 0xE8,
186 0x71, 0xE8, 0x38, 0xBB, 0x64, 0xDA, 0x85, 0x96,
187 0x57, 0x4A, 0xDA, 0xA7, 0x6F, 0xBD, 0x9F, 0xB0,
190 #define clear_len_03 8
191 #define auth_len_03 8
194 * =============== Packet Vector #4 ==================
195 * AES Key = C0 C1 C2 C3 C4 C5 C6 C7 C8 C9 CA CB CC CD CE CF
196 * Nonce = 00 00 00 06 05 04 03 A0 A1 A2 A3 A4 A5
197 * Total packet length = 31. [Input with 12 cleartext header octets]
198 * 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
199 * 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E
200 * CBC IV in: 59 00 00 00 06 05 04 03 A0 A1 A2 A3 A4 A5 00 13
201 * CBC IV out:06 65 2C 60 0E F5 89 63 CA C3 25 A9 CD 3E 2B E1
202 * After xor: 06 69 2C 61 0C F6 8D 66 CC C4 2D A0 C7 35 2B E1 [hdr]
203 * After AES: A0 75 09 AC 15 C2 58 86 04 2F 80 60 54 FE A6 86
204 * After xor: AC 78 07 A3 05 D3 4A 95 10 3A 96 77 4C E7 BC 9D [msg]
205 * After AES: 64 4C 09 90 D9 1B 83 E9 AB 4B 8E ED 06 6F F5 BF
206 * After xor: 78 51 17 90 D9 1B 83 E9 AB 4B 8E ED 06 6F F5 BF [msg]
207 * After AES: 4B 4F 4B 39 B5 93 E6 BF B0 B2 C2 B7 0F 29 CD 7A
208 * CBC-MAC : 4B 4F 4B 39 B5 93 E6 BF
209 * CTR Start: 01 00 00 00 06 05 04 03 A0 A1 A2 A3 A4 A5 00 01
210 * CTR[0001]: AE 81 66 6A 83 8B 88 6A EE BF 4A 5B 32 84 50 8A
211 * CTR[0002]: D1 B1 92 06 AC 93 9E 2F B6 DD CE 10 A7 74 FD 8D
212 * CTR[MAC ]: DD 87 2A 80 7C 75 F8 4E
213 * Total packet length = 39. [Authenticated and Encrypted Output]
214 * 00 01 02 03 04 05 06 07 08 09 0A 0B A2 8C 68 65
215 * 93 9A 9A 79 FA AA 5C 4C 2A 9D 4A 91 CD AC 8C 96
216 * C8 61 B9 C9 E6 1E F1
218 static const uint8_t keys_04
[] = {
219 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
220 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF
222 static const uint8_t nonce_04
[] = {
223 0x00, 0x00, 0x00, 0x06, 0x05, 0x04, 0x03, 0xA0,
224 0xA1, 0xA2, 0xA3, 0xA4, 0xA5
226 static const uint8_t packet_in_04
[] = {
227 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
228 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
229 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
230 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E
232 static const uint8_t packet_out_04
[] = {
233 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
234 0x08, 0x09, 0x0A, 0x0B, 0xA2, 0x8C, 0x68, 0x65,
235 0x93, 0x9A, 0x9A, 0x79, 0xFA, 0xAA, 0x5C, 0x4C,
236 0x2A, 0x9D, 0x4A, 0x91, 0xCD, 0xAC, 0x8C, 0x96,
237 0xC8, 0x61, 0xB9, 0xC9, 0xE6, 0x1E, 0xF1
239 #define clear_len_04 12
240 #define auth_len_04 8
243 * =============== Packet Vector #5 ==================
244 * AES Key = C0 C1 C2 C3 C4 C5 C6 C7 C8 C9 CA CB CC CD CE CF
245 * Nonce = 00 00 00 07 06 05 04 A0 A1 A2 A3 A4 A5
246 * Total packet length = 32. [Input with 12 cleartext header octets]
247 * 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
248 * 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F
249 * CBC IV in: 59 00 00 00 07 06 05 04 A0 A1 A2 A3 A4 A5 00 14
250 * CBC IV out:00 4C 50 95 45 80 3C 48 51 CD E1 3B 56 C8 9A 85
251 * After xor: 00 40 50 94 47 83 38 4D 57 CA E9 32 5C C3 9A 85 [hdr]
252 * After AES: E2 B8 F7 CE 49 B2 21 72 84 A8 EA 84 FA AD 67 5C
253 * After xor: EE B5 F9 C1 59 A3 33 61 90 BD FC 93 E2 B4 7D 47 [msg]
254 * After AES: 3E FB 36 72 25 DB 11 01 D3 C2 2F 0E CA FF 44 F3
255 * After xor: 22 E6 28 6D 25 DB 11 01 D3 C2 2F 0E CA FF 44 F3 [msg]
256 * After AES: 48 B9 E8 82 55 05 4A B5 49 0A 95 F9 34 9B 4B 5E
257 * CBC-MAC : 48 B9 E8 82 55 05 4A B5
258 * CTR Start: 01 00 00 00 07 06 05 04 A0 A1 A2 A3 A4 A5 00 01
259 * CTR[0001]: D0 FC F5 74 4D 8F 31 E8 89 5B 05 05 4B 7C 90 C3
260 * CTR[0002]: 72 A0 D4 21 9F 0D E1 D4 04 83 BC 2D 3D 0C FC 2A
261 * CTR[MAC ]: 19 51 D7 85 28 99 67 26
262 * Total packet length = 40. [Authenticated and Encrypted Output]
263 * 00 01 02 03 04 05 06 07 08 09 0A 0B DC F1 FB 7B
264 * 5D 9E 23 FB 9D 4E 13 12 53 65 8A D8 6E BD CA 3E
265 * 51 E8 3F 07 7D 9C 2D 93
267 static const uint8_t keys_05
[] = {
268 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
269 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF
271 static const uint8_t nonce_05
[] = {
272 0x00, 0x00, 0x00, 0x07, 0x06, 0x05, 0x04, 0xA0,
273 0xA1, 0xA2, 0xA3, 0xA4, 0xA5
275 static const uint8_t packet_in_05
[] = {
276 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
277 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
278 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
279 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F
281 static const uint8_t packet_out_05
[] = {
282 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
283 0x08, 0x09, 0x0A, 0x0B, 0xDC, 0xF1, 0xFB, 0x7B,
284 0x5D, 0x9E, 0x23, 0xFB, 0x9D, 0x4E, 0x13, 0x12,
285 0x53, 0x65, 0x8A, 0xD8, 0x6E, 0xBD, 0xCA, 0x3E,
286 0x51, 0xE8, 0x3F, 0x07, 0x7D, 0x9C, 0x2D, 0x93
288 #define clear_len_05 12
289 #define auth_len_05 8
292 * =============== Packet Vector #6 ==================
293 * AES Key = C0 C1 C2 C3 C4 C5 C6 C7 C8 C9 CA CB CC CD CE CF
294 * Nonce = 00 00 00 08 07 06 05 A0 A1 A2 A3 A4 A5
295 * Total packet length = 33. [Input with 12 cleartext header octets]
296 * 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
297 * 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F
299 * CBC IV in: 59 00 00 00 08 07 06 05 A0 A1 A2 A3 A4 A5 00 15
300 * CBC IV out:04 72 DA 4C 6F F6 0A 63 06 52 1A 06 04 80 CD E5
301 * After xor: 04 7E DA 4D 6D F5 0E 66 00 55 12 0F 0E 8B CD E5 [hdr]
302 * After AES: 64 4C 36 A5 A2 27 37 62 0B 89 F1 D7 BF F2 73 D4
303 * After xor: 68 41 38 AA B2 36 25 71 1F 9C E7 C0 A7 EB 69 CF [msg]
304 * After AES: 41 E1 19 CD 19 24 CE 77 F1 2F A6 60 C1 6E BB 4E
305 * After xor: 5D FC 07 D2 39 24 CE 77 F1 2F A6 60 C1 6E BB 4E [msg]
306 * After AES: A5 27 D8 15 6A C3 59 BF 1C B8 86 E6 2F 29 91 29
307 * CBC-MAC : A5 27 D8 15 6A C3 59 BF
308 * CTR Start: 01 00 00 00 08 07 06 05 A0 A1 A2 A3 A4 A5 00 01
309 * CTR[0001]: 63 CC BE 1E E0 17 44 98 45 64 B2 3A 8D 24 5C 80
310 * CTR[0002]: 39 6D BA A2 A7 D2 CB D4 B5 E1 7C 10 79 45 BB C0
311 * CTR[MAC ]: E5 7D DC 56 C6 52 92 2B
312 * Total packet length = 41. [Authenticated and Encrypted Output]
313 * 00 01 02 03 04 05 06 07 08 09 0A 0B 6F C1 B0 11
314 * F0 06 56 8B 51 71 A4 2D 95 3D 46 9B 25 70 A4 BD
315 * 87 40 5A 04 43 AC 91 CB 94
317 static const uint8_t keys_06
[] = {
318 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
319 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF
321 static const uint8_t nonce_06
[] = {
322 0x00, 0x00, 0x00, 0x08, 0x07, 0x06, 0x05, 0xA0,
323 0xA1, 0xA2, 0xA3, 0xA4, 0xA5
325 static const uint8_t packet_in_06
[] = {
326 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
327 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
328 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
329 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
332 static const uint8_t packet_out_06
[] = {
333 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
334 0x08, 0x09, 0x0A, 0x0B, 0x6F, 0xC1, 0xB0, 0x11,
335 0xF0, 0x06, 0x56, 0x8B, 0x51, 0x71, 0xA4, 0x2D,
336 0x95, 0x3D, 0x46, 0x9B, 0x25, 0x70, 0xA4, 0xBD,
337 0x87, 0x40, 0x5A, 0x04, 0x43, 0xAC, 0x91, 0xCB,
340 #define clear_len_06 12
341 #define auth_len_06 8
344 * =============== Packet Vector #7 ==================
345 * AES Key = C0 C1 C2 C3 C4 C5 C6 C7 C8 C9 CA CB CC CD CE CF
346 * Nonce = 00 00 00 09 08 07 06 A0 A1 A2 A3 A4 A5
347 * Total packet length = 31. [Input with 8 cleartext header octets]
348 * 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
349 * 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E
350 * CBC IV in: 61 00 00 00 09 08 07 06 A0 A1 A2 A3 A4 A5 00 17
351 * CBC IV out:60 06 C5 72 DA 23 9C BF A0 5B 0A DE D2 CD A8 1E
352 * After xor: 60 0E C5 73 D8 20 98 BA A6 5C 0A DE D2 CD A8 1E [hdr]
353 * After AES: 41 7D E2 AE 94 E2 EA D9 00 FC 44 FC D0 69 52 27
354 * After xor: 49 74 E8 A5 98 EF E4 D6 10 ED 56 EF C4 7C 44 30 [msg]
355 * After AES: 2A 6C 42 CA 49 D7 C7 01 C5 7D 59 FF 87 16 49 0E
356 * After xor: 32 75 58 D1 55 CA D9 01 C5 7D 59 FF 87 16 49 0E [msg]
357 * After AES: 89 8B D6 45 4E 27 20 BB D2 7E F3 15 7A 7C 90 B2
358 * CBC-MAC : 89 8B D6 45 4E 27 20 BB D2 7E
359 * CTR Start: 01 00 00 00 09 08 07 06 A0 A1 A2 A3 A4 A5 00 01
360 * CTR[0001]: 09 3C DB B9 C5 52 4F DA C1 C5 EC D2 91 C4 70 AF
361 * CTR[0002]: 11 57 83 86 E2 C4 72 B4 8E CC 8A AD AB 77 6F CB
362 * CTR[MAC ]: 8D 07 80 25 62 B0 8C 00 A6 EE
363 * Total packet length = 41. [Authenticated and Encrypted Output]
364 * 00 01 02 03 04 05 06 07 01 35 D1 B2 C9 5F 41 D5
365 * D1 D4 FE C1 85 D1 66 B8 09 4E 99 9D FE D9 6C 04
366 * 8C 56 60 2C 97 AC BB 74 90
368 static const uint8_t keys_07
[] = {
369 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
370 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF
372 static const uint8_t nonce_07
[] = {
373 0x00, 0x00, 0x00, 0x09, 0x08, 0x07, 0x06, 0xA0,
374 0xA1, 0xA2, 0xA3, 0xA4, 0xA5
376 static const uint8_t packet_in_07
[] = {
377 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
378 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
379 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
380 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E
382 static const uint8_t packet_out_07
[] = {
383 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
384 0x01, 0x35, 0xD1, 0xB2, 0xC9, 0x5F, 0x41, 0xD5,
385 0xD1, 0xD4, 0xFE, 0xC1, 0x85, 0xD1, 0x66, 0xB8,
386 0x09, 0x4E, 0x99, 0x9D, 0xFE, 0xD9, 0x6C, 0x04,
387 0x8C, 0x56, 0x60, 0x2C, 0x97, 0xAC, 0xBB, 0x74,
390 #define clear_len_07 8
391 #define auth_len_07 10
394 * =============== Packet Vector #8 ==================
395 * AES Key = C0 C1 C2 C3 C4 C5 C6 C7 C8 C9 CA CB CC CD CE CF
396 * Nonce = 00 00 00 0A 09 08 07 A0 A1 A2 A3 A4 A5
397 * Total packet length = 32. [Input with 8 cleartext header octets]
398 * 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
399 * 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F
400 * CBC IV in: 61 00 00 00 0A 09 08 07 A0 A1 A2 A3 A4 A5 00 18
401 * CBC IV out:63 A3 FA E4 6C 79 F3 FA 78 38 B8 A2 80 36 B6 0B
402 * After xor: 63 AB FA E5 6E 7A F7 FF 7E 3F B8 A2 80 36 B6 0B [hdr]
403 * After AES: 1C 99 1A 3D B7 60 79 27 34 40 79 1F AD 8B 5B 02
404 * After xor: 14 90 10 36 BB 6D 77 28 24 51 6B 0C B9 9E 4D 15 [msg]
405 * After AES: 14 19 E8 E8 CB BE 75 58 E1 E3 BE 4B 6C 9F 82 E3
406 * After xor: 0C 00 F2 F3 D7 A3 6B 47 E1 E3 BE 4B 6C 9F 82 E3 [msg]
407 * After AES: E0 16 E8 1C 7F 7B 8A 38 A5 38 F2 CB 5B B6 C1 F2
408 * CBC-MAC : E0 16 E8 1C 7F 7B 8A 38 A5 38
409 * CTR Start: 01 00 00 00 0A 09 08 07 A0 A1 A2 A3 A4 A5 00 01
410 * CTR[0001]: 73 7C 33 91 CC 8E 13 DD E0 AA C5 4B 6D B7 EB 98
411 * CTR[0002]: 74 B7 71 77 C5 AA C5 3B 04 A4 F8 70 8E 92 EB 2B
412 * CTR[MAC ]: 21 6D AC 2F 8B 4F 1C 07 91 8C
413 * Total packet length = 42. [Authenticated and Encrypted Output]
414 * 00 01 02 03 04 05 06 07 7B 75 39 9A C0 83 1D D2
415 * F0 BB D7 58 79 A2 FD 8F 6C AE 6B 6C D9 B7 DB 24
416 * C1 7B 44 33 F4 34 96 3F 34 B4
418 static const uint8_t keys_08
[] = {
419 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
420 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF
422 static const uint8_t nonce_08
[] = {
423 0x00, 0x00, 0x00, 0x0a, 0x09, 0x08, 0x07, 0xA0,
424 0xA1, 0xA2, 0xA3, 0xA4, 0xA5
426 static const uint8_t packet_in_08
[] = {
427 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
428 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
429 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
430 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F
432 static const uint8_t packet_out_08
[] = {
433 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
434 0x7B, 0x75, 0x39, 0x9A, 0xC0, 0x83, 0x1D, 0xD2,
435 0xF0, 0xBB, 0xD7, 0x58, 0x79, 0xA2, 0xFD, 0x8F,
436 0x6C, 0xAE, 0x6B, 0x6C, 0xD9, 0xB7, 0xDB, 0x24,
437 0xC1, 0x7B, 0x44, 0x33, 0xF4, 0x34, 0x96, 0x3F,
440 #define clear_len_08 8
441 #define auth_len_08 10
444 * =============== Packet Vector #9 ==================
445 * AES Key = C0 C1 C2 C3 C4 C5 C6 C7 C8 C9 CA CB CC CD CE CF
446 * Nonce = 00 00 00 0B 0A 09 08 A0 A1 A2 A3 A4 A5
447 * Total packet length = 33. [Input with 8 cleartext header octets]
448 * 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
449 * 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F
451 * CBC IV in: 61 00 00 00 0B 0A 09 08 A0 A1 A2 A3 A4 A5 00 19
452 * CBC IV out:4F 2C 86 11 1E 08 2A DD 6B 44 21 3A B5 13 13 16
453 * After xor: 4F 24 86 10 1C 0B 2E D8 6D 43 21 3A B5 13 13 16 [hdr]
454 * After AES: F6 EC 56 87 3C 57 12 DC 9C C5 3C A8 D4 D1 ED 0A
455 * After xor: FE E5 5C 8C 30 5A 1C D3 8C D4 2E BB C0 C4 FB 1D [msg]
456 * After AES: 17 C1 80 A5 31 53 D4 C3 03 85 0C 95 65 80 34 52
457 * After xor: 0F D8 9A BE 2D 4E CA DC 23 85 0C 95 65 80 34 52 [msg]
458 * After AES: 46 A1 F6 E2 B1 6E 75 F8 1C F5 6B 1A 80 04 44 1B
459 * CBC-MAC : 46 A1 F6 E2 B1 6E 75 F8 1C F5
460 * CTR Start: 01 00 00 00 0B 0A 09 08 A0 A1 A2 A3 A4 A5 00 01
461 * CTR[0001]: 8A 5A 10 6B C0 29 9A 55 5B 93 6B 0B 0E A0 DE 5A
462 * CTR[0002]: EA 05 FD E2 AB 22 5C FE B7 73 12 CB 88 D9 A5 4A
463 * CTR[MAC ]: AC 3D F1 07 DA 30 C4 86 43 BB
464 * Total packet length = 43. [Authenticated and Encrypted Output]
465 * 00 01 02 03 04 05 06 07 82 53 1A 60 CC 24 94 5A
466 * 4B 82 79 18 1A B5 C8 4D F2 1C E7 F9 B7 3F 42 E1
467 * 97 EA 9C 07 E5 6B 5E B1 7E 5F 4E
469 static const uint8_t keys_09
[] = {
470 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
471 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF
473 static const uint8_t nonce_09
[] = {
474 0x00, 0x00, 0x00, 0x0b, 0x0a, 0x09, 0x08, 0xA0,
475 0xA1, 0xA2, 0xA3, 0xA4, 0xA5
477 static const uint8_t packet_in_09
[] = {
478 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
479 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
480 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
481 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
484 static const uint8_t packet_out_09
[] = {
485 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
486 0x82, 0x53, 0x1A, 0x60, 0xCC, 0x24, 0x94, 0x5A,
487 0x4B, 0x82, 0x79, 0x18, 0x1A, 0xB5, 0xC8, 0x4D,
488 0xF2, 0x1C, 0xE7, 0xF9, 0xB7, 0x3F, 0x42, 0xE1,
489 0x97, 0xEA, 0x9C, 0x07, 0xE5, 0x6B, 0x5E, 0xB1,
492 #define clear_len_09 8
493 #define auth_len_09 10
496 * =============== Packet Vector #10 ==================
497 * AES Key = C0 C1 C2 C3 C4 C5 C6 C7 C8 C9 CA CB CC CD CE CF
498 * Nonce = 00 00 00 0C 0B 0A 09 A0 A1 A2 A3 A4 A5
499 * Total packet length = 31. [Input with 12 cleartext header octets]
500 * 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
501 * 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E
502 * CBC IV in: 61 00 00 00 0C 0B 0A 09 A0 A1 A2 A3 A4 A5 00 13
503 * CBC IV out:7F B8 0A 32 E9 80 57 46 EC 31 6C 3A B2 A2 EB 5D
504 * After xor: 7F B4 0A 33 EB 83 53 43 EA 36 64 33 B8 A9 EB 5D [hdr]
505 * After AES: 7E 96 96 BF F1 56 D6 A8 6E AC F5 7B 7F 23 47 5A
506 * After xor: 72 9B 98 B0 E1 47 C4 BB 7A B9 E3 6C 67 3A 5D 41 [msg]
507 * After AES: 8B 4A EE 42 04 24 8A 59 FA CC 88 66 57 66 DD 72
508 * After xor: 97 57 F0 42 04 24 8A 59 FA CC 88 66 57 66 DD 72 [msg]
509 * After AES: 41 63 89 36 62 ED D7 EB CD 6E 15 C1 89 48 62 05
510 * CBC-MAC : 41 63 89 36 62 ED D7 EB CD 6E
511 * CTR Start: 01 00 00 00 0C 0B 0A 09 A0 A1 A2 A3 A4 A5 00 01
512 * CTR[0001]: 0B 39 2B 9B 05 66 97 06 3F 12 56 8F 2B 13 A1 0F
513 * CTR[0002]: 07 89 65 25 23 40 94 3B 9E 69 B2 56 CC 5E F7 31
514 * CTR[MAC ]: 17 09 20 76 09 A0 4E 72 45 B3
515 * Total packet length = 41. [Authenticated and Encrypted Output]
516 * 00 01 02 03 04 05 06 07 08 09 0A 0B 07 34 25 94
517 * 15 77 85 15 2B 07 40 98 33 0A BB 14 1B 94 7B 56
518 * 6A A9 40 6B 4D 99 99 88 DD
520 static const uint8_t keys_10
[] = {
521 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
522 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF
524 static const uint8_t nonce_10
[] = {
525 0x00, 0x00, 0x00, 0x0c, 0x0b, 0x0a, 0x09, 0xA0,
526 0xA1, 0xA2, 0xA3, 0xA4, 0xA5
528 static const uint8_t packet_in_10
[] = {
529 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
530 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
531 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
532 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E
534 static const uint8_t packet_out_10
[] = {
535 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
536 0x08, 0x09, 0x0A, 0x0B, 0x07, 0x34, 0x25, 0x94,
537 0x15, 0x77, 0x85, 0x15, 0x2B, 0x07, 0x40, 0x98,
538 0x33, 0x0A, 0xBB, 0x14, 0x1B, 0x94, 0x7B, 0x56,
539 0x6A, 0xA9, 0x40, 0x6B, 0x4D, 0x99, 0x99, 0x88,
542 #define clear_len_10 12
543 #define auth_len_10 10
546 * =============== Packet Vector #11 ==================
547 * AES Key = C0 C1 C2 C3 C4 C5 C6 C7 C8 C9 CA CB CC CD CE CF
548 * Nonce = 00 00 00 0D 0C 0B 0A A0 A1 A2 A3 A4 A5
549 * Total packet length = 32. [Input with 12 cleartext header octets]
550 * 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
551 * 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F
552 * CBC IV in: 61 00 00 00 0D 0C 0B 0A A0 A1 A2 A3 A4 A5 00 14
553 * CBC IV out:B0 84 85 79 51 D2 FA 42 76 EF 3A D7 14 B9 62 87
554 * After xor: B0 88 85 78 53 D1 FE 47 70 E8 32 DE 1E B2 62 87 [hdr]
555 * After AES: C9 B3 64 7E D8 79 2A 5C 65 B7 CE CC 19 0A 97 0A
556 * After xor: C5 BE 6A 71 C8 68 38 4F 71 A2 D8 DB 01 13 8D 11 [msg]
557 * After AES: 34 0F 69 17 FA B9 19 D6 1D AC D0 35 36 D6 55 8B
558 * After xor: 28 12 77 08 FA B9 19 D6 1D AC D0 35 36 D6 55 8B [msg]
559 * After AES: 6B 5E 24 34 12 CC C2 AD 6F 1B 11 C3 A1 A9 D8 BC
560 * CBC-MAC : 6B 5E 24 34 12 CC C2 AD 6F 1B
561 * CTR Start: 01 00 00 00 0D 0C 0B 0A A0 A1 A2 A3 A4 A5 00 01
562 * CTR[0001]: 6B 66 BC 0C 90 A1 F1 12 FC BE 6F 4E 12 20 77 BC
563 * CTR[0002]: 97 9E 57 2B BE 65 8A E5 CC 20 11 83 2A 9A 9B 5B
564 * CTR[MAC ]: 9E 64 86 DD 02 B6 49 C1 6D 37
565 * Total packet length = 42. [Authenticated and Encrypted Output]
566 * 00 01 02 03 04 05 06 07 08 09 0A 0B 67 6B B2 03
567 * 80 B0 E3 01 E8 AB 79 59 0A 39 6D A7 8B 83 49 34
568 * F5 3A A2 E9 10 7A 8B 6C 02 2C
570 static const uint8_t keys_11
[] = {
571 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
572 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF
574 static const uint8_t nonce_11
[] = {
575 0x00, 0x00, 0x00, 0x0d, 0x0c, 0x0b, 0x0a, 0xA0,
576 0xA1, 0xA2, 0xA3, 0xA4, 0xA5
578 static const uint8_t packet_in_11
[] = {
579 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
580 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
581 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
582 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F
584 static const uint8_t packet_out_11
[] = {
585 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
586 0x08, 0x09, 0x0A, 0x0B, 0x67, 0x6B, 0xB2, 0x03,
587 0x80, 0xB0, 0xE3, 0x01, 0xE8, 0xAB, 0x79, 0x59,
588 0x0A, 0x39, 0x6D, 0xA7, 0x8B, 0x83, 0x49, 0x34,
589 0xF5, 0x3A, 0xA2, 0xE9, 0x10, 0x7A, 0x8B, 0x6C,
592 #define clear_len_11 12
593 #define auth_len_11 10
596 * =============== Packet Vector #12 ==================
597 * AES Key = C0 C1 C2 C3 C4 C5 C6 C7 C8 C9 CA CB CC CD CE CF
598 * Nonce = 00 00 00 0E 0D 0C 0B A0 A1 A2 A3 A4 A5
599 * Total packet length = 33. [Input with 12 cleartext header octets]
600 * 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
601 * 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F
603 * CBC IV in: 61 00 00 00 0E 0D 0C 0B A0 A1 A2 A3 A4 A5 00 15
604 * CBC IV out:5F 8E 8D 02 AD 95 7C 5A 36 14 CF 63 40 16 97 4F
605 * After xor: 5F 82 8D 03 AF 96 78 5F 30 13 C7 6A 4A 1D 97 4F [hdr]
606 * After AES: 63 FA BD 69 B9 55 65 FF 54 AA F4 60 88 7D EC 9F
607 * After xor: 6F F7 B3 66 A9 44 77 EC 40 BF E2 77 90 64 F6 84 [msg]
608 * After AES: 5A 76 5F 0B 93 CE 4F 6A B4 1D 91 30 18 57 6A D7
609 * After xor: 46 6B 41 14 B3 CE 4F 6A B4 1D 91 30 18 57 6A D7 [msg]
610 * After AES: 9D 66 92 41 01 08 D5 B6 A1 45 85 AC AF 86 32 E8
611 * CBC-MAC : 9D 66 92 41 01 08 D5 B6 A1 45
612 * CTR Start: 01 00 00 00 0E 0D 0C 0B A0 A1 A2 A3 A4 A5 00 01
613 * CTR[0001]: CC F2 AE D9 E0 4A C9 74 E6 58 55 B3 2B 94 30 BF
614 * CTR[0002]: A2 CA AC 11 63 F4 07 E5 E5 F6 E3 B3 79 0F 79 F8
615 * CTR[MAC ]: 50 7C 31 57 63 EF 78 D3 77 9E
616 * Total packet length = 43. [Authenticated and Encrypted Output]
617 * 00 01 02 03 04 05 06 07 08 09 0A 0B C0 FF A0 D6
618 * F0 5B DB 67 F2 4D 43 A4 33 8D 2A A4 BE D7 B2 0E
619 * 43 CD 1A A3 16 62 E7 AD 65 D6 DB
621 static const uint8_t keys_12
[] = {
622 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
623 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF
625 static const uint8_t nonce_12
[] = {
626 0x00, 0x00, 0x00, 0x0e, 0x0d, 0x0c, 0x0b, 0xA0,
627 0xA1, 0xA2, 0xA3, 0xA4, 0xA5
629 static const uint8_t packet_in_12
[] = {
630 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
631 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
632 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
633 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
636 static const uint8_t packet_out_12
[] = {
637 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
638 0x08, 0x09, 0x0A, 0x0B, 0xC0, 0xFF, 0xA0, 0xD6,
639 0xF0, 0x5B, 0xDB, 0x67, 0xF2, 0x4D, 0x43, 0xA4,
640 0x33, 0x8D, 0x2A, 0xA4, 0xBE, 0xD7, 0xB2, 0x0E,
641 0x43, 0xCD, 0x1A, 0xA3, 0x16, 0x62, 0xE7, 0xAD,
644 #define clear_len_12 12
645 #define auth_len_12 10
648 * =============== Packet Vector #13 ==================
649 * AES Key = D7 82 8D 13 B2 B0 BD C3 25 A7 62 36 DF 93 CC 6B
650 * Nonce = 00 41 2B 4E A9 CD BE 3C 96 96 76 6C FA
651 * Total packet length = 31. [Input with 8 cleartext header octets]
652 * 0B E1 A8 8B AC E0 18 B1 08 E8 CF 97 D8 20 EA 25
653 * 84 60 E9 6A D9 CF 52 89 05 4D 89 5C EA C4 7C
654 * CBC IV in: 59 00 41 2B 4E A9 CD BE 3C 96 96 76 6C FA 00 17
655 * CBC IV out:33 AE C3 1A 1F B7 CC 35 E5 DA D2 BA C0 90 D9 A3
656 * After xor: 33 A6 C8 FB B7 3C 60 D5 FD 6B D2 BA C0 90 D9 A3 [hdr]
657 * After AES: B7 56 CA 1E 5B 42 C6 9C 58 E3 0A F5 2B F7 7C FD
658 * After xor: BF BE 05 89 83 62 2C B9 DC 83 E3 9F F2 38 2E 74 [msg]
659 * After AES: 33 3D 3A 3D 07 B5 3C 7B 22 0E 96 1A 18 A9 A1 9E
660 * After xor: 36 70 B3 61 ED 71 40 7B 22 0E 96 1A 18 A9 A1 9E [msg]
661 * After AES: 14 BD DB 6B F9 01 63 4D FB 56 51 83 BC 74 93 F7
662 * CBC-MAC : 14 BD DB 6B F9 01 63 4D
663 * CTR Start: 01 00 41 2B 4E A9 CD BE 3C 96 96 76 6C FA 00 01
664 * CTR[0001]: 44 51 B0 11 7A 84 82 BF 03 19 AE C1 59 5E BD DA
665 * CTR[0002]: 83 EB 76 E1 3A 44 84 7F 92 20 09 07 76 B8 25 C5
666 * CTR[MAC ]: F3 31 2C A0 F5 DC B4 FE
667 * Total packet length = 39. [Authenticated and Encrypted Output]
668 * 0B E1 A8 8B AC E0 18 B1 4C B9 7F 86 A2 A4 68 9A
669 * 87 79 47 AB 80 91 EF 53 86 A6 FF BD D0 80 F8 E7
670 * 8C F7 CB 0C DD D7 B3
672 static const uint8_t keys_13
[] = {
673 0xD7, 0x82, 0x8D, 0x13, 0xB2, 0xB0, 0xBD, 0xC3,
674 0x25, 0xA7, 0x62, 0x36, 0xDF, 0x93, 0xCC, 0x6B
676 static const uint8_t nonce_13
[] = {
677 0x00, 0x41, 0x2b, 0x4e, 0xa9, 0xcd, 0xbe, 0x3c,
678 0x96, 0x96, 0x76, 0x6c, 0xfa
680 static const uint8_t packet_in_13
[] = {
681 0x0B, 0xE1, 0xA8, 0x8B, 0xAC, 0xE0, 0x18, 0xB1,
682 0x08, 0xE8, 0xCF, 0x97, 0xD8, 0x20, 0xEA, 0x25,
683 0x84, 0x60, 0xE9, 0x6A, 0xD9, 0xCF, 0x52, 0x89,
684 0x05, 0x4D, 0x89, 0x5C, 0xEA, 0xC4, 0x7C
686 static const uint8_t packet_out_13
[] = {
687 0x0B, 0xE1, 0xA8, 0x8B, 0xAC, 0xE0, 0x18, 0xB1,
688 0x4C, 0xB9, 0x7F, 0x86, 0xA2, 0xA4, 0x68, 0x9A,
689 0x87, 0x79, 0x47, 0xAB, 0x80, 0x91, 0xEF, 0x53,
690 0x86, 0xA6, 0xFF, 0xBD, 0xD0, 0x80, 0xF8, 0xE7,
691 0x8C, 0xF7, 0xCB, 0x0C, 0xDD, 0xD7, 0xB3
693 #define clear_len_13 8
694 #define auth_len_13 8
697 * =============== Packet Vector #14 ==================
698 * AES Key = D7 82 8D 13 B2 B0 BD C3 25 A7 62 36 DF 93 CC 6B
699 * Nonce = 00 33 56 8E F7 B2 63 3C 96 96 76 6C FA
700 * Total packet length = 32. [Input with 8 cleartext header octets]
701 * 63 01 8F 76 DC 8A 1B CB 90 20 EA 6F 91 BD D8 5A
702 * FA 00 39 BA 4B AF F9 BF B7 9C 70 28 94 9C D0 EC
703 * CBC IV in: 59 00 33 56 8E F7 B2 63 3C 96 96 76 6C FA 00 18
704 * CBC IV out:42 0D B1 50 BB 0C 44 DA 83 E4 52 09 55 99 67 E3
705 * After xor: 42 05 D2 51 34 7A 98 50 98 2F 52 09 55 99 67 E3 [hdr]
706 * After AES: EA D1 CA 56 02 02 09 5C E6 12 B0 D2 18 A0 DD 44
707 * After xor: 7A F1 20 39 93 BF D1 06 1C 12 89 68 53 0F 24 FB [msg]
708 * After AES: 51 77 41 69 C3 DE 6B 24 13 27 74 90 F5 FF C5 62
709 * After xor: E6 EB 31 41 57 42 BB C8 13 27 C5 62 [msg]
710 * After AES: D4 CC 3B 82 DF 9F CC 56 7E E5 83 61 D7 8D FB 5E
711 * CBC-MAC : D4 CC 3B 82 DF 9F CC 56
712 * CTR Start: 01 00 33 56 8E F7 B2 63 3C 96 96 76 6C FA 00 01
713 * CTR[0001]: DC EB F4 13 38 3C 66 A0 5A 72 55 EF 98 D7 FF AD
714 * CTR[0002]: 2F 54 2C BA 15 D6 6C DF E1 EC 46 8F 0E 68 A1 24
715 * CTR[MAC ]: 11 E2 D3 9F A2 E8 0C DC
716 * Total packet length = 40. [Authenticated and Encrypted Output]
717 * 63 01 8F 76 DC 8A 1B CB 4C CB 1E 7C A9 81 BE FA
718 * A0 72 6C 55 D3 78 06 12 98 C8 5C 92 81 4A BC 33
719 * C5 2E E8 1D 7D 77 C0 8A
721 static const uint8_t keys_14
[] = {
722 0xD7, 0x82, 0x8D, 0x13, 0xB2, 0xB0, 0xBD, 0xC3,
723 0x25, 0xA7, 0x62, 0x36, 0xDF, 0x93, 0xCC, 0x6B
725 static const uint8_t nonce_14
[] = {
726 0x00, 0x33, 0x56, 0x8E, 0xF7, 0xB2, 0x63, 0x3C,
727 0x96, 0x96, 0x76, 0x6C, 0xFA
729 static const uint8_t packet_in_14
[] = {
730 0x63, 0x01, 0x8F, 0x76, 0xDC, 0x8A, 0x1B, 0xCB,
731 0x90, 0x20, 0xEA, 0x6F, 0x91, 0xBD, 0xD8, 0x5A,
732 0xFA, 0x00, 0x39, 0xBA, 0x4B, 0xAF, 0xF9, 0xBF,
733 0xB7, 0x9C, 0x70, 0x28, 0x94, 0x9C, 0xD0, 0xEC,
735 static const uint8_t packet_out_14
[] = {
736 0x63, 0x01, 0x8F, 0x76, 0xDC, 0x8A, 0x1B, 0xCB,
737 0x4C, 0xCB, 0x1E, 0x7C, 0xA9, 0x81, 0xBE, 0xFA,
738 0xA0, 0x72, 0x6C, 0x55, 0xD3, 0x78, 0x06, 0x12,
739 0x98, 0xC8, 0x5C, 0x92, 0x81, 0x4A, 0xBC, 0x33,
740 0xC5, 0x2E, 0xE8, 0x1D, 0x7D, 0x77, 0xC0, 0x8A
742 #define clear_len_14 8
743 #define auth_len_14 8
746 * =============== Packet Vector #15 ==================
747 * AES Key = D7 82 8D 13 B2 B0 BD C3 25 A7 62 36 DF 93 CC 6B
748 * Nonce = 00 10 3F E4 13 36 71 3C 96 96 76 6C FA
749 * Total packet length = 33. [Input with 8 cleartext header octets]
750 * AA 6C FA 36 CA E8 6B 40 B9 16 E0 EA CC 1C 00 D7
751 * DC EC 68 EC 0B 3B BB 1A 02 DE 8A 2D 1A A3 46 13
753 * CBC IV in: 59 00 10 3F E4 13 36 71 3C 96 96 76 6C FA 00 19
754 * CBC IV out:B3 26 49 FF D5 9F 56 0F 02 2D 11 E2 62 C5 BE EA
755 * After xor: B3 2E E3 93 2F A9 9C E7 69 6D 11 E2 62 C5 BE EA [hdr]
756 * After AES: 82 50 9E E5 B2 FF DB CA 9B D0 2E 20 6B 3F B7 AD
757 * After xor: 3B 46 7E 0F 7E E3 DB 1D 47 3C 46 CC 60 04 0C B7 [msg]
758 * After AES: 80 46 0E 4C 08 3A D0 3F B9 A9 13 BE E4 DE 2F 66
759 * After xor: 82 98 84 61 12 99 96 2C 97 A9 13 BE E4 DE 2F 66 [msg]
760 * After AES: 47 29 CB 00 31 F1 81 C1 92 68 4B 89 A4 71 50 E7
761 * CBC-MAC : 47 29 CB 00 31 F1 81 C1
762 * CTR Start: 01 00 10 3F E4 13 36 71 3C 96 96 76 6C FA 00 01
763 * CTR[0001]: 08 C4 DA C8 EC C1 C0 7B 4C E1 F2 4C 37 5A 47 EE
764 * CTR[0002]: A7 87 2E 6C 6D C4 4E 84 26 02 50 4C 3F A5 73 C5
765 * CTR[MAC ]: E0 5F B2 6E EA 83 B4 C7
766 * Total packet length = 41. [Authenticated and Encrypted Output]
767 * AA 6C FA 36 CA E8 6B 40 B1 D2 3A 22 20 DD C0 AC
768 * 90 0D 9A A0 3C 61 FC F4 A5 59 A4 41 77 67 08 97
769 * 08 A7 76 79 6E DB 72 35 06
771 static const uint8_t keys_15
[] = {
772 0xD7, 0x82, 0x8D, 0x13, 0xB2, 0xB0, 0xBD, 0xC3,
773 0x25, 0xA7, 0x62, 0x36, 0xDF, 0x93, 0xCC, 0x6B
775 static const uint8_t nonce_15
[] = {
776 0x00, 0x10, 0x3F, 0xE4, 0x13, 0x36, 0x71, 0x3C,
777 0x96, 0x96, 0x76, 0x6C, 0xFA
779 static const uint8_t packet_in_15
[] = {
780 0xAA, 0x6C, 0xFA, 0x36, 0xCA, 0xE8, 0x6B, 0x40,
781 0xB9, 0x16, 0xE0, 0xEA, 0xCC, 0x1C, 0x00, 0xD7,
782 0xDC, 0xEC, 0x68, 0xEC, 0x0B, 0x3B, 0xBB, 0x1A,
783 0x02, 0xDE, 0x8A, 0x2D, 0x1A, 0xA3, 0x46, 0x13,
786 static const uint8_t packet_out_15
[] = {
787 0xAA, 0x6C, 0xFA, 0x36, 0xCA, 0xE8, 0x6B, 0x40,
788 0xB1, 0xD2, 0x3A, 0x22, 0x20, 0xDD, 0xC0, 0xAC,
789 0x90, 0x0D, 0x9A, 0xA0, 0x3C, 0x61, 0xFC, 0xF4,
790 0xA5, 0x59, 0xA4, 0x41, 0x77, 0x67, 0x08, 0x97,
791 0x08, 0xA7, 0x76, 0x79, 0x6E, 0xDB, 0x72, 0x35,
794 #define clear_len_15 8
795 #define auth_len_15 8
798 * =============== Packet Vector #16 ==================
799 * AES Key = D7 82 8D 13 B2 B0 BD C3 25 A7 62 36 DF 93 CC 6B
800 * Nonce = 00 76 4C 63 B8 05 8E 3C 96 96 76 6C FA
801 * Total packet length = 31. [Input with 12 cleartext header octets]
802 * D0 D0 73 5C 53 1E 1B EC F0 49 C2 44 12 DA AC 56
803 * 30 EF A5 39 6F 77 0C E1 A6 6B 21 F7 B2 10 1C
804 * CBC IV in: 59 00 76 4C 63 B8 05 8E 3C 96 96 76 6C FA 00 13
805 * CBC IV out:AB DC 4E C9 AA 72 33 97 DF 2D AD 76 33 DE 3B 0D
806 * After xor: AB D0 9E 19 D9 2E 60 89 C4 C1 5D 3F F1 9A 3B 0D [hdr]
807 * After AES: 62 86 F6 2F 23 42 63 B0 1C FD 8C 37 40 74 81 EB
808 * After xor: 70 5C 5A 79 13 AD C6 89 73 8A 80 D6 E6 1F A0 1C [msg]
809 * After AES: 88 95 84 18 CF 79 CA BE EB C0 0C C4 86 E6 01 F7
810 * After xor: 3A 85 98 18 CF 79 CA BE EB C0 0C C4 86 E6 01 F7 [msg]
811 * After AES: C1 85 92 D9 84 CD 67 80 63 D1 D9 6D C1 DF A1 11
812 * CBC-MAC : C1 85 92 D9 84 CD 67 80
813 * CTR Start: 01 00 76 4C 63 B8 05 8E 3C 96 96 76 6C FA 00 01
814 * CTR[0001]: 06 08 FF 95 A6 94 D5 59 F4 0B B7 9D EF FA 41 DF
815 * CTR[0002]: 80 55 3A 75 78 38 04 A9 64 8B 68 DD 7F DC DD 7A
816 * CTR[MAC ]: 5B EA DB 4E DF 07 B9 2F
817 * Total packet length = 39. [Authenticated and Encrypted Output]
818 * D0 D0 73 5C 53 1E 1B EC F0 49 C2 44 14 D2 53 C3
819 * 96 7B 70 60 9B 7C BB 7C 49 91 60 28 32 45 26 9A
820 * 6F 49 97 5B CA DE AF
822 static const uint8_t keys_16
[] = {
823 0xD7, 0x82, 0x8D, 0x13, 0xB2, 0xB0, 0xBD, 0xC3,
824 0x25, 0xA7, 0x62, 0x36, 0xDF, 0x93, 0xCC, 0x6B
826 static const uint8_t nonce_16
[] = {
827 0x00, 0x76, 0x4C, 0x63, 0xB8, 0x05, 0x8E, 0x3C,
828 0x96, 0x96, 0x76, 0x6C, 0xFA
830 static const uint8_t packet_in_16
[] = {
831 0xD0, 0xD0, 0x73, 0x5C, 0x53, 0x1E, 0x1B, 0xEC,
832 0xF0, 0x49, 0xC2, 0x44, 0x12, 0xDA, 0xAC, 0x56,
833 0x30, 0xEF, 0xA5, 0x39, 0x6F, 0x77, 0x0C, 0xE1,
834 0xA6, 0x6B, 0x21, 0xF7, 0xB2, 0x10, 0x1C
836 static const uint8_t packet_out_16
[] = {
837 0xD0, 0xD0, 0x73, 0x5C, 0x53, 0x1E, 0x1B, 0xEC,
838 0xF0, 0x49, 0xC2, 0x44, 0x14, 0xD2, 0x53, 0xC3,
839 0x96, 0x7B, 0x70, 0x60, 0x9B, 0x7C, 0xBB, 0x7C,
840 0x49, 0x91, 0x60, 0x28, 0x32, 0x45, 0x26, 0x9A,
841 0x6F, 0x49, 0x97, 0x5B, 0xCA, 0xDE, 0xAF
843 #define clear_len_16 12
844 #define auth_len_16 8
847 * =============== Packet Vector #17 ==================
848 * AES Key = D7 82 8D 13 B2 B0 BD C3 25 A7 62 36 DF 93 CC 6B
849 * Nonce = 00 F8 B6 78 09 4E 3B 3C 96 96 76 6C FA
850 * Total packet length = 32. [Input with 12 cleartext header octets]
851 * 77 B6 0F 01 1C 03 E1 52 58 99 BC AE E8 8B 6A 46
852 * C7 8D 63 E5 2E B8 C5 46 EF B5 DE 6F 75 E9 CC 0D
853 * CBC IV in: 59 00 F8 B6 78 09 4E 3B 3C 96 96 76 6C FA 00 14
854 * CBC IV out:F4 68 FE 5D B1 53 0B 7A 5A A5 FB 27 40 CF 6E 33
855 * After xor: F4 64 89 EB BE 52 17 79 BB F7 A3 BE FC 61 6E 33 [hdr]
856 * After AES: 23 29 0E 0B 33 45 9A 83 32 2D E4 06 86 67 10 04
857 * After xor: CB A2 64 4D F4 C8 F9 66 1C 95 21 40 69 D2 CE 6B [msg]
858 * After AES: 8F BE D4 0F 8B 89 B7 B8 20 D5 5F E0 3C E2 43 11
859 * After xor: FA 57 18 02 8B 89 B7 B8 20 D5 5F E0 3C E2 43 11 [msg]
860 * After AES: 6A DB 15 B6 71 81 B2 E2 2B E3 4A F2 B2 83 E2 29
861 * CBC-MAC : 6A DB 15 B6 71 81 B2 E2
862 * CTR Start: 01 00 F8 B6 78 09 4E 3B 3C 96 96 76 6C FA 00 01
863 * CTR[0001]: BD CE 95 5C CF D3 81 0A 91 EA 77 A6 A4 5B C0 4C
864 * CTR[0002]: 43 2E F2 32 AE 36 D8 92 22 BF 63 37 E6 B2 6C E8
865 * CTR[MAC ]: 1C F7 19 C1 35 7F CC DE
866 * Total packet length = 40. [Authenticated and Encrypted Output]
867 * 77 B6 0F 01 1C 03 E1 52 58 99 BC AE 55 45 FF 1A
868 * 08 5E E2 EF BF 52 B2 E0 4B EE 1E 23 36 C7 3E 3F
869 * 76 2C 0C 77 44 FE 7E 3C
871 static const uint8_t keys_17
[] = {
872 0xD7, 0x82, 0x8D, 0x13, 0xB2, 0xB0, 0xBD, 0xC3,
873 0x25, 0xA7, 0x62, 0x36, 0xDF, 0x93, 0xCC, 0x6B
875 static const uint8_t nonce_17
[] = {
876 0x00, 0xF8, 0xB6, 0x78, 0x09, 0x4E, 0x3B, 0x3C,
877 0x96, 0x96, 0x76, 0x6C, 0xFA
879 static const uint8_t packet_in_17
[] = {
880 0x77, 0xB6, 0x0F, 0x01, 0x1C, 0x03, 0xE1, 0x52,
881 0x58, 0x99, 0xBC, 0xAE, 0xE8, 0x8B, 0x6A, 0x46,
882 0xC7, 0x8D, 0x63, 0xE5, 0x2E, 0xB8, 0xC5, 0x46,
883 0xEF, 0xB5, 0xDE, 0x6F, 0x75, 0xE9, 0xCC, 0x0D
885 static const uint8_t packet_out_17
[] = {
886 0x77, 0xB6, 0x0F, 0x01, 0x1C, 0x03, 0xE1, 0x52,
887 0x58, 0x99, 0xBC, 0xAE, 0x55, 0x45, 0xFF, 0x1A,
888 0x08, 0x5E, 0xE2, 0xEF, 0xBF, 0x52, 0xB2, 0xE0,
889 0x4B, 0xEE, 0x1E, 0x23, 0x36, 0xC7, 0x3E, 0x3F,
890 0x76, 0x2C, 0x0C, 0x77, 0x44, 0xFE, 0x7E, 0x3C
892 #define clear_len_17 12
893 #define auth_len_17 8
896 * =============== Packet Vector #18 ==================
897 * AES Key = D7 82 8D 13 B2 B0 BD C3 25 A7 62 36 DF 93 CC 6B
898 * Nonce = 00 D5 60 91 2D 3F 70 3C 96 96 76 6C FA
899 * Total packet length = 33. [Input with 12 cleartext header octets]
900 * CD 90 44 D2 B7 1F DB 81 20 EA 60 C0 64 35 AC BA
901 * FB 11 A8 2E 2F 07 1D 7C A4 A5 EB D9 3A 80 3B A8
903 * CBC IV in: 59 00 D5 60 91 2D 3F 70 3C 96 96 76 6C FA 00 15
904 * CBC IV out:BA 37 74 54 D7 20 A4 59 25 97 F6 A3 D1 D6 BA 67
905 * After xor: BA 3B B9 C4 93 F2 13 46 FE 16 D6 49 B1 16 BA 67 [hdr]
906 * After AES: 81 6A 20 20 38 D0 A6 30 CB E0 B7 3C 39 BB CE 05
907 * After xor: E5 5F 8C 9A C3 C1 0E 1E E4 E7 AA 40 9D 1E 25 DC [msg]
908 * After AES: 6D 5C 15 FD 85 2D 5C 3C E3 03 3D 85 DA 57 BD AC
909 * After xor: 57 DC 2E 55 FA 2D 5C 3C E3 03 3D 85 DA 57 BD AC [msg]
910 * After AES: B0 4A 1C 23 BC 39 B6 51 76 FD 5B FF 9B C1 28 5E
911 * CBC-MAC : B0 4A 1C 23 BC 39 B6 51
912 * CTR Start: 01 00 D5 60 91 2D 3F 70 3C 96 96 76 6C FA 00 01
913 * CTR[0001]: 64 A2 C5 56 50 CE E0 4C 7A 93 D8 EE F5 43 E8 8E
914 * CTR[0002]: 18 E7 65 AC B7 B0 E9 AF 09 2B D0 20 6C A1 C8 3C
915 * CTR[MAC ]: F7 43 82 79 5C 49 F3 00
916 * Total packet length = 41. [Authenticated and Encrypted Output]
917 * CD 90 44 D2 B7 1F DB 81 20 EA 60 C0 00 97 69 EC
918 * AB DF 48 62 55 94 C5 92 51 E6 03 57 22 67 5E 04
919 * C8 47 09 9E 5A E0 70 45 51
921 static const uint8_t keys_18
[] = {
922 0xD7, 0x82, 0x8D, 0x13, 0xB2, 0xB0, 0xBD, 0xC3,
923 0x25, 0xA7, 0x62, 0x36, 0xDF, 0x93, 0xCC, 0x6B
925 static const uint8_t nonce_18
[] = {
926 0x00, 0xD5, 0x60, 0x91, 0x2D, 0x3F, 0x70, 0x3C,
927 0x96, 0x96, 0x76, 0x6C, 0xFA
929 static const uint8_t packet_in_18
[] = {
930 0xCD, 0x90, 0x44, 0xD2, 0xB7, 0x1F, 0xDB, 0x81,
931 0x20, 0xEA, 0x60, 0xC0, 0x64, 0x35, 0xAC, 0xBA,
932 0xFB, 0x11, 0xA8, 0x2E, 0x2F, 0x07, 0x1D, 0x7C,
933 0xA4, 0xA5, 0xEB, 0xD9, 0x3A, 0x80, 0x3B, 0xA8,
936 static const uint8_t packet_out_18
[] = {
937 0xCD, 0x90, 0x44, 0xD2, 0xB7, 0x1F, 0xDB, 0x81,
938 0x20, 0xEA, 0x60, 0xC0, 0x00, 0x97, 0x69, 0xEC,
939 0xAB, 0xDF, 0x48, 0x62, 0x55, 0x94, 0xC5, 0x92,
940 0x51, 0xE6, 0x03, 0x57, 0x22, 0x67, 0x5E, 0x04,
941 0xC8, 0x47, 0x09, 0x9E, 0x5A, 0xE0, 0x70, 0x45,
944 #define clear_len_18 12
945 #define auth_len_18 8
948 * =============== Packet Vector #19 ==================
949 * AES Key = D7 82 8D 13 B2 B0 BD C3 25 A7 62 36 DF 93 CC 6B
950 * Nonce = 00 42 FF F8 F1 95 1C 3C 96 96 76 6C FA
951 * Total packet length = 31. [Input with 8 cleartext header octets]
952 * D8 5B C7 E6 9F 94 4F B8 8A 19 B9 50 BC F7 1A 01
953 * 8E 5E 67 01 C9 17 87 65 98 09 D6 7D BE DD 18
954 * CBC IV in: 61 00 42 FF F8 F1 95 1C 3C 96 96 76 6C FA 00 17
955 * CBC IV out:44 F7 CC 9C 2B DD 2F 45 F6 38 25 6B 73 6E 1D 7A
956 * After xor: 44 FF 14 C7 EC 3B B0 D1 B9 80 25 6B 73 6E 1D 7A [hdr]
957 * After AES: 57 C3 73 F8 00 AA 5F CC 7B CF 1D 1B DD BB 4C 52
958 * After xor: DD DA CA A8 BC 5D 45 CD F5 91 7A 1A 14 AC CB 37 [msg]
959 * After AES: 42 4E 93 72 72 C8 79 B6 11 C7 A5 9F 47 8D 9F D8
960 * After xor: DA 47 45 0F CC 15 61 B6 11 C7 A5 9F 47 8D 9F D8 [msg]
961 * After AES: 9A CB 03 F8 B9 DB C8 D2 D2 D7 A4 B4 95 25 08 67
962 * CBC-MAC : 9A CB 03 F8 B9 DB C8 D2 D2 D7
963 * CTR Start: 01 00 42 FF F8 F1 95 1C 3C 96 96 76 6C FA 00 01
964 * CTR[0001]: 36 38 34 FA 28 83 3D B7 55 66 0D 98 65 0D 68 46
965 * CTR[0002]: 35 E9 63 54 87 16 72 56 3F 0C 08 AF 78 44 31 A9
966 * CTR[MAC ]: F9 B7 FA 46 7B 9B 40 45 14 6D
967 * Total packet length = 41. [Authenticated and Encrypted Output]
968 * D8 5B C7 E6 9F 94 4F B8 BC 21 8D AA 94 74 27 B6
969 * DB 38 6A 99 AC 1A EF 23 AD E0 B5 29 39 CB 6A 63
970 * 7C F9 BE C2 40 88 97 C6 BA
972 static const uint8_t keys_19
[] = {
973 0xD7, 0x82, 0x8D, 0x13, 0xB2, 0xB0, 0xBD, 0xC3,
974 0x25, 0xA7, 0x62, 0x36, 0xDF, 0x93, 0xCC, 0x6B
976 static const uint8_t nonce_19
[] = {
977 0x00, 0x42, 0xFF, 0xF8, 0xF1, 0x95, 0x1C, 0x3C,
978 0x96, 0x96, 0x76, 0x6C, 0xFA
980 static const uint8_t packet_in_19
[] = {
981 0xD8, 0x5B, 0xC7, 0xE6, 0x9F, 0x94, 0x4F, 0xB8,
982 0x8A, 0x19, 0xB9, 0x50, 0xBC, 0xF7, 0x1A, 0x01,
983 0x8E, 0x5E, 0x67, 0x01, 0xC9, 0x17, 0x87, 0x65,
984 0x98, 0x09, 0xD6, 0x7D, 0xBE, 0xDD, 0x18
986 static const uint8_t packet_out_19
[] = {
987 0xD8, 0x5B, 0xC7, 0xE6, 0x9F, 0x94, 0x4F, 0xB8,
988 0xBC, 0x21, 0x8D, 0xAA, 0x94, 0x74, 0x27, 0xB6,
989 0xDB, 0x38, 0x6A, 0x99, 0xAC, 0x1A, 0xEF, 0x23,
990 0xAD, 0xE0, 0xB5, 0x29, 0x39, 0xCB, 0x6A, 0x63,
991 0x7C, 0xF9, 0xBE, 0xC2, 0x40, 0x88, 0x97, 0xC6,
994 #define clear_len_19 8
995 #define auth_len_19 10
998 * ================= Packet Vector #20 ==================
999 * AES Key = D7 82 8D 13 B2 B0 BD C3 25 A7 62 36 DF 93 CC 6B
1000 * Nonce = 00 92 0F 40 E5 6C DC 3C 96 96 76 6C FA
1001 * Total packet length = 32. [Input with 8 cleartext header octets]
1002 * 74 A0 EB C9 06 9F 5B 37 17 61 43 3C 37 C5 A3 5F
1003 * C1 F3 9F 40 63 02 EB 90 7C 61 63 BE 38 C9 84 37
1004 * CBC IV in: 61 00 92 0F 40 E5 6C DC 3C 96 96 76 6C FA 00 18
1005 * CBC IV out:60 CB 21 CE 40 06 50 AE 2A D2 BE 52 9F 5F 0F C2
1006 * After xor: 60 C3 55 6E AB CF 56 31 71 E5 BE 52 9F 5F 0F C2 [hdr]
1007 * After AES: 03 20 64 14 35 32 5D 95 C8 A2 50 40 93 28 DA 9B
1008 * After xor: 14 41 27 28 02 F7 FE CA 09 51 CF 00 F0 2A 31 0B [msg]
1009 * After AES: B9 E8 87 95 ED F7 F0 08 15 15 F0 14 E2 FE 0E 48
1010 * After xor: C5 89 E4 2B D5 3E 74 3F 15 15 F0 14 E2 FE 0E 48 [msg]
1011 * After AES: 8F AD 0C 23 E9 63 7E 87 FA 21 45 51 1B 47 DE F1
1012 * CBC-MAC : 8F AD 0C 23 E9 63 7E 87 FA 21
1013 * CTR Start: 01 00 92 0F 40 E5 6C DC 3C 96 96 76 6C FA 00 01
1014 * CTR[0001]: 4F 71 A5 C1 12 42 E3 7D 29 F0 FE E4 1B E1 02 5F
1015 * CTR[0002]: 34 2B D3 F1 7C B7 7B C1 79 0B 05 05 61 59 27 2C
1016 * CTR[MAC ]: 7F 09 7B EF C6 AA C1 D3 73 65
1017 * Total packet length = 42. [Authenticated and Encrypted Output]
1018 * 74 A0 EB C9 06 9F 5B 37 58 10 E6 FD 25 87 40 22
1019 * E8 03 61 A4 78 E3 E9 CF 48 4A B0 4F 44 7E FF F6
1020 * F0 A4 77 CC 2F C9 BF 54 89 44
1022 static const uint8_t keys_20
[] = {
1023 0xD7, 0x82, 0x8D, 0x13, 0xB2, 0xB0, 0xBD, 0xC3,
1024 0x25, 0xA7, 0x62, 0x36, 0xDF, 0x93, 0xCC, 0x6B
1026 static const uint8_t nonce_20
[] = {
1027 0x00, 0x92, 0x0F, 0x40, 0xE5, 0x6C, 0xDC, 0x3C,
1028 0x96, 0x96, 0x76, 0x6C, 0xFA
1030 static const uint8_t packet_in_20
[] = {
1031 0x74, 0xA0, 0xEB, 0xC9, 0x06, 0x9F, 0x5B, 0x37,
1032 0x17, 0x61, 0x43, 0x3C, 0x37, 0xC5, 0xA3, 0x5F,
1033 0xC1, 0xF3, 0x9F, 0x40, 0x63, 0x02, 0xEB, 0x90,
1034 0x7C, 0x61, 0x63, 0xBE, 0x38, 0xC9, 0x84, 0x37
1036 static const uint8_t packet_out_20
[] = {
1037 0x74, 0xA0, 0xEB, 0xC9, 0x06, 0x9F, 0x5B, 0x37,
1038 0x58, 0x10, 0xE6, 0xFD, 0x25, 0x87, 0x40, 0x22,
1039 0xE8, 0x03, 0x61, 0xA4, 0x78, 0xE3, 0xE9, 0xCF,
1040 0x48, 0x4A, 0xB0, 0x4F, 0x44, 0x7E, 0xFF, 0xF6,
1041 0xF0, 0xA4, 0x77, 0xCC, 0x2F, 0xC9, 0xBF, 0x54,
1044 #define clear_len_20 8
1045 #define auth_len_20 10
1048 * =============== Packet Vector #21 ==================
1049 * AES Key = D7 82 8D 13 B2 B0 BD C3 25 A7 62 36 DF 93 CC 6B
1050 * Nonce = 00 27 CA 0C 71 20 BC 3C 96 96 76 6C FA
1051 * Total packet length = 33. [Input with 8 cleartext header octets]
1052 * 44 A3 AA 3A AE 64 75 CA A4 34 A8 E5 85 00 C6 E4
1053 * 15 30 53 88 62 D6 86 EA 9E 81 30 1B 5A E4 22 6B
1055 * CBC IV in: 61 00 27 CA 0C 71 20 BC 3C 96 96 76 6C FA 00 19
1056 * CBC IV out:43 07 C0 73 A8 9E E1 D5 05 27 B2 9A 62 48 D6 D2
1057 * After xor: 43 0F 84 D0 02 A4 4F B1 70 ED B2 9A 62 48 D6 D2 [hdr]
1058 * After AES: B6 0B C6 F5 84 01 75 BC 01 27 70 F1 11 8D 75 10
1059 * After xor: 12 3F 6E 10 01 01 B3 58 14 17 23 79 73 5B F3 FA [msg]
1060 * After AES: 7D 5E 64 92 CE 2C B9 EA 7E 4C 4A 09 09 89 C8 FB
1061 * After xor: E3 DF 54 89 94 C8 9B 81 84 4C 4A 09 09 89 C8 FB [msg]
1062 * After AES: 68 5F 8D 79 D2 2B 9B 74 21 DF 4C 3E 87 BA 0A AF
1063 * CBC-MAC : 68 5F 8D 79 D2 2B 9B 74 21 DF
1064 * CTR Start: 01 00 27 CA 0C 71 20 BC 3C 96 96 76 6C FA 00 01
1065 * CTR[0001]: 56 8A 45 9E 40 09 48 67 EB 85 E0 9E 6A 2E 64 76
1066 * CTR[0002]: A6 00 AA 92 92 03 54 9A AE EF 2C CC 59 13 7A 57
1067 * CTR[MAC ]: 25 1E DC DD 3F 11 10 F3 98 11
1068 * Total packet length = 43. [Authenticated and Encrypted Output]
1069 * 44 A3 AA 3A AE 64 75 CA F2 BE ED 7B C5 09 8E 83
1070 * FE B5 B3 16 08 F8 E2 9C 38 81 9A 89 C8 E7 76 F1
1071 * 54 4D 41 51 A4 ED 3A 8B 87 B9 CE
1073 static const uint8_t keys_21
[] = {
1074 0xD7, 0x82, 0x8D, 0x13, 0xB2, 0xB0, 0xBD, 0xC3,
1075 0x25, 0xA7, 0x62, 0x36, 0xDF, 0x93, 0xCC, 0x6B
1077 static const uint8_t nonce_21
[] = {
1078 0x00, 0x27, 0xCA, 0x0C, 0x71, 0x20, 0xBC, 0x3C,
1079 0x96, 0x96, 0x76, 0x6C, 0xFA
1081 static const uint8_t packet_in_21
[] = {
1082 0x44, 0xA3, 0xAA, 0x3A, 0xAE, 0x64, 0x75, 0xCA,
1083 0xA4, 0x34, 0xA8, 0xE5, 0x85, 0x00, 0xC6, 0xE4,
1084 0x15, 0x30, 0x53, 0x88, 0x62, 0xD6, 0x86, 0xEA,
1085 0x9E, 0x81, 0x30, 0x1B, 0x5A, 0xE4, 0x22, 0x6B,
1088 static const uint8_t packet_out_21
[] = {
1089 0x44, 0xA3, 0xAA, 0x3A, 0xAE, 0x64, 0x75, 0xCA,
1090 0xF2, 0xBE, 0xED, 0x7B, 0xC5, 0x09, 0x8E, 0x83,
1091 0xFE, 0xB5, 0xB3, 0x16, 0x08, 0xF8, 0xE2, 0x9C,
1092 0x38, 0x81, 0x9A, 0x89, 0xC8, 0xE7, 0x76, 0xF1,
1093 0x54, 0x4D, 0x41, 0x51, 0xA4, 0xED, 0x3A, 0x8B,
1096 #define clear_len_21 8
1097 #define auth_len_21 10
1100 * =============== Packet Vector #22 ==================
1101 * AES Key = D7 82 8D 13 B2 B0 BD C3 25 A7 62 36 DF 93 CC 6B
1102 * Nonce = 00 5B 8C CB CD 9A F8 3C 96 96 76 6C FA
1103 * Total packet length = 31. [Input with 12 cleartext header octets]
1104 * EC 46 BB 63 B0 25 20 C3 3C 49 FD 70 B9 6B 49 E2
1105 * 1D 62 17 41 63 28 75 DB 7F 6C 92 43 D2 D7 C2
1106 * CBC IV in: 61 00 5B 8C CB CD 9A F8 3C 96 96 76 6C FA 00 13
1107 * CBC IV out:91 14 AD 06 B6 CC 02 35 76 9A B6 14 C4 82 95 03
1108 * After xor: 91 18 41 40 0D AF B2 10 56 59 8A 5D 39 F2 95 03 [hdr]
1109 * After AES: 29 BD 7C 27 83 E3 E8 D3 C3 5C 01 F4 4C EC BB FA
1110 * After xor: 90 D6 35 C5 9E 81 FF 92 A0 74 74 2F 33 80 29 B9 [msg]
1111 * After AES: 4E DA F4 0D 21 0B D4 5F FE 97 90 B9 AA EC 34 4C
1112 * After xor: 9C 0D 36 0D 21 0B D4 5F FE 97 90 B9 AA EC 34 4C [msg]
1113 * After AES: 21 9E F8 90 EA 64 C2 11 A5 37 88 83 E1 BA 22 0D
1114 * CBC-MAC : 21 9E F8 90 EA 64 C2 11 A5 37
1115 * CTR Start: 01 00 5B 8C CB CD 9A F8 3C 96 96 76 6C FA 00 01
1116 * CTR[0001]: 88 BC 19 42 80 C1 FA 3E BE FC EF FB 4D C6 2D 54
1117 * CTR[0002]: 3E 59 7D A5 AE 21 CC A4 00 9E 4C 0C 91 F6 22 49
1118 * CTR[MAC ]: 5C BC 30 98 66 02 A9 F4 64 A0
1119 * Total packet length = 41. [Authenticated and Encrypted Output]
1120 * EC 46 BB 63 B0 25 20 C3 3C 49 FD 70 31 D7 50 A0
1121 * 9D A3 ED 7F DD D4 9A 20 32 AA BF 17 EC 8E BF 7D
1122 * 22 C8 08 8C 66 6B E5 C1 97
1124 static const uint8_t keys_22
[] = {
1125 0xD7, 0x82, 0x8D, 0x13, 0xB2, 0xB0, 0xBD, 0xC3,
1126 0x25, 0xA7, 0x62, 0x36, 0xDF, 0x93, 0xCC, 0x6B
1128 static const uint8_t nonce_22
[] = {
1129 0x00, 0x5B, 0x8C, 0xCB, 0xCD, 0x9A, 0xF8, 0x3C,
1130 0x96, 0x96, 0x76, 0x6C, 0xFA
1132 static const uint8_t packet_in_22
[] = {
1133 0xEC, 0x46, 0xBB, 0x63, 0xB0, 0x25, 0x20, 0xC3,
1134 0x3C, 0x49, 0xFD, 0x70, 0xB9, 0x6B, 0x49, 0xE2,
1135 0x1D, 0x62, 0x17, 0x41, 0x63, 0x28, 0x75, 0xDB,
1136 0x7F, 0x6C, 0x92, 0x43, 0xD2, 0xD7, 0xC2
1138 static const uint8_t packet_out_22
[] = {
1139 0xEC, 0x46, 0xBB, 0x63, 0xB0, 0x25, 0x20, 0xC3,
1140 0x3C, 0x49, 0xFD, 0x70, 0x31, 0xD7, 0x50, 0xA0,
1141 0x9D, 0xA3, 0xED, 0x7F, 0xDD, 0xD4, 0x9A, 0x20,
1142 0x32, 0xAA, 0xBF, 0x17, 0xEC, 0x8E, 0xBF, 0x7D,
1143 0x22, 0xC8, 0x08, 0x8C, 0x66, 0x6B, 0xE5, 0xC1,
1146 #define clear_len_22 12
1147 #define auth_len_22 10
1151 * =============== Packet Vector #23 ==================
1152 * AES Key = D7 82 8D 13 B2 B0 BD C3 25 A7 62 36 DF 93 CC 6B
1153 * Nonce = 00 3E BE 94 04 4B 9A 3C 96 96 76 6C FA
1154 * Total packet length = 32. [Input with 12 cleartext header octets]
1155 * 47 A6 5A C7 8B 3D 59 42 27 E8 5E 71 E2 FC FB B8
1156 * 80 44 2C 73 1B F9 51 67 C8 FF D7 89 5E 33 70 76
1157 * CBC IV in: 61 00 3E BE 94 04 4B 9A 3C 96 96 76 6C FA 00 14
1158 * CBC IV out:0F 70 3F 5A 54 2C 44 6E 8B 74 A3 73 9B 48 B9 61
1159 * After xor: 0F 7C 78 FC 0E EB CF 53 D2 36 84 9B C5 39 B9 61 [hdr]
1160 * After AES: 40 5B ED 29 D0 98 AE 91 DB 68 78 F3 68 B8 73 85
1161 * After xor: A2 A7 16 91 50 DC 82 E2 C0 91 29 94 A0 47 A4 0C [msg]
1162 * After AES: 3D 03 29 3C FD 81 1B 37 01 51 FB C7 85 6B 7A 74
1163 * After xor: 63 30 59 4A FD 81 1B 37 01 51 FB C7 85 6B 7A 74 [msg]
1164 * After AES: 66 4F 27 16 3E 36 0F 72 62 0D 4E 67 7C E0 61 DE
1165 * CBC-MAC : 66 4F 27 16 3E 36 0F 72 62 0D
1166 * CTR Start: 01 00 3E BE 94 04 4B 9A 3C 96 96 76 6C FA 00 01
1167 * CTR[0001]: 0A 7E 0A 63 53 C8 CF 9E BC 3B 6E 63 15 9A D0 97
1168 * CTR[0002]: EA 20 32 DA 27 82 6E 13 9E 1E 72 5C 5B 0D 3E BF
1169 * CTR[MAC ]: B9 31 27 CA F0 F1 A1 20 FA 70
1170 * Total packet length = 42. [Authenticated and Encrypted Output]
1171 * 47 A6 5A C7 8B 3D 59 42 27 E8 5E 71 E8 82 F1 DB
1172 * D3 8C E3 ED A7 C2 3F 04 DD 65 07 1E B4 13 42 AC
1173 * DF 7E 00 DC CE C7 AE 52 98 7D
1175 static const uint8_t keys_23
[] = {
1176 0xD7, 0x82, 0x8D, 0x13, 0xB2, 0xB0, 0xBD, 0xC3,
1177 0x25, 0xA7, 0x62, 0x36, 0xDF, 0x93, 0xCC, 0x6B
1179 static const uint8_t nonce_23
[] = {
1180 0x00, 0x3E, 0xBE, 0x94, 0x04, 0x4B, 0x9A, 0x3C,
1181 0x96, 0x96, 0x76, 0x6C, 0xFA
1183 static const uint8_t packet_in_23
[] = {
1184 0x47, 0xA6, 0x5A, 0xC7, 0x8B, 0x3D, 0x59, 0x42,
1185 0x27, 0xE8, 0x5E, 0x71, 0xE2, 0xFC, 0xFB, 0xB8,
1186 0x80, 0x44, 0x2C, 0x73, 0x1B, 0xF9, 0x51, 0x67,
1187 0xC8, 0xFF, 0xD7, 0x89, 0x5E, 0x33, 0x70, 0x76
1189 static const uint8_t packet_out_23
[] = {
1190 0x47, 0xA6, 0x5A, 0xC7, 0x8B, 0x3D, 0x59, 0x42,
1191 0x27, 0xE8, 0x5E, 0x71, 0xE8, 0x82, 0xF1, 0xDB,
1192 0xD3, 0x8C, 0xE3, 0xED, 0xA7, 0xC2, 0x3F, 0x04,
1193 0xDD, 0x65, 0x07, 0x1E, 0xB4, 0x13, 0x42, 0xAC,
1194 0xDF, 0x7E, 0x00, 0xDC, 0xCE, 0xC7, 0xAE, 0x52,
1197 #define clear_len_23 12
1198 #define auth_len_23 10
1201 * =============== Packet Vector #24 ==================
1202 * AES Key = D7 82 8D 13 B2 B0 BD C3 25 A7 62 36 DF 93 CC 6B
1203 * Nonce = 00 8D 49 3B 30 AE 8B 3C 96 96 76 6C FA
1204 * Total packet length = 33. [Input with 12 cleartext header octets]
1205 * 6E 37 A6 EF 54 6D 95 5D 34 AB 60 59 AB F2 1C 0B
1206 * 02 FE B8 8F 85 6D F4 A3 73 81 BC E3 CC 12 85 17
1208 * CBC IV in: 61 00 8D 49 3B 30 AE 8B 3C 96 96 76 6C FA 00 15
1209 * CBC IV out:67 AC E4 E8 06 77 7A D3 27 1D 0B 93 4C 67 98 15
1210 * After xor: 67 A0 8A DF A0 98 2E BE B2 40 3F 38 2C 3E 98 15 [hdr]
1211 * After AES: 35 58 F8 7E CA C2 B4 39 B6 7E 75 BB F1 5E 69 08
1212 * After xor: 9E AA E4 75 C8 3C 0C B6 33 13 81 18 82 DF D5 EB [msg]
1213 * After AES: 54 E4 7B 62 22 F0 BB 87 17 D0 71 6A EB AF 19 9E
1214 * After xor: 98 F6 FE 75 F6 F0 BB 87 17 D0 71 6A EB AF 19 9E [msg]
1215 * After AES: 23 E3 30 50 BC 57 DC 2C 3D 3E 7C 94 77 D1 49 71
1216 * CBC-MAC : 23 E3 30 50 BC 57 DC 2C 3D 3E
1217 * CTR Start: 01 00 8D 49 3B 30 AE 8B 3C 96 96 76 6C FA 00 01
1218 * CTR[0001]: 58 DB 19 B3 88 9A A3 8B 3C A4 0B 16 FF 42 2C 73
1219 * CTR[0002]: C3 2F 24 3D 65 DC 7E 9F 4B 02 16 AB 7F B9 6B 4D
1220 * CTR[MAC ]: 4E 2D AE D2 53 F6 B1 8A 1D 67
1221 * Total packet length = 43. [Authenticated and Encrypted Output]
1222 * 6E 37 A6 EF 54 6D 95 5D 34 AB 60 59 F3 29 05 B8
1223 * 8A 64 1B 04 B9 C9 FF B5 8C C3 90 90 0F 3D A1 2A
1224 * B1 6D CE 9E 82 EF A1 6D A6 20 59
1226 static const uint8_t keys_24
[] = {
1227 0xD7, 0x82, 0x8D, 0x13, 0xB2, 0xB0, 0xBD, 0xC3,
1228 0x25, 0xA7, 0x62, 0x36, 0xDF, 0x93, 0xCC, 0x6B
1230 static const uint8_t nonce_24
[] = {
1231 0x00, 0x8D, 0x49, 0x3B, 0x30, 0xAE, 0x8B, 0x3C,
1232 0x96, 0x96, 0x76, 0x6C, 0xFA
1234 static const uint8_t packet_in_24
[] = {
1235 0x6E, 0x37, 0xA6, 0xEF, 0x54, 0x6D, 0x95, 0x5D,
1236 0x34, 0xAB, 0x60, 0x59, 0xAB, 0xF2, 0x1C, 0x0B,
1237 0x02, 0xFE, 0xB8, 0x8F, 0x85, 0x6D, 0xF4, 0xA3,
1238 0x73, 0x81, 0xBC, 0xE3, 0xCC, 0x12, 0x85, 0x17,
1241 static const uint8_t packet_out_24
[] = {
1242 0x6E, 0x37, 0xA6, 0xEF, 0x54, 0x6D, 0x95, 0x5D,
1243 0x34, 0xAB, 0x60, 0x59, 0xF3, 0x29, 0x05, 0xB8,
1244 0x8A, 0x64, 0x1B, 0x04, 0xB9, 0xC9, 0xFF, 0xB5,
1245 0x8C, 0xC3, 0x90, 0x90, 0x0F, 0x3D, 0xA1, 0x2A,
1246 0xB1, 0x6D, 0xCE, 0x9E, 0x82, 0xEF, 0xA1, 0x6D,
1249 #define clear_len_24 12
1250 #define auth_len_24 10
1252 /** Additional AES-CCM-128 test vectors */
1253 static const uint8_t keys_90
[] = {
1254 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
1255 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F
1257 static const uint8_t nonce_90
[] = {
1258 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16
1260 static const uint8_t packet_in_90
[] = {
1261 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1262 0x20, 0x21, 0x22, 0x23
1264 static const uint8_t packet_out_90
[] = {
1265 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1266 0x71, 0x62, 0x01, 0x5B,
1267 0x4D, 0xAC, 0x25, 0x5D
1269 #define clear_len_90 8
1270 #define auth_len_90 4
1272 static const uint8_t keys_91
[] = {
1273 0xC9, 0x7C, 0x1F, 0x67, 0xCE, 0x37, 0x11, 0x85,
1274 0x51, 0x4A, 0x8A, 0x19, 0xF2, 0xBD, 0xD5, 0x2F
1276 static const uint8_t nonce_91
[] = {
1277 0x00, 0x50, 0x30, 0xF1, 0x84, 0x44, 0x08, 0xB5,
1278 0x03, 0x97, 0x76, 0xE7, 0x0C
1280 static const uint8_t packet_in_91
[] = {
1281 0x08, 0x40, 0x0F, 0xD2, 0xE1, 0x28, 0xA5, 0x7C,
1282 0x50, 0x30, 0xF1, 0x84, 0x44, 0x08, 0xAB, 0xAE,
1283 0xA5, 0xB8, 0xFC, 0xBA, 0x00, 0x00,
1284 0xF8, 0xBA, 0x1A, 0x55, 0xD0, 0x2F, 0x85, 0xAE,
1285 0x96, 0x7B, 0xB6, 0x2F, 0xB6, 0xCD, 0xA8, 0xEB,
1286 0x7E, 0x78, 0xA0, 0x50
1288 static const uint8_t packet_out_91
[] = {
1289 0x08, 0x40, 0x0F, 0xD2, 0xE1, 0x28, 0xA5, 0x7C,
1290 0x50, 0x30, 0xF1, 0x84, 0x44, 0x08, 0xAB, 0xAE,
1291 0xA5, 0xB8, 0xFC, 0xBA, 0x00, 0x00,
1292 0xF3, 0xD0, 0xA2, 0xFE, 0x9A, 0x3D, 0xBF, 0x23,
1293 0x42, 0xA6, 0x43, 0xE4, 0x32, 0x46, 0xE8, 0x0C,
1294 0x3C, 0x04, 0xD0, 0x19,
1295 0x78, 0x45, 0xCE, 0x0B, 0x16, 0xF9, 0x76, 0x23
1297 #define clear_len_91 22
1298 #define auth_len_91 8
1301 static const uint8_t keys_92
[] = {
1302 0xC9, 0x7C, 0x1F, 0x67, 0xCE, 0x37, 0x11, 0x85,
1303 0x51, 0x4A, 0x8A, 0x19, 0xF2, 0xBD, 0xD5, 0x2F
1305 static const uint8_t nonce_92
[] = {
1306 0x00, 0x50, 0x30, 0xF1, 0x84, 0x44, 0x08, 0xB5,
1307 0x03, 0x97, 0x76, 0xE7, 0x0C
1309 static const uint8_t packet_in_92
[] = {
1310 0xF8, 0xBA, 0x1A, 0x55, 0xD0, 0x2F, 0x85, 0xAE,
1311 0x96, 0x7B, 0xB6, 0x2F, 0xB6, 0xCD, 0xA8, 0xEB,
1312 0x7E, 0x78, 0xA0, 0x50
1314 static const uint8_t packet_out_92
[] = {
1315 0xF3, 0xD0, 0xA2, 0xFE, 0x9A, 0x3D, 0xBF, 0x23,
1316 0x42, 0xA6, 0x43, 0xE4, 0x32, 0x46, 0xE8, 0x0C,
1317 0x3C, 0x04, 0xD0, 0x19,
1318 0x41, 0x83, 0x21, 0x89, 0xA3, 0xD3, 0x1B, 0x43
1320 #define clear_len_92 0
1321 #define auth_len_92 8
1323 static const uint8_t keys_100
[] = {
1324 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
1325 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F
1327 static const uint8_t nonce_100
[] = {
1328 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16
1330 static const uint8_t packet_in_100
[] = {
1331 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1332 0x20, 0x21, 0x22, 0x23,
1334 static const uint8_t packet_out_100
[] = {
1335 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1336 0x71, 0x62, 0x01, 0x5B,
1337 0xB0, 0xC9, 0x5E, 0x58, 0x03, 0x6E
1339 #define clear_len_100 8
1340 #define auth_len_100 6
1342 static const uint8_t keys_101
[] = {
1343 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
1344 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F
1346 static const uint8_t nonce_101
[] = {
1347 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16
1349 static const uint8_t packet_in_101
[] = {
1350 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1351 0x20, 0x21, 0x22, 0x23,
1353 static const uint8_t packet_out_101
[] = {
1354 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1355 0x71, 0x62, 0x01, 0x5B,
1356 0xD0, 0xAD, 0x86, 0xFD, 0x33, 0xC2, 0x69, 0x86
1358 #define clear_len_101 8
1359 #define auth_len_101 8
1361 static const uint8_t keys_102
[] = {
1362 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
1363 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F
1365 static const uint8_t nonce_102
[] = {
1366 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16
1368 static const uint8_t packet_in_102
[] = {
1369 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1370 0x20, 0x21, 0x22, 0x23,
1372 static const uint8_t packet_out_102
[] = {
1373 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1374 0x71, 0x62, 0x01, 0x5B,
1375 0x05, 0x12, 0xDA, 0xBF, 0xD9, 0x72, 0xA6, 0x68,
1378 #define clear_len_102 8
1379 #define auth_len_102 10
1381 static const uint8_t keys_103
[] = {
1382 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
1383 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F
1385 static const uint8_t nonce_103
[] = {
1386 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16
1388 static const uint8_t packet_in_103
[] = {
1389 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1390 0x20, 0x21, 0x22, 0x23,
1392 static const uint8_t packet_out_103
[] = {
1393 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1394 0x71, 0x62, 0x01, 0x5B,
1395 0xBA, 0x03, 0xBF, 0x8C, 0xE0, 0xD6, 0x00, 0xA4,
1396 0x48, 0x6F, 0xCC, 0xB3
1398 #define clear_len_103 8
1399 #define auth_len_103 12
1401 static const uint8_t keys_104
[] = {
1402 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
1403 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F
1405 static const uint8_t nonce_104
[] = {
1406 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16
1408 static const uint8_t packet_in_104
[] = {
1409 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1410 0x20, 0x21, 0x22, 0x23,
1412 static const uint8_t packet_out_104
[] = {
1413 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1414 0x71, 0x62, 0x01, 0x5B,
1415 0x6B, 0x9B, 0xFB, 0xFE, 0xA8, 0x2C, 0x04, 0x77,
1416 0x8E, 0x67, 0xF5, 0x18, 0x46, 0xC6
1418 #define clear_len_104 8
1419 #define auth_len_104 14
1421 static const uint8_t keys_105
[] = {
1422 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
1423 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F
1425 static const uint8_t nonce_105
[] = {
1426 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16
1428 static const uint8_t packet_in_105
[] = {
1429 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1430 0x20, 0x21, 0x22, 0x23,
1432 static const uint8_t packet_out_105
[] = {
1433 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1434 0x71, 0x62, 0x01, 0x5B,
1435 0x2B, 0xB5, 0x7C, 0x0A, 0xF4, 0x5E, 0x4D, 0x83,
1436 0x04, 0xF0, 0x5F, 0x45, 0x99, 0x3F, 0x15, 0x17
1438 #define clear_len_105 8
1439 #define auth_len_105 16
1441 static const uint8_t keys_106
[] = {
1442 0x4a, 0xe7, 0x01, 0x10, 0x3c, 0x63, 0xde, 0xca,
1443 0x5b, 0x5a, 0x39, 0x39, 0xd7, 0xd0, 0x59, 0x92
1445 static const uint8_t nonce_106
[] = {
1446 0x5a, 0x8a, 0xa4, 0x85, 0xc3, 0x16, 0xe9
1448 static const uint8_t packet_out_106
[] = {
1449 0x02, 0x20, 0x9f, 0x55
1451 #define clear_len_106 0
1452 #define auth_len_106 4
1454 #define CCM_TEST_VEC(num) \
1455 { keys_##num, nonce_##num, sizeof(nonce_##num), \
1456 packet_in_##num, sizeof(packet_in_##num), \
1457 clear_len_##num, packet_out_##num, \
1459 #define CCM_TEST_VEC_2(num) \
1460 { keys_##num, nonce_##num, sizeof(nonce_##num), \
1462 clear_len_##num, packet_out_##num, \
1465 static const struct ccm_rfc3610_vector
{
1466 const uint8_t *keys
;
1467 const uint8_t *nonce
;
1468 const size_t nonce_len
;
1469 /* packet in = [ AAD | plain text ] */
1470 const uint8_t *packet_in
;
1471 const size_t packet_len
;
1472 const size_t clear_len
;
1473 /* packet out = [ AAD | cipher text | authentication tag ] */
1474 const uint8_t *packet_out
;
1475 const size_t auth_len
;
1510 CCM_TEST_VEC_2(106),
1514 ccm_job_ok(const struct ccm_rfc3610_vector
*vec
,
1515 const struct JOB_AES_HMAC
*job
,
1516 const uint8_t *target
,
1517 const uint8_t *padding
,
1518 const uint8_t *auth
,
1519 const size_t sizeof_padding
,
1523 if (job
->status
!= STS_COMPLETED
) {
1524 printf("%d Error status:%d", __LINE__
, job
->status
);
1530 if (dir
== ENCRYPT
) {
1531 if (memcmp(vec
->packet_out
, target
+ sizeof_padding
,
1533 printf("cipher mismatched\n");
1534 hexdump(stderr
, "Received",
1535 target
+ sizeof_padding
,
1537 hexdump(stderr
, "Expected",
1538 vec
->packet_out
, vec
->packet_len
);
1542 if (memcmp(vec
->packet_in
, target
+ sizeof_padding
,
1544 printf("cipher mismatched\n");
1545 hexdump(stderr
, "Received",
1546 target
+ sizeof_padding
,
1548 hexdump(stderr
, "Expected", vec
->packet_in
,
1553 } else { /* out-of-place */
1554 if (dir
== ENCRYPT
) {
1555 if (memcmp(vec
->packet_out
+ vec
->clear_len
,
1556 target
+ sizeof_padding
,
1557 vec
->packet_len
- vec
->clear_len
)) {
1558 printf("cipher mismatched\n");
1559 hexdump(stderr
, "Received",
1560 target
+ sizeof_padding
,
1561 vec
->packet_len
- vec
->clear_len
);
1562 hexdump(stderr
, "Expected",
1563 vec
->packet_out
+ vec
->clear_len
,
1564 vec
->packet_len
- vec
->clear_len
);
1568 if (memcmp(vec
->packet_in
+ vec
->clear_len
,
1569 target
+ sizeof_padding
,
1570 vec
->packet_len
- vec
->clear_len
)) {
1571 printf("cipher mismatched\n");
1572 hexdump(stderr
, "Received",
1573 target
+ sizeof_padding
,
1574 vec
->packet_len
- vec
->clear_len
);
1575 hexdump(stderr
, "Expected",
1576 vec
->packet_in
+ vec
->clear_len
,
1577 vec
->packet_len
- vec
->clear_len
);
1583 if (memcmp(padding
, target
, sizeof_padding
)) {
1584 printf("cipher overwrite head\n");
1585 hexdump(stderr
, "Target", target
, sizeof(padding
));
1590 if (memcmp(padding
, target
+ sizeof_padding
+ vec
->packet_len
,
1592 printf("cipher overwrite tail\n");
1593 hexdump(stderr
, "Target",
1594 target
+ sizeof_padding
+ vec
->packet_len
,
1599 if (memcmp(padding
, target
+ sizeof_padding
+ vec
->packet_len
-
1600 vec
->clear_len
, sizeof_padding
)) {
1601 printf("cipher overwrite tail\n");
1602 hexdump(stderr
, "Target", target
+ sizeof_padding
+
1603 vec
->packet_len
- vec
->clear_len
,
1610 if (memcmp(padding
, &auth
[sizeof_padding
+ vec
->auth_len
],
1612 printf("hash overwrite tail\n");
1613 hexdump(stderr
, "Target",
1614 &auth
[sizeof_padding
+ vec
->auth_len
], sizeof_padding
);
1618 if (memcmp(padding
, &auth
[0], sizeof_padding
)) {
1619 printf("hash overwrite head\n");
1620 hexdump(stderr
, "Target", &auth
[0], sizeof_padding
);
1624 if (memcmp(vec
->packet_out
+ vec
->packet_len
, &auth
[sizeof_padding
],
1626 printf("hash mismatched\n");
1627 hexdump(stderr
, "Received", &auth
[sizeof_padding
],
1629 hexdump(stderr
, "Expected", vec
->packet_out
+ vec
->packet_len
,
1637 test_ccm(struct MB_MGR
*mb_mgr
,
1638 const struct ccm_rfc3610_vector
*vec
,
1639 const int dir
, const int in_place
, const int num_jobs
)
1641 DECLARE_ALIGNED(uint32_t expkey
[4*15], 16);
1642 DECLARE_ALIGNED(uint32_t dust
[4*15], 16);
1643 struct JOB_AES_HMAC
*job
;
1644 uint8_t padding
[16];
1645 uint8_t **targets
= malloc(num_jobs
* sizeof(void *));
1646 uint8_t **auths
= malloc(num_jobs
* sizeof(void *));
1647 int i
= 0, jobs_rx
= 0, ret
= -1;
1648 const int order
= (dir
== ENCRYPT
) ? CIPHER_HASH
: HASH_CIPHER
;
1650 if (targets
== NULL
|| auths
== NULL
) {
1651 fprintf(stderr
, "Can't allocate buffer memory\n");
1655 memset(padding
, -1, sizeof(padding
));
1656 memset(targets
, 0, num_jobs
* sizeof(void *));
1657 memset(auths
, 0, num_jobs
* sizeof(void *));
1659 for (i
= 0; i
< num_jobs
; i
++) {
1660 targets
[i
] = malloc(vec
->packet_len
+ (sizeof(padding
) * 2));
1661 auths
[i
] = malloc(16 + (sizeof(padding
) * 2));
1662 if (targets
[i
] == NULL
|| auths
[i
] == NULL
) {
1663 fprintf(stderr
, "Can't allocate buffer memory\n");
1667 memset(targets
[i
], -1, vec
->packet_len
+ (sizeof(padding
) * 2));
1668 memset(auths
[i
], -1, 16 + (sizeof(padding
) * 2));
1672 memcpy(targets
[i
] + sizeof(padding
),
1673 vec
->packet_in
, vec
->packet_len
);
1675 memcpy(targets
[i
] + sizeof(padding
),
1676 vec
->packet_out
, vec
->packet_len
);
1680 IMB_AES_KEYEXP_128(mb_mgr
, vec
->keys
, expkey
, dust
);
1682 while ((job
= IMB_FLUSH_JOB(mb_mgr
)) != NULL
)
1685 for (i
= 0; i
< num_jobs
; i
++) {
1686 job
= IMB_GET_NEXT_JOB(mb_mgr
);
1687 job
->cipher_direction
= dir
;
1688 job
->chain_order
= order
;
1691 targets
[i
] + sizeof(padding
) + vec
->clear_len
;
1692 job
->src
= targets
[i
] + sizeof(padding
);
1694 if (dir
== ENCRYPT
) {
1695 job
->dst
= targets
[i
] + sizeof(padding
);
1696 job
->src
= vec
->packet_in
;
1698 job
->dst
= targets
[i
] + sizeof(padding
);
1699 job
->src
= vec
->packet_out
;
1702 job
->cipher_mode
= CCM
;
1703 job
->aes_enc_key_expanded
= expkey
;
1704 job
->aes_dec_key_expanded
= expkey
;
1705 job
->aes_key_len_in_bytes
= 16; /* AES-CCM-128 for now */
1706 job
->iv
= vec
->nonce
;
1707 job
->iv_len_in_bytes
= vec
->nonce_len
;
1708 job
->cipher_start_src_offset_in_bytes
= vec
->clear_len
;
1709 job
->msg_len_to_cipher_in_bytes
=
1710 vec
->packet_len
- vec
->clear_len
;
1712 job
->hash_alg
= AES_CCM
;
1713 job
->hash_start_src_offset_in_bytes
= vec
->clear_len
;
1714 job
->msg_len_to_hash_in_bytes
=
1715 vec
->packet_len
- vec
->clear_len
;
1716 job
->auth_tag_output
= auths
[i
] + sizeof(padding
);
1717 job
->auth_tag_output_len_in_bytes
= vec
->auth_len
;
1719 job
->u
.CCM
.aad_len_in_bytes
= vec
->clear_len
;
1720 job
->u
.CCM
.aad
= job
->src
;
1722 job
->user_data
= targets
[i
];
1723 job
->user_data2
= auths
[i
];
1725 job
= IMB_SUBMIT_JOB(mb_mgr
);
1729 printf("%d Unexpected return from submit_job\n",
1733 if (!ccm_job_ok(vec
, job
, job
->user_data
, padding
,
1734 job
->user_data2
, sizeof(padding
),
1740 while ((job
= IMB_FLUSH_JOB(mb_mgr
)) != NULL
) {
1743 if (!ccm_job_ok(vec
, job
, job
->user_data
, padding
,
1744 job
->user_data2
, sizeof(padding
), dir
,
1749 if (jobs_rx
!= num_jobs
) {
1750 printf("Expected %d jobs, received %d\n", num_jobs
, jobs_rx
);
1756 while ((job
= IMB_FLUSH_JOB(mb_mgr
)) != NULL
)
1759 for (i
= 0; i
< num_jobs
; i
++) {
1760 if (targets
[i
] != NULL
)
1762 if (auths
[i
] != NULL
)
1767 if (targets
!= NULL
)
1777 test_ccm_std_vectors(struct MB_MGR
*mb_mgr
, const int num_jobs
)
1779 const int vectors_cnt
= sizeof(ccm_vectors
) / sizeof(ccm_vectors
[0]);
1783 printf("AES-CCM standard test vectors (N jobs = %d):\n", num_jobs
);
1784 for (vect
= 1; vect
<= vectors_cnt
; vect
++) {
1785 const int idx
= vect
- 1;
1787 printf("Standard vector [%d/%d] NONCELen:%d PktLen:%d "
1788 "AADLen:%d AUTHlen:%d\n",
1790 (int) ccm_vectors
[idx
].nonce_len
,
1791 (int) ccm_vectors
[idx
].packet_len
,
1792 (int) ccm_vectors
[idx
].clear_len
,
1793 (int) ccm_vectors
[idx
].auth_len
);
1798 if (test_ccm(mb_mgr
, &ccm_vectors
[idx
], ENCRYPT
, 1, num_jobs
)) {
1799 printf("error #%d encrypt in-place\n", vect
);
1803 if (test_ccm(mb_mgr
, &ccm_vectors
[idx
], DECRYPT
, 1, num_jobs
)) {
1804 printf("error #%d decrypt in-place\n", vect
);
1808 if (test_ccm(mb_mgr
, &ccm_vectors
[idx
], ENCRYPT
, 0, num_jobs
)) {
1809 printf("error #%d encrypt out-of-place\n", vect
);
1813 if (test_ccm(mb_mgr
, &ccm_vectors
[idx
], DECRYPT
, 0, num_jobs
)) {
1814 printf("error #%d decrypt out-of-place\n", vect
);
1823 ccm_test(const enum arch_type arch
,
1824 struct MB_MGR
*mb_mgr
)
1828 (void) arch
; /* unused */
1830 errors
+= test_ccm_std_vectors(mb_mgr
, 1);
1831 errors
+= test_ccm_std_vectors(mb_mgr
, 3);
1832 errors
+= test_ccm_std_vectors(mb_mgr
, 4);
1833 errors
+= test_ccm_std_vectors(mb_mgr
, 5);
1834 errors
+= test_ccm_std_vectors(mb_mgr
, 7);
1835 errors
+= test_ccm_std_vectors(mb_mgr
, 8);
1836 errors
+= test_ccm_std_vectors(mb_mgr
, 9);
1839 printf("...Pass\n");
1841 printf("...Fail\n");