CryptBn.c

 
#include "InternalCryptLib.h"
#include <openssl/bn.h>
 
VOID *
EFIAPI
BigNumInit (
  VOID
  )
{
  return BN_new ();
}
 
VOID *
EFIAPI
BigNumFromBin (
  IN CONST UINT8  *Buf,
  IN UINTN        Len
  )
{
  return BN_bin2bn (Buf, (INT32)Len, NULL);
}
 
INTN
EFIAPI
BigNumToBin (
  IN CONST VOID  *Bn,
  OUT UINT8      *Buf
  )
{
  return BN_bn2bin (Bn, Buf);
}
 
VOID
EFIAPI
BigNumFree (
  IN VOID     *Bn,
  IN BOOLEAN  Clear
  )
{
  if (Clear) {
    BN_clear_free (Bn);
  } else {
    BN_free (Bn);
  }
}
 
BOOLEAN
EFIAPI
BigNumAdd (
  IN CONST VOID  *BnA,
  IN CONST VOID  *BnB,
  OUT VOID       *BnRes
  )
{
  return (BOOLEAN)BN_add (BnRes, BnA, BnB);
}
 
BOOLEAN
EFIAPI
BigNumSub (
  IN CONST VOID  *BnA,
  IN CONST VOID  *BnB,
  OUT VOID       *BnRes
  )
{
  return (BOOLEAN)BN_sub (BnRes, BnA, BnB);
}
 
BOOLEAN
EFIAPI
BigNumMod (
  IN CONST VOID  *BnA,
  IN CONST VOID  *BnB,
  OUT VOID       *BnRes
  )
{
  BOOLEAN  RetVal;
  BN_CTX   *Ctx;
 
  Ctx = BN_CTX_new ();
  if (Ctx == NULL) {
    return FALSE;
  }
 
  RetVal = (BOOLEAN)BN_mod (BnRes, BnA, BnB, Ctx);
  BN_CTX_free (Ctx);
 
  return RetVal;
}
 
BOOLEAN
EFIAPI
BigNumExpMod (
  IN CONST VOID  *BnA,
  IN CONST VOID  *BnP,
  IN CONST VOID  *BnM,
  OUT VOID       *BnRes
  )
{
  BOOLEAN  RetVal;
  BN_CTX   *Ctx;
 
  Ctx = BN_CTX_new ();
  if (Ctx == NULL) {
    return FALSE;
  }
 
  RetVal = (BOOLEAN)BN_mod_exp (BnRes, BnA, BnP, BnM, Ctx);
 
  BN_CTX_free (Ctx);
  return RetVal;
}
 
BOOLEAN
EFIAPI
BigNumInverseMod (
  IN CONST VOID  *BnA,
  IN CONST VOID  *BnM,
  OUT VOID       *BnRes
  )
{
  BOOLEAN  RetVal;
  BN_CTX   *Ctx;
 
  Ctx = BN_CTX_new ();
  if (Ctx == NULL) {
    return FALSE;
  }
 
  RetVal = FALSE;
  if (BN_mod_inverse (BnRes, BnA, BnM, Ctx) != NULL) {
    RetVal = TRUE;
  }
 
  BN_CTX_free (Ctx);
  return RetVal;
}
 
BOOLEAN
EFIAPI
BigNumDiv (
  IN CONST VOID  *BnA,
  IN CONST VOID  *BnB,
  OUT VOID       *BnRes
  )
{
  BOOLEAN  RetVal;
  BN_CTX   *Ctx;
 
  Ctx = BN_CTX_new ();
  if (Ctx == NULL) {
    return FALSE;
  }
 
  RetVal = (BOOLEAN)BN_div (BnRes, NULL, BnA, BnB, Ctx);
  BN_CTX_free (Ctx);
 
  return RetVal;
}
 
