pka.c File Reference

#include "pka.h"

Macros
#define	MAX(x, y)    (((x) > (y)) ? (x) : (y))
#define	MIN(x, y)    (((x) < (y)) ? (x) : (y))
#define	INRANGE(x, y, z)    ((x) > (y) && (x) < (z))
#define	PKA_MAX_CURVE_SIZE_32_BIT_WORD   12
#define	PKA_MAX_LEN_IN_32_BIT_WORD   PKA_MAX_CURVE_SIZE_32_BIT_WORD
#define	PKA_NO_POINTER_REG   0xFF

Functions
static uint32_t	PKAWritePkaParam (const uint8_t *param, uint32_t paramLength, uint32_t paramOffset, uint32_t ptrRegOffset)
static uint32_t	PKAWritePkaParamExtraOffset (const uint8_t *param, uint32_t paramLength, uint32_t paramOffset, uint32_t ptrRegOffset)
static uint32_t	PKAGetBigNumResult (uint8_t *resultBuf, uint32_t *resultLength, uint32_t resultPKAMemAddr)
static uint32_t	PKAGetBigNumResultRemainder (uint8_t *resultBuf, uint32_t *resultLength, uint32_t resultPKAMemAddr)
static uint32_t	PKAGetECCResult (uint8_t *curvePointX, uint8_t *curvePointY, uint32_t resultPKAMemAddr, uint32_t length)
uint32_t	PKAGetOpsStatus (void)
	Gets the PKA operation status. More...
bool	PKAArrayAllZeros (const uint8_t *array, uint32_t arrayLength)
	Checks whether and array only consists of zeros. More...
void	PKAZeroOutArray (const uint8_t *array, uint32_t arrayLength)
	Zeros-out an array. More...
uint32_t	PKABigNumModStart (const uint8_t *bigNum, uint32_t bigNumLength, const uint8_t *modulus, uint32_t modulusLength, uint32_t *resultPKAMemAddr)
	Starts a big number modulus operation. More...
uint32_t	PKABigNumModGetResult (uint8_t *resultBuf, uint32_t length, uint32_t resultPKAMemAddr)
	Gets the result of the big number modulus operation. More...
uint32_t	PKABigNumDivideStart (const uint8_t *dividend, uint32_t dividendLength, const uint8_t *divisor, uint32_t divisorLength, uint32_t *resultQuotientMemAddr, uint32_t *resultRemainderMemAddr)
	Starts a big number divide operation. More...
uint32_t	PKABigNumDivideGetQuotient (uint8_t *resultBuf, uint32_t *length, uint32_t resultQuotientMemAddr)
	Gets the quotient of the big number divide operation. More...
uint32_t	PKABigNumDivideGetRemainder (uint8_t *resultBuf, uint32_t *length, uint32_t resultQuotientMemAddr)
	Gets the remainder of the big number divide operation. More...
uint32_t	PKABigNumCmpStart (const uint8_t *bigNum1, const uint8_t *bigNum2, uint32_t length)
	Starts the comparison of two big numbers. More...
uint32_t	PKABigNumCmpGetResult (void)
	Gets the result of the comparison operation of two big numbers. More...
uint32_t	PKABigNumInvModStart (const uint8_t *bigNum, uint32_t bigNumLength, const uint8_t *modulus, uint32_t modulusLength, uint32_t *resultPKAMemAddr)
	Starts a big number inverse modulo operation. More...
uint32_t	PKABigNumInvModGetResult (uint8_t *resultBuf, uint32_t length, uint32_t resultPKAMemAddr)
	Gets the result of the big number inverse modulo operation. More...
uint32_t	PKABigNumMultiplyStart (const uint8_t *multiplicand, uint32_t multiplicandLength, const uint8_t *multiplier, uint32_t multiplierLength, uint32_t *resultPKAMemAddr)
	Starts the multiplication of two big numbers. More...
uint32_t	PKABigNumMultGetResult (uint8_t *resultBuf, uint32_t *resultLength, uint32_t resultPKAMemAddr)
	Gets the result of the big number multiplication. More...
uint32_t	PKABigNumAddStart (const uint8_t *bigNum1, uint32_t bigNum1Length, const uint8_t *bigNum2, uint32_t bigNum2Length, uint32_t *resultPKAMemAddr)
	Starts the addition of two big numbers. More...
