]> git.proxmox.com Git - ceph.git/blob - ceph/src/spdk/intel-ipsec-mb/LibTestApp/ctr_test.c
projects / ceph.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
update source to Ceph Pacific 16.2.2
[ceph.git] / ceph / src / spdk / intel-ipsec-mb / LibTestApp / ctr_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 #include "utils.h"
36
37 #define BYTE_ROUND_UP(x) ((x + 7) / 8)
38 /*
39 * Test Vector from
40 * https://tools.ietf.org/html/rfc3686
41 *
42 */
43 /*
44 Test Vector #1: Encrypting 16 octets using AES-CTR with 128-bit key
45 AES Key : AE 68 52 F8 12 10 67 CC 4B F7 A5 76 55 77 F3 9E
46 AES-CTR IV : 00 00 00 00 00 00 00 00
47 Nonce : 00 00 00 30
48 Plaintext String : 'Single block msg'
49 Plaintext : 53 69 6E 67 6C 65 20 62 6C 6F 63 6B 20 6D 73 67
50 Counter Block (1): 00 00 00 30 00 00 00 00 00 00 00 00 00 00 00 01
51 Key Stream (1): B7 60 33 28 DB C2 93 1B 41 0E 16 C8 06 7E 62 DF
52 Ciphertext : E4 09 5D 4F B7 A7 B3 79 2D 61 75 A3 26 13 11 B8
53 */
54 static const uint8_t K1_CTR[] = {
55 0xAE, 0x68, 0x52, 0xF8, 0x12, 0x10, 0x67, 0xCC,
56 0x4B, 0xF7, 0xA5, 0x76, 0x55, 0x77, 0xF3, 0x9E,
57 };
58 static const uint8_t IV1_CTR[] = {
59 0x00, 0x00, 0x00, 0x30, /* nonce */
60 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
61 };
62 static const uint8_t P1_CTR[] = {
63 0x53, 0x69, 0x6E, 0x67, 0x6C, 0x65, 0x20, 0x62,
64 0x6C, 0x6F, 0x63, 0x6B, 0x20, 0x6D, 0x73, 0x67,
65 };
66 static const uint8_t C1_CTR[] = {
67 0xE4, 0x09, 0x5D, 0x4F, 0xB7, 0xA7, 0xB3, 0x79,
68 0x2D, 0x61, 0x75, 0xA3, 0x26, 0x13, 0x11, 0xB8,
69 };
70 static const uint8_t T1_CTR[] = { 0 };
71 static const uint8_t A1_CTR[] = { 0 };
72 #define A1_CTR_len 0
73
74 /*
75 Test Vector #2: Encrypting 32 octets using AES-CTR with 128-bit key
76 AES Key : 7E 24 06 78 17 FA E0 D7 43 D6 CE 1F 32 53 91 63
77 AES-CTR IV : C0 54 3B 59 DA 48 D9 0B
78 Nonce : 00 6C B6 DB
79 Plaintext : 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
80 : 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F
81 Counter Block (1): 00 6C B6 DB C0 54 3B 59 DA 48 D9 0B 00 00 00 01
82 Key Stream (1): 51 05 A3 05 12 8F 74 DE 71 04 4B E5 82 D7 DD 87
83 Counter Block (2): 00 6C B6 DB C0 54 3B 59 DA 48 D9 0B 00 00 00 02
84 Key Stream (2): FB 3F 0C EF 52 CF 41 DF E4 FF 2A C4 8D 5C A0 37
85 Ciphertext : 51 04 A1 06 16 8A 72 D9 79 0D 41 EE 8E DA D3 88
86 : EB 2E 1E FC 46 DA 57 C8 FC E6 30 DF 91 41 BE 28
87 */
88 static const uint8_t K2_CTR[] = {
89 0x7E, 0x24, 0x06, 0x78, 0x17, 0xFA, 0xE0, 0xD7,
90 0x43, 0xD6, 0xCE, 0x1F, 0x32, 0x53, 0x91, 0x63,
91 };
92 static const uint8_t IV2_CTR[] = {
93 0x00, 0x6C, 0xB6, 0xDB, /* nonce */
94 0xC0, 0x54, 0x3B, 0x59, 0xDA, 0x48, 0xD9, 0x0B,
95 };
96 static const uint8_t P2_CTR[] = {
97 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
98 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
99 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
100 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
101 };
102 static const uint8_t C2_CTR[] = {
103 0x51, 0x04, 0xA1, 0x06, 0x16, 0x8A, 0x72, 0xD9,
104 0x79, 0x0D, 0x41, 0xEE, 0x8E, 0xDA, 0xD3, 0x88,
105 0xEB, 0x2E, 0x1E, 0xFC, 0x46, 0xDA, 0x57, 0xC8,
106 0xFC, 0xE6, 0x30, 0xDF, 0x91, 0x41, 0xBE, 0x28,
107 };
108 static const uint8_t T2_CTR[] = { 0 };
109 static const uint8_t A2_CTR[] = { 0 };
110 #define A2_CTR_len 0
111
112 /*
113 Test Vector #3: Encrypting 36 octets using AES-CTR with 128-bit key
114 AES Key : 76 91 BE 03 5E 50 20 A8 AC 6E 61 85 29 F9 A0 DC
115 AES-CTR IV : 27 77 7F 3F 4A 17 86 F0
116 Nonce : 00 E0 01 7B
117 Plaintext : 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
118 : 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F
119 : 20 21 22 23
120 Counter Block (1): 00 E0 01 7B 27 77 7F 3F 4A 17 86 F0 00 00 00 01
121 Key Stream (1): C1 CE 4A AB 9B 2A FB DE C7 4F 58 E2 E3 D6 7C D8
122 Counter Block (2): 00 E0 01 7B 27 77 7F 3F 4A 17 86 F0 00 00 00 02
123 Key Stream (2): 55 51 B6 38 CA 78 6E 21 CD 83 46 F1 B2 EE 0E 4C
124 Counter Block (3): 00 E0 01 7B 27 77 7F 3F 4A 17 86 F0 00 00 00 03
125 Key Stream (3): 05 93 25 0C 17 55 36 00 A6 3D FE CF 56 23 87 E9
126 Ciphertext : C1 CF 48 A8 9F 2F FD D9 CF 46 52 E9 EF DB 72 D7
127 : 45 40 A4 2B DE 6D 78 36 D5 9A 5C EA AE F3 10 53
128 : 25 B2 07 2F
129 */
130 static const uint8_t K3_CTR[] = {
131 0x76, 0x91, 0xBE, 0x03, 0x5E, 0x50, 0x20, 0xA8,
132 0xAC, 0x6E, 0x61, 0x85, 0x29, 0xF9, 0xA0, 0xDC,
133 };
134 static const uint8_t IV3_CTR[] = {
135 0x00, 0xE0, 0x01, 0x7B, /* nonce */
136 0x27, 0x77, 0x7F, 0x3F, 0x4A, 0x17, 0x86, 0xF0,
137 };
138 static const uint8_t P3_CTR[] = {
139 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
140 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
141 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
142 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
143 0x20, 0x21, 0x22, 0x23,
144 };
145 static const uint8_t C3_CTR[] = {
146 0xC1, 0xCF, 0x48, 0xA8, 0x9F, 0x2F, 0xFD, 0xD9,
147 0xCF, 0x46, 0x52, 0xE9, 0xEF, 0xDB, 0x72, 0xD7,
148 0x45, 0x40, 0xA4, 0x2B, 0xDE, 0x6D, 0x78, 0x36,
149 0xD5, 0x9A, 0x5C, 0xEA, 0xAE, 0xF3, 0x10, 0x53,
150 0x25, 0xB2, 0x07, 0x2F,
151 };
152 static const uint8_t T3_CTR[] = { 0 };
153 static const uint8_t A3_CTR[] = { 0 };
154 #define A3_CTR_len 0
155
156 /*
157 Test Vector #4: Encrypting 16 octets using AES-CTR with 192-bit key
158 AES Key : 16 AF 5B 14 5F C9 F5 79 C1 75 F9 3E 3B FB 0E ED
159 : 86 3D 06 CC FD B7 85 15
160 AES-CTR IV : 36 73 3C 14 7D 6D 93 CB
161 Nonce : 00 00 00 48
162 Plaintext String : 'Single block msg'
163 Plaintext : 53 69 6E 67 6C 65 20 62 6C 6F 63 6B 20 6D 73 67
164 Counter Block (1): 00 00 00 48 36 73 3C 14 7D 6D 93 CB 00 00 00 01
165 Key Stream (1): 18 3C 56 28 8E 3C E9 AA 22 16 56 CB 23 A6 9A 4F
166 Ciphertext : 4B 55 38 4F E2 59 C9 C8 4E 79 35 A0 03 CB E9 28
167 */
168 static const uint8_t K4_CTR[] = {
169 0x16, 0xAF, 0x5B, 0x14, 0x5F, 0xC9, 0xF5, 0x79,
170 0xC1, 0x75, 0xF9, 0x3E, 0x3B, 0xFB, 0x0E, 0xED,
171 0x86, 0x3D, 0x06, 0xCC, 0xFD, 0xB7, 0x85, 0x15,
172 };
173 static const uint8_t IV4_CTR[] = {
174 0x00, 0x00, 0x00, 0x48, /* nonce */
175 0x36, 0x73, 0x3C, 0x14, 0x7D, 0x6D, 0x93, 0xCB,
176 };
177 static const uint8_t P4_CTR[] = {
178 0x53, 0x69, 0x6E, 0x67, 0x6C, 0x65, 0x20, 0x62,
179 0x6C, 0x6F, 0x63, 0x6B, 0x20, 0x6D, 0x73, 0x67,
180 };
181 static const uint8_t C4_CTR[] = {
182 0x4B, 0x55, 0x38, 0x4F, 0xE2, 0x59, 0xC9, 0xC8,
183 0x4E, 0x79, 0x35, 0xA0, 0x03, 0xCB, 0xE9, 0x28,
184 };
185 static const uint8_t T4_CTR[] = { 0 };
186 static const uint8_t A4_CTR[] = { 0 };
187 #define A4_CTR_len 0
188
189 /*
190 Test Vector #5: Encrypting 32 octets using AES-CTR with 192-bit key
191 AES Key : 7C 5C B2 40 1B 3D C3 3C 19 E7 34 08 19 E0 F6 9C
192 : 67 8C 3D B8 E6 F6 A9 1A
193 AES-CTR IV : 02 0C 6E AD C2 CB 50 0D
194 Nonce : 00 96 B0 3B
195 Plaintext : 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
196 : 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F
197 Counter Block (1): 00 96 B0 3B 02 0C 6E AD C2 CB 50 0D 00 00 00 01
198 Key Stream (1): 45 33 41 FF 64 9E 25 35 76 D6 A0 F1 7D 3C C3 90
199 Counter Block (2): 00 96 B0 3B 02 0C 6E AD C2 CB 50 0D 00 00 00 02
200 Key Stream (2): 94 81 62 0F 4E C1 B1 8B E4 06 FA E4 5E E9 E5 1F
201 Ciphertext : 45 32 43 FC 60 9B 23 32 7E DF AA FA 71 31 CD 9F
202 : 84 90 70 1C 5A D4 A7 9C FC 1F E0 FF 42 F4 FB 00
203 */
204 static const uint8_t K5_CTR[] = {
205 0x7C, 0x5C, 0xB2, 0x40, 0x1B, 0x3D, 0xC3, 0x3C,
206 0x19, 0xE7, 0x34, 0x08, 0x19, 0xE0, 0xF6, 0x9C,
207 0x67, 0x8C, 0x3D, 0xB8, 0xE6, 0xF6, 0xA9, 0x1A,
208 };
209 static const uint8_t IV5_CTR[] = {
210 0x00, 0x96, 0xB0, 0x3B, /* nonce */
211 0x02, 0x0C, 0x6E, 0xAD, 0xC2, 0xCB, 0x50, 0x0D,
212 };
213 static const uint8_t P5_CTR[] = {
214 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
215 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
216 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
217 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
218 };
219 static const uint8_t C5_CTR[] = {
220 0x45, 0x32, 0x43, 0xFC, 0x60, 0x9B, 0x23, 0x32,
221 0x7E, 0xDF, 0xAA, 0xFA, 0x71, 0x31, 0xCD, 0x9F,
222 0x84, 0x90, 0x70, 0x1C, 0x5A, 0xD4, 0xA7, 0x9C,
223 0xFC, 0x1F, 0xE0, 0xFF, 0x42, 0xF4, 0xFB, 0x00,
224 };
225 static const uint8_t T5_CTR[] = { 0 };
226 static const uint8_t A5_CTR[] = { 0 };
227 #define A5_CTR_len 0
228
229 /*
230 Test Vector #6: Encrypting 36 octets using AES-CTR with 192-bit key
231 AES Key : 02 BF 39 1E E8 EC B1 59 B9 59 61 7B 09 65 27 9B
232 : F5 9B 60 A7 86 D3 E0 FE
233 AES-CTR IV : 5C BD 60 27 8D CC 09 12
234 Nonce : 00 07 BD FD
235 Plaintext : 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
236 : 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F
237 : 20 21 22 23
238 Counter Block (1): 00 07 BD FD 5C BD 60 27 8D CC 09 12 00 00 00 01
239 Key Stream (1): 96 88 3D C6 5A 59 74 28 5C 02 77 DA D1 FA E9 57
240 Counter Block (2): 00 07 BD FD 5C BD 60 27 8D CC 09 12 00 00 00 02
241 Key Stream (2): C2 99 AE 86 D2 84 73 9F 5D 2F D2 0A 7A 32 3F 97
242 Counter Block (3): 00 07 BD FD 5C BD 60 27 8D CC 09 12 00 00 00 03
243 Key Stream (3): 8B CF 2B 16 39 99 B2 26 15 B4 9C D4 FE 57 39 98
244 Ciphertext : 96 89 3F C5 5E 5C 72 2F 54 0B 7D D1 DD F7 E7 58
245 : D2 88 BC 95 C6 91 65 88 45 36 C8 11 66 2F 21 88
246 : AB EE 09 35
247 */
248 static const uint8_t K6_CTR[] = {
249 0x02, 0xBF, 0x39, 0x1E, 0xE8, 0xEC, 0xB1, 0x59,
250 0xB9, 0x59, 0x61, 0x7B, 0x09, 0x65, 0x27, 0x9B,
251 0xF5, 0x9B, 0x60, 0xA7, 0x86, 0xD3, 0xE0, 0xFE,
252 };
253 static const uint8_t IV6_CTR[] = {
254 0x00, 0x07, 0xBD, 0xFD, /* nonce */
255 0x5C, 0xBD, 0x60, 0x27, 0x8D, 0xCC, 0x09, 0x12,
256 };
257 static const uint8_t P6_CTR[] = {
258 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
259 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
260 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
261 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
262 0x20, 0x21, 0x22, 0x23,
263 };
264 static const uint8_t C6_CTR[] = {
265 0x96, 0x89, 0x3F, 0xC5, 0x5E, 0x5C, 0x72, 0x2F,
266 0x54, 0x0B, 0x7D, 0xD1, 0xDD, 0xF7, 0xE7, 0x58,
267 0xD2, 0x88, 0xBC, 0x95, 0xC6, 0x91, 0x65, 0x88,
268 0x45, 0x36, 0xC8, 0x11, 0x66, 0x2F, 0x21, 0x88,
269 0xAB, 0xEE, 0x09, 0x35,
270 };
271 static const uint8_t T6_CTR[] = { 0 };
272 static const uint8_t A6_CTR[] = { 0 };
273 #define A6_CTR_len 0
274
275 /*
276 Test Vector #7: Encrypting 16 octets using AES-CTR with 256-bit key
277 AES Key : 77 6B EF F2 85 1D B0 6F 4C 8A 05 42 C8 69 6F 6C
278 : 6A 81 AF 1E EC 96 B4 D3 7F C1 D6 89 E6 C1 C1 04
279 AES-CTR IV : DB 56 72 C9 7A A8 F0 B2
280 Nonce : 00 00 00 60
281 Plaintext String : 'Single block msg'
282 Plaintext : 53 69 6E 67 6C 65 20 62 6C 6F 63 6B 20 6D 73 67
283 Counter Block (1): 00 00 00 60 DB 56 72 C9 7A A8 F0 B2 00 00 00 01
284 Key Stream (1): 47 33 BE 7A D3 E7 6E A5 3A 67 00 B7 51 8E 93 A7
285 Ciphertext : 14 5A D0 1D BF 82 4E C7 56 08 63 DC 71 E3 E0 C0
286 */
287 static const uint8_t K7_CTR[] = {
288 0x77, 0x6B, 0xEF, 0xF2, 0x85, 0x1D, 0xB0, 0x6F,
289 0x4C, 0x8A, 0x05, 0x42, 0xC8, 0x69, 0x6F, 0x6C,
290 0x6A, 0x81, 0xAF, 0x1E, 0xEC, 0x96, 0xB4, 0xD3,
291 0x7F, 0xC1, 0xD6, 0x89, 0xE6, 0xC1, 0xC1, 0x04,
292 };
293 static const uint8_t IV7_CTR[] = {
294 0x00, 0x00, 0x00, 0x60, /* nonce */
295 0xDB, 0x56, 0x72, 0xC9, 0x7A, 0xA8, 0xF0, 0xB2,
296 };
297 static const uint8_t P7_CTR[] = {
298 0x53, 0x69, 0x6E, 0x67, 0x6C, 0x65, 0x20, 0x62,
299 0x6C, 0x6F, 0x63, 0x6B, 0x20, 0x6D, 0x73, 0x67,
300 };
301 static const uint8_t C7_CTR[] = {
302 0x14, 0x5A, 0xD0, 0x1D, 0xBF, 0x82, 0x4E, 0xC7,
303 0x56, 0x08, 0x63, 0xDC, 0x71, 0xE3, 0xE0, 0xC0,
304 };
305 static const uint8_t T7_CTR[] = { 0 };
306 static const uint8_t A7_CTR[] = { 0 };
307 #define A7_CTR_len 0
308
309 /*
310 Test Vector #8: Encrypting 32 octets using AES-CTR with 256-bit key
311 AES Key : F6 D6 6D 6B D5 2D 59 BB 07 96 36 58 79 EF F8 86
312 : C6 6D D5 1A 5B 6A 99 74 4B 50 59 0C 87 A2 38 84
313 AES-CTR IV : C1 58 5E F1 5A 43 D8 75
314 Nonce : 00 FA AC 24
315 Plaintext : 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
316 : 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F
317 Counter block (1): 00 FA AC 24 C1 58 5E F1 5A 43 D8 75 00 00 00 01
318 Key stream (1): F0 5F 21 18 3C 91 67 2B 41 E7 0A 00 8C 43 BC A6
319 Counter block (2): 00 FA AC 24 C1 58 5E F1 5A 43 D8 75 00 00 00 02
320 Key stream (2): A8 21 79 43 9B 96 8B 7D 4D 29 99 06 8F 59 B1 03
321 Ciphertext : F0 5E 23 1B 38 94 61 2C 49 EE 00 0B 80 4E B2 A9
322 : B8 30 6B 50 8F 83 9D 6A 55 30 83 1D 93 44 AF 1C
323 */
324 static const uint8_t K8_CTR[] = {
325 0xF6, 0xD6, 0x6D, 0x6B, 0xD5, 0x2D, 0x59, 0xBB,
326 0x07, 0x96, 0x36, 0x58, 0x79, 0xEF, 0xF8, 0x86,
327 0xC6, 0x6D, 0xD5, 0x1A, 0x5B, 0x6A, 0x99, 0x74,
328 0x4B, 0x50, 0x59, 0x0C, 0x87, 0xA2, 0x38, 0x84,
329 };
330 static const uint8_t IV8_CTR[] = {
331 0x00, 0xFA, 0xAC, 0x24, /* nonce */
332 0xC1, 0x58, 0x5E, 0xF1, 0x5A, 0x43, 0xD8, 0x75,
333 };
334 static const uint8_t P8_CTR[] = {
335 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
336 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
337 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
338 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
339 };
340 static const uint8_t C8_CTR[] = {
341 0xF0, 0x5E, 0x23, 0x1B, 0x38, 0x94, 0x61, 0x2C,
342 0x49, 0xEE, 0x00, 0x0B, 0x80, 0x4E, 0xB2, 0xA9,
343 0xB8, 0x30, 0x6B, 0x50, 0x8F, 0x83, 0x9D, 0x6A,
344 0x55, 0x30, 0x83, 0x1D, 0x93, 0x44, 0xAF, 0x1C,
345 };
346 static const uint8_t T8_CTR[] = { 0 };
347 static const uint8_t A8_CTR[] = { 0 };
348 #define A8_CTR_len 0
349
350 /*
351 Test Vector #9: Encrypting 36 octets using AES-CTR with 256-bit key
352 AES Key : FF 7A 61 7C E6 91 48 E4 F1 72 6E 2F 43 58 1D E2
353 : AA 62 D9 F8 05 53 2E DF F1 EE D6 87 FB 54 15 3D
354 AES-CTR IV : 51 A5 1D 70 A1 C1 11 48
355 Nonce : 00 1C C5 B7
356 Plaintext : 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
357 : 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F
358 : 20 21 22 23
359 Counter block (1): 00 1C C5 B7 51 A5 1D 70 A1 C1 11 48 00 00 00 01
360 Key stream (1): EB 6D 50 81 19 0E BD F0 C6 7C 9E 4D 26 C7 41 A5
361 Counter block (2): 00 1C C5 B7 51 A5 1D 70 A1 C1 11 48 00 00 00 02
362 Key stream (2): A4 16 CD 95 71 7C EB 10 EC 95 DA AE 9F CB 19 00
363 Counter block (3): 00 1C C5 B7 51 A5 1D 70 A1 C1 11 48 00 00 00 03
364 Key stream (3): 3E E1 C4 9B C6 B9 CA 21 3F 6E E2 71 D0 A9 33 39
365 Ciphertext : EB 6C 52 82 1D 0B BB F7 CE 75 94 46 2A CA 4F AA
366 : B4 07 DF 86 65 69 FD 07 F4 8C C0 B5 83 D6 07 1F
367 : 1E C0 E6 B8
368 */
369 static const uint8_t K9_CTR[] = {
370 0xFF, 0x7A, 0x61, 0x7C, 0xE6, 0x91, 0x48, 0xE4,
371 0xF1, 0x72, 0x6E, 0x2F, 0x43, 0x58, 0x1D, 0xE2,
372 0xAA, 0x62, 0xD9, 0xF8, 0x05, 0x53, 0x2E, 0xDF,
373 0xF1, 0xEE, 0xD6, 0x87, 0xFB, 0x54, 0x15, 0x3D,
374 };
375 static const uint8_t IV9_CTR[] = {
376 0x00, 0x1C, 0xC5, 0xB7, /* nonce */
377 0x51, 0xA5, 0x1D, 0x70, 0xA1, 0xC1, 0x11, 0x48,
378 };
379 static const uint8_t P9_CTR[] = {
380 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
381 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
382 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
383 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
384 0x20, 0x21, 0x22, 0x23,
385 };
386 static const uint8_t C9_CTR[] = {
387 0xEB, 0x6C, 0x52, 0x82, 0x1D, 0x0B, 0xBB, 0xF7,
388 0xCE, 0x75, 0x94, 0x46, 0x2A, 0xCA, 0x4F, 0xAA,
389 0xB4, 0x07, 0xDF, 0x86, 0x65, 0x69, 0xFD, 0x07,
390 0xF4, 0x8C, 0xC0, 0xB5, 0x83, 0xD6, 0x07, 0x1F,
391 0x1E, 0xC0, 0xE6, 0xB8,
392 };
393 static const uint8_t T9_CTR[] = { 0 };
394 static const uint8_t A9_CTR[] = { 0 };
395 #define A9_CTR_len 0
396
397 /*
398 Test Vector #10: Encrypting 128 octets using AES-CTR with 128-bit key
399 AES Key : AE 68 52 F8 12 10 67 CC 4B F7 A5 76 55 77 F3 9E
400 AES-CTR IV : 00 00 00 00 00 00 00 00
401 Nonce : 00 00 00 30
402 Plaintext String : 'Full 8 blocks'
403 */
404 static const uint8_t K10_CTR[] = {
405 0xAE, 0x68, 0x52, 0xF8, 0x12, 0x10, 0x67, 0xCC,
406 0x4B, 0xF7, 0xA5, 0x76, 0x55, 0x77, 0xF3, 0x9E,
407 };
408 static const uint8_t IV10_CTR[] = {
409 0x00, 0x00, 0x00, 0x30, /* nonce */
410 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
411 };
412 static const uint8_t P10_CTR[] = {
413 0xA8, 0x63, 0x44, 0xF8, 0x36, 0x59, 0x2F, 0xF2,
414 0xDA, 0xDD, 0x17, 0xCE, 0xFE, 0x2A, 0xF2, 0xA2,
415 0x35, 0x87, 0x34, 0x0F, 0x35, 0xFC, 0xD8, 0xF2,
416 0x57, 0xA1, 0xCB, 0x19, 0x0C, 0x33, 0x14, 0xE1,
417 0x23, 0xEB, 0xC0, 0x88, 0x82, 0x05, 0x5F, 0x01,
418 0x5D, 0xFC, 0x53, 0x08, 0xDB, 0x34, 0x8E, 0x94,
419 0xE4, 0xA8, 0x26, 0x7F, 0xBC, 0xB7, 0x8B, 0xE1,
420 0x58, 0x2F, 0x2C, 0x91, 0xCD, 0x5B, 0x4A, 0xAA,
421 0x7A, 0xBA, 0x5F, 0xD2, 0x9B, 0xF8, 0x7D, 0xEA,
422 0x76, 0xB6, 0x64, 0xB3, 0x29, 0xD3, 0x02, 0x19,
423 0xA0, 0xDC, 0xE9, 0xB8, 0x90, 0x51, 0xA8, 0xDE,
424 0x2E, 0xA1, 0xB7, 0x7E, 0x51, 0x0D, 0x34, 0xB3,
425 0xED, 0xE7, 0x5E, 0xB8, 0x8A, 0xE9, 0xFE, 0x89,
426 0xF8, 0x0B, 0x85, 0x09, 0x76, 0x08, 0x78, 0x0D,
427 0x27, 0x59, 0x8E, 0x14, 0x43, 0x46, 0xA0, 0x91,
428 0xEE, 0xAA, 0xFF, 0x74, 0x8D, 0xBC, 0x98, 0xB9
429 };
430
431 static const uint8_t C10_CTR[] = {
432 0x1F, 0x03, 0x77, 0xD0, 0xED, 0x9B, 0xBC, 0xE9,
433 0x9B, 0xD3, 0x01, 0x06, 0xF8, 0x54, 0x90, 0x7D,
434 0x67, 0x6F, 0x19, 0xD7, 0x0B, 0xF3, 0x92, 0x8D,
435 0x60, 0xC0, 0x18, 0x5A, 0x24, 0xC1, 0xD7, 0x60,
436 0x82, 0x9C, 0x22, 0x37, 0x45, 0xE3, 0x9D, 0xA6,
437 0x76, 0x37, 0xE1, 0x7A, 0x13, 0xB4, 0x40, 0x63,
438 0xF4, 0xD8, 0xDE, 0x41, 0x64, 0xFC, 0xE2, 0x42,
439 0x2E, 0x3F, 0xEA, 0xE1, 0x28, 0x06, 0xA5, 0xAC,
440 0x6A, 0xC1, 0x58, 0x0C, 0x84, 0xFF, 0x9B, 0x6A,
441 0xE5, 0xBE, 0x4E, 0x8C, 0x4C, 0xE9, 0x97, 0xD5,
442 0x24, 0x30, 0x1B, 0x19, 0xDF, 0x87, 0x56, 0x85,
443 0x31, 0x56, 0x5A, 0xDE, 0xE0, 0x6E, 0xC0, 0x1C,
444 0xCB, 0x51, 0x5B, 0x6E, 0xAC, 0xF5, 0xB0, 0x60,
445 0x60, 0x2F, 0x62, 0x0A, 0xEA, 0x62, 0x51, 0x2E,
446 0x5B, 0x1B, 0x99, 0x51, 0x3B, 0xAC, 0xE9, 0xC5,
447 0x59, 0x7D, 0x0E, 0xB6, 0x51, 0x6C, 0x16, 0x7A
448 };
449
450 static const uint8_t T10_CTR[] = { 0 };
451 static const uint8_t A10_CTR[] = { 0 };
452 #define A10_CTR_len 0
453
454 /*
455 Test Vector #11: Encrypting 136 octets using AES-CTR with 128-bit key
456 AES Key : AE 68 52 F8 12 10 67 CC 4B F7 A5 76 55 77 F3 9E
457 AES-CTR IV : 00 00 00 00 00 00 00 00
458 Nonce : 00 00 00 30
459 Plaintext String : 'Full 8 blocks + extra partial block'
460 */
461 static const uint8_t K11_CTR[] = {
462 0xAE, 0x68, 0x52, 0xF8, 0x12, 0x10, 0x67, 0xCC,
463 0x4B, 0xF7, 0xA5, 0x76, 0x55, 0x77, 0xF3, 0x9E,
464 };
465 static const uint8_t IV11_CTR[] = {
466 0x00, 0x00, 0x00, 0x30, /* nonce */
467 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
468 };
469 static const uint8_t P11_CTR[] = {
470 0xA8, 0x63, 0x44, 0xF8, 0x36, 0x59, 0x2F, 0xF2,
471 0xDA, 0xDD, 0x17, 0xCE, 0xFE, 0x2A, 0xF2, 0xA2,
472 0x35, 0x87, 0x34, 0x0F, 0x35, 0xFC, 0xD8, 0xF2,
473 0x57, 0xA1, 0xCB, 0x19, 0x0C, 0x33, 0x14, 0xE1,
474 0x23, 0xEB, 0xC0, 0x88, 0x82, 0x05, 0x5F, 0x01,
475 0x5D, 0xFC, 0x53, 0x08, 0xDB, 0x34, 0x8E, 0x94,
476 0xE4, 0xA8, 0x26, 0x7F, 0xBC, 0xB7, 0x8B, 0xE1,
477 0x58, 0x2F, 0x2C, 0x91, 0xCD, 0x5B, 0x4A, 0xAA,
478 0x7A, 0xBA, 0x5F, 0xD2, 0x9B, 0xF8, 0x7D, 0xEA,
479 0x76, 0xB6, 0x64, 0xB3, 0x29, 0xD3, 0x02, 0x19,
480 0xA0, 0xDC, 0xE9, 0xB8, 0x90, 0x51, 0xA8, 0xDE,
481 0x2E, 0xA1, 0xB7, 0x7E, 0x51, 0x0D, 0x34, 0xB3,
482 0xED, 0xE7, 0x5E, 0xB8, 0x8A, 0xE9, 0xFE, 0x89,
483 0xF8, 0x0B, 0x85, 0x09, 0x76, 0x08, 0x78, 0x0D,
484 0x27, 0x59, 0x8E, 0x14, 0x43, 0x46, 0xA0, 0x91,
485 0xEE, 0xAA, 0xFF, 0x74, 0x8D, 0xBC, 0x98, 0xB9,
486 0x12, 0xAD, 0x82, 0xDF, 0x2F, 0xF8, 0x9C, 0xE0
487 };
488
489 static const uint8_t C11_CTR[] = {
490 0x1F, 0x03, 0x77, 0xD0, 0xED, 0x9B, 0xBC, 0xE9,
491 0x9B, 0xD3, 0x01, 0x06, 0xF8, 0x54, 0x90, 0x7D,
492 0x67, 0x6F, 0x19, 0xD7, 0x0B, 0xF3, 0x92, 0x8D,
493 0x60, 0xC0, 0x18, 0x5A, 0x24, 0xC1, 0xD7, 0x60,
494 0x82, 0x9C, 0x22, 0x37, 0x45, 0xE3, 0x9D, 0xA6,
495 0x76, 0x37, 0xE1, 0x7A, 0x13, 0xB4, 0x40, 0x63,
496 0xF4, 0xD8, 0xDE, 0x41, 0x64, 0xFC, 0xE2, 0x42,
497 0x2E, 0x3F, 0xEA, 0xE1, 0x28, 0x06, 0xA5, 0xAC,
498 0x6A, 0xC1, 0x58, 0x0C, 0x84, 0xFF, 0x9B, 0x6A,
499 0xE5, 0xBE, 0x4E, 0x8C, 0x4C, 0xE9, 0x97, 0xD5,
500 0x24, 0x30, 0x1B, 0x19, 0xDF, 0x87, 0x56, 0x85,
501 0x31, 0x56, 0x5A, 0xDE, 0xE0, 0x6E, 0xC0, 0x1C,
502 0xCB, 0x51, 0x5B, 0x6E, 0xAC, 0xF5, 0xB0, 0x60,
503 0x60, 0x2F, 0x62, 0x0A, 0xEA, 0x62, 0x51, 0x2E,
504 0x5B, 0x1B, 0x99, 0x51, 0x3B, 0xAC, 0xE9, 0xC5,
505 0x59, 0x7D, 0x0E, 0xB6, 0x51, 0x6C, 0x16, 0x7A,
506 0x7A, 0x13, 0xB4, 0x40, 0x69, 0x9B, 0x58, 0x16
507 };
508 static const uint8_t T11_CTR[] = { 0 };
509 static const uint8_t A11_CTR[] = { 0 };
510 #define A11_CTR_len 0
511
512 /*
513 Test Vector #12: Encrypting 256 octets using AES-CTR with 128-bit key
514 AES Key : AE 68 52 F8 12 10 67 CC 4B F7 A5 76 55 77 F3 9E
515 AES-CTR IV : 00 00 00 00 00 00 00 00
516 Nonce : 00 00 00 30
517 Plaintext String : 'Full 2x8 blocks'
518 */
519 static const uint8_t K12_CTR[] = {
520 0xAE, 0x68, 0x52, 0xF8, 0x12, 0x10, 0x67, 0xCC,
521 0x4B, 0xF7, 0xA5, 0x76, 0x55, 0x77, 0xF3, 0x9E,
522 };
523 static const uint8_t IV12_CTR[] = {
524 0x00, 0x00, 0x00, 0x30, /* nonce */
525 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
526 };
527 static const uint8_t P12_CTR[] = {
528 0xA8, 0x63, 0x44, 0xF8, 0x36, 0x59, 0x2F, 0xF2,
529 0xDA, 0xDD, 0x17, 0xCE, 0xFE, 0x2A, 0xF2, 0xA2,
530 0x35, 0x87, 0x34, 0x0F, 0x35, 0xFC, 0xD8, 0xF2,
531 0x57, 0xA1, 0xCB, 0x19, 0x0C, 0x33, 0x14, 0xE1,
532 0x23, 0xEB, 0xC0, 0x88, 0x82, 0x05, 0x5F, 0x01,
533 0x5D, 0xFC, 0x53, 0x08, 0xDB, 0x34, 0x8E, 0x94,
534 0xE4, 0xA8, 0x26, 0x7F, 0xBC, 0xB7, 0x8B, 0xE1,
535 0x58, 0x2F, 0x2C, 0x91, 0xCD, 0x5B, 0x4A, 0xAA,
536 0x7A, 0xBA, 0x5F, 0xD2, 0x9B, 0xF8, 0x7D, 0xEA,
537 0x76, 0xB6, 0x64, 0xB3, 0x29, 0xD3, 0x02, 0x19,
538 0xA0, 0xDC, 0xE9, 0xB8, 0x90, 0x51, 0xA8, 0xDE,
539 0x2E, 0xA1, 0xB7, 0x7E, 0x51, 0x0D, 0x34, 0xB3,
540 0xED, 0xE7, 0x5E, 0xB8, 0x8A, 0xE9, 0xFE, 0x89,
541 0xF8, 0x0B, 0x85, 0x09, 0x76, 0x08, 0x78, 0x0D,
542 0x27, 0x59, 0x8E, 0x14, 0x43, 0x46, 0xA0, 0x91,
543 0xEE, 0xAA, 0xFF, 0x74, 0x8D, 0xBC, 0x98, 0xB9,
544 0x77, 0xBD, 0x41, 0x4F, 0xAB, 0xF8, 0x78, 0x1F,
545 0xED, 0x2B, 0x14, 0x89, 0xB5, 0x7B, 0x61, 0x5E,
546 0x88, 0x35, 0x46, 0x0F, 0x83, 0x5B, 0xC6, 0xE6,
547 0x61, 0x1D, 0xD8, 0x5E, 0xD3, 0xC3, 0xC6, 0xE8,
548 0xFB, 0x8E, 0x59, 0xDB, 0x31, 0x17, 0xF8, 0xCD,
549 0xC1, 0xD4, 0x2D, 0xEF, 0xD8, 0x25, 0x9E, 0x88,
550 0x10, 0x58, 0xF2, 0xA6, 0x84, 0x4F, 0xA1, 0x32,
551 0x5F, 0x0E, 0xA2, 0x14, 0xF7, 0x03, 0x85, 0x06,
552 0x94, 0x4F, 0x83, 0x87, 0x04, 0x97, 0x5A, 0x8D,
553 0x9A, 0x73, 0x36, 0x2A, 0xE0, 0x6D, 0xA9, 0x1F,
554 0xBC, 0x2F, 0xD2, 0x9E, 0xD1, 0x7D, 0x2C, 0x89,
555 0x1F, 0xE1, 0xA0, 0x8F, 0x5D, 0x3E, 0xAB, 0x9E,
556 0x79, 0x1A, 0x76, 0xC3, 0x0A, 0xC8, 0xCF, 0xCB,
557 0x35, 0x63, 0xD9, 0x46, 0x87, 0xAF, 0x74, 0x24,
558 0x47, 0xBA, 0x60, 0xAB, 0x33, 0x5D, 0xA8, 0xDE,
559 0xFE, 0x1B, 0xC5, 0x3F, 0xAC, 0xD9, 0xAD, 0x94
560 };
561
562 static const uint8_t C12_CTR[] = {
563 0x1F, 0x03, 0x77, 0xD0, 0xED, 0x9B, 0xBC, 0xE9,
564 0x9B, 0xD3, 0x01, 0x06, 0xF8, 0x54, 0x90, 0x7D,
565 0x67, 0x6F, 0x19, 0xD7, 0x0B, 0xF3, 0x92, 0x8D,
566 0x60, 0xC0, 0x18, 0x5A, 0x24, 0xC1, 0xD7, 0x60,
567 0x82, 0x9C, 0x22, 0x37, 0x45, 0xE3, 0x9D, 0xA6,
568 0x76, 0x37, 0xE1, 0x7A, 0x13, 0xB4, 0x40, 0x63,
569 0xF4, 0xD8, 0xDE, 0x41, 0x64, 0xFC, 0xE2, 0x42,
570 0x2E, 0x3F, 0xEA, 0xE1, 0x28, 0x06, 0xA5, 0xAC,
571 0x6A, 0xC1, 0x58, 0x0C, 0x84, 0xFF, 0x9B, 0x6A,
572 0xE5, 0xBE, 0x4E, 0x8C, 0x4C, 0xE9, 0x97, 0xD5,
573 0x24, 0x30, 0x1B, 0x19, 0xDF, 0x87, 0x56, 0x85,
574 0x31, 0x56, 0x5A, 0xDE, 0xE0, 0x6E, 0xC0, 0x1C,
575 0xCB, 0x51, 0x5B, 0x6E, 0xAC, 0xF5, 0xB0, 0x60,
576 0x60, 0x2F, 0x62, 0x0A, 0xEA, 0x62, 0x51, 0x2E,
577 0x5B, 0x1B, 0x99, 0x51, 0x3B, 0xAC, 0xE9, 0xC5,
578 0x59, 0x7D, 0x0E, 0xB6, 0x51, 0x6C, 0x16, 0x7A,
579 0x1F, 0x03, 0x77, 0xD0, 0xED, 0x9B, 0xBC, 0xE9,
580 0x9B, 0xD3, 0x01, 0x06, 0xF8, 0x54, 0x90, 0x7D,
581 0x67, 0x6F, 0x19, 0xD7, 0x0B, 0xF3, 0x92, 0x8D,
582 0x60, 0xC0, 0x18, 0x5A, 0x24, 0xC1, 0xD7, 0x60,
583 0x82, 0x9C, 0x22, 0x37, 0x45, 0xE3, 0x9D, 0xA6,
584 0x76, 0x37, 0xE1, 0x7A, 0x13, 0xB4, 0x40, 0x63,
585 0xF4, 0xD8, 0xDE, 0x41, 0x64, 0xFC, 0xE2, 0x42,
586 0x2E, 0x3F, 0xEA, 0xE1, 0x28, 0x06, 0xA5, 0xAC,
587 0x6A, 0xC1, 0x58, 0x0C, 0x84, 0xFF, 0x9B, 0x6A,
588 0xE5, 0xBE, 0x4E, 0x8C, 0x4C, 0xE9, 0x97, 0xD5,
589 0x24, 0x30, 0x1B, 0x19, 0xDF, 0x87, 0x56, 0x85,
590 0x31, 0x56, 0x5A, 0xDE, 0xE0, 0x6E, 0xC0, 0x1C,
591 0xCB, 0x51, 0x5B, 0x6E, 0xAC, 0xF5, 0xB0, 0x60,
592 0x60, 0x2F, 0x62, 0x0A, 0xEA, 0x62, 0x51, 0x2E,
593 0x5B, 0x1B, 0x99, 0x51, 0x3B, 0xAC, 0xE9, 0xC5,
594 0x59, 0x7D, 0x0E, 0xB6, 0x51, 0x6C, 0x16, 0x7A,
595 };
596 static const uint8_t T12_CTR[] = { 0 };
597 static const uint8_t A12_CTR[] = { 0 };
598 #define A12_CTR_len 0
599
600 /*
601 Test Vector #13: Encrypting 300 octets using AES-CTR with 128-bit key
602 AES Key : AE 68 52 F8 12 10 67 CC 4B F7 A5 76 55 77 F3 9E
603 AES-CTR IV : 00 00 00 00 00 00 00 00
604 Nonce : 00 00 00 30
605 Plaintext String : 'Full 2x8 blocks + 44B (2 full blocks and partial block)'
606 */
607 static const uint8_t K13_CTR[] = {
608 0xAE, 0x68, 0x52, 0xF8, 0x12, 0x10, 0x67, 0xCC,
609 0x4B, 0xF7, 0xA5, 0x76, 0x55, 0x77, 0xF3, 0x9E,
610 };
611 static const uint8_t IV13_CTR[] = {
612 0x00, 0x00, 0x00, 0x30, /* nonce */
613 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
614 };
615 static const uint8_t P13_CTR[] = {
616 0xA8, 0x63, 0x44, 0xF8, 0x36, 0x59, 0x2F, 0xF2,
617 0xDA, 0xDD, 0x17, 0xCE, 0xFE, 0x2A, 0xF2, 0xA2,
618 0x35, 0x87, 0x34, 0x0F, 0x35, 0xFC, 0xD8, 0xF2,
619 0x57, 0xA1, 0xCB, 0x19, 0x0C, 0x33, 0x14, 0xE1,
620 0x23, 0xEB, 0xC0, 0x88, 0x82, 0x05, 0x5F, 0x01,
621 0x5D, 0xFC, 0x53, 0x08, 0xDB, 0x34, 0x8E, 0x94,
622 0xE4, 0xA8, 0x26, 0x7F, 0xBC, 0xB7, 0x8B, 0xE1,
623 0x58, 0x2F, 0x2C, 0x91, 0xCD, 0x5B, 0x4A, 0xAA,
624 0x7A, 0xBA, 0x5F, 0xD2, 0x9B, 0xF8, 0x7D, 0xEA,
625 0x76, 0xB6, 0x64, 0xB3, 0x29, 0xD3, 0x02, 0x19,
626 0xA0, 0xDC, 0xE9, 0xB8, 0x90, 0x51, 0xA8, 0xDE,
627 0x2E, 0xA1, 0xB7, 0x7E, 0x51, 0x0D, 0x34, 0xB3,
628 0xED, 0xE7, 0x5E, 0xB8, 0x8A, 0xE9, 0xFE, 0x89,
629 0xF8, 0x0B, 0x85, 0x09, 0x76, 0x08, 0x78, 0x0D,
630 0x27, 0x59, 0x8E, 0x14, 0x43, 0x46, 0xA0, 0x91,
631 0xEE, 0xAA, 0xFF, 0x74, 0x8D, 0xBC, 0x98, 0xB9,
632 0x77, 0xBD, 0x41, 0x4F, 0xAB, 0xF8, 0x78, 0x1F,
633 0xED, 0x2B, 0x14, 0x89, 0xB5, 0x7B, 0x61, 0x5E,
634 0x88, 0x35, 0x46, 0x0F, 0x83, 0x5B, 0xC6, 0xE6,
635 0x61, 0x1D, 0xD8, 0x5E, 0xD3, 0xC3, 0xC6, 0xE8,
636 0xFB, 0x8E, 0x59, 0xDB, 0x31, 0x17, 0xF8, 0xCD,
637 0xC1, 0xD4, 0x2D, 0xEF, 0xD8, 0x25, 0x9E, 0x88,
638 0x10, 0x58, 0xF2, 0xA6, 0x84, 0x4F, 0xA1, 0x32,
639 0x5F, 0x0E, 0xA2, 0x14, 0xF7, 0x03, 0x85, 0x06,
640 0x94, 0x4F, 0x83, 0x87, 0x04, 0x97, 0x5A, 0x8D,
641 0x9A, 0x73, 0x36, 0x2A, 0xE0, 0x6D, 0xA9, 0x1F,
642 0xBC, 0x2F, 0xD2, 0x9E, 0xD1, 0x7D, 0x2C, 0x89,
643 0x1F, 0xE1, 0xA0, 0x8F, 0x5D, 0x3E, 0xAB, 0x9E,
644 0x79, 0x1A, 0x76, 0xC3, 0x0A, 0xC8, 0xCF, 0xCB,
645 0x35, 0x63, 0xD9, 0x46, 0x87, 0xAF, 0x74, 0x24,
646 0x47, 0xBA, 0x60, 0xAB, 0x33, 0x5D, 0xA8, 0xDE,
647 0xFE, 0x1B, 0xC5, 0x3F, 0xAC, 0xD9, 0xAD, 0x94,
648 0x66, 0xb8, 0x3f, 0x3a, 0x21, 0x9f, 0xd0, 0x43,
649 0x46, 0xdd, 0x65, 0x8b, 0x44, 0x99, 0x66, 0x91,
650 0x64, 0xe2, 0x69, 0x6f, 0xbb, 0x85, 0x8c, 0xcc,
651 0x7f, 0xea, 0x96, 0xd1, 0x5e, 0xb4, 0x7c, 0xd0,
652 0xab, 0x02, 0x8d, 0xa3, 0x59, 0x3b, 0x8c, 0xd5,
653 0xd0, 0xe7, 0xb4, 0xc4
654 };
655
656 static const uint8_t C13_CTR[] = {
657 0x1F, 0x03, 0x77, 0xD0, 0xED, 0x9B, 0xBC, 0xE9,
658 0x9B, 0xD3, 0x01, 0x06, 0xF8, 0x54, 0x90, 0x7D,
659 0x67, 0x6F, 0x19, 0xD7, 0x0B, 0xF3, 0x92, 0x8D,
660 0x60, 0xC0, 0x18, 0x5A, 0x24, 0xC1, 0xD7, 0x60,
661 0x82, 0x9C, 0x22, 0x37, 0x45, 0xE3, 0x9D, 0xA6,
662 0x76, 0x37, 0xE1, 0x7A, 0x13, 0xB4, 0x40, 0x63,
663 0xF4, 0xD8, 0xDE, 0x41, 0x64, 0xFC, 0xE2, 0x42,
664 0x2E, 0x3F, 0xEA, 0xE1, 0x28, 0x06, 0xA5, 0xAC,
665 0x6A, 0xC1, 0x58, 0x0C, 0x84, 0xFF, 0x9B, 0x6A,
666 0xE5, 0xBE, 0x4E, 0x8C, 0x4C, 0xE9, 0x97, 0xD5,
667 0x24, 0x30, 0x1B, 0x19, 0xDF, 0x87, 0x56, 0x85,
668 0x31, 0x56, 0x5A, 0xDE, 0xE0, 0x6E, 0xC0, 0x1C,
669 0xCB, 0x51, 0x5B, 0x6E, 0xAC, 0xF5, 0xB0, 0x60,
670 0x60, 0x2F, 0x62, 0x0A, 0xEA, 0x62, 0x51, 0x2E,
671 0x5B, 0x1B, 0x99, 0x51, 0x3B, 0xAC, 0xE9, 0xC5,
672 0x59, 0x7D, 0x0E, 0xB6, 0x51, 0x6C, 0x16, 0x7A,
673 0x1F, 0x03, 0x77, 0xD0, 0xED, 0x9B, 0xBC, 0xE9,
674 0x9B, 0xD3, 0x01, 0x06, 0xF8, 0x54, 0x90, 0x7D,
675 0x67, 0x6F, 0x19, 0xD7, 0x0B, 0xF3, 0x92, 0x8D,
676 0x60, 0xC0, 0x18, 0x5A, 0x24, 0xC1, 0xD7, 0x60,
677 0x82, 0x9C, 0x22, 0x37, 0x45, 0xE3, 0x9D, 0xA6,
678 0x76, 0x37, 0xE1, 0x7A, 0x13, 0xB4, 0x40, 0x63,
679 0xF4, 0xD8, 0xDE, 0x41, 0x64, 0xFC, 0xE2, 0x42,
680 0x2E, 0x3F, 0xEA, 0xE1, 0x28, 0x06, 0xA5, 0xAC,
681 0x6A, 0xC1, 0x58, 0x0C, 0x84, 0xFF, 0x9B, 0x6A,
682 0xE5, 0xBE, 0x4E, 0x8C, 0x4C, 0xE9, 0x97, 0xD5,
683 0x24, 0x30, 0x1B, 0x19, 0xDF, 0x87, 0x56, 0x85,
684 0x31, 0x56, 0x5A, 0xDE, 0xE0, 0x6E, 0xC0, 0x1C,
685 0xCB, 0x51, 0x5B, 0x6E, 0xAC, 0xF5, 0xB0, 0x60,
686 0x60, 0x2F, 0x62, 0x0A, 0xEA, 0x62, 0x51, 0x2E,
687 0x5B, 0x1B, 0x99, 0x51, 0x3B, 0xAC, 0xE9, 0xC5,
688 0x59, 0x7D, 0x0E, 0xB6, 0x51, 0x6C, 0x16, 0x7A,
689 0xED, 0x52, 0x55, 0xB9, 0x76, 0x6C, 0x5E, 0x6E,
690 0x76, 0x97, 0x00, 0xC7, 0xEB, 0xFE, 0xEC, 0x10,
691 0x94, 0x2C, 0xA9, 0xAF, 0x9B, 0x09, 0x19, 0xB3,
692 0x17, 0x29, 0x96, 0xBA, 0x8E, 0xAC, 0x3D, 0x0A,
693 0x9B, 0x70, 0x54, 0x0F, 0x1E, 0xD4, 0xE8, 0x13,
694 0xE6, 0x8F, 0xAD, 0xFD
695
696 };
697 static const uint8_t T13_CTR[] = { 0 };
698 static const uint8_t A13_CTR[] = { 0 };
699 #define A13_CTR_len 0
700
701 /*
702 Test Vector #14: Encrypting 384 octets using AES-CTR with 128-bit key
703 AES Key : AE 68 52 F8 12 10 67 CC 4B F7 A5 76 55 77 F3 9E
704 AES-CTR IV : 00 00 00 00 00 00 00 00
705 Nonce : 00 00 00 30
706 Plaintext String : 'Full 3x8 blocks'
707 */
708 static const uint8_t K14_CTR[] = {
709 0xAE, 0x68, 0x52, 0xF8, 0x12, 0x10, 0x67, 0xCC,
710 0x4B, 0xF7, 0xA5, 0x76, 0x55, 0x77, 0xF3, 0x9E,
711 };
712 static const uint8_t IV14_CTR[] = {
713 0x00, 0x00, 0x00, 0x30, /* nonce */
714 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
715 };
716 static const uint8_t P14_CTR[] = {
717 0xA8, 0x63, 0x44, 0xF8, 0x36, 0x59, 0x2F, 0xF2,
718 0xDA, 0xDD, 0x17, 0xCE, 0xFE, 0x2A, 0xF2, 0xA2,
719 0x35, 0x87, 0x34, 0x0F, 0x35, 0xFC, 0xD8, 0xF2,
720 0x57, 0xA1, 0xCB, 0x19, 0x0C, 0x33, 0x14, 0xE1,
721 0x23, 0xEB, 0xC0, 0x88, 0x82, 0x05, 0x5F, 0x01,
722 0x5D, 0xFC, 0x53, 0x08, 0xDB, 0x34, 0x8E, 0x94,
723 0xE4, 0xA8, 0x26, 0x7F, 0xBC, 0xB7, 0x8B, 0xE1,
724 0x58, 0x2F, 0x2C, 0x91, 0xCD, 0x5B, 0x4A, 0xAA,
725 0x7A, 0xBA, 0x5F, 0xD2, 0x9B, 0xF8, 0x7D, 0xEA,
726 0x76, 0xB6, 0x64, 0xB3, 0x29, 0xD3, 0x02, 0x19,
727 0xA0, 0xDC, 0xE9, 0xB8, 0x90, 0x51, 0xA8, 0xDE,
728 0x2E, 0xA1, 0xB7, 0x7E, 0x51, 0x0D, 0x34, 0xB3,
729 0xED, 0xE7, 0x5E, 0xB8, 0x8A, 0xE9, 0xFE, 0x89,
730 0xF8, 0x0B, 0x85, 0x09, 0x76, 0x08, 0x78, 0x0D,
731 0x27, 0x59, 0x8E, 0x14, 0x43, 0x46, 0xA0, 0x91,
732 0xEE, 0xAA, 0xFF, 0x74, 0x8D, 0xBC, 0x98, 0xB9,
733 0x77, 0xBD, 0x41, 0x4F, 0xAB, 0xF8, 0x78, 0x1F,
734 0xED, 0x2B, 0x14, 0x89, 0xB5, 0x7B, 0x61, 0x5E,
735 0x88, 0x35, 0x46, 0x0F, 0x83, 0x5B, 0xC6, 0xE6,
736 0x61, 0x1D, 0xD8, 0x5E, 0xD3, 0xC3, 0xC6, 0xE8,
737 0xFB, 0x8E, 0x59, 0xDB, 0x31, 0x17, 0xF8, 0xCD,
738 0xC1, 0xD4, 0x2D, 0xEF, 0xD8, 0x25, 0x9E, 0x88,
739 0x10, 0x58, 0xF2, 0xA6, 0x84, 0x4F, 0xA1, 0x32,
740 0x5F, 0x0E, 0xA2, 0x14, 0xF7, 0x03, 0x85, 0x06,
741 0x94, 0x4F, 0x83, 0x87, 0x04, 0x97, 0x5A, 0x8D,
742 0x9A, 0x73, 0x36, 0x2A, 0xE0, 0x6D, 0xA9, 0x1F,
743 0xBC, 0x2F, 0xD2, 0x9E, 0xD1, 0x7D, 0x2C, 0x89,
744 0x1F, 0xE1, 0xA0, 0x8F, 0x5D, 0x3E, 0xAB, 0x9E,
745 0x79, 0x1A, 0x76, 0xC3, 0x0A, 0xC8, 0xCF, 0xCB,
746 0x35, 0x63, 0xD9, 0x46, 0x87, 0xAF, 0x74, 0x24,
747 0x47, 0xBA, 0x60, 0xAB, 0x33, 0x5D, 0xA8, 0xDE,
748 0xFE, 0x1B, 0xC5, 0x3F, 0xAC, 0xD9, 0xAD, 0x94,
749 0x66, 0xb8, 0x3f, 0x3a, 0x21, 0x9f, 0xd0, 0x43,
750 0x46, 0xdd, 0x65, 0x8b, 0x44, 0x99, 0x66, 0x91,
751 0x64, 0xe2, 0x69, 0x6f, 0xbb, 0x85, 0x8c, 0xcc,
752 0x7f, 0xea, 0x96, 0xd1, 0x5e, 0xb4, 0x7c, 0xd0,
753 0xab, 0x02, 0x8d, 0xa3, 0x59, 0x3b, 0x8c, 0xd5,
754 0xd0, 0xe7, 0xb4, 0xc4, 0x90, 0x41, 0x9f, 0x78,
755 0x4e, 0x82, 0x9e, 0xe4, 0x1b, 0x97, 0xa9, 0xa4,
756 0x7b, 0x48, 0xad, 0x56, 0xc0, 0xe4, 0x86, 0x52,
757 0xfc, 0xad, 0x93, 0x0b, 0x7d, 0x38, 0xce, 0x73,
758 0x64, 0xbd, 0xf7, 0x00, 0x7b, 0xe6, 0x46, 0x03,
759 0x2f, 0x4b, 0x75, 0x9f, 0x3a, 0x2d, 0x32, 0x42,
760 0xfe, 0x80, 0x74, 0x89, 0x27, 0x34, 0xce, 0x5e,
761 0xbf, 0xbe, 0x07, 0x50, 0x91, 0x08, 0x27, 0x2b,
762 0x32, 0x77, 0xa7, 0xff, 0x83, 0xb1, 0xab, 0xc8,
763 0x98, 0xbe, 0xac, 0x33, 0x7c, 0x47, 0x19, 0x33,
764 0x6f, 0x4d, 0xbe, 0x3e, 0xdc, 0xe0, 0x87, 0xfb
765 };
766
767 static const uint8_t C14_CTR[] = {
768 0x1F, 0x03, 0x77, 0xD0, 0xED, 0x9B, 0xBC, 0xE9,
769 0x9B, 0xD3, 0x01, 0x06, 0xF8, 0x54, 0x90, 0x7D,
770 0x67, 0x6F, 0x19, 0xD7, 0x0B, 0xF3, 0x92, 0x8D,
771 0x60, 0xC0, 0x18, 0x5A, 0x24, 0xC1, 0xD7, 0x60,
772 0x82, 0x9C, 0x22, 0x37, 0x45, 0xE3, 0x9D, 0xA6,
773 0x76, 0x37, 0xE1, 0x7A, 0x13, 0xB4, 0x40, 0x63,
774 0xF4, 0xD8, 0xDE, 0x41, 0x64, 0xFC, 0xE2, 0x42,
775 0x2E, 0x3F, 0xEA, 0xE1, 0x28, 0x06, 0xA5, 0xAC,
776 0x6A, 0xC1, 0x58, 0x0C, 0x84, 0xFF, 0x9B, 0x6A,
777 0xE5, 0xBE, 0x4E, 0x8C, 0x4C, 0xE9, 0x97, 0xD5,
778 0x24, 0x30, 0x1B, 0x19, 0xDF, 0x87, 0x56, 0x85,
779 0x31, 0x56, 0x5A, 0xDE, 0xE0, 0x6E, 0xC0, 0x1C,
780 0xCB, 0x51, 0x5B, 0x6E, 0xAC, 0xF5, 0xB0, 0x60,
781 0x60, 0x2F, 0x62, 0x0A, 0xEA, 0x62, 0x51, 0x2E,
782 0x5B, 0x1B, 0x99, 0x51, 0x3B, 0xAC, 0xE9, 0xC5,
783 0x59, 0x7D, 0x0E, 0xB6, 0x51, 0x6C, 0x16, 0x7A,
784 0x1F, 0x03, 0x77, 0xD0, 0xED, 0x9B, 0xBC, 0xE9,
785 0x9B, 0xD3, 0x01, 0x06, 0xF8, 0x54, 0x90, 0x7D,
786 0x67, 0x6F, 0x19, 0xD7, 0x0B, 0xF3, 0x92, 0x8D,
787 0x60, 0xC0, 0x18, 0x5A, 0x24, 0xC1, 0xD7, 0x60,
788 0x82, 0x9C, 0x22, 0x37, 0x45, 0xE3, 0x9D, 0xA6,
789 0x76, 0x37, 0xE1, 0x7A, 0x13, 0xB4, 0x40, 0x63,
790 0xF4, 0xD8, 0xDE, 0x41, 0x64, 0xFC, 0xE2, 0x42,
791 0x2E, 0x3F, 0xEA, 0xE1, 0x28, 0x06, 0xA5, 0xAC,
792 0x6A, 0xC1, 0x58, 0x0C, 0x84, 0xFF, 0x9B, 0x6A,
793 0xE5, 0xBE, 0x4E, 0x8C, 0x4C, 0xE9, 0x97, 0xD5,
794 0x24, 0x30, 0x1B, 0x19, 0xDF, 0x87, 0x56, 0x85,
795 0x31, 0x56, 0x5A, 0xDE, 0xE0, 0x6E, 0xC0, 0x1C,
796 0xCB, 0x51, 0x5B, 0x6E, 0xAC, 0xF5, 0xB0, 0x60,
797 0x60, 0x2F, 0x62, 0x0A, 0xEA, 0x62, 0x51, 0x2E,
798 0x5B, 0x1B, 0x99, 0x51, 0x3B, 0xAC, 0xE9, 0xC5,
799 0x59, 0x7D, 0x0E, 0xB6, 0x51, 0x6C, 0x16, 0x7A,
800 0xED, 0x52, 0x55, 0xB9, 0x76, 0x6C, 0x5E, 0x6E,
801 0x76, 0x97, 0x00, 0xC7, 0xEB, 0xFE, 0xEC, 0x10,
802 0x94, 0x2C, 0xA9, 0xAF, 0x9B, 0x09, 0x19, 0xB3,
803 0x17, 0x29, 0x96, 0xBA, 0x8E, 0xAC, 0x3D, 0x0A,
804 0x9B, 0x70, 0x54, 0x0F, 0x1E, 0xD4, 0xE8, 0x13,
805 0xE6, 0x8F, 0xAD, 0xFD, 0xFD, 0x13, 0xCF, 0xD5,
806 0x94, 0x06, 0xA0, 0x24, 0x79, 0xC0, 0xF8, 0x05,
807 0x3D, 0x19, 0xEB, 0x96, 0xDA, 0x31, 0xAE, 0xF5,
808 0x4D, 0x82, 0x2C, 0x23, 0x03, 0x9A, 0x43, 0x85,
809 0x94, 0x36, 0x30, 0xE8, 0x0A, 0x9B, 0x1F, 0x05,
810 0x6E, 0x4B, 0xA5, 0x98, 0x78, 0xBE, 0x73, 0x0D,
811 0x8C, 0x60, 0x55, 0x88, 0xD6, 0xA3, 0x80, 0x13,
812 0x19, 0xDB, 0xF8, 0xCD, 0xA7, 0xDC, 0x28, 0x4C,
813 0x09, 0xAF, 0xFE, 0x88, 0x77, 0xE1, 0x6E, 0x12,
814 0x57, 0x5A, 0xA8, 0xC6, 0x38, 0xCF, 0xF5, 0x0D,
815 0x42, 0x2C, 0x67, 0xB3, 0x22, 0x6F, 0x3D, 0x7D
816 };
817 static const uint8_t T14_CTR[] = { 0 };
818 static const uint8_t A14_CTR[] = { 0 };
819 #define A14_CTR_len 0
820
821 static const uint8_t K15_CTR[] = {
822 0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6,
823 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C
824 };
825 static const uint8_t IV15_CTR[] = {
826 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
827 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF
828 };
829 static const uint8_t P15_CTR[] = {
830 0x6B, 0xC1, 0xBE, 0xE2, 0x2E, 0x40, 0x9F, 0x96,
831 0xE9, 0x3D, 0x7E, 0x11, 0x73, 0x93, 0x17, 0x2A,
832 0xAE, 0x2D, 0x8A, 0x57, 0x1E, 0x03, 0xAC, 0x9C,
833 0x9E, 0xB7, 0x6F, 0xAC, 0x45, 0xAF, 0x8E, 0x51,
834 0x30, 0xC8, 0x1C, 0x46, 0xA3, 0x5C, 0xE4, 0x11,
835 0xE5, 0xFB, 0xC1, 0x19, 0x1A, 0x0A, 0x52, 0xEF,
836 0xF6, 0x9F, 0x24, 0x45, 0xDF, 0x4F, 0x9B, 0x17,
837 0xAD, 0x2B, 0x41, 0x7B, 0xE6, 0x6C, 0x37, 0x10
838 };
839
840 static const uint8_t C15_CTR[] = {
841 0x87, 0x4D, 0x61, 0x91, 0xB6, 0x20, 0xE3, 0x26,
842 0x1B, 0xEF, 0x68, 0x64, 0x99, 0x0D, 0xB6, 0xCE,
843 0x98, 0x06, 0xF6, 0x6B, 0x79, 0x70, 0xFD, 0xFF,
844 0x86, 0x17, 0x18, 0x7B, 0xB9, 0xFF, 0xFD, 0xFF,
845 0x5A, 0xE4, 0xDF, 0x3E, 0xDB, 0xD5, 0xD3, 0x5E,
846 0x5B, 0x4F, 0x09, 0x02, 0x0D, 0xB0, 0x3E, 0xAB,
847 0x1E, 0x03, 0x1D, 0xDA, 0x2F, 0xBE, 0x03, 0xD1,
848 0x79, 0x21, 0x70, 0xA0, 0xF3, 0x00, 0x9C, 0xEE
849 };
850
851 static const uint8_t T15_CTR[] = { 0 };
852 static const uint8_t A15_CTR[] = { 0 };
853 #define A15_CTR_len 0
854
855 #define bit_vector(N) \
856 {K##N, (KBITS(K##N)), IV##N, sizeof(IV##N), A##N, A##N##_len, \
857 P##N, P##N##_len, C##N, T##N, sizeof(T##N)}
858
859 static const uint8_t K1_CTR_BIT[] = {
860 0xd3, 0xc5, 0xd5, 0x92, 0x32, 0x7f, 0xb1, 0x1c,
861 0x40, 0x35, 0xc6, 0x68, 0x0a, 0xf8, 0xc6, 0xd1
862
863 };
864 static const uint8_t IV1_CTR_BIT[] = {
865 0x39, 0x8a, 0x59, 0xb4, 0xac, 0x00, 0x00, 0x00,
866 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
867 };
868
869 /* Last 3 bits (not to be ciphered) set to 1, since
870 * the output buffer is set to all 0xff */
871 static const uint8_t P1_CTR_BIT[] = {
872 0x98, 0x1b, 0xa6, 0x82, 0x4c, 0x1b, 0xfb, 0x1a,
873 0xb4, 0x85, 0x47, 0x20, 0x29, 0xb7, 0x1d, 0x80,
874 0x8c, 0xe3, 0x3e, 0x2c, 0xc3, 0xc0, 0xb5, 0xfc,
875 0x1f, 0x3d, 0xe8, 0xa6, 0xdc, 0x66, 0xb1, 0xf7
876 };
877
878 static const uint8_t C1_CTR_BIT[] = {
879 0xe9, 0xfe, 0xd8, 0xa6, 0x3d, 0x15, 0x53, 0x04,
880 0xd7, 0x1d, 0xf2, 0x0b, 0xf3, 0xe8, 0x22, 0x14,
881 0xb2, 0x0e, 0xd7, 0xda, 0xd2, 0xf2, 0x33, 0xdc,
882 0x3c, 0x22, 0xd7, 0xbd, 0xee, 0xed, 0x8e, 0x7f
883 };
884
885 static const uint8_t T1_CTR_BIT[] = { 0 };
886 static const uint8_t A1_CTR_BIT[] = { 0 };
887 #define A1_CTR_BIT_len 0
888 #define P1_CTR_BIT_len 253
889
890 static const uint8_t K2_CTR_BIT[] = {
891 0x2b, 0xd6, 0x45, 0x9f, 0x82, 0xc4, 0x40, 0xe0,
892 0x95, 0x2c, 0x49, 0x10, 0x48, 0x05, 0xff, 0x48
893 };
894
895 static const uint8_t IV2_CTR_BIT[] = {
896 0xc6, 0x75, 0xa6, 0x4b, 0x64, 0x00, 0x00, 0x00,
897 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
898 };
899
900 /* Last 2 bits (not to be ciphered) set to 1, since
901 * the output buffer is set to all 0xff */
902 static const uint8_t P2_CTR_BIT[] = {
903 0x7e, 0xc6, 0x12, 0x72, 0x74, 0x3b, 0xf1, 0x61,
904 0x47, 0x26, 0x44, 0x6a, 0x6c, 0x38, 0xce, 0xd1,
905 0x66, 0xf6, 0xca, 0x76, 0xeb, 0x54, 0x30, 0x04,
906 0x42, 0x86, 0x34, 0x6c, 0xef, 0x13, 0x0f, 0x92,
907 0x92, 0x2b, 0x03, 0x45, 0x0d, 0x3a, 0x99, 0x75,
908 0xe5, 0xbd, 0x2e, 0xa0, 0xeb, 0x55, 0xad, 0x8e,
909 0x1b, 0x19, 0x9e, 0x3e, 0xc4, 0x31, 0x60, 0x20,
910 0xe9, 0xa1, 0xb2, 0x85, 0xe7, 0x62, 0x79, 0x53,
911 0x59, 0xb7, 0xbd, 0xfd, 0x39, 0xbe, 0xf4, 0xb2,
912 0x48, 0x45, 0x83, 0xd5, 0xaf, 0xe0, 0x82, 0xae,
913 0xe6, 0x38, 0xbf, 0x5f, 0xd5, 0xa6, 0x06, 0x19,
914 0x39, 0x01, 0xa0, 0x8f, 0x4a, 0xb4, 0x1a, 0xab,
915 0x9b, 0x13, 0x48, 0x83
916 };
917
918 static const uint8_t C2_CTR_BIT[] = {
919 0x59, 0x61, 0x60, 0x53, 0x53, 0xc6, 0x4b, 0xdc,
920 0xa1, 0x5b, 0x19, 0x5e, 0x28, 0x85, 0x53, 0xa9,
921 0x10, 0x63, 0x25, 0x06, 0xd6, 0x20, 0x0a, 0xa7,
922 0x90, 0xc4, 0xc8, 0x06, 0xc9, 0x99, 0x04, 0xcf,
923 0x24, 0x45, 0xcc, 0x50, 0xbb, 0x1c, 0xf1, 0x68,
924 0xa4, 0x96, 0x73, 0x73, 0x4e, 0x08, 0x1b, 0x57,
925 0xe3, 0x24, 0xce, 0x52, 0x59, 0xc0, 0xe7, 0x8d,
926 0x4c, 0xd9, 0x7b, 0x87, 0x09, 0x76, 0x50, 0x3c,
927 0x09, 0x43, 0xf2, 0xcb, 0x5a, 0xe8, 0xf0, 0x52,
928 0xc7, 0xb7, 0xd3, 0x92, 0x23, 0x95, 0x87, 0xb8,
929 0x95, 0x60, 0x86, 0xbc, 0xab, 0x18, 0x83, 0x60,
930 0x42, 0xe2, 0xe6, 0xce, 0x42, 0x43, 0x2a, 0x17,
931 0x10, 0x5c, 0x53, 0xd3
932 };
933
934 static const uint8_t T2_CTR_BIT[] = { 0 };
935 static const uint8_t A2_CTR_BIT[] = { 0 };
936 #define A2_CTR_BIT_len 0
937 #define P2_CTR_BIT_len 798
938
939 static const uint8_t K3_CTR_BIT[] = {
940 0x0a, 0x8b, 0x6b, 0xd8, 0xd9, 0xb0, 0x8b, 0x08,
941 0xd6, 0x4e, 0x32, 0xd1, 0x81, 0x77, 0x77, 0xfb
942 };
943
944 static const uint8_t IV3_CTR_BIT[] = {
945 0x54, 0x4d, 0x49, 0xcd, 0x20, 0x00, 0x00, 0x00,
946 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
947 };
948
949 /* Last 2 bits (not to be ciphered) set to 1, since
950 * the output buffer is set to all 0xff */
951 static const uint8_t P3_CTR_BIT[] = {
952 0xfd, 0x40, 0xa4, 0x1d, 0x37, 0x0a, 0x1f, 0x65,
953 0x74, 0x50, 0x95, 0x68, 0x7d, 0x47, 0xba, 0x1d,
954 0x36, 0xd2, 0x34, 0x9e, 0x23, 0xf6, 0x44, 0x39,
955 0x2c, 0x8e, 0xa9, 0xc4, 0x9d, 0x40, 0xc1, 0x32,
956 0x71, 0xaf, 0xf2, 0x64, 0xd0, 0xf2, 0x4b
957 };
958
959 static const uint8_t C3_CTR_BIT[] = {
960 0x75, 0x75, 0x0d, 0x37, 0xb4, 0xbb, 0xa2, 0xa4,
961 0xde, 0xdb, 0x34, 0x23, 0x5b, 0xd6, 0x8c, 0x66,
962 0x45, 0xac, 0xda, 0xac, 0xa4, 0x81, 0x38, 0xa3,
963 0xb0, 0xc4, 0x71, 0xe2, 0xa7, 0x04, 0x1a, 0x57,
964 0x64, 0x23, 0xd2, 0x92, 0x72, 0x87, 0xf3
965 };
966
967 static const uint8_t T3_CTR_BIT[] = { 0 };
968 static const uint8_t A3_CTR_BIT[] = { 0 };
969 #define A3_CTR_BIT_len 0
970 #define P3_CTR_BIT_len 310
971
972 static const uint8_t K4_CTR_BIT[] = {
973 0xaa, 0x1f, 0x95, 0xae, 0xa5, 0x33, 0xbc, 0xb3,
974 0x2e, 0xb6, 0x3b, 0xf5, 0x2d, 0x8f, 0x83, 0x1a
975 };
976
977 static const uint8_t IV4_CTR_BIT[] = {
978 0x72, 0xd8, 0xc6, 0x71, 0x84, 0x00, 0x00, 0x00,
979 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
980 };
981
982 /* Last 2 bits (not to be ciphered) set to 1, since
983 * the output buffer is set to all 0xff */
984 static const uint8_t P4_CTR_BIT[] = {
985 0xfb, 0x1b, 0x96, 0xc5, 0xc8, 0xba, 0xdf, 0xb2,
986 0xe8, 0xe8, 0xed, 0xfd, 0xe7, 0x8e, 0x57, 0xf2,
987 0xad, 0x81, 0xe7, 0x41, 0x03, 0xfc, 0x43, 0x0a,
988 0x53, 0x4d, 0xcc, 0x37, 0xaf, 0xce, 0xc7, 0x0e,
989 0x15, 0x17, 0xbb, 0x06, 0xf2, 0x72, 0x19, 0xda,
990 0xe4, 0x90, 0x22, 0xdd, 0xc4, 0x7a, 0x06, 0x8d,
991 0xe4, 0xc9, 0x49, 0x6a, 0x95, 0x1a, 0x6b, 0x09,
992 0xed, 0xbd, 0xc8, 0x64, 0xc7, 0xad, 0xbd, 0x74,
993 0x0a, 0xc5, 0x0c, 0x02, 0x2f, 0x30, 0x82, 0xba,
994 0xfd, 0x22, 0xd7, 0x81, 0x97, 0xc5, 0xd5, 0x08,
995 0xb9, 0x77, 0xbc, 0xa1, 0x3f, 0x32, 0xe6, 0x52,
996 0xe7, 0x4b, 0xa7, 0x28, 0x57, 0x60, 0x77, 0xce,
997 0x62, 0x8c, 0x53, 0x5e, 0x87, 0xdc, 0x60, 0x77,
998 0xba, 0x07, 0xd2, 0x90, 0x68, 0x59, 0x0c, 0x8c,
999 0xb5, 0xf1, 0x08, 0x8e, 0x08, 0x2c, 0xfa, 0x0e,
1000 0xc9, 0x61, 0x30, 0x2d, 0x69, 0xcf, 0x3d, 0x47
1001 };
1002
1003 static const uint8_t C4_CTR_BIT[] = {
1004 0xdf, 0xb4, 0x40, 0xac, 0xb3, 0x77, 0x35, 0x49,
1005 0xef, 0xc0, 0x46, 0x28, 0xae, 0xb8, 0xd8, 0x15,
1006 0x62, 0x75, 0x23, 0x0b, 0xdc, 0x69, 0x0d, 0x94,
1007 0xb0, 0x0d, 0x8d, 0x95, 0xf2, 0x8c, 0x4b, 0x56,
1008 0x30, 0x7f, 0x60, 0xf4, 0xca, 0x55, 0xeb, 0xa6,
1009 0x61, 0xeb, 0xba, 0x72, 0xac, 0x80, 0x8f, 0xa8,
1010 0xc4, 0x9e, 0x26, 0x78, 0x8e, 0xd0, 0x4a, 0x5d,
1011 0x60, 0x6c, 0xb4, 0x18, 0xde, 0x74, 0x87, 0x8b,
1012 0x9a, 0x22, 0xf8, 0xef, 0x29, 0x59, 0x0b, 0xc4,
1013 0xeb, 0x57, 0xc9, 0xfa, 0xf7, 0xc4, 0x15, 0x24,
1014 0xa8, 0x85, 0xb8, 0x97, 0x9c, 0x42, 0x3f, 0x2f,
1015 0x8f, 0x8e, 0x05, 0x92, 0xa9, 0x87, 0x92, 0x01,
1016 0xbe, 0x7f, 0xf9, 0x77, 0x7a, 0x16, 0x2a, 0xb8,
1017 0x10, 0xfe, 0xb3, 0x24, 0xba, 0x74, 0xc4, 0xc1,
1018 0x56, 0xe0, 0x4d, 0x39, 0x09, 0x72, 0x09, 0x65,
1019 0x3a, 0xc3, 0x3e, 0x5a, 0x5f, 0x2d, 0x88, 0x67
1020 };
1021
1022 static const uint8_t T4_CTR_BIT[] = { 0 };
1023 static const uint8_t A4_CTR_BIT[] = { 0 };
1024 #define A4_CTR_BIT_len 0
1025 #define P4_CTR_BIT_len 1022
1026
1027 static const uint8_t K5_CTR_BIT[] = {
1028 0x96, 0x18, 0xae, 0x46, 0x89, 0x1f, 0x86, 0x57,
1029 0x8e, 0xeb, 0xe9, 0x0e, 0xf7, 0xa1, 0x20, 0x2e
1030 };
1031
1032 static const uint8_t IV5_CTR_BIT[] = {
1033 0xc6, 0x75, 0xa6, 0x4b, 0x64, 0x00, 0x00, 0x00,
1034 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
1035 };
1036
1037 /* Last 3 bits (not to be ciphered) set to 1, since
1038 * the output buffer is set to all 0xff */
1039 static const uint8_t P5_CTR_BIT[] = {
1040 0x8d, 0xaa, 0x17, 0xb1, 0xae, 0x05, 0x05, 0x29,
1041 0xc6, 0x82, 0x7f, 0x28, 0xc0, 0xef, 0x6a, 0x12,
1042 0x42, 0xe9, 0x3f, 0x8b, 0x31, 0x4f, 0xb1, 0x8a,
1043 0x77, 0xf7, 0x90, 0xae, 0x04, 0x9f, 0xed, 0xd6,
1044 0x12, 0x26, 0x7f, 0xec, 0xae, 0xfc, 0x45, 0x01,
1045 0x74, 0xd7, 0x6d, 0x9f, 0x9a, 0xa7, 0x75, 0x5a,
1046 0x30, 0xcd, 0x90, 0xa9, 0xa5, 0x87, 0x4b, 0xf4,
1047 0x8e, 0xaf, 0x70, 0xee, 0xa3, 0xa6, 0x2a, 0x25,
1048 0x0a, 0x8b, 0x6b, 0xd8, 0xd9, 0xb0, 0x8b, 0x08,
1049 0xd6, 0x4e, 0x32, 0xd1, 0x81, 0x77, 0x77, 0xfb,
1050 0x54, 0x4d, 0x49, 0xcd, 0x49, 0x72, 0x0e, 0x21,
1051 0x9d, 0xbf, 0x8b, 0xbe, 0xd3, 0x39, 0x04, 0xe1,
1052 0xfd, 0x40, 0xa4, 0x1d, 0x37, 0x0a, 0x1f, 0x65,
1053 0x74, 0x50, 0x95, 0x68, 0x7d, 0x47, 0xba, 0x1d,
1054 0x36, 0xd2, 0x34, 0x9e, 0x23, 0xf6, 0x44, 0x39,
1055 0x2c, 0x8e, 0xa9, 0xc4, 0x9d, 0x40, 0xc1, 0x32,
1056 0x71, 0xaf, 0xf2, 0x64, 0xd0, 0xf2, 0x48, 0x41,
1057 0xd6, 0x46, 0x5f, 0x09, 0x96, 0xff, 0x84, 0xe6,
1058 0x5f, 0xc5, 0x17, 0xc5, 0x3e, 0xfc, 0x33, 0x63,
1059 0xc3, 0x84, 0x92, 0xaf
1060 };
1061
1062 static const uint8_t C5_CTR_BIT[] = {
1063 0x91, 0x9c, 0x8c, 0x33, 0xd6, 0x67, 0x89, 0x70,
1064 0x3d, 0x05, 0xa0, 0xd7, 0xce, 0x82, 0xa2, 0xae,
1065 0xac, 0x4e, 0xe7, 0x6c, 0x0f, 0x4d, 0xa0, 0x50,
1066 0x33, 0x5e, 0x8a, 0x84, 0xe7, 0x89, 0x7b, 0xa5,
1067 0xdf, 0x2f, 0x36, 0xbd, 0x51, 0x3e, 0x3d, 0x0c,
1068 0x85, 0x78, 0xc7, 0xa0, 0xfc, 0xf0, 0x43, 0xe0,
1069 0x3a, 0xa3, 0xa3, 0x9f, 0xba, 0xad, 0x7d, 0x15,
1070 0xbe, 0x07, 0x4f, 0xaa, 0x5d, 0x90, 0x29, 0xf7,
1071 0x1f, 0xb4, 0x57, 0xb6, 0x47, 0x83, 0x47, 0x14,
1072 0xb0, 0xe1, 0x8f, 0x11, 0x7f, 0xca, 0x10, 0x67,
1073 0x79, 0x45, 0x09, 0x6c, 0x8c, 0x5f, 0x32, 0x6b,
1074 0xa8, 0xd6, 0x09, 0x5e, 0xb2, 0x9c, 0x3e, 0x36,
1075 0xcf, 0x24, 0x5d, 0x16, 0x22, 0xaa, 0xfe, 0x92,
1076 0x1f, 0x75, 0x66, 0xc4, 0xf5, 0xd6, 0x44, 0xf2,
1077 0xf1, 0xfc, 0x0e, 0xc6, 0x84, 0xdd, 0xb2, 0x13,
1078 0x49, 0x74, 0x76, 0x22, 0xe2, 0x09, 0x29, 0x5d,
1079 0x27, 0xff, 0x3f, 0x95, 0x62, 0x33, 0x71, 0xd4,
1080 0x9b, 0x14, 0x7c, 0x0a, 0xf4, 0x86, 0x17, 0x1f,
1081 0x22, 0xcd, 0x04, 0xb1, 0xcb, 0xeb, 0x26, 0x58,
1082 0x22, 0x3e, 0x69, 0x3f
1083 };
1084
1085 static const uint8_t T5_CTR_BIT[] = { 0 };
1086 static const uint8_t A5_CTR_BIT[] = { 0 };
1087 #define A5_CTR_BIT_len 0
1088 #define P5_CTR_BIT_len 1245
1089
1090 static const uint8_t K6_CTR_BIT[] = {
1091 0x54, 0xf4, 0xe2, 0xe0, 0x4c, 0x83, 0x78, 0x6e,
1092 0xec, 0x8f, 0xb5, 0xab, 0xe8, 0xe3, 0x65, 0x66
1093
1094 };
1095 static const uint8_t IV6_CTR_BIT[] = {
1096 0xac, 0xa4, 0xf5, 0x0f, 0x58, 0x00, 0x00, 0x00,
1097 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
1098 };
1099
1100 /* Last 3 bits (not to be ciphered) set to 1, since
1101 * the output buffer is set to all 0xff */
1102 static const uint8_t P6_CTR_BIT[] = {
1103 0x40, 0x98, 0x1b, 0xa6, 0x82, 0x4c, 0x1b, 0xfb,
1104 0x42, 0x86, 0xb2, 0x99, 0x78, 0x3d, 0xaf, 0x44,
1105 0x2c, 0x09, 0x9f, 0x7a, 0xb0, 0xf5, 0x8d, 0x5c,
1106 0x8e, 0x46, 0xb1, 0x04, 0xf0, 0x8f, 0x01, 0xb4,
1107 0x1a, 0xb4, 0x85, 0x47, 0x20, 0x29, 0xb7, 0x1d,
1108 0x36, 0xbd, 0x1a, 0x3d, 0x90, 0xdc, 0x3a, 0x41,
1109 0xb4, 0x6d, 0x51, 0x67, 0x2a, 0xc4, 0xc9, 0x66,
1110 0x3a, 0x2b, 0xe0, 0x63, 0xda, 0x4b, 0xc8, 0xd2,
1111 0x80, 0x8c, 0xe3, 0x3e, 0x2c, 0xcc, 0xbf, 0xc6,
1112 0x34, 0xe1, 0xb2, 0x59, 0x06, 0x08, 0x76, 0xa0,
1113 0xfb, 0xb5, 0xa4, 0x37, 0xeb, 0xcc, 0x8d, 0x31,
1114 0xc1, 0x9e, 0x44, 0x54, 0x31, 0x87, 0x45, 0xe3,
1115 0xfa, 0x16, 0xbb, 0x11, 0xad, 0xae, 0x24, 0x88,
1116 0x79, 0xfe, 0x52, 0xdb, 0x25, 0x43, 0xe5, 0x3c,
1117 0xf4, 0x45, 0xd3, 0xd8, 0x28, 0xce, 0x0b, 0xf5,
1118 0xc5, 0x60, 0x59, 0x3d, 0x97, 0x27, 0x8a, 0x59,
1119 0x76, 0x2d, 0xd0, 0xc2, 0xc9, 0xcd, 0x68, 0xd4,
1120 0x49, 0x6a, 0x79, 0x25, 0x08, 0x61, 0x40, 0x14,
1121 0xb1, 0x3b, 0x6a, 0xa5, 0x11, 0x28, 0xc1, 0x8c,
1122 0xd6, 0xa9, 0x0b, 0x87, 0x97, 0x8c, 0x2f, 0xf1,
1123 0xca, 0xbe, 0x7d, 0x9f, 0x89, 0x8a, 0x41, 0x1b,
1124 0xfd, 0xb8, 0x4f, 0x68, 0xf6, 0x72, 0x7b, 0x14,
1125 0x99, 0xcd, 0xd3, 0x0d, 0xf0, 0x44, 0x3a, 0xb4,
1126 0xa6, 0x66, 0x53, 0x33, 0x0b, 0xcb, 0xa1, 0x10,
1127 0x5e, 0x4c, 0xec, 0x03, 0x4c, 0x73, 0xe6, 0x05,
1128 0xb4, 0x31, 0x0e, 0xaa, 0xad, 0xcf, 0xd5, 0xb0,
1129 0xca, 0x27, 0xff, 0xd8, 0x9d, 0x14, 0x4d, 0xf4,
1130 0x79, 0x27, 0x59, 0x42, 0x7c, 0x9c, 0xc1, 0xf8,
1131 0xcd, 0x8c, 0x87, 0x20, 0x23, 0x64, 0xb8, 0xa6,
1132 0x87, 0x95, 0x4c, 0xb0, 0x5a, 0x8d, 0x4e, 0x2d,
1133 0x99, 0xe7, 0x3d, 0xb1, 0x60, 0xde, 0xb1, 0x80,
1134 0xad, 0x08, 0x41, 0xe9, 0x67, 0x41, 0xa5, 0xd5,
1135 0x9f, 0xe4, 0x18, 0x9f, 0x15, 0x42, 0x00, 0x26,
1136 0xfe, 0x4c, 0xd1, 0x21, 0x04, 0x93, 0x2f, 0xb3,
1137 0x8f, 0x73, 0x53, 0x40, 0x43, 0x8a, 0xaf, 0x7e,
1138 0xca, 0x6f, 0xd5, 0xcf, 0xd3, 0xa1, 0x95, 0xce,
1139 0x5a, 0xbe, 0x65, 0x27, 0x2a, 0xf6, 0x07, 0xad,
1140 0xa1, 0xbe, 0x65, 0xa6, 0xb4, 0xc9, 0xc0, 0x69,
1141 0x32, 0x34, 0x09, 0x2c, 0x4d, 0x01, 0x8f, 0x17,
1142 0x56, 0xc6, 0xdb, 0x9d, 0xc8, 0xa6, 0xd8, 0x0b,
1143 0x88, 0x81, 0x38, 0x61, 0x6b, 0x68, 0x12, 0x62,
1144 0xf9, 0x54, 0xd0, 0xe7, 0x71, 0x17, 0x48, 0x78,
1145 0x0d, 0x92, 0x29, 0x1d, 0x86, 0x29, 0x99, 0x72,
1146 0xdb, 0x74, 0x1c, 0xfa, 0x4f, 0x37, 0xb8, 0xb5,
1147 0x6c, 0xdb, 0x18, 0xa7, 0xca, 0x82, 0x18, 0xe8,
1148 0x6e, 0x4b, 0x4b, 0x71, 0x6a, 0x4d, 0x04, 0x37,
1149 0x1f, 0xbe, 0xc2, 0x62, 0xfc, 0x5a, 0xd0, 0xb3,
1150 0x81, 0x9b, 0x18, 0x7b, 0x97, 0xe5, 0x5b, 0x1a,
1151 0x4d, 0x7c, 0x19, 0xee, 0x24, 0xc8, 0xb4, 0xd7,
1152 0x72, 0x3c, 0xfe, 0xdf, 0x04, 0x5b, 0x8a, 0xca,
1153 0xe4, 0x86, 0x95, 0x17, 0xd8, 0x0e, 0x50, 0x61,
1154 0x5d, 0x90, 0x35, 0xd5, 0xd9, 0xc5, 0xa4, 0x0a,
1155 0xf6, 0x02, 0x28, 0x0b, 0x54, 0x25, 0x97, 0xb0,
1156 0xcb, 0x18, 0x61, 0x9e, 0xeb, 0x35, 0x92, 0x57,
1157 0x59, 0xd1, 0x95, 0xe1, 0x00, 0xe8, 0xe4, 0xaa,
1158 0x0c, 0x38, 0xa3, 0xc2, 0xab, 0xe0, 0xf3, 0xd8,
1159 0xff, 0x04, 0xf3, 0xc3, 0x3c, 0x29, 0x50, 0x69,
1160 0xc2, 0x36, 0x94, 0xb5, 0xbb, 0xea, 0xcd, 0xd5,
1161 0x42, 0xe2, 0x8e, 0x8a, 0x94, 0xed, 0xb9, 0x11,
1162 0x9f, 0x41, 0x2d, 0x05, 0x4b, 0xe1, 0xfa, 0x72,
1163 0x00, 0xb0, 0x97
1164 };
1165
1166 static const uint8_t C6_CTR_BIT[] = {
1167 0x5c, 0xb7, 0x2c, 0x6e, 0xdc, 0x87, 0x8f, 0x15,
1168 0x66, 0xe1, 0x02, 0x53, 0xaf, 0xc3, 0x64, 0xc9,
1169 0xfa, 0x54, 0x0d, 0x91, 0x4d, 0xb9, 0x4c, 0xbe,
1170 0xe2, 0x75, 0xd0, 0x91, 0x7c, 0xa6, 0xaf, 0x0d,
1171 0x77, 0xac, 0xb4, 0xef, 0x3b, 0xbe, 0x1a, 0x72,
1172 0x2b, 0x2e, 0xf5, 0xbd, 0x1d, 0x4b, 0x8e, 0x2a,
1173 0xa5, 0x02, 0x4e, 0xc1, 0x38, 0x8a, 0x20, 0x1e,
1174 0x7b, 0xce, 0x79, 0x20, 0xae, 0xc6, 0x15, 0x89,
1175 0x5f, 0x76, 0x3a, 0x55, 0x64, 0xdc, 0xc4, 0xc4,
1176 0x82, 0xa2, 0xee, 0x1d, 0x8b, 0xfe, 0xcc, 0x44,
1177 0x98, 0xec, 0xa8, 0x3f, 0xbb, 0x75, 0xf9, 0xab,
1178 0x53, 0x0e, 0x0d, 0xaf, 0xbe, 0xde, 0x2f, 0xa5,
1179 0x89, 0x5b, 0x82, 0x99, 0x1b, 0x62, 0x77, 0xc5,
1180 0x29, 0xe0, 0xf2, 0x52, 0x9d, 0x7f, 0x79, 0x60,
1181 0x6b, 0xe9, 0x67, 0x06, 0x29, 0x6d, 0xed, 0xfa,
1182 0x9d, 0x74, 0x12, 0xb6, 0x16, 0x95, 0x8c, 0xb5,
1183 0x63, 0xc6, 0x78, 0xc0, 0x28, 0x25, 0xc3, 0x0d,
1184 0x0a, 0xee, 0x77, 0xc4, 0xc1, 0x46, 0xd2, 0x76,
1185 0x54, 0x12, 0x42, 0x1a, 0x80, 0x8d, 0x13, 0xce,
1186 0xc8, 0x19, 0x69, 0x4c, 0x75, 0xad, 0x57, 0x2e,
1187 0x9b, 0x97, 0x3d, 0x94, 0x8b, 0x81, 0xa9, 0x33,
1188 0x7c, 0x3b, 0x2a, 0x17, 0x19, 0x2e, 0x22, 0xc2,
1189 0x06, 0x9f, 0x7e, 0xd1, 0x16, 0x2a, 0xf4, 0x4c,
1190 0xde, 0xa8, 0x17, 0x60, 0x36, 0x65, 0xe8, 0x07,
1191 0xce, 0x40, 0xc8, 0xe0, 0xdd, 0x9d, 0x63, 0x94,
1192 0xdc, 0x6e, 0x31, 0x15, 0x3f, 0xe1, 0x95, 0x5c,
1193 0x47, 0xaf, 0xb5, 0x1f, 0x26, 0x17, 0xee, 0x0c,
1194 0x5e, 0x3b, 0x8e, 0xf1, 0xad, 0x75, 0x74, 0xed,
1195 0x34, 0x3e, 0xdc, 0x27, 0x43, 0xcc, 0x94, 0xc9,
1196 0x90, 0xe1, 0xf1, 0xfd, 0x26, 0x42, 0x53, 0xc1,
1197 0x78, 0xde, 0xa7, 0x39, 0xc0, 0xbe, 0xfe, 0xeb,
1198 0xcd, 0x9f, 0x9b, 0x76, 0xd4, 0x9c, 0x10, 0x15,
1199 0xc9, 0xfe, 0xcf, 0x50, 0xe5, 0x3b, 0x8b, 0x52,
1200 0x04, 0xdb, 0xcd, 0x3e, 0xed, 0x86, 0x38, 0x55,
1201 0xda, 0xbc, 0xdc, 0xc9, 0x4b, 0x31, 0xe3, 0x18,
1202 0x02, 0x15, 0x68, 0x85, 0x5c, 0x8b, 0x9e, 0x52,
1203 0xa9, 0x81, 0x95, 0x7a, 0x11, 0x28, 0x27, 0xf9,
1204 0x78, 0xba, 0x96, 0x0f, 0x14, 0x47, 0x91, 0x1b,
1205 0x31, 0x7b, 0x55, 0x11, 0xfb, 0xcc, 0x7f, 0xb1,
1206 0x3a, 0xc1, 0x53, 0xdb, 0x74, 0x25, 0x11, 0x17,
1207 0xe4, 0x86, 0x1e, 0xb9, 0xe8, 0x3b, 0xff, 0xff,
1208 0xc4, 0xeb, 0x77, 0x55, 0x57, 0x90, 0x38, 0xe5,
1209 0x79, 0x24, 0xb1, 0xf7, 0x8b, 0x3e, 0x1a, 0xd9,
1210 0x0b, 0xab, 0x2a, 0x07, 0x87, 0x1b, 0x72, 0xdb,
1211 0x5e, 0xef, 0x96, 0xc3, 0x34, 0x04, 0x49, 0x66,
1212 0xdb, 0x0c, 0x37, 0xca, 0xfd, 0x1a, 0x89, 0xe5,
1213 0x64, 0x6a, 0x35, 0x80, 0xeb, 0x64, 0x65, 0xf1,
1214 0x21, 0xdc, 0xe9, 0xcb, 0x88, 0xd8, 0x5b, 0x96,
1215 0xcf, 0x23, 0xcc, 0xcc, 0xd4, 0x28, 0x07, 0x67,
1216 0xbe, 0xe8, 0xee, 0xb2, 0x3d, 0x86, 0x52, 0x46,
1217 0x1d, 0xb6, 0x49, 0x31, 0x03, 0x00, 0x3b, 0xaf,
1218 0x89, 0xf5, 0xe1, 0x82, 0x61, 0xea, 0x43, 0xc8,
1219 0x4a, 0x92, 0xeb, 0xff, 0xff, 0xe4, 0x90, 0x9d,
1220 0xc4, 0x6c, 0x51, 0x92, 0xf8, 0x25, 0xf7, 0x70,
1221 0x60, 0x0b, 0x96, 0x02, 0xc5, 0x57, 0xb5, 0xf8,
1222 0xb4, 0x31, 0xa7, 0x9d, 0x45, 0x97, 0x7d, 0xd9,
1223 0xc4, 0x1b, 0x86, 0x3d, 0xa9, 0xe1, 0x42, 0xe9,
1224 0x00, 0x20, 0xcf, 0xd0, 0x74, 0xd6, 0x92, 0x7b,
1225 0x7a, 0xb3, 0xb6, 0x72, 0x5d, 0x1a, 0x6f, 0x3f,
1226 0x98, 0xb9, 0xc9, 0xda, 0xa8, 0x98, 0x2a, 0xff,
1227 0x06, 0x78, 0x2f
1228 };
1229
1230 static const uint8_t T6_CTR_BIT[] = { 0 };
1231 static const uint8_t A6_CTR_BIT[] = { 0 };
1232 #define A6_CTR_BIT_len 0
1233 #define P6_CTR_BIT_len 3861
1234
1235 static const struct gcm_ctr_vector ctr_vectors[] = {
1236 /*
1237 * field order {K, Klen, IV, IVlen, A, Alen, P, Plen, C, T, Tlen};
1238 * original vector does not have a valid sub hash key
1239 */
1240 vector(1_CTR),
1241 vector(2_CTR),
1242 vector(3_CTR),
1243 vector(4_CTR),
1244 vector(5_CTR),
1245 vector(6_CTR),
1246 vector(7_CTR),
1247 vector(8_CTR),
1248 vector(9_CTR),
1249 vector(10_CTR),
1250 vector(11_CTR),
1251 vector(12_CTR),
1252 vector(13_CTR),
1253 vector(14_CTR),
1254 vector(15_CTR)
1255 };
1256
1257 static const struct gcm_ctr_vector ctr_bit_vectors[] = {
1258 bit_vector(1_CTR_BIT),
1259 bit_vector(2_CTR_BIT),
1260 bit_vector(3_CTR_BIT),
1261 bit_vector(4_CTR_BIT),
1262 bit_vector(5_CTR_BIT),
1263 bit_vector(6_CTR_BIT)
1264 };
1265
1266 static int
1267 test_ctr(struct MB_MGR *mb_mgr,
1268 const void *expkey,
1269 unsigned key_len,
1270 const void *iv,
1271 unsigned iv_len,
1272 const uint8_t *in_text,
1273 const uint8_t *out_text,
1274 unsigned text_len,
1275 int dir,
1276 int order,
1277 const JOB_CIPHER_MODE alg)
1278 {
1279 uint32_t text_byte_len;
1280 struct JOB_AES_HMAC *job;
1281 uint8_t padding[16];
1282 uint8_t *target;
1283 int ret = -1;
1284
1285 /* Get number of bytes (in case algo is CNTR_BITLEN) */
1286 if (alg == CNTR)
1287 text_byte_len = text_len;
1288 else
1289 text_byte_len = BYTE_ROUND_UP(text_len);
1290
1291 target = malloc(text_byte_len + (sizeof(padding) * 2));
1292 if (target == NULL) {
1293 fprintf(stderr, "Can't allocate buffer memory\n");
1294 goto end;
1295 }
1296
1297 memset(target, -1, text_byte_len + (sizeof(padding) * 2));
1298 memset(padding, -1, sizeof(padding));
1299
1300 while ((job = IMB_FLUSH_JOB(mb_mgr)) != NULL)
1301 ;
1302
1303 job = IMB_GET_NEXT_JOB(mb_mgr);
1304 job->cipher_direction = dir;
1305 job->chain_order = order;
1306 job->dst = target + 16;
1307 job->src = in_text;
1308 job->cipher_mode = alg;
1309 job->aes_enc_key_expanded = expkey;
1310 job->aes_dec_key_expanded = expkey;
1311 job->aes_key_len_in_bytes = key_len;
1312 job->iv = iv;
1313 job->iv_len_in_bytes = iv_len;
1314 job->cipher_start_src_offset_in_bytes = 0;
1315 if (alg == CNTR)
1316 job->msg_len_to_cipher_in_bytes = text_byte_len;
1317 else
1318 job->msg_len_to_cipher_in_bits = text_len;
1319
1320 job->hash_alg = NULL_HASH;
1321
1322 job = IMB_SUBMIT_JOB(mb_mgr);
1323 if (!job) {
1324 printf("%d Unexpected null return from submit_job\n", __LINE__);
1325 goto end;
1326 }
1327 if (job->status != STS_COMPLETED) {
1328 printf("%d Error status:%d", __LINE__, job->status);
1329 goto end;
1330 }
1331 job = IMB_FLUSH_JOB(mb_mgr);
1332 if (job) {
1333 printf("%u Unexpected return from flush_job\n", __LINE__);
1334 goto end;
1335 }
1336
1337 if (memcmp(out_text, target + 16, text_byte_len)) {
1338 printf("mismatched\n");
1339 hexdump(stderr, "Target", target, text_byte_len + 32);
1340 hexdump(stderr, "Expected", out_text, text_byte_len);
1341 goto end;
1342 }
1343 if (memcmp(padding, target, sizeof(padding))) {
1344 printf("overwrite head\n");
1345 hexdump(stderr, "Target", target, text_byte_len + 32);
1346 goto end;
1347 }
1348 if (memcmp(padding, target + sizeof(padding) + text_byte_len,
1349 sizeof(padding))) {
1350 printf("overwrite tail\n");
1351 hexdump(stderr, "Target", target, text_byte_len + 32);
1352 goto end;
1353 }
1354 ret = 0;
1355 while ((job = IMB_FLUSH_JOB(mb_mgr)) != NULL)
1356 ;
1357 end:
1358 if (target != NULL)
1359 free(target);
1360 return ret;
1361 }
1362
1363 static int
1364 test_ctr_vectors(struct MB_MGR *mb_mgr, const struct gcm_ctr_vector *vectors,
1365 const uint32_t vectors_cnt, const JOB_CIPHER_MODE alg)
1366 {
1367 uint32_t vect;
1368 int errors = 0;
1369 DECLARE_ALIGNED(uint32_t expkey[4*15], 16);
1370 DECLARE_ALIGNED(uint32_t dust[4*15], 16);
1371
1372 printf("AES-CTR standard test vectors:\n");
1373 for (vect = 0; vect < vectors_cnt; vect++) {
1374 #ifdef DEBUG
1375 if (alg == CNTR)
1376 printf("Standard vector %d/%d Keylen:%d IVlen:%d PTLen:%d ",
1377 vect, vectors_cnt - 1,
1378 (int) vectors[vect].Klen,
1379 (int) vectors[vect].IVlen,
1380 (int) vectors[vect].Plen);
1381 else
1382 printf("Bit vector %d/%d Keylen:%d IVlen:%d PTLen:%d ",
1383 vect, vectors_cnt - 1,
1384 (int) vectors[vect].Klen,
1385 (int) vectors[vect].IVlen,
1386 (int) vectors[vect].Plen);
1387 #else
1388 printf(".");
1389 #endif
1390
1391
1392 switch (vectors[vect].Klen) {
1393 case BITS_128:
1394 IMB_AES_KEYEXP_128(mb_mgr, vectors[vect].K,
1395 expkey, dust);
1396 break;
1397 case BITS_192:
1398 IMB_AES_KEYEXP_192(mb_mgr, vectors[vect].K,
1399 expkey, dust);
1400 break;
1401 case BITS_256:
1402 IMB_AES_KEYEXP_256(mb_mgr, vectors[vect].K,
1403 expkey, dust);
1404 break;
1405 default:
1406 return -1;
1407 }
1408
1409 if (test_ctr(mb_mgr,
1410 expkey, vectors[vect].Klen,
1411 vectors[vect].IV,
1412 (unsigned) vectors[vect].IVlen,
1413 vectors[vect].P, vectors[vect].C,
1414 (unsigned) vectors[vect].Plen,
1415 ENCRYPT, CIPHER_HASH, alg)) {
1416 printf("error #%d encrypt\n", vect + 1);
1417 errors++;
1418 }
1419
1420 if (test_ctr(mb_mgr,
1421 expkey, vectors[vect].Klen,
1422 vectors[vect].IV,
1423 (unsigned) vectors[vect].IVlen,
1424 vectors[vect].C, vectors[vect].P,
1425 (unsigned) vectors[vect].Plen,
1426 DECRYPT, HASH_CIPHER, alg)) {
1427 printf("error #%d decrypt\n", vect + 1);
1428 errors++;
1429 }
1430
1431 if (vectors[vect].IVlen == 12) {
1432 /* IV in the table didn't
1433 * include block counter (12 bytes).
1434 * Let's encrypt & decrypt the same but
1435 * with 16 byte IV that includes block counter.
1436 */
1437 const unsigned new_iv_len = 16;
1438 const unsigned orig_iv_len = 12;
1439 uint8_t local_iv[16];
1440
1441 memcpy(local_iv, vectors[vect].IV, orig_iv_len);
1442 /* 32-bit 0x01000000 in LE */
1443 local_iv[12] = 0x00;
1444 local_iv[13] = 0x00;
1445 local_iv[14] = 0x00;
1446 local_iv[15] = 0x01;
1447
1448 if (test_ctr(mb_mgr,
1449 expkey, vectors[vect].Klen,
1450 local_iv, new_iv_len,
1451 vectors[vect].P, vectors[vect].C,
1452 (unsigned) vectors[vect].Plen,
1453 ENCRYPT, CIPHER_HASH, alg)) {
1454 printf("error #%d encrypt\n", vect + 1);
1455 errors++;
1456 }
1457
1458 if (test_ctr(mb_mgr,
1459 expkey, vectors[vect].Klen,
1460 local_iv, new_iv_len,
1461 vectors[vect].C, vectors[vect].P,
1462 (unsigned) vectors[vect].Plen,
1463 DECRYPT, HASH_CIPHER, alg)) {
1464 printf("error #%d decrypt\n", vect + 1);
1465 errors++;
1466 }
1467 }
1468 }
1469 printf("\n");
1470 return errors;
1471 }
1472
1473 int
1474 ctr_test(const enum arch_type arch,
1475 struct MB_MGR *mb_mgr)
1476 {
1477 int errors;
1478
1479 (void) arch; /* unused */
1480
1481 const uint32_t ctr_vec_cnt = DIM(ctr_vectors);
1482 const uint32_t ctr_bit_vec_cnt = DIM(ctr_bit_vectors);
1483
1484 /* Standard CTR vectors */
1485 errors = test_ctr_vectors(mb_mgr, ctr_vectors, ctr_vec_cnt, CNTR);
1486
1487 /* CTR_BITLEN vectors */
1488 errors += test_ctr_vectors(mb_mgr, ctr_bit_vectors, ctr_bit_vec_cnt,
1489 CNTR_BITLEN);
1490
1491 if (0 == errors)
1492 printf("...Pass\n");
1493 else
1494 printf("...Fail\n");
1495
1496 return errors;
1497 }
Ceph