cryptodev: fix KASUMI F9 expected parameters
[dpdk.git] / test / test / test_cryptodev_kasumi_test_vectors.h
1 /*-
2  *   BSD LICENSE
3  *
4  *   Copyright(c) 2016-2017 Intel Corporation. All rights reserved.
5  *
6  *   Redistribution and use in source and binary forms, with or without
7  *   modification, are permitted provided that the following conditions
8  *   are met:
9  *
10  *   * Redistributions of source code must retain the above copyright
11  *     notice, this list of conditions and the following disclaimer.
12  *   * Redistributions in binary form must reproduce the above copyright
13  *     notice, this list of conditions and the following disclaimer in
14  *     the documentation and/or other materials provided with the
15  *     distribution.
16  *   * Neither the name of Intel Corporation nor the names of its
17  *     contributors may be used to endorse or promote products derived
18  *     from this software without specific prior written permission.
19  *
20  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31  */
32
33 #ifndef TEST_CRYPTODEV_KASUMI_TEST_VECTORS_H_
34 #define TEST_CRYPTODEV_KASUMI_TEST_VECTORS_H_
35
36 struct kasumi_test_data {
37         struct {
38                 uint8_t data[64];
39                 unsigned len;
40         } key;
41
42         struct {
43                 uint8_t data[64] __rte_aligned(16);
44                 unsigned len;
45         } cipher_iv;
46
47         /*
48          * Data may include COUNT (4 bytes), FRESH (4 bytes),
49          * DIRECTION (1 bit), plus 1 0*, with enough 0s,
50          * so total length is multiple of 8 or 64 bits
51          */
52         struct {
53                 uint8_t data[1024];
54                 unsigned len; /* length must be in Bits */
55         } plaintext;
56
57         struct {
58                 unsigned len;
59         } validDataLenInBits;
60
61         struct {
62                 uint8_t data[1024];
63                 unsigned len; /* length must be in Bits */
64         } ciphertext;
65
66         struct {
67                 unsigned len;
68         } validCipherLenInBits;
69
70         struct {
71                 unsigned int len;
72         } validCipherOffsetInBits;
73
74         /* Actual length of data to be hashed */
75         struct {
76                 unsigned len;
77         } validAuthLenInBits;
78
79         struct {
80                 uint8_t data[64];
81                 unsigned len;
82         } digest;
83
84 };
85
86 struct kasumi_test_data kasumi_test_case_1 = {
87         .key = {
88                 .data = {
89                         0x2B, 0xD6, 0x45, 0x9F, 0x82, 0xC5, 0xB3, 0x00,
90                         0x95, 0x2C, 0x49, 0x10, 0x48, 0x81, 0xFF, 0x48
91                 },
92                 .len = 16
93         },
94         .cipher_iv = {
95                 .data = {
96                         0x72, 0xA4, 0xF2, 0x0F, 0x64, 0x00, 0x00, 0x00
97                 },
98                 .len = 8
99         },
100         .plaintext = {
101                 .data = {
102                         0x7E, 0xC6, 0x12, 0x72, 0x74, 0x3B, 0xF1, 0x61,
103                         0x47, 0x26, 0x44, 0x6A, 0x6C, 0x38, 0xCE, 0xD1,
104                         0x66, 0xF6, 0xCA, 0x76, 0xEB, 0x54, 0x30, 0x04,
105                         0x42, 0x86, 0x34, 0x6C, 0xEF, 0x13, 0x0F, 0x92,
106                         0x92, 0x2B, 0x03, 0x45, 0x0D, 0x3A, 0x99, 0x75,
107                         0xE5, 0xBD, 0x2E, 0xA0, 0xEB, 0x55, 0xAD, 0x8E,
108                         0x1B, 0x19, 0x9E, 0x3E, 0xC4, 0x31, 0x60, 0x20,
109                         0xE9, 0xA1, 0xB2, 0x85, 0xE7, 0x62, 0x79, 0x53,
110                         0x59, 0xB7, 0xBD, 0xFD, 0x39, 0xBE, 0xF4, 0xB2,
111                         0x48, 0x45, 0x83, 0xD5, 0xAF, 0xE0, 0x82, 0xAE,
112                         0xE6, 0x38, 0xBF, 0x5F, 0xD5, 0xA6, 0x06, 0x19,
113                         0x39, 0x01, 0xA0, 0x8F, 0x4A, 0xB4, 0x1A, 0xAB,
114                         0x9B, 0x13, 0x48, 0x80
115                 },
116                 .len = 800
117         },
118         .ciphertext = {
119                 .data = {
120                         0xD1, 0xE2, 0xDE, 0x70, 0xEE, 0xF8, 0x6C, 0x69,
121                         0x64, 0xFB, 0x54, 0x2B, 0xC2, 0xD4, 0x60, 0xAA,
122                         0xBF, 0xAA, 0x10, 0xA4, 0xA0, 0x93, 0x26, 0x2B,
123                         0x7D, 0x19, 0x9E, 0x70, 0x6F, 0xC2, 0xD4, 0x89,
124                         0x15, 0x53, 0x29, 0x69, 0x10, 0xF3, 0xA9, 0x73,
125                         0x01, 0x26, 0x82, 0xE4, 0x1C, 0x4E, 0x2B, 0x02,
126                         0xBE, 0x20, 0x17, 0xB7, 0x25, 0x3B, 0xBF, 0x93,
127                         0x09, 0xDE, 0x58, 0x19, 0xCB, 0x42, 0xE8, 0x19,
128                         0x56, 0xF4, 0xC9, 0x9B, 0xC9, 0x76, 0x5C, 0xAF,
129                         0x53, 0xB1, 0xD0, 0xBB, 0x82, 0x79, 0x82, 0x6A,
130                         0xDB, 0xBC, 0x55, 0x22, 0xE9, 0x15, 0xC1, 0x20,
131                         0xA6, 0x18, 0xA5, 0xA7, 0xF5, 0xE8, 0x97, 0x08,
132                         0x93, 0x39, 0x65, 0x0F
133                 },
134                 .len = 800
135         },
136         .validCipherLenInBits = {
137                 .len = 798
138         },
139         .validCipherOffsetInBits = {
140                 .len = 0
141         }
142 };
143
144 struct kasumi_test_data kasumi_test_case_2 = {
145         .key = {
146                 .data = {
147                         0xEF, 0xA8, 0xB2, 0x22, 0x9E, 0x72, 0x0C, 0x2A,
148                         0x7C, 0x36, 0xEA, 0x55, 0xE9, 0x60, 0x56, 0x95
149                 },
150                 .len = 16
151         },
152         .cipher_iv = {
153                 .data = {
154                         0xE2, 0x8B, 0xCF, 0x7B, 0xC0, 0x00, 0x00, 0x00
155                 },
156                 .len = 8
157         },
158         .plaintext = {
159                 .data = {
160                         0x10, 0x11, 0x12, 0x31, 0xE0, 0x60, 0x25, 0x3A,
161                         0x43, 0xFD, 0x3F, 0x57, 0xE3, 0x76, 0x07, 0xAB,
162                         0x28, 0x27, 0xB5, 0x99, 0xB6, 0xB1, 0xBB, 0xDA,
163                         0x37, 0xA8, 0xAB, 0xCC, 0x5A, 0x8C, 0x55, 0x0D,
164                         0x1B, 0xFB, 0x2F, 0x49, 0x46, 0x24, 0xFB, 0x50,
165                         0x36, 0x7F, 0xA3, 0x6C, 0xE3, 0xBC, 0x68, 0xF1,
166                         0x1C, 0xF9, 0x3B, 0x15, 0x10, 0x37, 0x6B, 0x02,
167                         0x13, 0x0F, 0x81, 0x2A, 0x9F, 0xA1, 0x69, 0xD8
168                 },
169                 .len = 512
170         },
171         .ciphertext = {
172                 .data = {
173                         0x3D, 0xEA, 0xCC, 0x7C, 0x15, 0x82, 0x1C, 0xAA,
174                         0x89, 0xEE, 0xCA, 0xDE, 0x9B, 0x5B, 0xD3, 0x61,
175                         0x4B, 0xD0, 0xC8, 0x41, 0x9D, 0x71, 0x03, 0x85,
176                         0xDD, 0xBE, 0x58, 0x49, 0xEF, 0x1B, 0xAC, 0x5A,
177                         0xE8, 0xB1, 0x4A, 0x5B, 0x0A, 0x67, 0x41, 0x52,
178                         0x1E, 0xB4, 0xE0, 0x0B, 0xB9, 0xEC, 0xF3, 0xE9,
179                         0xF7, 0xCC, 0xB9, 0xCA, 0xE7, 0x41, 0x52, 0xD7,
180                         0xF4, 0xE2, 0xA0, 0x34, 0xB6, 0xEA, 0x00, 0xEC
181                 },
182                 .len = 512
183         },
184         .validCipherLenInBits = {
185                 .len = 510
186         },
187         .validCipherOffsetInBits = {
188                 .len = 0
189         }
190 };
191
192 struct kasumi_test_data kasumi_test_case_3 = {
193         .key = {
194                 .data = {
195                          0x5A, 0xCB, 0x1D, 0x64, 0x4C, 0x0D, 0x51, 0x20,
196                          0x4E, 0xA5, 0xF1, 0x45, 0x10, 0x10, 0xD8, 0x52
197                 },
198                 .len = 16
199         },
200         .cipher_iv = {
201                 .data = {
202                         0xFA, 0x55, 0x6B, 0x26, 0x1C, 0x00, 0x00, 0x00
203                 },
204                 .len = 8
205         },
206         .plaintext = {
207                 .data = {
208                         0x38, 0xA6, 0xF0, 0x56, 0x05, 0xD2, 0xEC, 0x49,
209                         0xAD, 0x9C, 0x44, 0x1F, 0x89, 0x0B, 0x38, 0xC4,
210                         0x57, 0xA4, 0x9D, 0x42, 0x14, 0x07, 0xE8, 0xC0
211                 },
212                 .len = 192
213         },
214         .ciphertext = {
215                 .data = {
216                         0x38, 0xA6, 0xF0, 0x56, 0x05, 0xD2, 0xEC, 0x49,
217                         0x9B, 0xC9, 0x2C, 0xA8, 0x03, 0xC6, 0x7B, 0x28,
218                         0xA1, 0x1A, 0x4B, 0xEE, 0x5A, 0x0C, 0x25, 0xC0
219                 },
220                 .len = 192
221         },
222         .validDataLenInBits = {
223                 .len = 192
224         },
225         .validCipherLenInBits = {
226                 .len = 120
227         },
228         .validAuthLenInBits = {
229                 .len = 192
230         },
231         .validCipherOffsetInBits = {
232                 .len = 64
233         },
234         .digest = {
235                 .data = {0x87, 0x5F, 0xE4, 0x89},
236                 .len  = 4
237         }
238 };
239
240 struct kasumi_test_data kasumi_test_case_4 = {
241         .key = {
242                 .data = {
243                         0xD3, 0xC5, 0xD5, 0x92, 0x32, 0x7F, 0xB1, 0x1C,
244                         0x40, 0x35, 0xC6, 0x68, 0x0A, 0xF8, 0xC6, 0xD1
245                 },
246                 .len = 16
247         },
248         .cipher_iv = {
249                 .data = {
250                         0x39, 0x8A, 0x59, 0xB4, 0x2C, 0x00, 0x00, 0x00,
251                 },
252                 .len = 8
253         },
254         .plaintext = {
255                 .data = {
256                         0x98, 0x1B, 0xA6, 0x82, 0x4C, 0x1B, 0xFB, 0x1A,
257                         0xB4, 0x85, 0x47, 0x20, 0x29, 0xB7, 0x1D, 0x80,
258                         0x8C, 0xE3, 0x3E, 0x2C, 0xC3, 0xC0, 0xB5, 0xFC,
259                         0x1F, 0x3D, 0xE8, 0xA6, 0xDC, 0x66, 0xB1, 0xF0
260                 },
261                 .len = 256
262         },
263         .ciphertext = {
264                 .data = {
265                         0x5B, 0xB9, 0x43, 0x1B, 0xB1, 0xE9, 0x8B, 0xD1,
266                         0x1B, 0x93, 0xDB, 0x7C, 0x3D, 0x45, 0x13, 0x65,
267                         0x59, 0xBB, 0x86, 0xA2, 0x95, 0xAA, 0x20, 0x4E,
268                         0xCB, 0xEB, 0xF6, 0xF7, 0xA5, 0x10, 0x15, 0x10
269                 },
270                 .len = 256
271         },
272         .validCipherLenInBits = {
273                 .len = 253
274         },
275         .validCipherOffsetInBits = {
276                 .len = 0
277         }
278 };
279
280 struct kasumi_test_data kasumi_test_case_5 = {
281         .key = {
282                 .data = {
283                         0x60, 0x90, 0xEA, 0xE0, 0x4C, 0x83, 0x70, 0x6E,
284                         0xEC, 0xBF, 0x65, 0x2B, 0xE8, 0xE3, 0x65, 0x66
285                 },
286                 .len = 16
287         },
288         .cipher_iv = {
289                 .data = {
290                         0x72, 0xA4, 0xF2, 0x0F, 0x48, 0x00, 0x00, 0x00
291                 },
292                 .len = 8
293         },
294         .plaintext = {
295                 .data = {
296                         0x40, 0x98, 0x1B, 0xA6, 0x82, 0x4C, 0x1B, 0xFB,
297                         0x42, 0x86, 0xB2, 0x99, 0x78, 0x3D, 0xAF, 0x44,
298                         0x2C, 0x09, 0x9F, 0x7A, 0xB0, 0xF5, 0x8D, 0x5C,
299                         0x8E, 0x46, 0xB1, 0x04, 0xF0, 0x8F, 0x01, 0xB4,
300                         0x1A, 0xB4, 0x85, 0x47, 0x20, 0x29, 0xB7, 0x1D,
301                         0x36, 0xBD, 0x1A, 0x3D, 0x90, 0xDC, 0x3A, 0x41,
302                         0xB4, 0x6D, 0x51, 0x67, 0x2A, 0xC4, 0xC9, 0x66,
303                         0x3A, 0x2B, 0xE0, 0x63, 0xDA, 0x4B, 0xC8, 0xD2,
304                         0x80, 0x8C, 0xE3, 0x3E, 0x2C, 0xCC, 0xBF, 0xC6,
305                         0x34, 0xE1, 0xB2, 0x59, 0x06, 0x08, 0x76, 0xA0,
306                         0xFB, 0xB5, 0xA4, 0x37, 0xEB, 0xCC, 0x8D, 0x31,
307                         0xC1, 0x9E, 0x44, 0x54, 0x31, 0x87, 0x45, 0xE3,
308                         0x98, 0x76, 0x45, 0x98, 0x7A, 0x98, 0x6F, 0x2C,
309                         0xB0
310                 },
311                 .len = 840
312         },
313         .ciphertext = {
314                 .data = {
315                         0xDD, 0xB3, 0x64, 0xDD, 0x2A, 0xAE, 0xC2, 0x4D,
316                         0xFF, 0x29, 0x19, 0x57, 0xB7, 0x8B, 0xAD, 0x06,
317                         0x3A, 0xC5, 0x79, 0xCD, 0x90, 0x41, 0xBA, 0xBE,
318                         0x89, 0xFD, 0x19, 0x5C, 0x05, 0x78, 0xCB, 0x9F,
319                         0xDE, 0x42, 0x17, 0x56, 0x61, 0x78, 0xD2, 0x02,
320                         0x40, 0x20, 0x6D, 0x07, 0xCF, 0xA6, 0x19, 0xEC,
321                         0x05, 0x9F, 0x63, 0x51, 0x44, 0x59, 0xFC, 0x10,
322                         0xD4, 0x2D, 0xC9, 0x93, 0x4E, 0x56, 0xEB, 0xC0,
323                         0xCB, 0xC6, 0x0D, 0x4D, 0x2D, 0xF1, 0x74, 0x77,
324                         0x4C, 0xBD, 0xCD, 0x5D, 0xA4, 0xA3, 0x50, 0x31,
325                         0x7A, 0x7F, 0x12, 0xE1, 0x94, 0x94, 0x71, 0xF8,
326                         0xA2, 0x95, 0xF2, 0x72, 0xE6, 0x8F, 0xC0, 0x71,
327                         0x59, 0xB0, 0x7D, 0x8E, 0x2D, 0x26, 0xE4, 0x59,
328                         0x9E
329                 },
330                 .len = 840
331         },
332         .validCipherLenInBits = {
333                 .len = 837
334         },
335         .validCipherOffsetInBits = {
336                 .len = 0
337         }
338 };
339
340 struct kasumi_test_data kasumi_test_case_6 = {
341         .key = {
342                 .data = {
343                          0x5A, 0xCB, 0x1D, 0x64, 0x4C, 0x0D, 0x51, 0x20,
344                          0x4E, 0xA5, 0xF1, 0x45, 0x10, 0x10, 0xD8, 0x52
345                 },
346                 .len = 16
347         },
348         .cipher_iv = {
349                 .data = {
350                         0xFA, 0x55, 0x6B, 0x26, 0x1C, 0x00, 0x00, 0x00
351                 },
352                 .len = 8
353         },
354         .plaintext = {
355                 .data = {
356                         0x38, 0xA6, 0xF0, 0x56, 0x05, 0xD2, 0xEC, 0x49,
357                         0xAD, 0x9C, 0x44, 0x1F, 0x89, 0x0B, 0x38, 0xC4,
358                         0x57, 0xA4, 0x9D, 0x42, 0x14, 0x07, 0xE8, 0xC0
359                 },
360                 .len = 192
361         },
362         .ciphertext = {
363                 .data = {
364                         0x38, 0xA6, 0xF0, 0x56, 0x05, 0xD2, 0xEC, 0x49,
365                         0x9B, 0xC9, 0x2C, 0xA8, 0x03, 0xC6, 0x7B, 0x28,
366                         0xA1, 0x1A, 0x4B, 0xEE, 0x5A, 0x0C, 0x25, 0xC0
367                 },
368                 .len = 192
369         },
370         .validDataLenInBits = {
371                 .len = 192
372         },
373         .validCipherLenInBits = {
374                 .len = 120
375         },
376         .validCipherOffsetInBits = {
377                 .len = 64
378         },
379         .validAuthLenInBits = {
380                 .len = 192
381         },
382         .digest = {
383                 .data = {0x0F, 0xD2, 0xAA, 0xB5},
384                 .len  = 4
385         }
386 };
387 #endif /* TEST_CRYPTODEV_KASUMI_TEST_VECTORS_H_ */