uint32_t	PKABigNumSubGetResult (uint8_t *resultBuf, uint32_t *resultLength, uint32_t resultPKAMemAddr)
	Gets the result of the subtraction operation on two big numbers. More...
uint32_t	PKABigNumSubStart (const uint8_t *minuend, uint32_t minuendLength, const uint8_t *subtrahend, uint32_t subtrahendLength, uint32_t *resultPKAMemAddr)
	Starts the subtraction of one big number from another. More...
uint32_t	PKABigNumAddGetResult (uint8_t *resultBuf, uint32_t *resultLength, uint32_t resultPKAMemAddr)
	Gets the result of the addition operation on two big numbers. More...
uint32_t	PKAEccMultiplyStart (const uint8_t *scalar, const uint8_t *curvePointX, const uint8_t *curvePointY, const uint8_t *prime, const uint8_t *a, const uint8_t *b, uint32_t length, uint32_t *resultPKAMemAddr)
	Starts ECC multiplication. More...
uint32_t	PKAEccMontgomeryMultiplyStart (const uint8_t *scalar, const uint8_t *curvePointX, const uint8_t *prime, const uint8_t *a, uint32_t length, uint32_t *resultPKAMemAddr)
	Starts ECC Montgomery multiplication. More...
uint32_t	PKAEccMultiplyGetResult (uint8_t *curvePointX, uint8_t *curvePointY, uint32_t resultPKAMemAddr, uint32_t length)
	Gets the result of ECC multiplication. More...
uint32_t	PKAEccAddStart (const uint8_t *curvePoint1X, const uint8_t *curvePoint1Y, const uint8_t *curvePoint2X, const uint8_t *curvePoint2Y, const uint8_t *prime, const uint8_t *a, uint32_t length, uint32_t *resultPKAMemAddr)
	Starts the ECC addition. More...
uint32_t	PKAEccAddGetResult (uint8_t *curvePointX, uint8_t *curvePointY, uint32_t resultPKAMemAddr, uint32_t length)
	Gets the result of the ECC addition. More...
uint32_t	PKAEccVerifyPublicKeyWeierstrassStart (const uint8_t *curvePointX, const uint8_t *curvePointY, const uint8_t *prime, const uint8_t *a, const uint8_t *b, const uint8_t *order, uint32_t length)
	Begins the validation of a public key against a Short-Weierstrass curve. More...

Variables
const PKA_EccPoint224	NISTP224_generator
	X coordinate of the generator point of the NISTP224 curve. More...
const PKA_EccParam224	NISTP224_prime
	Prime of the NISTP224 curve. More...
const PKA_EccParam224	NISTP224_a
	a constant of the NISTP224 curve when expressed in short Weierstrass form (y^3 = x^2 + a*x + b). More...
const PKA_EccParam224	NISTP224_b
	b constant of the NISTP224 curve when expressed in short Weierstrass form (y^3 = x^2 + a*x + b). More...
const PKA_EccParam224	NISTP224_order
	Order of the NISTP224 curve. More...
const PKA_EccPoint256	NISTP256_generator
	X coordinate of the generator point of the NISTP256 curve. More...
const PKA_EccParam256	NISTP256_prime
	Prime of the NISTP256 curve. More...
const PKA_EccParam256	NISTP256_a
	a constant of the NISTP256 curve when expressed in short Weierstrass form (y^3 = x^2 + a*x + b). More...
const PKA_EccParam256	NISTP256_b
	b constant of the NISTP256 curve when expressed in short Weierstrass form (y^3 = x^2 + a*x + b). More...
const PKA_EccParam256	NISTP256_order
	Order of the NISTP256 curve. More...
const PKA_EccPoint384	NISTP384_generator
	X coordinate of the generator point of the NISTP384 curve. More...
const PKA_EccParam384	NISTP384_prime
	Prime of the NISTP384 curve. More...
const PKA_EccParam384	NISTP384_a
	a constant of the NISTP384 curve when expressed in short Weierstrass form (y^3 = x^2 + a*x + b). More...
const PKA_EccParam384	NISTP384_b
	b constant of the NISTP384 curve when expressed in short Weierstrass form (y^3 = x^2 + a*x + b). More...
