test/test/test_cryptodev_kasumi_hash_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_HASH_TEST_VECTORS_H_
  34 #define TEST_CRYPTODEV_KASUMI_HASH_TEST_VECTORS_H_
  35
  36 struct kasumi_hash_test_data {
  37         struct {
  38                 uint8_t data[16];
  39                 unsigned len;
  40         } key;
  41
  42         /* Includes: COUNT (4 bytes) and FRESH (4 bytes) */
  43         struct {
  44                 uint8_t data[8];
  45                 unsigned len;
  46         } auth_iv;
  47
  48         /* Includes message and DIRECTION (1 bit), plus 1 0*,
  49          * with enough 0s, so total length is multiple of 64 bits */
  50         struct {
  51                 uint8_t data[2056];
  52                 unsigned len; /* length must be in Bits */
  53         } plaintext;
  54
  55         /* Actual length of data to be hashed */
  56         struct {
  57                 unsigned len;
  58         } validAuthLenInBits;
  59
  60         struct {
  61                 uint8_t data[64];
  62                 unsigned len;
  63         } digest;
  64 };
  65
  66 struct kasumi_hash_test_data kasumi_hash_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         .auth_iv = {
  75                 .data = {
  76                         0x38, 0xA6, 0xF0, 0x56, 0x05, 0xD2, 0xEC, 0x49,
  77                 },
  78                 .len = 8
  79         },
  80         .plaintext = {
  81                 .data = {
  82                         0x6B, 0x22, 0x77, 0x37, 0x29, 0x6F, 0x39, 0x3C,
  83                         0x80, 0x79, 0x35, 0x3E, 0xDC, 0x87, 0xE2, 0xE8,
  84                         0x05, 0xD2, 0xEC, 0x49, 0xA4, 0xF2, 0xD8, 0xE2
  85                 },
  86                 .len = 192
  87         },
  88         .validAuthLenInBits = {
  89                 .len = 189
  90         },
  91         .digest = {
  92                 .data = {0xF6, 0x3B, 0xD7, 0x2C},
  93                 .len  = 4
  94         }
  95 };
  96
  97 struct kasumi_hash_test_data kasumi_hash_test_case_2 = {
  98         .key = {
  99                 .data = {
 100                         0xD4, 0x2F, 0x68, 0x24, 0x28, 0x20, 0x1C, 0xAF,
 101                         0xCD, 0x9F, 0x97, 0x94, 0x5E, 0x6D, 0xE7, 0xB7
 102                 },
 103                 .len = 16
 104         },
 105         .auth_iv = {
 106                 .data = {
 107                         0x3E, 0xDC, 0x87, 0xE2, 0xA4, 0xF2, 0xD8, 0xE2,
 108                 },
 109                 .len = 8
 110         },
 111         .plaintext = {
 112                 .data = {
 113                         0xB5, 0x92, 0x43, 0x84, 0x32, 0x8A, 0x4A, 0xE0,
 114                         0x0B, 0x73, 0x71, 0x09, 0xF8, 0xB6, 0xC8, 0xDD,
 115                         0x2B, 0x4D, 0xB6, 0x3D, 0xD5, 0x33, 0x98, 0x1C,
 116                         0xEB, 0x19, 0xAA, 0xD5, 0x2A, 0x5B, 0x2B, 0xC3
 117                 },
 118                 .len = 256
 119         },
 120         .validAuthLenInBits = {
 121                 .len = 254
 122         },
 123         .digest = {
 124                 .data = {0xA9, 0xDA, 0xF1, 0xFF},
 125                 .len  = 4
 126         }
 127 };
 128
 129 struct kasumi_hash_test_data kasumi_hash_test_case_3 = {
 130         .key = {
 131                 .data = {
 132                         0xFD, 0xB9, 0xCF, 0xDF, 0x28, 0x93, 0x6C, 0xC4,
 133                         0x83, 0xA3, 0x18, 0x69, 0xD8, 0x1B, 0x8F, 0xAB
 134                 },
 135                 .len = 16
 136         },
 137         .auth_iv = {
 138                 .data = {
 139                         0x36, 0xAF, 0x61, 0x44, 0x98, 0x38, 0xF0, 0x3A,
 140                 },
 141                 .len = 8
 142         },
 143         .plaintext = {
 144                 .data = {
 145                         0x59, 0x32, 0xBC, 0x0A, 0xCE, 0x2B, 0x0A, 0xBA,
 146                         0x33, 0xD8, 0xAC, 0x18, 0x8A, 0xC5, 0x4F, 0x34,
 147                         0x6F, 0xAD, 0x10, 0xBF, 0x9D, 0xEE, 0x29, 0x20,
 148                         0xB4, 0x3B, 0xD0, 0xC5, 0x3A, 0x91, 0x5C, 0xB7,
 149                         0xDF, 0x6C, 0xAA, 0x72, 0x05, 0x3A, 0xBF, 0xF3,
 150                         0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 151                 },
 152                 .len = 384
 153         },
 154         .validAuthLenInBits = {
 155                 .len = 319
 156         },
 157         .digest = {
 158                 .data = {0x15, 0x37, 0xD3, 0x16},
 159                 .len  = 4
 160         }
 161 };
 162
 163 struct kasumi_hash_test_data kasumi_hash_test_case_4 = {
 164         .key = {
 165                 .data = {
 166                         0xC7, 0x36, 0xC6, 0xAA, 0xB2, 0x2B, 0xFF, 0xF9,
 167                         0x1E, 0x26, 0x98, 0xD2, 0xE2, 0x2A, 0xD5, 0x7E
 168                 },
 169         .len = 16
 170         },
 171         .auth_iv = {
 172                 .data = {
 173                         0x14, 0x79, 0x3E, 0x41, 0x03, 0x97, 0xE8, 0xFD
 174                 },
 175                 .len = 8
 176         },
 177         .plaintext = {
 178                 .data = {
 179                         0xD0, 0xA7, 0xD4, 0x63, 0xDF, 0x9F, 0xB2, 0xB2,
 180                         0x78, 0x83, 0x3F, 0xA0, 0x2E, 0x23, 0x5A, 0xA1,
 181                         0x72, 0xBD, 0x97, 0x0C, 0x14, 0x73, 0xE1, 0x29,
 182                         0x07, 0xFB, 0x64, 0x8B, 0x65, 0x99, 0xAA, 0xA0,
 183                         0xB2, 0x4A, 0x03, 0x86, 0x65, 0x42, 0x2B, 0x20,
 184                         0xA4, 0x99, 0x27, 0x6A, 0x50, 0x42, 0x70, 0x09,
 185                         0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 186                 },
 187                 .len = 448
 188         },
 189         .validAuthLenInBits = {
 190                 .len = 384
 191                 },
 192         .digest = {
 193                 .data = {0xDD, 0x7D, 0xFA, 0xDD },
 194                 .len  = 4
 195         }
 196 };
 197
 198 struct kasumi_hash_test_data kasumi_hash_test_case_5 = {
 199         .key = {
 200                 .data = {
 201                         0xF4, 0xEB, 0xEC, 0x69, 0xE7, 0x3E, 0xAF, 0x2E,
 202                         0xB2, 0xCF, 0x6A, 0xF4, 0xB3, 0x12, 0x0F, 0xFD
 203                 },
 204                 .len = 16
 205         },
 206         .auth_iv = {
 207                 .data = {
 208                         0x29, 0x6F, 0x39, 0x3C, 0x6B, 0x22, 0x77, 0x37,
 209                 },
 210                 .len = 8
 211         },
 212         .plaintext = {
 213                 .data = {
 214                         0x10, 0xBF, 0xFF, 0x83, 0x9E, 0x0C, 0x71, 0x65,
 215                         0x8D, 0xBB, 0x2D, 0x17, 0x07, 0xE1, 0x45, 0x72,
 216                         0x4F, 0x41, 0xC1, 0x6F, 0x48, 0xBF, 0x40, 0x3C,
 217                         0x3B, 0x18, 0xE3, 0x8F, 0xD5, 0xD1, 0x66, 0x3B,
 218                         0x6F, 0x6D, 0x90, 0x01, 0x93, 0xE3, 0xCE, 0xA8,
 219                         0xBB, 0x4F, 0x1B, 0x4F, 0x5B, 0xE8, 0x22, 0x03,
 220                         0x22, 0x32, 0xA7, 0x8D, 0x7D, 0x75, 0x23, 0x8D,
 221                         0x5E, 0x6D, 0xAE, 0xCD, 0x3B, 0x43, 0x22, 0xCF,
 222                         0x59, 0xBC, 0x7E, 0xA8, 0x4A, 0xB1, 0x88, 0x11,
 223                         0xB5, 0xBF, 0xB7, 0xBC, 0x55, 0x3F, 0x4F, 0xE4,
 224                         0x44, 0x78, 0xCE, 0x28, 0x7A, 0x14, 0x87, 0x99,
 225                         0x90, 0xD1, 0x8D, 0x12, 0xCA, 0x79, 0xD2, 0xC8,
 226                         0x55, 0x14, 0x90, 0x21, 0xCD, 0x5C, 0xE8, 0xCA,
 227                         0x03, 0x71, 0xCA, 0x04, 0xFC, 0xCE, 0x14, 0x3E,
 228                         0x3D, 0x7C, 0xFE, 0xE9, 0x45, 0x85, 0xB5, 0x88,
 229                         0x5C, 0xAC, 0x46, 0x06, 0x8B, 0xC0, 0x00, 0x00
 230                 },
 231                 .len = 1024
 232         },
 233         .validAuthLenInBits = {
 234                 .len = 1000
 235         },
 236         .digest = {
 237                 .data = {0xC3, 0x83, 0x83, 0x9D},
 238                 .len  = 4
 239         }
 240 };
 241
 242 struct kasumi_hash_test_data kasumi_hash_test_case_6 = {
 243         .key = {
 244                 .data = {
 245                         0x83, 0xFD, 0x23, 0xA2, 0x44, 0xA7, 0x4C, 0xF3,
 246                         0x58, 0xDA, 0x30, 0x19, 0xF1, 0x72, 0x26, 0x35
 247                 },
 248                 .len = 16
 249         },
 250         .auth_iv = {
 251                 .data = {
 252                         0x36, 0xAF, 0x61, 0x44, 0x4F, 0x30, 0x2A, 0xD2
 253                 },
 254                 .len = 8
 255         },
 256         .plaintext = {
 257                 .data = {
 258                         0x35, 0xC6, 0x87, 0x16, 0x63, 0x3C, 0x66, 0xFB,
 259                         0x75, 0x0C, 0x26, 0x68, 0x65, 0xD5, 0x3C, 0x11,
 260                         0xEA, 0x05, 0xB1, 0xE9, 0xFA, 0x49, 0xC8, 0x39,
 261                         0x8D, 0x48, 0xE1, 0xEF, 0xA5, 0x90, 0x9D, 0x39,
 262                         0x47, 0x90, 0x28, 0x37, 0xF5, 0xAE, 0x96, 0xD5,
 263                         0xA0, 0x5B, 0xC8, 0xD6, 0x1C, 0xA8, 0xDB, 0xEF,
 264                         0x1B, 0x13, 0xA4, 0xB4, 0xAB, 0xFE, 0x4F, 0xB1,
 265                         0x00, 0x60, 0x45, 0xB6, 0x74, 0xBB, 0x54, 0x72,
 266                         0x93, 0x04, 0xC3, 0x82, 0xBE, 0x53, 0xA5, 0xAF,
 267                         0x05, 0x55, 0x61, 0x76, 0xF6, 0xEA, 0xA2, 0xEF,
 268                         0x1D, 0x05, 0xE4, 0xB0, 0x83, 0x18, 0x1E, 0xE6,
 269                         0x74, 0xCD, 0xA5, 0xA4, 0x85, 0xF7, 0x4D, 0x7A,
 270                         0xC0
 271                 },
 272                 .len = 776
 273         },
 274         .validAuthLenInBits = {
 275                 .len = 768
 276         },
 277         .digest = {
 278                 .data = {0x95, 0xAE, 0x41, 0xBA},
 279                 .len  = 4
 280         }
 281 };
 282
 283 struct kasumi_hash_test_data kasumi_hash_test_case_7 = {
 284         .key = {
 285                 .data = {
 286                         0x5A, 0xCB, 0x1D, 0x64, 0x4C, 0x0D, 0x51, 0x20,
 287                         0x4E, 0xA5, 0xF1, 0x45, 0x10, 0x10, 0xD8, 0x52
 288                 },
 289                 .len = 16
 290         },
 291         .auth_iv = {
 292                 .data = {
 293                         0x38, 0xA6, 0xF0, 0x56, 0x05, 0xD2, 0xEC, 0x49,
 294                 },
 295                 .len = 8
 296         },
 297         .plaintext = {
 298                 .data = {
 299                         0xAD, 0x9C, 0x44, 0x1F, 0x89, 0x0B, 0x38, 0xC4,
 300                         0x57, 0xA4, 0x9D, 0x42, 0x14, 0x07, 0xE8, 0xC0
 301                 },
 302                 .len = 128
 303         },
 304         .validAuthLenInBits = {
 305                 .len = 120
 306         },
 307         .digest = {
 308                 .data = {0x87, 0x5F, 0xE4, 0x89},
 309                 .len  = 4
 310         }
 311 };
 312 #endif /* TEST_CRYPTODEV_KASUMI_HASH_TEST_VECTORS_H_ */