test/drbgtest.h

   1 /*
   2  * Copyright 2011-2017 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the OpenSSL license (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 /*
  11  * Known answer tests for SP800-90 DRBG CTR mode.
  12  */
  13
  14
  15 /*
  16  * AES-128 use df PR
  17  */
  18 static const unsigned char aes_128_use_df_pr_entropyinput[] = {
  19     0x61, 0x52, 0x7c, 0xe3, 0x23, 0x7d, 0x0a, 0x07, 0x10, 0x0c, 0x50, 0x33,
  20     0xc8, 0xdb, 0xff, 0x12
  21 };
  22 static const unsigned char aes_128_use_df_pr_nonce[] = {
  23     0x51, 0x0d, 0x85, 0x77, 0xed, 0x22, 0x97, 0x28
  24 };
  25 static const unsigned char aes_128_use_df_pr_personalizationstring[] = {
  26     0x59, 0x9f, 0xbb, 0xcd, 0xd5, 0x25, 0x69, 0xb5, 0xcb, 0xb5, 0x03, 0xfe,
  27     0xd7, 0xd7, 0x01, 0x67
  28 };
  29 static const unsigned char aes_128_use_df_pr_additionalinput[] = {
  30     0xef, 0x88, 0x76, 0x01, 0xaf, 0x3c, 0xfe, 0x8b, 0xaf, 0x26, 0x06, 0x9e,
  31     0x9a, 0x47, 0x08, 0x76
  32 };
  33 static const unsigned char aes_128_use_df_pr_entropyinputpr[] = {
  34     0xe2, 0x76, 0xf9, 0xf6, 0x3a, 0xba, 0x10, 0x9f, 0xbf, 0x47, 0x0e, 0x51,
  35     0x09, 0xfb, 0xa3, 0xb6
  36 };
  37 static const unsigned char aes_128_use_df_pr_int_returnedbits[] = {
  38     0xd4, 0x98, 0x8a, 0x46, 0x80, 0x4c, 0xdb, 0xa3, 0x59, 0x02, 0x57, 0x52,
  39     0x66, 0x1c, 0xea, 0x5b
  40 };
  41 static const unsigned char aes_128_use_df_pr_additionalinput2[] = {
  42     0x88, 0x8c, 0x91, 0xd6, 0xbe, 0x56, 0x6e, 0x08, 0x9a, 0x62, 0x2b, 0x11,
  43     0x3f, 0x5e, 0x31, 0x06
  44 };
  45 static const unsigned char aes_128_use_df_pr_entropyinputpr2[] = {
  46     0xc0, 0x5c, 0x6b, 0x98, 0x01, 0x0d, 0x58, 0x18, 0x51, 0x18, 0x96, 0xae,
  47     0xa7, 0xe3, 0xa8, 0x67
  48 };
  49 static const unsigned char aes_128_use_df_pr_returnedbits[] = {
  50     0xcf, 0x01, 0xac, 0x22, 0x31, 0x06, 0x8e, 0xfc, 0xce, 0x56, 0xea, 0x24,
  51     0x0f, 0x38, 0x43, 0xc6
  52 };
  53
  54
  55 /*
  56  * AES-128 use df no PR
  57  */
  58 static const unsigned char aes_128_use_df_entropyinput[] = {
  59     0x1f, 0x8e, 0x34, 0x82, 0x0c, 0xb7, 0xbe, 0xc5, 0x01, 0x3e, 0xd0, 0xa3,
  60     0x9d, 0x7d, 0x1c, 0x9b
  61 };
  62 static const unsigned char aes_128_use_df_nonce[] = {
  63     0xd5, 0x4d, 0xbd, 0x4a, 0x93, 0x7f, 0xb8, 0x96,
  64 };
  65 static const unsigned char aes_128_use_df_personalizationstring[] = {
  66     0xab, 0xd6, 0x3f, 0x04, 0xfe, 0x27, 0x6b, 0x2d, 0xd7, 0xc3, 0x1c, 0xf3,
  67     0x38, 0x66, 0xba, 0x1b
  68 };
  69 static const unsigned char aes_128_use_df_additionalinput[] = {
  70     0xfe, 0xf4, 0x09, 0xa8, 0xb7, 0x73, 0x27, 0x9c, 0x5f, 0xa7, 0xea, 0x46,
  71     0xb5, 0xe2, 0xb2, 0x41
  72 };
  73 static const unsigned char aes_128_use_df_int_returnedbits[] = {
  74     0x42, 0xe4, 0x4e, 0x7b, 0x27, 0xdd, 0xcb, 0xbc, 0x0a, 0xcf, 0xa6, 0x67,
  75     0xe7, 0x57, 0x11, 0xb4
  76 };
  77 static const unsigned char aes_128_use_df_entropyinputreseed[] = {
  78     0x14, 0x26, 0x69, 0xd9, 0xf3, 0x65, 0x03, 0xd6, 0x6b, 0xb9, 0x44, 0x0b,
  79     0xc7, 0xc4, 0x9e, 0x39
  80 };
  81 static const unsigned char aes_128_use_df_additionalinputreseed[] = {
  82     0x55, 0x2e, 0x60, 0x9a, 0x05, 0x72, 0x8a, 0xa8, 0xef, 0x22, 0x81, 0x5a,
  83     0xc8, 0x93, 0xfa, 0x84
  84 };
  85 static const unsigned char aes_128_use_df_additionalinput2[] = {
  86     0x3c, 0x40, 0xc8, 0xc4, 0x16, 0x0c, 0x21, 0xa4, 0x37, 0x2c, 0x8f, 0xa5,
  87     0x06, 0x0c, 0x15, 0x2c
  88 };
  89 static const unsigned char aes_128_use_df_returnedbits[] = {
  90     0xe1, 0x3e, 0x99, 0x98, 0x86, 0x67, 0x0b, 0x63, 0x7b, 0xbe, 0x3f, 0x88,
  91     0x46, 0x81, 0xc7, 0x19
  92 };
  93
  94
  95 /*
  96  * AES-192 use df PR
  97  */
  98 static const unsigned char aes_192_use_df_pr_entropyinput[] = {
  99     0x2b, 0x4e, 0x8b, 0xe1, 0xf1, 0x34, 0x80, 0x56, 0x81, 0xf9, 0x74, 0xec,
 100     0x17, 0x44, 0x2a, 0xf1, 0x14, 0xb0, 0xbf, 0x97, 0x39, 0xb7, 0x04, 0x7d
 101 };
 102 static const unsigned char aes_192_use_df_pr_nonce[] = {
 103     0xd6, 0x9d, 0xeb, 0x14, 0x4e, 0x6c, 0x30, 0x1e, 0x39, 0x55, 0x73, 0xd0,
 104     0xd1, 0x80, 0x78, 0xfa
 105 };
 106 static const unsigned char aes_192_use_df_pr_personalizationstring[] = {
 107     0xfc, 0x43, 0x4a, 0xf8, 0x9a, 0x55, 0xb3, 0x53, 0x83, 0xe2, 0x18, 0x16,
 108     0x0c, 0xdc, 0xcd, 0x5e, 0x4f, 0xa0, 0x03, 0x01, 0x2b, 0x9f, 0xe4, 0xd5,
 109     0x7d, 0x49, 0xf0, 0x41, 0x9e, 0x3d, 0x99, 0x04
 110 };
 111 static const unsigned char aes_192_use_df_pr_additionalinput[] = {
 112     0x5e, 0x9f, 0x49, 0x6f, 0x21, 0x8b, 0x1d, 0x32, 0xd5, 0x84, 0x5c, 0xac,
 113     0xaf, 0xdf, 0xe4, 0x79, 0x9e, 0xaf, 0xa9, 0x82, 0xd0, 0xf8, 0x4f, 0xcb,
 114     0x69, 0x10, 0x0a, 0x7e, 0x81, 0x57, 0xb5, 0x36
 115 };
 116 static const unsigned char aes_192_use_df_pr_entropyinputpr[] = {
 117     0xd4, 0x81, 0x0c, 0xd7, 0x66, 0x39, 0xec, 0x42, 0x53, 0x87, 0x41, 0xa5,
 118     0x1e, 0x7d, 0x80, 0x91, 0x8e, 0xbb, 0xed, 0xac, 0x14, 0x02, 0x1a, 0xd5,
 119 };
 120 static const unsigned char aes_192_use_df_pr_int_returnedbits[] = {
 121     0xdf, 0x1d, 0x39, 0x45, 0x7c, 0x9b, 0xc6, 0x2b, 0x7d, 0x8c, 0x93, 0xe9,
 122     0x19, 0x30, 0x6b, 0x67
 123 };
 124 static const unsigned char aes_192_use_df_pr_additionalinput2[] = {
 125     0x00, 0x71, 0x27, 0x4e, 0xd3, 0x14, 0xf1, 0x20, 0x7f, 0x4a, 0x41, 0x32,
 126     0x2a, 0x97, 0x11, 0x43, 0x8f, 0x4a, 0x15, 0x7b, 0x9b, 0x51, 0x79, 0xda,
 127     0x49, 0x3d, 0xde, 0xe8, 0xbc, 0x93, 0x91, 0x99
 128 };
 129 static const unsigned char aes_192_use_df_pr_entropyinputpr2[] = {
 130     0x90, 0xee, 0x76, 0xa1, 0x45, 0x8d, 0xb7, 0x40, 0xb0, 0x11, 0xbf, 0xd0,
 131     0x65, 0xd7, 0x3c, 0x7c, 0x4f, 0x20, 0x3f, 0x4e, 0x11, 0x9d, 0xb3, 0x5e,
 132 };
 133 static const unsigned char aes_192_use_df_pr_returnedbits[] = {
 134     0x24, 0x3b, 0x20, 0xa4, 0x37, 0x66, 0xba, 0x72, 0x39, 0x3f, 0xcf, 0x3c,
 135     0x7e, 0x1a, 0x2b, 0x83
 136 };
 137
 138
 139 /*
 140  * AES-192 use df no PR
 141  */
 142 static const unsigned char aes_192_use_df_entropyinput[] = {
 143     0x8d, 0x74, 0xa4, 0x50, 0x1a, 0x02, 0x68, 0x0c, 0x2a, 0x69, 0xc4, 0x82,
 144     0x3b, 0xbb, 0xda, 0x0e, 0x7f, 0x77, 0xa3, 0x17, 0x78, 0x57, 0xb2, 0x7b,
 145 };
 146 static const unsigned char aes_192_use_df_nonce[] = {
 147     0x75, 0xd5, 0x1f, 0xac, 0xa4, 0x8d, 0x42, 0x78, 0xd7, 0x69, 0x86, 0x9d,
 148     0x77, 0xd7, 0x41, 0x0e
 149 };
 150 static const unsigned char aes_192_use_df_personalizationstring[] = {
 151     0x4e, 0x33, 0x41, 0x3c, 0x9c, 0xc2, 0xd2, 0x53, 0xaf, 0x90, 0xea, 0xcf,
 152     0x19, 0x50, 0x1e, 0xe6, 0x6f, 0x63, 0xc8, 0x32, 0x22, 0xdc, 0x07, 0x65,
 153     0x9c, 0xd3, 0xf8, 0x30, 0x9e, 0xed, 0x35, 0x70
 154 };
 155 static const unsigned char aes_192_use_df_additionalinput[] = {
 156     0x5d, 0x8b, 0x8c, 0xc1, 0xdf, 0x0e, 0x02, 0x78, 0xfb, 0x19, 0xb8, 0x69,
 157     0x78, 0x4e, 0x9c, 0x52, 0xbc, 0xc7, 0x20, 0xc9, 0xe6, 0x5e, 0x77, 0x22,
 158     0x28, 0x3d, 0x0c, 0x9e, 0x68, 0xa8, 0x45, 0xd7
 159 };
 160 static const unsigned char aes_192_use_df_int_returnedbits[] = {
 161     0xd5, 0xe7, 0x08, 0xc5, 0x19, 0x99, 0xd5, 0x31, 0x03, 0x0a, 0x74, 0xb6,
 162     0xb7, 0xed, 0xe9, 0xea
 163 };
 164 static const unsigned char aes_192_use_df_entropyinputreseed[] = {
 165     0x9c, 0x26, 0xda, 0xf1, 0xac, 0xd9, 0x5a, 0xd6, 0xa8, 0x65, 0xf5, 0x02,
 166     0x8f, 0xdc, 0xa2, 0x09, 0x54, 0xa6, 0xe2, 0xa4, 0xde, 0x32, 0xe0, 0x01,
 167 };
 168 static const unsigned char aes_192_use_df_additionalinputreseed[] = {
 169     0x9b, 0x90, 0xb0, 0x3a, 0x0e, 0x3a, 0x80, 0x07, 0x4a, 0xf4, 0xda, 0x76,
 170     0x28, 0x30, 0x3c, 0xee, 0x54, 0x1b, 0x94, 0x59, 0x51, 0x43, 0x56, 0x77,
 171     0xaf, 0x88, 0xdd, 0x63, 0x89, 0x47, 0x06, 0x65
 172 };
 173 static const unsigned char aes_192_use_df_additionalinput2[] = {
 174     0x3c, 0x11, 0x64, 0x7a, 0x96, 0xf5, 0xd8, 0xb8, 0xae, 0xd6, 0x70, 0x4e,
 175     0x16, 0x96, 0xde, 0xe9, 0x62, 0xbc, 0xee, 0x28, 0x2f, 0x26, 0xa6, 0xf0,
 176     0x56, 0xef, 0xa3, 0xf1, 0x6b, 0xa1, 0xb1, 0x77
 177 };
 178 static const unsigned char aes_192_use_df_returnedbits[] = {
 179     0x0b, 0xe2, 0x56, 0x03, 0x1e, 0xdb, 0x2c, 0x6d, 0x7f, 0x1b, 0x15, 0x58,
 180     0x1a, 0xf9, 0x13, 0x28
 181 };
 182
 183
 184 /*
 185  * AES-256 use df PR
 186  */
 187 static const unsigned char aes_256_use_df_pr_entropyinput[] = {
 188     0x61, 0x68, 0xfc, 0x1a, 0xf0, 0xb5, 0x95, 0x6b, 0x85, 0x09, 0x9b, 0x74,
 189     0x3f, 0x13, 0x78, 0x49, 0x3b, 0x85, 0xec, 0x93, 0x13, 0x3b, 0xa9, 0x4f,
 190     0x96, 0xab, 0x2c, 0xe4, 0xc8, 0x8f, 0xdd, 0x6a
 191 };
 192 static const unsigned char aes_256_use_df_pr_nonce[] = {
 193     0xad, 0xd2, 0xbb, 0xba, 0xb7, 0x65, 0x89, 0xc3, 0x21, 0x6c, 0x55, 0x33,
 194     0x2b, 0x36, 0xff, 0xa4
 195 };
 196 static const unsigned char aes_256_use_df_pr_personalizationstring[] = {
 197     0x6e, 0xca, 0xe7, 0x20, 0x72, 0xd3, 0x84, 0x5a, 0x32, 0xd3, 0x4b, 0x24,
 198     0x72, 0xc4, 0x63, 0x2b, 0x9d, 0x12, 0x24, 0x0c, 0x23, 0x26, 0x8e, 0x83,
 199     0x16, 0x37, 0x0b, 0xd1, 0x06, 0x4f, 0x68, 0x6d
 200 };
 201 static const unsigned char aes_256_use_df_pr_additionalinput[] = {
 202     0x7e, 0x08, 0x4a, 0xbb, 0xe3, 0x21, 0x7c, 0xc9, 0x23, 0xd2, 0xf8, 0xb0,
 203     0x73, 0x98, 0xba, 0x84, 0x74, 0x23, 0xab, 0x06, 0x8a, 0xe2, 0x22, 0xd3,
 204     0x7b, 0xce, 0x9b, 0xd2, 0x4a, 0x76, 0xb8, 0xde
 205 };
 206 static const unsigned char aes_256_use_df_pr_entropyinputpr[] = {
 207     0x0b, 0x23, 0xaf, 0xdf, 0xf1, 0x62, 0xd7, 0xd3, 0x43, 0x97, 0xf8, 0x77,
 208     0x04, 0xa8, 0x42, 0x20, 0xbd, 0xf6, 0x0f, 0xc1, 0x17, 0x2f, 0x9f, 0x54,
 209     0xbb, 0x56, 0x17, 0x86, 0x68, 0x0e, 0xba, 0xa9
 210 };
 211 static const unsigned char aes_256_use_df_pr_int_returnedbits[] = {
 212     0x31, 0x8e, 0xad, 0xaf, 0x40, 0xeb, 0x6b, 0x74, 0x31, 0x46, 0x80, 0xc7,
 213     0x17, 0xab, 0x3c, 0x7a
 214 };
 215 static const unsigned char aes_256_use_df_pr_additionalinput2[] = {
 216     0x94, 0x6b, 0xc9, 0x9f, 0xab, 0x8d, 0xc5, 0xec, 0x71, 0x88, 0x1d, 0x00,
 217     0x8c, 0x89, 0x68, 0xe4, 0xc8, 0x07, 0x77, 0x36, 0x17, 0x6d, 0x79, 0x78,
 218     0xc7, 0x06, 0x4e, 0x99, 0x04, 0x28, 0x29, 0xc3
 219 };
 220 static const unsigned char aes_256_use_df_pr_entropyinputpr2[] = {
 221     0xbf, 0x6c, 0x59, 0x2a, 0x0d, 0x44, 0x0f, 0xae, 0x9a, 0x5e, 0x03, 0x73,
 222     0xd8, 0xa6, 0xe1, 0xcf, 0x25, 0x61, 0x38, 0x24, 0x86, 0x9e, 0x53, 0xe8,
 223     0xa4, 0xdf, 0x56, 0xf4, 0x06, 0x07, 0x9c, 0x0f
 224 };
 225 static const unsigned char aes_256_use_df_pr_returnedbits[] = {
 226     0x22, 0x4a, 0xb4, 0xb8, 0xb6, 0xee, 0x7d, 0xb1, 0x9e, 0xc9, 0xf9, 0xa0,
 227     0xd9, 0xe2, 0x97, 0x00
 228 };
 229
 230
 231 /*
 232  * AES-256 use df no PR
 233  */
 234 static const unsigned char aes_256_use_df_entropyinput[] = {
 235     0xa5, 0x3e, 0x37, 0x10, 0x17, 0x43, 0x91, 0x93, 0x59, 0x1e, 0x47, 0x50,
 236     0x87, 0xaa, 0xdd, 0xd5, 0xc1, 0xc3, 0x86, 0xcd, 0xca, 0x0d, 0xdb, 0x68,
 237     0xe0, 0x02, 0xd8, 0x0f, 0xdc, 0x40, 0x1a, 0x47
 238 };
 239 static const unsigned char aes_256_use_df_nonce[] = {
 240     0xa9, 0x4d, 0xa5, 0x5a, 0xfd, 0xc5, 0x0c, 0xe5, 0x1c, 0x9a, 0x3b, 0x8a,
 241     0x4c, 0x44, 0x84, 0x40
 242 };
 243 static const unsigned char aes_256_use_df_personalizationstring[] = {
 244     0x8b, 0x52, 0xa2, 0x4a, 0x93, 0xc3, 0x4e, 0xa7, 0x1e, 0x1c, 0xa7, 0x05,
 245     0xeb, 0x82, 0x9b, 0xa6, 0x5d, 0xe4, 0xd4, 0xe0, 0x7f, 0xa3, 0xd8, 0x6b,
 246     0x37, 0x84, 0x5f, 0xf1, 0xc7, 0xd5, 0xf6, 0xd2
 247 };
 248 static const unsigned char aes_256_use_df_additionalinput[] = {
 249     0x20, 0xf4, 0x22, 0xed, 0xf8, 0x5c, 0xa1, 0x6a, 0x01, 0xcf, 0xbe, 0x5f,
 250     0x8d, 0x6c, 0x94, 0x7f, 0xae, 0x12, 0xa8, 0x57, 0xdb, 0x2a, 0xa9, 0xbf,
 251     0xc7, 0xb3, 0x65, 0x81, 0x80, 0x8d, 0x0d, 0x46
 252 };
 253 static const unsigned char aes_256_use_df_int_returnedbits[] = {
 254     0x4e, 0x44, 0xfd, 0xf3, 0x9e, 0x29, 0xa2, 0xb8, 0x0f, 0x5d, 0x6c, 0xe1,
 255     0x28, 0x0c, 0x3b, 0xc1
 256 };
 257 static const unsigned char aes_256_use_df_entropyinputreseed[] = {
 258     0xdd, 0x40, 0xe5, 0x98, 0x7b, 0x27, 0x16, 0x73, 0x15, 0x68, 0xd2, 0x76,
 259     0xbf, 0x0c, 0x67, 0x15, 0x75, 0x79, 0x03, 0xd3, 0xde, 0xde, 0x91, 0x46,
 260     0x42, 0xdd, 0xd4, 0x67, 0xc8, 0x79, 0xc8, 0x1e
 261 };
 262 static const unsigned char aes_256_use_df_additionalinputreseed[] = {
 263     0x7f, 0xd8, 0x1f, 0xbd, 0x2a, 0xb5, 0x1c, 0x11, 0x5d, 0x83, 0x4e, 0x99,
 264     0xf6, 0x5c, 0xa5, 0x40, 0x20, 0xed, 0x38, 0x8e, 0xd5, 0x9e, 0xe0, 0x75,
 265     0x93, 0xfe, 0x12, 0x5e, 0x5d, 0x73, 0xfb, 0x75
 266 };
 267 static const unsigned char aes_256_use_df_additionalinput2[] = {
 268     0xcd, 0x2c, 0xff, 0x14, 0x69, 0x3e, 0x4c, 0x9e, 0xfd, 0xfe, 0x26, 0x0d,
 269     0xe9, 0x86, 0x00, 0x49, 0x30, 0xba, 0xb1, 0xc6, 0x50, 0x57, 0x77, 0x2a,
 270     0x62, 0x39, 0x2c, 0x3b, 0x74, 0xeb, 0xc9, 0x0d
 271 };
 272 static const unsigned char aes_256_use_df_returnedbits[] = {
 273     0x4f, 0x78, 0xbe, 0xb9, 0x4d, 0x97, 0x8c, 0xe9, 0xd0, 0x97, 0xfe, 0xad,
 274     0xfa, 0xfd, 0x35, 0x5e
 275 };
 276
 277
 278 /*
 279  * AES-128 no df PR
 280  */
 281 static const unsigned char aes_128_no_df_pr_entropyinput[] = {
 282     0x9a, 0x25, 0x65, 0x10, 0x67, 0xd5, 0xb6, 0x6b, 0x70, 0xa1, 0xb3, 0xa4,
 283     0x43, 0x95, 0x80, 0xc0, 0x84, 0x0a, 0x79, 0xb0, 0x88, 0x74, 0xf2, 0xbf,
 284     0x31, 0x6c, 0x33, 0x38, 0x0b, 0x00, 0xb2, 0x5a
 285 };
 286 static const unsigned char aes_128_no_df_pr_nonce[] = {
 287     0x78, 0x47, 0x6b, 0xf7, 0x90, 0x8e, 0x87, 0xf1,
 288 };
 289 static const unsigned char aes_128_no_df_pr_personalizationstring[] = {
 290     0xf7, 0x22, 0x1d, 0x3a, 0xbe, 0x1d, 0xca, 0x32, 0x1b, 0xbd, 0x87, 0x0c,
 291     0x51, 0x24, 0x19, 0xee, 0xa3, 0x23, 0x09, 0x63, 0x33, 0x3d, 0xa8, 0x0c,
 292     0x1c, 0xfa, 0x42, 0x89, 0xcc, 0x6f, 0xa0, 0xa8
 293 };
 294 static const unsigned char aes_128_no_df_pr_additionalinput[] = {
 295     0xc9, 0xe0, 0x80, 0xbf, 0x8c, 0x45, 0x58, 0x39, 0xff, 0x00, 0xab, 0x02,
 296     0x4c, 0x3e, 0x3a, 0x95, 0x9b, 0x80, 0xa8, 0x21, 0x2a, 0xee, 0xba, 0x73,
 297     0xb1, 0xd9, 0xcf, 0x28, 0xf6, 0x8f, 0x9b, 0x12
 298 };
 299 static const unsigned char aes_128_no_df_pr_entropyinputpr[] = {
 300     0x4c, 0xa8, 0xc5, 0xf0, 0x59, 0x9e, 0xa6, 0x8d, 0x26, 0x53, 0xd7, 0x8a,
 301     0xa9, 0xd8, 0xf7, 0xed, 0xb2, 0xf9, 0x12, 0x42, 0xe1, 0xe5, 0xbd, 0xe7,
 302     0xe7, 0x1d, 0x74, 0x99, 0x00, 0x9d, 0x31, 0x3e
 303 };
 304 static const unsigned char aes_128_no_df_pr_int_returnedbits[] = {
 305     0xe2, 0xac, 0x20, 0xf0, 0x80, 0xe7, 0xbc, 0x7e, 0x9c, 0x7b, 0x65, 0x71,
 306     0xaf, 0x19, 0x32, 0x16
 307 };
 308 static const unsigned char aes_128_no_df_pr_additionalinput2[] = {
 309     0x32, 0x7f, 0x38, 0x8b, 0x73, 0x0a, 0x78, 0x83, 0xdc, 0x30, 0xbe, 0x9f,
 310     0x10, 0x1f, 0xf5, 0x1f, 0xca, 0x00, 0xb5, 0x0d, 0xd6, 0x9d, 0x60, 0x83,
 311     0x51, 0x54, 0x7d, 0x38, 0x23, 0x3a, 0x52, 0x50
 312 };
 313 static const unsigned char aes_128_no_df_pr_entropyinputpr2[] = {
 314     0x18, 0x61, 0x53, 0x56, 0xed, 0xed, 0xd7, 0x20, 0xfb, 0x71, 0x04, 0x7a,
 315     0xb2, 0xac, 0xc1, 0x28, 0xcd, 0xf2, 0xc2, 0xfc, 0xaa, 0xb1, 0x06, 0x07,
 316     0xe9, 0x46, 0x95, 0x02, 0x48, 0x01, 0x78, 0xf9
 317 };
 318 static const unsigned char aes_128_no_df_pr_returnedbits[] = {
 319     0x29, 0xc8, 0x1b, 0x15, 0xb1, 0xd1, 0xc2, 0xf6, 0x71, 0x86, 0x68, 0x33,
 320     0x57, 0x82, 0x33, 0xaf
 321 };
 322
 323
 324 /*
 325  * AES-128 no df no PR
 326  */
 327 static const unsigned char aes_128_no_df_entropyinput[] = {
 328     0xc9, 0xc5, 0x79, 0xbc, 0xe8, 0xc5, 0x19, 0xd8, 0xbc, 0x66, 0x73, 0x67,
 329     0xf6, 0xd3, 0x72, 0xaa, 0xa6, 0x16, 0xb8, 0x50, 0xb7, 0x47, 0x3a, 0x42,
 330     0xab, 0xf4, 0x16, 0xb2, 0x96, 0xd2, 0xb6, 0x60
 331 };
 332 static const unsigned char aes_128_no_df_nonce[] = {
 333     0x5f, 0xbf, 0x97, 0x0c, 0x4b, 0xa4, 0x87, 0x13,
 334 };
 335 static const unsigned char aes_128_no_df_personalizationstring[] = {
 336     0xce, 0xfb, 0x7b, 0x3f, 0xd4, 0x6b, 0x29, 0x0d, 0x69, 0x06, 0xff, 0xbb,
 337     0xf2, 0xe5, 0xc6, 0x6c, 0x0a, 0x10, 0xa0, 0xcf, 0x1a, 0x48, 0xc7, 0x8b,
 338     0x3c, 0x16, 0x88, 0xed, 0x50, 0x13, 0x81, 0xce
 339 };
 340 static const unsigned char aes_128_no_df_additionalinput[] = {
 341     0x4b, 0x22, 0x46, 0x18, 0x02, 0x7b, 0xd2, 0x1b, 0x22, 0x42, 0x7c, 0x37,
 342     0xd9, 0xf6, 0xe8, 0x9b, 0x12, 0x30, 0x5f, 0xe9, 0x90, 0xe8, 0x08, 0x24,
 343     0x4f, 0x06, 0x66, 0xdb, 0x19, 0x2b, 0x13, 0x95
 344 };
 345 static const unsigned char aes_128_no_df_int_returnedbits[] = {
 346     0x2e, 0x96, 0x70, 0x64, 0xfa, 0xdf, 0xdf, 0x57, 0xb5, 0x82, 0xee, 0xd6,
 347     0xed, 0x3e, 0x65, 0xc2
 348 };
 349 static const unsigned char aes_128_no_df_entropyinputreseed[] = {
 350     0x26, 0xc0, 0x72, 0x16, 0x3a, 0x4b, 0xb7, 0x99, 0xd4, 0x07, 0xaf, 0x66,
 351     0x62, 0x36, 0x96, 0xa4, 0x51, 0x17, 0xfa, 0x07, 0x8b, 0x17, 0x5e, 0xa1,
 352     0x2f, 0x3c, 0x10, 0xe7, 0x90, 0xd0, 0x46, 0x00
 353 };
 354 static const unsigned char aes_128_no_df_additionalinputreseed[] = {
 355     0x83, 0x39, 0x37, 0x7b, 0x02, 0x06, 0xd2, 0x12, 0x13, 0x8d, 0x8b, 0xf2,
 356     0xf0, 0xf6, 0x26, 0xeb, 0xa4, 0x22, 0x7b, 0xc2, 0xe7, 0xba, 0x79, 0xe4,
 357     0x3b, 0x77, 0x5d, 0x4d, 0x47, 0xb2, 0x2d, 0xb4
 358 };
 359 static const unsigned char aes_128_no_df_additionalinput2[] = {
 360     0x0b, 0xb9, 0x67, 0x37, 0xdb, 0x83, 0xdf, 0xca, 0x81, 0x8b, 0xf9, 0x3f,
 361     0xf1, 0x11, 0x1b, 0x2f, 0xf0, 0x61, 0xa6, 0xdf, 0xba, 0xa3, 0xb1, 0xac,
 362     0xd3, 0xe6, 0x09, 0xb8, 0x2c, 0x6a, 0x67, 0xd6
 363 };
 364 static const unsigned char aes_128_no_df_returnedbits[] = {
 365     0x1e, 0xa7, 0xa4, 0xe4, 0xe1, 0xa6, 0x7c, 0x69, 0x9a, 0x44, 0x6c, 0x36,
 366     0x81, 0x37, 0x19, 0xd4
 367 };
 368
 369
 370 /*
 371  * AES-192 no df PR
 372  */
 373 static const unsigned char aes_192_no_df_pr_entropyinput[] = {
 374     0x9d, 0x2c, 0xd2, 0x55, 0x66, 0xea, 0xe0, 0xbe, 0x18, 0xb7, 0x76, 0xe7,
 375     0x73, 0x35, 0xd8, 0x1f, 0xad, 0x3a, 0xe3, 0x81, 0x0e, 0x92, 0xd0, 0x61,
 376     0xc9, 0x12, 0x26, 0xf6, 0x1c, 0xdf, 0xfe, 0x47, 0xaa, 0xfe, 0x7d, 0x5a,
 377     0x17, 0x1f, 0x8d, 0x9a
 378 };
 379 static const unsigned char aes_192_no_df_pr_nonce[] = {
 380     0x44, 0x82, 0xed, 0xe8, 0x4c, 0x28, 0x5a, 0x14, 0xff, 0x88, 0x8d, 0x19,
 381     0x61, 0x5c, 0xee, 0x0f
 382 };
 383 static const unsigned char aes_192_no_df_pr_personalizationstring[] = {
 384     0x47, 0xd7, 0x9b, 0x99, 0xaa, 0xcb, 0xe7, 0xd2, 0x57, 0x66, 0x2c, 0xe1,
 385     0x78, 0xd6, 0x2c, 0xea, 0xa3, 0x23, 0x5f, 0x2a, 0xc1, 0x3a, 0xf0, 0xa4,
 386     0x20, 0x3b, 0xfa, 0x07, 0xd5, 0x05, 0x02, 0xe4, 0x57, 0x01, 0xb6, 0x10,
 387     0x57, 0x2e, 0xe7, 0x55
 388 };
 389 static const unsigned char aes_192_no_df_pr_additionalinput[] = {
 390     0x4b, 0x74, 0x0b, 0x40, 0xce, 0x6b, 0xc2, 0x6a, 0x24, 0xb4, 0xf3, 0xad,
 391     0x7a, 0xa5, 0x7a, 0xa2, 0x15, 0xe2, 0xc8, 0x61, 0x15, 0xc6, 0xb7, 0x85,
 392     0x69, 0x11, 0xad, 0x7b, 0x14, 0xd2, 0xf6, 0x12, 0xa1, 0x95, 0x5d, 0x3f,
 393     0xe2, 0xd0, 0x0c, 0x2f
 394 };
 395 static const unsigned char aes_192_no_df_pr_entropyinputpr[] = {
 396     0x0c, 0x9c, 0xad, 0x05, 0xee, 0xae, 0x48, 0x23, 0x89, 0x59, 0xa1, 0x94,
 397     0xd7, 0xd8, 0x75, 0xd5, 0x54, 0x93, 0xc7, 0x4a, 0xd9, 0x26, 0xde, 0xeb,
 398     0xba, 0xb0, 0x7e, 0x30, 0x1d, 0x5f, 0x69, 0x40, 0x9c, 0x3b, 0x17, 0x58,
 399     0x1d, 0x30, 0xb3, 0x78
 400 };
 401 static const unsigned char aes_192_no_df_pr_int_returnedbits[] = {
 402     0xf7, 0x93, 0xb0, 0x6d, 0x77, 0x83, 0xd5, 0x38, 0x01, 0xe1, 0x52, 0x40,
 403     0x7e, 0x3e, 0x0c, 0x26
 404 };
 405 static const unsigned char aes_192_no_df_pr_additionalinput2[] = {
 406     0xbc, 0x4b, 0x37, 0x44, 0x1c, 0xc5, 0x45, 0x5f, 0x8f, 0x51, 0x62, 0x8a,
 407     0x85, 0x30, 0x1d, 0x7c, 0xe4, 0xcf, 0xf7, 0x44, 0xce, 0x32, 0x3e, 0x57,
 408     0x95, 0xa4, 0x2a, 0xdf, 0xfd, 0x9e, 0x38, 0x41, 0xb3, 0xf6, 0xc5, 0xee,
 409     0x0c, 0x4b, 0xee, 0x6e
 410 };
 411 static const unsigned char aes_192_no_df_pr_entropyinputpr2[] = {
 412     0xec, 0xaf, 0xf6, 0x4f, 0xb1, 0xa0, 0x54, 0xb5, 0x5b, 0xe3, 0x46, 0xb0,
 413     0x76, 0x5a, 0x7c, 0x3f, 0x7b, 0x94, 0x69, 0x21, 0x51, 0x02, 0xe5, 0x9f,
 414     0x04, 0x59, 0x02, 0x98, 0xc6, 0x43, 0x2c, 0xcc, 0x26, 0x4c, 0x87, 0x6b,
 415     0x8e, 0x0a, 0x83, 0xdf
 416 };
 417 static const unsigned char aes_192_no_df_pr_returnedbits[] = {
 418     0x74, 0x45, 0xfb, 0x53, 0x84, 0x96, 0xbe, 0xff, 0x15, 0xcc, 0x41, 0x91,
 419     0xb9, 0xa1, 0x21, 0x68
 420 };
 421
 422
 423 /*
 424  * AES-192 no df no PR
 425  */
 426 static const unsigned char aes_192_no_df_entropyinput[] = {
 427     0x3c, 0x7d, 0xb5, 0xe0, 0x54, 0xd9, 0x6e, 0x8c, 0xa9, 0x86, 0xce, 0x4e,
 428     0x6b, 0xaf, 0xeb, 0x2f, 0xe7, 0x75, 0xe0, 0x8b, 0xa4, 0x3b, 0x07, 0xfe,
 429     0xbe, 0x33, 0x75, 0x93, 0x80, 0x27, 0xb5, 0x29, 0x47, 0x8b, 0xc7, 0x28,
 430     0x94, 0xc3, 0x59, 0x63
 431 };
 432 static const unsigned char aes_192_no_df_nonce[] = {
 433     0x43, 0xf1, 0x7d, 0xb8, 0xc3, 0xfe, 0xd0, 0x23, 0x6b, 0xb4, 0x92, 0xdb,
 434     0x29, 0xfd, 0x45, 0x71
 435 };
 436 static const unsigned char aes_192_no_df_personalizationstring[] = {
 437     0x9f, 0x24, 0x29, 0x99, 0x9e, 0x01, 0xab, 0xe9, 0x19, 0xd8, 0x23, 0x08,
 438     0xb7, 0xd6, 0x7e, 0x8c, 0xc0, 0x9e, 0x7f, 0x6e, 0x5b, 0x33, 0x20, 0x96,
 439     0x0b, 0x23, 0x2c, 0xa5, 0x6a, 0xf8, 0x1b, 0x04, 0x26, 0xdb, 0x2e, 0x2b,
 440     0x3b, 0x88, 0xce, 0x35
 441 };
 442 static const unsigned char aes_192_no_df_additionalinput[] = {
 443     0x94, 0xe9, 0x7c, 0x3d, 0xa7, 0xdb, 0x60, 0x83, 0x1f, 0x98, 0x3f, 0x0b,
 444     0x88, 0x59, 0x57, 0x51, 0x88, 0x9f, 0x76, 0x49, 0x9f, 0xa6, 0xda, 0x71,
 445     0x1d, 0x0d, 0x47, 0x16, 0x63, 0xc5, 0x68, 0xe4, 0x5d, 0x39, 0x69, 0xb3,
 446     0x3e, 0xbe, 0xd4, 0x8e
 447 };
 448 static const unsigned char aes_192_no_df_int_returnedbits[] = {
 449     0xf9, 0xd7, 0xad, 0x69, 0xab, 0x8f, 0x23, 0x56, 0x70, 0x17, 0x4f, 0x2a,
 450     0x45, 0xe7, 0x4a, 0xc5
 451 };
 452 static const unsigned char aes_192_no_df_entropyinputreseed[] = {
 453     0xa6, 0x71, 0x6a, 0x3d, 0xba, 0xd1, 0xe8, 0x66, 0xa6, 0xef, 0xb2, 0x0e,
 454     0xa8, 0x9c, 0xaa, 0x4e, 0xaf, 0x17, 0x89, 0x50, 0x00, 0xda, 0xa1, 0xb1,
 455     0x0b, 0xa4, 0xd9, 0x35, 0x89, 0xc8, 0xe5, 0xb0, 0xd9, 0xb7, 0xc4, 0x33,
 456     0x9b, 0xcb, 0x7e, 0x75
 457 };
 458 static const unsigned char aes_192_no_df_additionalinputreseed[] = {
 459     0x27, 0x21, 0xfc, 0xc2, 0xbd, 0xf3, 0x3c, 0xce, 0xc3, 0xca, 0xc1, 0x01,
 460     0xe0, 0xff, 0x93, 0x12, 0x7d, 0x54, 0x42, 0xe3, 0x9f, 0x03, 0xdf, 0x27,
 461     0x04, 0x07, 0x3c, 0x53, 0x7f, 0xa8, 0x66, 0xc8, 0x97, 0x4b, 0x61, 0x40,
 462     0x5d, 0x7a, 0x25, 0x79
 463 };
 464 static const unsigned char aes_192_no_df_additionalinput2[] = {
 465     0x2d, 0x8e, 0x16, 0x5d, 0x0b, 0x9f, 0xeb, 0xaa, 0xd6, 0xec, 0x28, 0x71,
 466     0x7c, 0x0b, 0xc1, 0x1d, 0xd4, 0x44, 0x19, 0x47, 0xfd, 0x1d, 0x7c, 0xe5,
 467     0xf3, 0x27, 0xe1, 0xb6, 0x72, 0x0a, 0xe0, 0xec, 0x0e, 0xcd, 0xef, 0x1a,
 468     0x91, 0x6a, 0xe3, 0x5f
 469 };
 470 static const unsigned char aes_192_no_df_returnedbits[] = {
 471     0xe5, 0xda, 0xb8, 0xe0, 0x63, 0x59, 0x5a, 0xcc, 0x3d, 0xdc, 0x9f, 0xe8,
 472     0x66, 0x67, 0x2c, 0x92
 473 };
 474
 475
 476 /*
 477  * AES-256 no df PR
 478  */
 479 static const unsigned char aes_256_no_df_pr_entropyinput[] = {
 480     0x15, 0xc7, 0x5d, 0xcb, 0x41, 0x4b, 0x16, 0x01, 0x3a, 0xd1, 0x44, 0xe8,
 481     0x22, 0x32, 0xc6, 0x9c, 0x3f, 0xe7, 0x43, 0xf5, 0x9a, 0xd3, 0xea, 0xf2,
 482     0xd7, 0x4e, 0x6e, 0x6a, 0x55, 0x73, 0x40, 0xef, 0x89, 0xad, 0x0d, 0x03,
 483     0x96, 0x7e, 0x78, 0x81, 0x2f, 0x91, 0x1b, 0x44, 0xb0, 0x02, 0xba, 0x1c,
 484 };
 485 static const unsigned char aes_256_no_df_pr_nonce[] = {
 486     0xdc, 0xe4, 0xd4, 0x27, 0x7a, 0x90, 0xd7, 0x99, 0x43, 0xa1, 0x3c, 0x30,
 487     0xcc, 0x4b, 0xee, 0x2e
 488 };
 489 static const unsigned char aes_256_no_df_pr_personalizationstring[] = {
 490     0xe3, 0xe6, 0xb9, 0x11, 0xe4, 0x7a, 0xa4, 0x40, 0x6b, 0xf8, 0x73, 0xf7,
 491     0x7e, 0xec, 0xc7, 0xb9, 0x97, 0xbf, 0xf8, 0x25, 0x7b, 0xbe, 0x11, 0x9b,
 492     0x5b, 0x6a, 0x0c, 0x2e, 0x2b, 0x01, 0x51, 0xcd, 0x41, 0x4b, 0x6b, 0xac,
 493     0x31, 0xa8, 0x0b, 0xf7, 0xe6, 0x59, 0x42, 0xb8, 0x03, 0x0c, 0xf8, 0x06,
 494 };
 495 static const unsigned char aes_256_no_df_pr_additionalinput[] = {
 496     0x6a, 0x9f, 0x00, 0x91, 0xae, 0xfe, 0xcf, 0x84, 0x99, 0xce, 0xb1, 0x40,
 497     0x6d, 0x5d, 0x33, 0x28, 0x84, 0xf4, 0x8c, 0x63, 0x4c, 0x7e, 0xbd, 0x2c,
 498     0x80, 0x76, 0xee, 0x5a, 0xaa, 0x15, 0x07, 0x31, 0xd8, 0xbb, 0x8c, 0x69,
 499     0x9d, 0x9d, 0xbc, 0x7e, 0x49, 0xae, 0xec, 0x39, 0x6b, 0xd1, 0x1f, 0x7e,
 500 };
 501 static const unsigned char aes_256_no_df_pr_entropyinputpr[] = {
 502     0xf3, 0xb9, 0x75, 0x9c, 0xbd, 0x88, 0xea, 0xa2, 0x50, 0xad, 0xd6, 0x16,
 503     0x1a, 0x12, 0x3c, 0x86, 0x68, 0xaf, 0x6f, 0xbe, 0x19, 0xf2, 0xee, 0xcc,
 504     0xa5, 0x70, 0x84, 0x53, 0x50, 0xcb, 0x9f, 0x14, 0xa9, 0xe5, 0xee, 0xb9,
 505     0x48, 0x45, 0x40, 0xe2, 0xc7, 0xc9, 0x9a, 0x74, 0xff, 0x8c, 0x99, 0x1f,
 506 };
 507 static const unsigned char aes_256_no_df_pr_int_returnedbits[] = {
 508     0x2e, 0xf2, 0x45, 0x4c, 0x62, 0x2e, 0x0a, 0xb9, 0x6b, 0xa2, 0xfd, 0x56,
 509     0x79, 0x60, 0x93, 0xcf
 510 };
 511 static const unsigned char aes_256_no_df_pr_additionalinput2[] = {
 512     0xaf, 0x69, 0x20, 0xe9, 0x3b, 0x37, 0x9d, 0x3f, 0xb4, 0x80, 0x02, 0x7a,
 513     0x25, 0x7d, 0xb8, 0xde, 0x71, 0xc5, 0x06, 0x0c, 0xb4, 0xe2, 0x8f, 0x35,
 514     0xd8, 0x14, 0x0d, 0x7f, 0x76, 0x63, 0x4e, 0xb5, 0xee, 0xe9, 0x6f, 0x34,
 515     0xc7, 0x5f, 0x56, 0x14, 0x4a, 0xe8, 0x73, 0x95, 0x5b, 0x1c, 0xb9, 0xcb,
 516 };
 517 static const unsigned char aes_256_no_df_pr_entropyinputpr2[] = {
 518     0xe5, 0xb0, 0x2e, 0x7e, 0x52, 0x30, 0xe3, 0x63, 0x82, 0xb6, 0x44, 0xd3,
 519     0x25, 0x19, 0x05, 0x24, 0x9a, 0x9f, 0x5f, 0x27, 0x6a, 0x29, 0xab, 0xfa,
 520     0x07, 0xa2, 0x42, 0x0f, 0xc5, 0xa8, 0x94, 0x7c, 0x17, 0x7b, 0x85, 0x83,
 521     0x0c, 0x25, 0x0e, 0x63, 0x0b, 0xe9, 0x12, 0x60, 0xcd, 0xef, 0x80, 0x0f,
 522 };
 523 static const unsigned char aes_256_no_df_pr_returnedbits[] = {
 524     0x5e, 0xf2, 0x26, 0xef, 0x9f, 0x58, 0x5d, 0xd5, 0x4a, 0x10, 0xfe, 0xa7,
 525     0x2d, 0x5f, 0x4a, 0x46
 526 };
 527
 528
 529 /*
 530  * AES-256 no df no PR
 531  */
 532 static const unsigned char aes_256_no_df_entropyinput[] = {
 533     0xfb, 0xcf, 0x1b, 0x61, 0x16, 0x89, 0x78, 0x23, 0xf5, 0xd8, 0x96, 0xe3,
 534     0x4e, 0x64, 0x0b, 0x29, 0x9a, 0x3f, 0xf8, 0xa5, 0xed, 0xf2, 0xfe, 0xdb,
 535     0x16, 0xca, 0x7f, 0x10, 0xfa, 0x5e, 0x18, 0x76, 0x2c, 0x63, 0x5e, 0x96,
 536     0xcf, 0xb3, 0xd6, 0xfc, 0xaf, 0x99, 0x39, 0x28, 0x9c, 0x61, 0xe8, 0xb3,
 537 };
 538 static const unsigned char aes_256_no_df_nonce[] = {
 539     0x12, 0x96, 0xf0, 0x52, 0xf3, 0x8d, 0x81, 0xcf, 0xde, 0x86, 0xf2, 0x99,
 540     0x43, 0x96, 0xb9, 0xf0
 541 };
 542 static const unsigned char aes_256_no_df_personalizationstring[] = {
 543     0x63, 0x0d, 0x78, 0xf5, 0x90, 0x8e, 0x32, 0x47, 0xb0, 0x4d, 0x37, 0x60,
 544     0x09, 0x96, 0xbc, 0xbf, 0x97, 0x7a, 0x62, 0x14, 0x45, 0xbd, 0x8d, 0xcc,
 545     0x69, 0xfb, 0x03, 0xe1, 0x80, 0x1c, 0xc7, 0xe2, 0x2a, 0xf9, 0x37, 0x3f,
 546     0x66, 0x4d, 0x62, 0xd9, 0x10, 0xe0, 0xad, 0xc8, 0x9a, 0xf0, 0xa8, 0x6d,
 547 };
 548 static const unsigned char aes_256_no_df_additionalinput[] = {
 549     0x36, 0xc6, 0x13, 0x60, 0xbb, 0x14, 0xad, 0x22, 0xb0, 0x38, 0xac, 0xa6,
 550     0x18, 0x16, 0x93, 0x25, 0x86, 0xb7, 0xdc, 0xdc, 0x36, 0x98, 0x2b, 0xf9,
 551     0x68, 0x33, 0xd3, 0xc6, 0xff, 0xce, 0x8d, 0x15, 0x59, 0x82, 0x76, 0xed,
 552     0x6f, 0x8d, 0x49, 0x74, 0x2f, 0xda, 0xdc, 0x1f, 0x17, 0xd0, 0xde, 0x17,
 553 };
 554 static const unsigned char aes_256_no_df_int_returnedbits[] = {
 555     0x16, 0x2f, 0x8e, 0x3f, 0x21, 0x7a, 0x1c, 0x20, 0x56, 0xd1, 0x92, 0xf6,
 556     0xd2, 0x25, 0x75, 0x0e
 557 };
 558 static const unsigned char aes_256_no_df_entropyinputreseed[] = {
 559     0x91, 0x79, 0x76, 0xee, 0xe0, 0xcf, 0x9e, 0xc2, 0xd5, 0xd4, 0x23, 0x9b,
 560     0x12, 0x8c, 0x7e, 0x0a, 0xb7, 0xd2, 0x8b, 0xd6, 0x7c, 0xa3, 0xc6, 0xe5,
 561     0x0e, 0xaa, 0xc7, 0x6b, 0xae, 0x0d, 0xfa, 0x53, 0x06, 0x79, 0xa1, 0xed,
 562     0x4d, 0x6a, 0x0e, 0xd8, 0x9d, 0xbe, 0x1b, 0x31, 0x93, 0x7b, 0xec, 0xfb,
 563 };
 564 static const unsigned char aes_256_no_df_additionalinputreseed[] = {
 565     0xd2, 0x46, 0x50, 0x22, 0x10, 0x14, 0x63, 0xf7, 0xea, 0x0f, 0xb9, 0x7e,
 566     0x0d, 0xe1, 0x94, 0x07, 0xaf, 0x09, 0x44, 0x31, 0xea, 0x64, 0xa4, 0x18,
 567     0x5b, 0xf9, 0xd8, 0xc2, 0xfa, 0x03, 0x47, 0xc5, 0x39, 0x43, 0xd5, 0x3b,
 568     0x62, 0x86, 0x64, 0xea, 0x2c, 0x73, 0x8c, 0xae, 0x9d, 0x98, 0x98, 0x29,
 569 };
 570 static const unsigned char aes_256_no_df_additionalinput2[] = {
 571     0x8c, 0xab, 0x18, 0xf8, 0xc3, 0xec, 0x18, 0x5c, 0xb3, 0x1e, 0x9d, 0xbe,
 572     0x3f, 0x03, 0xb4, 0x00, 0x98, 0x9d, 0xae, 0xeb, 0xf4, 0x94, 0xf8, 0x42,
 573     0x8f, 0xe3, 0x39, 0x07, 0xe1, 0xc9, 0xad, 0x0b, 0x1f, 0xed, 0xc0, 0xba,
 574     0xf6, 0xd1, 0xec, 0x27, 0x86, 0x7b, 0xd6, 0x55, 0x9b, 0x60, 0xa5, 0xc6,
 575 };
 576 static const unsigned char aes_256_no_df_returnedbits[] = {
 577     0xef, 0xd2, 0xd8, 0x5c, 0xdc, 0x62, 0x25, 0x9f, 0xaa, 0x1e, 0x2c, 0x67,
 578     0xf6, 0x02, 0x32, 0xe2
 579 };