const PKA_EccParam384	NISTP384_order
	Order of the NISTP384 curve. More...
const PKA_EccPoint521	NISTP521_generator
	X coordinate of the generator point of the NISTP521 curve. More...
const PKA_EccParam521	NISTP521_prime
	Prime of the NISTP521 curve. More...
const PKA_EccParam521	NISTP521_a
	a constant of the NISTP521 curve when expressed in short Weierstrass form (y^3 = x^2 + a*x + b). More...
const PKA_EccParam521	NISTP521_b
	b constant of the NISTP521 curve when expressed in short Weierstrass form (y^3 = x^2 + a*x + b). More...
const PKA_EccParam521	NISTP521_order
	Order of the NISTP521 curve. More...
const PKA_EccPoint256	BrainpoolP256R1_generator
	X coordinate of the generator point of the BrainpoolP256R1 curve. More...
const PKA_EccParam256	BrainpoolP256R1_prime
	Prime of the BrainpoolP256R1 curve. More...
const PKA_EccParam256	BrainpoolP256R1_a
	a constant of the BrainpoolP256R1 curve when expressed in short Weierstrass form (y^3 = x^2 + a*x + b). More...
const PKA_EccParam256	BrainpoolP256R1_b
	b constant of the BrainpoolP256R1 curve when expressed in short Weierstrass form (y^3 = x^2 + a*x + b). More...
const PKA_EccParam256	BrainpoolP256R1_order
	Order of the BrainpoolP256R1 curve. More...
const PKA_EccPoint384	BrainpoolP384R1_generator
	X coordinate of the generator point of the BrainpoolP384R1 curve. More...
const PKA_EccParam384	BrainpoolP384R1_prime
	Prime of the BrainpoolP384R1 curve. More...
const PKA_EccParam384	BrainpoolP384R1_a
	a constant of the BrainpoolP384R1 curve when expressed in short Weierstrass form (y^3 = x^2 + a*x + b). More...
const PKA_EccParam384	BrainpoolP384R1_b
	b constant of the BrainpoolP384R1 curve when expressed in short Weierstrass form (y^3 = x^2 + a*x + b). More...
const PKA_EccParam384	BrainpoolP384R1_order
	Order of the BrainpoolP384R1 curve. More...
const PKA_EccPoint512	BrainpoolP512R1_generator
	X coordinate of the generator point of the BrainpoolP512R1 curve. More...
const PKA_EccParam512	BrainpoolP512R1_prime
	Prime of the BrainpoolP512R1 curve. More...
const PKA_EccParam512	BrainpoolP512R1_a
	a constant of the BrainpoolP512R1 curve when expressed in short Weierstrass form (y^3 = x^2 + a*x + b). More...
const PKA_EccParam512	BrainpoolP512R1_b
	b constant of the BrainpoolP512R1 curve when expressed in short Weierstrass form (y^3 = x^2 + a*x + b). More...
const PKA_EccParam512	BrainpoolP512R1_order
	Order of the BrainpoolP512R1 curve. More...
const PKA_EccPoint256	Curve25519_generator
	X coordinate of the generator point of the Curve25519 curve. More...
const PKA_EccParam256	Curve25519_prime
	Prime of the Curve25519 curve. More...
const PKA_EccParam256	Curve25519_a
	a constant of the Curve25519 curve when expressed in Montgomery form (By^2 = x^3 + a*x^2 + x). More...
const PKA_EccParam256	Curve25519_b
	b constant of the Curve25519 curve when expressed in Montgomery form (By^2 = x^3 + a*x^2 + x). More...
const PKA_EccParam256	Curve25519_order
	Order of the Curve25519 curve. More...

Macro Definition Documentation

#define INRANGE	(		x,
			y,
			z
	)		((x) > (y) && (x) < (z))

#define MAX	(		x,
			y
	)		(((x) > (y)) ? (x) : (y))

#define MIN	(		x,
			y
	)		(((x) < (y)) ? (x) : (y))

#define PKA_MAX_CURVE_SIZE_32_BIT_WORD   12

Referenced by PKAEccMontgomeryMultiplyStart(), and PKAEccMultiplyStart().

#define PKA_MAX_LEN_IN_32_BIT_WORD   PKA_MAX_CURVE_SIZE_32_BIT_WORD

