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 };
 580
 581
 582 /* SHA-1 PR  */
 583 static const unsigned char sha1_pr_entropyinput[] =
 584 {
 585     0xd2, 0x36, 0xa5, 0x27, 0x31, 0x73, 0xdd, 0x11, 0x4f, 0x93, 0xbd, 0xe2,
 586     0x31, 0xa5, 0x91, 0x13
 587 };
 588 static const unsigned char sha1_pr_nonce[] =
 589 {
 590     0xb5, 0xb3, 0x60, 0xef, 0xf7, 0x63, 0x31, 0xf3
 591 };
 592 static const unsigned char sha1_pr_personalizationstring[] =
 593 {
 594     0xd4, 0xbb, 0x02, 0x10, 0xb2, 0x71, 0xdb, 0x81, 0xd6, 0xf0, 0x42, 0x60,
 595     0xda, 0xea, 0x77, 0x52
 596 };
 597 static const unsigned char sha1_pr_additionalinput[] =
 598 {
 599     0x4d, 0xd2, 0x6c, 0x87, 0xfb, 0x2c, 0x4f, 0xa6, 0x8d, 0x16, 0x63, 0x22,
 600     0x6a, 0x51, 0xe3, 0xf8
 601 };
 602 static const unsigned char sha1_pr_entropyinputpr[] =
 603 {
 604     0xc9, 0x83, 0x9e, 0x16, 0xf6, 0x1c, 0x0f, 0xb2, 0xec, 0x60, 0x31, 0xa9,
 605     0xcb, 0xa9, 0x36, 0x7a
 606 };
 607 static const unsigned char sha1_pr_int_returnedbits[] =
 608 {
 609     0xa8, 0x13, 0x4f, 0xf4, 0x31, 0x02, 0x44, 0xe3, 0xd3, 0x3d, 0x61, 0x9e,
 610     0xe5, 0xc6, 0x3e, 0x89, 0xb5, 0x9b, 0x0f, 0x35
 611 };
 612 static const unsigned char sha1_pr_additionalinput2[] =
 613 {
 614     0xf9, 0xe8, 0xd2, 0x72, 0x13, 0x34, 0x95, 0x6f, 0x15, 0x49, 0x47, 0x99,
 615     0x16, 0x03, 0x19, 0x47
 616 };
 617 static const unsigned char sha1_pr_entropyinputpr2[] =
 618 {
 619     0x4e, 0x8c, 0x49, 0x9b, 0x4a, 0x5c, 0x9b, 0x9c, 0x3a, 0xee, 0xfb, 0xd2,
 620     0xae, 0xcd, 0x8c, 0xc4
 621 };
 622 static const unsigned char sha1_pr_returnedbits[] =
 623 {
 624     0x50, 0xb4, 0xb4, 0xcd, 0x68, 0x57, 0xfc, 0x2e, 0xc1, 0x52, 0xcc, 0xf6,
 625     0x68, 0xa4, 0x81, 0xed, 0x7e, 0xe4, 0x1d, 0x87
 626 };
 627
 628
 629 /* SHA-1 No PR  */
 630 static const unsigned char sha1_entropyinput[] =
 631 {
 632     0xa9, 0x47, 0x1b, 0x29, 0x2d, 0x1c, 0x05, 0xdf, 0x76, 0xd0, 0x62, 0xf9,
 633     0xe2, 0x7f, 0x4c, 0x7b
 634 };
 635 static const unsigned char sha1_nonce[] =
 636 {
 637     0x53, 0x23, 0x24, 0xe3, 0xec, 0x0c, 0x54, 0x14
 638 };
 639 static const unsigned char sha1_personalizationstring[] =
 640 {
 641     0x7a, 0x87, 0xa1, 0xac, 0x1c, 0xfd, 0xab, 0xae, 0xf7, 0xd6, 0xfb, 0x76,
 642     0x28, 0xec, 0x6d, 0xca
 643 };
 644 static const unsigned char sha1_additionalinput[] =
 645 {
 646     0xfc, 0x92, 0x35, 0xd6, 0x7e, 0xb7, 0x24, 0x65, 0xfd, 0x12, 0x27, 0x35,
 647     0xc0, 0x72, 0xca, 0x28
 648 };
 649 static const unsigned char sha1_int_returnedbits[] =
 650 {
 651     0x57, 0x88, 0x82, 0xe5, 0x25, 0xa5, 0x2c, 0x4a, 0x06, 0x20, 0x6c, 0x72,
 652     0x55, 0x61, 0xdd, 0x90, 0x71, 0x9f, 0x95, 0xea
 653 };
 654 static const unsigned char sha1_entropyinputreseed[] =
 655 {
 656     0x69, 0xa5, 0x40, 0x62, 0x98, 0x47, 0x56, 0x73, 0x4a, 0x8f, 0x60, 0x96,
 657     0xd6, 0x99, 0x27, 0xed
 658 };
 659 static const unsigned char sha1_additionalinputreseed[] =
 660 {
 661     0xe5, 0x40, 0x4e, 0xbd, 0x50, 0x00, 0xf5, 0x15, 0xa6, 0xee, 0x45, 0xda,
 662     0x84, 0x3d, 0xd4, 0xc0
 663 };
 664 static const unsigned char sha1_additionalinput2[] =
 665 {
 666     0x11, 0x51, 0x14, 0xf0, 0x09, 0x1b, 0x4e, 0x56, 0x0d, 0xe9, 0xf6, 0x1e,
 667     0x52, 0x65, 0xcd, 0x96
 668 };
 669 static const unsigned char sha1_returnedbits[] =
 670 {
 671     0xa1, 0x9c, 0x94, 0x6e, 0x29, 0xe1, 0x33, 0x0d, 0x32, 0xd6, 0xaa, 0xce,
 672     0x71, 0x3f, 0x52, 0x72, 0x8b, 0x42, 0xa8, 0xd7
 673 };
 674
 675
 676 /* SHA-224 PR  */
 677 static const unsigned char sha224_pr_entropyinput[] =
 678 {
 679     0x12, 0x69, 0x32, 0x4f, 0x83, 0xa6, 0xf5, 0x14, 0xe3, 0x49, 0x3e, 0x75,
 680     0x3e, 0xde, 0xad, 0xa1, 0x29, 0xc3, 0xf3, 0x19, 0x20, 0xb5, 0x4c, 0xd9
 681 };
 682 static const unsigned char sha224_pr_nonce[] =
 683 {
 684     0x6a, 0x78, 0xd0, 0xeb, 0xbb, 0x5a, 0xf0, 0xee, 0xe8, 0xc3, 0xba, 0x71
 685 };
 686 static const unsigned char sha224_pr_personalizationstring[] =
 687 {
 688     0xd5, 0xb8, 0xb6, 0xbc, 0xc1, 0x5b, 0x60, 0x31, 0x3c, 0xf5, 0xe5, 0xc0,
 689     0x8e, 0x52, 0x7a, 0xbd, 0xea, 0x47, 0xa9, 0x5f, 0x8f, 0xf9, 0x8b, 0xae
 690 };
 691 static const unsigned char sha224_pr_additionalinput[] =
 692 {
 693     0x1f, 0x55, 0xec, 0xae, 0x16, 0x12, 0x84, 0xba, 0x84, 0x16, 0x19, 0x88,
 694     0x8e, 0xb8, 0x33, 0x25, 0x54, 0xff, 0xca, 0x79, 0xaf, 0x07, 0x25, 0x50
 695 };
 696 static const unsigned char sha224_pr_entropyinputpr[] =
 697 {
 698     0x92, 0xa3, 0x32, 0xa8, 0x9a, 0x0a, 0x58, 0x7c, 0x1d, 0x5a, 0x7e, 0xe1,
 699     0xb2, 0x73, 0xab, 0x0e, 0x16, 0x79, 0x23, 0xd3, 0x29, 0x89, 0x81, 0xe1
 700 };
 701 static const unsigned char sha224_pr_int_returnedbits[] =
 702 {
 703     0xf3, 0x38, 0x91, 0x40, 0x37, 0x7a, 0x51, 0x72, 0x42, 0x74, 0x78, 0x0a,
 704     0x69, 0xfd, 0xa6, 0x44, 0x43, 0x45, 0x6c, 0x0c, 0x5a, 0x19, 0xff, 0xf1,
 705     0x54, 0x60, 0xee, 0x6a
 706 };
 707 static const unsigned char sha224_pr_additionalinput2[] =
 708 {
 709     0x75, 0xf3, 0x04, 0x25, 0xdd, 0x36, 0xa8, 0x37, 0x46, 0xae, 0x0c, 0x52,
 710     0x05, 0x79, 0x4c, 0x26, 0xdb, 0xe9, 0x71, 0x16, 0x4c, 0x0a, 0xf2, 0x60
 711 };
 712 static const unsigned char sha224_pr_entropyinputpr2[] =
 713 {
 714     0xea, 0xc5, 0x03, 0x0a, 0x4f, 0xb0, 0x38, 0x8d, 0x23, 0xd4, 0xc8, 0x77,
 715     0xe2, 0x6d, 0x9c, 0x0b, 0x44, 0xf7, 0x2d, 0x5b, 0xbf, 0x5d, 0x2a, 0x11
 716 };
 717 static const unsigned char sha224_pr_returnedbits[] =
 718 {
 719     0x60, 0x50, 0x2b, 0xe7, 0x86, 0xd8, 0x26, 0x73, 0xe3, 0x1d, 0x95, 0x20,
 720     0xb3, 0x2c, 0x32, 0x1c, 0xf5, 0xce, 0x57, 0xa6, 0x67, 0x2b, 0xdc, 0x4e,
 721     0xdd, 0x11, 0x4c, 0xc4
 722 };
 723
 724
 725 /* SHA-224 No PR  */
 726 static const unsigned char sha224_entropyinput[] =
 727 {
 728     0xb2, 0x1c, 0x77, 0x4d, 0xf6, 0xd3, 0xb6, 0x40, 0xb7, 0x30, 0x3e, 0x29,
 729     0xb0, 0x85, 0x1c, 0xbe, 0x4a, 0xea, 0x6b, 0x5a, 0xb5, 0x8a, 0x97, 0xeb
 730 };
 731 static const unsigned char sha224_nonce[] =
 732 {
 733     0x42, 0x02, 0x0a, 0x1c, 0x98, 0x9a, 0x77, 0x9e, 0x9f, 0x80, 0xba, 0xe0
 734 };
 735 static const unsigned char sha224_personalizationstring[] =
 736 {
 737     0x98, 0xb8, 0x04, 0x41, 0xfc, 0xc1, 0x5d, 0xc5, 0xe9, 0xb9, 0x08, 0xda,
 738     0xf9, 0xfa, 0x0d, 0x90, 0xce, 0xdf, 0x1d, 0x10, 0xa9, 0x8d, 0x50, 0x0c
 739 };
 740 static const unsigned char sha224_additionalinput[] =
 741 {
 742     0x9a, 0x8d, 0x39, 0x49, 0x42, 0xd5, 0x0b, 0xae, 0xe1, 0xaf, 0xb7, 0x00,
 743     0x02, 0xfa, 0x96, 0xb1, 0xa5, 0x1d, 0x2d, 0x25, 0x78, 0xee, 0x83, 0x3f
 744 };
 745 static const unsigned char sha224_int_returnedbits[] =
 746 {
 747     0xe4, 0xf5, 0x53, 0x79, 0x5a, 0x97, 0x58, 0x06, 0x08, 0xba, 0x7b, 0xfa,
 748     0xf0, 0x83, 0x05, 0x8c, 0x22, 0xc0, 0xc9, 0xdb, 0x15, 0xe7, 0xde, 0x20,
 749     0x55, 0x22, 0x9a, 0xad
 750 };
 751 static const unsigned char sha224_entropyinputreseed[] =
 752 {
 753     0x67, 0x09, 0x48, 0xaa, 0x07, 0x16, 0x99, 0x89, 0x7f, 0x6d, 0xa0, 0xe5,
 754     0x8f, 0xdf, 0xbc, 0xdb, 0xfe, 0xe5, 0x6c, 0x7a, 0x95, 0x4a, 0x66, 0x17
 755 };
 756 static const unsigned char sha224_additionalinputreseed[] =
 757 {
 758     0x0f, 0x4b, 0x1c, 0x6f, 0xb7, 0xe3, 0x47, 0xe5, 0x5d, 0x7d, 0x38, 0xd6,
 759     0x28, 0x9b, 0xeb, 0x55, 0x63, 0x09, 0x3e, 0x7c, 0x56, 0xea, 0xf8, 0x19
 760 };
 761 static const unsigned char sha224_additionalinput2[] =
 762 {
 763     0x2d, 0x26, 0x7c, 0x37, 0xe4, 0x7a, 0x28, 0x5e, 0x5a, 0x3c, 0xaf, 0x3d,
 764     0x5a, 0x8e, 0x55, 0xa2, 0x1a, 0x6e, 0xc0, 0xe5, 0xf6, 0x21, 0xd3, 0xf6
 765 };
 766 static const unsigned char sha224_returnedbits[] =
 767 {
 768     0x4d, 0x83, 0x35, 0xdf, 0x67, 0xa9, 0xfc, 0x17, 0xda, 0x70, 0xcc, 0x8b,
 769     0x7f, 0x77, 0xae, 0xa2, 0x5f, 0xb9, 0x7e, 0x74, 0x4c, 0x26, 0xc1, 0x7a,
 770     0x3b, 0xa7, 0x5c, 0x93
 771 };
 772
 773
 774 /* SHA-256 PR  */
 775 static const unsigned char sha256_pr_entropyinput[] =
 776 {
 777     0xce, 0x49, 0x00, 0x7a, 0x56, 0xe3, 0x67, 0x8f, 0xe1, 0xb6, 0xa7, 0xd4,
 778     0x4f, 0x08, 0x7a, 0x1b, 0x01, 0xf4, 0xfa, 0x6b, 0xef, 0xb7, 0xe5, 0xeb,
 779     0x07, 0x3d, 0x11, 0x0d, 0xc8, 0xea, 0x2b, 0xfe
 780 };
 781 static const unsigned char sha256_pr_nonce[] =
 782 {
 783     0x73, 0x41, 0xc8, 0x92, 0x94, 0xe2, 0xc5, 0x5f, 0x93, 0xfd, 0x39, 0x5d,
 784     0x2b, 0x91, 0x4d, 0x38
 785 };
 786 static const unsigned char sha256_pr_personalizationstring[] =
 787 {
 788     0x50, 0x6d, 0x01, 0x01, 0x07, 0x5a, 0x80, 0x35, 0x7a, 0x56, 0x1a, 0x56,
 789     0x2f, 0x9a, 0x0b, 0x35, 0xb2, 0xb1, 0xc9, 0xe5, 0xca, 0x69, 0x61, 0x48,
 790     0xff, 0xfb, 0x0f, 0xd9, 0x4b, 0x79, 0x1d, 0xba
 791 };
 792 static const unsigned char sha256_pr_additionalinput[] =
 793 {
 794     0x20, 0xb8, 0xdf, 0x44, 0x77, 0x5a, 0xb8, 0xd3, 0xbf, 0xf6, 0xcf, 0xac,
 795     0x5e, 0xa6, 0x96, 0x62, 0x73, 0x44, 0x40, 0x4a, 0x30, 0xfb, 0x38, 0xa5,
 796     0x7b, 0x0d, 0xe4, 0x0d, 0xc6, 0xe4, 0x9a, 0x1f
 797 };
 798 static const unsigned char sha256_pr_entropyinputpr[] =
 799 {
 800     0x04, 0xc4, 0x65, 0xf4, 0xd3, 0xbf, 0x83, 0x4b, 0xab, 0xc8, 0x41, 0xa8,
 801     0xc2, 0xe0, 0x44, 0x63, 0x77, 0x4c, 0x6f, 0x6c, 0x49, 0x46, 0xff, 0x94,
 802     0x17, 0xea, 0xe6, 0x1a, 0x9d, 0x5e, 0x66, 0x78
 803 };
 804 static const unsigned char sha256_pr_int_returnedbits[] =
 805 {
 806     0x07, 0x4d, 0xac, 0x9b, 0x86, 0xca, 0x4a, 0xaa, 0x6e, 0x7a, 0x03, 0xa2,
 807     0x5d, 0x10, 0xea, 0x0b, 0xf9, 0x83, 0xcc, 0xd1, 0xfc, 0xe2, 0x07, 0xc7,
 808     0x06, 0x34, 0x60, 0x6f, 0x83, 0x94, 0x99, 0x76
 809 };
 810 static const unsigned char sha256_pr_additionalinput2[] =
 811 {
 812     0x89, 0x4e, 0x45, 0x8c, 0x11, 0xf9, 0xbc, 0x5b, 0xac, 0x74, 0x8b, 0x4b,
 813     0x5f, 0xf7, 0x19, 0xf3, 0xf5, 0x24, 0x54, 0x14, 0xd1, 0x15, 0xb1, 0x43,
 814     0x12, 0xa4, 0x5f, 0xd4, 0xec, 0xfc, 0xcd, 0x09
 815 };
 816 static const unsigned char sha256_pr_entropyinputpr2[] =
 817 {
 818     0x0e, 0xeb, 0x1f, 0xd7, 0xfc, 0xd1, 0x9d, 0xd4, 0x05, 0x36, 0x8b, 0xb2,
 819     0xfb, 0xe4, 0xf4, 0x51, 0x0c, 0x87, 0x9b, 0x02, 0x44, 0xd5, 0x92, 0x4d,
 820     0x44, 0xfe, 0x1a, 0x03, 0x43, 0x56, 0xbd, 0x86
 821 };
 822 static const unsigned char sha256_pr_returnedbits[] =
 823 {
 824     0x02, 0xaa, 0xb6, 0x1d, 0x7e, 0x2a, 0x40, 0x03, 0x69, 0x2d, 0x49, 0xa3,
 825     0x41, 0xe7, 0x44, 0x0b, 0xaf, 0x7b, 0x85, 0xe4, 0x5f, 0x53, 0x3b, 0x64,
 826     0xbc, 0x89, 0xc8, 0x82, 0xd4, 0x78, 0x37, 0xa2
 827 };
 828
 829
 830 /* SHA-256 No PR  */
 831 static const unsigned char sha256_entropyinput[] =
 832 {
 833     0x5b, 0x1b, 0xec, 0x4d, 0xa9, 0x38, 0x74, 0x5a, 0x34, 0x0b, 0x7b, 0xc5,
 834     0xe5, 0xd7, 0x66, 0x7c, 0xbc, 0x82, 0xb9, 0x0e, 0x2d, 0x1f, 0x92, 0xd7,
 835     0xc1, 0xbc, 0x67, 0x69, 0xec, 0x6b, 0x03, 0x3c
 836 };
 837 static const unsigned char sha256_nonce[] =
 838 {
 839     0xa4, 0x0c, 0xd8, 0x9c, 0x61, 0xd8, 0xc3, 0x54, 0xfe, 0x53, 0xc9, 0xe5,
 840     0x5d, 0x6f, 0x6d, 0x35
 841 };
 842 static const unsigned char sha256_personalizationstring[] =
 843 {
 844     0x22, 0x5e, 0x62, 0x93, 0x42, 0x83, 0x78, 0x24, 0xd8, 0x40, 0x8c, 0xde,
 845     0x6f, 0xf9, 0xa4, 0x7a, 0xc5, 0xa7, 0x3b, 0x88, 0xa3, 0xee, 0x42, 0x20,
 846     0xfd, 0x61, 0x56, 0xc6, 0x4c, 0x13, 0x41, 0x9c
 847 };
 848 static const unsigned char sha256_additionalinput[] =
 849 {
 850     0xbf, 0x74, 0x5b, 0xf6, 0xc5, 0x64, 0x5e, 0x99, 0x34, 0x8f, 0xbc, 0xa4,
 851     0xe2, 0xbd, 0xd8, 0x85, 0x26, 0x37, 0xea, 0xba, 0x4f, 0xf2, 0x9a, 0x9a,
 852     0x66, 0xfc, 0xdf, 0x63, 0x26, 0x26, 0x19, 0x87
 853 };
 854 static const unsigned char sha256_int_returnedbits[] =
 855 {
 856     0xb3, 0xc6, 0x07, 0x07, 0xd6, 0x75, 0xf6, 0x2b, 0xd6, 0x21, 0x96, 0xf1,
 857     0xae, 0xdb, 0x2b, 0xac, 0x25, 0x2a, 0xae, 0xae, 0x41, 0x72, 0x03, 0x5e,
 858     0xbf, 0xd3, 0x64, 0xbc, 0x59, 0xf9, 0xc0, 0x76
 859 };
 860 static const unsigned char sha256_entropyinputreseed[] =
 861 {
 862     0xbf, 0x20, 0x33, 0x56, 0x29, 0xa8, 0x37, 0x04, 0x1f, 0x78, 0x34, 0x3d,
 863     0x81, 0x2a, 0xc9, 0x86, 0xc6, 0x7a, 0x2f, 0x88, 0x5e, 0xd5, 0xbe, 0x34,
 864     0x46, 0x20, 0xa4, 0x35, 0xeb, 0xc7, 0xe2, 0x9d
 865 };
 866 static const unsigned char sha256_additionalinputreseed[] =
 867 {
 868     0x9b, 0xae, 0x2d, 0x2d, 0x61, 0xa4, 0x89, 0xeb, 0x43, 0x46, 0xa7, 0xda,
 869     0xef, 0x40, 0xca, 0x4a, 0x99, 0x11, 0x41, 0xdc, 0x5c, 0x94, 0xe9, 0xac,
 870     0xd4, 0xd0, 0xe6, 0xbd, 0xfb, 0x03, 0x9c, 0xa8
 871 };
 872 static const unsigned char sha256_additionalinput2[] =
 873 {
 874     0x23, 0xaa, 0x0c, 0xbd, 0x28, 0x33, 0xe2, 0x51, 0xfc, 0x71, 0xd2, 0x15,
 875     0x1f, 0x76, 0xfd, 0x0d, 0xe0, 0xb7, 0xb5, 0x84, 0x75, 0x5b, 0xbe, 0xf3,
 876     0x5c, 0xca, 0xc5, 0x30, 0xf2, 0x75, 0x1f, 0xda
 877 };
 878 static const unsigned char sha256_returnedbits[] =
 879 {
 880     0x90, 0x3c, 0xc1, 0x10, 0x8c, 0x12, 0x01, 0xc6, 0xa6, 0x3a, 0x0f, 0x4d,
 881     0xb6, 0x3a, 0x4f, 0x41, 0x9c, 0x61, 0x75, 0x84, 0xe9, 0x74, 0x75, 0xfd,
 882     0xfe, 0xf2, 0x1f, 0x43, 0xd8, 0x5e, 0x24, 0xa3
 883 };
 884
 885
 886 /* SHA-384 PR  */
 887 static const unsigned char sha384_pr_entropyinput[] =
 888 {
 889     0x71, 0x9d, 0xb2, 0x5a, 0x71, 0x6d, 0x04, 0xe9, 0x1e, 0xc7, 0x92, 0x24,
 890     0x6e, 0x12, 0x33, 0xa9, 0x52, 0x64, 0x31, 0xef, 0x71, 0xeb, 0x22, 0x55,
 891     0x28, 0x97, 0x06, 0x6a, 0xc0, 0x0c, 0xa0, 0x7e
 892 };
 893 static const unsigned char sha384_pr_nonce[] =
 894 {
 895     0xf5, 0x0d, 0xfa, 0xb0, 0xec, 0x6a, 0x7c, 0xd6, 0xbd, 0x9b, 0x05, 0xfd,
 896     0x38, 0x3e, 0x2e, 0x56
 897 };
 898 static const unsigned char sha384_pr_personalizationstring[] =
 899 {
 900     0x74, 0xac, 0x7e, 0x6d, 0xb1, 0xa4, 0xe7, 0x21, 0xd1, 0x1e, 0x6e, 0x96,
 901     0x6d, 0x4d, 0x53, 0x46, 0x82, 0x96, 0x6e, 0xcf, 0xaa, 0x81, 0x8d, 0x7d,
 902     0x9e, 0xe1, 0x0f, 0x15, 0xea, 0x41, 0xbf, 0xe3
 903 };
 904 static const unsigned char sha384_pr_additionalinput[] =
 905 {
 906     0xda, 0x95, 0xd4, 0xd0, 0xb8, 0x11, 0xd3, 0x49, 0x27, 0x5d, 0xa9, 0x39,
 907     0x68, 0xf3, 0xa8, 0xe9, 0x5d, 0x19, 0x8a, 0x2b, 0x66, 0xe8, 0x69, 0x06,
 908     0x7c, 0x9e, 0x03, 0xa1, 0x8b, 0x26, 0x2d, 0x6e
 909 };
 910 static const unsigned char sha384_pr_entropyinputpr[] =
 911 {
 912     0x49, 0xdf, 0x44, 0x00, 0xe4, 0x1c, 0x75, 0x0b, 0x26, 0x5a, 0x59, 0x64,
 913     0x1f, 0x4e, 0xb1, 0xb2, 0x13, 0xf1, 0x22, 0x4e, 0xb4, 0x6d, 0x9a, 0xcc,
 914     0xa0, 0x48, 0xe6, 0xcf, 0x1d, 0xd1, 0x92, 0x0d
 915 };
 916 static const unsigned char sha384_pr_int_returnedbits[] =
 917 {
 918     0xc8, 0x52, 0xae, 0xbf, 0x04, 0x3c, 0x27, 0xb7, 0x78, 0x18, 0xaa, 0x8f,
 919     0xff, 0xcf, 0xa4, 0xf1, 0xcc, 0xe7, 0x68, 0xfa, 0x22, 0xa2, 0x13, 0x45,
 920     0xe8, 0xdd, 0x87, 0xe6, 0xf2, 0x6e, 0xdd, 0xc7, 0x52, 0x90, 0x9f, 0x7b,
 921     0xfa, 0x61, 0x2d, 0x9d, 0x9e, 0xcf, 0x98, 0xac, 0x52, 0x40, 0xce, 0xaf
 922 };
 923 static const unsigned char sha384_pr_additionalinput2[] =
 924 {
 925     0x61, 0x7c, 0x03, 0x9a, 0x3e, 0x50, 0x57, 0x60, 0xc5, 0x83, 0xc9, 0xb2,
 926     0xd1, 0x87, 0x85, 0x66, 0x92, 0x5d, 0x84, 0x0e, 0x53, 0xfb, 0x70, 0x03,
 927     0x72, 0xfd, 0xba, 0xae, 0x9c, 0x8f, 0xf8, 0x18
 928 };
 929 static const unsigned char sha384_pr_entropyinputpr2[] =
 930 {
 931     0xf8, 0xeb, 0x89, 0xb1, 0x8d, 0x78, 0xbe, 0x21, 0xe0, 0xbb, 0x9d, 0xb7,
 932     0x95, 0x0e, 0xd9, 0x46, 0x0c, 0x8c, 0xe2, 0x63, 0xb7, 0x9d, 0x67, 0x90,
 933     0xbd, 0xc7, 0x0b, 0xa5, 0xce, 0xb2, 0x65, 0x81
 934 };
 935 static const unsigned char sha384_pr_returnedbits[] =
 936 {
 937     0xe6, 0x9f, 0xfe, 0x68, 0xd6, 0xb5, 0x79, 0xf1, 0x06, 0x5f, 0xa3, 0xbb,
 938     0x23, 0x85, 0xd8, 0xf0, 0x29, 0x5a, 0x68, 0x9e, 0xf5, 0xf4, 0xa6, 0x12,
 939     0xe0, 0x9a, 0xe2, 0xac, 0x00, 0x1d, 0x98, 0x26, 0xfc, 0x53, 0x95, 0x53,
 940     0xe4, 0x3e, 0x17, 0xd5, 0x08, 0x0b, 0x70, 0x3d, 0x67, 0x99, 0xac, 0x66
 941 };
 942
 943
 944 /* SHA-384 No PR  */
 945 static const unsigned char sha384_entropyinput[] =
 946 {
 947     0x07, 0x15, 0x27, 0x2a, 0xaf, 0x74, 0x24, 0x37, 0xbc, 0xd5, 0x14, 0x69,
 948     0xce, 0x11, 0xff, 0xa2, 0x6b, 0xb8, 0x05, 0x67, 0x34, 0xf8, 0xbd, 0x6d,
 949     0x6a, 0xcc, 0xcd, 0x60, 0xa3, 0x68, 0xca, 0xf4
 950 };
 951 static const unsigned char sha384_nonce[] =
 952 {
 953     0x70, 0x17, 0xc2, 0x5b, 0x5d, 0x22, 0x0b, 0x06, 0x15, 0x54, 0x78, 0x77,
 954     0x44, 0xaf, 0x2f, 0x09
 955 };
 956 static const unsigned char sha384_personalizationstring[] =
 957 {
 958     0x89, 0x39, 0x28, 0xb0, 0x60, 0xeb, 0x3d, 0xdc, 0x55, 0x75, 0x86, 0xeb,
 959     0xae, 0xa2, 0x8f, 0xbc, 0x1b, 0x75, 0xd4, 0xe1, 0x0f, 0xaa, 0x38, 0xca,
 960     0x62, 0x8b, 0xcb, 0x2c, 0x26, 0xf6, 0xbc, 0xb1
 961 };
 962 static const unsigned char sha384_additionalinput[] =
 963 {
 964     0x30, 0x2b, 0x42, 0x35, 0xef, 0xda, 0x40, 0x55, 0x28, 0xc6, 0x95, 0xfb,
 965     0x54, 0x01, 0x62, 0xd7, 0x87, 0x14, 0x48, 0x6d, 0x90, 0x4c, 0xa9, 0x02,
 966     0x54, 0x40, 0x22, 0xc8, 0x66, 0xa5, 0x48, 0x48
 967 };
 968 static const unsigned char sha384_int_returnedbits[] =
 969 {
 970     0x82, 0xc4, 0xa1, 0x9c, 0x21, 0xd2, 0xe7, 0xa5, 0xa6, 0xf6, 0x5f, 0x04,
 971     0x5c, 0xc7, 0x31, 0x9d, 0x8d, 0x59, 0x74, 0x50, 0x19, 0x89, 0x2f, 0x63,
 972     0xd5, 0xb7, 0x7e, 0xeb, 0x15, 0xe3, 0x70, 0x83, 0xa1, 0x24, 0x59, 0xfa,
 973     0x2c, 0x56, 0xf6, 0x88, 0x3a, 0x92, 0x93, 0xa1, 0xfb, 0x79, 0xc1, 0x7a
 974 };
 975 static const unsigned char sha384_entropyinputreseed[] =
 976 {
 977     0x39, 0xa6, 0xe8, 0x5c, 0x82, 0x17, 0x71, 0x26, 0x57, 0x4f, 0x9f, 0xc2,
 978     0x55, 0xff, 0x5c, 0x9b, 0x53, 0x1a, 0xd1, 0x5f, 0xbc, 0x62, 0xe4, 0x27,
 979     0x2d, 0x32, 0xf0, 0xe4, 0x52, 0x8c, 0xc5, 0x0c
 980 };
 981 static const unsigned char sha384_additionalinputreseed[] =
 982 {
 983     0x8d, 0xcb, 0x8d, 0xce, 0x08, 0xea, 0x80, 0xe8, 0x9b, 0x61, 0xa8, 0x0f,
 984     0xaf, 0x49, 0x20, 0x9e, 0x74, 0xcb, 0x57, 0x80, 0x42, 0xb0, 0x84, 0x5e,
 985     0x30, 0x2a, 0x67, 0x08, 0xf4, 0xe3, 0x40, 0x22
 986 };
 987 static const unsigned char sha384_additionalinput2[] =
 988 {
 989     0x7c, 0x8f, 0xc2, 0xae, 0x22, 0x4a, 0xd6, 0xf6, 0x05, 0xa4, 0x7a, 0xea,
 990     0xbb, 0x25, 0xd0, 0xb7, 0x5a, 0xd6, 0xcf, 0x9d, 0xf3, 0x6c, 0xe2, 0xb2,
 991     0x4e, 0xb4, 0xbd, 0xf4, 0xe5, 0x40, 0x80, 0x94
 992 };
 993 static const unsigned char sha384_returnedbits[] =
 994 {
 995     0x9e, 0x7e, 0xfb, 0x59, 0xbb, 0xaa, 0x3c, 0xf7, 0xe1, 0xf8, 0x76, 0xdd,
 996     0x63, 0x5f, 0xaf, 0x23, 0xd6, 0x64, 0x61, 0xc0, 0x9a, 0x09, 0x47, 0xc9,
 997     0x33, 0xdf, 0x6d, 0x55, 0x91, 0x34, 0x79, 0x70, 0xc4, 0x99, 0x6e, 0x54,
 998     0x09, 0x64, 0x21, 0x1a, 0xbd, 0x1e, 0x80, 0x40, 0x34, 0xad, 0xfa, 0xd7
 999 };
