random.c

flint库 RSA算法

/*                                                                            */
/*  Function:  Generation of a pseudorandom number of type ULONG              */
/*  Syntax:    ULONG lRandBBS_l (STATEBBS *rstate);                           */
/*  Input:     rstate (Initialized internal state of PRNG)                    */
/*  Output:    rstate (Internal state of PRNG)                                */
/*  Returns:   Pseudorandom number of type ULONG                              */
/*                                                                            */
/******************************************************************************/
ULONG __FLINT_API
lRandBBS_l (STATEBBS * rstate)
{
  int i;
  ULONG r = SwitchRandBBS_l(rstate);
  for (i = 1; i < (sizeof (ULONG) << 3); i++)
    {
      r = (r << 1) + SwitchRandBBS_l (rstate);
    }

  return r;
}


/******************************************************************************/
/*                                                                            */
/*  Function:  Generation of a pseudorandom number of type CLINT              */
/*             (Preceding Initialization by InitRandBBS() required)           */
/*  Syntax:    int RandBBS_l (CLINT r_l, STATEBBS *rstate, int l);            */
/*  Input:     rstate (Initialized internal state of PRNG)                    */
/*             l (Number of binary digits of random number to generated)      */
/*  Output:    r_l (Pseudorandom number)                                      */
/*             rstate (Internal state of PRNG)                                */
/*  Returns:   E_CLINT_OK  if everything is OK                                */
/*             E_CLINT_RIN if generator is not initialized                    */
/*                                                                            */
/******************************************************************************/
int __FLINT_API
RandBBS_l (CLINT r_l, STATEBBS * rstate, int l)
{
  USHORT i, j;
  USHORT ls, lr;

  if (!rstate->RandBBSInit)
    {
      return E_CLINT_RIN;
    }

  l = (int)MIN ((unsigned int)l, CLINTMAXBIT);
  ls = (USHORT)l >> LDBITPERDGT;
  lr = (USHORT)l & ((USHORT)BITPERDGT - 1);

  for (i = 1; i <= ls; i++)
    {
      r_l[i] = sRandBBS_l (rstate);
    }

  if (lr > 0)
    {
      ++ls;
      r_l[ls] = sRandBBS_l (rstate);
      j = 1U << (lr - 1);                         /* j <- 2^(lr - 1) */
      r_l[ls] = (r_l[ls] | j) & ((j << 1) - 1);   /* bt lr to 1, higher bits to */
    }
  else
    {
      r_l[ls] |= BASEDIV2;
    }

  SETDIGITS_L (r_l, ls);

  /* Purging ov variables */
  local_memset (&i, 0, sizeof (i));
  local_memset (&j, 0, sizeof (j));
  local_memset (&ls, 0, sizeof (ls));
  local_memset (&lr, 0, sizeof (lr));

  return E_CLINT_OK;
}


/******************************************************************************/
/*                                                                            */
/*  Function:   Purging of the internal state of RandBBS                      */
/*  Syntax:     void PurgeRandBBS_l (STATEBBS * rstate);                      */
/*  Input:      rstate (Internal state of PRNG)                               */
/*  Output:     rstate (Purged indernal state of PRNG)                        */
/*  Returns:    -                                                             */
/*                                                                            */
/******************************************************************************/
void __FLINT_API
PurgeRandBBS_l (STATEBBS * rstate)
{
  /* Purge status of BBS-PRNG */
  memset (rstate->XBBS, 0, sizeof (CLINT));

  /* Reset initialization flag */
  rstate->RandBBSInit = 0;
}


/*** Higher Level Functions for Generation of Random Numbers of Type CLINT ****/


/******************************************************************************/
/*                                                                            */
/*  Function:  Initialisation of a chosen PRNG                                */
/*             with entropy generated by GetEntropy_l                         */
/*  Syntax:    int InitRand_l (STATEPRNG *xrstate, char *UsrStr,              */
/*                             int LenUsrStr, int AddEntropy, int Generator); */
/*  Input:     UsrStr (String for initialization optionally provided by user) */
/*             LenUsrStr (Length of UsrStr in bytes)                          */
/*             AddEntropy (Number of additionally requested entropy bytes     */
/*             Generator (PRNG to be initialized: one of FLINT_RND64          */
/*                                                       FLINT_RNDRMDSHA1     */
/*                                                       FLINT_RNDAES         */
/*                                                       FLINT_RNDBBS)        */
/*  Output:    xrstate (Initialized state of random number generator)         */
/*  Output:    -                                                              */
/*  Returns:   0: OK                                                          */
/*             n > 0: Number of requested but not generated entropy bytes     */
/*             n < 0: Requested generator does not exist, RND64 initialized   */
/*                                                                            */
/******************************************************************************/
int __FLINT_API
InitRand_l (STATEPRNG *xrstate, char *UsrStr, int LenUsrStr, int AddEntropy, int Generator)
{
  int error;

  switch (Generator)
    {
      case FLINT_RNDBBS:
        error = InitRandBBS_l (&xrstate->StateBBS, (char*)UsrStr, LenUsrStr, AddEntropy);
        xrstate->Generator = FLINT_RNDBBS;
        break;
      case FLINT_RNDRMDSHA1:
        error = InitRandRMDSHA1_l (&xrstate->StateRMDSHA1, (char*)UsrStr, LenUsrStr, AddEntropy);
        xrstate->Generator = FLINT_RNDRMDSHA1;
        break;
      case FLINT_RNDAES:
        error = InitRandAES_l (&xrstate->StateAES, (char*)UsrStr, LenUsrStr, AddEntropy, 10);
        xrstate->Generator = FLINT_RNDAES;
        break;
      case FLINT_RND64:
        error = InitRand64_l ((char*)UsrStr, LenUsrStr, AddEntropy);
        xrstate->Generator = FLINT_RND64;
        break;
      default:
        InitRand64_l ((char*)UsrStr, LenUsrStr, AddEntropy);
        xrstate->Generator = FLINT_RND64;
        error = -AddEntropy;
    }

  return error;
}