#define PKA_NO_POINTER_REG   0xFF

Referenced by PKAEccAddStart(), PKAEccMontgomeryMultiplyStart(), and PKAEccMultiplyStart().

Function Documentation

static uint32_t PKAGetBigNumResult ( uint8_t *  resultBuf, uint32_t *  resultLength, uint32_t  resultPKAMemAddr  )

static

Referenced by PKABigNumAddGetResult(), PKABigNumDivideGetQuotient(), PKABigNumInvModGetResult(), PKABigNumMultGetResult(), and PKABigNumSubGetResult().

{
    uint32_t mswOffset;
    uint32_t lswOffset;
    uint32_t lengthInWords;
    uint32_t i;
    uint32_t *resultWordAlias = (uint32_t *)resultBuf;

    // Check the arguments.
    ASSERT(resultBuf);
    ASSERT((resultPKAMemAddr > PKA_RAM_BASE) &&
           (resultPKAMemAddr < (PKA_RAM_BASE + PKA_RAM_TOT_BYTE_SIZE)));

    // Verify that the operation is complete.
    if (HWREG(PKA_BASE + PKA_O_FUNCTION) & PKA_FUNCTION_RUN) {
        return PKA_STATUS_OPERATION_BUSY;
    }

    // Get the MSW register value.
    mswOffset = HWREG(PKA_BASE + PKA_O_MSW);

    // If the result vector is zero, write back one zero byte so the caller does not need
    // to handle a special error for the perhaps valid result of zero.
    // They will only get the error status if they do not provide a buffer
    if (mswOffset & PKA_MSW_RESULT_IS_ZERO_M) {
        if (resultLength && resultBuf && *resultLength){

            resultBuf[0] = 0;
            *resultLength = 1;

            return PKA_STATUS_SUCCESS;
        }
        else {
            return PKA_STATUS_BUF_UNDERFLOW;
        }
    }

    // Get the length of the result
    mswOffset = ((mswOffset & PKA_MSW_MSW_ADDRESS_M) + 1);
    lswOffset = ((resultPKAMemAddr - PKA_RAM_BASE) >> 2);

    if (mswOffset >= lswOffset) {
        lengthInWords = mswOffset - lswOffset;
    }
    else {
        return PKA_STATUS_RESULT_ADDRESS_INCORRECT;
    }

    // Check if the provided buffer length is adequate to store the result data.
    if (resultLength && (*resultLength < lengthInWords * sizeof(uint32_t))) {
        return PKA_STATUS_BUF_UNDERFLOW;
    }

    // Copy the resultant length.
    *resultLength = lengthInWords * sizeof(uint32_t);

    if (resultBuf) {
        // Copy the result into the resultBuf.
        for (i = 0; i < lengthInWords; i++) {
            resultWordAlias[i]= HWREG(resultPKAMemAddr + sizeof(uint32_t) * i);
        }
    }

    return PKA_STATUS_SUCCESS;
}

static uint32_t PKAGetBigNumResultRemainder ( uint8_t *  resultBuf, uint32_t *  resultLength, uint32_t  resultPKAMemAddr  )

static

Referenced by PKABigNumDivideGetRemainder(), and PKABigNumModGetResult().

{
    uint32_t regMSWVal;
    uint32_t lengthInWords;
    uint32_t i;
    uint32_t *resultWordAlias = (uint32_t *)resultBuf;

    // Check the arguments.
    ASSERT(resultBuf);
    ASSERT((resultPKAMemAddr > PKA_RAM_BASE) &&
           (resultPKAMemAddr < (PKA_RAM_BASE + PKA_RAM_TOT_BYTE_SIZE)));

    // Verify that the operation is complete.
    if (HWREG(PKA_BASE + PKA_O_FUNCTION) & PKA_FUNCTION_RUN) {
        return PKA_STATUS_OPERATION_BUSY;
    }

    // Get the MSW register value.
    regMSWVal = HWREG(PKA_BASE + PKA_O_DIVMSW);

    // If the result vector is zero, write back one zero byte so the caller does not need
    // to handle a special error for the perhaps valid result of zero.
    // They will only get the error status if they do not provide a buffer
    if (regMSWVal & PKA_DIVMSW_RESULT_IS_ZERO_M) {
        if (resultLength && resultBuf && *resultLength){

            resultBuf[0] = 0;
            *resultLength = 1;

            return PKA_STATUS_SUCCESS;
        }
        else {
            return PKA_STATUS_BUF_UNDERFLOW;
        }
    }

    // Get the length of the result
    lengthInWords = ((regMSWVal & PKA_DIVMSW_MSW_ADDRESS_M) + 1) - ((resultPKAMemAddr - PKA_RAM_BASE) >> 2);

    // Check if the provided buffer length is adequate to store the result data.
    if (resultLength && (*resultLength < lengthInWords * sizeof(uint32_t))) {
        return PKA_STATUS_BUF_UNDERFLOW;
    }

    // Copy the resultant length.
    *resultLength = lengthInWords * sizeof(uint32_t);


    if (resultBuf) {
        // Copy the result into the resultBuf.
        for (i = 0; i < lengthInWords; i++) {
            resultWordAlias[i] = HWREG(resultPKAMemAddr + sizeof(uint32_t) * i);
        }
    }

    return PKA_STATUS_SUCCESS;
}

