]> git.proxmox.com Git - ceph.git/blob - ceph/src/spdk/intel-ipsec-mb/LibTestApp/ccm_test.c
projects / ceph.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
update sources to ceph Nautilus 14.2.1
[ceph.git] / ceph / src / spdk / intel-ipsec-mb / LibTestApp / ccm_test.c
1 /*****************************************************************************
2 Copyright (c) 2017-2018, Intel Corporation
3
4 Redistribution and use in source and binary forms, with or without
5 modification, are permitted provided that the following conditions are met:
6
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.
15
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 *****************************************************************************/
27
28 #include <stdint.h>
29 #include <stdlib.h>
30 #include <stdio.h>
31 #include <string.h>
32
33 #include <intel-ipsec-mb.h>
34 #include "gcm_ctr_vectors_test.h"
35
36 int ccm_test(const enum arch_type arch, struct MB_MGR *mb_mgr);
37
38 /*
39 * Test vectors from https://tools.ietf.org/html/rfc3610
40 */
41
42 /*
43 * =============== Packet Vector #1 ==================
44 * AES Key = C0 C1 C2 C3 C4 C5 C6 C7 C8 C9 CA CB CC CD CE CF
45 * Nonce = 00 00 00 03 02 01 00 A0 A1 A2 A3 A4 A5
46 * Total packet length = 31. [Input with 8 cleartext header octets]
47 * 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
48 * 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E
49 * CBC IV in: 59 00 00 00 03 02 01 00 A0 A1 A2 A3 A4 A5 00 17
50 * CBC IV out:EB 9D 55 47 73 09 55 AB 23 1E 0A 2D FE 4B 90 D6
51 * After xor: EB 95 55 46 71 0A 51 AE 25 19 0A 2D FE 4B 90 D6 [hdr]
52 * After AES: CD B6 41 1E 3C DC 9B 4F 5D 92 58 B6 9E E7 F0 91
53 * After xor: C5 BF 4B 15 30 D1 95 40 4D 83 4A A5 8A F2 E6 86 [msg]
54 * After AES: 9C 38 40 5E A0 3C 1B C9 04 B5 8B 40 C7 6C A2 EB
55 * After xor: 84 21 5A 45 BC 21 05 C9 04 B5 8B 40 C7 6C A2 EB [msg]
56 * After AES: 2D C6 97 E4 11 CA 83 A8 60 C2 C4 06 CC AA 54 2F
57 * CBC-MAC : 2D C6 97 E4 11 CA 83 A8
58 * CTR Start: 01 00 00 00 03 02 01 00 A0 A1 A2 A3 A4 A5 00 01
59 * CTR[0001]: 50 85 9D 91 6D CB 6D DD E0 77 C2 D1 D4 EC 9F 97
60 * CTR[0002]: 75 46 71 7A C6 DE 9A FF 64 0C 9C 06 DE 6D 0D 8F
61 * CTR[MAC ]: 3A 2E 46 C8 EC 33 A5 48
62 * Total packet length = 39. [Authenticated and Encrypted Output]
63 * 00 01 02 03 04 05 06 07 58 8C 97 9A 61 C6 63 D2
64 * F0 66 D0 C2 C0 F9 89 80 6D 5F 6B 61 DA C3 84 17
65 * E8 D1 2C FD F9 26 E0
66 */
67 static const uint8_t keys_01[] = {
68 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
69 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF
70 };
71 static const uint8_t nonce_01[] = {
72 0x00, 0x00, 0x00, 0x03, 0x02, 0x01, 0x00, 0xA0,
73 0xA1, 0xA2, 0xA3, 0xA4, 0xA5
74 };
75 static const uint8_t packet_in_01[] = {
76 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
77 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
78 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
79 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E
80 };
81 static const uint8_t packet_out_01[] = {
82 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
83 0x58, 0x8C, 0x97, 0x9A, 0x61, 0xC6, 0x63, 0xD2,
84 0xF0, 0x66, 0xD0, 0xC2, 0xC0, 0xF9, 0x89, 0x80,
85 0x6D, 0x5F, 0x6B, 0x61, 0xDA, 0xC3, 0x84, 0x17,
86 0xE8, 0xD1, 0x2C, 0xFD, 0xF9, 0x26, 0xE0
87 };
88 #define clear_len_01 8
89 #define auth_len_01 8
90
91 /*
92 * =============== Packet Vector #2 ==================
93 * AES Key = C0 C1 C2 C3 C4 C5 C6 C7 C8 C9 CA CB CC CD CE CF
94 * Nonce = 00 00 00 04 03 02 01 A0 A1 A2 A3 A4 A5
95 * Total packet length = 32. [Input with 8 cleartext header octets]
96 * 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
97 * 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F
98 * CBC IV in: 59 00 00 00 04 03 02 01 A0 A1 A2 A3 A4 A5 00 18
99 * CBC IV out:F0 C2 54 D3 CA 03 E2 39 70 BD 24 A8 4C 39 9E 77
100 * After xor: F0 CA 54 D2 C8 00 E6 3C 76 BA 24 A8 4C 39 9E 77 [hdr]
101 * After AES: 48 DE 8B 86 28 EA 4A 40 00 AA 42 C2 95 BF 4A 8C
102 * After xor: 40 D7 81 8D 24 E7 44 4F 10 BB 50 D1 81 AA 5C 9B [msg]
103 * After AES: 0F 89 FF BC A6 2B C2 4F 13 21 5F 16 87 96 AA 33
104 * After xor: 17 90 E5 A7 BA 36 DC 50 13 21 5F 16 87 96 AA 33 [msg]
105 * After AES: F7 B9 05 6A 86 92 6C F3 FB 16 3D C4 99 EF AA 11
106 * CBC-MAC : F7 B9 05 6A 86 92 6C F3
107 * CTR Start: 01 00 00 00 04 03 02 01 A0 A1 A2 A3 A4 A5 00 01
108 * CTR[0001]: 7A C0 10 3D ED 38 F6 C0 39 0D BA 87 1C 49 91 F4
109 * CTR[0002]: D4 0C DE 22 D5 F9 24 24 F7 BE 9A 56 9D A7 9F 51
110 * CTR[MAC ]: 57 28 D0 04 96 D2 65 E5
111 * Total packet length = 40. [Authenticated and Encrypted Output]
112 * 00 01 02 03 04 05 06 07 72 C9 1A 36 E1 35 F8 CF
113 * 29 1C A8 94 08 5C 87 E3 CC 15 C4 39 C9 E4 3A 3B
114 * A0 91 D5 6E 10 40 09 16
115 */
116 static const uint8_t keys_02[] = {
117 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
118 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF
119 };
120 static const uint8_t nonce_02[] = {
121 0x00, 0x00, 0x00, 0x04, 0x03, 0x02, 0x01, 0xA0,
122 0xA1, 0xA2, 0xA3, 0xA4, 0xA5
123 };
124 static const uint8_t packet_in_02[] = {
125 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
126 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
127 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
128 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F
129 };
130 static const uint8_t packet_out_02[] = {
131 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
132 0x72, 0xC9, 0x1A, 0x36, 0xE1, 0x35, 0xF8, 0xCF,
133 0x29, 0x1C, 0xA8, 0x94, 0x08, 0x5C, 0x87, 0xE3,
134 0xCC, 0x15, 0xC4, 0x39, 0xC9, 0xE4, 0x3A, 0x3B,
135 0xA0, 0x91, 0xD5, 0x6E, 0x10, 0x40, 0x09, 0x16
136 };
137 #define clear_len_02 8
138 #define auth_len_02 8
139
140 /*
141 * =============== Packet Vector #3 ==================
142 * AES Key = C0 C1 C2 C3 C4 C5 C6 C7 C8 C9 CA CB CC CD CE CF
143 * Nonce = 00 00 00 05 04 03 02 A0 A1 A2 A3 A4 A5
144 * Total packet length = 33. [Input with 8 cleartext header octets]
145 * 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
146 * 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F
147 * 20
148 * CBC IV in: 59 00 00 00 05 04 03 02 A0 A1 A2 A3 A4 A5 00 19
149 * CBC IV out:6F 8A 12 F7 BF 8D 4D C5 A1 19 6E 95 DF F0 B4 27
150 * After xor: 6F 82 12 F6 BD 8E 49 C0 A7 1E 6E 95 DF F0 B4 27 [hdr]
151 * After AES: 37 E9 B7 8C C2 20 17 E7 33 80 43 0C BE F4 28 24
152 * After xor: 3F E0 BD 87 CE 2D 19 E8 23 91 51 1F AA E1 3E 33 [msg]
153 * After AES: 90 CA 05 13 9F 4D 4E CF 22 6F E9 81 C5 9E 2D 40
154 * After xor: 88 D3 1F 08 83 50 50 D0 02 6F E9 81 C5 9E 2D 40 [msg]
155 * After AES: 73 B4 67 75 C0 26 DE AA 41 03 97 D6 70 FE 5F B0
156 * CBC-MAC : 73 B4 67 75 C0 26 DE AA
157 * CTR Start: 01 00 00 00 05 04 03 02 A0 A1 A2 A3 A4 A5 00 01
158 * CTR[0001]: 59 B8 EF FF 46 14 73 12 B4 7A 1D 9D 39 3D 3C FF
159 * CTR[0002]: 69 F1 22 A0 78 C7 9B 89 77 89 4C 99 97 5C 23 78
160 * CTR[MAC ]: 39 6E C0 1A 7D B9 6E 6F
161 * Total packet length = 41. [Authenticated and Encrypted Output]
162 * 00 01 02 03 04 05 06 07 51 B1 E5 F4 4A 19 7D 1D
163 * A4 6B 0F 8E 2D 28 2A E8 71 E8 38 BB 64 DA 85 96
164 * 57 4A DA A7 6F BD 9F B0 C5
165 */
166 static const uint8_t keys_03[] = {
167 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
168 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF
169 };
170 static const uint8_t nonce_03[] = {
171 0x00, 0x00, 0x00, 0x05, 0x04, 0x03, 0x02, 0xA0,
172 0xA1, 0xA2, 0xA3, 0xA4, 0xA5
173 };
174 static const uint8_t packet_in_03[] = {
175 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
176 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
177 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
178 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
179 0x20
180 };
181 static const uint8_t packet_out_03[] = {
182 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
183 0x51, 0xB1, 0xE5, 0xF4, 0x4A, 0x19, 0x7D, 0x1D,
184 0xA4, 0x6B, 0x0F, 0x8E, 0x2D, 0x28, 0x2A, 0xE8,
185 0x71, 0xE8, 0x38, 0xBB, 0x64, 0xDA, 0x85, 0x96,
186 0x57, 0x4A, 0xDA, 0xA7, 0x6F, 0xBD, 0x9F, 0xB0,
187 0xC5
188 };
189 #define clear_len_03 8
190 #define auth_len_03 8
191
192 /*
193 * =============== Packet Vector #4 ==================
194 * AES Key = C0 C1 C2 C3 C4 C5 C6 C7 C8 C9 CA CB CC CD CE CF
195 * Nonce = 00 00 00 06 05 04 03 A0 A1 A2 A3 A4 A5
196 * Total packet length = 31. [Input with 12 cleartext header octets]
197 * 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
198 * 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E
199 * CBC IV in: 59 00 00 00 06 05 04 03 A0 A1 A2 A3 A4 A5 00 13
200 * CBC IV out:06 65 2C 60 0E F5 89 63 CA C3 25 A9 CD 3E 2B E1
201 * After xor: 06 69 2C 61 0C F6 8D 66 CC C4 2D A0 C7 35 2B E1 [hdr]
202 * After AES: A0 75 09 AC 15 C2 58 86 04 2F 80 60 54 FE A6 86
203 * After xor: AC 78 07 A3 05 D3 4A 95 10 3A 96 77 4C E7 BC 9D [msg]
204 * After AES: 64 4C 09 90 D9 1B 83 E9 AB 4B 8E ED 06 6F F5 BF
205 * After xor: 78 51 17 90 D9 1B 83 E9 AB 4B 8E ED 06 6F F5 BF [msg]
206 * After AES: 4B 4F 4B 39 B5 93 E6 BF B0 B2 C2 B7 0F 29 CD 7A
207 * CBC-MAC : 4B 4F 4B 39 B5 93 E6 BF
208 * CTR Start: 01 00 00 00 06 05 04 03 A0 A1 A2 A3 A4 A5 00 01
209 * CTR[0001]: AE 81 66 6A 83 8B 88 6A EE BF 4A 5B 32 84 50 8A
210 * CTR[0002]: D1 B1 92 06 AC 93 9E 2F B6 DD CE 10 A7 74 FD 8D
211 * CTR[MAC ]: DD 87 2A 80 7C 75 F8 4E
212 * Total packet length = 39. [Authenticated and Encrypted Output]
213 * 00 01 02 03 04 05 06 07 08 09 0A 0B A2 8C 68 65
214 * 93 9A 9A 79 FA AA 5C 4C 2A 9D 4A 91 CD AC 8C 96
215 * C8 61 B9 C9 E6 1E F1
216 */
217 static const uint8_t keys_04[] = {
218 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
219 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF
220 };
221 static const uint8_t nonce_04[] = {
222 0x00, 0x00, 0x00, 0x06, 0x05, 0x04, 0x03, 0xA0,
223 0xA1, 0xA2, 0xA3, 0xA4, 0xA5
224 };
225 static const uint8_t packet_in_04[] = {
226 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
227 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
228 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
229 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E
230 };
231 static const uint8_t packet_out_04[] = {
232 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
233 0x08, 0x09, 0x0A, 0x0B, 0xA2, 0x8C, 0x68, 0x65,
234 0x93, 0x9A, 0x9A, 0x79, 0xFA, 0xAA, 0x5C, 0x4C,
235 0x2A, 0x9D, 0x4A, 0x91, 0xCD, 0xAC, 0x8C, 0x96,
236 0xC8, 0x61, 0xB9, 0xC9, 0xE6, 0x1E, 0xF1
237 };
238 #define clear_len_04 12
239 #define auth_len_04 8
240
241 /*
242 * =============== Packet Vector #5 ==================
243 * AES Key = C0 C1 C2 C3 C4 C5 C6 C7 C8 C9 CA CB CC CD CE CF
244 * Nonce = 00 00 00 07 06 05 04 A0 A1 A2 A3 A4 A5
245 * Total packet length = 32. [Input with 12 cleartext header octets]
246 * 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
247 * 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F
248 * CBC IV in: 59 00 00 00 07 06 05 04 A0 A1 A2 A3 A4 A5 00 14
249 * CBC IV out:00 4C 50 95 45 80 3C 48 51 CD E1 3B 56 C8 9A 85
250 * After xor: 00 40 50 94 47 83 38 4D 57 CA E9 32 5C C3 9A 85 [hdr]
251 * After AES: E2 B8 F7 CE 49 B2 21 72 84 A8 EA 84 FA AD 67 5C
252 * After xor: EE B5 F9 C1 59 A3 33 61 90 BD FC 93 E2 B4 7D 47 [msg]
253 * After AES: 3E FB 36 72 25 DB 11 01 D3 C2 2F 0E CA FF 44 F3
254 * After xor: 22 E6 28 6D 25 DB 11 01 D3 C2 2F 0E CA FF 44 F3 [msg]
255 * After AES: 48 B9 E8 82 55 05 4A B5 49 0A 95 F9 34 9B 4B 5E
256 * CBC-MAC : 48 B9 E8 82 55 05 4A B5
257 * CTR Start: 01 00 00 00 07 06 05 04 A0 A1 A2 A3 A4 A5 00 01
258 * CTR[0001]: D0 FC F5 74 4D 8F 31 E8 89 5B 05 05 4B 7C 90 C3
259 * CTR[0002]: 72 A0 D4 21 9F 0D E1 D4 04 83 BC 2D 3D 0C FC 2A
260 * CTR[MAC ]: 19 51 D7 85 28 99 67 26
261 * Total packet length = 40. [Authenticated and Encrypted Output]
262 * 00 01 02 03 04 05 06 07 08 09 0A 0B DC F1 FB 7B
263 * 5D 9E 23 FB 9D 4E 13 12 53 65 8A D8 6E BD CA 3E
264 * 51 E8 3F 07 7D 9C 2D 93
265 */
266 static const uint8_t keys_05[] = {
267 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
268 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF
269 };
270 static const uint8_t nonce_05[] = {
271 0x00, 0x00, 0x00, 0x07, 0x06, 0x05, 0x04, 0xA0,
272 0xA1, 0xA2, 0xA3, 0xA4, 0xA5
273 };
274 static const uint8_t packet_in_05[] = {
275 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
276 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
277 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
278 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F
279 };
280 static const uint8_t packet_out_05[] = {
281 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
282 0x08, 0x09, 0x0A, 0x0B, 0xDC, 0xF1, 0xFB, 0x7B,
283 0x5D, 0x9E, 0x23, 0xFB, 0x9D, 0x4E, 0x13, 0x12,
284 0x53, 0x65, 0x8A, 0xD8, 0x6E, 0xBD, 0xCA, 0x3E,
285 0x51, 0xE8, 0x3F, 0x07, 0x7D, 0x9C, 0x2D, 0x93
286 };
287 #define clear_len_05 12
288 #define auth_len_05 8
289
290 /*
291 * =============== Packet Vector #6 ==================
292 * AES Key = C0 C1 C2 C3 C4 C5 C6 C7 C8 C9 CA CB CC CD CE CF
293 * Nonce = 00 00 00 08 07 06 05 A0 A1 A2 A3 A4 A5
294 * Total packet length = 33. [Input with 12 cleartext header octets]
295 * 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
296 * 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F
297 * 20
298 * CBC IV in: 59 00 00 00 08 07 06 05 A0 A1 A2 A3 A4 A5 00 15
299 * CBC IV out:04 72 DA 4C 6F F6 0A 63 06 52 1A 06 04 80 CD E5
300 * After xor: 04 7E DA 4D 6D F5 0E 66 00 55 12 0F 0E 8B CD E5 [hdr]
301 * After AES: 64 4C 36 A5 A2 27 37 62 0B 89 F1 D7 BF F2 73 D4
302 * After xor: 68 41 38 AA B2 36 25 71 1F 9C E7 C0 A7 EB 69 CF [msg]
303 * After AES: 41 E1 19 CD 19 24 CE 77 F1 2F A6 60 C1 6E BB 4E
304 * After xor: 5D FC 07 D2 39 24 CE 77 F1 2F A6 60 C1 6E BB 4E [msg]
305 * After AES: A5 27 D8 15 6A C3 59 BF 1C B8 86 E6 2F 29 91 29
306 * CBC-MAC : A5 27 D8 15 6A C3 59 BF
307 * CTR Start: 01 00 00 00 08 07 06 05 A0 A1 A2 A3 A4 A5 00 01
308 * CTR[0001]: 63 CC BE 1E E0 17 44 98 45 64 B2 3A 8D 24 5C 80
309 * CTR[0002]: 39 6D BA A2 A7 D2 CB D4 B5 E1 7C 10 79 45 BB C0
310 * CTR[MAC ]: E5 7D DC 56 C6 52 92 2B
311 * Total packet length = 41. [Authenticated and Encrypted Output]
312 * 00 01 02 03 04 05 06 07 08 09 0A 0B 6F C1 B0 11
313 * F0 06 56 8B 51 71 A4 2D 95 3D 46 9B 25 70 A4 BD
314 * 87 40 5A 04 43 AC 91 CB 94
315 */
316 static const uint8_t keys_06[] = {
317 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
318 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF
319 };
320 static const uint8_t nonce_06[] = {
321 0x00, 0x00, 0x00, 0x08, 0x07, 0x06, 0x05, 0xA0,
322 0xA1, 0xA2, 0xA3, 0xA4, 0xA5
323 };
324 static const uint8_t packet_in_06[] = {
325 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
326 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
327 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
328 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
329 0x20
330 };
331 static const uint8_t packet_out_06[] = {
332 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
333 0x08, 0x09, 0x0A, 0x0B, 0x6F, 0xC1, 0xB0, 0x11,
334 0xF0, 0x06, 0x56, 0x8B, 0x51, 0x71, 0xA4, 0x2D,
335 0x95, 0x3D, 0x46, 0x9B, 0x25, 0x70, 0xA4, 0xBD,
336 0x87, 0x40, 0x5A, 0x04, 0x43, 0xAC, 0x91, 0xCB,
337 0x94
338 };
339 #define clear_len_06 12
340 #define auth_len_06 8
341
342 /*
343 * =============== Packet Vector #7 ==================
344 * AES Key = C0 C1 C2 C3 C4 C5 C6 C7 C8 C9 CA CB CC CD CE CF
345 * Nonce = 00 00 00 09 08 07 06 A0 A1 A2 A3 A4 A5
346 * Total packet length = 31. [Input with 8 cleartext header octets]
347 * 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
348 * 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E
349 * CBC IV in: 61 00 00 00 09 08 07 06 A0 A1 A2 A3 A4 A5 00 17
350 * CBC IV out:60 06 C5 72 DA 23 9C BF A0 5B 0A DE D2 CD A8 1E
351 * After xor: 60 0E C5 73 D8 20 98 BA A6 5C 0A DE D2 CD A8 1E [hdr]
352 * After AES: 41 7D E2 AE 94 E2 EA D9 00 FC 44 FC D0 69 52 27
353 * After xor: 49 74 E8 A5 98 EF E4 D6 10 ED 56 EF C4 7C 44 30 [msg]
354 * After AES: 2A 6C 42 CA 49 D7 C7 01 C5 7D 59 FF 87 16 49 0E
355 * After xor: 32 75 58 D1 55 CA D9 01 C5 7D 59 FF 87 16 49 0E [msg]
356 * After AES: 89 8B D6 45 4E 27 20 BB D2 7E F3 15 7A 7C 90 B2
357 * CBC-MAC : 89 8B D6 45 4E 27 20 BB D2 7E
358 * CTR Start: 01 00 00 00 09 08 07 06 A0 A1 A2 A3 A4 A5 00 01
359 * CTR[0001]: 09 3C DB B9 C5 52 4F DA C1 C5 EC D2 91 C4 70 AF
360 * CTR[0002]: 11 57 83 86 E2 C4 72 B4 8E CC 8A AD AB 77 6F CB
361 * CTR[MAC ]: 8D 07 80 25 62 B0 8C 00 A6 EE
362 * Total packet length = 41. [Authenticated and Encrypted Output]
363 * 00 01 02 03 04 05 06 07 01 35 D1 B2 C9 5F 41 D5
364 * D1 D4 FE C1 85 D1 66 B8 09 4E 99 9D FE D9 6C 04
365 * 8C 56 60 2C 97 AC BB 74 90
366 */
367 static const uint8_t keys_07[] = {
368 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
369 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF
370 };
371 static const uint8_t nonce_07[] = {
372 0x00, 0x00, 0x00, 0x09, 0x08, 0x07, 0x06, 0xA0,
373 0xA1, 0xA2, 0xA3, 0xA4, 0xA5
374 };
375 static const uint8_t packet_in_07[] = {
376 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
377 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
378 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
379 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E
380 };
381 static const uint8_t packet_out_07[] = {
382 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
383 0x01, 0x35, 0xD1, 0xB2, 0xC9, 0x5F, 0x41, 0xD5,
384 0xD1, 0xD4, 0xFE, 0xC1, 0x85, 0xD1, 0x66, 0xB8,
385 0x09, 0x4E, 0x99, 0x9D, 0xFE, 0xD9, 0x6C, 0x04,
386 0x8C, 0x56, 0x60, 0x2C, 0x97, 0xAC, 0xBB, 0x74,
387 0x90
388 };
389 #define clear_len_07 8
390 #define auth_len_07 10
391
392 /*
393 * =============== Packet Vector #8 ==================
394 * AES Key = C0 C1 C2 C3 C4 C5 C6 C7 C8 C9 CA CB CC CD CE CF
395 * Nonce = 00 00 00 0A 09 08 07 A0 A1 A2 A3 A4 A5
396 * Total packet length = 32. [Input with 8 cleartext header octets]
397 * 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
398 * 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F
399 * CBC IV in: 61 00 00 00 0A 09 08 07 A0 A1 A2 A3 A4 A5 00 18
400 * CBC IV out:63 A3 FA E4 6C 79 F3 FA 78 38 B8 A2 80 36 B6 0B
401 * After xor: 63 AB FA E5 6E 7A F7 FF 7E 3F B8 A2 80 36 B6 0B [hdr]
402 * After AES: 1C 99 1A 3D B7 60 79 27 34 40 79 1F AD 8B 5B 02
403 * After xor: 14 90 10 36 BB 6D 77 28 24 51 6B 0C B9 9E 4D 15 [msg]
404 * After AES: 14 19 E8 E8 CB BE 75 58 E1 E3 BE 4B 6C 9F 82 E3
405 * After xor: 0C 00 F2 F3 D7 A3 6B 47 E1 E3 BE 4B 6C 9F 82 E3 [msg]
406 * After AES: E0 16 E8 1C 7F 7B 8A 38 A5 38 F2 CB 5B B6 C1 F2
407 * CBC-MAC : E0 16 E8 1C 7F 7B 8A 38 A5 38
408 * CTR Start: 01 00 00 00 0A 09 08 07 A0 A1 A2 A3 A4 A5 00 01
409 * CTR[0001]: 73 7C 33 91 CC 8E 13 DD E0 AA C5 4B 6D B7 EB 98
410 * CTR[0002]: 74 B7 71 77 C5 AA C5 3B 04 A4 F8 70 8E 92 EB 2B
411 * CTR[MAC ]: 21 6D AC 2F 8B 4F 1C 07 91 8C
412 * Total packet length = 42. [Authenticated and Encrypted Output]
413 * 00 01 02 03 04 05 06 07 7B 75 39 9A C0 83 1D D2
414 * F0 BB D7 58 79 A2 FD 8F 6C AE 6B 6C D9 B7 DB 24
415 * C1 7B 44 33 F4 34 96 3F 34 B4
416 */
417 static const uint8_t keys_08[] = {
418 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
419 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF
420 };
421 static const uint8_t nonce_08[] = {
422 0x00, 0x00, 0x00, 0x0a, 0x09, 0x08, 0x07, 0xA0,
423 0xA1, 0xA2, 0xA3, 0xA4, 0xA5
424 };
425 static const uint8_t packet_in_08[] = {
426 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
427 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
428 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
429 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F
430 };
431 static const uint8_t packet_out_08[] = {
432 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
433 0x7B, 0x75, 0x39, 0x9A, 0xC0, 0x83, 0x1D, 0xD2,
434 0xF0, 0xBB, 0xD7, 0x58, 0x79, 0xA2, 0xFD, 0x8F,
435 0x6C, 0xAE, 0x6B, 0x6C, 0xD9, 0xB7, 0xDB, 0x24,
436 0xC1, 0x7B, 0x44, 0x33, 0xF4, 0x34, 0x96, 0x3F,
437 0x34, 0xB4
438 };
439 #define clear_len_08 8
440 #define auth_len_08 10
441
442 /*
443 * =============== Packet Vector #9 ==================
444 * AES Key = C0 C1 C2 C3 C4 C5 C6 C7 C8 C9 CA CB CC CD CE CF
445 * Nonce = 00 00 00 0B 0A 09 08 A0 A1 A2 A3 A4 A5
446 * Total packet length = 33. [Input with 8 cleartext header octets]
447 * 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
448 * 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F
449 * 20
450 * CBC IV in: 61 00 00 00 0B 0A 09 08 A0 A1 A2 A3 A4 A5 00 19
451 * CBC IV out:4F 2C 86 11 1E 08 2A DD 6B 44 21 3A B5 13 13 16
452 * After xor: 4F 24 86 10 1C 0B 2E D8 6D 43 21 3A B5 13 13 16 [hdr]
453 * After AES: F6 EC 56 87 3C 57 12 DC 9C C5 3C A8 D4 D1 ED 0A
454 * After xor: FE E5 5C 8C 30 5A 1C D3 8C D4 2E BB C0 C4 FB 1D [msg]
455 * After AES: 17 C1 80 A5 31 53 D4 C3 03 85 0C 95 65 80 34 52
456 * After xor: 0F D8 9A BE 2D 4E CA DC 23 85 0C 95 65 80 34 52 [msg]
457 * After AES: 46 A1 F6 E2 B1 6E 75 F8 1C F5 6B 1A 80 04 44 1B
458 * CBC-MAC : 46 A1 F6 E2 B1 6E 75 F8 1C F5
459 * CTR Start: 01 00 00 00 0B 0A 09 08 A0 A1 A2 A3 A4 A5 00 01
460 * CTR[0001]: 8A 5A 10 6B C0 29 9A 55 5B 93 6B 0B 0E A0 DE 5A
461 * CTR[0002]: EA 05 FD E2 AB 22 5C FE B7 73 12 CB 88 D9 A5 4A
462 * CTR[MAC ]: AC 3D F1 07 DA 30 C4 86 43 BB
463 * Total packet length = 43. [Authenticated and Encrypted Output]
464 * 00 01 02 03 04 05 06 07 82 53 1A 60 CC 24 94 5A
465 * 4B 82 79 18 1A B5 C8 4D F2 1C E7 F9 B7 3F 42 E1
466 * 97 EA 9C 07 E5 6B 5E B1 7E 5F 4E
467 */
468 static const uint8_t keys_09[] = {
469 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
470 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF
471 };
472 static const uint8_t nonce_09[] = {
473 0x00, 0x00, 0x00, 0x0b, 0x0a, 0x09, 0x08, 0xA0,
474 0xA1, 0xA2, 0xA3, 0xA4, 0xA5
475 };
476 static const uint8_t packet_in_09[] = {
477 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
478 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
479 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
480 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
481 0x20
482 };
483 static const uint8_t packet_out_09[] = {
484 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
485 0x82, 0x53, 0x1A, 0x60, 0xCC, 0x24, 0x94, 0x5A,
486 0x4B, 0x82, 0x79, 0x18, 0x1A, 0xB5, 0xC8, 0x4D,
487 0xF2, 0x1C, 0xE7, 0xF9, 0xB7, 0x3F, 0x42, 0xE1,
488 0x97, 0xEA, 0x9C, 0x07, 0xE5, 0x6B, 0x5E, 0xB1,
489 0x7E, 0x5F, 0x4E
490 };
491 #define clear_len_09 8
492 #define auth_len_09 10
493
494 /*
495 * =============== Packet Vector #10 ==================
496 * AES Key = C0 C1 C2 C3 C4 C5 C6 C7 C8 C9 CA CB CC CD CE CF
497 * Nonce = 00 00 00 0C 0B 0A 09 A0 A1 A2 A3 A4 A5
498 * Total packet length = 31. [Input with 12 cleartext header octets]
499 * 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
500 * 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E
501 * CBC IV in: 61 00 00 00 0C 0B 0A 09 A0 A1 A2 A3 A4 A5 00 13
502 * CBC IV out:7F B8 0A 32 E9 80 57 46 EC 31 6C 3A B2 A2 EB 5D
503 * After xor: 7F B4 0A 33 EB 83 53 43 EA 36 64 33 B8 A9 EB 5D [hdr]
504 * After AES: 7E 96 96 BF F1 56 D6 A8 6E AC F5 7B 7F 23 47 5A
505 * After xor: 72 9B 98 B0 E1 47 C4 BB 7A B9 E3 6C 67 3A 5D 41 [msg]
506 * After AES: 8B 4A EE 42 04 24 8A 59 FA CC 88 66 57 66 DD 72
507 * After xor: 97 57 F0 42 04 24 8A 59 FA CC 88 66 57 66 DD 72 [msg]
508 * After AES: 41 63 89 36 62 ED D7 EB CD 6E 15 C1 89 48 62 05
509 * CBC-MAC : 41 63 89 36 62 ED D7 EB CD 6E
510 * CTR Start: 01 00 00 00 0C 0B 0A 09 A0 A1 A2 A3 A4 A5 00 01
511 * CTR[0001]: 0B 39 2B 9B 05 66 97 06 3F 12 56 8F 2B 13 A1 0F
512 * CTR[0002]: 07 89 65 25 23 40 94 3B 9E 69 B2 56 CC 5E F7 31
513 * CTR[MAC ]: 17 09 20 76 09 A0 4E 72 45 B3
514 * Total packet length = 41. [Authenticated and Encrypted Output]
515 * 00 01 02 03 04 05 06 07 08 09 0A 0B 07 34 25 94
516 * 15 77 85 15 2B 07 40 98 33 0A BB 14 1B 94 7B 56
517 * 6A A9 40 6B 4D 99 99 88 DD
518 */
519 static const uint8_t keys_10[] = {
520 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
521 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF
522 };
523 static const uint8_t nonce_10[] = {
524 0x00, 0x00, 0x00, 0x0c, 0x0b, 0x0a, 0x09, 0xA0,
525 0xA1, 0xA2, 0xA3, 0xA4, 0xA5
526 };
527 static const uint8_t packet_in_10[] = {
528 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
529 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
530 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
531 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E
532 };
533 static const uint8_t packet_out_10[] = {
534 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
535 0x08, 0x09, 0x0A, 0x0B, 0x07, 0x34, 0x25, 0x94,
536 0x15, 0x77, 0x85, 0x15, 0x2B, 0x07, 0x40, 0x98,
537 0x33, 0x0A, 0xBB, 0x14, 0x1B, 0x94, 0x7B, 0x56,
538 0x6A, 0xA9, 0x40, 0x6B, 0x4D, 0x99, 0x99, 0x88,
539 0xDD
540 };
541 #define clear_len_10 12
542 #define auth_len_10 10
543
544 /*
545 * =============== Packet Vector #11 ==================
546 * AES Key = C0 C1 C2 C3 C4 C5 C6 C7 C8 C9 CA CB CC CD CE CF
547 * Nonce = 00 00 00 0D 0C 0B 0A A0 A1 A2 A3 A4 A5
548 * Total packet length = 32. [Input with 12 cleartext header octets]
549 * 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
550 * 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F
551 * CBC IV in: 61 00 00 00 0D 0C 0B 0A A0 A1 A2 A3 A4 A5 00 14
552 * CBC IV out:B0 84 85 79 51 D2 FA 42 76 EF 3A D7 14 B9 62 87
553 * After xor: B0 88 85 78 53 D1 FE 47 70 E8 32 DE 1E B2 62 87 [hdr]
554 * After AES: C9 B3 64 7E D8 79 2A 5C 65 B7 CE CC 19 0A 97 0A
555 * After xor: C5 BE 6A 71 C8 68 38 4F 71 A2 D8 DB 01 13 8D 11 [msg]
556 * After AES: 34 0F 69 17 FA B9 19 D6 1D AC D0 35 36 D6 55 8B
557 * After xor: 28 12 77 08 FA B9 19 D6 1D AC D0 35 36 D6 55 8B [msg]
558 * After AES: 6B 5E 24 34 12 CC C2 AD 6F 1B 11 C3 A1 A9 D8 BC
559 * CBC-MAC : 6B 5E 24 34 12 CC C2 AD 6F 1B
560 * CTR Start: 01 00 00 00 0D 0C 0B 0A A0 A1 A2 A3 A4 A5 00 01
561 * CTR[0001]: 6B 66 BC 0C 90 A1 F1 12 FC BE 6F 4E 12 20 77 BC
562 * CTR[0002]: 97 9E 57 2B BE 65 8A E5 CC 20 11 83 2A 9A 9B 5B
563 * CTR[MAC ]: 9E 64 86 DD 02 B6 49 C1 6D 37
564 * Total packet length = 42. [Authenticated and Encrypted Output]
565 * 00 01 02 03 04 05 06 07 08 09 0A 0B 67 6B B2 03
566 * 80 B0 E3 01 E8 AB 79 59 0A 39 6D A7 8B 83 49 34
567 * F5 3A A2 E9 10 7A 8B 6C 02 2C
568 */
569 static const uint8_t keys_11[] = {
570 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
571 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF
572 };
573 static const uint8_t nonce_11[] = {
574 0x00, 0x00, 0x00, 0x0d, 0x0c, 0x0b, 0x0a, 0xA0,
575 0xA1, 0xA2, 0xA3, 0xA4, 0xA5
576 };
577 static const uint8_t packet_in_11[] = {
578 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
579 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
580 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
581 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F
582 };
583 static const uint8_t packet_out_11[] = {
584 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
585 0x08, 0x09, 0x0A, 0x0B, 0x67, 0x6B, 0xB2, 0x03,
586 0x80, 0xB0, 0xE3, 0x01, 0xE8, 0xAB, 0x79, 0x59,
587 0x0A, 0x39, 0x6D, 0xA7, 0x8B, 0x83, 0x49, 0x34,
588 0xF5, 0x3A, 0xA2, 0xE9, 0x10, 0x7A, 0x8B, 0x6C,
589 0x02, 0x2C
590 };
591 #define clear_len_11 12
592 #define auth_len_11 10
593
594 /*
595 * =============== Packet Vector #12 ==================
596 * AES Key = C0 C1 C2 C3 C4 C5 C6 C7 C8 C9 CA CB CC CD CE CF
597 * Nonce = 00 00 00 0E 0D 0C 0B A0 A1 A2 A3 A4 A5
598 * Total packet length = 33. [Input with 12 cleartext header octets]
599 * 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
600 * 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F
601 * 20
602 * CBC IV in: 61 00 00 00 0E 0D 0C 0B A0 A1 A2 A3 A4 A5 00 15
603 * CBC IV out:5F 8E 8D 02 AD 95 7C 5A 36 14 CF 63 40 16 97 4F
604 * After xor: 5F 82 8D 03 AF 96 78 5F 30 13 C7 6A 4A 1D 97 4F [hdr]
605 * After AES: 63 FA BD 69 B9 55 65 FF 54 AA F4 60 88 7D EC 9F
606 * After xor: 6F F7 B3 66 A9 44 77 EC 40 BF E2 77 90 64 F6 84 [msg]
607 * After AES: 5A 76 5F 0B 93 CE 4F 6A B4 1D 91 30 18 57 6A D7
608 * After xor: 46 6B 41 14 B3 CE 4F 6A B4 1D 91 30 18 57 6A D7 [msg]
609 * After AES: 9D 66 92 41 01 08 D5 B6 A1 45 85 AC AF 86 32 E8
610 * CBC-MAC : 9D 66 92 41 01 08 D5 B6 A1 45
611 * CTR Start: 01 00 00 00 0E 0D 0C 0B A0 A1 A2 A3 A4 A5 00 01
612 * CTR[0001]: CC F2 AE D9 E0 4A C9 74 E6 58 55 B3 2B 94 30 BF
613 * CTR[0002]: A2 CA AC 11 63 F4 07 E5 E5 F6 E3 B3 79 0F 79 F8
614 * CTR[MAC ]: 50 7C 31 57 63 EF 78 D3 77 9E
615 * Total packet length = 43. [Authenticated and Encrypted Output]
616 * 00 01 02 03 04 05 06 07 08 09 0A 0B C0 FF A0 D6
617 * F0 5B DB 67 F2 4D 43 A4 33 8D 2A A4 BE D7 B2 0E
618 * 43 CD 1A A3 16 62 E7 AD 65 D6 DB
619 */
620 static const uint8_t keys_12[] = {
621 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
622 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF
623 };
624 static const uint8_t nonce_12[] = {
625 0x00, 0x00, 0x00, 0x0e, 0x0d, 0x0c, 0x0b, 0xA0,
626 0xA1, 0xA2, 0xA3, 0xA4, 0xA5
627 };
628 static const uint8_t packet_in_12[] = {
629 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
630 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
631 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
632 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
633 0x20
634 };
635 static const uint8_t packet_out_12[] = {
636 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
637 0x08, 0x09, 0x0A, 0x0B, 0xC0, 0xFF, 0xA0, 0xD6,
638 0xF0, 0x5B, 0xDB, 0x67, 0xF2, 0x4D, 0x43, 0xA4,
639 0x33, 0x8D, 0x2A, 0xA4, 0xBE, 0xD7, 0xB2, 0x0E,
640 0x43, 0xCD, 0x1A, 0xA3, 0x16, 0x62, 0xE7, 0xAD,
641 0x65, 0xD6, 0xDB
642 };
643 #define clear_len_12 12
644 #define auth_len_12 10
645
646 /*
647 * =============== Packet Vector #13 ==================
648 * AES Key = D7 82 8D 13 B2 B0 BD C3 25 A7 62 36 DF 93 CC 6B
649 * Nonce = 00 41 2B 4E A9 CD BE 3C 96 96 76 6C FA
650 * Total packet length = 31. [Input with 8 cleartext header octets]
651 * 0B E1 A8 8B AC E0 18 B1 08 E8 CF 97 D8 20 EA 25
652 * 84 60 E9 6A D9 CF 52 89 05 4D 89 5C EA C4 7C
653 * CBC IV in: 59 00 41 2B 4E A9 CD BE 3C 96 96 76 6C FA 00 17
654 * CBC IV out:33 AE C3 1A 1F B7 CC 35 E5 DA D2 BA C0 90 D9 A3
655 * After xor: 33 A6 C8 FB B7 3C 60 D5 FD 6B D2 BA C0 90 D9 A3 [hdr]
656 * After AES: B7 56 CA 1E 5B 42 C6 9C 58 E3 0A F5 2B F7 7C FD
657 * After xor: BF BE 05 89 83 62 2C B9 DC 83 E3 9F F2 38 2E 74 [msg]
658 * After AES: 33 3D 3A 3D 07 B5 3C 7B 22 0E 96 1A 18 A9 A1 9E
659 * After xor: 36 70 B3 61 ED 71 40 7B 22 0E 96 1A 18 A9 A1 9E [msg]
660 * After AES: 14 BD DB 6B F9 01 63 4D FB 56 51 83 BC 74 93 F7
661 * CBC-MAC : 14 BD DB 6B F9 01 63 4D
662 * CTR Start: 01 00 41 2B 4E A9 CD BE 3C 96 96 76 6C FA 00 01
663 * CTR[0001]: 44 51 B0 11 7A 84 82 BF 03 19 AE C1 59 5E BD DA
664 * CTR[0002]: 83 EB 76 E1 3A 44 84 7F 92 20 09 07 76 B8 25 C5
665 * CTR[MAC ]: F3 31 2C A0 F5 DC B4 FE
666 * Total packet length = 39. [Authenticated and Encrypted Output]
667 * 0B E1 A8 8B AC E0 18 B1 4C B9 7F 86 A2 A4 68 9A
668 * 87 79 47 AB 80 91 EF 53 86 A6 FF BD D0 80 F8 E7
669 * 8C F7 CB 0C DD D7 B3
670 */
671 static const uint8_t keys_13[] = {
672 0xD7, 0x82, 0x8D, 0x13, 0xB2, 0xB0, 0xBD, 0xC3,
673 0x25, 0xA7, 0x62, 0x36, 0xDF, 0x93, 0xCC, 0x6B
674 };
675 static const uint8_t nonce_13[] = {
676 0x00, 0x41, 0x2b, 0x4e, 0xa9, 0xcd, 0xbe, 0x3c,
677 0x96, 0x96, 0x76, 0x6c, 0xfa
678 };
679 static const uint8_t packet_in_13[] = {
680 0x0B, 0xE1, 0xA8, 0x8B, 0xAC, 0xE0, 0x18, 0xB1,
681 0x08, 0xE8, 0xCF, 0x97, 0xD8, 0x20, 0xEA, 0x25,
682 0x84, 0x60, 0xE9, 0x6A, 0xD9, 0xCF, 0x52, 0x89,
683 0x05, 0x4D, 0x89, 0x5C, 0xEA, 0xC4, 0x7C
684 };
685 static const uint8_t packet_out_13[] = {
686 0x0B, 0xE1, 0xA8, 0x8B, 0xAC, 0xE0, 0x18, 0xB1,
687 0x4C, 0xB9, 0x7F, 0x86, 0xA2, 0xA4, 0x68, 0x9A,
688 0x87, 0x79, 0x47, 0xAB, 0x80, 0x91, 0xEF, 0x53,
689 0x86, 0xA6, 0xFF, 0xBD, 0xD0, 0x80, 0xF8, 0xE7,
690 0x8C, 0xF7, 0xCB, 0x0C, 0xDD, 0xD7, 0xB3
691 };
692 #define clear_len_13 8
693 #define auth_len_13 8
694
695 /*
696 * =============== Packet Vector #14 ==================
697 * AES Key = D7 82 8D 13 B2 B0 BD C3 25 A7 62 36 DF 93 CC 6B
698 * Nonce = 00 33 56 8E F7 B2 63 3C 96 96 76 6C FA
699 * Total packet length = 32. [Input with 8 cleartext header octets]
700 * 63 01 8F 76 DC 8A 1B CB 90 20 EA 6F 91 BD D8 5A
701 * FA 00 39 BA 4B AF F9 BF B7 9C 70 28 94 9C D0 EC
702 * CBC IV in: 59 00 33 56 8E F7 B2 63 3C 96 96 76 6C FA 00 18
703 * CBC IV out:42 0D B1 50 BB 0C 44 DA 83 E4 52 09 55 99 67 E3
704 * After xor: 42 05 D2 51 34 7A 98 50 98 2F 52 09 55 99 67 E3 [hdr]
705 * After AES: EA D1 CA 56 02 02 09 5C E6 12 B0 D2 18 A0 DD 44
706 * After xor: 7A F1 20 39 93 BF D1 06 1C 12 89 68 53 0F 24 FB [msg]
707 * After AES: 51 77 41 69 C3 DE 6B 24 13 27 74 90 F5 FF C5 62
708 * After xor: E6 EB 31 41 57 42 BB C8 13 27 C5 62 [msg]
709 * After AES: D4 CC 3B 82 DF 9F CC 56 7E E5 83 61 D7 8D FB 5E
710 * CBC-MAC : D4 CC 3B 82 DF 9F CC 56
711 * CTR Start: 01 00 33 56 8E F7 B2 63 3C 96 96 76 6C FA 00 01
712 * CTR[0001]: DC EB F4 13 38 3C 66 A0 5A 72 55 EF 98 D7 FF AD
713 * CTR[0002]: 2F 54 2C BA 15 D6 6C DF E1 EC 46 8F 0E 68 A1 24
714 * CTR[MAC ]: 11 E2 D3 9F A2 E8 0C DC
715 * Total packet length = 40. [Authenticated and Encrypted Output]
716 * 63 01 8F 76 DC 8A 1B CB 4C CB 1E 7C A9 81 BE FA
717 * A0 72 6C 55 D3 78 06 12 98 C8 5C 92 81 4A BC 33
718 * C5 2E E8 1D 7D 77 C0 8A
719 */
720 static const uint8_t keys_14[] = {
721 0xD7, 0x82, 0x8D, 0x13, 0xB2, 0xB0, 0xBD, 0xC3,
722 0x25, 0xA7, 0x62, 0x36, 0xDF, 0x93, 0xCC, 0x6B
723 };
724 static const uint8_t nonce_14[] = {
725 0x00, 0x33, 0x56, 0x8E, 0xF7, 0xB2, 0x63, 0x3C,
726 0x96, 0x96, 0x76, 0x6C, 0xFA
727 };
728 static const uint8_t packet_in_14[] = {
729 0x63, 0x01, 0x8F, 0x76, 0xDC, 0x8A, 0x1B, 0xCB,
730 0x90, 0x20, 0xEA, 0x6F, 0x91, 0xBD, 0xD8, 0x5A,
731 0xFA, 0x00, 0x39, 0xBA, 0x4B, 0xAF, 0xF9, 0xBF,
732 0xB7, 0x9C, 0x70, 0x28, 0x94, 0x9C, 0xD0, 0xEC,
733 };
734 static const uint8_t packet_out_14[] = {
735 0x63, 0x01, 0x8F, 0x76, 0xDC, 0x8A, 0x1B, 0xCB,
736 0x4C, 0xCB, 0x1E, 0x7C, 0xA9, 0x81, 0xBE, 0xFA,
737 0xA0, 0x72, 0x6C, 0x55, 0xD3, 0x78, 0x06, 0x12,
738 0x98, 0xC8, 0x5C, 0x92, 0x81, 0x4A, 0xBC, 0x33,
739 0xC5, 0x2E, 0xE8, 0x1D, 0x7D, 0x77, 0xC0, 0x8A
740 };
741 #define clear_len_14 8
742 #define auth_len_14 8
743
744 /*
745 * =============== Packet Vector #15 ==================
746 * AES Key = D7 82 8D 13 B2 B0 BD C3 25 A7 62 36 DF 93 CC 6B
747 * Nonce = 00 10 3F E4 13 36 71 3C 96 96 76 6C FA
748 * Total packet length = 33. [Input with 8 cleartext header octets]
749 * AA 6C FA 36 CA E8 6B 40 B9 16 E0 EA CC 1C 00 D7
750 * DC EC 68 EC 0B 3B BB 1A 02 DE 8A 2D 1A A3 46 13
751 * 2E
752 * CBC IV in: 59 00 10 3F E4 13 36 71 3C 96 96 76 6C FA 00 19
753 * CBC IV out:B3 26 49 FF D5 9F 56 0F 02 2D 11 E2 62 C5 BE EA
754 * After xor: B3 2E E3 93 2F A9 9C E7 69 6D 11 E2 62 C5 BE EA [hdr]
755 * After AES: 82 50 9E E5 B2 FF DB CA 9B D0 2E 20 6B 3F B7 AD
756 * After xor: 3B 46 7E 0F 7E E3 DB 1D 47 3C 46 CC 60 04 0C B7 [msg]
757 * After AES: 80 46 0E 4C 08 3A D0 3F B9 A9 13 BE E4 DE 2F 66
758 * After xor: 82 98 84 61 12 99 96 2C 97 A9 13 BE E4 DE 2F 66 [msg]
759 * After AES: 47 29 CB 00 31 F1 81 C1 92 68 4B 89 A4 71 50 E7
760 * CBC-MAC : 47 29 CB 00 31 F1 81 C1
761 * CTR Start: 01 00 10 3F E4 13 36 71 3C 96 96 76 6C FA 00 01
762 * CTR[0001]: 08 C4 DA C8 EC C1 C0 7B 4C E1 F2 4C 37 5A 47 EE
763 * CTR[0002]: A7 87 2E 6C 6D C4 4E 84 26 02 50 4C 3F A5 73 C5
764 * CTR[MAC ]: E0 5F B2 6E EA 83 B4 C7
765 * Total packet length = 41. [Authenticated and Encrypted Output]
766 * AA 6C FA 36 CA E8 6B 40 B1 D2 3A 22 20 DD C0 AC
767 * 90 0D 9A A0 3C 61 FC F4 A5 59 A4 41 77 67 08 97
768 * 08 A7 76 79 6E DB 72 35 06
769 */
770 static const uint8_t keys_15[] = {
771 0xD7, 0x82, 0x8D, 0x13, 0xB2, 0xB0, 0xBD, 0xC3,
772 0x25, 0xA7, 0x62, 0x36, 0xDF, 0x93, 0xCC, 0x6B
773 };
774 static const uint8_t nonce_15[] = {
775 0x00, 0x10, 0x3F, 0xE4, 0x13, 0x36, 0x71, 0x3C,
776 0x96, 0x96, 0x76, 0x6C, 0xFA
777 };
778 static const uint8_t packet_in_15[] = {
779 0xAA, 0x6C, 0xFA, 0x36, 0xCA, 0xE8, 0x6B, 0x40,
780 0xB9, 0x16, 0xE0, 0xEA, 0xCC, 0x1C, 0x00, 0xD7,
781 0xDC, 0xEC, 0x68, 0xEC, 0x0B, 0x3B, 0xBB, 0x1A,
782 0x02, 0xDE, 0x8A, 0x2D, 0x1A, 0xA3, 0x46, 0x13,
783 0x2E
784 };
785 static const uint8_t packet_out_15[] = {
786 0xAA, 0x6C, 0xFA, 0x36, 0xCA, 0xE8, 0x6B, 0x40,
787 0xB1, 0xD2, 0x3A, 0x22, 0x20, 0xDD, 0xC0, 0xAC,
788 0x90, 0x0D, 0x9A, 0xA0, 0x3C, 0x61, 0xFC, 0xF4,
789 0xA5, 0x59, 0xA4, 0x41, 0x77, 0x67, 0x08, 0x97,
790 0x08, 0xA7, 0x76, 0x79, 0x6E, 0xDB, 0x72, 0x35,
791 0x06
792 };
793 #define clear_len_15 8
794 #define auth_len_15 8
795
796 /*
797 * =============== Packet Vector #16 ==================
798 * AES Key = D7 82 8D 13 B2 B0 BD C3 25 A7 62 36 DF 93 CC 6B
799 * Nonce = 00 76 4C 63 B8 05 8E 3C 96 96 76 6C FA
800 * Total packet length = 31. [Input with 12 cleartext header octets]
801 * D0 D0 73 5C 53 1E 1B EC F0 49 C2 44 12 DA AC 56
802 * 30 EF A5 39 6F 77 0C E1 A6 6B 21 F7 B2 10 1C
803 * CBC IV in: 59 00 76 4C 63 B8 05 8E 3C 96 96 76 6C FA 00 13
804 * CBC IV out:AB DC 4E C9 AA 72 33 97 DF 2D AD 76 33 DE 3B 0D
805 * After xor: AB D0 9E 19 D9 2E 60 89 C4 C1 5D 3F F1 9A 3B 0D [hdr]
806 * After AES: 62 86 F6 2F 23 42 63 B0 1C FD 8C 37 40 74 81 EB
807 * After xor: 70 5C 5A 79 13 AD C6 89 73 8A 80 D6 E6 1F A0 1C [msg]
808 * After AES: 88 95 84 18 CF 79 CA BE EB C0 0C C4 86 E6 01 F7
809 * After xor: 3A 85 98 18 CF 79 CA BE EB C0 0C C4 86 E6 01 F7 [msg]
810 * After AES: C1 85 92 D9 84 CD 67 80 63 D1 D9 6D C1 DF A1 11
811 * CBC-MAC : C1 85 92 D9 84 CD 67 80
812 * CTR Start: 01 00 76 4C 63 B8 05 8E 3C 96 96 76 6C FA 00 01
813 * CTR[0001]: 06 08 FF 95 A6 94 D5 59 F4 0B B7 9D EF FA 41 DF
814 * CTR[0002]: 80 55 3A 75 78 38 04 A9 64 8B 68 DD 7F DC DD 7A
815 * CTR[MAC ]: 5B EA DB 4E DF 07 B9 2F
816 * Total packet length = 39. [Authenticated and Encrypted Output]
817 * D0 D0 73 5C 53 1E 1B EC F0 49 C2 44 14 D2 53 C3
818 * 96 7B 70 60 9B 7C BB 7C 49 91 60 28 32 45 26 9A
819 * 6F 49 97 5B CA DE AF
820 */
821 static const uint8_t keys_16[] = {
822 0xD7, 0x82, 0x8D, 0x13, 0xB2, 0xB0, 0xBD, 0xC3,
823 0x25, 0xA7, 0x62, 0x36, 0xDF, 0x93, 0xCC, 0x6B
824 };
825 static const uint8_t nonce_16[] = {
826 0x00, 0x76, 0x4C, 0x63, 0xB8, 0x05, 0x8E, 0x3C,
827 0x96, 0x96, 0x76, 0x6C, 0xFA
828 };
829 static const uint8_t packet_in_16[] = {
830 0xD0, 0xD0, 0x73, 0x5C, 0x53, 0x1E, 0x1B, 0xEC,
831 0xF0, 0x49, 0xC2, 0x44, 0x12, 0xDA, 0xAC, 0x56,
832 0x30, 0xEF, 0xA5, 0x39, 0x6F, 0x77, 0x0C, 0xE1,
833 0xA6, 0x6B, 0x21, 0xF7, 0xB2, 0x10, 0x1C
834 };
835 static const uint8_t packet_out_16[] = {
836 0xD0, 0xD0, 0x73, 0x5C, 0x53, 0x1E, 0x1B, 0xEC,
837 0xF0, 0x49, 0xC2, 0x44, 0x14, 0xD2, 0x53, 0xC3,
838 0x96, 0x7B, 0x70, 0x60, 0x9B, 0x7C, 0xBB, 0x7C,
839 0x49, 0x91, 0x60, 0x28, 0x32, 0x45, 0x26, 0x9A,
840 0x6F, 0x49, 0x97, 0x5B, 0xCA, 0xDE, 0xAF
841 };
842 #define clear_len_16 12
843 #define auth_len_16 8
844
845 /*
846 * =============== Packet Vector #17 ==================
847 * AES Key = D7 82 8D 13 B2 B0 BD C3 25 A7 62 36 DF 93 CC 6B
848 * Nonce = 00 F8 B6 78 09 4E 3B 3C 96 96 76 6C FA
849 * Total packet length = 32. [Input with 12 cleartext header octets]
850 * 77 B6 0F 01 1C 03 E1 52 58 99 BC AE E8 8B 6A 46
851 * C7 8D 63 E5 2E B8 C5 46 EF B5 DE 6F 75 E9 CC 0D
852 * CBC IV in: 59 00 F8 B6 78 09 4E 3B 3C 96 96 76 6C FA 00 14
853 * CBC IV out:F4 68 FE 5D B1 53 0B 7A 5A A5 FB 27 40 CF 6E 33
854 * After xor: F4 64 89 EB BE 52 17 79 BB F7 A3 BE FC 61 6E 33 [hdr]
855 * After AES: 23 29 0E 0B 33 45 9A 83 32 2D E4 06 86 67 10 04
856 * After xor: CB A2 64 4D F4 C8 F9 66 1C 95 21 40 69 D2 CE 6B [msg]
857 * After AES: 8F BE D4 0F 8B 89 B7 B8 20 D5 5F E0 3C E2 43 11
858 * After xor: FA 57 18 02 8B 89 B7 B8 20 D5 5F E0 3C E2 43 11 [msg]
859 * After AES: 6A DB 15 B6 71 81 B2 E2 2B E3 4A F2 B2 83 E2 29
860 * CBC-MAC : 6A DB 15 B6 71 81 B2 E2
861 * CTR Start: 01 00 F8 B6 78 09 4E 3B 3C 96 96 76 6C FA 00 01
862 * CTR[0001]: BD CE 95 5C CF D3 81 0A 91 EA 77 A6 A4 5B C0 4C
863 * CTR[0002]: 43 2E F2 32 AE 36 D8 92 22 BF 63 37 E6 B2 6C E8
864 * CTR[MAC ]: 1C F7 19 C1 35 7F CC DE
865 * Total packet length = 40. [Authenticated and Encrypted Output]
866 * 77 B6 0F 01 1C 03 E1 52 58 99 BC AE 55 45 FF 1A
867 * 08 5E E2 EF BF 52 B2 E0 4B EE 1E 23 36 C7 3E 3F
868 * 76 2C 0C 77 44 FE 7E 3C
869 */
870 static const uint8_t keys_17[] = {
871 0xD7, 0x82, 0x8D, 0x13, 0xB2, 0xB0, 0xBD, 0xC3,
872 0x25, 0xA7, 0x62, 0x36, 0xDF, 0x93, 0xCC, 0x6B
873 };
874 static const uint8_t nonce_17[] = {
875 0x00, 0xF8, 0xB6, 0x78, 0x09, 0x4E, 0x3B, 0x3C,
876 0x96, 0x96, 0x76, 0x6C, 0xFA
877 };
878 static const uint8_t packet_in_17[] = {
879 0x77, 0xB6, 0x0F, 0x01, 0x1C, 0x03, 0xE1, 0x52,
880 0x58, 0x99, 0xBC, 0xAE, 0xE8, 0x8B, 0x6A, 0x46,
881 0xC7, 0x8D, 0x63, 0xE5, 0x2E, 0xB8, 0xC5, 0x46,
882 0xEF, 0xB5, 0xDE, 0x6F, 0x75, 0xE9, 0xCC, 0x0D
883 };
884 static const uint8_t packet_out_17[] = {
885 0x77, 0xB6, 0x0F, 0x01, 0x1C, 0x03, 0xE1, 0x52,
886 0x58, 0x99, 0xBC, 0xAE, 0x55, 0x45, 0xFF, 0x1A,
887 0x08, 0x5E, 0xE2, 0xEF, 0xBF, 0x52, 0xB2, 0xE0,
888 0x4B, 0xEE, 0x1E, 0x23, 0x36, 0xC7, 0x3E, 0x3F,
889 0x76, 0x2C, 0x0C, 0x77, 0x44, 0xFE, 0x7E, 0x3C
890 };
891 #define clear_len_17 12
892 #define auth_len_17 8
893
894 /*
895 * =============== Packet Vector #18 ==================
896 * AES Key = D7 82 8D 13 B2 B0 BD C3 25 A7 62 36 DF 93 CC 6B
897 * Nonce = 00 D5 60 91 2D 3F 70 3C 96 96 76 6C FA
898 * Total packet length = 33. [Input with 12 cleartext header octets]
899 * CD 90 44 D2 B7 1F DB 81 20 EA 60 C0 64 35 AC BA
900 * FB 11 A8 2E 2F 07 1D 7C A4 A5 EB D9 3A 80 3B A8
901 * 7F
902 * CBC IV in: 59 00 D5 60 91 2D 3F 70 3C 96 96 76 6C FA 00 15
903 * CBC IV out:BA 37 74 54 D7 20 A4 59 25 97 F6 A3 D1 D6 BA 67
904 * After xor: BA 3B B9 C4 93 F2 13 46 FE 16 D6 49 B1 16 BA 67 [hdr]
905 * After AES: 81 6A 20 20 38 D0 A6 30 CB E0 B7 3C 39 BB CE 05
906 * After xor: E5 5F 8C 9A C3 C1 0E 1E E4 E7 AA 40 9D 1E 25 DC [msg]
907 * After AES: 6D 5C 15 FD 85 2D 5C 3C E3 03 3D 85 DA 57 BD AC
908 * After xor: 57 DC 2E 55 FA 2D 5C 3C E3 03 3D 85 DA 57 BD AC [msg]
909 * After AES: B0 4A 1C 23 BC 39 B6 51 76 FD 5B FF 9B C1 28 5E
910 * CBC-MAC : B0 4A 1C 23 BC 39 B6 51
911 * CTR Start: 01 00 D5 60 91 2D 3F 70 3C 96 96 76 6C FA 00 01
912 * CTR[0001]: 64 A2 C5 56 50 CE E0 4C 7A 93 D8 EE F5 43 E8 8E
913 * CTR[0002]: 18 E7 65 AC B7 B0 E9 AF 09 2B D0 20 6C A1 C8 3C
914 * CTR[MAC ]: F7 43 82 79 5C 49 F3 00
915 * Total packet length = 41. [Authenticated and Encrypted Output]
916 * CD 90 44 D2 B7 1F DB 81 20 EA 60 C0 00 97 69 EC
917 * AB DF 48 62 55 94 C5 92 51 E6 03 57 22 67 5E 04
918 * C8 47 09 9E 5A E0 70 45 51
919 */
920 static const uint8_t keys_18[] = {
921 0xD7, 0x82, 0x8D, 0x13, 0xB2, 0xB0, 0xBD, 0xC3,
922 0x25, 0xA7, 0x62, 0x36, 0xDF, 0x93, 0xCC, 0x6B
923 };
924 static const uint8_t nonce_18[] = {
925 0x00, 0xD5, 0x60, 0x91, 0x2D, 0x3F, 0x70, 0x3C,
926 0x96, 0x96, 0x76, 0x6C, 0xFA
927 };
928 static const uint8_t packet_in_18[] = {
929 0xCD, 0x90, 0x44, 0xD2, 0xB7, 0x1F, 0xDB, 0x81,
930 0x20, 0xEA, 0x60, 0xC0, 0x64, 0x35, 0xAC, 0xBA,
931 0xFB, 0x11, 0xA8, 0x2E, 0x2F, 0x07, 0x1D, 0x7C,
932 0xA4, 0xA5, 0xEB, 0xD9, 0x3A, 0x80, 0x3B, 0xA8,
933 0x7F
934 };
935 static const uint8_t packet_out_18[] = {
936 0xCD, 0x90, 0x44, 0xD2, 0xB7, 0x1F, 0xDB, 0x81,
937 0x20, 0xEA, 0x60, 0xC0, 0x00, 0x97, 0x69, 0xEC,
938 0xAB, 0xDF, 0x48, 0x62, 0x55, 0x94, 0xC5, 0x92,
939 0x51, 0xE6, 0x03, 0x57, 0x22, 0x67, 0x5E, 0x04,
940 0xC8, 0x47, 0x09, 0x9E, 0x5A, 0xE0, 0x70, 0x45,
941 0x51
942 };
943 #define clear_len_18 12
944 #define auth_len_18 8
945
946 /*
947 * =============== Packet Vector #19 ==================
948 * AES Key = D7 82 8D 13 B2 B0 BD C3 25 A7 62 36 DF 93 CC 6B
949 * Nonce = 00 42 FF F8 F1 95 1C 3C 96 96 76 6C FA
950 * Total packet length = 31. [Input with 8 cleartext header octets]
951 * D8 5B C7 E6 9F 94 4F B8 8A 19 B9 50 BC F7 1A 01
952 * 8E 5E 67 01 C9 17 87 65 98 09 D6 7D BE DD 18
953 * CBC IV in: 61 00 42 FF F8 F1 95 1C 3C 96 96 76 6C FA 00 17
954 * CBC IV out:44 F7 CC 9C 2B DD 2F 45 F6 38 25 6B 73 6E 1D 7A
955 * After xor: 44 FF 14 C7 EC 3B B0 D1 B9 80 25 6B 73 6E 1D 7A [hdr]
956 * After AES: 57 C3 73 F8 00 AA 5F CC 7B CF 1D 1B DD BB 4C 52
957 * After xor: DD DA CA A8 BC 5D 45 CD F5 91 7A 1A 14 AC CB 37 [msg]
958 * After AES: 42 4E 93 72 72 C8 79 B6 11 C7 A5 9F 47 8D 9F D8
959 * After xor: DA 47 45 0F CC 15 61 B6 11 C7 A5 9F 47 8D 9F D8 [msg]
960 * After AES: 9A CB 03 F8 B9 DB C8 D2 D2 D7 A4 B4 95 25 08 67
961 * CBC-MAC : 9A CB 03 F8 B9 DB C8 D2 D2 D7
962 * CTR Start: 01 00 42 FF F8 F1 95 1C 3C 96 96 76 6C FA 00 01
963 * CTR[0001]: 36 38 34 FA 28 83 3D B7 55 66 0D 98 65 0D 68 46
964 * CTR[0002]: 35 E9 63 54 87 16 72 56 3F 0C 08 AF 78 44 31 A9
965 * CTR[MAC ]: F9 B7 FA 46 7B 9B 40 45 14 6D
966 * Total packet length = 41. [Authenticated and Encrypted Output]
967 * D8 5B C7 E6 9F 94 4F B8 BC 21 8D AA 94 74 27 B6
968 * DB 38 6A 99 AC 1A EF 23 AD E0 B5 29 39 CB 6A 63
969 * 7C F9 BE C2 40 88 97 C6 BA
970 */
971 static const uint8_t keys_19[] = {
972 0xD7, 0x82, 0x8D, 0x13, 0xB2, 0xB0, 0xBD, 0xC3,
973 0x25, 0xA7, 0x62, 0x36, 0xDF, 0x93, 0xCC, 0x6B
974 };
975 static const uint8_t nonce_19[] = {
976 0x00, 0x42, 0xFF, 0xF8, 0xF1, 0x95, 0x1C, 0x3C,
977 0x96, 0x96, 0x76, 0x6C, 0xFA
978 };
979 static const uint8_t packet_in_19[] = {
980 0xD8, 0x5B, 0xC7, 0xE6, 0x9F, 0x94, 0x4F, 0xB8,
981 0x8A, 0x19, 0xB9, 0x50, 0xBC, 0xF7, 0x1A, 0x01,
982 0x8E, 0x5E, 0x67, 0x01, 0xC9, 0x17, 0x87, 0x65,
983 0x98, 0x09, 0xD6, 0x7D, 0xBE, 0xDD, 0x18
984 };
985 static const uint8_t packet_out_19[] = {
986 0xD8, 0x5B, 0xC7, 0xE6, 0x9F, 0x94, 0x4F, 0xB8,
987 0xBC, 0x21, 0x8D, 0xAA, 0x94, 0x74, 0x27, 0xB6,
988 0xDB, 0x38, 0x6A, 0x99, 0xAC, 0x1A, 0xEF, 0x23,
989 0xAD, 0xE0, 0xB5, 0x29, 0x39, 0xCB, 0x6A, 0x63,
990 0x7C, 0xF9, 0xBE, 0xC2, 0x40, 0x88, 0x97, 0xC6,
991 0xBA
992 };
993 #define clear_len_19 8
994 #define auth_len_19 10
995
996 /*
997 * ================= Packet Vector #20 ==================
998 * AES Key = D7 82 8D 13 B2 B0 BD C3 25 A7 62 36 DF 93 CC 6B
999 * Nonce = 00 92 0F 40 E5 6C DC 3C 96 96 76 6C FA
1000 * Total packet length = 32. [Input with 8 cleartext header octets]
1001 * 74 A0 EB C9 06 9F 5B 37 17 61 43 3C 37 C5 A3 5F
1002 * C1 F3 9F 40 63 02 EB 90 7C 61 63 BE 38 C9 84 37
1003 * CBC IV in: 61 00 92 0F 40 E5 6C DC 3C 96 96 76 6C FA 00 18
1004 * CBC IV out:60 CB 21 CE 40 06 50 AE 2A D2 BE 52 9F 5F 0F C2
1005 * After xor: 60 C3 55 6E AB CF 56 31 71 E5 BE 52 9F 5F 0F C2 [hdr]
1006 * After AES: 03 20 64 14 35 32 5D 95 C8 A2 50 40 93 28 DA 9B
1007 * After xor: 14 41 27 28 02 F7 FE CA 09 51 CF 00 F0 2A 31 0B [msg]
1008 * After AES: B9 E8 87 95 ED F7 F0 08 15 15 F0 14 E2 FE 0E 48
1009 * After xor: C5 89 E4 2B D5 3E 74 3F 15 15 F0 14 E2 FE 0E 48 [msg]
1010 * After AES: 8F AD 0C 23 E9 63 7E 87 FA 21 45 51 1B 47 DE F1
1011 * CBC-MAC : 8F AD 0C 23 E9 63 7E 87 FA 21
1012 * CTR Start: 01 00 92 0F 40 E5 6C DC 3C 96 96 76 6C FA 00 01
1013 * CTR[0001]: 4F 71 A5 C1 12 42 E3 7D 29 F0 FE E4 1B E1 02 5F
1014 * CTR[0002]: 34 2B D3 F1 7C B7 7B C1 79 0B 05 05 61 59 27 2C
1015 * CTR[MAC ]: 7F 09 7B EF C6 AA C1 D3 73 65
1016 * Total packet length = 42. [Authenticated and Encrypted Output]
1017 * 74 A0 EB C9 06 9F 5B 37 58 10 E6 FD 25 87 40 22
1018 * E8 03 61 A4 78 E3 E9 CF 48 4A B0 4F 44 7E FF F6
1019 * F0 A4 77 CC 2F C9 BF 54 89 44
1020 */
1021 static const uint8_t keys_20[] = {
1022 0xD7, 0x82, 0x8D, 0x13, 0xB2, 0xB0, 0xBD, 0xC3,
1023 0x25, 0xA7, 0x62, 0x36, 0xDF, 0x93, 0xCC, 0x6B
1024 };
1025 static const uint8_t nonce_20[] = {
1026 0x00, 0x92, 0x0F, 0x40, 0xE5, 0x6C, 0xDC, 0x3C,
1027 0x96, 0x96, 0x76, 0x6C, 0xFA
1028 };
1029 static const uint8_t packet_in_20[] = {
1030 0x74, 0xA0, 0xEB, 0xC9, 0x06, 0x9F, 0x5B, 0x37,
1031 0x17, 0x61, 0x43, 0x3C, 0x37, 0xC5, 0xA3, 0x5F,
1032 0xC1, 0xF3, 0x9F, 0x40, 0x63, 0x02, 0xEB, 0x90,
1033 0x7C, 0x61, 0x63, 0xBE, 0x38, 0xC9, 0x84, 0x37
1034 };
1035 static const uint8_t packet_out_20[] = {
1036 0x74, 0xA0, 0xEB, 0xC9, 0x06, 0x9F, 0x5B, 0x37,
1037 0x58, 0x10, 0xE6, 0xFD, 0x25, 0x87, 0x40, 0x22,
1038 0xE8, 0x03, 0x61, 0xA4, 0x78, 0xE3, 0xE9, 0xCF,
1039 0x48, 0x4A, 0xB0, 0x4F, 0x44, 0x7E, 0xFF, 0xF6,
1040 0xF0, 0xA4, 0x77, 0xCC, 0x2F, 0xC9, 0xBF, 0x54,
1041 0x89, 0x44
1042 };
1043 #define clear_len_20 8
1044 #define auth_len_20 10
1045
1046 /*
1047 * =============== Packet Vector #21 ==================
1048 * AES Key = D7 82 8D 13 B2 B0 BD C3 25 A7 62 36 DF 93 CC 6B
1049 * Nonce = 00 27 CA 0C 71 20 BC 3C 96 96 76 6C FA
1050 * Total packet length = 33. [Input with 8 cleartext header octets]
1051 * 44 A3 AA 3A AE 64 75 CA A4 34 A8 E5 85 00 C6 E4
1052 * 15 30 53 88 62 D6 86 EA 9E 81 30 1B 5A E4 22 6B
1053 * FA
1054 * CBC IV in: 61 00 27 CA 0C 71 20 BC 3C 96 96 76 6C FA 00 19
1055 * CBC IV out:43 07 C0 73 A8 9E E1 D5 05 27 B2 9A 62 48 D6 D2
1056 * After xor: 43 0F 84 D0 02 A4 4F B1 70 ED B2 9A 62 48 D6 D2 [hdr]
1057 * After AES: B6 0B C6 F5 84 01 75 BC 01 27 70 F1 11 8D 75 10
1058 * After xor: 12 3F 6E 10 01 01 B3 58 14 17 23 79 73 5B F3 FA [msg]
1059 * After AES: 7D 5E 64 92 CE 2C B9 EA 7E 4C 4A 09 09 89 C8 FB
1060 * After xor: E3 DF 54 89 94 C8 9B 81 84 4C 4A 09 09 89 C8 FB [msg]
1061 * After AES: 68 5F 8D 79 D2 2B 9B 74 21 DF 4C 3E 87 BA 0A AF
1062 * CBC-MAC : 68 5F 8D 79 D2 2B 9B 74 21 DF
1063 * CTR Start: 01 00 27 CA 0C 71 20 BC 3C 96 96 76 6C FA 00 01
1064 * CTR[0001]: 56 8A 45 9E 40 09 48 67 EB 85 E0 9E 6A 2E 64 76
1065 * CTR[0002]: A6 00 AA 92 92 03 54 9A AE EF 2C CC 59 13 7A 57
1066 * CTR[MAC ]: 25 1E DC DD 3F 11 10 F3 98 11
1067 * Total packet length = 43. [Authenticated and Encrypted Output]
1068 * 44 A3 AA 3A AE 64 75 CA F2 BE ED 7B C5 09 8E 83
1069 * FE B5 B3 16 08 F8 E2 9C 38 81 9A 89 C8 E7 76 F1
1070 * 54 4D 41 51 A4 ED 3A 8B 87 B9 CE
1071 */
1072 static const uint8_t keys_21[] = {
1073 0xD7, 0x82, 0x8D, 0x13, 0xB2, 0xB0, 0xBD, 0xC3,
1074 0x25, 0xA7, 0x62, 0x36, 0xDF, 0x93, 0xCC, 0x6B
1075 };
1076 static const uint8_t nonce_21[] = {
1077 0x00, 0x27, 0xCA, 0x0C, 0x71, 0x20, 0xBC, 0x3C,
1078 0x96, 0x96, 0x76, 0x6C, 0xFA
1079 };
1080 static const uint8_t packet_in_21[] = {
1081 0x44, 0xA3, 0xAA, 0x3A, 0xAE, 0x64, 0x75, 0xCA,
1082 0xA4, 0x34, 0xA8, 0xE5, 0x85, 0x00, 0xC6, 0xE4,
1083 0x15, 0x30, 0x53, 0x88, 0x62, 0xD6, 0x86, 0xEA,
1084 0x9E, 0x81, 0x30, 0x1B, 0x5A, 0xE4, 0x22, 0x6B,
1085 0xFA
1086 };
1087 static const uint8_t packet_out_21[] = {
1088 0x44, 0xA3, 0xAA, 0x3A, 0xAE, 0x64, 0x75, 0xCA,
1089 0xF2, 0xBE, 0xED, 0x7B, 0xC5, 0x09, 0x8E, 0x83,
1090 0xFE, 0xB5, 0xB3, 0x16, 0x08, 0xF8, 0xE2, 0x9C,
1091 0x38, 0x81, 0x9A, 0x89, 0xC8, 0xE7, 0x76, 0xF1,
1092 0x54, 0x4D, 0x41, 0x51, 0xA4, 0xED, 0x3A, 0x8B,
1093 0x87, 0xB9, 0xCE
1094 };
1095 #define clear_len_21 8
1096 #define auth_len_21 10
1097
1098 /*
1099 * =============== Packet Vector #22 ==================
1100 * AES Key = D7 82 8D 13 B2 B0 BD C3 25 A7 62 36 DF 93 CC 6B
1101 * Nonce = 00 5B 8C CB CD 9A F8 3C 96 96 76 6C FA
1102 * Total packet length = 31. [Input with 12 cleartext header octets]
1103 * EC 46 BB 63 B0 25 20 C3 3C 49 FD 70 B9 6B 49 E2
1104 * 1D 62 17 41 63 28 75 DB 7F 6C 92 43 D2 D7 C2
1105 * CBC IV in: 61 00 5B 8C CB CD 9A F8 3C 96 96 76 6C FA 00 13
1106 * CBC IV out:91 14 AD 06 B6 CC 02 35 76 9A B6 14 C4 82 95 03
1107 * After xor: 91 18 41 40 0D AF B2 10 56 59 8A 5D 39 F2 95 03 [hdr]
1108 * After AES: 29 BD 7C 27 83 E3 E8 D3 C3 5C 01 F4 4C EC BB FA
1109 * After xor: 90 D6 35 C5 9E 81 FF 92 A0 74 74 2F 33 80 29 B9 [msg]
1110 * After AES: 4E DA F4 0D 21 0B D4 5F FE 97 90 B9 AA EC 34 4C
1111 * After xor: 9C 0D 36 0D 21 0B D4 5F FE 97 90 B9 AA EC 34 4C [msg]
1112 * After AES: 21 9E F8 90 EA 64 C2 11 A5 37 88 83 E1 BA 22 0D
1113 * CBC-MAC : 21 9E F8 90 EA 64 C2 11 A5 37
1114 * CTR Start: 01 00 5B 8C CB CD 9A F8 3C 96 96 76 6C FA 00 01
1115 * CTR[0001]: 88 BC 19 42 80 C1 FA 3E BE FC EF FB 4D C6 2D 54
1116 * CTR[0002]: 3E 59 7D A5 AE 21 CC A4 00 9E 4C 0C 91 F6 22 49
1117 * CTR[MAC ]: 5C BC 30 98 66 02 A9 F4 64 A0
1118 * Total packet length = 41. [Authenticated and Encrypted Output]
1119 * EC 46 BB 63 B0 25 20 C3 3C 49 FD 70 31 D7 50 A0
1120 * 9D A3 ED 7F DD D4 9A 20 32 AA BF 17 EC 8E BF 7D
1121 * 22 C8 08 8C 66 6B E5 C1 97
1122 */
1123 static const uint8_t keys_22[] = {
1124 0xD7, 0x82, 0x8D, 0x13, 0xB2, 0xB0, 0xBD, 0xC3,
1125 0x25, 0xA7, 0x62, 0x36, 0xDF, 0x93, 0xCC, 0x6B
1126 };
1127 static const uint8_t nonce_22[] = {
1128 0x00, 0x5B, 0x8C, 0xCB, 0xCD, 0x9A, 0xF8, 0x3C,
1129 0x96, 0x96, 0x76, 0x6C, 0xFA
1130 };
1131 static const uint8_t packet_in_22[] = {
1132 0xEC, 0x46, 0xBB, 0x63, 0xB0, 0x25, 0x20, 0xC3,
1133 0x3C, 0x49, 0xFD, 0x70, 0xB9, 0x6B, 0x49, 0xE2,
1134 0x1D, 0x62, 0x17, 0x41, 0x63, 0x28, 0x75, 0xDB,
1135 0x7F, 0x6C, 0x92, 0x43, 0xD2, 0xD7, 0xC2
1136 };
1137 static const uint8_t packet_out_22[] = {
1138 0xEC, 0x46, 0xBB, 0x63, 0xB0, 0x25, 0x20, 0xC3,
1139 0x3C, 0x49, 0xFD, 0x70, 0x31, 0xD7, 0x50, 0xA0,
1140 0x9D, 0xA3, 0xED, 0x7F, 0xDD, 0xD4, 0x9A, 0x20,
1141 0x32, 0xAA, 0xBF, 0x17, 0xEC, 0x8E, 0xBF, 0x7D,
1142 0x22, 0xC8, 0x08, 0x8C, 0x66, 0x6B, 0xE5, 0xC1,
1143 0x97
1144 };
1145 #define clear_len_22 12
1146 #define auth_len_22 10
1147
1148
1149 /*
1150 * =============== Packet Vector #23 ==================
1151 * AES Key = D7 82 8D 13 B2 B0 BD C3 25 A7 62 36 DF 93 CC 6B
1152 * Nonce = 00 3E BE 94 04 4B 9A 3C 96 96 76 6C FA
1153 * Total packet length = 32. [Input with 12 cleartext header octets]
1154 * 47 A6 5A C7 8B 3D 59 42 27 E8 5E 71 E2 FC FB B8
1155 * 80 44 2C 73 1B F9 51 67 C8 FF D7 89 5E 33 70 76
1156 * CBC IV in: 61 00 3E BE 94 04 4B 9A 3C 96 96 76 6C FA 00 14
1157 * CBC IV out:0F 70 3F 5A 54 2C 44 6E 8B 74 A3 73 9B 48 B9 61
1158 * After xor: 0F 7C 78 FC 0E EB CF 53 D2 36 84 9B C5 39 B9 61 [hdr]
1159 * After AES: 40 5B ED 29 D0 98 AE 91 DB 68 78 F3 68 B8 73 85
1160 * After xor: A2 A7 16 91 50 DC 82 E2 C0 91 29 94 A0 47 A4 0C [msg]
1161 * After AES: 3D 03 29 3C FD 81 1B 37 01 51 FB C7 85 6B 7A 74
1162 * After xor: 63 30 59 4A FD 81 1B 37 01 51 FB C7 85 6B 7A 74 [msg]
1163 * After AES: 66 4F 27 16 3E 36 0F 72 62 0D 4E 67 7C E0 61 DE
1164 * CBC-MAC : 66 4F 27 16 3E 36 0F 72 62 0D
1165 * CTR Start: 01 00 3E BE 94 04 4B 9A 3C 96 96 76 6C FA 00 01
1166 * CTR[0001]: 0A 7E 0A 63 53 C8 CF 9E BC 3B 6E 63 15 9A D0 97
1167 * CTR[0002]: EA 20 32 DA 27 82 6E 13 9E 1E 72 5C 5B 0D 3E BF
1168 * CTR[MAC ]: B9 31 27 CA F0 F1 A1 20 FA 70
1169 * Total packet length = 42. [Authenticated and Encrypted Output]
1170 * 47 A6 5A C7 8B 3D 59 42 27 E8 5E 71 E8 82 F1 DB
1171 * D3 8C E3 ED A7 C2 3F 04 DD 65 07 1E B4 13 42 AC
1172 * DF 7E 00 DC CE C7 AE 52 98 7D
1173 */
1174 static const uint8_t keys_23[] = {
1175 0xD7, 0x82, 0x8D, 0x13, 0xB2, 0xB0, 0xBD, 0xC3,
1176 0x25, 0xA7, 0x62, 0x36, 0xDF, 0x93, 0xCC, 0x6B
1177 };
1178 static const uint8_t nonce_23[] = {
1179 0x00, 0x3E, 0xBE, 0x94, 0x04, 0x4B, 0x9A, 0x3C,
1180 0x96, 0x96, 0x76, 0x6C, 0xFA
1181 };
1182 static const uint8_t packet_in_23[] = {
1183 0x47, 0xA6, 0x5A, 0xC7, 0x8B, 0x3D, 0x59, 0x42,
1184 0x27, 0xE8, 0x5E, 0x71, 0xE2, 0xFC, 0xFB, 0xB8,
1185 0x80, 0x44, 0x2C, 0x73, 0x1B, 0xF9, 0x51, 0x67,
1186 0xC8, 0xFF, 0xD7, 0x89, 0x5E, 0x33, 0x70, 0x76
1187 };
1188 static const uint8_t packet_out_23[] = {
1189 0x47, 0xA6, 0x5A, 0xC7, 0x8B, 0x3D, 0x59, 0x42,
1190 0x27, 0xE8, 0x5E, 0x71, 0xE8, 0x82, 0xF1, 0xDB,
1191 0xD3, 0x8C, 0xE3, 0xED, 0xA7, 0xC2, 0x3F, 0x04,
1192 0xDD, 0x65, 0x07, 0x1E, 0xB4, 0x13, 0x42, 0xAC,
1193 0xDF, 0x7E, 0x00, 0xDC, 0xCE, 0xC7, 0xAE, 0x52,
1194 0x98, 0x7D
1195 };
1196 #define clear_len_23 12
1197 #define auth_len_23 10
1198
1199 /*
1200 * =============== Packet Vector #24 ==================
1201 * AES Key = D7 82 8D 13 B2 B0 BD C3 25 A7 62 36 DF 93 CC 6B
1202 * Nonce = 00 8D 49 3B 30 AE 8B 3C 96 96 76 6C FA
1203 * Total packet length = 33. [Input with 12 cleartext header octets]
1204 * 6E 37 A6 EF 54 6D 95 5D 34 AB 60 59 AB F2 1C 0B
1205 * 02 FE B8 8F 85 6D F4 A3 73 81 BC E3 CC 12 85 17
1206 * D4
1207 * CBC IV in: 61 00 8D 49 3B 30 AE 8B 3C 96 96 76 6C FA 00 15
1208 * CBC IV out:67 AC E4 E8 06 77 7A D3 27 1D 0B 93 4C 67 98 15
1209 * After xor: 67 A0 8A DF A0 98 2E BE B2 40 3F 38 2C 3E 98 15 [hdr]
1210 * After AES: 35 58 F8 7E CA C2 B4 39 B6 7E 75 BB F1 5E 69 08
1211 * After xor: 9E AA E4 75 C8 3C 0C B6 33 13 81 18 82 DF D5 EB [msg]
1212 * After AES: 54 E4 7B 62 22 F0 BB 87 17 D0 71 6A EB AF 19 9E
1213 * After xor: 98 F6 FE 75 F6 F0 BB 87 17 D0 71 6A EB AF 19 9E [msg]
1214 * After AES: 23 E3 30 50 BC 57 DC 2C 3D 3E 7C 94 77 D1 49 71
1215 * CBC-MAC : 23 E3 30 50 BC 57 DC 2C 3D 3E
1216 * CTR Start: 01 00 8D 49 3B 30 AE 8B 3C 96 96 76 6C FA 00 01
1217 * CTR[0001]: 58 DB 19 B3 88 9A A3 8B 3C A4 0B 16 FF 42 2C 73
1218 * CTR[0002]: C3 2F 24 3D 65 DC 7E 9F 4B 02 16 AB 7F B9 6B 4D
1219 * CTR[MAC ]: 4E 2D AE D2 53 F6 B1 8A 1D 67
1220 * Total packet length = 43. [Authenticated and Encrypted Output]
1221 * 6E 37 A6 EF 54 6D 95 5D 34 AB 60 59 F3 29 05 B8
1222 * 8A 64 1B 04 B9 C9 FF B5 8C C3 90 90 0F 3D A1 2A
1223 * B1 6D CE 9E 82 EF A1 6D A6 20 59
1224 */
1225 static const uint8_t keys_24[] = {
1226 0xD7, 0x82, 0x8D, 0x13, 0xB2, 0xB0, 0xBD, 0xC3,
1227 0x25, 0xA7, 0x62, 0x36, 0xDF, 0x93, 0xCC, 0x6B
1228 };
1229 static const uint8_t nonce_24[] = {
1230 0x00, 0x8D, 0x49, 0x3B, 0x30, 0xAE, 0x8B, 0x3C,
1231 0x96, 0x96, 0x76, 0x6C, 0xFA
1232 };
1233 static const uint8_t packet_in_24[] = {
1234 0x6E, 0x37, 0xA6, 0xEF, 0x54, 0x6D, 0x95, 0x5D,
1235 0x34, 0xAB, 0x60, 0x59, 0xAB, 0xF2, 0x1C, 0x0B,
1236 0x02, 0xFE, 0xB8, 0x8F, 0x85, 0x6D, 0xF4, 0xA3,
1237 0x73, 0x81, 0xBC, 0xE3, 0xCC, 0x12, 0x85, 0x17,
1238 0xD4
1239 };
1240 static const uint8_t packet_out_24[] = {
1241 0x6E, 0x37, 0xA6, 0xEF, 0x54, 0x6D, 0x95, 0x5D,
1242 0x34, 0xAB, 0x60, 0x59, 0xF3, 0x29, 0x05, 0xB8,
1243 0x8A, 0x64, 0x1B, 0x04, 0xB9, 0xC9, 0xFF, 0xB5,
1244 0x8C, 0xC3, 0x90, 0x90, 0x0F, 0x3D, 0xA1, 0x2A,
1245 0xB1, 0x6D, 0xCE, 0x9E, 0x82, 0xEF, 0xA1, 0x6D,
1246 0xA6, 0x20, 0x59
1247 };
1248 #define clear_len_24 12
1249 #define auth_len_24 10
1250
1251 /** Additional AES-CCM-128 test vectors */
1252 static const uint8_t keys_90[] = {
1253 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
1254 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F
1255 };
1256 static const uint8_t nonce_90[] = {
1257 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16
1258 };
1259 static const uint8_t packet_in_90[] = {
1260 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1261 0x20, 0x21, 0x22, 0x23
1262 };
1263 static const uint8_t packet_out_90[] = {
1264 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1265 0x71, 0x62, 0x01, 0x5B,
1266 0x4D, 0xAC, 0x25, 0x5D
1267 };
1268 #define clear_len_90 8
1269 #define auth_len_90 4
1270
1271 static const uint8_t keys_91[] = {
1272 0xC9, 0x7C, 0x1F, 0x67, 0xCE, 0x37, 0x11, 0x85,
1273 0x51, 0x4A, 0x8A, 0x19, 0xF2, 0xBD, 0xD5, 0x2F
1274 };
1275 static const uint8_t nonce_91[] = {
1276 0x00, 0x50, 0x30, 0xF1, 0x84, 0x44, 0x08, 0xB5,
1277 0x03, 0x97, 0x76, 0xE7, 0x0C
1278 };
1279 static const uint8_t packet_in_91[] = {
1280 0x08, 0x40, 0x0F, 0xD2, 0xE1, 0x28, 0xA5, 0x7C,
1281 0x50, 0x30, 0xF1, 0x84, 0x44, 0x08, 0xAB, 0xAE,
1282 0xA5, 0xB8, 0xFC, 0xBA, 0x00, 0x00,
1283 0xF8, 0xBA, 0x1A, 0x55, 0xD0, 0x2F, 0x85, 0xAE,
1284 0x96, 0x7B, 0xB6, 0x2F, 0xB6, 0xCD, 0xA8, 0xEB,
1285 0x7E, 0x78, 0xA0, 0x50
1286 };
1287 static const uint8_t packet_out_91[] = {
1288 0x08, 0x40, 0x0F, 0xD2, 0xE1, 0x28, 0xA5, 0x7C,
1289 0x50, 0x30, 0xF1, 0x84, 0x44, 0x08, 0xAB, 0xAE,
1290 0xA5, 0xB8, 0xFC, 0xBA, 0x00, 0x00,
1291 0xF3, 0xD0, 0xA2, 0xFE, 0x9A, 0x3D, 0xBF, 0x23,
1292 0x42, 0xA6, 0x43, 0xE4, 0x32, 0x46, 0xE8, 0x0C,
1293 0x3C, 0x04, 0xD0, 0x19,
1294 0x78, 0x45, 0xCE, 0x0B, 0x16, 0xF9, 0x76, 0x23
1295 };
1296 #define clear_len_91 22
1297 #define auth_len_91 8
1298
1299
1300 static const uint8_t keys_92[] = {
1301 0xC9, 0x7C, 0x1F, 0x67, 0xCE, 0x37, 0x11, 0x85,
1302 0x51, 0x4A, 0x8A, 0x19, 0xF2, 0xBD, 0xD5, 0x2F
1303 };
1304 static const uint8_t nonce_92[] = {
1305 0x00, 0x50, 0x30, 0xF1, 0x84, 0x44, 0x08, 0xB5,
1306 0x03, 0x97, 0x76, 0xE7, 0x0C
1307 };
1308 static const uint8_t packet_in_92[] = {
1309 0xF8, 0xBA, 0x1A, 0x55, 0xD0, 0x2F, 0x85, 0xAE,
1310 0x96, 0x7B, 0xB6, 0x2F, 0xB6, 0xCD, 0xA8, 0xEB,
1311 0x7E, 0x78, 0xA0, 0x50
1312 };
1313 static const uint8_t packet_out_92[] = {
1314 0xF3, 0xD0, 0xA2, 0xFE, 0x9A, 0x3D, 0xBF, 0x23,
1315 0x42, 0xA6, 0x43, 0xE4, 0x32, 0x46, 0xE8, 0x0C,
1316 0x3C, 0x04, 0xD0, 0x19,
1317 0x41, 0x83, 0x21, 0x89, 0xA3, 0xD3, 0x1B, 0x43
1318 };
1319 #define clear_len_92 0
1320 #define auth_len_92 8
1321
1322 static const uint8_t keys_100[] = {
1323 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
1324 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F
1325 };
1326 static const uint8_t nonce_100[] = {
1327 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16
1328 };
1329 static const uint8_t packet_in_100[] = {
1330 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1331 0x20, 0x21, 0x22, 0x23,
1332 };
1333 static const uint8_t packet_out_100[] = {
1334 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1335 0x71, 0x62, 0x01, 0x5B,
1336 0xB0, 0xC9, 0x5E, 0x58, 0x03, 0x6E
1337 };
1338 #define clear_len_100 8
1339 #define auth_len_100 6
1340
1341 static const uint8_t keys_101[] = {
1342 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
1343 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F
1344 };
1345 static const uint8_t nonce_101[] = {
1346 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16
1347 };
1348 static const uint8_t packet_in_101[] = {
1349 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1350 0x20, 0x21, 0x22, 0x23,
1351 };
1352 static const uint8_t packet_out_101[] = {
1353 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1354 0x71, 0x62, 0x01, 0x5B,
1355 0xD0, 0xAD, 0x86, 0xFD, 0x33, 0xC2, 0x69, 0x86
1356 };
1357 #define clear_len_101 8
1358 #define auth_len_101 8
1359
1360 static const uint8_t keys_102[] = {
1361 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
1362 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F
1363 };
1364 static const uint8_t nonce_102[] = {
1365 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16
1366 };
1367 static const uint8_t packet_in_102[] = {
1368 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1369 0x20, 0x21, 0x22, 0x23,
1370 };
1371 static const uint8_t packet_out_102[] = {
1372 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1373 0x71, 0x62, 0x01, 0x5B,
1374 0x05, 0x12, 0xDA, 0xBF, 0xD9, 0x72, 0xA6, 0x68,
1375 0x53, 0xC1
1376 };
1377 #define clear_len_102 8
1378 #define auth_len_102 10
1379
1380 static const uint8_t keys_103[] = {
1381 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
1382 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F
1383 };
1384 static const uint8_t nonce_103[] = {
1385 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16
1386 };
1387 static const uint8_t packet_in_103[] = {
1388 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1389 0x20, 0x21, 0x22, 0x23,
1390 };
1391 static const uint8_t packet_out_103[] = {
1392 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1393 0x71, 0x62, 0x01, 0x5B,
1394 0xBA, 0x03, 0xBF, 0x8C, 0xE0, 0xD6, 0x00, 0xA4,
1395 0x48, 0x6F, 0xCC, 0xB3
1396 };
1397 #define clear_len_103 8
1398 #define auth_len_103 12
1399
1400 static const uint8_t keys_104[] = {
1401 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
1402 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F
1403 };
1404 static const uint8_t nonce_104[] = {
1405 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16
1406 };
1407 static const uint8_t packet_in_104[] = {
1408 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1409 0x20, 0x21, 0x22, 0x23,
1410 };
1411 static const uint8_t packet_out_104[] = {
1412 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1413 0x71, 0x62, 0x01, 0x5B,
1414 0x6B, 0x9B, 0xFB, 0xFE, 0xA8, 0x2C, 0x04, 0x77,
1415 0x8E, 0x67, 0xF5, 0x18, 0x46, 0xC6
1416 };
1417 #define clear_len_104 8
1418 #define auth_len_104 14
1419
1420 static const uint8_t keys_105[] = {
1421 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
1422 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F
1423 };
1424 static const uint8_t nonce_105[] = {
1425 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16
1426 };
1427 static const uint8_t packet_in_105[] = {
1428 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1429 0x20, 0x21, 0x22, 0x23,
1430 };
1431 static const uint8_t packet_out_105[] = {
1432 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1433 0x71, 0x62, 0x01, 0x5B,
1434 0x2B, 0xB5, 0x7C, 0x0A, 0xF4, 0x5E, 0x4D, 0x83,
1435 0x04, 0xF0, 0x5F, 0x45, 0x99, 0x3F, 0x15, 0x17
1436 };
1437 #define clear_len_105 8
1438 #define auth_len_105 16
1439
1440 #define CCM_TEST_VEC(num) \
1441 { keys_##num, nonce_##num, sizeof(nonce_##num), \
1442 packet_in_##num, sizeof(packet_in_##num), \
1443 clear_len_##num, packet_out_##num, \
1444 auth_len_##num }
1445
1446 static const struct ccm_rfc3610_vector {
1447 const uint8_t *keys;
1448 const uint8_t *nonce;
1449 const size_t nonce_len;
1450 /* packet in = [ AAD | plain text ] */
1451 const uint8_t *packet_in;
1452 const size_t packet_len;
1453 const size_t clear_len;
1454 /* packet out = [ AAD | cipher text | authentication tag ] */
1455 const uint8_t *packet_out;
1456 const size_t auth_len;
1457 } ccm_vectors[] = {
1458 CCM_TEST_VEC(01),
1459 CCM_TEST_VEC(02),
1460 CCM_TEST_VEC(03),
1461 CCM_TEST_VEC(04),
1462 CCM_TEST_VEC(05),
1463 CCM_TEST_VEC(06),
1464 CCM_TEST_VEC(07),
1465 CCM_TEST_VEC(08),
1466 CCM_TEST_VEC(09),
1467 CCM_TEST_VEC(10),
1468 CCM_TEST_VEC(11),
1469 CCM_TEST_VEC(12),
1470 CCM_TEST_VEC(13),
1471 CCM_TEST_VEC(14),
1472 CCM_TEST_VEC(15),
1473 CCM_TEST_VEC(16),
1474 CCM_TEST_VEC(17),
1475 CCM_TEST_VEC(18),
1476 CCM_TEST_VEC(19),
1477 CCM_TEST_VEC(20),
1478 CCM_TEST_VEC(21),
1479 CCM_TEST_VEC(22),
1480 CCM_TEST_VEC(23),
1481 CCM_TEST_VEC(24),
1482 CCM_TEST_VEC(90),
1483 CCM_TEST_VEC(91),
1484 CCM_TEST_VEC(92),
1485 CCM_TEST_VEC(100),
1486 CCM_TEST_VEC(101),
1487 CCM_TEST_VEC(102),
1488 CCM_TEST_VEC(103),
1489 CCM_TEST_VEC(104),
1490 CCM_TEST_VEC(105),
1491 };
1492
1493 #ifdef _WIN32
1494 #define snprintf _snprintf
1495 #endif
1496
1497 static void
1498 hexdump(FILE *fp,
1499 const char *msg,
1500 const void *p,
1501 size_t len)
1502 {
1503 unsigned int i, out, ofs;
1504 const unsigned char *data = p;
1505
1506 fprintf(fp, "%s\n", msg);
1507
1508 ofs = 0;
1509 while (ofs < len) {
1510 char line[120];
1511
1512 out = snprintf(line, sizeof(line), "%08x:", ofs);
1513 for (i = 0; ((ofs + i) < len) && (i < 16); i++)
1514 out += snprintf(line + out, sizeof(line) - out,
1515 " %02x", (data[ofs + i] & 0xff));
1516 for (; i <= 16; i++)
1517 out += snprintf(line + out, sizeof(line) - out, " | ");
1518 for (i = 0; (ofs < len) && (i < 16); i++, ofs++) {
1519 unsigned char c = data[ofs];
1520
1521 if ((c < ' ') || (c > '~'))
1522 c = '.';
1523 out += snprintf(line + out,
1524 sizeof(line) - out, "%c", c);
1525 }
1526 fprintf(fp, "%s\n", line);
1527 }
1528 }
1529
1530 static int
1531 ccm_job_ok(const struct ccm_rfc3610_vector *vec,
1532 const struct JOB_AES_HMAC *job,
1533 const uint8_t *target,
1534 const uint8_t *padding,
1535 const uint8_t *auth,
1536 const size_t sizeof_padding,
1537 const int dir,
1538 const int in_place)
1539 {
1540 if (job->status != STS_COMPLETED) {
1541 printf("%d Error status:%d", __LINE__, job->status);
1542 return 0;
1543 }
1544
1545 /* cipher checks */
1546 if (in_place) {
1547 if (dir == ENCRYPT) {
1548 if (memcmp(vec->packet_out, target + sizeof_padding,
1549 vec->packet_len)) {
1550 printf("cipher mismatched\n");
1551 hexdump(stderr, "Received",
1552 target + sizeof_padding,
1553 vec->packet_len);
1554 hexdump(stderr, "Expected",
1555 vec->packet_out, vec->packet_len);
1556 return 0;
1557 }
1558 } else {
1559 if (memcmp(vec->packet_in, target + sizeof_padding,
1560 vec->packet_len)) {
1561 printf("cipher mismatched\n");
1562 hexdump(stderr, "Received",
1563 target + sizeof_padding,
1564 vec->packet_len);
1565 hexdump(stderr, "Expected", vec->packet_in,
1566 vec->packet_len);
1567 return 0;
1568 }
1569 }
1570 } else { /* out-of-place */
1571 if (dir == ENCRYPT) {
1572 if (memcmp(vec->packet_out + vec->clear_len,
1573 target + sizeof_padding,
1574 vec->packet_len - vec->clear_len)) {
1575 printf("cipher mismatched\n");
1576 hexdump(stderr, "Received",
1577 target + sizeof_padding,
1578 vec->packet_len - vec->clear_len);
1579 hexdump(stderr, "Expected",
1580 vec->packet_out + vec->clear_len,
1581 vec->packet_len - vec->clear_len);
1582 return 0;
1583 }
1584 } else {
1585 if (memcmp(vec->packet_in + vec->clear_len,
1586 target + sizeof_padding,
1587 vec->packet_len - vec->clear_len)) {
1588 printf("cipher mismatched\n");
1589 hexdump(stderr, "Received",
1590 target + sizeof_padding,
1591 vec->packet_len - vec->clear_len);
1592 hexdump(stderr, "Expected",
1593 vec->packet_in + vec->clear_len,
1594 vec->packet_len - vec->clear_len);
1595 return 0;
1596 }
1597 }
1598 }
1599
1600 if (memcmp(padding, target, sizeof_padding)) {
1601 printf("cipher overwrite head\n");
1602 hexdump(stderr, "Target", target, sizeof(padding));
1603 return 0;
1604 }
1605
1606 if (in_place) {
1607 if (memcmp(padding, target + sizeof_padding + vec->packet_len,
1608 sizeof_padding)) {
1609 printf("cipher overwrite tail\n");
1610 hexdump(stderr, "Target",
1611 target + sizeof_padding + vec->packet_len,
1612 sizeof_padding);
1613 return 0;
1614 }
1615 } else {
1616 if (memcmp(padding, target + sizeof_padding + vec->packet_len -
1617 vec->clear_len, sizeof_padding)) {
1618 printf("cipher overwrite tail\n");
1619 hexdump(stderr, "Target", target + sizeof_padding +
1620 vec->packet_len - vec->clear_len,
1621 sizeof_padding);
1622 return 0;
1623 }
1624 }
1625
1626 /* hash checks */
1627 if (memcmp(padding, &auth[sizeof_padding + vec->auth_len],
1628 sizeof_padding)) {
1629 printf("hash overwrite tail\n");
1630 hexdump(stderr, "Target",
1631 &auth[sizeof_padding + vec->auth_len], sizeof_padding);
1632 return 0;
1633 }
1634
1635 if (memcmp(padding, &auth[0], sizeof_padding)) {
1636 printf("hash overwrite head\n");
1637 hexdump(stderr, "Target", &auth[0], sizeof_padding);
1638 return 0;
1639 }
1640
1641 if (memcmp(vec->packet_out + vec->packet_len, &auth[sizeof_padding],
1642 vec->auth_len)) {
1643 printf("hash mismatched\n");
1644 hexdump(stderr, "Received", &auth[sizeof_padding],
1645 vec->auth_len);
1646 hexdump(stderr, "Expected", vec->packet_out + vec->packet_len,
1647 vec->auth_len);
1648 return 0;
1649 }
1650 return 1;
1651 }
1652
1653 static int
1654 test_ccm(struct MB_MGR *mb_mgr,
1655 const struct ccm_rfc3610_vector *vec,
1656 const int dir, const int in_place, const int num_jobs)
1657 {
1658 DECLARE_ALIGNED(uint32_t expkey[4*15], 16);
1659 DECLARE_ALIGNED(uint32_t dust[4*15], 16);
1660 struct JOB_AES_HMAC *job;
1661 uint8_t padding[16];
1662 uint8_t **targets = malloc(num_jobs * sizeof(void *));
1663 uint8_t **auths = malloc(num_jobs * sizeof(void *));
1664 int i = 0, jobs_rx = 0, ret = -1;
1665 const int order = (dir == ENCRYPT) ? CIPHER_HASH : HASH_CIPHER;
1666
1667 if (targets == NULL || auths == NULL) {
1668 fprintf(stderr, "Can't allocate buffer memory\n");
1669 goto end2;
1670 }
1671
1672 memset(padding, -1, sizeof(padding));
1673 memset(targets, 0, num_jobs * sizeof(void *));
1674 memset(auths, 0, num_jobs * sizeof(void *));
1675
1676 for (i = 0; i < num_jobs; i++) {
1677 targets[i] = malloc(vec->packet_len + (sizeof(padding) * 2));
1678 auths[i] = malloc(16 + (sizeof(padding) * 2));
1679 if (targets[i] == NULL || auths[i] == NULL) {
1680 fprintf(stderr, "Can't allocate buffer memory\n");
1681 goto end;
1682 }
1683
1684 memset(targets[i], -1, vec->packet_len + (sizeof(padding) * 2));
1685 memset(auths[i], -1, 16 + (sizeof(padding) * 2));
1686
1687 if (in_place) {
1688 if (dir == ENCRYPT)
1689 memcpy(targets[i] + sizeof(padding),
1690 vec->packet_in, vec->packet_len);
1691 else
1692 memcpy(targets[i] + sizeof(padding),
1693 vec->packet_out, vec->packet_len);
1694 }
1695 }
1696
1697 IMB_AES_KEYEXP_128(mb_mgr, vec->keys, expkey, dust);
1698
1699 while ((job = IMB_FLUSH_JOB(mb_mgr)) != NULL)
1700 ;
1701
1702 for (i = 0; i < num_jobs; i++) {
1703 job = IMB_GET_NEXT_JOB(mb_mgr);
1704 job->cipher_direction = dir;
1705 job->chain_order = order;
1706 if (in_place) {
1707 job->dst =
1708 targets[i] + sizeof(padding) + vec->clear_len;
1709 job->src = targets[i] + sizeof(padding);
1710 } else {
1711 if (dir == ENCRYPT) {
1712 job->dst = targets[i] + sizeof(padding);
1713 job->src = vec->packet_in;
1714 } else {
1715 job->dst = targets[i] + sizeof(padding);
1716 job->src = vec->packet_out;
1717 }
1718 }
1719 job->cipher_mode = CCM;
1720 job->aes_enc_key_expanded = expkey;
1721 job->aes_dec_key_expanded = expkey;
1722 job->aes_key_len_in_bytes = 16; /* AES-CCM-128 for now */
1723 job->iv = vec->nonce;
1724 job->iv_len_in_bytes = vec->nonce_len;
1725 job->cipher_start_src_offset_in_bytes = vec->clear_len;
1726 job->msg_len_to_cipher_in_bytes =
1727 vec->packet_len - vec->clear_len;
1728
1729 job->hash_alg = AES_CCM;
1730 job->hash_start_src_offset_in_bytes = vec->clear_len;
1731 job->msg_len_to_hash_in_bytes =
1732 vec->packet_len - vec->clear_len;
1733 job->auth_tag_output = auths[i] + sizeof(padding);
1734 job->auth_tag_output_len_in_bytes = vec->auth_len;
1735
1736 job->u.CCM.aad_len_in_bytes = vec->clear_len;
1737 job->u.CCM.aad = job->src;
1738
1739 job->user_data = targets[i];
1740 job->user_data2 = auths[i];
1741
1742 job = IMB_SUBMIT_JOB(mb_mgr);
1743 if (job) {
1744 jobs_rx++;
1745 if (num_jobs < 4) {
1746 printf("%d Unexpected return from submit_job\n",
1747 __LINE__);
1748 goto end;
1749 }
1750 if (!ccm_job_ok(vec, job, job->user_data, padding,
1751 job->user_data2, sizeof(padding),
1752 dir, in_place))
1753 goto end;
1754 }
1755 }
1756
1757 while ((job = IMB_FLUSH_JOB(mb_mgr)) != NULL) {
1758 jobs_rx++;
1759
1760 if (!ccm_job_ok(vec, job, job->user_data, padding,
1761 job->user_data2, sizeof(padding), dir,
1762 in_place))
1763 goto end;
1764 }
1765
1766 if (jobs_rx != num_jobs) {
1767 printf("Expected %d jobs, received %d\n", num_jobs, jobs_rx);
1768 goto end;
1769 }
1770 ret = 0;
1771
1772 end:
1773 for (i = 0; i < num_jobs; i++) {
1774 if (targets[i] != NULL)
1775 free(targets[i]);
1776 if (auths[i] != NULL)
1777 free(auths[i]);
1778 }
1779
1780 end2:
1781 if (targets != NULL)
1782 free(targets);
1783
1784 if (auths != NULL)
1785 free(auths);
1786
1787 return ret;
1788 }
1789
1790 static int
1791 test_ccm_std_vectors(struct MB_MGR *mb_mgr, const int num_jobs)
1792 {
1793 const int vectors_cnt = sizeof(ccm_vectors) / sizeof(ccm_vectors[0]);
1794 int vect;
1795 int errors = 0;
1796
1797 printf("AES-CCM standard test vectors (N jobs = %d):\n", num_jobs);
1798 for (vect = 1; vect <= vectors_cnt; vect++) {
1799 const int idx = vect - 1;
1800 #ifdef DEBUG
1801 printf("Standard vector [%d/%d] NONCELen:%d PktLen:%d "
1802 "AADLen:%d AUTHlen:%d\n",
1803 vect, vectors_cnt,
1804 (int) ccm_vectors[idx].nonce_len,
1805 (int) ccm_vectors[idx].packet_len,
1806 (int) ccm_vectors[idx].clear_len,
1807 (int) ccm_vectors[idx].auth_len);
1808 #else
1809 printf(".");
1810 #endif
1811
1812 if (test_ccm(mb_mgr, &ccm_vectors[idx], ENCRYPT, 1, num_jobs)) {
1813 printf("error #%d encrypt in-place\n", vect);
1814 errors++;
1815 }
1816
1817 if (test_ccm(mb_mgr, &ccm_vectors[idx], DECRYPT, 1, num_jobs)) {
1818 printf("error #%d decrypt in-place\n", vect);
1819 errors++;
1820 }
1821
1822 if (test_ccm(mb_mgr, &ccm_vectors[idx], ENCRYPT, 0, num_jobs)) {
1823 printf("error #%d encrypt out-of-place\n", vect);
1824 errors++;
1825 }
1826
1827 if (test_ccm(mb_mgr, &ccm_vectors[idx], DECRYPT, 0, num_jobs)) {
1828 printf("error #%d decrypt out-of-place\n", vect);
1829 errors++;
1830 }
1831 }
1832 printf("\n");
1833 return errors;
1834 }
1835
1836 int
1837 ccm_test(const enum arch_type arch,
1838 struct MB_MGR *mb_mgr)
1839 {
1840 int errors = 0;
1841
1842 (void) arch; /* unused */
1843
1844 errors += test_ccm_std_vectors(mb_mgr, 1);
1845 errors += test_ccm_std_vectors(mb_mgr, 3);
1846 errors += test_ccm_std_vectors(mb_mgr, 4);
1847 errors += test_ccm_std_vectors(mb_mgr, 5);
1848 errors += test_ccm_std_vectors(mb_mgr, 7);
1849 errors += test_ccm_std_vectors(mb_mgr, 8);
1850 errors += test_ccm_std_vectors(mb_mgr, 9);
1851
1852 if (0 == errors)
1853 printf("...Pass\n");
1854 else
1855 printf("...Fail\n");
1856
1857 return errors;
1858 }
Ceph