/******************************************************************************/
/*                                                                            */
/*  Function:  Generation of a pseudorandom number of type UCHAR              */
/*  Syntax:    UCHAR bRand_l (STATEPRNG *xrstate)                             */
/*  Input:     xrstate (Initialized state of chosen random number generator)  */
/*  Output:    -                                                              */
/*  Returns:   Pseudorandom number of type UCHAR                              */
/*                                                                            */
/******************************************************************************/
UCHAR __FLINT_API
bRand_l (STATEPRNG *xrstate)
{
  UCHAR r;

  switch (xrstate->Generator)
    {
      case FLINT_RNDBBS:
        r = bRandBBS_l (&xrstate->StateBBS);
        break;
      case FLINT_RNDRMDSHA1:
        r = bRandRMDSHA1_l (&xrstate->StateRMDSHA1);
        break;
      case FLINT_RNDAES:
        r = bRandAES_l (&xrstate->StateAES);
        break;
      case FLINT_RND64:
        r = ucrand64_l ();
        break;
      default:
        r = ucrand64_l ();
    }

  return r;
}



/******************************************************************************/
/*                                                                            */
/*  Function:  Generation of a pseudorandom number of type USHORT             */
/*  Syntax:    USHORT sRand_l (STATEPRNG *xrstate);                           */
/*  Input:     xrstate (Choice and initialized state of PRNG)                 */
/*  Output:    xrstate (State of chosen PRNG)                                 */
/*  Returns:   Pseudorandom number of type USHORT                             */
/*                                                                            */
/******************************************************************************/
USHORT __FLINT_API
sRand_l (STATEPRNG *xrstate)
{
  USHORT r;

  switch (xrstate->Generator)
    {
      case FLINT_RNDBBS:
        r = sRandBBS_l (&xrstate->StateBBS);
        break;
      case FLINT_RNDRMDSHA1:
        r = sRandRMDSHA1_l (&xrstate->StateRMDSHA1);
        break;
      case FLINT_RNDAES:
        r = sRandAES_l (&xrstate->StateAES);
        break;
      case FLINT_RND64:
        r = usrand64_l ();
        break;
      default:
        r = usrand64_l ();
    }

  return r;
}


/******************************************************************************/
/*                                                                            */
/*  Function:  Generation of a pseudorandom number of type ULONG              */
/*  Syntax:    ULONG lRand_l (STATEPRNG *xrstate);                            */
/*  Input:     xrstate (Choice and initialized state of PRNG)                 */
/*  Output:    xrstate (State of chosen PRNG)                                 */
/*  Returns:   Pseudorandom number of type ULONG                              */
/*                                                                            */
/******************************************************************************/
ULONG __FLINT_API
lRand_l (STATEPRNG *xrstate)
{
  ULONG r;

  switch (xrstate->Generator)
    {
      case FLINT_RNDBBS:
        r = lRandBBS_l (&xrstate->StateBBS);
        break;
      case FLINT_RNDRMDSHA1:
        r = lRandRMDSHA1_l (&xrstate->StateRMDSHA1);
        break;
      case FLINT_RNDAES:
        r = lRandAES_l (&xrstate->StateAES);
        break;
      case FLINT_RND64:
        r = usrand64_l ();
        break;
      default:
        r = usrand64_l ();
    }

  return r;
}


/******************************************************************************/
/*                                                                            */
/*  Function:  Generation of a pseudorandom number of type CLINT              */
/*             (Preceding Initialization by InitRand_l() required)            */
/*  Syntax:    int Rand_l (CLINT r_l, STATEPRNG *xrstate, int l);             */
/*  Input:     xrstate (Choice and initialized state of PRNG)                 */
/*             l (Number of binary digits of random number to generated)      */
/*  Output:    r_l (Pseudorandom number)                                      */
/*             xrstate (State of chosen PRNG)                                 */
/*  Returns:   E_CLINT_OK  if everything is OK                                */
/*             E_CLINT_RIN if requested generator is not initialized or       */
/*                         invalid choice                                     */
/*                                                                            */
/******************************************************************************/
int __FLINT_API
Rand_l (CLINT r_l, STATEPRNG *xrstate, int l)
{
  int error = E_CLINT_OK;

  switch (xrstate->Generator)
    {
      case FLINT_RNDBBS:
        error = RandBBS_l (r_l, &xrstate->StateBBS, MIN (l, (int)CLINTMAXBIT));
        break;
      case FLINT_RNDAES:
        error = RandAES_l (r_l, &xrstate->StateAES, MIN (l, (int)CLINTMAXBIT));
        break;
      case FLINT_RNDRMDSHA1:
        error = RandRMDSHA1_l (r_l, &xrstate->StateRMDSHA1, MIN (l, (int)CLINTMAXBIT));
        break;
      case FLINT_RND64:
        rand_l (r_l, MIN (l, (int)CLINTMAXBIT));