static uint32_t PKAGetECCResult ( uint8_t *  curvePointX, uint8_t *  curvePointY, uint32_t  resultPKAMemAddr, uint32_t  length  )

static

Referenced by PKAEccAddGetResult(), and PKAEccMultiplyGetResult().

{
    uint32_t i = 0;
    uint32_t *xWordAlias = (uint32_t *)curvePointX;
    uint32_t *yWordAlias = (uint32_t *)curvePointY;
    uint32_t lengthInWordsCeiling = 0;

    // Check for the arguments.
    ASSERT(curvePoint);
    ASSERT(curvePointX);
    ASSERT(curvePointY);
    ASSERT((resultPKAMemAddr > PKA_RAM_BASE) &&
           (resultPKAMemAddr < (PKA_RAM_BASE + PKA_RAM_TOT_BYTE_SIZE)));

    // Verify that the operation is completed.
    if (HWREG(PKA_BASE + PKA_O_FUNCTION) & PKA_FUNCTION_RUN) {
        return PKA_STATUS_OPERATION_BUSY;
    }

    if (HWREG(PKA_BASE + PKA_O_SHIFT)) {
         return PKA_STATUS_FAILURE;
    }

    // Check to make sure that the result vector is not the point at infinity.
    if (HWREG(PKA_BASE + PKA_O_MSW) & PKA_MSW_RESULT_IS_ZERO) {
        return PKA_STATUS_POINT_AT_INFINITY;
    }

    if (curvePointX != NULL) {
        // Copy the x co-ordinate value of the result from vector D into
        // the curvePoint.
        for (i = 0; i < (length / sizeof(uint32_t)); i++) {
            xWordAlias[i] = HWREG(resultPKAMemAddr + sizeof(uint32_t) * i);
        }

        // If the length is not a word-multiple, fill up a temporary word and copy that in
        // to avoid a bus error.
        if (length % sizeof(uint32_t)) {
            uint32_t temp = 0;
            uint8_t j;

            // Load the entire word line of the coordinate remainder
            temp = HWREG(resultPKAMemAddr + sizeof(uint32_t) * i);

            // Write all remaining bytes to the coordinate
            for (j = 0; j < length % sizeof(uint32_t); j++) {
                curvePointX[i * sizeof(uint32_t) + j] = ((uint8_t *)&temp)[j];
            }

        }
    }

    lengthInWordsCeiling = (length % sizeof(uint32_t)) ? length / sizeof(uint32_t) + 1 : length / sizeof(uint32_t);

    resultPKAMemAddr += sizeof(uint32_t) * (2 + lengthInWordsCeiling + (lengthInWordsCeiling % 2));

    if (curvePointY != NULL) {
        // Copy the y co-ordinate value of the result from vector D into
        // the curvePoint.
        for (i = 0; i < (length / sizeof(uint32_t)); i++) {
            yWordAlias[i] = HWREG(resultPKAMemAddr + sizeof(uint32_t) * i);
        }

        // If the length is not a word-multiple, fill up a temporary word and copy that in
        // to avoid a bus error.
        if (length % sizeof(uint32_t)) {
            uint32_t temp = 0;
            uint8_t j;

            // Load the entire word line of the coordinate remainder
            temp = HWREG(resultPKAMemAddr + sizeof(uint32_t) * i);

            // Write all remaining bytes to the coordinate
            for (j = 0; j < length % sizeof(uint32_t); j++) {
                curvePointY[i * sizeof(uint32_t) + j] = ((uint8_t *)&temp)[j];
            }
        }
    }


    return PKA_STATUS_SUCCESS;
}

