]> git.proxmox.com Git - ceph.git/blame - ceph/src/spdk/intel-ipsec-mb/LibTestApp/ccm_test.c
projects / ceph.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
import 15.2.0 Octopus source
[ceph.git] / ceph / src / spdk / intel-ipsec-mb / LibTestApp / ccm_test.c
CommitLineData
11fdf7f2
TL		 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"
9f95a23c 35#include "utils.h"
11fdf7f2
TL		 36
37int ccm_test(const enum arch_type arch, struct MB_MGR *mb_mgr);
38
39/*
40 * Test vectors from https://tools.ietf.org/html/rfc3610
41 */
42
43/*
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
67 */
68static const uint8_t keys_01[] = {
69 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
70 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF
71};
72static const uint8_t nonce_01[] = {
73 0x00, 0x00, 0x00, 0x03, 0x02, 0x01, 0x00, 0xA0,
74 0xA1, 0xA2, 0xA3, 0xA4, 0xA5
75};
76static 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
81};
82static 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
88};
89#define clear_len_01 8
90#define auth_len_01 8
91
92/*
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
116 */
117static const uint8_t keys_02[] = {
118 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
119 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF
120};
121static const uint8_t nonce_02[] = {
122 0x00, 0x00, 0x00, 0x04, 0x03, 0x02, 0x01, 0xA0,
123 0xA1, 0xA2, 0xA3, 0xA4, 0xA5
124};
125static 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
130};
131static 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
137};
138#define clear_len_02 8
139#define auth_len_02 8
140
141/*
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
148 * 20
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
166 */
167static const uint8_t keys_03[] = {
168 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
169 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF
170};
171static const uint8_t nonce_03[] = {
172 0x00, 0x00, 0x00, 0x05, 0x04, 0x03, 0x02, 0xA0,
173 0xA1, 0xA2, 0xA3, 0xA4, 0xA5
174};
175static 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,
180 0x20
181};
182static 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,
188 0xC5
189};
190#define clear_len_03 8
191#define auth_len_03 8
192
193/*
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
217 */
218static const uint8_t keys_04[] = {
219 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
220 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF
221};
222static const uint8_t nonce_04[] = {
223 0x00, 0x00, 0x00, 0x06, 0x05, 0x04, 0x03, 0xA0,
224 0xA1, 0xA2, 0xA3, 0xA4, 0xA5
225};
226static 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
231};
232static 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
238};
239#define clear_len_04 12
240#define auth_len_04 8
241
242/*
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
266 */
267static const uint8_t keys_05[] = {
268 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
269 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF
270};
271static const uint8_t nonce_05[] = {
272 0x00, 0x00, 0x00, 0x07, 0x06, 0x05, 0x04, 0xA0,
273 0xA1, 0xA2, 0xA3, 0xA4, 0xA5
274};
275static 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
280};
281static 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
287};
288#define clear_len_05 12
289#define auth_len_05 8
290
291/*
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
298 * 20
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
316 */
317static const uint8_t keys_06[] = {
318 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
319 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF
320};
321static const uint8_t nonce_06[] = {
322 0x00, 0x00, 0x00, 0x08, 0x07, 0x06, 0x05, 0xA0,
323 0xA1, 0xA2, 0xA3, 0xA4, 0xA5
324};
325static 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,
330 0x20
331};
332static 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,
338 0x94
339};
340#define clear_len_06 12
341#define auth_len_06 8
342
343/*
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
367 */
368static const uint8_t keys_07[] = {
369 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
370 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF
371};
372static const uint8_t nonce_07[] = {
373 0x00, 0x00, 0x00, 0x09, 0x08, 0x07, 0x06, 0xA0,
374 0xA1, 0xA2, 0xA3, 0xA4, 0xA5
375};
376static 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
381};
382static 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,
388 0x90
389};
390#define clear_len_07 8
391#define auth_len_07 10
392
393/*
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
417 */
418static const uint8_t keys_08[] = {
419 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
420 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF
421};
422static const uint8_t nonce_08[] = {
423 0x00, 0x00, 0x00, 0x0a, 0x09, 0x08, 0x07, 0xA0,
424 0xA1, 0xA2, 0xA3, 0xA4, 0xA5
425};
426static 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
431};
432static 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,
438 0x34, 0xB4
439};
440#define clear_len_08 8
441#define auth_len_08 10
442
443/*
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
450 * 20
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
468 */
469static const uint8_t keys_09[] = {
470 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
471 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF
472};
473static const uint8_t nonce_09[] = {
474 0x00, 0x00, 0x00, 0x0b, 0x0a, 0x09, 0x08, 0xA0,
475 0xA1, 0xA2, 0xA3, 0xA4, 0xA5
476};
477static 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,
482 0x20
483};
484static 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,
490 0x7E, 0x5F, 0x4E
491};
492#define clear_len_09 8
493#define auth_len_09 10
494
495/*
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
519 */
520static const uint8_t keys_10[] = {
521 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
522 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF
523};
524static const uint8_t nonce_10[] = {
525 0x00, 0x00, 0x00, 0x0c, 0x0b, 0x0a, 0x09, 0xA0,
526 0xA1, 0xA2, 0xA3, 0xA4, 0xA5
527};
528static 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
533};
534static 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,
540 0xDD
541};
542#define clear_len_10 12
543#define auth_len_10 10
544
545/*
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
569 */
570static const uint8_t keys_11[] = {
571 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
572 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF
573};
574static const uint8_t nonce_11[] = {
575 0x00, 0x00, 0x00, 0x0d, 0x0c, 0x0b, 0x0a, 0xA0,
576 0xA1, 0xA2, 0xA3, 0xA4, 0xA5
577};
578static 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
583};
584static 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,
590 0x02, 0x2C
591};
592#define clear_len_11 12
593#define auth_len_11 10
594
595/*
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
602 * 20
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
620 */
621static const uint8_t keys_12[] = {
622 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
623 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF
624};
625static const uint8_t nonce_12[] = {
626 0x00, 0x00, 0x00, 0x0e, 0x0d, 0x0c, 0x0b, 0xA0,
627 0xA1, 0xA2, 0xA3, 0xA4, 0xA5
628};
629static 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,
634 0x20
635};
636static 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,
642 0x65, 0xD6, 0xDB
643};
644#define clear_len_12 12
645#define auth_len_12 10
646
647/*
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
671 */
672static const uint8_t keys_13[] = {
673 0xD7, 0x82, 0x8D, 0x13, 0xB2, 0xB0, 0xBD, 0xC3,
674 0x25, 0xA7, 0x62, 0x36, 0xDF, 0x93, 0xCC, 0x6B
675};
676static const uint8_t nonce_13[] = {
677 0x00, 0x41, 0x2b, 0x4e, 0xa9, 0xcd, 0xbe, 0x3c,
678 0x96, 0x96, 0x76, 0x6c, 0xfa
679};
680static 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
685};
686static 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
692};
693#define clear_len_13 8
694#define auth_len_13 8
695
696/*
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
720 */
721static const uint8_t keys_14[] = {
722 0xD7, 0x82, 0x8D, 0x13, 0xB2, 0xB0, 0xBD, 0xC3,
723 0x25, 0xA7, 0x62, 0x36, 0xDF, 0x93, 0xCC, 0x6B
724};
725static const uint8_t nonce_14[] = {
726 0x00, 0x33, 0x56, 0x8E, 0xF7, 0xB2, 0x63, 0x3C,
727 0x96, 0x96, 0x76, 0x6C, 0xFA
728};
729static 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,
734};
735static 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
741};
742#define clear_len_14 8
743#define auth_len_14 8
744
745/*
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
752 * 2E
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
770 */
771static const uint8_t keys_15[] = {
772 0xD7, 0x82, 0x8D, 0x13, 0xB2, 0xB0, 0xBD, 0xC3,
773 0x25, 0xA7, 0x62, 0x36, 0xDF, 0x93, 0xCC, 0x6B
774};
775static const uint8_t nonce_15[] = {
776 0x00, 0x10, 0x3F, 0xE4, 0x13, 0x36, 0x71, 0x3C,
777 0x96, 0x96, 0x76, 0x6C, 0xFA
778};
779static 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,
784 0x2E
785};
786static 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,
792 0x06
793};
794#define clear_len_15 8
795#define auth_len_15 8
796
797/*
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
821 */
822static const uint8_t keys_16[] = {
823 0xD7, 0x82, 0x8D, 0x13, 0xB2, 0xB0, 0xBD, 0xC3,
824 0x25, 0xA7, 0x62, 0x36, 0xDF, 0x93, 0xCC, 0x6B
825};
826static const uint8_t nonce_16[] = {
827 0x00, 0x76, 0x4C, 0x63, 0xB8, 0x05, 0x8E, 0x3C,
828 0x96, 0x96, 0x76, 0x6C, 0xFA
829};
830static 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
835};
836static 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
842};
843#define clear_len_16 12
844#define auth_len_16 8
845
846/*
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
870 */
871static const uint8_t keys_17[] = {
872 0xD7, 0x82, 0x8D, 0x13, 0xB2, 0xB0, 0xBD, 0xC3,
873 0x25, 0xA7, 0x62, 0x36, 0xDF, 0x93, 0xCC, 0x6B
874};
875static const uint8_t nonce_17[] = {
876 0x00, 0xF8, 0xB6, 0x78, 0x09, 0x4E, 0x3B, 0x3C,
877 0x96, 0x96, 0x76, 0x6C, 0xFA
878};
879static 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
884};
885static 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
891};
892#define clear_len_17 12
893#define auth_len_17 8
894
895/*
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
902 * 7F
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
920 */
921static const uint8_t keys_18[] = {
922 0xD7, 0x82, 0x8D, 0x13, 0xB2, 0xB0, 0xBD, 0xC3,
923 0x25, 0xA7, 0x62, 0x36, 0xDF, 0x93, 0xCC, 0x6B
924};
925static const uint8_t nonce_18[] = {
926 0x00, 0xD5, 0x60, 0x91, 0x2D, 0x3F, 0x70, 0x3C,
927 0x96, 0x96, 0x76, 0x6C, 0xFA
928};
929static 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,
934 0x7F
935};
936static 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,
942 0x51
943};
944#define clear_len_18 12
945#define auth_len_18 8
946
947/*
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
971 */
972static const uint8_t keys_19[] = {
973 0xD7, 0x82, 0x8D, 0x13, 0xB2, 0xB0, 0xBD, 0xC3,
974 0x25, 0xA7, 0x62, 0x36, 0xDF, 0x93, 0xCC, 0x6B
975};
976static const uint8_t nonce_19[] = {
977 0x00, 0x42, 0xFF, 0xF8, 0xF1, 0x95, 0x1C, 0x3C,
978 0x96, 0x96, 0x76, 0x6C, 0xFA
979};
980static 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
985};
986static 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,
992 0xBA
993};
994#define clear_len_19 8
995#define auth_len_19 10
996
997/*
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
1021 */
1022static const uint8_t keys_20[] = {
1023 0xD7, 0x82, 0x8D, 0x13, 0xB2, 0xB0, 0xBD, 0xC3,
1024 0x25, 0xA7, 0x62, 0x36, 0xDF, 0x93, 0xCC, 0x6B
1025};
1026static const uint8_t nonce_20[] = {
1027 0x00, 0x92, 0x0F, 0x40, 0xE5, 0x6C, 0xDC, 0x3C,
1028 0x96, 0x96, 0x76, 0x6C, 0xFA
1029};
1030static 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
1035};
1036static 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,
1042 0x89, 0x44
1043};
1044#define clear_len_20 8
1045#define auth_len_20 10
1046
1047/*
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
1054 * FA
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
1072 */
1073static const uint8_t keys_21[] = {
1074 0xD7, 0x82, 0x8D, 0x13, 0xB2, 0xB0, 0xBD, 0xC3,
1075 0x25, 0xA7, 0x62, 0x36, 0xDF, 0x93, 0xCC, 0x6B
1076};
1077static const uint8_t nonce_21[] = {
1078 0x00, 0x27, 0xCA, 0x0C, 0x71, 0x20, 0xBC, 0x3C,
1079 0x96, 0x96, 0x76, 0x6C, 0xFA
1080};
1081static 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,
1086 0xFA
1087};
1088static 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,
1094 0x87, 0xB9, 0xCE
1095};
1096#define clear_len_21 8
1097#define auth_len_21 10
1098
1099/*
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
1123 */
1124static const uint8_t keys_22[] = {
1125 0xD7, 0x82, 0x8D, 0x13, 0xB2, 0xB0, 0xBD, 0xC3,
1126 0x25, 0xA7, 0x62, 0x36, 0xDF, 0x93, 0xCC, 0x6B
1127};
1128static const uint8_t nonce_22[] = {
1129 0x00, 0x5B, 0x8C, 0xCB, 0xCD, 0x9A, 0xF8, 0x3C,
1130 0x96, 0x96, 0x76, 0x6C, 0xFA
1131};
1132static 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
1137};
1138static 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,
1144 0x97
1145};
1146#define clear_len_22 12
1147#define auth_len_22 10
1148
1149
1150/*
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
1174 */
1175static const uint8_t keys_23[] = {
1176 0xD7, 0x82, 0x8D, 0x13, 0xB2, 0xB0, 0xBD, 0xC3,
1177 0x25, 0xA7, 0x62, 0x36, 0xDF, 0x93, 0xCC, 0x6B
1178};
1179static const uint8_t nonce_23[] = {
1180 0x00, 0x3E, 0xBE, 0x94, 0x04, 0x4B, 0x9A, 0x3C,
1181 0x96, 0x96, 0x76, 0x6C, 0xFA
1182};
1183static 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
1188};
1189static 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,
1195 0x98, 0x7D
1196};
1197#define clear_len_23 12
1198#define auth_len_23 10
1199
1200/*
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
1207 * D4
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
1225 */
1226static const uint8_t keys_24[] = {
1227 0xD7, 0x82, 0x8D, 0x13, 0xB2, 0xB0, 0xBD, 0xC3,
1228 0x25, 0xA7, 0x62, 0x36, 0xDF, 0x93, 0xCC, 0x6B
1229};
1230static const uint8_t nonce_24[] = {
1231 0x00, 0x8D, 0x49, 0x3B, 0x30, 0xAE, 0x8B, 0x3C,
1232 0x96, 0x96, 0x76, 0x6C, 0xFA
1233};
1234static 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,
1239 0xD4
1240};
1241static 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,
1247 0xA6, 0x20, 0x59
1248};
1249#define clear_len_24 12
1250#define auth_len_24 10
1251
1252/** Additional AES-CCM-128 test vectors */
1253static const uint8_t keys_90[] = {
1254 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
1255 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F
1256};
1257static const uint8_t nonce_90[] = {
1258 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16
1259};
1260static const uint8_t packet_in_90[] = {
1261 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1262 0x20, 0x21, 0x22, 0x23
1263};
1264static 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
1268};
1269#define clear_len_90 8
1270#define auth_len_90 4
1271
1272static const uint8_t keys_91[] = {
1273 0xC9, 0x7C, 0x1F, 0x67, 0xCE, 0x37, 0x11, 0x85,
1274 0x51, 0x4A, 0x8A, 0x19, 0xF2, 0xBD, 0xD5, 0x2F
1275};
1276static const uint8_t nonce_91[] = {
1277 0x00, 0x50, 0x30, 0xF1, 0x84, 0x44, 0x08, 0xB5,
1278 0x03, 0x97, 0x76, 0xE7, 0x0C
1279};
1280static 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
1287};
1288static 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
1296};
1297#define clear_len_91 22
1298#define auth_len_91 8
1299
1300
1301static const uint8_t keys_92[] = {
1302 0xC9, 0x7C, 0x1F, 0x67, 0xCE, 0x37, 0x11, 0x85,
1303 0x51, 0x4A, 0x8A, 0x19, 0xF2, 0xBD, 0xD5, 0x2F
1304};
1305static const uint8_t nonce_92[] = {
1306 0x00, 0x50, 0x30, 0xF1, 0x84, 0x44, 0x08, 0xB5,
1307 0x03, 0x97, 0x76, 0xE7, 0x0C
1308};
1309static 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
1313};
1314static 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
1319};
1320#define clear_len_92 0
1321#define auth_len_92 8
1322
1323static const uint8_t keys_100[] = {
1324 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
1325 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F
1326};
1327static const uint8_t nonce_100[] = {
1328 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16
1329};
1330static const uint8_t packet_in_100[] = {
1331 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1332 0x20, 0x21, 0x22, 0x23,
1333};
1334static 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
1338};
1339#define clear_len_100 8
1340#define auth_len_100 6
1341
1342static const uint8_t keys_101[] = {
1343 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
1344 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F
1345};
1346static const uint8_t nonce_101[] = {
1347 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16
1348};
1349static const uint8_t packet_in_101[] = {
1350 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1351 0x20, 0x21, 0x22, 0x23,
1352};
1353static 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
1357};
1358#define clear_len_101 8
1359#define auth_len_101 8
1360
1361static const uint8_t keys_102[] = {
1362 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
1363 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F
1364};
1365static const uint8_t nonce_102[] = {
1366 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16
1367};
1368static const uint8_t packet_in_102[] = {
1369 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1370 0x20, 0x21, 0x22, 0x23,
1371};
1372static 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,
1376 0x53, 0xC1
1377};
1378#define clear_len_102 8
1379#define auth_len_102 10
1380
1381static const uint8_t keys_103[] = {
1382 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
1383 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F
1384};
1385static const uint8_t nonce_103[] = {
1386 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16
1387};
1388static const uint8_t packet_in_103[] = {
1389 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1390 0x20, 0x21, 0x22, 0x23,
1391};
1392static 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
1397};
1398#define clear_len_103 8
1399#define auth_len_103 12
1400
1401static const uint8_t keys_104[] = {
1402 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
1403 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F
1404};
1405static const uint8_t nonce_104[] = {
1406 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16
1407};
1408static const uint8_t packet_in_104[] = {
1409 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1410 0x20, 0x21, 0x22, 0x23,
1411};
1412static 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
1417};
1418#define clear_len_104 8
1419#define auth_len_104 14
1420
1421static const uint8_t keys_105[] = {
1422 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
1423 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F
1424};
1425static const uint8_t nonce_105[] = {
1426 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16
1427};
1428static const uint8_t packet_in_105[] = {
1429 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1430 0x20, 0x21, 0x22, 0x23,
1431};
1432static 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
1437};
1438#define clear_len_105 8
1439#define auth_len_105 16
1440
9f95a23c
TL		 1441static const uint8_t keys_106[] = {
1442 0x4a, 0xe7, 0x01, 0x10, 0x3c, 0x63, 0xde, 0xca,
1443 0x5b, 0x5a, 0x39, 0x39, 0xd7, 0xd0, 0x59, 0x92
1444};
1445static const uint8_t nonce_106[] = {
1446 0x5a, 0x8a, 0xa4, 0x85, 0xc3, 0x16, 0xe9
1447};
1448static const uint8_t packet_out_106[] = {
1449 0x02, 0x20, 0x9f, 0x55
1450};
1451#define clear_len_106 0
1452#define auth_len_106 4
1453
11fdf7f2
TL		 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, \
1458 auth_len_##num }
9f95a23c
TL		 1459#define CCM_TEST_VEC_2(num) \
1460 { keys_##num, nonce_##num, sizeof(nonce_##num), \
1461 NULL, 0, \
1462 clear_len_##num, packet_out_##num, \
1463 auth_len_##num }
11fdf7f2
TL		 1464
1465static 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;
1476} ccm_vectors[] = {
1477 CCM_TEST_VEC(01),
1478 CCM_TEST_VEC(02),
1479 CCM_TEST_VEC(03),
1480 CCM_TEST_VEC(04),
1481 CCM_TEST_VEC(05),
1482 CCM_TEST_VEC(06),
1483 CCM_TEST_VEC(07),
1484 CCM_TEST_VEC(08),
1485 CCM_TEST_VEC(09),
1486 CCM_TEST_VEC(10),
1487 CCM_TEST_VEC(11),
1488 CCM_TEST_VEC(12),
1489 CCM_TEST_VEC(13),
1490 CCM_TEST_VEC(14),
1491 CCM_TEST_VEC(15),
1492 CCM_TEST_VEC(16),
1493 CCM_TEST_VEC(17),
1494 CCM_TEST_VEC(18),
1495 CCM_TEST_VEC(19),
1496 CCM_TEST_VEC(20),
1497 CCM_TEST_VEC(21),
1498 CCM_TEST_VEC(22),
1499 CCM_TEST_VEC(23),
1500 CCM_TEST_VEC(24),
1501 CCM_TEST_VEC(90),
1502 CCM_TEST_VEC(91),
1503 CCM_TEST_VEC(92),
1504 CCM_TEST_VEC(100),
1505 CCM_TEST_VEC(101),
1506 CCM_TEST_VEC(102),
1507 CCM_TEST_VEC(103),
1508 CCM_TEST_VEC(104),
1509 CCM_TEST_VEC(105),
9f95a23c 1510 CCM_TEST_VEC_2(106),
11fdf7f2
TL		 1511};
1512
11fdf7f2
TL		 1513static int
1514ccm_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,
1520 const int dir,
1521 const int in_place)
1522{
1523 if (job->status != STS_COMPLETED) {
1524 printf("%d Error status:%d", __LINE__, job->status);
1525 return 0;
1526 }
1527
1528 /* cipher checks */
1529 if (in_place) {
1530 if (dir == ENCRYPT) {
1531 if (memcmp(vec->packet_out, target + sizeof_padding,
1532 vec->packet_len)) {
1533 printf("cipher mismatched\n");
1534 hexdump(stderr, "Received",
1535 target + sizeof_padding,
1536 vec->packet_len);
1537 hexdump(stderr, "Expected",
1538 vec->packet_out, vec->packet_len);
1539 return 0;
1540 }
1541 } else {
1542 if (memcmp(vec->packet_in, target + sizeof_padding,
1543 vec->packet_len)) {
1544 printf("cipher mismatched\n");
1545 hexdump(stderr, "Received",
1546 target + sizeof_padding,
1547 vec->packet_len);
1548 hexdump(stderr, "Expected", vec->packet_in,
1549 vec->packet_len);
1550 return 0;
1551 }
1552 }
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);
1565 return 0;
1566 }
1567 } else {
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);
1578 return 0;
1579 }
1580 }
1581 }
1582
1583 if (memcmp(padding, target, sizeof_padding)) {
1584 printf("cipher overwrite head\n");
1585 hexdump(stderr, "Target", target, sizeof(padding));
1586 return 0;
1587 }
1588
1589 if (in_place) {
1590 if (memcmp(padding, target + sizeof_padding + vec->packet_len,
1591 sizeof_padding)) {
1592 printf("cipher overwrite tail\n");
1593 hexdump(stderr, "Target",
1594 target + sizeof_padding + vec->packet_len,
1595 sizeof_padding);
1596 return 0;
1597 }
1598 } else {
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,
1604 sizeof_padding);
1605 return 0;
1606 }
1607 }
1608
1609 /* hash checks */
1610 if (memcmp(padding, &auth[sizeof_padding + vec->auth_len],
1611 sizeof_padding)) {
1612 printf("hash overwrite tail\n");
1613 hexdump(stderr, "Target",
1614 &auth[sizeof_padding + vec->auth_len], sizeof_padding);
1615 return 0;
1616 }
1617
1618 if (memcmp(padding, &auth[0], sizeof_padding)) {
1619 printf("hash overwrite head\n");
1620 hexdump(stderr, "Target", &auth[0], sizeof_padding);
1621 return 0;
1622 }
1623
1624 if (memcmp(vec->packet_out + vec->packet_len, &auth[sizeof_padding],
1625 vec->auth_len)) {
1626 printf("hash mismatched\n");
1627 hexdump(stderr, "Received", &auth[sizeof_padding],
1628 vec->auth_len);
1629 hexdump(stderr, "Expected", vec->packet_out + vec->packet_len,
1630 vec->auth_len);
1631 return 0;
1632 }
1633 return 1;
1634}
1635
1636static int
1637test_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)
1640{
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;
1649
1650 if (targets == NULL || auths == NULL) {
1651 fprintf(stderr, "Can't allocate buffer memory\n");
1652 goto end2;
1653 }
1654
1655 memset(padding, -1, sizeof(padding));
1656 memset(targets, 0, num_jobs * sizeof(void *));
1657 memset(auths, 0, num_jobs * sizeof(void *));
1658
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");
1664 goto end;
1665 }
1666
1667 memset(targets[i], -1, vec->packet_len + (sizeof(padding) * 2));
1668 memset(auths[i], -1, 16 + (sizeof(padding) * 2));
1669
1670 if (in_place) {
1671 if (dir == ENCRYPT)
1672 memcpy(targets[i] + sizeof(padding),
1673 vec->packet_in, vec->packet_len);
1674 else
1675 memcpy(targets[i] + sizeof(padding),
1676 vec->packet_out, vec->packet_len);
1677 }
1678 }
1679
1680 IMB_AES_KEYEXP_128(mb_mgr, vec->keys, expkey, dust);
1681
1682 while ((job = IMB_FLUSH_JOB(mb_mgr)) != NULL)
1683 ;
1684
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;
1689 if (in_place) {
1690 job->dst =
1691 targets[i] + sizeof(padding) + vec->clear_len;
1692 job->src = targets[i] + sizeof(padding);
1693 } else {
1694 if (dir == ENCRYPT) {
1695 job->dst = targets[i] + sizeof(padding);
1696 job->src = vec->packet_in;
1697 } else {
1698 job->dst = targets[i] + sizeof(padding);
1699 job->src = vec->packet_out;
1700 }
1701 }
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;
1711
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;
1718
1719 job->u.CCM.aad_len_in_bytes = vec->clear_len;
1720 job->u.CCM.aad = job->src;
1721
1722 job->user_data = targets[i];
1723 job->user_data2 = auths[i];
1724
1725 job = IMB_SUBMIT_JOB(mb_mgr);
1726 if (job) {
1727 jobs_rx++;
1728 if (num_jobs < 4) {
1729 printf("%d Unexpected return from submit_job\n",
1730 __LINE__);
1731 goto end;
1732 }
1733 if (!ccm_job_ok(vec, job, job->user_data, padding,
1734 job->user_data2, sizeof(padding),
1735 dir, in_place))
1736 goto end;
1737 }
1738 }
1739
1740 while ((job = IMB_FLUSH_JOB(mb_mgr)) != NULL) {
1741 jobs_rx++;
1742
1743 if (!ccm_job_ok(vec, job, job->user_data, padding,
1744 job->user_data2, sizeof(padding), dir,
1745 in_place))
1746 goto end;
1747 }
1748
1749 if (jobs_rx != num_jobs) {
1750 printf("Expected %d jobs, received %d\n", num_jobs, jobs_rx);
1751 goto end;
1752 }
1753 ret = 0;
1754
1755 end:
9f95a23c
TL		 1756 while ((job = IMB_FLUSH_JOB(mb_mgr)) != NULL)
1757 ;
1758
11fdf7f2
TL		 1759 for (i = 0; i < num_jobs; i++) {
1760 if (targets[i] != NULL)
1761 free(targets[i]);
1762 if (auths[i] != NULL)
1763 free(auths[i]);
1764 }
1765
1766 end2:
1767 if (targets != NULL)
1768 free(targets);
1769
1770 if (auths != NULL)
1771 free(auths);
1772
1773 return ret;
1774}
1775
1776static int
1777test_ccm_std_vectors(struct MB_MGR *mb_mgr, const int num_jobs)
1778{
1779 const int vectors_cnt = sizeof(ccm_vectors) / sizeof(ccm_vectors[0]);
1780 int vect;
1781 int errors = 0;
1782
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;
1786#ifdef DEBUG
1787 printf("Standard vector [%d/%d] NONCELen:%d PktLen:%d "
1788 "AADLen:%d AUTHlen:%d\n",
1789 vect, vectors_cnt,
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);
1794#else
1795 printf(".");
1796#endif
1797
1798 if (test_ccm(mb_mgr, &ccm_vectors[idx], ENCRYPT, 1, num_jobs)) {
1799 printf("error #%d encrypt in-place\n", vect);
1800 errors++;
1801 }
1802
1803 if (test_ccm(mb_mgr, &ccm_vectors[idx], DECRYPT, 1, num_jobs)) {
1804 printf("error #%d decrypt in-place\n", vect);
1805 errors++;
1806 }
1807
1808 if (test_ccm(mb_mgr, &ccm_vectors[idx], ENCRYPT, 0, num_jobs)) {
1809 printf("error #%d encrypt out-of-place\n", vect);
1810 errors++;
1811 }
1812
1813 if (test_ccm(mb_mgr, &ccm_vectors[idx], DECRYPT, 0, num_jobs)) {
1814 printf("error #%d decrypt out-of-place\n", vect);
1815 errors++;
1816 }
1817 }
1818 printf("\n");
1819 return errors;
1820}
1821
1822int
1823ccm_test(const enum arch_type arch,
1824 struct MB_MGR *mb_mgr)
1825{
1826 int errors = 0;
1827
1828 (void) arch; /* unused */
1829
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);
1837
1838 if (0 == errors)
1839 printf("...Pass\n");
1840 else
1841 printf("...Fail\n");
1842
1843 return errors;
1844}
Ceph