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