BOOLEAN
EFIAPI
BigNumMulMod (
  IN CONST VOID  *BnA,
  IN CONST VOID  *BnB,
  IN CONST VOID  *BnM,
  OUT VOID       *BnRes
  )
{
  BOOLEAN  RetVal;
  BN_CTX   *Ctx;
 
  Ctx = BN_CTX_new ();
  if (Ctx == NULL) {
    return FALSE;
  }
 
  RetVal = (BOOLEAN)BN_mod_mul (BnRes, BnA, BnB, BnM, Ctx);
  BN_CTX_free (Ctx);
 
  return RetVal;
}
 
INTN
EFIAPI
BigNumCmp (
  IN CONST VOID  *BnA,
  IN CONST VOID  *BnB
  )
{
  return BN_cmp (BnA, BnB);
}
 
UINTN
EFIAPI
BigNumBits (
  IN CONST VOID  *Bn
  )
{
  return BN_num_bits (Bn);
}
 
UINTN
EFIAPI
BigNumBytes (
  IN CONST VOID  *Bn
  )
{
  return BN_num_bytes (Bn);
}
 
BOOLEAN
EFIAPI
BigNumIsWord (
  IN CONST VOID  *Bn,
  IN UINTN       Num
  )
{
  return (BOOLEAN)BN_is_word (Bn, Num);
}
 
BOOLEAN
EFIAPI
BigNumIsOdd (
  IN CONST VOID  *Bn
  )
{
  return (BOOLEAN)BN_is_odd (Bn);
}
 
VOID *
EFIAPI
BigNumCopy (
  OUT VOID       *BnDst,
  IN CONST VOID  *BnSrc
  )
{
  return BN_copy (BnDst, BnSrc);
}
 
CONST VOID *
EFIAPI
BigNumValueOne (
  VOID
  )
{
  return BN_value_one ();
}
 
BOOLEAN
EFIAPI
BigNumRShift (
  IN CONST VOID  *Bn,
  IN UINTN       N,
  OUT VOID       *BnRes
  )
{
  return (BOOLEAN)BN_rshift (BnRes, Bn, (INT32)N);
}
 
VOID
EFIAPI
BigNumConstTime (
  IN VOID  *Bn
  )
{
  BN_set_flags (Bn, BN_FLG_CONSTTIME);
}
 
BOOLEAN
EFIAPI
BigNumSqrMod (
  IN CONST VOID  *BnA,
  IN CONST VOID  *BnM,
  OUT VOID       *BnRes
  )
{
  BOOLEAN  RetVal;
  BN_CTX   *Ctx;
 
  Ctx = BN_CTX_new ();
  if (Ctx == NULL) {
    return FALSE;
  }
 
  RetVal = (BOOLEAN)BN_mod_sqr (BnRes, BnA, BnM, Ctx);
  BN_CTX_free (Ctx);
 
  return RetVal;
}
 
VOID *
EFIAPI
BigNumNewContext (
  VOID
  )
{
  return BN_CTX_new ();
}
 
VOID
EFIAPI
BigNumContextFree (
  IN VOID  *BnCtx
  )
{
  BN_CTX_free (BnCtx);
}
 
BOOLEAN
EFIAPI
BigNumSetUint (
  IN VOID   *Bn,
  IN UINTN  Val
  )
{
  return (BOOLEAN)BN_set_word (Bn, Val);
}
 
BOOLEAN
EFIAPI
BigNumAddMod (
  IN CONST VOID  *BnA,
  IN CONST VOID  *BnB,
  IN CONST VOID  *BnM,
  OUT VOID       *BnRes
  )
{
  BOOLEAN  RetVal;
  BN_CTX   *Ctx;
 
  Ctx = BN_CTX_new ();
  if (Ctx == NULL) {
    return FALSE;
  }
 
  RetVal = (BOOLEAN)BN_mod_add (BnRes, BnA, BnB, BnM, Ctx);
  BN_CTX_free (Ctx);
 
  return RetVal;
}