static uint32_t PKAWritePkaParam ( const uint8_t *  param, uint32_t  paramLength, uint32_t  paramOffset, uint32_t  ptrRegOffset  )

static

Referenced by PKABigNumAddStart(), PKABigNumCmpStart(), PKABigNumDivideStart(), PKABigNumInvModStart(), PKABigNumModStart(), PKABigNumMultiplyStart(), PKABigNumSubStart(), PKAEccMontgomeryMultiplyStart(), PKAEccMultiplyStart(), and PKAWritePkaParamExtraOffset().

{
    uint32_t i;
    uint32_t *paramWordAlias = (uint32_t *)param;
    // Take the floor of paramLength in 32-bit words
    uint32_t paramLengthInWords = paramLength / sizeof(uint32_t);

    // Only copy data if it is specified. We may wish to simply allocate another buffer and get
    // the required offset.
    if (param) {
        // Load the number in PKA RAM
        for (i = 0; i < paramLengthInWords; i++) {
            HWREG(PKA_RAM_BASE + paramOffset + sizeof(uint32_t) * i) = paramWordAlias[i];
        }

        // If the length is not a word-multiple, fill up a temporary word and copy that in
        // to avoid a bus error. The extra zeros at the end should not matter, as the large
        // number is little-endian and thus has no effect.
        // We could have correctly calculated ceiling(paramLength / sizeof(uint32_t)) above.
        // However, we would not have been able to zero-out the extra few most significant
        // bytes of the most significant word. That would have resulted in doing maths operations
        // on whatever follows param in RAM.
        if (paramLength % sizeof(uint32_t)) {
            uint32_t temp = 0;
            uint8_t j;

            // Load the entire word line of the param remainder
            temp = paramWordAlias[i];

            // Zero-out all bytes beyond the end of the param
            for (j = paramLength % sizeof(uint32_t); j < sizeof(uint32_t); j++) {
                ((uint8_t *)&temp)[j] = 0;
            }

            HWREG(PKA_RAM_BASE + paramOffset + sizeof(uint32_t) * i) = temp;

            // Increment paramLengthInWords since we take the ceiling of length / sizeof(uint32_t)
            paramLengthInWords++;
        }
    }

    // Update the A, B, C, or D pointer with the offset address of the PKA RAM location
    // where the number will be stored.
    switch (ptrRegOffset) {
        case PKA_O_APTR:
            HWREG(PKA_BASE + PKA_O_APTR) = paramOffset >> 2;
            HWREG(PKA_BASE + PKA_O_ALENGTH) = paramLengthInWords;
            break;
        case PKA_O_BPTR:
            HWREG(PKA_BASE + PKA_O_BPTR) = paramOffset >> 2;
            HWREG(PKA_BASE + PKA_O_BLENGTH) = paramLengthInWords;
            break;
        case PKA_O_CPTR:
            HWREG(PKA_BASE + PKA_O_CPTR) = paramOffset >> 2;
            break;
        case PKA_O_DPTR:
            HWREG(PKA_BASE + PKA_O_DPTR) = paramOffset >> 2;
            break;
    }

    // Ensure 8-byte alignment of next parameter.
    // Returns the offset for the next parameter.
    return paramOffset + sizeof(uint32_t) * (paramLengthInWords + (paramLengthInWords % 2));
}

static uint32_t PKAWritePkaParamExtraOffset ( const uint8_t *  param, uint32_t  paramLength, uint32_t  paramOffset, uint32_t  ptrRegOffset  )

static

Referenced by PKABigNumDivideStart(), PKABigNumModStart(), PKAEccAddStart(), PKAEccMontgomeryMultiplyStart(), and PKAEccMultiplyStart().

{
    // Ensure 16-byte alignment.
    return  (sizeof(uint32_t) * 2) + PKAWritePkaParam(param, paramLength, paramOffset, ptrRegOffset);
}

Here is the call graph for this function: