CryptoPkg/Library/BaseCryptLib/Pk/CryptDh.c

   1 /** @file
   2   Diffie-Hellman Wrapper Implementation over OpenSSL.
   3
   4 Copyright (c) 2010 - 2018, Intel Corporation. All rights reserved.<BR>
   5 SPDX-License-Identifier: BSD-2-Clause-Patent
   6
   7 **/
   8
   9 #include "InternalCryptLib.h"
  10 #include <openssl/bn.h>
  11 #include <openssl/dh.h>
  12
  13 /**
  14   Allocates and Initializes one Diffie-Hellman Context for subsequent use.
  15
  16   @return  Pointer to the Diffie-Hellman Context that has been initialized.
  17            If the allocations fails, DhNew() returns NULL.
  18
  19 **/
  20 VOID *
  21 EFIAPI
  22 DhNew (
  23   VOID
  24   )
  25 {
  26   //
  27   // Allocates & Initializes DH Context by OpenSSL DH_new()
  28   //
  29   return (VOID *) DH_new ();
  30 }
  31
  32 /**
  33   Release the specified DH context.
  34
  35   If DhContext is NULL, then return FALSE.
  36
  37   @param[in]  DhContext  Pointer to the DH context to be released.
  38
  39 **/
  40 VOID
  41 EFIAPI
  42 DhFree (
  43   IN  VOID  *DhContext
  44   )
  45 {
  46   //
  47   // Free OpenSSL DH Context
  48   //
  49   DH_free ((DH *) DhContext);
  50 }
  51
  52 /**
  53   Generates DH parameter.
  54
  55   Given generator g, and length of prime number p in bits, this function generates p,
  56   and sets DH context according to value of g and p.
  57
  58   Before this function can be invoked, pseudorandom number generator must be correctly
  59   initialized by RandomSeed().
  60
  61   If DhContext is NULL, then return FALSE.
  62   If Prime is NULL, then return FALSE.
  63
  64   @param[in, out]  DhContext    Pointer to the DH context.
  65   @param[in]       Generator    Value of generator.
  66   @param[in]       PrimeLength  Length in bits of prime to be generated.
  67   @param[out]      Prime        Pointer to the buffer to receive the generated prime number.
  68
  69   @retval TRUE   DH parameter generation succeeded.
  70   @retval FALSE  Value of Generator is not supported.
  71   @retval FALSE  PRNG fails to generate random prime number with PrimeLength.
  72
  73 **/
  74 BOOLEAN
  75 EFIAPI
  76 DhGenerateParameter (
  77   IN OUT  VOID   *DhContext,
  78   IN      UINTN  Generator,
  79   IN      UINTN  PrimeLength,
  80   OUT     UINT8  *Prime
  81   )
  82 {
  83   BOOLEAN RetVal;
  84   BIGNUM  *BnP;
  85
  86   //
  87   // Check input parameters.
  88   //
  89   if (DhContext == NULL || Prime == NULL || PrimeLength > INT_MAX) {
  90     return FALSE;
  91   }
  92
  93   if (Generator != DH_GENERATOR_2 && Generator != DH_GENERATOR_5) {
  94     return FALSE;
  95   }
  96
  97   RetVal = (BOOLEAN) DH_generate_parameters_ex (DhContext, (UINT32) PrimeLength, (UINT32) Generator, NULL);
  98   if (!RetVal) {
  99     return FALSE;
 100   }
 101
 102   DH_get0_pqg (DhContext, (const BIGNUM **)&BnP, NULL, NULL);
 103   BN_bn2bin (BnP, Prime);
 104
 105   return TRUE;
 106 }
 107
 108 /**
 109   Sets generator and prime parameters for DH.
 110
 111   Given generator g, and prime number p, this function and sets DH
 112   context accordingly.
 113
 114   If DhContext is NULL, then return FALSE.
 115   If Prime is NULL, then return FALSE.
 116
 117   @param[in, out]  DhContext    Pointer to the DH context.
 118   @param[in]       Generator    Value of generator.
 119   @param[in]       PrimeLength  Length in bits of prime to be generated.
 120   @param[in]       Prime        Pointer to the prime number.
 121
 122   @retval TRUE   DH parameter setting succeeded.
 123   @retval FALSE  Value of Generator is not supported.
 124   @retval FALSE  Value of Generator is not suitable for the Prime.
 125   @retval FALSE  Value of Prime is not a prime number.
 126   @retval FALSE  Value of Prime is not a safe prime number.
 127
 128 **/
 129 BOOLEAN
 130 EFIAPI
 131 DhSetParameter (
 132   IN OUT  VOID         *DhContext,
 133   IN      UINTN        Generator,
 134   IN      UINTN        PrimeLength,
 135   IN      CONST UINT8  *Prime
 136   )
 137 {
 138   DH      *Dh;
 139   BIGNUM  *BnP;
 140   BIGNUM  *BnG;
 141
 142   //
 143   // Check input parameters.
 144   //
 145   if (DhContext == NULL || Prime == NULL || PrimeLength > INT_MAX) {
 146     return FALSE;
 147   }
 148
 149   if (Generator != DH_GENERATOR_2 && Generator != DH_GENERATOR_5) {
 150     return FALSE;
 151   }
 152
 153   //
 154   // Set the generator and prime parameters for DH object.
 155   //
 156   Dh  = (DH *)DhContext;
 157   BnP = BN_bin2bn ((const unsigned char *)Prime, (int)(PrimeLength / 8), NULL);
 158   BnG = BN_bin2bn ((const unsigned char *)&Generator, 1, NULL);
 159   if ((BnP == NULL) || (BnG == NULL) || !DH_set0_pqg (Dh, BnP, NULL, BnG)) {
 160     goto Error;
 161   }
 162
 163   return TRUE;
 164
 165 Error:
 166   BN_free (BnP);
 167   BN_free (BnG);
 168
 169   return FALSE;
 170 }
 171
 172 /**
 173   Generates DH public key.
 174
 175   This function generates random secret exponent, and computes the public key, which is
 176   returned via parameter PublicKey and PublicKeySize. DH context is updated accordingly.
 177   If the PublicKey buffer is too small to hold the public key, FALSE is returned and
 178   PublicKeySize is set to the required buffer size to obtain the public key.
 179
 180   If DhContext is NULL, then return FALSE.
 181   If PublicKeySize is NULL, then return FALSE.
 182   If PublicKeySize is large enough but PublicKey is NULL, then return FALSE.
 183
 184   @param[in, out]  DhContext      Pointer to the DH context.
 185   @param[out]      PublicKey      Pointer to the buffer to receive generated public key.
 186   @param[in, out]  PublicKeySize  On input, the size of PublicKey buffer in bytes.
 187                                   On output, the size of data returned in PublicKey buffer in bytes.
 188
 189   @retval TRUE   DH public key generation succeeded.
 190   @retval FALSE  DH public key generation failed.
 191   @retval FALSE  PublicKeySize is not large enough.
 192
 193 **/
 194 BOOLEAN
 195 EFIAPI
 196 DhGenerateKey (
 197   IN OUT  VOID   *DhContext,
 198   OUT     UINT8  *PublicKey,
 199   IN OUT  UINTN  *PublicKeySize
 200   )
 201 {
 202   BOOLEAN RetVal;
 203   DH      *Dh;
 204   BIGNUM  *DhPubKey;
 205   INTN    Size;
 206
 207   //
 208   // Check input parameters.
 209   //
 210   if (DhContext == NULL || PublicKeySize == NULL) {
 211     return FALSE;
 212   }
 213
 214   if (PublicKey == NULL && *PublicKeySize != 0) {
 215     return FALSE;
 216   }
 217
 218   Dh = (DH *) DhContext;
 219
 220   RetVal = (BOOLEAN) DH_generate_key (DhContext);
 221   if (RetVal) {
 222     DH_get0_key (Dh, (const BIGNUM **)&DhPubKey, NULL);
 223     Size = BN_num_bytes (DhPubKey);
 224     if ((Size > 0) && (*PublicKeySize < (UINTN) Size)) {
 225       *PublicKeySize = Size;
 226       return FALSE;
 227     }
 228
 229     if (PublicKey != NULL) {
 230       BN_bn2bin (DhPubKey, PublicKey);
 231     }
 232     *PublicKeySize = Size;
 233   }
 234
 235   return RetVal;
 236 }
 237
 238 /**
 239   Computes exchanged common key.
 240
 241   Given peer's public key, this function computes the exchanged common key, based on its own
 242   context including value of prime modulus and random secret exponent.
 243
 244   If DhContext is NULL, then return FALSE.
 245   If PeerPublicKey is NULL, then return FALSE.
 246   If KeySize is NULL, then return FALSE.
 247   If Key is NULL, then return FALSE.
 248   If KeySize is not large enough, then return FALSE.
 249
 250   @param[in, out]  DhContext          Pointer to the DH context.
 251   @param[in]       PeerPublicKey      Pointer to the peer's public key.
 252   @param[in]       PeerPublicKeySize  Size of peer's public key in bytes.
 253   @param[out]      Key                Pointer to the buffer to receive generated key.
 254   @param[in, out]  KeySize            On input, the size of Key buffer in bytes.
 255                                       On output, the size of data returned in Key buffer in bytes.
 256
 257   @retval TRUE   DH exchanged key generation succeeded.
 258   @retval FALSE  DH exchanged key generation failed.
 259   @retval FALSE  KeySize is not large enough.
 260
 261 **/
 262 BOOLEAN
 263 EFIAPI
 264 DhComputeKey (
 265   IN OUT  VOID         *DhContext,
 266   IN      CONST UINT8  *PeerPublicKey,
 267   IN      UINTN        PeerPublicKeySize,
 268   OUT     UINT8        *Key,
 269   IN OUT  UINTN        *KeySize
 270   )
 271 {
 272   BIGNUM  *Bn;
 273   INTN    Size;
 274
 275   //
 276   // Check input parameters.
 277   //
 278   if (DhContext == NULL || PeerPublicKey == NULL || KeySize == NULL || Key == NULL) {
 279     return FALSE;
 280   }
 281
 282   if (PeerPublicKeySize > INT_MAX) {
 283     return FALSE;
 284   }
 285
 286   Bn = BN_bin2bn (PeerPublicKey, (UINT32) PeerPublicKeySize, NULL);
 287   if (Bn == NULL) {
 288     return FALSE;
 289   }
 290
 291   Size = DH_compute_key (Key, Bn, DhContext);
 292   if (Size < 0) {
 293     BN_free (Bn);
 294     return FALSE;
 295   }
 296
 297   if (*KeySize < (UINTN) Size) {
 298     *KeySize = Size;
 299     BN_free (Bn);
 300     return FALSE;
 301   }
 302
 303   *KeySize = Size;
 304   BN_free (Bn);
 305   return TRUE;
 306 }