test/test/test_cryptodev_kasumi_test_vectors.h

   1 /*-
   2  *   BSD LICENSE
   3  *
   4  *   Copyright(c) 2016 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         } iv;
  46
  47         /* Includes: COUNT (4 bytes) and FRESH (4 bytes) */
  48         struct {
  49                 uint8_t data[8];
  50                 unsigned len;
  51         } aad;
  52
  53         struct {
  54                 uint8_t data[1024]; /* Data may include direction bit */
  55                 unsigned len; /* length must be in Bits */
  56         } plaintext;
  57
  58         struct {
  59                 unsigned len;
  60         } validDataLenInBits;
  61
  62         struct {
  63                 uint8_t data[1024];
  64                 unsigned len; /* length must be in Bits */
  65         } ciphertext;
  66
  67         struct {
  68                 unsigned len;
  69         } validCipherLenInBits;
  70
  71         struct {
  72                 unsigned len;
  73         } validCipherOffsetLenInBits;
  74
  75         /* Actual length of data to be hashed */
  76         struct {
  77                 unsigned len;
  78         } validAuthLenInBits;
  79
  80         struct {
  81                 unsigned len;
  82         } validAuthOffsetLenInBits;
  83
  84         struct {
  85                 uint8_t data[64];
  86                 unsigned len;
  87         } digest;
  88
  89 };
  90
  91 struct kasumi_test_data kasumi_test_case_1 = {
  92         .key = {
  93                 .data = {
  94                         0x2B, 0xD6, 0x45, 0x9F, 0x82, 0xC5, 0xB3, 0x00,
  95                         0x95, 0x2C, 0x49, 0x10, 0x48, 0x81, 0xFF, 0x48
  96                 },
  97                 .len = 16
  98         },
  99         .iv = {
 100                 .data = {
 101                         0x72, 0xA4, 0xF2, 0x0F, 0x64, 0x00, 0x00, 0x00
 102                 },
 103                 .len = 8
 104         },
 105         .plaintext = {
 106                 .data = {
 107                         0x7E, 0xC6, 0x12, 0x72, 0x74, 0x3B, 0xF1, 0x61,
 108                         0x47, 0x26, 0x44, 0x6A, 0x6C, 0x38, 0xCE, 0xD1,
 109                         0x66, 0xF6, 0xCA, 0x76, 0xEB, 0x54, 0x30, 0x04,
 110                         0x42, 0x86, 0x34, 0x6C, 0xEF, 0x13, 0x0F, 0x92,
 111                         0x92, 0x2B, 0x03, 0x45, 0x0D, 0x3A, 0x99, 0x75,
 112                         0xE5, 0xBD, 0x2E, 0xA0, 0xEB, 0x55, 0xAD, 0x8E,
 113                         0x1B, 0x19, 0x9E, 0x3E, 0xC4, 0x31, 0x60, 0x20,
 114                         0xE9, 0xA1, 0xB2, 0x85, 0xE7, 0x62, 0x79, 0x53,
 115                         0x59, 0xB7, 0xBD, 0xFD, 0x39, 0xBE, 0xF4, 0xB2,
 116                         0x48, 0x45, 0x83, 0xD5, 0xAF, 0xE0, 0x82, 0xAE,
 117                         0xE6, 0x38, 0xBF, 0x5F, 0xD5, 0xA6, 0x06, 0x19,
 118                         0x39, 0x01, 0xA0, 0x8F, 0x4A, 0xB4, 0x1A, 0xAB,
 119                         0x9B, 0x13, 0x48, 0x80
 120                 },
 121                 .len = 800
 122         },
 123         .ciphertext = {
 124                 .data = {
 125                         0xD1, 0xE2, 0xDE, 0x70, 0xEE, 0xF8, 0x6C, 0x69,
 126                         0x64, 0xFB, 0x54, 0x2B, 0xC2, 0xD4, 0x60, 0xAA,
 127                         0xBF, 0xAA, 0x10, 0xA4, 0xA0, 0x93, 0x26, 0x2B,
 128                         0x7D, 0x19, 0x9E, 0x70, 0x6F, 0xC2, 0xD4, 0x89,
 129                         0x15, 0x53, 0x29, 0x69, 0x10, 0xF3, 0xA9, 0x73,
 130                         0x01, 0x26, 0x82, 0xE4, 0x1C, 0x4E, 0x2B, 0x02,
 131                         0xBE, 0x20, 0x17, 0xB7, 0x25, 0x3B, 0xBF, 0x93,
 132                         0x09, 0xDE, 0x58, 0x19, 0xCB, 0x42, 0xE8, 0x19,
 133                         0x56, 0xF4, 0xC9, 0x9B, 0xC9, 0x76, 0x5C, 0xAF,
 134                         0x53, 0xB1, 0xD0, 0xBB, 0x82, 0x79, 0x82, 0x6A,
 135                         0xDB, 0xBC, 0x55, 0x22, 0xE9, 0x15, 0xC1, 0x20,
 136                         0xA6, 0x18, 0xA5, 0xA7, 0xF5, 0xE8, 0x97, 0x08,
 137                         0x93, 0x39, 0x65, 0x0F
 138                 },
 139                 .len = 800
 140         },
 141         .validCipherLenInBits = {
 142                 .len = 798
 143         },
 144         .validCipherOffsetLenInBits = {
 145                 .len = 64
 146         },
 147 };
 148
 149 struct kasumi_test_data kasumi_test_case_2 = {
 150         .key = {
 151                 .data = {
 152                         0xEF, 0xA8, 0xB2, 0x22, 0x9E, 0x72, 0x0C, 0x2A,
 153                         0x7C, 0x36, 0xEA, 0x55, 0xE9, 0x60, 0x56, 0x95
 154                 },
 155                 .len = 16
 156         },
 157         .iv = {
 158                 .data = {
 159                         0xE2, 0x8B, 0xCF, 0x7B, 0xC0, 0x00, 0x00, 0x00
 160                 },
 161                 .len = 8
 162         },
 163         .plaintext = {
 164                 .data = {
 165                         0x10, 0x11, 0x12, 0x31, 0xE0, 0x60, 0x25, 0x3A,
 166                         0x43, 0xFD, 0x3F, 0x57, 0xE3, 0x76, 0x07, 0xAB,
 167                         0x28, 0x27, 0xB5, 0x99, 0xB6, 0xB1, 0xBB, 0xDA,
 168                         0x37, 0xA8, 0xAB, 0xCC, 0x5A, 0x8C, 0x55, 0x0D,
 169                         0x1B, 0xFB, 0x2F, 0x49, 0x46, 0x24, 0xFB, 0x50,
 170                         0x36, 0x7F, 0xA3, 0x6C, 0xE3, 0xBC, 0x68, 0xF1,
 171                         0x1C, 0xF9, 0x3B, 0x15, 0x10, 0x37, 0x6B, 0x02,
 172                         0x13, 0x0F, 0x81, 0x2A, 0x9F, 0xA1, 0x69, 0xD8
 173                 },
 174                 .len = 512
 175         },
 176         .ciphertext = {
 177                 .data = {
 178                         0x3D, 0xEA, 0xCC, 0x7C, 0x15, 0x82, 0x1C, 0xAA,
 179                         0x89, 0xEE, 0xCA, 0xDE, 0x9B, 0x5B, 0xD3, 0x61,
 180                         0x4B, 0xD0, 0xC8, 0x41, 0x9D, 0x71, 0x03, 0x85,
 181                         0xDD, 0xBE, 0x58, 0x49, 0xEF, 0x1B, 0xAC, 0x5A,
 182                         0xE8, 0xB1, 0x4A, 0x5B, 0x0A, 0x67, 0x41, 0x52,
 183                         0x1E, 0xB4, 0xE0, 0x0B, 0xB9, 0xEC, 0xF3, 0xE9,
 184                         0xF7, 0xCC, 0xB9, 0xCA, 0xE7, 0x41, 0x52, 0xD7,
 185                         0xF4, 0xE2, 0xA0, 0x34, 0xB6, 0xEA, 0x00, 0xEC
 186                 },
 187                 .len = 512
 188         },
 189         .validCipherLenInBits = {
 190                 .len = 510
 191         },
 192         .validCipherOffsetLenInBits = {
 193                 .len = 64
 194         }
 195 };
 196
 197 struct kasumi_test_data kasumi_test_case_3 = {
 198         .key = {
 199                 .data = {
 200                          0x5A, 0xCB, 0x1D, 0x64, 0x4C, 0x0D, 0x51, 0x20,
 201                          0x4E, 0xA5, 0xF1, 0x45, 0x10, 0x10, 0xD8, 0x52
 202                 },
 203                 .len = 16
 204         },
 205         .iv = {
 206                 .data = {
 207                         0xFA, 0x55, 0x6B, 0x26, 0x1C, 0x00, 0x00, 0x00
 208                 },
 209                 .len = 8
 210         },
 211         .aad = {
 212                 .data = {
 213                         0x38, 0xA6, 0xF0, 0x56, 0x05, 0xD2, 0xEC, 0x49
 214                 },
 215                 .len = 8
 216         },
 217         .plaintext = {
 218                 .data = {
 219                         0xAD, 0x9C, 0x44, 0x1F, 0x89, 0x0B, 0x38, 0xC4,
 220                         0x57, 0xA4, 0x9D, 0x42, 0x14, 0x07, 0xE8, 0xC0
 221                 },
 222                 .len = 128
 223         },
 224         .ciphertext = {
 225                 .data = {
 226                         0x9B, 0xC9, 0x2C, 0xA8, 0x03, 0xC6, 0x7B, 0x28,
 227                         0xA1, 0x1A, 0x4B, 0xEE, 0x5A, 0x0C, 0x25
 228                 },
 229                 .len = 120
 230         },
 231         .validDataLenInBits = {
 232                         .len = 128
 233         },
 234         .validCipherLenInBits = {
 235                 .len = 120
 236         },
 237         .validCipherOffsetLenInBits = {
 238                 .len = 64
 239         },
 240         .validAuthLenInBits = {
 241                 .len = 120
 242         },
 243         .validAuthOffsetLenInBits = {
 244                 .len = 64
 245         },
 246         .digest = {
 247                 .data = {0x87, 0x5F, 0xE4, 0x89},
 248                 .len  = 4
 249         }
 250 };
 251
 252 struct kasumi_test_data kasumi_test_case_4 = {
 253         .key = {
 254                 .data = {
 255                         0xD3, 0xC5, 0xD5, 0x92, 0x32, 0x7F, 0xB1, 0x1C,
 256                         0x40, 0x35, 0xC6, 0x68, 0x0A, 0xF8, 0xC6, 0xD1
 257                 },
 258                 .len = 16
 259         },
 260         .iv = {
 261                 .data = {
 262                         0x39, 0x8A, 0x59, 0xB4, 0x2C, 0x00, 0x00, 0x00,
 263                 },
 264                 .len = 8
 265         },
 266         .plaintext = {
 267                 .data = {
 268                         0x98, 0x1B, 0xA6, 0x82, 0x4C, 0x1B, 0xFB, 0x1A,
 269                         0xB4, 0x85, 0x47, 0x20, 0x29, 0xB7, 0x1D, 0x80,
 270                         0x8C, 0xE3, 0x3E, 0x2C, 0xC3, 0xC0, 0xB5, 0xFC,
 271                         0x1F, 0x3D, 0xE8, 0xA6, 0xDC, 0x66, 0xB1, 0xF0
 272                 },
 273                 .len = 256
 274         },
 275         .ciphertext = {
 276                 .data = {
 277                         0x5B, 0xB9, 0x43, 0x1B, 0xB1, 0xE9, 0x8B, 0xD1,
 278                         0x1B, 0x93, 0xDB, 0x7C, 0x3D, 0x45, 0x13, 0x65,
 279                         0x59, 0xBB, 0x86, 0xA2, 0x95, 0xAA, 0x20, 0x4E,
 280                         0xCB, 0xEB, 0xF6, 0xF7, 0xA5, 0x10, 0x15, 0x10
 281                 },
 282                 .len = 256
 283         },
 284         .validCipherLenInBits = {
 285                 .len = 253
 286         },
 287         .validCipherOffsetLenInBits = {
 288                 .len = 64
 289         }
 290 };
 291
 292 struct kasumi_test_data kasumi_test_case_5 = {
 293         .key = {
 294                 .data = {
 295                         0x60, 0x90, 0xEA, 0xE0, 0x4C, 0x83, 0x70, 0x6E,
 296                         0xEC, 0xBF, 0x65, 0x2B, 0xE8, 0xE3, 0x65, 0x66
 297                 },
 298                 .len = 16
 299         },
 300         .iv = {
 301                 .data = {
 302                         0x72, 0xA4, 0xF2, 0x0F, 0x48, 0x00, 0x00, 0x00
 303                 },
 304                 .len = 8
 305         },
 306         .plaintext = {
 307                 .data = {
 308                         0x40, 0x98, 0x1B, 0xA6, 0x82, 0x4C, 0x1B, 0xFB,
 309                         0x42, 0x86, 0xB2, 0x99, 0x78, 0x3D, 0xAF, 0x44,
 310                         0x2C, 0x09, 0x9F, 0x7A, 0xB0, 0xF5, 0x8D, 0x5C,
 311                         0x8E, 0x46, 0xB1, 0x04, 0xF0, 0x8F, 0x01, 0xB4,
 312                         0x1A, 0xB4, 0x85, 0x47, 0x20, 0x29, 0xB7, 0x1D,
 313                         0x36, 0xBD, 0x1A, 0x3D, 0x90, 0xDC, 0x3A, 0x41,
 314                         0xB4, 0x6D, 0x51, 0x67, 0x2A, 0xC4, 0xC9, 0x66,
 315                         0x3A, 0x2B, 0xE0, 0x63, 0xDA, 0x4B, 0xC8, 0xD2,
 316                         0x80, 0x8C, 0xE3, 0x3E, 0x2C, 0xCC, 0xBF, 0xC6,
 317                         0x34, 0xE1, 0xB2, 0x59, 0x06, 0x08, 0x76, 0xA0,
 318                         0xFB, 0xB5, 0xA4, 0x37, 0xEB, 0xCC, 0x8D, 0x31,
 319                         0xC1, 0x9E, 0x44, 0x54, 0x31, 0x87, 0x45, 0xE3,
 320                         0x98, 0x76, 0x45, 0x98, 0x7A, 0x98, 0x6F, 0x2C,
 321                         0xB0
 322                 },
 323                 .len = 840
 324         },
 325         .ciphertext = {
 326                 .data = {
 327                         0xDD, 0xB3, 0x64, 0xDD, 0x2A, 0xAE, 0xC2, 0x4D,
 328                         0xFF, 0x29, 0x19, 0x57, 0xB7, 0x8B, 0xAD, 0x06,
 329                         0x3A, 0xC5, 0x79, 0xCD, 0x90, 0x41, 0xBA, 0xBE,
 330                         0x89, 0xFD, 0x19, 0x5C, 0x05, 0x78, 0xCB, 0x9F,
 331                         0xDE, 0x42, 0x17, 0x56, 0x61, 0x78, 0xD2, 0x02,
 332                         0x40, 0x20, 0x6D, 0x07, 0xCF, 0xA6, 0x19, 0xEC,
 333                         0x05, 0x9F, 0x63, 0x51, 0x44, 0x59, 0xFC, 0x10,
 334                         0xD4, 0x2D, 0xC9, 0x93, 0x4E, 0x56, 0xEB, 0xC0,
 335                         0xCB, 0xC6, 0x0D, 0x4D, 0x2D, 0xF1, 0x74, 0x77,
 336                         0x4C, 0xBD, 0xCD, 0x5D, 0xA4, 0xA3, 0x50, 0x31,
 337                         0x7A, 0x7F, 0x12, 0xE1, 0x94, 0x94, 0x71, 0xF8,
 338                         0xA2, 0x95, 0xF2, 0x72, 0xE6, 0x8F, 0xC0, 0x71,
 339                         0x59, 0xB0, 0x7D, 0x8E, 0x2D, 0x26, 0xE4, 0x59,
 340                         0x9E
 341                 },
 342                 .len = 840
 343         },
 344         .validCipherLenInBits = {
 345                 .len = 837
 346         },
 347         .validCipherOffsetLenInBits = {
 348                 .len = 64
 349         },
 350 };
 351
 352 struct kasumi_test_data kasumi_test_case_6 = {
 353         .key = {
 354                 .data = {
 355                          0x5A, 0xCB, 0x1D, 0x64, 0x4C, 0x0D, 0x51, 0x20,
 356                          0x4E, 0xA5, 0xF1, 0x45, 0x10, 0x10, 0xD8, 0x52
 357                 },
 358                 .len = 16
 359         },
 360         .iv = {
 361                 .data = {
 362                         0xFA, 0x55, 0x6B, 0x26, 0x1C, 0x00, 0x00, 0x00
 363                 },
 364                 .len = 8
 365         },
 366         .aad = {
 367                 .data = {
 368                         0x38, 0xA6, 0xF0, 0x56, 0x05, 0xD2, 0xEC, 0x49
 369                 },
 370                 .len = 8
 371         },
 372         .plaintext = {
 373                 .data = {
 374                         0xAD, 0x9C, 0x44, 0x1F, 0x89, 0x0B, 0x38, 0xC4,
 375                         0x57, 0xA4, 0x9D, 0x42, 0x14, 0x07, 0xE8, 0xC0
 376                 },
 377                 .len = 128
 378         },
 379         .ciphertext = {
 380                 .data = {
 381                         0x9B, 0xC9, 0x2C, 0xA8, 0x03, 0xC6, 0x7B, 0x28,
 382                         0xA1, 0x1A, 0x4B, 0xEE, 0x5A, 0x0C, 0x25
 383                 },
 384                 .len = 120
 385         },
 386         .validDataLenInBits = {
 387                         .len = 128
 388         },
 389         .validCipherLenInBits = {
 390                 .len = 120
 391         },
 392         .validCipherOffsetLenInBits = {
 393                 .len = 64
 394         },
 395         .validAuthLenInBits = {
 396                 .len = 120
 397         },
 398         .validAuthOffsetLenInBits = {
 399                 .len = 64
 400         },
 401         .digest = {
 402                 .data = {0x0F, 0xD2, 0xAA, 0xB5},
 403                 .len  = 4
 404         }
 405 };
 406
 407 #endif /* TEST_CRYPTODEV_KASUMI_TEST_VECTORS_H_ */