1000
1001
1002 /* SHA-512 PR  */
1003 static const unsigned char sha512_pr_entropyinput[] =
1004 {
1005     0x13, 0xf7, 0x61, 0x75, 0x65, 0x28, 0xa2, 0x59, 0x13, 0x5a, 0x4a, 0x4f,
1006     0x56, 0x60, 0x8c, 0x53, 0x7d, 0xb0, 0xbd, 0x06, 0x4f, 0xed, 0xcc, 0xd2,
1007     0xa2, 0xb5, 0xfd, 0x5b, 0x3a, 0xab, 0xec, 0x28
1008 };
1009 static const unsigned char sha512_pr_nonce[] =
1010 {
1011     0xbe, 0xa3, 0x91, 0x93, 0x1d, 0xc3, 0x31, 0x3a, 0x23, 0x33, 0x50, 0x67,
1012     0x88, 0xc7, 0xa2, 0xc4
1013 };
1014 static const unsigned char sha512_pr_personalizationstring[] =
1015 {
1016     0x1f, 0x59, 0x4d, 0x7b, 0xe6, 0x46, 0x91, 0x48, 0xc1, 0x25, 0xfa, 0xff,
1017     0x89, 0x12, 0x77, 0x35, 0xdf, 0x3e, 0xf4, 0x80, 0x5f, 0xd9, 0xb0, 0x07,
1018     0x22, 0x41, 0xdd, 0x48, 0x78, 0x6b, 0x77, 0x2b
1019 };
1020 static const unsigned char sha512_pr_additionalinput[] =
1021 {
1022     0x30, 0xff, 0x63, 0x6f, 0xac, 0xd9, 0x84, 0x39, 0x6f, 0xe4, 0x99, 0xce,
1023     0x91, 0x7d, 0x7e, 0xc8, 0x58, 0xf2, 0x12, 0xc3, 0xb6, 0xad, 0xda, 0x22,
1024     0x04, 0xa0, 0xd2, 0x21, 0xfe, 0xf2, 0x95, 0x1d
1025 };
1026 static const unsigned char sha512_pr_entropyinputpr[] =
1027 {
1028     0x64, 0x54, 0x13, 0xec, 0x4f, 0x77, 0xda, 0xb2, 0x92, 0x2e, 0x52, 0x80,
1029     0x11, 0x10, 0xc2, 0xf8, 0xe6, 0xa7, 0xcd, 0x4b, 0xfc, 0x32, 0x2e, 0x9e,
1030     0xeb, 0xbb, 0xb1, 0xbf, 0x15, 0x5c, 0x73, 0x08
1031 };
1032 static const unsigned char sha512_pr_int_returnedbits[] =
1033 {
1034     0xef, 0x1e, 0xdc, 0x0a, 0xa4, 0x36, 0x91, 0x9c, 0x3d, 0x27, 0x97, 0x50,
1035     0x8d, 0x36, 0x29, 0x8d, 0xce, 0x6a, 0x0c, 0xf7, 0x21, 0xc0, 0x91, 0xae,
1036     0x0c, 0x96, 0x72, 0xbd, 0x52, 0x81, 0x58, 0xfc, 0x6d, 0xe5, 0xf7, 0xa5,
1037     0xfd, 0x5d, 0xa7, 0x58, 0x68, 0xc8, 0x99, 0x58, 0x8e, 0xc8, 0xce, 0x95,
1038     0x01, 0x7d, 0xff, 0xa4, 0xc8, 0xf7, 0x63, 0xfe, 0x5f, 0x69, 0x83, 0x53,
1039     0xe2, 0xc6, 0x8b, 0xc3
1040 };
1041 static const unsigned char sha512_pr_additionalinput2[] =
1042 {
1043     0xe6, 0x9b, 0xc4, 0x88, 0x34, 0xca, 0xea, 0x29, 0x2f, 0x98, 0x05, 0xa4,
1044     0xd3, 0xc0, 0x7b, 0x11, 0xe8, 0xbb, 0x75, 0xf2, 0xbd, 0x29, 0xb7, 0x40,
1045     0x25, 0x7f, 0xc1, 0xb7, 0xb1, 0xf1, 0x25, 0x61
1046 };
1047 static const unsigned char sha512_pr_entropyinputpr2[] =
1048 {
1049     0x23, 0x6d, 0xff, 0xde, 0xfb, 0xd1, 0xba, 0x33, 0x18, 0xe6, 0xbe, 0xb5,
1050     0x48, 0x77, 0x6d, 0x7f, 0xa7, 0xe1, 0x4d, 0x48, 0x1e, 0x3c, 0xa7, 0x34,
1051     0x1a, 0xc8, 0x60, 0xdb, 0x8f, 0x99, 0x15, 0x99
1052 };
1053 static const unsigned char sha512_pr_returnedbits[] =
1054 {
1055     0x70, 0x27, 0x31, 0xdb, 0x92, 0x70, 0x21, 0xfe, 0x16, 0xb6, 0xc8, 0x51,
1056     0x34, 0x87, 0x65, 0xd0, 0x4e, 0xfd, 0xfe, 0x68, 0xec, 0xac, 0xdc, 0x93,
1057     0x41, 0x38, 0x92, 0x90, 0xb4, 0x94, 0xf9, 0x0d, 0xa4, 0xf7, 0x4e, 0x80,
1058     0x92, 0x67, 0x48, 0x40, 0xa7, 0x08, 0xc7, 0xbc, 0x66, 0x00, 0xfd, 0xf7,
1059     0x4c, 0x8b, 0x17, 0x6e, 0xd1, 0x8f, 0x9b, 0xf3, 0x6f, 0xf6, 0x34, 0xdd,
1060     0x67, 0xf7, 0x68, 0xdd
1061 };
1062
1063
1064 /* SHA-512 No PR  */
1065 static const unsigned char sha512_entropyinput[] =
1066 {
1067     0xb6, 0x0b, 0xb7, 0xbc, 0x84, 0x56, 0xf6, 0x12, 0xaf, 0x45, 0x67, 0x17,
1068     0x7c, 0xd1, 0xb2, 0x78, 0x2b, 0xa0, 0xf2, 0xbe, 0xb6, 0x6d, 0x8b, 0x56,
1069     0xc6, 0xbc, 0x4d, 0xe1, 0xf7, 0xbe, 0xce, 0xbd
1070 };
1071 static const unsigned char sha512_nonce[] =
1072 {
1073     0x9d, 0xed, 0xc0, 0xe5, 0x5a, 0x98, 0x6a, 0xcb, 0x51, 0x7d, 0x76, 0x31,
1074     0x5a, 0x64, 0xf0, 0xf7
1075 };
1076 static const unsigned char sha512_personalizationstring[] =
1077 {
1078     0xc2, 0x6d, 0xa3, 0xc3, 0x06, 0x74, 0xe5, 0x01, 0x5c, 0x10, 0x17, 0xc7,
1079     0xaf, 0x83, 0x9d, 0x59, 0x8d, 0x2d, 0x29, 0x38, 0xc5, 0x59, 0x70, 0x8b,
1080     0x46, 0x48, 0x2d, 0xcf, 0x36, 0x7d, 0x59, 0xc0
1081 };
1082 static const unsigned char sha512_additionalinput[] =
1083 {
1084     0xec, 0x8c, 0xd4, 0xf7, 0x61, 0x6e, 0x0d, 0x95, 0x79, 0xb7, 0x28, 0xad,
1085     0x5f, 0x69, 0x74, 0x5f, 0x2d, 0x36, 0x06, 0x8a, 0x6b, 0xac, 0x54, 0x97,
1086     0xc4, 0xa1, 0x12, 0x85, 0x0a, 0xdf, 0x4b, 0x34
1087 };
1088 static const unsigned char sha512_int_returnedbits[] =
1089 {
1090     0x84, 0x2f, 0x1f, 0x68, 0x6a, 0xa3, 0xad, 0x1e, 0xfb, 0xf4, 0x15, 0xbd,
1091     0xde, 0x38, 0xd4, 0x30, 0x80, 0x51, 0xe9, 0xd3, 0xc7, 0x20, 0x88, 0xe9,
1092     0xf5, 0xcc, 0xdf, 0x57, 0x5c, 0x47, 0x2f, 0x57, 0x3c, 0x5f, 0x13, 0x56,
1093     0xcc, 0xc5, 0x4f, 0x84, 0xf8, 0x10, 0x41, 0xd5, 0x7e, 0x58, 0x6e, 0x19,
1094     0x19, 0x9e, 0xaf, 0xc2, 0x22, 0x58, 0x41, 0x50, 0x79, 0xc2, 0xd8, 0x04,
1095     0x28, 0xd4, 0x39, 0x9a
1096 };
1097 static const unsigned char sha512_entropyinputreseed[] =
1098 {
1099     0xfa, 0x7f, 0x46, 0x51, 0x83, 0x62, 0x98, 0x16, 0x9a, 0x19, 0xa2, 0x49,
1100     0xa9, 0xe6, 0x4a, 0xd8, 0x85, 0xe7, 0xd4, 0x3b, 0x2c, 0x82, 0xc5, 0x82,
1101     0xbf, 0x11, 0xf9, 0x9e, 0xbc, 0xd0, 0x01, 0xee
1102 };
1103 static const unsigned char sha512_additionalinputreseed[] =
1104 {
1105     0xb9, 0x12, 0xe0, 0x4f, 0xf7, 0xa7, 0xc4, 0xd8, 0xd0, 0x8e, 0x99, 0x29,
1106     0x7c, 0x9a, 0xe9, 0xcf, 0xc4, 0x6c, 0xf8, 0xc3, 0xa7, 0x41, 0x83, 0xd6,
1107     0x2e, 0xfa, 0xb8, 0x5e, 0x8e, 0x6b, 0x78, 0x20
1108 };
1109 static const unsigned char sha512_additionalinput2[] =
1110 {
1111     0xd7, 0x07, 0x52, 0xb9, 0x83, 0x2c, 0x03, 0x71, 0xee, 0xc9, 0xc0, 0x85,
1112     0xe1, 0x57, 0xb2, 0xcd, 0x3a, 0xf0, 0xc9, 0x34, 0x24, 0x41, 0x1c, 0x42,
1113     0x99, 0xb2, 0x84, 0xe9, 0x17, 0xd2, 0x76, 0x92
1114 };
1115 static const unsigned char sha512_returnedbits[] =
1116 {
1117     0x36, 0x17, 0x5d, 0x98, 0x2b, 0x65, 0x25, 0x8e, 0xc8, 0x29, 0xdf, 0x27,
1118     0x05, 0x36, 0x26, 0x12, 0x8a, 0x68, 0x74, 0x27, 0x37, 0xd4, 0x7f, 0x32,
1119     0xb1, 0x12, 0xd6, 0x85, 0x83, 0xeb, 0x2e, 0xa0, 0xed, 0x4b, 0xb5, 0x7b,
1120     0x6f, 0x39, 0x3c, 0x71, 0x77, 0x02, 0x12, 0xcc, 0x2c, 0x3a, 0x8e, 0x63,
1121     0xdf, 0x4a, 0xbd, 0x6f, 0x6e, 0x2e, 0xed, 0x0a, 0x85, 0xa5, 0x2f, 0xa2,
1122     0x68, 0xde, 0x42, 0xb5
1123 };
1124
1125
1126 /* HMAC SHA-1 PR  */
1127 static const unsigned char hmac_sha1_pr_entropyinput[] =
1128 {
1129     0x26, 0x5f, 0x36, 0x14, 0xff, 0x3d, 0x83, 0xfa, 0x73, 0x5e, 0x75, 0xdc,
1130     0x2c, 0x18, 0x17, 0x1b
1131 };
1132 static const unsigned char hmac_sha1_pr_nonce[] =
1133 {
1134     0xc8, 0xe3, 0x57, 0xa5, 0x7b, 0x74, 0x86, 0x6e
1135 };
1136 static const unsigned char hmac_sha1_pr_personalizationstring[] =
1137 {
1138     0x6e, 0xdb, 0x0d, 0xfe, 0x7d, 0xac, 0x79, 0xd0, 0xa5, 0x3a, 0x48, 0x85,
1139     0x80, 0xe2, 0x7f, 0x2a
1140 };
1141 static const unsigned char hmac_sha1_pr_additionalinput[] =
1142 {
1143     0x31, 0xcd, 0x5e, 0x43, 0xdc, 0xfb, 0x7a, 0x79, 0xca, 0x88, 0xde, 0x1f,
1144     0xd7, 0xbb, 0x42, 0x09
1145 };
1146 static const unsigned char hmac_sha1_pr_entropyinputpr[] =
1147 {
1148     0x7c, 0x23, 0x95, 0x38, 0x00, 0x95, 0xc1, 0x78, 0x1f, 0x8f, 0xd7, 0x63,
1149     0x23, 0x87, 0x2a, 0xed
1150 };
1151 static const unsigned char hmac_sha1_pr_int_returnedbits[] =
1152 {
1153     0xbb, 0x34, 0xe7, 0x93, 0xa3, 0x02, 0x2c, 0x4a, 0xd0, 0x89, 0xda, 0x7f,
1154     0xed, 0xf4, 0x4c, 0xde, 0x17, 0xec, 0xe5, 0x6c
1155 };
1156 static const unsigned char hmac_sha1_pr_additionalinput2[] =
1157 {
1158     0x49, 0xbc, 0x2d, 0x2c, 0xb7, 0x32, 0xcb, 0x20, 0xdf, 0xf5, 0x77, 0x58,
1159     0xa0, 0x4b, 0x93, 0x6e
1160 };
1161 static const unsigned char hmac_sha1_pr_entropyinputpr2[] =
1162 {
1163     0x3c, 0xaa, 0xb0, 0x21, 0x42, 0xb0, 0xdd, 0x34, 0xf0, 0x16, 0x7f, 0x0c,
1164     0x0f, 0xff, 0x2e, 0xaf
1165 };
1166 static const unsigned char hmac_sha1_pr_returnedbits[] =
1167 {
1168     0x8e, 0xcb, 0xa3, 0x64, 0xb2, 0xb8, 0x33, 0x6c, 0x64, 0x3b, 0x78, 0x16,
1169     0x99, 0x35, 0xc8, 0x30, 0xcb, 0x3e, 0xa0, 0xd8
1170 };
1171
1172
1173 /* HMAC SHA-1 No PR  */
1174 static const unsigned char hmac_sha1_entropyinput[] =
1175 {
1176     0x32, 0x9a, 0x2a, 0x87, 0x7b, 0x89, 0x7c, 0xf6, 0xcb, 0x95, 0xd5, 0x40,
1177     0x17, 0xfe, 0x47, 0x70
1178 };
1179 static const unsigned char hmac_sha1_nonce[] =
1180 {
1181     0x16, 0xd8, 0xe0, 0xc7, 0x52, 0xcf, 0x4a, 0x25
1182 };
1183 static const unsigned char hmac_sha1_personalizationstring[] =
1184 {
1185     0x35, 0x35, 0xa9, 0xa5, 0x40, 0xbe, 0x9b, 0xd1, 0x56, 0xdd, 0x44, 0x00,
1186     0x72, 0xf7, 0xd3, 0x5e
1187 };
1188 static const unsigned char hmac_sha1_additionalinput[] =
1189 {
1190     0x1b, 0x2c, 0x84, 0x2d, 0x4a, 0x89, 0x8f, 0x69, 0x19, 0xf1, 0xf3, 0xdb,
1191     0xbb, 0xe3, 0xaa, 0xea
1192 };
1193 static const unsigned char hmac_sha1_int_returnedbits[] =
1194 {
1195     0xcf, 0xfa, 0x7d, 0x72, 0x0f, 0xe6, 0xc7, 0x96, 0xa0, 0x69, 0x31, 0x11,
1196     0x9b, 0x0b, 0x1a, 0x20, 0x1f, 0x3f, 0xaa, 0xd1
1197 };
1198 static const unsigned char hmac_sha1_entropyinputreseed[] =
1199 {
1200     0x90, 0x75, 0x15, 0x04, 0x95, 0xf1, 0xba, 0x81, 0x0c, 0x37, 0x94, 0x6f,
1201     0x86, 0x52, 0x6d, 0x9c
1202 };
1203 static const unsigned char hmac_sha1_additionalinputreseed[] =
1204 {
1205     0x5b, 0x40, 0xba, 0x5f, 0x17, 0x70, 0xf0, 0x4b, 0xdf, 0xc9, 0x97, 0x92,
1206     0x79, 0xc5, 0x82, 0x28
1207 };
1208 static const unsigned char hmac_sha1_additionalinput2[] =
1209 {
1210     0x97, 0xc8, 0x80, 0x90, 0xb3, 0xaa, 0x6e, 0x60, 0xea, 0x83, 0x7a, 0xe3,
1211     0x8a, 0xca, 0xa4, 0x7f
1212 };
1213 static const unsigned char hmac_sha1_returnedbits[] =
1214 {
1215     0x90, 0xbd, 0x05, 0x56, 0x6d, 0xb5, 0x22, 0xd5, 0xb9, 0x5a, 0x29, 0x2d,
1216     0xe9, 0x0b, 0xe1, 0xac, 0xde, 0x27, 0x0b, 0xb0
1217 };
1218
1219
1220 /* HMAC SHA-224 PR  */
1221 static const unsigned char hmac_sha224_pr_entropyinput[] =
1222 {
1223     0x17, 0x32, 0x2b, 0x2e, 0x6f, 0x1b, 0x9c, 0x6d, 0x31, 0xe0, 0x34, 0x07,
1224     0xcf, 0xed, 0xf6, 0xb6, 0x5a, 0x76, 0x4c, 0xbc, 0x62, 0x85, 0x01, 0x90
1225 };
1226 static const unsigned char hmac_sha224_pr_nonce[] =
1227 {
1228     0x38, 0xbf, 0x5f, 0x20, 0xb3, 0x68, 0x2f, 0x43, 0x61, 0x05, 0x8f, 0x23
1229 };
1230 static const unsigned char hmac_sha224_pr_personalizationstring[] =
1231 {
1232     0xc0, 0xc9, 0x45, 0xac, 0x8d, 0x27, 0x77, 0x08, 0x0b, 0x17, 0x6d, 0xed,
1233     0xc1, 0x7d, 0xd5, 0x07, 0x9d, 0x6e, 0xf8, 0x23, 0x2a, 0x22, 0x13, 0xbd
1234 };
1235 static const unsigned char hmac_sha224_pr_additionalinput[] =
1236 {
1237     0xa4, 0x3c, 0xe7, 0x3b, 0xea, 0x19, 0x45, 0x32, 0xc2, 0x83, 0x6d, 0x21,
1238     0x8a, 0xc0, 0xee, 0x67, 0x45, 0xde, 0x13, 0x7d, 0x9d, 0x61, 0x00, 0x3b
1239 };
1240 static const unsigned char hmac_sha224_pr_entropyinputpr[] =
1241 {
1242     0x15, 0x05, 0x74, 0x4a, 0x7f, 0x8d, 0x5c, 0x60, 0x16, 0xe5, 0x7b, 0xad,
1243     0xf5, 0x41, 0x8f, 0x55, 0x60, 0xc4, 0x09, 0xee, 0x1e, 0x11, 0x81, 0xab
1244 };
1245 static const unsigned char hmac_sha224_pr_int_returnedbits[] =
1246 {
1247     0x6f, 0xf5, 0x9a, 0xe2, 0x54, 0x53, 0x30, 0x3d, 0x5a, 0x27, 0x29, 0x38,
1248     0x27, 0xf2, 0x0d, 0x05, 0xe9, 0x26, 0xcb, 0x16, 0xc3, 0x51, 0x5f, 0x13,
1249     0x41, 0xfe, 0x99, 0xf2
1250 };
1251 static const unsigned char hmac_sha224_pr_additionalinput2[] =
1252 {
1253     0x73, 0x81, 0x88, 0x84, 0x8f, 0xed, 0x6f, 0x10, 0x9f, 0x93, 0xbf, 0x17,
1254     0x35, 0x7c, 0xef, 0xd5, 0x8d, 0x26, 0xa6, 0x7a, 0xe8, 0x09, 0x36, 0x4f
1255 };
1256 static const unsigned char hmac_sha224_pr_entropyinputpr2[] =
1257 {
1258     0xe6, 0xcf, 0xcf, 0x7e, 0x12, 0xe5, 0x43, 0xd2, 0x38, 0xd8, 0x24, 0x6f,
1259     0x5a, 0x37, 0x68, 0xbf, 0x4f, 0xa0, 0xff, 0xd5, 0x61, 0x8a, 0x93, 0xe0
1260 };
1261 static const unsigned char hmac_sha224_pr_returnedbits[] =
1262 {
1263     0xaf, 0xf9, 0xd8, 0x19, 0x91, 0x30, 0x82, 0x6f, 0xa9, 0x1e, 0x9d, 0xd7,
1264     0xf3, 0x50, 0xe0, 0xc7, 0xd5, 0x64, 0x96, 0x7d, 0x4c, 0x4d, 0x78, 0x03,
1265     0x6d, 0xd8, 0x9e, 0x72
1266 };
1267
1268
1269 /* HMAC SHA-224 No PR  */
1270 static const unsigned char hmac_sha224_entropyinput[] =
1271 {
1272     0x11, 0x82, 0xfd, 0xd9, 0x42, 0xf4, 0xfa, 0xc8, 0xf2, 0x41, 0xe6, 0x54,
1273     0x01, 0xae, 0x22, 0x6e, 0xc6, 0xaf, 0xaf, 0xd0, 0xa6, 0xb2, 0xe2, 0x6d
1274 };
1275 static const unsigned char hmac_sha224_nonce[] =
1276 {
1277     0xa9, 0x48, 0xd7, 0x92, 0x39, 0x7e, 0x2a, 0xdc, 0x30, 0x1f, 0x0e, 0x2b
1278 };
1279 static const unsigned char hmac_sha224_personalizationstring[] =
1280 {
1281     0x11, 0xd5, 0xf4, 0xbd, 0x67, 0x8c, 0x31, 0xcf, 0xa3, 0x3f, 0x1e, 0x6b,
1282     0xa8, 0x07, 0x02, 0x0b, 0xc8, 0x2e, 0x6c, 0x64, 0x41, 0x5b, 0xc8, 0x37
1283 };
1284 static const unsigned char hmac_sha224_additionalinput[] =
1285 {
1286     0x68, 0x18, 0xc2, 0x06, 0xeb, 0x3e, 0x04, 0x95, 0x44, 0x5e, 0xfb, 0xe6,
1287     0x41, 0xc1, 0x5c, 0xcc, 0x40, 0x2f, 0xb7, 0xd2, 0x0f, 0xf3, 0x6b, 0xe7
1288 };
1289 static const unsigned char hmac_sha224_int_returnedbits[] =
1290 {
1291     0x7f, 0x45, 0xc7, 0x5d, 0x32, 0xe6, 0x17, 0x60, 0xba, 0xdc, 0xb8, 0x42,
1292     0x1b, 0x9c, 0xf1, 0xfa, 0x3b, 0x4d, 0x29, 0x54, 0xc6, 0x90, 0xff, 0x5c,
1293     0xcd, 0xd6, 0xa9, 0xcc
1294 };
1295 static const unsigned char hmac_sha224_entropyinputreseed[] =
1296 {
1297     0xc4, 0x8e, 0x37, 0x95, 0x69, 0x53, 0x28, 0xd7, 0x37, 0xbb, 0x70, 0x95,
1298     0x1c, 0x07, 0x1d, 0xd9, 0xb7, 0xe6, 0x1b, 0xbb, 0xfe, 0x41, 0xeb, 0xc9
1299 };
1300 static const unsigned char hmac_sha224_additionalinputreseed[] =
1301 {
1302     0x53, 0x17, 0xa1, 0x6a, 0xfa, 0x77, 0x47, 0xb0, 0x95, 0x56, 0x9a, 0x20,
1303     0x57, 0xde, 0x5c, 0x89, 0x9f, 0x7f, 0xe2, 0xde, 0x17, 0x3a, 0x50, 0x23
1304 };
1305 static const unsigned char hmac_sha224_additionalinput2[] =
1306 {
1307     0x3a, 0x32, 0xf9, 0x85, 0x0c, 0xc1, 0xed, 0x76, 0x2d, 0xdf, 0x40, 0xc3,
1308     0x06, 0x22, 0x66, 0xd4, 0x9a, 0x9a, 0xff, 0x5a, 0x7e, 0x7a, 0xf3, 0x96
1309 };
1310 static const unsigned char hmac_sha224_returnedbits[] =
1311 {
1312     0x43, 0xb4, 0x57, 0x5c, 0x38, 0x25, 0x9d, 0xae, 0xec, 0x96, 0xd1, 0x85,
1313     0x3a, 0x84, 0x8d, 0xfe, 0x68, 0xd5, 0x0e, 0x5c, 0x8f, 0x65, 0xa5, 0x4e,
1314     0x45, 0x84, 0xa8, 0x94
1315 };
1316
1317
1318 /* HMAC SHA-256 PR  */
1319 static const unsigned char hmac_sha256_pr_entropyinput[] =
1320 {
1321     0x4d, 0xb0, 0x43, 0xd8, 0x34, 0x4b, 0x10, 0x70, 0xb1, 0x8b, 0xed, 0xea,
1322     0x07, 0x92, 0x9f, 0x6c, 0x79, 0x31, 0xaf, 0x81, 0x29, 0xeb, 0x6e, 0xca,
1323     0x32, 0x48, 0x28, 0xe7, 0x02, 0x5d, 0xa6, 0xa6
1324 };
1325 static const unsigned char hmac_sha256_pr_nonce[] =
1326 {
1327     0x3a, 0xae, 0x15, 0xa9, 0x99, 0xdc, 0xe4, 0x67, 0x34, 0x3b, 0x70, 0x15,
1328     0xaa, 0xd3, 0x30, 0x9a
1329 };
1330 static const unsigned char hmac_sha256_pr_personalizationstring[] =
1331 {
1332     0x13, 0x1d, 0x24, 0x04, 0xb0, 0x18, 0x81, 0x15, 0x21, 0x51, 0x2a, 0x24,
1333     0x52, 0x61, 0xbe, 0x64, 0x82, 0x6b, 0x55, 0x2f, 0xe2, 0xf1, 0x40, 0x7d,
1334     0x71, 0xd8, 0x01, 0x86, 0x15, 0xb7, 0x8b, 0xb5
1335 };
1336 static const unsigned char hmac_sha256_pr_additionalinput[] =
1337 {
1338     0x8f, 0xa6, 0x54, 0x5f, 0xb1, 0xd0, 0xd8, 0xc3, 0xe7, 0x0c, 0x15, 0xa9,
1339     0x23, 0x6e, 0xfe, 0xfb, 0x93, 0xf7, 0x3a, 0xbd, 0x59, 0x01, 0xfa, 0x18,
1340     0x8e, 0xe9, 0x1a, 0xa9, 0x78, 0xfc, 0x79, 0x0b
1341 };
1342 static const unsigned char hmac_sha256_pr_entropyinputpr[] =
1343 {
1344     0xcf, 0x24, 0xb9, 0xeb, 0xb3, 0xd4, 0xcd, 0x17, 0x37, 0x38, 0x75, 0x79,
1345     0x15, 0xcb, 0x2d, 0x75, 0x51, 0xf1, 0xcc, 0xaa, 0x32, 0xa4, 0xa7, 0x36,
1346     0x7c, 0x5c, 0xe4, 0x47, 0xf1, 0x3e, 0x1d, 0xe5
1347 };
1348 static const unsigned char hmac_sha256_pr_int_returnedbits[] =
1349 {
1350     0x52, 0x42, 0xfa, 0xeb, 0x85, 0xe0, 0x30, 0x22, 0x79, 0x00, 0x16, 0xb2,
1351     0x88, 0x2f, 0x14, 0x6a, 0xb7, 0xfc, 0xb7, 0x53, 0xdc, 0x4a, 0x12, 0xef,
1352     0x54, 0xd6, 0x33, 0xe9, 0x20, 0xd6, 0xfd, 0x56
1353 };
1354 static const unsigned char hmac_sha256_pr_additionalinput2[] =
1355 {
1356     0xf4, 0xf6, 0x49, 0xa1, 0x2d, 0x64, 0x2b, 0x30, 0x58, 0xf8, 0xbd, 0xb8,
1357     0x75, 0xeb, 0xbb, 0x5e, 0x1c, 0x9b, 0x81, 0x6a, 0xda, 0x14, 0x86, 0x6e,
1358     0xd0, 0xda, 0x18, 0xb7, 0x88, 0xfb, 0x59, 0xf3
1359 };
1360 static const unsigned char hmac_sha256_pr_entropyinputpr2[] =
1361 {
1362     0x21, 0xcd, 0x6e, 0x46, 0xad, 0x99, 0x07, 0x17, 0xb4, 0x3d, 0x76, 0x0a,
1363     0xff, 0x5b, 0x52, 0x50, 0x78, 0xdf, 0x1f, 0x24, 0x06, 0x0d, 0x3f, 0x74,
1364     0xa9, 0xc9, 0x37, 0xcf, 0xd8, 0x26, 0x25, 0x91
1365 };
1366 static const unsigned char hmac_sha256_pr_returnedbits[] =
1367 {
1368     0xa7, 0xaf, 0x2f, 0x29, 0xe0, 0x3a, 0x72, 0x95, 0x96, 0x1c, 0xa9, 0xf0,
1369     0x4a, 0x17, 0x4d, 0x66, 0x06, 0x10, 0xbf, 0x39, 0x89, 0x88, 0xb8, 0x91,
1370     0x37, 0x18, 0x99, 0xcf, 0x8c, 0x53, 0x3b, 0x7e
1371 };
1372
1373
1374 /* HMAC SHA-256 No PR  */
1375 static const unsigned char hmac_sha256_entropyinput[] =
1376 {
1377     0x96, 0xb7, 0x53, 0x22, 0x1e, 0x52, 0x2a, 0x96, 0xb1, 0x15, 0x3c, 0x35,
1378     0x5a, 0x8b, 0xd3, 0x4a, 0xa6, 0x6c, 0x83, 0x0a, 0x7d, 0xa3, 0x23, 0x3d,
1379     0x43, 0xa1, 0x07, 0x2c, 0x2d, 0xe3, 0x81, 0xcc
1380 };
1381 static const unsigned char hmac_sha256_nonce[] =
1382 {
1383     0xf1, 0xac, 0x97, 0xcb, 0x5e, 0x06, 0x48, 0xd2, 0x94, 0xbe, 0x15, 0x2e,
1384     0xc7, 0xfc, 0xc2, 0x01
1385 };
1386 static const unsigned char hmac_sha256_personalizationstring[] =
1387 {
1388     0x98, 0xc5, 0x1e, 0x35, 0x5e, 0x89, 0x0d, 0xce, 0x64, 0x6d, 0x18, 0xa7,
1389     0x5a, 0xc6, 0xf3, 0xe7, 0xd6, 0x9e, 0xc0, 0xea, 0xb7, 0x3a, 0x8d, 0x65,
1390     0xb8, 0xeb, 0x10, 0xd7, 0x57, 0x18, 0xa0, 0x32
1391 };
1392 static const unsigned char hmac_sha256_additionalinput[] =
1393 {
1394     0x1b, 0x10, 0xaf, 0xac, 0xd0, 0x65, 0x95, 0xad, 0x04, 0xad, 0x03, 0x1c,
1395     0xe0, 0x40, 0xd6, 0x3e, 0x1c, 0x46, 0x53, 0x39, 0x7c, 0xe2, 0xbc, 0xda,
1396     0x8c, 0xa2, 0x33, 0xa7, 0x9a, 0x26, 0xd3, 0x27
1397 };
1398 static const unsigned char hmac_sha256_int_returnedbits[] =
1399 {
1400     0xba, 0x61, 0x0e, 0x55, 0xfe, 0x11, 0x8a, 0x9e, 0x0f, 0x80, 0xdf, 0x1d,
1401     0x03, 0x0a, 0xfe, 0x15, 0x94, 0x28, 0x4b, 0xba, 0xf4, 0x9f, 0x51, 0x25,
1402     0x88, 0xe5, 0x4e, 0xfb, 0xaf, 0xce, 0x69, 0x90
1403 };
1404 static const unsigned char hmac_sha256_entropyinputreseed[] =
1405 {
1406     0x62, 0x7f, 0x1e, 0x6b, 0xe8, 0x8e, 0xe1, 0x35, 0x7d, 0x9b, 0x4f, 0xc7,
1407     0xec, 0xc8, 0xac, 0xef, 0x6b, 0x13, 0x9e, 0x05, 0x56, 0xc1, 0x08, 0xf9,
1408     0x2f, 0x0f, 0x27, 0x9c, 0xd4, 0x15, 0xed, 0x2d
1409 };
1410 static const unsigned char hmac_sha256_additionalinputreseed[] =
1411 {
1412     0xc7, 0x76, 0x6e, 0xa9, 0xd2, 0xb2, 0x76, 0x40, 0x82, 0x25, 0x2c, 0xb3,
1413     0x6f, 0xac, 0xe9, 0x74, 0xef, 0x8f, 0x3c, 0x8e, 0xcd, 0xf1, 0xbf, 0xb3,
1414     0x49, 0x77, 0x34, 0x88, 0x52, 0x36, 0xe6, 0x2e
1415 };
1416 static const unsigned char hmac_sha256_additionalinput2[] =
1417 {
1418     0x8d, 0xb8, 0x0c, 0xd1, 0xbf, 0x70, 0xf6, 0x19, 0xc3, 0x41, 0x80, 0x9f,
1419     0xe1, 0xa5, 0xa4, 0x1f, 0x2c, 0x26, 0xb1, 0xe5, 0xd8, 0xeb, 0xbe, 0xf8,
1420     0xdf, 0x88, 0x6a, 0x89, 0xd6, 0x05, 0xd8, 0x9d
1421 };
1422 static const unsigned char hmac_sha256_returnedbits[] =
1423 {
1424     0x43, 0x12, 0x2a, 0x2c, 0x40, 0x53, 0x2e, 0x7c, 0x66, 0x34, 0xac, 0xc3,
1425     0x43, 0xe3, 0xe0, 0x6a, 0xfc, 0xfa, 0xea, 0x87, 0x21, 0x1f, 0xe2, 0x26,
1426     0xc4, 0xf9, 0x09, 0x9a, 0x0d, 0x6e, 0x7f, 0xe0
1427 };
1428
1429
1430 /* HMAC SHA-384 PR  */
1431 static const unsigned char hmac_sha384_pr_entropyinput[] =
1432 {
1433     0x69, 0x81, 0x98, 0x88, 0x44, 0xf5, 0xd6, 0x2e, 0x00, 0x08, 0x3b, 0xc5,
1434     0xfb, 0xd7, 0x8e, 0x6f, 0x23, 0xf8, 0x6d, 0x09, 0xd6, 0x85, 0x49, 0xd1,
1435     0xf8, 0x6d, 0xa4, 0x58, 0x54, 0xfd, 0x88, 0xa9
1436 };
1437 static const unsigned char hmac_sha384_pr_nonce[] =
1438 {
1439     0x6e, 0x38, 0x81, 0xca, 0xb7, 0xe8, 0x6e, 0x66, 0x49, 0x8a, 0xb2, 0x59,
1440     0xee, 0x16, 0xc9, 0xde
1441 };
1442 static const unsigned char hmac_sha384_pr_personalizationstring[] =
1443 {
1444     0xfe, 0x4c, 0xd9, 0xf4, 0x78, 0x3b, 0x08, 0x41, 0x8d, 0x8f, 0x55, 0xc4,
1445     0x43, 0x56, 0xb6, 0x12, 0x36, 0x6b, 0x30, 0xb7, 0x5e, 0xe1, 0xb9, 0x47,
1446     0x04, 0xb1, 0x4e, 0xa9, 0x00, 0xa1, 0x52, 0xa1
1447 };
1448 static const unsigned char hmac_sha384_pr_additionalinput[] =
1449 {
1450     0x89, 0xe9, 0xcc, 0x8f, 0x27, 0x3c, 0x26, 0xd1, 0x95, 0xc8, 0x7d, 0x0f,
1451     0x5b, 0x1a, 0xf0, 0x78, 0x39, 0x56, 0x6f, 0xa4, 0x23, 0xe7, 0xd1, 0xda,
1452     0x7c, 0x66, 0x33, 0xa0, 0x90, 0xc9, 0x92, 0x88
1453 };
1454 static const unsigned char hmac_sha384_pr_entropyinputpr[] =
1455 {
1456     0xbe, 0x3d, 0x7c, 0x0d, 0xca, 0xda, 0x7c, 0x49, 0xb8, 0x12, 0x36, 0xc0,
1457     0xdb, 0xad, 0x35, 0xa8, 0xc7, 0x0b, 0x2a, 0x2c, 0x69, 0x6d, 0x25, 0x56,
1458     0x63, 0x82, 0x11, 0x3e, 0xa7, 0x33, 0x70, 0x72
1459 };
1460 static const unsigned char hmac_sha384_pr_int_returnedbits[] =
1461 {
1462     0x82, 0x3d, 0xe6, 0x54, 0x80, 0x42, 0xf8, 0xba, 0x90, 0x4f, 0x06, 0xa6,
1463     0xd2, 0x7f, 0xbf, 0x79, 0x7c, 0x12, 0x7d, 0xa6, 0xa2, 0x66, 0xe8, 0xa6,
1464     0xc0, 0xd6, 0x4a, 0x55, 0xbf, 0xd8, 0x0a, 0xc5, 0xf8, 0x03, 0x88, 0xdd,
1465     0x8e, 0x87, 0xd1, 0x5a, 0x48, 0x26, 0x72, 0x2a, 0x8e, 0xcf, 0xee, 0xba
1466 };
1467 static const unsigned char hmac_sha384_pr_additionalinput2[] =
1468 {
1469     0x8f, 0xff, 0xd9, 0x84, 0xbb, 0x85, 0x3a, 0x66, 0xa1, 0x21, 0xce, 0xb2,
1470     0x3a, 0x3a, 0x17, 0x22, 0x19, 0xae, 0xc7, 0xb6, 0x63, 0x81, 0xd5, 0xff,
1471     0x0d, 0xc8, 0xe1, 0xaf, 0x57, 0xd2, 0xcb, 0x60
1472 };
1473 static const unsigned char hmac_sha384_pr_entropyinputpr2[] =
1474 {
1475     0xd7, 0xfb, 0xc9, 0xe8, 0xe2, 0xf2, 0xaa, 0x4c, 0xb8, 0x51, 0x2f, 0xe1,
1476     0x22, 0xba, 0xf3, 0xda, 0x0a, 0x19, 0x76, 0x71, 0x57, 0xb2, 0x1d, 0x94,
1477     0x09, 0x69, 0x6c, 0xd3, 0x97, 0x51, 0x81, 0x87
1478 };
1479
1480
1481 static const unsigned char hmac_sha384_pr_returnedbits[] =
1482 {
1483     0xe6, 0x19, 0x28, 0xa8, 0x21, 0xce, 0x5e, 0xdb, 0x24, 0x79, 0x8c, 0x76,
1484     0x5d, 0x73, 0xb2, 0xdf, 0xac, 0xef, 0x85, 0xa7, 0x3b, 0x19, 0x09, 0x8b,
1485     0x7f, 0x98, 0x28, 0xa9, 0x93, 0xd8, 0x7a, 0xad, 0x55, 0x8b, 0x24, 0x9d,
1486     0xe6, 0x98, 0xfe, 0x47, 0xd5, 0x48, 0xc1, 0x23, 0xd8, 0x1d, 0x62, 0x75
1487 };
1488
1489
1490 /* HMAC SHA-384 No PR  */
1491 static const unsigned char hmac_sha384_entropyinput[] =
1492 {
1493     0xc3, 0x56, 0x2b, 0x1d, 0xc2, 0xbb, 0xa8, 0xf0, 0xae, 0x1b, 0x0d, 0xd3,
1494     0x5a, 0x6c, 0xda, 0x57, 0x8e, 0xa5, 0x8a, 0x0d, 0x6c, 0x4b, 0x18, 0xb1,
1495     0x04, 0x3e, 0xb4, 0x99, 0x35, 0xc4, 0xc0, 0x5f
1496 };
1497 static const unsigned char hmac_sha384_nonce[] =
1498 {
1499     0xc5, 0x49, 0x1e, 0x66, 0x27, 0x92, 0xbe, 0xec, 0xb5, 0x1e, 0x4b, 0xb1,
1500     0x38, 0xe3, 0xeb, 0x62
1501 };
1502 static const unsigned char hmac_sha384_personalizationstring[] =
1503 {
1504     0xbe, 0xe7, 0x6b, 0x57, 0xde, 0x88, 0x11, 0x96, 0x9b, 0x6e, 0xea, 0xe5,
1505     0x63, 0x83, 0x4c, 0xb6, 0x8d, 0x66, 0xaa, 0x1f, 0x8b, 0x54, 0xe7, 0x62,
1506     0x6d, 0x5a, 0xfc, 0xbf, 0x97, 0xba, 0xcd, 0x77
1507 };
1508 static const unsigned char hmac_sha384_additionalinput[] =
1509 {
1510     0xe5, 0x28, 0x5f, 0x43, 0xf5, 0x83, 0x6e, 0x0a, 0x83, 0x5c, 0xe3, 0x81,
1511     0x03, 0xf2, 0xf8, 0x78, 0x00, 0x7c, 0x95, 0x87, 0x16, 0xd6, 0x6c, 0x58,
1512     0x33, 0x6c, 0x53, 0x35, 0x0d, 0x66, 0xe3, 0xce
1513 };
1514 static const unsigned char hmac_sha384_int_returnedbits[] =
1515 {
1516     0xe2, 0x1f, 0xf3, 0xda, 0x0d, 0x19, 0x99, 0x87, 0xc4, 0x90, 0xa2, 0x31,
1517     0xca, 0x2a, 0x89, 0x58, 0x43, 0x44, 0xb8, 0xde, 0xcf, 0xa4, 0xbe, 0x3b,
1518     0x53, 0x26, 0x22, 0x31, 0x76, 0x41, 0x22, 0xb5, 0xa8, 0x70, 0x2f, 0x4b,
1519     0x64, 0x95, 0x4d, 0x48, 0x96, 0x35, 0xe6, 0xbd, 0x3c, 0x34, 0xdb, 0x1b
1520 };
1521 static const unsigned char hmac_sha384_entropyinputreseed[] =
1522 {
1523     0x77, 0x61, 0xba, 0xbc, 0xf2, 0xc1, 0xf3, 0x4b, 0x86, 0x65, 0xfd, 0x48,
1524     0x0e, 0x3c, 0x02, 0x5e, 0xa2, 0x7a, 0x6b, 0x7c, 0xed, 0x21, 0x5e, 0xf9,
1525     0xcd, 0xcd, 0x77, 0x07, 0x2b, 0xbe, 0xc5, 0x5c
1526 };
1527 static const unsigned char hmac_sha384_additionalinputreseed[] =
1528 {
1529     0x18, 0x24, 0x5f, 0xc6, 0x84, 0xd1, 0x67, 0xc3, 0x9a, 0x11, 0xa5, 0x8c,
1530     0x07, 0x39, 0x21, 0x83, 0x4d, 0x04, 0xc4, 0x6a, 0x28, 0x19, 0xcf, 0x92,
1531     0x21, 0xd9, 0x9e, 0x41, 0x72, 0x6c, 0x9e, 0x63
1532 };
1533 static const unsigned char hmac_sha384_additionalinput2[] =
1534 {
1535     0x96, 0x67, 0x41, 0x28, 0x9b, 0xb7, 0x92, 0x8d, 0x64, 0x3b, 0xe4, 0xcf,
1536     0x7e, 0xaa, 0x1e, 0xb1, 0x4b, 0x1d, 0x09, 0x56, 0x67, 0x9c, 0xc6, 0x6d,
1537     0x3b, 0xe8, 0x91, 0x9d, 0xe1, 0x8a, 0xb7, 0x32
1538 };
1539 static const unsigned char hmac_sha384_returnedbits[] =
1540 {
1541     0xe3, 0x59, 0x61, 0x38, 0x92, 0xec, 0xe2, 0x3c, 0xff, 0xb7, 0xdb, 0x19,
1542     0x0f, 0x5b, 0x93, 0x68, 0x0d, 0xa4, 0x94, 0x40, 0x72, 0x0b, 0xe0, 0xed,
1543     0x4d, 0xcd, 0x68, 0xa0, 0x1e, 0xfe, 0x67, 0xb2, 0xfa, 0x21, 0x56, 0x74,
1544     0xa4, 0xad, 0xcf, 0xb7, 0x60, 0x66, 0x2e, 0x40, 0xde, 0x82, 0xca, 0xfb
1545 };
1546
1547
1548 /* HMAC SHA-512 PR  */
1549 static const unsigned char hmac_sha512_pr_entropyinput[] =
1550 {
1551     0xaa, 0x9e, 0x45, 0x67, 0x0e, 0x00, 0x2a, 0x67, 0x98, 0xd6, 0xda, 0x0b,
1552     0x0f, 0x17, 0x7e, 0xac, 0xfd, 0x27, 0xc4, 0xca, 0x84, 0xdf, 0xde, 0xba,
1553     0x85, 0xd9, 0xbe, 0x8f, 0xf3, 0xff, 0x91, 0x4d
1554 };
1555 static const unsigned char hmac_sha512_pr_nonce[] =
1556 {
1557     0x8c, 0x49, 0x2f, 0x58, 0x1e, 0x7a, 0xda, 0x4b, 0x7e, 0x8a, 0x30, 0x7b,
1558     0x86, 0xea, 0xaf, 0xa2
1559 };
1560 static const unsigned char hmac_sha512_pr_personalizationstring[] =
1561 {
1562     0x71, 0xe1, 0xbb, 0xad, 0xa7, 0x4b, 0x2e, 0x31, 0x3b, 0x0b, 0xec, 0x24,
1563     0x99, 0x38, 0xbc, 0xaa, 0x05, 0x4c, 0x46, 0x44, 0xfa, 0xad, 0x8e, 0x02,
1564     0xc1, 0x7e, 0xad, 0xec, 0x54, 0xa6, 0xd0, 0xad
1565 };
1566 static const unsigned char hmac_sha512_pr_additionalinput[] =
1567 {
1568     0x3d, 0x6e, 0xa6, 0xa8, 0x29, 0x2a, 0xb2, 0xf5, 0x98, 0x42, 0xe4, 0x92,
1569     0x78, 0x22, 0x67, 0xfd, 0x1b, 0x15, 0x1e, 0x29, 0xaa, 0x71, 0x3c, 0x3c,
1570     0xe7, 0x05, 0x20, 0xa9, 0x29, 0xc6, 0x75, 0x71
1571 };
1572 static const unsigned char hmac_sha512_pr_entropyinputpr[] =
1573 {
1574     0xab, 0xb9, 0x16, 0xd8, 0x55, 0x35, 0x54, 0xb7, 0x97, 0x3f, 0x94, 0xbc,
1575     0x2f, 0x7c, 0x70, 0xc7, 0xd0, 0xed, 0xb7, 0x4b, 0xf7, 0xf6, 0x6c, 0x03,
1576     0x0c, 0xb0, 0x03, 0xd8, 0xbb, 0x71, 0xd9, 0x10
1577 };
1578 static const unsigned char hmac_sha512_pr_int_returnedbits[] =
1579 {
1580     0x8e, 0xd3, 0xfd, 0x52, 0x9e, 0x83, 0x08, 0x49, 0x18, 0x6e, 0x23, 0x56,
1581     0x5c, 0x45, 0x93, 0x34, 0x05, 0xe2, 0x98, 0x8f, 0x0c, 0xd4, 0x32, 0x0c,
1582     0xfd, 0xda, 0x5f, 0x92, 0x3a, 0x8c, 0x81, 0xbd, 0xf6, 0x6c, 0x55, 0xfd,
1583     0xb8, 0x20, 0xce, 0x8d, 0x97, 0x27, 0xe8, 0xe8, 0xe0, 0xb3, 0x85, 0x50,
1584     0xa2, 0xc2, 0xb2, 0x95, 0x1d, 0x48, 0xd3, 0x7b, 0x4b, 0x78, 0x13, 0x35,
1585     0x05, 0x17, 0xbe, 0x0d
1586 };
1587 static const unsigned char hmac_sha512_pr_additionalinput2[] =
1588 {
1589     0xc3, 0xfc, 0x95, 0xaa, 0x69, 0x06, 0xae, 0x59, 0x41, 0xce, 0x26, 0x08,
1590     0x29, 0x6d, 0x45, 0xda, 0xe8, 0xb3, 0x6c, 0x95, 0x60, 0x0f, 0x70, 0x2c,
1591     0x10, 0xba, 0x38, 0x8c, 0xcf, 0x29, 0x99, 0xaa
1592 };
1593 static const unsigned char hmac_sha512_pr_entropyinputpr2[] =
1594 {
1595     0x3b, 0x9a, 0x25, 0xce, 0xd7, 0xf9, 0x5c, 0xd1, 0x3a, 0x3e, 0xaa, 0x71,
1596     0x14, 0x3e, 0x19, 0xe8, 0xce, 0xe6, 0xfe, 0x51, 0x84, 0xe9, 0x1b, 0xfe,
1597     0x3f, 0xa7, 0xf2, 0xfd, 0x76, 0x5f, 0x6a, 0xe7
1598 };
1599 static const unsigned char hmac_sha512_pr_returnedbits[] =
1600 {
1601     0xb7, 0x82, 0xa9, 0x57, 0x81, 0x67, 0x53, 0xb5, 0xa1, 0xe9, 0x3d, 0x35,
1602     0xf9, 0xe4, 0x97, 0xbe, 0xa6, 0xca, 0xf1, 0x01, 0x13, 0x09, 0xe7, 0x21,
1603     0xc0, 0xed, 0x93, 0x5d, 0x4b, 0xf4, 0xeb, 0x8d, 0x53, 0x25, 0x8a, 0xc4,
1604     0xb1, 0x6f, 0x6e, 0x37, 0xcd, 0x2e, 0xac, 0x39, 0xb2, 0xb6, 0x99, 0xa3,
1605     0x82, 0x00, 0xb0, 0x21, 0xf0, 0xc7, 0x2f, 0x4c, 0x73, 0x92, 0xfd, 0x00,
1606     0xb6, 0xaf, 0xbc, 0xd3
1607 };
1608
1609
1610 /* HMAC SHA-512 No PR  */
1611 static const unsigned char hmac_sha512_entropyinput[] =
1612 {
1613     0x6e, 0x85, 0xe6, 0x25, 0x96, 0x29, 0xa7, 0x52, 0x5b, 0x60, 0xba, 0xaa,
1614     0xde, 0xdb, 0x36, 0x0a, 0x51, 0x9a, 0x15, 0xae, 0x6e, 0x18, 0xd3, 0xfe,
1615     0x39, 0xb9, 0x4a, 0x96, 0xf8, 0x77, 0xcb, 0x95
1616 };
1617 static const unsigned char hmac_sha512_nonce[] =
1618 {
1619     0xe0, 0xa6, 0x5d, 0x08, 0xc3, 0x7c, 0xae, 0x25, 0x2e, 0x80, 0xd1, 0x3e,
1620     0xd9, 0xaf, 0x43, 0x3c
1621 };
1622 static const unsigned char hmac_sha512_personalizationstring[] =
1623 {
1624     0x53, 0x99, 0x52, 0x5f, 0x11, 0xa9, 0x64, 0x66, 0x20, 0x5e, 0x1b, 0x5f,
1625     0x42, 0xb3, 0xf4, 0xda, 0xed, 0xbb, 0x63, 0xc1, 0x23, 0xaf, 0xd0, 0x01,
1626     0x90, 0x3b, 0xd0, 0x78, 0xe4, 0x0b, 0xa7, 0x20
1627 };
1628 static const unsigned char hmac_sha512_additionalinput[] =
1629 {
1630     0x85, 0x90, 0x80, 0xd3, 0x98, 0xf1, 0x53, 0x6d, 0x68, 0x15, 0x8f, 0xe5,
1631     0x60, 0x3f, 0x17, 0x29, 0x55, 0x8d, 0x33, 0xb1, 0x45, 0x64, 0x64, 0x8d,
1632     0x50, 0x21, 0x89, 0xae, 0xf6, 0xfd, 0x32, 0x73
1633 };
1634 static const unsigned char hmac_sha512_int_returnedbits[] =
1635 {
1636     0x28, 0x56, 0x30, 0x6f, 0xf4, 0xa1, 0x48, 0xe0, 0xc9, 0xf5, 0x75, 0x90,
1637     0xcc, 0xfb, 0xdf, 0xdf, 0x71, 0x3d, 0x0a, 0x9a, 0x03, 0x65, 0x3b, 0x18,
1638     0x61, 0xe3, 0xd1, 0xda, 0xcc, 0x4a, 0xfe, 0x55, 0x38, 0xf8, 0x21, 0x6b,
1639     0xfa, 0x18, 0x01, 0x42, 0x39, 0x2f, 0x99, 0x53, 0x38, 0x15, 0x82, 0x34,
1640     0xc5, 0x93, 0x92, 0xbc, 0x4d, 0x75, 0x1a, 0x5f, 0x21, 0x27, 0xcc, 0xa1,
1641     0xb1, 0x57, 0x69, 0xe8
1642 };
1643 static const unsigned char hmac_sha512_entropyinputreseed[] =
1644 {
1645     0x8c, 0x52, 0x7e, 0x77, 0x72, 0x3f, 0xa3, 0x04, 0x97, 0x10, 0x9b, 0x41,
1646     0xbd, 0xe8, 0xff, 0x89, 0xed, 0x80, 0xe3, 0xbd, 0xaa, 0x12, 0x2d, 0xca,
1647     0x75, 0x82, 0x36, 0x77, 0x88, 0xcd, 0xa6, 0x73
1648 };
1649 static const unsigned char hmac_sha512_additionalinputreseed[] =
1650 {
1651     0x7e, 0x32, 0xe3, 0x69, 0x69, 0x07, 0x34, 0xa2, 0x16, 0xa2, 0x5d, 0x1a,
1652     0x10, 0x91, 0xd3, 0xe2, 0x21, 0xa2, 0xa3, 0xdd, 0xcd, 0x0c, 0x09, 0x86,
1653     0x11, 0xe1, 0x50, 0xff, 0x5c, 0xb7, 0xeb, 0x5c
1654 };
1655 static const unsigned char hmac_sha512_additionalinput2[] =
1656 {
1657     0x7f, 0x78, 0x66, 0xd8, 0xfb, 0x67, 0xcf, 0x8d, 0x8c, 0x08, 0x30, 0xa5,
1658     0xf8, 0x7d, 0xcf, 0x44, 0x59, 0xce, 0xf8, 0xdf, 0x58, 0xd3, 0x60, 0xcb,
1659     0xa8, 0x60, 0xb9, 0x07, 0xc4, 0xb1, 0x95, 0x48
1660 };
1661 static const unsigned char hmac_sha512_returnedbits[] =
1662 {
1663     0xdf, 0xa7, 0x36, 0xd4, 0xdc, 0x5d, 0x4d, 0x31, 0xad, 0x69, 0x46, 0x9f,
1664     0xf1, 0x7c, 0xd7, 0x3b, 0x4f, 0x55, 0xf2, 0xd7, 0xb9, 0x9d, 0xad, 0x7a,
1665     0x79, 0x08, 0x59, 0xa5, 0xdc, 0x74, 0xf5, 0x9b, 0x73, 0xd2, 0x13, 0x25,
1666     0x0b, 0x81, 0x08, 0x08, 0x25, 0xfb, 0x39, 0xf2, 0xf0, 0xa3, 0xa4, 0x8d,
1667     0xef, 0x05, 0x9e, 0xb8, 0xc7, 0x52, 0xe4, 0x0e, 0x42, 0xaa, 0x7c, 0x79,
1668     0xc2, 0xd6, 0xfd, 0xa5
1669 };
1670