CryptoPkg/Library/BaseCryptLib/Kdf/CryptHkdf.c

   1 /** @file
   2   HMAC-SHA256 KDF Wrapper Implementation over OpenSSL.
   3
   4 Copyright (c) 2018 - 2022, Intel Corporation. All rights reserved.<BR>
   5 SPDX-License-Identifier: BSD-2-Clause-Patent
   6
   7 **/
   8
   9 #include "InternalCryptLib.h"
  10 #include <openssl/evp.h>
  11 #include <openssl/kdf.h>
  12
  13 /**
  14   Derive HMAC-based Extract-and-Expand Key Derivation Function (HKDF).
  15
  16   @param[in]   Md               Message Digest.
  17   @param[in]   Key              Pointer to the user-supplied key.
  18   @param[in]   KeySize          Key size in bytes.
  19   @param[in]   Salt             Pointer to the salt(non-secret) value.
  20   @param[in]   SaltSize         Salt size in bytes.
  21   @param[in]   Info             Pointer to the application specific info.
  22   @param[in]   InfoSize         Info size in bytes.
  23   @param[out]  Out              Pointer to buffer to receive hkdf value.
  24   @param[in]   OutSize          Size of hkdf bytes to generate.
  25
  26   @retval TRUE   Hkdf generated successfully.
  27   @retval FALSE  Hkdf generation failed.
  28
  29 **/
  30 STATIC
  31 BOOLEAN
  32 HkdfMdExtractAndExpand (
  33   IN   CONST EVP_MD  *Md,
  34   IN   CONST UINT8   *Key,
  35   IN   UINTN         KeySize,
  36   IN   CONST UINT8   *Salt,
  37   IN   UINTN         SaltSize,
  38   IN   CONST UINT8   *Info,
  39   IN   UINTN         InfoSize,
  40   OUT  UINT8         *Out,
  41   IN   UINTN         OutSize
  42   )
  43 {
  44   EVP_PKEY_CTX  *pHkdfCtx;
  45   BOOLEAN       Result;
  46
  47   if ((Key == NULL) || (Salt == NULL) || (Info == NULL) || (Out == NULL) ||
  48       (KeySize > INT_MAX) || (SaltSize > INT_MAX) || (InfoSize > INT_MAX) || (OutSize > INT_MAX))
  49   {
  50     return FALSE;
  51   }
  52
  53   pHkdfCtx = EVP_PKEY_CTX_new_id (EVP_PKEY_HKDF, NULL);
  54   if (pHkdfCtx == NULL) {
  55     return FALSE;
  56   }
  57
  58   Result = EVP_PKEY_derive_init (pHkdfCtx) > 0;
  59   if (Result) {
  60     Result = EVP_PKEY_CTX_set_hkdf_md (pHkdfCtx, Md) > 0;
  61   }
  62
  63   if (Result) {
  64     Result = EVP_PKEY_CTX_set1_hkdf_salt (pHkdfCtx, Salt, (UINT32)SaltSize) > 0;
  65   }
  66
  67   if (Result) {
  68     Result = EVP_PKEY_CTX_set1_hkdf_key (pHkdfCtx, Key, (UINT32)KeySize) > 0;
  69   }
  70
  71   if (Result) {
  72     Result = EVP_PKEY_CTX_add1_hkdf_info (pHkdfCtx, Info, (UINT32)InfoSize) > 0;
  73   }
  74
  75   if (Result) {
  76     Result = EVP_PKEY_derive (pHkdfCtx, Out, &OutSize) > 0;
  77   }
  78
  79   EVP_PKEY_CTX_free (pHkdfCtx);
  80   pHkdfCtx = NULL;
  81   return Result;
  82 }
  83
  84 /**
  85   Derive HMAC-based Extract key Derivation Function (HKDF).
  86
  87   @param[in]   Md               message digest.
  88   @param[in]   Key              Pointer to the user-supplied key.
  89   @param[in]   KeySize          key size in bytes.
  90   @param[in]   Salt             Pointer to the salt(non-secret) value.
  91   @param[in]   SaltSize         salt size in bytes.
  92   @param[out]  PrkOut           Pointer to buffer to receive hkdf value.
  93   @param[in]   PrkOutSize       size of hkdf bytes to generate.
  94
  95   @retval true   Hkdf generated successfully.
  96   @retval false  Hkdf generation failed.
  97
  98 **/
  99 STATIC
 100 BOOLEAN
 101 HkdfMdExtract (
 102   IN CONST EVP_MD  *Md,
 103   IN CONST UINT8   *Key,
 104   IN  UINTN        KeySize,
 105   IN CONST UINT8   *Salt,
 106   IN UINTN         SaltSize,
 107   OUT UINT8        *PrkOut,
 108   UINTN            PrkOutSize
 109   )
 110 {
 111   EVP_PKEY_CTX  *pHkdfCtx;
 112   BOOLEAN       Result;
 113
 114   if ((Key == NULL) || (Salt == NULL) || (PrkOut == NULL) ||
 115       (KeySize > INT_MAX) || (SaltSize > INT_MAX) ||
 116       (PrkOutSize > INT_MAX))
 117   {
 118     return FALSE;
 119   }
 120
 121   pHkdfCtx = EVP_PKEY_CTX_new_id (EVP_PKEY_HKDF, NULL);
 122   if (pHkdfCtx == NULL) {
 123     return FALSE;
 124   }
 125
 126   Result = EVP_PKEY_derive_init (pHkdfCtx) > 0;
 127   if (Result) {
 128     Result = EVP_PKEY_CTX_set_hkdf_md (pHkdfCtx, Md) > 0;
 129   }
 130
 131   if (Result) {
 132     Result =
 133       EVP_PKEY_CTX_hkdf_mode (
 134         pHkdfCtx,
 135         EVP_PKEY_HKDEF_MODE_EXTRACT_ONLY
 136         ) > 0;
 137   }
 138
 139   if (Result) {
 140     Result = EVP_PKEY_CTX_set1_hkdf_salt (
 141                pHkdfCtx,
 142                Salt,
 143                (uint32_t)SaltSize
 144                ) > 0;
 145   }
 146
 147   if (Result) {
 148     Result = EVP_PKEY_CTX_set1_hkdf_key (
 149                pHkdfCtx,
 150                Key,
 151                (uint32_t)KeySize
 152                ) > 0;
 153   }
 154
 155   if (Result) {
 156     Result = EVP_PKEY_derive (pHkdfCtx, PrkOut, &PrkOutSize) > 0;
 157   }
 158
 159   EVP_PKEY_CTX_free (pHkdfCtx);
 160   pHkdfCtx = NULL;
 161   return Result;
 162 }
 163
 164 /**
 165   Derive SHA256 HMAC-based Expand Key Derivation Function (HKDF).
 166
 167   @param[in]   Md               Message Digest.
 168   @param[in]   Prk              Pointer to the user-supplied key.
 169   @param[in]   PrkSize          Key size in bytes.
 170   @param[in]   Info             Pointer to the application specific info.
 171   @param[in]   InfoSize         Info size in bytes.
 172   @param[out]  Out              Pointer to buffer to receive hkdf value.
 173   @param[in]   OutSize          Size of hkdf bytes to generate.
 174
 175   @retval TRUE   Hkdf generated successfully.
 176   @retval FALSE  Hkdf generation failed.
 177
 178 **/
 179 STATIC
 180 BOOLEAN
 181 HkdfMdExpand (
 182   IN   CONST EVP_MD  *Md,
 183   IN   CONST UINT8   *Prk,
 184   IN   UINTN         PrkSize,
 185   IN   CONST UINT8   *Info,
 186   IN   UINTN         InfoSize,
 187   OUT  UINT8         *Out,
 188   IN   UINTN         OutSize
 189   )
 190 {
 191   EVP_PKEY_CTX  *pHkdfCtx;
 192   BOOLEAN       Result;
 193
 194   if ((Prk == NULL) || (Info == NULL) || (Out == NULL) ||
 195       (PrkSize > INT_MAX) || (InfoSize > INT_MAX) || (OutSize > INT_MAX))
 196   {
 197     return FALSE;
 198   }
 199
 200   pHkdfCtx = EVP_PKEY_CTX_new_id (EVP_PKEY_HKDF, NULL);
 201   if (pHkdfCtx == NULL) {
 202     return FALSE;
 203   }
 204
 205   Result = EVP_PKEY_derive_init (pHkdfCtx) > 0;
 206   if (Result) {
 207     Result = EVP_PKEY_CTX_set_hkdf_md (pHkdfCtx, Md) > 0;
 208   }
 209
 210   if (Result) {
 211     Result = EVP_PKEY_CTX_hkdf_mode (pHkdfCtx, EVP_PKEY_HKDEF_MODE_EXPAND_ONLY) > 0;
 212   }
 213
 214   if (Result) {
 215     Result = EVP_PKEY_CTX_set1_hkdf_key (pHkdfCtx, Prk, (UINT32)PrkSize) > 0;
 216   }
 217
 218   if (Result) {
 219     Result = EVP_PKEY_CTX_add1_hkdf_info (pHkdfCtx, Info, (UINT32)InfoSize) > 0;
 220   }
 221
 222   if (Result) {
 223     Result = EVP_PKEY_derive (pHkdfCtx, Out, &OutSize) > 0;
 224   }
 225
 226   EVP_PKEY_CTX_free (pHkdfCtx);
 227   pHkdfCtx = NULL;
 228   return Result;
 229 }
 230
 231 /**
 232   Derive HMAC-based Extract-and-Expand Key Derivation Function (HKDF).
 233
 234   @param[in]   Key              Pointer to the user-supplied key.
 235   @param[in]   KeySize          Key size in bytes.
 236   @param[in]   Salt             Pointer to the salt(non-secret) value.
 237   @param[in]   SaltSize         Salt size in bytes.
 238   @param[in]   Info             Pointer to the application specific info.
 239   @param[in]   InfoSize         Info size in bytes.
 240   @param[out]  Out              Pointer to buffer to receive hkdf value.
 241   @param[in]   OutSize          Size of hkdf bytes to generate.
 242
 243   @retval TRUE   Hkdf generated successfully.
 244   @retval FALSE  Hkdf generation failed.
 245
 246 **/
 247 BOOLEAN
 248 EFIAPI
 249 HkdfSha256ExtractAndExpand (
 250   IN   CONST UINT8  *Key,
 251   IN   UINTN        KeySize,
 252   IN   CONST UINT8  *Salt,
 253   IN   UINTN        SaltSize,
 254   IN   CONST UINT8  *Info,
 255   IN   UINTN        InfoSize,
 256   OUT  UINT8        *Out,
 257   IN   UINTN        OutSize
 258   )
 259 {
 260   return HkdfMdExtractAndExpand (EVP_sha256 (), Key, KeySize, Salt, SaltSize, Info, InfoSize, Out, OutSize);
 261 }
 262
 263 /**
 264   Derive SHA256 HMAC-based Extract key Derivation Function (HKDF).
 265
 266   @param[in]   Key              Pointer to the user-supplied key.
 267   @param[in]   KeySize          key size in bytes.
 268   @param[in]   Salt             Pointer to the salt(non-secret) value.
 269   @param[in]   SaltSize         salt size in bytes.
 270   @param[out]  PrkOut           Pointer to buffer to receive hkdf value.
 271   @param[in]   PrkOutSize       size of hkdf bytes to generate.
 272
 273   @retval true   Hkdf generated successfully.
 274   @retval false  Hkdf generation failed.
 275
 276 **/
 277 BOOLEAN
 278 EFIAPI
 279 HkdfSha256Extract (
 280   IN CONST UINT8  *Key,
 281   IN UINTN        KeySize,
 282   IN CONST UINT8  *Salt,
 283   IN UINTN        SaltSize,
 284   OUT UINT8       *PrkOut,
 285   UINTN           PrkOutSize
 286   )
 287 {
 288   return HkdfMdExtract (
 289            EVP_sha256 (),
 290            Key,
 291            KeySize,
 292            Salt,
 293            SaltSize,
 294            PrkOut,
 295            PrkOutSize
 296            );
 297 }
 298
 299 /**
 300   Derive SHA256 HMAC-based Expand Key Derivation Function (HKDF).
 301
 302   @param[in]   Prk              Pointer to the user-supplied key.
 303   @param[in]   PrkSize          Key size in bytes.
 304   @param[in]   Info             Pointer to the application specific info.
 305   @param[in]   InfoSize         Info size in bytes.
 306   @param[out]  Out              Pointer to buffer to receive hkdf value.
 307   @param[in]   OutSize          Size of hkdf bytes to generate.
 308
 309   @retval TRUE   Hkdf generated successfully.
 310   @retval FALSE  Hkdf generation failed.
 311
 312 **/
 313 BOOLEAN
 314 EFIAPI
 315 HkdfSha256Expand (
 316   IN   CONST UINT8  *Prk,
 317   IN   UINTN        PrkSize,
 318   IN   CONST UINT8  *Info,
 319   IN   UINTN        InfoSize,
 320   OUT  UINT8        *Out,
 321   IN   UINTN        OutSize
 322   )
 323 {
 324   return HkdfMdExpand (EVP_sha256 (), Prk, PrkSize, Info, InfoSize, Out, OutSize);
 325 }
 326
 327 /**
 328   Derive SHA384 HMAC-based Extract-and-Expand Key Derivation Function (HKDF).
 329
 330   @param[in]   Key              Pointer to the user-supplied key.
 331   @param[in]   KeySize          Key size in bytes.
 332   @param[in]   Salt             Pointer to the salt(non-secret) value.
 333   @param[in]   SaltSize         Salt size in bytes.
 334   @param[in]   Info             Pointer to the application specific info.
 335   @param[in]   InfoSize         Info size in bytes.
 336   @param[out]  Out              Pointer to buffer to receive hkdf value.
 337   @param[in]   OutSize          Size of hkdf bytes to generate.
 338
 339   @retval TRUE   Hkdf generated successfully.
 340   @retval FALSE  Hkdf generation failed.
 341
 342 **/
 343 BOOLEAN
 344 EFIAPI
 345 HkdfSha384ExtractAndExpand (
 346   IN   CONST UINT8  *Key,
 347   IN   UINTN        KeySize,
 348   IN   CONST UINT8  *Salt,
 349   IN   UINTN        SaltSize,
 350   IN   CONST UINT8  *Info,
 351   IN   UINTN        InfoSize,
 352   OUT  UINT8        *Out,
 353   IN   UINTN        OutSize
 354   )
 355 {
 356   return HkdfMdExtractAndExpand (EVP_sha384 (), Key, KeySize, Salt, SaltSize, Info, InfoSize, Out, OutSize);
 357 }
 358
 359 /**
 360   Derive SHA384 HMAC-based Extract key Derivation Function (HKDF).
 361
 362   @param[in]   Key              Pointer to the user-supplied key.
 363   @param[in]   KeySize          key size in bytes.
 364   @param[in]   Salt             Pointer to the salt(non-secret) value.
 365   @param[in]   SaltSize         salt size in bytes.
 366   @param[out]  PrkOut           Pointer to buffer to receive hkdf value.
 367   @param[in]   PrkOutSize       size of hkdf bytes to generate.
 368
 369   @retval true   Hkdf generated successfully.
 370   @retval false  Hkdf generation failed.
 371
 372 **/
 373 BOOLEAN
 374 EFIAPI
 375 HkdfSha384Extract (
 376   IN CONST UINT8  *Key,
 377   IN UINTN        KeySize,
 378   IN CONST UINT8  *Salt,
 379   IN UINTN        SaltSize,
 380   OUT UINT8       *PrkOut,
 381   UINTN           PrkOutSize
 382   )
 383 {
 384   return HkdfMdExtract (
 385            EVP_sha384 (),
 386            Key,
 387            KeySize,
 388            Salt,
 389            SaltSize,
 390            PrkOut,
 391            PrkOutSize
 392            );
 393 }
 394
 395 /**
 396   Derive SHA384 HMAC-based Expand Key Derivation Function (HKDF).
 397
 398   @param[in]   Prk              Pointer to the user-supplied key.
 399   @param[in]   PrkSize          Key size in bytes.
 400   @param[in]   Info             Pointer to the application specific info.
 401   @param[in]   InfoSize         Info size in bytes.
 402   @param[out]  Out              Pointer to buffer to receive hkdf value.
 403   @param[in]   OutSize          Size of hkdf bytes to generate.
 404
 405   @retval TRUE   Hkdf generated successfully.
 406   @retval FALSE  Hkdf generation failed.
 407
 408 **/
 409 BOOLEAN
 410 EFIAPI
 411 HkdfSha384Expand (
 412   IN   CONST UINT8  *Prk,
 413   IN   UINTN        PrkSize,
 414   IN   CONST UINT8  *Info,
 415   IN   UINTN        InfoSize,
 416   OUT  UINT8        *Out,
 417   IN   UINTN        OutSize
 418   )
 419 {
 420   return HkdfMdExpand (EVP_sha384 (), Prk, PrkSize, Info, InfoSize, Out, OutSize);
 421 }