CryptRsaExt.c

Go to the documentation of this file.

 
#include "InternalCryptLib.h"
 
#include <openssl/bn.h>
#include <openssl/rsa.h>
#include <openssl/err.h>
#include <openssl/objects.h>
 
BOOLEAN
EFIAPI
RsaGetKey (
  IN OUT  VOID         *RsaContext,
  IN      RSA_KEY_TAG  KeyTag,
  OUT     UINT8        *BigNumber,
  IN OUT  UINTN        *BnSize
  )
{
  RSA     *RsaKey;
  BIGNUM  *BnKey;
  UINTN   Size;
 
  //
  // Check input parameters.
  //
  if ((RsaContext == NULL) || (BnSize == NULL)) {
    return FALSE;
  }
 
  RsaKey  = (RSA *)RsaContext;
  Size    = *BnSize;
  *BnSize = 0;
  BnKey   = NULL;
 
  switch (KeyTag) {
    //
    // RSA Public Modulus (N)
    //
    case RsaKeyN:
      RSA_get0_key (RsaKey, (const BIGNUM **)&BnKey, NULL, NULL);
      break;
 
    //
    // RSA Public Exponent (e)
    //
    case RsaKeyE:
      RSA_get0_key (RsaKey, NULL, (const BIGNUM **)&BnKey, NULL);
      break;
 
    //
    // RSA Private Exponent (d)
    //
    case RsaKeyD:
      RSA_get0_key (RsaKey, NULL, NULL, (const BIGNUM **)&BnKey);
      break;
 
    //
    // RSA Secret Prime Factor of Modulus (p)
    //
    case RsaKeyP:
      RSA_get0_factors (RsaKey, (const BIGNUM **)&BnKey, NULL);
      break;
 
    //
    // RSA Secret Prime Factor of Modules (q)
    //
    case RsaKeyQ:
      RSA_get0_factors (RsaKey, NULL, (const BIGNUM **)&BnKey);
      break;
 
    //
    // p's CRT Exponent (== d mod (p - 1))
    //
    case RsaKeyDp:
      RSA_get0_crt_params (RsaKey, (const BIGNUM **)&BnKey, NULL, NULL);
      break;
 
    //
    // q's CRT Exponent (== d mod (q - 1))
    //
    case RsaKeyDq:
      RSA_get0_crt_params (RsaKey, NULL, (const BIGNUM **)&BnKey, NULL);
      break;
 
    //
    // The CRT Coefficient (== 1/q mod p)
    //
    case RsaKeyQInv:
      RSA_get0_crt_params (RsaKey, NULL, NULL, (const BIGNUM **)&BnKey);
      break;
 
    default:
      return FALSE;
  }
 
  if (BnKey == NULL) {
    return FALSE;
  }
 
  *BnSize = Size;
  Size    = BN_num_bytes (BnKey);
 
  if (*BnSize < Size) {
    *BnSize = Size;
    return FALSE;
  }
 
  if (BigNumber == NULL) {
    *BnSize = Size;
    return TRUE;
  }
 
  *BnSize = BN_bn2bin (BnKey, BigNumber);
 
  return TRUE;
}
 
BOOLEAN
EFIAPI
RsaGenerateKey (
  IN OUT  VOID         *RsaContext,
  IN      UINTN        ModulusLength,
  IN      CONST UINT8  *PublicExponent,
  IN      UINTN        PublicExponentSize
  )
{
  BIGNUM   *KeyE;
  BOOLEAN  RetVal;
 
  //
  // Check input parameters.
  //
  if ((RsaContext == NULL) || (ModulusLength > INT_MAX) || (PublicExponentSize > INT_MAX)) {
    return FALSE;
  }
 
  KeyE = BN_new ();
  if (KeyE == NULL) {
    return FALSE;
  }
 
  RetVal = FALSE;
 
  if (PublicExponent == NULL) {
    if (BN_set_word (KeyE, 0x10001) == 0) {
      goto _Exit;
    }
  } else {
    if (BN_bin2bn (PublicExponent, (UINT32)PublicExponentSize, KeyE) == NULL) {
      goto _Exit;
    }
  }
 
  if (RSA_generate_key_ex ((RSA *)RsaContext, (UINT32)ModulusLength, KeyE, NULL) == 1) {
    RetVal = TRUE;
  }
 
_Exit:
  BN_free (KeyE);
  return RetVal;
}
 
BOOLEAN
EFIAPI
RsaCheckKey (
  IN  VOID  *RsaContext
  )
{
  UINTN  Reason;
 
  //
  // Check input parameters.
  //
  if (RsaContext == NULL) {
    return FALSE;
  }
 
  if (RSA_check_key ((RSA *)RsaContext) != 1) {
    Reason = ERR_GET_REASON (ERR_peek_last_error ());
    if ((Reason == RSA_R_P_NOT_PRIME) ||
        (Reason == RSA_R_Q_NOT_PRIME) ||
        (Reason == RSA_R_N_DOES_NOT_EQUAL_P_Q) ||
        (Reason == RSA_R_D_E_NOT_CONGRUENT_TO_1))
    {
      return FALSE;
    }
  }
 
  return TRUE;
}
 
BOOLEAN
EFIAPI
RsaPkcs1Sign (
  IN      VOID         *RsaContext,
  IN      CONST UINT8  *MessageHash,
  IN      UINTN        HashSize,
  OUT     UINT8        *Signature,
  IN OUT  UINTN        *SigSize
  )
{
  RSA    *Rsa;
  UINTN  Size;
  INT32  DigestType;
 
  //
  // Check input parameters.
  //
  if ((RsaContext == NULL) || (MessageHash == NULL)) {
    return FALSE;
  }
 
  Rsa  = (RSA *)RsaContext;
  Size = RSA_size (Rsa);
 
  if (*SigSize < Size) {
    *SigSize = Size;
    return FALSE;
  }
 
  if (Signature == NULL) {
    return FALSE;
  }
 
  //
  // Determine the message digest algorithm according to digest size.
  //   Only MD5, SHA-1, SHA-256, SHA-384 or SHA-512 algorithm is supported.
  //
  switch (HashSize) {
    case MD5_DIGEST_SIZE:
      DigestType = NID_md5;
      break;
 
    case SHA1_DIGEST_SIZE:
      DigestType = NID_sha1;
      break;
 
    case SHA256_DIGEST_SIZE:
      DigestType = NID_sha256;
      break;
 
    case SHA384_DIGEST_SIZE:
      DigestType = NID_sha384;
      break;
 
    case SHA512_DIGEST_SIZE:
      DigestType = NID_sha512;
      break;
 
    default:
      return FALSE;
  }
 
  return (BOOLEAN)RSA_sign (
                    DigestType,
                    MessageHash,
                    (UINT32)HashSize,
                    Signature,
                    (UINT32 *)SigSize,
                    (RSA *)RsaContext
                    );
}