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_ */