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