android-8.0.0_r1.0/s

// This file was extracted from the TCG Published
// Trusted Platform Module Library
// Part 4: Supporting Routines
// Family "2.0"
// Level 00 Revision 01.16
// October 30, 2014

#include <string.h>

#include "CryptoEngine.h"

#ifndef EMBEDDED_MODE
#include "OsslCryptoEngine.h"
//
//
//          Externally Accessible Functions
//
//           _math__Normalize2B()
//
//     This function will normalize the value in a TPM2B. If there are leading bytes of zero, the first non-zero
//     byte is shifted up.
//
//     Return Value                     Meaning
//
//     0                                no significant bytes, value is zero
//     >0                               number of significant bytes
//
LIB_EXPORT UINT16
_math__Normalize2B(
     TPM2B               *b                  // IN/OUT: number to normalize
     )
{
     UINT16        from;
     UINT16        to;
     UINT16        size = b->size;
     for(from = 0; b->buffer[from] == 0 && from < size; from++);
     b->size -= from;
     for(to = 0; from < size; to++, from++ )
         b->buffer[to] = b->buffer[from];
     return b->size;
}
//
//
//
//        _math__Denormalize2B()
//
//     This function is used to adjust a TPM2B so that the number has the desired number of bytes. This is
//     accomplished by adding bytes of zero at the start of the number.
//
//     Return Value                      Meaning
//
//     TRUE                              number de-normalized
//     FALSE                             number already larger than the desired size
//
LIB_EXPORT BOOL
_math__Denormalize2B(
    TPM2B              *in,                   // IN:OUT TPM2B number to de-normalize
    UINT32              size                  // IN: the desired size
    )
{
    UINT32       to;
    UINT32       from;
    // If the current size is greater than the requested size, see if this can be
    // normalized to a value smaller than the requested size and then de-normalize
    if(in->size > size)
    {
        _math__Normalize2B(in);
        if(in->size > size)
            return FALSE;
    }
    // If the size is already what is requested, leave
    if(in->size == size)
        return TRUE;
    // move the bytes to the 'right'
    for(from = in->size, to = size; from > 0;)
        in->buffer[--to] = in->buffer[--from];
    // 'to' will always be greater than 0 because we checked for equal above.
    for(; to > 0;)
        in->buffer[--to] = 0;
    in->size = (UINT16)size;
    return TRUE;
}
//
//
//        _math__sub()
//
//     This function to subtract one unsigned value from another c = a - b. c may be the same as a or b.
//
//     Return Value                      Meaning
//
//     1                                 if (a > b) so no borrow
//     0                                 if (a = b) so no borrow and b == a
//     -1                                if (a < b) so there was a borrow
//
LIB_EXPORT int
_math__sub(
    const UINT32        aSize,                //   IN: size   of a
    const BYTE         *a,                    //   IN: a
    const UINT32        bSize,                //   IN: size   of b
    const BYTE         *b,                    //   IN: b
    UINT16             *cSize,                //   OUT: set   to MAX(aSize, bSize)
    BYTE               *c                     //   OUT: the   difference
    )
{
    int               borrow = 0;
    int               notZero = 0;
    int               i;
    int               i2;
    // set c to the longer of a or b
    *cSize = (UINT16)((aSize > bSize) ? aSize : bSize);
    // pick the shorter of a and b
    i = (aSize > bSize) ? bSize : aSize;
    i2 = *cSize - i;
    a = &a[aSize - 1];
    b = &b[bSize - 1];
    c = &c[*cSize - 1];
    for(; i > 0; i--)
    {
        borrow = *a-- - *b-- + borrow;
        *c-- = (BYTE)borrow;
        notZero = notZero || borrow;
        borrow >>= 8;
    }
    if(aSize > bSize)
    {
        for(;i2 > 0; i2--)
        {
            borrow = *a-- + borrow;
            *c-- = (BYTE)borrow;
            notZero = notZero || borrow;
            borrow >>= 8;
        }
    }
    else if(aSize < bSize)
    {
        for(;i2 > 0; i2--)
        {
            borrow = 0 - *b-- + borrow;
            *c-- = (BYTE)borrow;
            notZero = notZero || borrow;
            borrow >>= 8;
        }
    }
    // if there is a borrow, then b > a
    if(borrow)
        return -1;
    // either a > b or they are the same
    return notZero;
}
//
//
//         _math__Inc()
//
//      This function increments a large, big-endian number value by one.
//
//      Return Value                   Meaning
//
//      0                              result is zero
//      !0                             result is not zero
//
LIB_EXPORT int
_math__Inc(
    UINT32             aSize,              // IN: size of a
    BYTE              *a                   // IN: a
    )
{
//
      for(a = &a[aSize-1];aSize > 0; aSize--)
      {
          if((*a-- += 1) != 0)
              return 1;
      }
      return 0;
}
//
//
//          _math__Dec()
//
//      This function decrements a large, ENDIAN value by one.
//
LIB_EXPORT void
_math__Dec(
      UINT32            aSize,                // IN: size of a
      BYTE             *a                     // IN: a
      )
{
      for(a = &a[aSize-1]; aSize > 0; aSize--)
      {
          if((*a-- -= 1) != 0xff)
              return;
      }
      return;
}
//
//
//          _math__Mul()
//
//      This function is used to multiply two large integers: p = a* b. If the size of p is not specified (pSize ==
//      NULL), the size of the results p is assumed to be aSize + bSize and the results are de-normalized so that
//      the resulting size is exactly aSize + bSize. If pSize is provided, then the actual size of the result is
//      returned. The initial value for pSize must be at least aSize + pSize.
//
//      Return Value                      Meaning
//
//      <0                                indicates an error
//      >= 0                              the size of the product
//
LIB_EXPORT int
_math__Mul(
      const UINT32      aSize,                //   IN: size of a
      const BYTE       *a,                    //   IN: a
      const UINT32      bSize,                //   IN: size of b
      const BYTE       *b,                    //   IN: b
      UINT32           *pSize,                //   IN/OUT: size of the product
      BYTE             *p                     //   OUT: product. length of product = aSize +
                                              //       bSize
      )
{
      BIGNUM           *bnA;
      BIGNUM           *bnB;
      BIGNUM           *bnP;
      BN_CTX           *context;
      int              retVal = 0;
      // First check that pSize is large enough if present
      if((pSize != NULL) && (*pSize < (aSize + bSize)))
          return CRYPT_PARAMETER;
      pAssert(pSize == NULL || *pSize <= MAX_2B_BYTES);
      //
//
    // Allocate space for BIGNUM context
    //
    context = BN_CTX_new();
    if(context == NULL)
        FAIL(FATAL_ERROR_ALLOCATION);
    bnA = BN_CTX_get(context);
    bnB = BN_CTX_get(context);
    bnP = BN_CTX_get(context);
    if (bnP == NULL)
        FAIL(FATAL_ERROR_ALLOCATION);
    // Convert the inputs to BIGNUMs
    //
    if (BN_bin2bn(a, aSize, bnA) == NULL || BN_bin2bn(b, bSize, bnB) == NULL)
        FAIL(FATAL_ERROR_INTERNAL);
    // Perform the multiplication
    //
    if (BN_mul(bnP, bnA, bnB, context) != 1)
        FAIL(FATAL_ERROR_INTERNAL);
    // If the size of the results is allowed to float, then set the return
    // size. Otherwise, it might be necessary to de-normalize the results
    retVal = BN_num_bytes(bnP);
    if(pSize == NULL)
    {
        BN_bn2bin(bnP, &p[aSize + bSize - retVal]);
        memset(p, 0, aSize + bSize - retVal);
        retVal = aSize + bSize;
    }
    else
    {
        BN_bn2bin(bnP, p);
        *pSize = retVal;
    }
    BN_CTX_end(context);
    BN_CTX_free(context);
    return retVal;
}
//
//
//         _math__Div()
//
//      Divide an integer (n) by an integer (d) producing a quotient (q) and a remainder (r). If q or r is not needed,
//      then the pointer to them may be set to NULL.
//
//      Return Value                     Meaning
//
//      CRYPT_SUCCESS                    operation complete
//      CRYPT_UNDERFLOW                  q or r is too small to receive the result
//
LIB_EXPORT CRYPT_RESULT
_math__Div(
    const TPM2B         *n,                  //   IN: numerator
    const TPM2B         *d,                  //   IN: denominator
    TPM2B               *q,                  //   OUT: quotient
    TPM2B               *r                   //   OUT: remainder
    )
{
    BIGNUM              *bnN;
    BIGNUM              *bnD;
    BIGNUM              *bnQ;
    BIGNUM              *bnR;
    BN_CTX            *context;
    CRYPT_RESULT       retVal = CRYPT_SUCCESS;
    // Get structures for the big number representations
    context = BN_CTX_new();
    if(context == NULL)
        FAIL(FATAL_ERROR_ALLOCATION);
    BN_CTX_start(context);
    bnN = BN_CTX_get(context);
    bnD = BN_CTX_get(context);
    bnQ = BN_CTX_get(context);
    bnR = BN_CTX_get(context);
    // Errors in BN_CTX_get() are sticky so only need to check the last allocation
    if (    bnR == NULL
         || BN_bin2bn(n->buffer, n->size, bnN) == NULL
         || BN_bin2bn(d->buffer, d->size, bnD) == NULL)
             FAIL(FATAL_ERROR_INTERNAL);
    // Check for divide by zero.
    if(BN_num_bits(bnD) == 0)
        FAIL(FATAL_ERROR_DIVIDE_ZERO);
    // Perform the division
    if (BN_div(bnQ, bnR, bnN, bnD, context) != 1)
        FAIL(FATAL_ERROR_INTERNAL);
    // Convert the BIGNUM result back to our format
    if(q != NULL)   // If the quotient is being returned
    {
        if(!BnTo2B(q, bnQ, q->size))
        {
            retVal = CRYPT_UNDERFLOW;
            goto Done;
        }
      }
    if(r != NULL)   // If the remainder is being returned
    {
        if(!BnTo2B(r, bnR, r->size))
            retVal = CRYPT_UNDERFLOW;
    }
Done:
   BN_CTX_end(context);
   BN_CTX_free(context);
    return retVal;
}
#endif // ! EMBEDDED_MODE
//
//
//         _math__uComp()
//
//      This function compare two unsigned values.
//
//      Return Value                      Meaning
//
//      1                                 if (a > b)
//      0                                 if (a = b)
//      -1                                if (a < b)
//
LIB_EXPORT int
_math__uComp(
    const UINT32       aSize,                 // IN: size of a
    const BYTE        *a,                     // IN: a
    const UINT32       bSize,                // IN: size of b
    const BYTE        *b                     // IN: b
    )
{
    int              borrow = 0;
    int              notZero = 0;
    int              i;
    // If a has more digits than b, then a is greater than b if
    // any of the more significant bytes is non zero
    if((i = (int)aSize - (int)bSize) > 0)
        for(; i > 0; i--)
            if(*a++) // means a > b
                 return 1;
    // If b has more digits than a, then b is greater if any of the
    // more significant bytes is non zero
    if(i < 0) // Means that b is longer than a
        for(; i < 0; i++)
            if(*b++) // means that b > a
                 return -1;
    // Either the vales are the same size or the upper bytes of a or b are
    // all zero, so compare the rest
    i = (aSize > bSize) ? bSize : aSize;
    a = &a[i-1];
    b = &b[i-1];
    for(; i > 0; i--)
    {
        borrow = *a-- - *b-- + borrow;
        notZero = notZero || borrow;
        borrow >>= 8;
    }
    // if there is a borrow, then b > a
    if(borrow)
        return -1;
    // either a > b or they are the same
    return notZero;
}
//
//
//           _math__Comp()
//
//      Compare two signed integers:
//
//      Return Value                    Meaning
//
//      1                               if a > b
//      0                               if a = b
//      -1                              if a < b
//
LIB_EXPORT int
_math__Comp(
    const   UINT32     aSize,                //   IN:   size of a
    const   BYTE      *a,                    //   IN:   a buffer
    const   UINT32     bSize,                //   IN:   size of b
    const   BYTE      *b                     //   IN:   b buffer
    )
{
    int        signA, signB;              // sign of a and b
    // For positive or 0, sign_a is 1
    // for negative, sign_a is 0
    signA = ((a[0] & 0x80) == 0) ? 1 : 0;
    // For positive or 0, sign_b is 1
    // for negative, sign_b is 0
   signB = ((b[0] & 0x80) == 0) ? 1 : 0;
   if(signA != signB)
   {
       return signA - signB;
   }
   if(signA == 1)
       // do unsigned compare function
       return _math__uComp(aSize, a, bSize, b);
   else
       // do unsigned compare the other way
       return 0 - _math__uComp(aSize, a, bSize, b);
}
//
//
//       _math__ModExp
//
//      This function is used to do modular exponentiation in support of RSA. The most typical uses are: c = m^e
//      mod n (RSA encrypt) and m = c^d mod n (RSA decrypt). When doing decryption, the e parameter of the
//      function will contain the private exponent d instead of the public exponent e.
//      If the results will not fit in the provided buffer, an error is returned (CRYPT_ERROR_UNDERFLOW). If
//      the results is smaller than the buffer, the results is de-normalized.
//      This version is intended for use with RSA and requires that m be less than n.
//
//      Return Value                      Meaning
//
//      CRYPT_SUCCESS                     exponentiation succeeded
//      CRYPT_PARAMETER                   number to exponentiate is larger than the modulus
//      CRYPT_UNDERFLOW                   result will not fit into the provided buffer
//
#ifndef EMBEDDED_MODE
LIB_EXPORT CRYPT_RESULT
_math__ModExp(
   UINT32               cSize,                 //   IN: size of the result
   BYTE                *c,                     //   OUT: results buffer
   const UINT32         mSize,                 //   IN: size of number to be exponentiated
   const BYTE          *m,                     //   IN: number to be exponentiated
   const UINT32         eSize,                 //   IN: size of power
   const BYTE          *e,                     //   IN: power
   const UINT32         nSize,                 //   IN: modulus size
   const BYTE          *n                      //   IN: modulu
   )
{
   CRYPT_RESULT         retVal = CRYPT_SUCCESS;
   BN_CTX              *context;
   BIGNUM              *bnC;
   BIGNUM              *bnM;
   BIGNUM              *bnE;
   BIGNUM              *bnN;
   INT32                i;
   context = BN_CTX_new();
   if(context == NULL)
       FAIL(FATAL_ERROR_ALLOCATION);
   BN_CTX_start(context);
   bnC = BN_CTX_get(context);
   bnM = BN_CTX_get(context);
   bnE = BN_CTX_get(context);
   bnN = BN_CTX_get(context);
   // Errors for BN_CTX_get are sticky so only need to check last allocation
   if(bnN == NULL)
         FAIL(FATAL_ERROR_ALLOCATION);
    //convert arguments
    if (    BN_bin2bn(m, mSize, bnM) == NULL
         || BN_bin2bn(e, eSize, bnE) == NULL
         || BN_bin2bn(n, nSize, bnN) == NULL)
             FAIL(FATAL_ERROR_INTERNAL);
    // Don't do exponentiation if the number being exponentiated is
    // larger than the modulus.
    if(BN_ucmp(bnM, bnN) >= 0)
    {
        retVal = CRYPT_PARAMETER;
        goto Cleanup;
    }
    // Perform the exponentiation
    if(!(BN_mod_exp(bnC, bnM, bnE, bnN, context)))
        FAIL(FATAL_ERROR_INTERNAL);
    // Convert the results
    // Make sure that the results will fit in the provided buffer.
    if((unsigned)BN_num_bytes(bnC) > cSize)
    {
        retVal = CRYPT_UNDERFLOW;
        goto Cleanup;
    }
    i = cSize - BN_num_bytes(bnC);
    BN_bn2bin(bnC, &c[i]);
    memset(c, 0, i);
Cleanup:
   // Free up allocated BN values
   BN_CTX_end(context);
   BN_CTX_free(context);
   return retVal;
}
//
//
//       _math__IsPrime()
//
//      Check if an 32-bit integer is a prime.
//
//      Return Value                      Meaning
//
//      TRUE                              if the integer is probably a prime
//      FALSE                             if the integer is definitely not a prime
//
LIB_EXPORT BOOL
_math__IsPrime(
    const UINT32         prime
    )
{
    int       isPrime;
    BIGNUM    *p;
    // Assume the size variables are not overflow, which should not happen in
    // the contexts that this function will be called.
    if((p = BN_new()) == NULL)
        FAIL(FATAL_ERROR_ALLOCATION);
    if(!BN_set_word(p, prime))
        FAIL(FATAL_ERROR_INTERNAL);
    //
    // BN_is_prime returning -1 means that it ran into an error.
//
   // It should only return 0 or 1
   //
   if((isPrime = BN_is_prime_ex(p, BN_prime_checks, NULL, NULL)) < 0)
       FAIL(FATAL_ERROR_INTERNAL);
   if(p != NULL)
       BN_clear_free(p);
   return (isPrime == 1);
}
#endif // ! EMBEDDED_MODE