fuquan/allwinner_a64
1
1
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
allwinner_a64/android/external/tpm2/CpriECC.c
August 71b83c22f1 upload android base code part2
2018-08-08 16:14:42 +08:00

2191 lines
83 KiB
C
Raw Permalink Blame History

// 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 "OsslCryptoEngine.h"
#ifdef TPM_ALG_ECC
#include "CpriDataEcc.h"
#include "CpriDataEcc.c"
//
//
// Functions
//
// _cpri__EccStartup()
//
// This function is called at TPM Startup to initialize the crypto units.
// In this implementation, no initialization is performed at startup but a future version may initialize the self-
// test functions here.
//
LIB_EXPORT BOOL
_cpri__EccStartup(
void
)
{
return TRUE;
}
//
//
// _cpri__GetCurveIdByIndex()
//
// This function returns the number of the i-th implemented curve. The normal use would be to call this
// function with i starting at 0. When the i is greater than or equal to the number of implemented curves,
// TPM_ECC_NONE is returned.
//
LIB_EXPORT TPM_ECC_CURVE
_cpri__GetCurveIdByIndex(
UINT16 i
)
{
if(i >= ECC_CURVE_COUNT)
return TPM_ECC_NONE;
return eccCurves[i].curveId;
}
LIB_EXPORT UINT32
_cpri__EccGetCurveCount(
void
)
{
return ECC_CURVE_COUNT;
}
//
//
// _cpri__EccGetParametersByCurveId()
//
// This function returns a pointer to the curve data that is associated with the indicated curveId. If there is no
// curve with the indicated ID, the function returns NULL.
//
//
//
//
// Return Value Meaning
//
// NULL curve with the indicated TPM_ECC_CURVE value is not
// implemented
// non-NULL pointer to the curve data
//
LIB_EXPORT const ECC_CURVE *
_cpri__EccGetParametersByCurveId(
TPM_ECC_CURVE curveId // IN: the curveID
)
{
int i;
for(i = 0; i < ECC_CURVE_COUNT; i++)
{
if(eccCurves[i].curveId == curveId)
return &eccCurves[i];
}
FAIL(FATAL_ERROR_INTERNAL);
return NULL; // Never reached.
}
static const ECC_CURVE_DATA *
GetCurveData(
TPM_ECC_CURVE curveId // IN: the curveID
)
{
const ECC_CURVE *curve = _cpri__EccGetParametersByCurveId(curveId);
return curve->curveData;
}
//
//
// Point2B()
//
// This function makes a TPMS_ECC_POINT from a BIGNUM EC_POINT.
//
static BOOL
Point2B(
EC_GROUP *group, // IN: group for the point
TPMS_ECC_POINT *p, // OUT: receives the converted point
EC_POINT *ecP, // IN: the point to convert
INT16 size, // IN: size of the coordinates
BN_CTX *context // IN: working context
)
{
BIGNUM *bnX;
BIGNUM *bnY;
BN_CTX_start(context);
bnX = BN_CTX_get(context);
bnY = BN_CTX_get(context);
if( bnY == NULL
// Get the coordinate values
|| EC_POINT_get_affine_coordinates_GFp(group, ecP, bnX, bnY, context) != 1
// Convert x
|| (!BnTo2B(&p->x.b, bnX, size))
// Convert y
|| (!BnTo2B(&p->y.b, bnY, size))
)
FAIL(FATAL_ERROR_INTERNAL);
BN_CTX_end(context);
return TRUE;
}
//
//
// EccCurveInit()
//
// This function initializes the OpenSSL() group definition structure
// This function is only used within this file.
// It is a fatal error if groupContext is not provided.
//
// Return Value Meaning
//
// NULL the TPM_ECC_CURVE is not valid
// non-NULL points to a structure in groupContext static EC_GROUP *
//
static EC_GROUP *
EccCurveInit(
TPM_ECC_CURVE curveId, // IN: the ID of the curve
BN_CTX *groupContext // IN: the context in which the group is to be
// created
)
{
const ECC_CURVE_DATA *curveData = GetCurveData(curveId);
EC_GROUP *group = NULL;
EC_POINT *P = NULL;
BN_CTX *context;
BIGNUM *bnP;
BIGNUM *bnA;
BIGNUM *bnB;
BIGNUM *bnX;
BIGNUM *bnY;
BIGNUM *bnN;
BIGNUM *bnH;
int ok = FALSE;
// Context must be provided and curve selector must be valid
pAssert(groupContext != NULL && curveData != NULL);
context = BN_CTX_new();
if(context == NULL)
FAIL(FATAL_ERROR_ALLOCATION);
BN_CTX_start(context);
bnP = BN_CTX_get(context);
bnA = BN_CTX_get(context);
bnB = BN_CTX_get(context);
bnX = BN_CTX_get(context);
bnY = BN_CTX_get(context);
bnN = BN_CTX_get(context);
bnH = BN_CTX_get(context);
if (bnH == NULL)
goto Cleanup;
// Convert the number formats
BnFrom2B(bnP, curveData->p);
BnFrom2B(bnA, curveData->a);
BnFrom2B(bnB, curveData->b);
BnFrom2B(bnX, curveData->x);
BnFrom2B(bnY, curveData->y);
BnFrom2B(bnN, curveData->n);
BnFrom2B(bnH, curveData->h);
// initialize EC group, associate a generator point and initialize the point
// from the parameter data
ok = ( (group = EC_GROUP_new_curve_GFp(bnP, bnA, bnB, groupContext)) != NULL
&& (P = EC_POINT_new(group)) != NULL
&& EC_POINT_set_affine_coordinates_GFp(group, P, bnX, bnY, groupContext)
&& EC_GROUP_set_generator(group, P, bnN, bnH)
);
Cleanup:
if (!ok && group != NULL)
{
EC_GROUP_free(group);
group = NULL;
}
if(P != NULL)
EC_POINT_free(P);
BN_CTX_end(context);
BN_CTX_free(context);
return group;
}
//
//
// PointFrom2B()
//
// This function sets the coordinates of an existing BN Point from a TPMS_ECC_POINT.
//
static EC_POINT *
PointFrom2B(
EC_GROUP *group, // IN: the group for the point
EC_POINT *ecP, // IN: an existing BN point in the group
TPMS_ECC_POINT *p, // IN: the 2B coordinates of the point
BN_CTX *context // IN: the BIGNUM context
)
{
BIGNUM *bnX;
BIGNUM *bnY;
// If the point is not allocated then just return a NULL
if(ecP == NULL)
return NULL;
BN_CTX_start(context);
bnX = BN_CTX_get(context);
bnY = BN_CTX_get(context);
if( // Set the coordinates of the point
bnY == NULL
|| BN_bin2bn(p->x.t.buffer, p->x.t.size, bnX) == NULL
|| BN_bin2bn(p->y.t.buffer, p->y.t.size, bnY) == NULL
|| !EC_POINT_set_affine_coordinates_GFp(group, ecP, bnX, bnY, context)
)
FAIL(FATAL_ERROR_INTERNAL);
BN_CTX_end(context);
return ecP;
}
//
//
// EccInitPoint2B()
//
// This function allocates a point in the provided group and initializes it with the values in a
// TPMS_ECC_POINT.
//
static EC_POINT *
EccInitPoint2B(
EC_GROUP *group, // IN: group for the point
TPMS_ECC_POINT *p, // IN: the coordinates for the point
BN_CTX *context // IN: the BIGNUM context
)
{
EC_POINT *ecP;
BN_CTX_start(context);
ecP = EC_POINT_new(group);
if(PointFrom2B(group, ecP, p, context) == NULL)
FAIL(FATAL_ERROR_INTERNAL);
BN_CTX_end(context);
return ecP;
}
//
//
// PointMul()
//
// This function does a point multiply and checks for the result being the point at infinity. Q = ([A]G + [B]P)
//
// Return Value Meaning
//
// CRYPT_NO_RESULT point is at infinity
// CRYPT_SUCCESS point not at infinity
//
static CRYPT_RESULT
PointMul(
EC_GROUP *group, // IN: group curve
EC_POINT *ecpQ, // OUT: result
BIGNUM *bnA, // IN: scalar for [A]G
EC_POINT *ecpP, // IN: point for [B]P
BIGNUM *bnB, // IN: scalar for [B]P
BN_CTX *context // IN: working context
)
{
if(EC_POINT_mul(group, ecpQ, bnA, ecpP, bnB, context) != 1)
FAIL(FATAL_ERROR_INTERNAL);
if(EC_POINT_is_at_infinity(group, ecpQ))
return CRYPT_NO_RESULT;
return CRYPT_SUCCESS;
}
//
//
// GetRandomPrivate()
//
// This function gets a random value (d) to use as a private ECC key and then qualifies the key so that it is
// between 0 < d < n.
// It is a fatal error if dOut or pIn is not provided or if the size of pIn is larger than MAX_ECC_KEY_BYTES
// (the largest buffer size of a TPM2B_ECC_PARAMETER)
//
static void
GetRandomPrivate(
TPM2B_ECC_PARAMETER *dOut, // OUT: the qualified random value
const TPM2B *pIn // IN: the maximum value for the key
)
{
int i;
BYTE *pb;
pAssert(pIn != NULL && dOut != NULL && pIn->size <= MAX_ECC_KEY_BYTES);
// Set the size of the output
dOut->t.size = pIn->size;
// Get some random bits
while(TRUE)
{
_cpri__GenerateRandom(dOut->t.size, dOut->t.buffer);
// See if the d < n
if(memcmp(dOut->t.buffer, pIn->buffer, pIn->size) < 0)
{
// dOut < n so make sure that 0 < dOut
for(pb = dOut->t.buffer, i = dOut->t.size; i > 0; i--)
{
if(*pb++ != 0)
return;
}
}
}
}
//
//
// _cpri__EccPointMultiply
//
// This function computes 'R := [dIn]G + [uIn]QIn. Where dIn and uIn are scalars, G and QIn are points on
// the specified curve and G is the default generator of the curve.
// The xOut and yOut parameters are optional and may be set to NULL if not used.
// It is not necessary to provide uIn if QIn is specified but one of uIn and dIn must be provided. If dIn and
// QIn are specified but uIn is not provided, then R = [dIn]QIn.
// If the multiply produces the point at infinity, the CRYPT_NO_RESULT is returned.
// The sizes of xOut and yOut' will be set to be the size of the degree of the curve
// It is a fatal error if dIn and uIn are both unspecified (NULL) or if Qin or Rout is unspecified.
//
//
//
//
// Return Value Meaning
//
// CRYPT_SUCCESS point multiplication succeeded
// CRYPT_POINT the point Qin is not on the curve
// CRYPT_NO_RESULT the product point is at infinity
//
LIB_EXPORT CRYPT_RESULT
_cpri__EccPointMultiply(
TPMS_ECC_POINT *Rout, // OUT: the product point R
TPM_ECC_CURVE curveId, // IN: the curve to use
TPM2B_ECC_PARAMETER *dIn, // IN: value to multiply against the
// curve generator
TPMS_ECC_POINT *Qin, // IN: point Q
TPM2B_ECC_PARAMETER *uIn // IN: scalar value for the multiplier
// of Q
)
{
BN_CTX *context;
BIGNUM *bnD;
BIGNUM *bnU;
EC_GROUP *group;
EC_POINT *R = NULL;
EC_POINT *Q = NULL;
CRYPT_RESULT retVal = CRYPT_SUCCESS;
// Validate that the required parameters are provided.
pAssert((dIn != NULL || uIn != NULL) && (Qin != NULL || dIn != NULL));
// If a point is provided for the multiply, make sure that it is on the curve
if(Qin != NULL && !_cpri__EccIsPointOnCurve(curveId, Qin))
return CRYPT_POINT;
context = BN_CTX_new();
if(context == NULL)
FAIL(FATAL_ERROR_ALLOCATION);
BN_CTX_start(context);
bnU = BN_CTX_get(context);
bnD = BN_CTX_get(context);
group = EccCurveInit(curveId, context);
// There should be no path for getting a bad curve ID into this function.
pAssert(group != NULL);
// check allocations should have worked and allocate R
if( bnD == NULL
|| (R = EC_POINT_new(group)) == NULL)
FAIL(FATAL_ERROR_ALLOCATION);
// If Qin is present, create the point
if(Qin != NULL)
{
// Assume the size variables do not overflow. This should not happen in
// the contexts in which this function will be called.
assert2Bsize(Qin->x.t);
assert2Bsize(Qin->x.t);
Q = EccInitPoint2B(group, Qin, context);
}
if(dIn != NULL)
{
// Assume the size variables do not overflow, which should not happen in
// the contexts that this function will be called.
assert2Bsize(dIn->t);
BnFrom2B(bnD, &dIn->b);
}
else
bnD = NULL;
// If uIn is specified, initialize its BIGNUM
if(uIn != NULL)
{
// Assume the size variables do not overflow, which should not happen in
// the contexts that this function will be called.
assert2Bsize(uIn->t);
BnFrom2B(bnU, &uIn->b);
}
// If uIn is not specified but Q is, then we are going to
// do R = [d]Q
else if(Qin != NULL)
{
bnU = bnD;
bnD = NULL;
}
// If neither Q nor u is specified, then null this pointer
else
bnU = NULL;
// Use the generator of the curve
if((retVal = PointMul(group, R, bnD, Q, bnU, context)) == CRYPT_SUCCESS)
Point2B(group, Rout, R, (INT16) ((EC_GROUP_get_degree(group)+7)/8), context);
if (Q)
EC_POINT_free(Q);
if(R)
EC_POINT_free(R);
if(group)
EC_GROUP_free(group);
BN_CTX_end(context);
BN_CTX_free(context);
return retVal;
}
#if defined TPM_ALG_ECDAA || defined TPM_ALG_SM2 //%
//
//
// ClearPoint2B()
//
// Initialize the size values of a point
//
static void
ClearPoint2B(
TPMS_ECC_POINT *p // IN: the point
)
{
if(p != NULL) {
p->x.t.size = 0;
p->y.t.size = 0;
}
}
//
//
// _cpri__EccCommitCompute()
//
// This function performs the point multiply operations required by TPM2_Commit().
// If B or M is provided, they must be on the curve defined by curveId. This routine does not check that they
// are on the curve and results are unpredictable if they are not.
//
//
//
// It is a fatal error if r or d is NULL. If B is not NULL, then it is a fatal error if K and L are both NULL. If M is
// not NULL, then it is a fatal error if E is NULL.
//
// Return Value Meaning
//
// CRYPT_SUCCESS computations completed normally
// CRYPT_NO_RESULT if K, L or E was computed to be the point at infinity
// CRYPT_CANCEL a cancel indication was asserted during this function
//
LIB_EXPORT CRYPT_RESULT
_cpri__EccCommitCompute(
TPMS_ECC_POINT *K, // OUT: [d]B or [r]Q
TPMS_ECC_POINT *L, // OUT: [r]B
TPMS_ECC_POINT *E, // OUT: [r]M
TPM_ECC_CURVE curveId, // IN: the curve for the computations
TPMS_ECC_POINT *M, // IN: M (optional)
TPMS_ECC_POINT *B, // IN: B (optional)
TPM2B_ECC_PARAMETER *d, // IN: d (required)
TPM2B_ECC_PARAMETER *r // IN: the computed r value (required)
)
{
BN_CTX *context;
BIGNUM *bnY, *bnR, *bnD;
EC_GROUP *group;
EC_POINT *pK = NULL, *pL = NULL, *pE = NULL, *pM = NULL, *pB = NULL;
UINT16 keySizeInBytes;
CRYPT_RESULT retVal = CRYPT_SUCCESS;
// Validate that the required parameters are provided.
// Note: E has to be provided if computing E := [r]Q or E := [r]M. Will do
// E := [r]Q if both M and B are NULL.
pAssert((r && (K || !B) && (L || !B)) || (E || (!M && B)));
context = BN_CTX_new();
if(context == NULL)
FAIL(FATAL_ERROR_ALLOCATION);
BN_CTX_start(context);
bnR = BN_CTX_get(context);
bnD = BN_CTX_get(context);
bnY = BN_CTX_get(context);
if(bnY == NULL)
FAIL(FATAL_ERROR_ALLOCATION);
// Initialize the output points in case they are not computed
ClearPoint2B(K);
ClearPoint2B(L);
ClearPoint2B(E);
if((group = EccCurveInit(curveId, context)) == NULL)
{
retVal = CRYPT_PARAMETER;
goto Cleanup2;
}
keySizeInBytes = (UINT16) ((EC_GROUP_get_degree(group)+7)/8);
// Size of the r parameter may not be zero
pAssert((int) r->t.size > 0);
// Convert scalars to BIGNUM
BnFrom2B(bnR, &r->b);
// If B is provided, compute K=[d]B and L=[r]B
if(B != NULL)
{
// Size of the d parameter may not be zero
pAssert((int) d->t.size > 0);
BnFrom2B(bnD, &d->b);
// Allocate the points to receive the value
if( (pK = EC_POINT_new(group)) == NULL
|| (pL = EC_POINT_new(group)) == NULL)
FAIL(FATAL_ERROR_ALLOCATION);
// need to compute K = [d]B
// Allocate and initialize BIGNUM version of B
pB = EccInitPoint2B(group, B, context);
// do the math for K = [d]B
if((retVal = PointMul(group, pK, NULL, pB, bnD, context)) != CRYPT_SUCCESS)
goto Cleanup;
// Convert BN K to TPM2B K
Point2B(group, K, pK, (INT16)keySizeInBytes, context);
// compute L= [r]B after checking for cancel
if(_plat__IsCanceled())
{
retVal = CRYPT_CANCEL;
goto Cleanup;
}
// compute L = [r]B
if((retVal = PointMul(group, pL, NULL, pB, bnR, context)) != CRYPT_SUCCESS)
goto Cleanup;
// Convert BN L to TPM2B L
Point2B(group, L, pL, (INT16)keySizeInBytes, context);
}
if(M != NULL || B == NULL)
{
// if this is the third point multiply, check for cancel first
if(B != NULL && _plat__IsCanceled())
{
retVal = CRYPT_CANCEL;
goto Cleanup;
}
// Allocate E
if((pE = EC_POINT_new(group)) == NULL)
FAIL(FATAL_ERROR_ALLOCATION);
// Create BIGNUM version of M unless M is NULL
if(M != NULL)
{
// M provided so initialize a BIGNUM M and compute E = [r]M
pM = EccInitPoint2B(group, M, context);
retVal = PointMul(group, pE, NULL, pM, bnR, context);
}
else
// compute E = [r]G (this is only done if M and B are both NULL
retVal = PointMul(group, pE, bnR, NULL, NULL, context);
if(retVal == CRYPT_SUCCESS)
// Convert E to 2B format
Point2B(group, E, pE, (INT16)keySizeInBytes, context);
}
Cleanup:
EC_GROUP_free(group);
if(pK != NULL) EC_POINT_free(pK);
if(pL != NULL) EC_POINT_free(pL);
if(pE != NULL) EC_POINT_free(pE);
if(pM != NULL) EC_POINT_free(pM);
if(pB != NULL) EC_POINT_free(pB);
Cleanup2:
BN_CTX_end(context);
BN_CTX_free(context);
return retVal;
}
#endif //%
//
//
// _cpri__EccIsPointOnCurve()
//
// This function is used to test if a point is on a defined curve. It does this by checking that y^2 mod p = x^3
// + a*x + b mod p
// It is a fatal error if Q is not specified (is NULL).
//
// Return Value Meaning
//
// TRUE point is on curve
// FALSE point is not on curve or curve is not supported
//
LIB_EXPORT BOOL
_cpri__EccIsPointOnCurve(
TPM_ECC_CURVE curveId, // IN: the curve selector
TPMS_ECC_POINT *Q // IN: the point.
)
{
BN_CTX *context;
BIGNUM *bnX;
BIGNUM *bnY;
BIGNUM *bnA;
BIGNUM *bnB;
BIGNUM *bnP;
BIGNUM *bn3;
const ECC_CURVE_DATA *curveData = GetCurveData(curveId);
BOOL retVal;
pAssert(Q != NULL && curveData != NULL);
if((context = BN_CTX_new()) == NULL)
FAIL(FATAL_ERROR_ALLOCATION);
BN_CTX_start(context);
bnX = BN_CTX_get(context);
bnY = BN_CTX_get(context);
bnA = BN_CTX_get(context);
bnB = BN_CTX_get(context);
bn3 = BN_CTX_get(context);
bnP = BN_CTX_get(context);
if(bnP == NULL)
FAIL(FATAL_ERROR_ALLOCATION);
// Convert values
if ( !BN_bin2bn(Q->x.t.buffer, Q->x.t.size, bnX)
|| !BN_bin2bn(Q->y.t.buffer, Q->y.t.size, bnY)
|| !BN_bin2bn(curveData->p->buffer, curveData->p->size, bnP)
|| !BN_bin2bn(curveData->a->buffer, curveData->a->size, bnA)
|| !BN_set_word(bn3, 3)
|| !BN_bin2bn(curveData->b->buffer, curveData->b->size, bnB)
)
FAIL(FATAL_ERROR_INTERNAL);
// The following sequence is probably not optimal but it seems to be correct.
// compute x^3 + a*x + b mod p
// first, compute a*x mod p
if( !BN_mod_mul(bnA, bnA, bnX, bnP, context)
//
// next, compute a*x + b mod p
|| !BN_mod_add(bnA, bnA, bnB, bnP, context)
// next, compute X^3 mod p
|| !BN_mod_exp(bnX, bnX, bn3, bnP, context)
// finally, compute x^3 + a*x + b mod p
|| !BN_mod_add(bnX, bnX, bnA, bnP, context)
// then compute y^2
|| !BN_mod_mul(bnY, bnY, bnY, bnP, context)
)
FAIL(FATAL_ERROR_INTERNAL);
retVal = BN_cmp(bnX, bnY) == 0;
BN_CTX_end(context);
BN_CTX_free(context);
return retVal;
}
//
//
// _cpri__GenerateKeyEcc()
//
// This function generates an ECC key pair based on the input parameters. This routine uses KDFa() to
// produce candidate numbers. The method is according to FIPS 186-3, section B.4.1 "GKey() Pair
// Generation Using Extra Random Bits." According to the method in FIPS 186-3, the resulting private value
// d should be 1 <= d < n where n is the order of the base point. In this implementation, the range of the
// private value is further restricted to be 2^(nLen/2) <= d < n where nLen is the order of n.
//
// EXAMPLE: If the curve is NIST-P256, then nLen is 256 bits and d will need to be between 2^128 <= d < n
//
// It is a fatal error if Qout, dOut, or seed is not provided (is NULL).
//
// Return Value Meaning
//
// CRYPT_PARAMETER the hash algorithm is not supported
//
LIB_EXPORT CRYPT_RESULT
_cpri__GenerateKeyEcc(
TPMS_ECC_POINT *Qout, // OUT: the public point
TPM2B_ECC_PARAMETER *dOut, // OUT: the private scalar
TPM_ECC_CURVE curveId, // IN: the curve identifier
TPM_ALG_ID hashAlg, // IN: hash algorithm to use in the key
// generation process
TPM2B *seed, // IN: the seed to use
const char *label, // IN: A label for the generation
// process.
TPM2B *extra, // IN: Party 1 data for the KDF
UINT32 *counter // IN/OUT: Counter value to allow KDF
// iteration to be propagated across
// multiple functions
)
{
const ECC_CURVE_DATA *curveData = GetCurveData(curveId);
INT16 keySizeInBytes;
UINT32 count = 0;
CRYPT_RESULT retVal;
UINT16 hLen = _cpri__GetDigestSize(hashAlg);
BIGNUM *bnNm1; // Order of the curve minus one
BIGNUM *bnD; // the private scalar
BN_CTX *context; // the context for the BIGNUM values
BYTE withExtra[MAX_ECC_KEY_BYTES + 8]; // trial key with
//extra bits
TPM2B_4_BYTE_VALUE marshaledCounter = {.t = {4}};
UINT32 totalBits;
// Validate parameters (these are fatal)
pAssert( seed != NULL && dOut != NULL && Qout != NULL && curveData != NULL);
// Non-fatal parameter checks.
if(hLen <= 0)
return CRYPT_PARAMETER;
// allocate the local BN values
context = BN_CTX_new();
if(context == NULL)
FAIL(FATAL_ERROR_ALLOCATION);
BN_CTX_start(context);
bnNm1 = BN_CTX_get(context);
bnD = BN_CTX_get(context);
// The size of the input scalars is limited by the size of the size of a
// TPM2B_ECC_PARAMETER. Make sure that it is not irrational.
pAssert((int) curveData->n->size <= MAX_ECC_KEY_BYTES);
if( bnD == NULL
|| BN_bin2bn(curveData->n->buffer, curveData->n->size, bnNm1) == NULL
|| (keySizeInBytes = (INT16) BN_num_bytes(bnNm1)) > MAX_ECC_KEY_BYTES)
FAIL(FATAL_ERROR_INTERNAL);
// get the total number of bits
totalBits = BN_num_bits(bnNm1) + 64;
// Reduce bnNm1 from 'n' to 'n' - 1
BN_sub_word(bnNm1, 1);
// Initialize the count value
if(counter != NULL)
count = *counter;
if(count == 0)
count = 1;
// Start search for key (should be quick)
for(; count != 0; count++)
{
UINT32_TO_BYTE_ARRAY(count, marshaledCounter.t.buffer);
_cpri__KDFa(hashAlg, seed, label, extra, &marshaledCounter.b,
totalBits, withExtra, NULL, FALSE);
// Convert the result and modular reduce
// Assume the size variables do not overflow, which should not happen in
// the contexts that this function will be called.
pAssert(keySizeInBytes <= MAX_ECC_KEY_BYTES);
if ( BN_bin2bn(withExtra, keySizeInBytes+8, bnD) == NULL
|| BN_mod(bnD, bnD, bnNm1, context) != 1)
FAIL(FATAL_ERROR_INTERNAL);
// Add one to get 0 < d < n
BN_add_word(bnD, 1);
if(BnTo2B(&dOut->b, bnD, keySizeInBytes) != 1)
FAIL(FATAL_ERROR_INTERNAL);
// Do the point multiply to create the public portion of the key. If
// the multiply generates the point at infinity (unlikely), do another
// iteration.
if( (retVal = _cpri__EccPointMultiply(Qout, curveId, dOut, NULL, NULL))
!= CRYPT_NO_RESULT)
break;
}
if(count == 0) // if counter wrapped, then the TPM should go into failure mode
FAIL(FATAL_ERROR_INTERNAL);
// Free up allocated BN values
BN_CTX_end(context);
BN_CTX_free(context);
if(counter != NULL)
*counter = count;
return retVal;
}
//
//
// _cpri__GetEphemeralEcc()
//
// This function creates an ephemeral ECC. It is ephemeral in that is expected that the private part of the
// key will be discarded
//
LIB_EXPORT CRYPT_RESULT
_cpri__GetEphemeralEcc(
TPMS_ECC_POINT *Qout, // OUT: the public point
TPM2B_ECC_PARAMETER *dOut, // OUT: the private scalar
TPM_ECC_CURVE curveId // IN: the curve for the key
)
{
CRYPT_RESULT retVal;
const ECC_CURVE_DATA *curveData = GetCurveData(curveId);
pAssert(curveData != NULL);
// Keep getting random values until one is found that doesn't create a point
// at infinity. This will never, ever, ever, ever, ever, happen but if it does
// we have to get a next random value.
while(TRUE)
{
GetRandomPrivate(dOut, curveData->p);
// _cpri__EccPointMultiply does not return CRYPT_ECC_POINT if no point is
// provided. CRYPT_PARAMTER should not be returned because the curve ID
// has to be supported. Thus the only possible error is CRYPT_NO_RESULT.
retVal = _cpri__EccPointMultiply(Qout, curveId, dOut, NULL, NULL);
if(retVal != CRYPT_NO_RESULT)
return retVal; // Will return CRYPT_SUCCESS
}
}
#ifdef TPM_ALG_ECDSA //%
//
//
// SignEcdsa()
//
// This function implements the ECDSA signing algorithm. The method is described in the comments below.
// It is a fatal error if rOut, sOut, dIn, or digest are not provided.
//
LIB_EXPORT CRYPT_RESULT
SignEcdsa(
TPM2B_ECC_PARAMETER *rOut, // OUT: r component of the signature
TPM2B_ECC_PARAMETER *sOut, // OUT: s component of the signature
TPM_ECC_CURVE curveId, // IN: the curve used in the signature
// process
TPM2B_ECC_PARAMETER *dIn, // IN: the private key
TPM2B *digest // IN: the value to sign
)
{
BIGNUM *bnK;
BIGNUM *bnIk;
BIGNUM *bnN;
BIGNUM *bnR;
//
BIGNUM *bnD;
BIGNUM *bnZ;
TPM2B_ECC_PARAMETER k;
TPMS_ECC_POINT R;
BN_CTX *context;
CRYPT_RESULT retVal = CRYPT_SUCCESS;
const ECC_CURVE_DATA *curveData = GetCurveData(curveId);
pAssert(rOut != NULL && sOut != NULL && dIn != NULL && digest != NULL);
context = BN_CTX_new();
if(context == NULL)
FAIL(FATAL_ERROR_ALLOCATION);
BN_CTX_start(context);
bnN = BN_CTX_get(context);
bnZ = BN_CTX_get(context);
bnR = BN_CTX_get(context);
bnD = BN_CTX_get(context);
bnIk = BN_CTX_get(context);
bnK = BN_CTX_get(context);
// Assume the size variables do not overflow, which should not happen in
// the contexts that this function will be called.
pAssert(curveData->n->size <= MAX_ECC_PARAMETER_BYTES);
if( bnK == NULL
|| BN_bin2bn(curveData->n->buffer, curveData->n->size, bnN) == NULL)
FAIL(FATAL_ERROR_INTERNAL);
// The algorithm as described in "Suite B Implementer's Guide to FIPS 186-3(ECDSA)"
// 1. Use one of the routines in Appendix A.2 to generate (k, k^-1), a per-message
// secret number and its inverse modulo n. Since n is prime, the
// output will be invalid only if there is a failure in the RBG.
// 2. Compute the elliptic curve point R = [k]G = (xR, yR) using EC scalar
// multiplication (see [Routines]), where G is the base point included in
// the set of domain parameters.
// 3. Compute r = xR mod n. If r = 0, then return to Step 1. 1.
// 4. Use the selected hash function to compute H = Hash(M).
// 5. Convert the bit string H to an integer e as described in Appendix B.2.
// 6. Compute s = (k^-1 * (e + d * r)) mod n. If s = 0, return to Step 1.2.
// 7. Return (r, s).
// Generate a random value k in the range 1 <= k < n
// Want a K value that is the same size as the curve order
k.t.size = curveData->n->size;
while(TRUE) // This implements the loop at step 6. If s is zero, start over.
{
while(TRUE)
{
// Step 1 and 2 -- generate an ephemeral key and the modular inverse
// of the private key.
while(TRUE)
{
GetRandomPrivate(&k, curveData->n);
// Do the point multiply to generate a point and check to see if
// the point it at infinity
if( _cpri__EccPointMultiply(&R, curveId, &k, NULL, NULL)
!= CRYPT_NO_RESULT)
break; // can only be CRYPT_SUCCESS
}
// x coordinate is mod p. Make it mod n
// Assume the size variables do not overflow, which should not happen
// in the contexts that this function will be called.
assert2Bsize(R.x.t);
BN_bin2bn(R.x.t.buffer, R.x.t.size, bnR);
BN_mod(bnR, bnR, bnN, context);
// Make sure that it is not zero;
if(BN_is_zero(bnR))
continue;
// Make sure that a modular inverse exists
// Assume the size variables do not overflow, which should not happen
// in the contexts that this function will be called.
assert2Bsize(k.t);
BN_bin2bn(k.t.buffer, k.t.size, bnK);
if( BN_mod_inverse(bnIk, bnK, bnN, context) != NULL)
break;
}
// Set z = leftmost bits of the digest
// NOTE: This is implemented such that the key size needs to be
// an even number of bytes in length.
if(digest->size > curveData->n->size)
{
// Assume the size variables do not overflow, which should not happen
// in the contexts that this function will be called.
pAssert(curveData->n->size <= MAX_ECC_KEY_BYTES);
// digest is larger than n so truncate
BN_bin2bn(digest->buffer, curveData->n->size, bnZ);
}
else
{
// Assume the size variables do not overflow, which should not happen
// in the contexts that this function will be called.
pAssert(digest->size <= MAX_DIGEST_SIZE);
// digest is same or smaller than n so use it all
BN_bin2bn(digest->buffer, digest->size, bnZ);
}
// Assume the size variables do not overflow, which should not happen in
// the contexts that this function will be called.
assert2Bsize(dIn->t);
if( bnZ == NULL
// need the private scalar of the signing key
|| BN_bin2bn(dIn->t.buffer, dIn->t.size, bnD) == NULL)
FAIL(FATAL_ERROR_INTERNAL);
// NOTE: When the result of an operation is going to be reduced mod x
// any modular multiplication is done so that the intermediate values
// don't get too large.
//
// now have inverse of K (bnIk), z (bnZ), r (bnR), d (bnD) and n (bnN)
// Compute s = k^-1 (z + r*d)(mod n)
// first do d = r*d mod n
if( !BN_mod_mul(bnD, bnR, bnD, bnN, context)
// d = z + r * d
|| !BN_add(bnD, bnZ, bnD)
// d = k^(-1)(z + r * d)(mod n)
|| !BN_mod_mul(bnD, bnIk, bnD, bnN, context)
// convert to TPM2B format
|| !BnTo2B(&sOut->b, bnD, curveData->n->size)
// and write the modular reduced version of r
// NOTE: this was deferred to reduce the number of
// error checks.
|| !BnTo2B(&rOut->b, bnR, curveData->n->size))
FAIL(FATAL_ERROR_INTERNAL);
if(!BN_is_zero(bnD))
break; // signature not zero so done
// if the signature value was zero, start over
}
// Free up allocated BN values
BN_CTX_end(context);
BN_CTX_free(context);
return retVal;
}
#endif //%
#if defined TPM_ALG_ECDAA || defined TPM_ALG_ECSCHNORR //%
//
//
// EcDaa()
//
// This function is used to perform a modified Schnorr signature for ECDAA.
// This function performs s = k + T * d mod n where
// a) 'k is a random, or pseudo-random value used in the commit phase
// b) T is the digest to be signed, and
// c) d is a private key.
// If tIn is NULL then use tOut as T
//
// Return Value Meaning
//
// CRYPT_SUCCESS signature created
//
static CRYPT_RESULT
EcDaa(
TPM2B_ECC_PARAMETER *tOut, // OUT: T component of the signature
TPM2B_ECC_PARAMETER *sOut, // OUT: s component of the signature
TPM_ECC_CURVE curveId, // IN: the curve used in signing
TPM2B_ECC_PARAMETER *dIn, // IN: the private key
TPM2B *tIn, // IN: the value to sign
TPM2B_ECC_PARAMETER *kIn // IN: a random value from commit
)
{
BIGNUM *bnN, *bnK, *bnT, *bnD;
BN_CTX *context;
const TPM2B *n;
const ECC_CURVE_DATA *curveData = GetCurveData(curveId);
BOOL OK = TRUE;
// Parameter checks
pAssert( sOut != NULL && dIn != NULL && tOut != NULL
&& kIn != NULL && curveData != NULL);
// this just saves key strokes
n = curveData->n;
if(tIn != NULL)
Copy2B(&tOut->b, tIn);
// The size of dIn and kIn input scalars is limited by the size of the size
// of a TPM2B_ECC_PARAMETER and tIn can be no larger than a digest.
// Make sure they are within range.
pAssert( (int) dIn->t.size <= MAX_ECC_KEY_BYTES
&& (int) kIn->t.size <= MAX_ECC_KEY_BYTES
//
&& (int) tOut->t.size <= MAX_DIGEST_SIZE
);
context = BN_CTX_new();
if(context == NULL)
FAIL(FATAL_ERROR_ALLOCATION);
BN_CTX_start(context);
bnN = BN_CTX_get(context);
bnK = BN_CTX_get(context);
bnT = BN_CTX_get(context);
bnD = BN_CTX_get(context);
// Check for allocation problems
if(bnD == NULL)
FAIL(FATAL_ERROR_ALLOCATION);
// Convert values
if( BN_bin2bn(n->buffer, n->size, bnN) == NULL
|| BN_bin2bn(kIn->t.buffer, kIn->t.size, bnK) == NULL
|| BN_bin2bn(dIn->t.buffer, dIn->t.size, bnD) == NULL
|| BN_bin2bn(tOut->t.buffer, tOut->t.size, bnT) == NULL)
FAIL(FATAL_ERROR_INTERNAL);
// Compute T = T mod n
OK = OK && BN_mod(bnT, bnT, bnN, context);
// compute (s = k + T * d mod n)
// d = T * d mod n
OK = OK && BN_mod_mul(bnD, bnT, bnD, bnN, context) == 1;
// d = k + T * d mod n
OK = OK && BN_mod_add(bnD, bnK, bnD, bnN, context) == 1;
// s = d
OK = OK && BnTo2B(&sOut->b, bnD, n->size);
// r = T
OK = OK && BnTo2B(&tOut->b, bnT, n->size);
if(!OK)
FAIL(FATAL_ERROR_INTERNAL);
// Cleanup
BN_CTX_end(context);
BN_CTX_free(context);
return CRYPT_SUCCESS;
}
#endif //%
#ifdef TPM_ALG_ECSCHNORR //%
//
//
// Mod2B()
//
// Function does modular reduction of TPM2B values.
//
static CRYPT_RESULT
Mod2B(
TPM2B *x, // IN/OUT: value to reduce
const TPM2B *n // IN: mod
)
{
int compare;
compare = _math__uComp(x->size, x->buffer, n->size, n->buffer);
if(compare < 0)
// if x < n, then mod is x
return CRYPT_SUCCESS;
if(compare == 0)
{
// if x == n then mod is 0
x->size = 0;
x->buffer[0] = 0;
return CRYPT_SUCCESS;
}
return _math__Div(x, n, NULL, x);
}
//
//
// SchnorrEcc()
//
// This function is used to perform a modified Schnorr signature.
// This function will generate a random value k and compute
// a) (xR, yR) = [k]G
// b) r = hash(P || xR)(mod n)
// c) s= k + r * ds
// d) return the tuple T, s
//
//
//
//
// Return Value Meaning
//
// CRYPT_SUCCESS signature created
// CRYPT_SCHEME hashAlg can't produce zero-length digest
//
static CRYPT_RESULT
SchnorrEcc(
TPM2B_ECC_PARAMETER *rOut, // OUT: r component of the signature
TPM2B_ECC_PARAMETER *sOut, // OUT: s component of the signature
TPM_ALG_ID hashAlg, // IN: hash algorithm used
TPM_ECC_CURVE curveId, // IN: the curve used in signing
TPM2B_ECC_PARAMETER *dIn, // IN: the private key
TPM2B *digest, // IN: the digest to sign
TPM2B_ECC_PARAMETER *kIn // IN: for testing
)
{
TPM2B_ECC_PARAMETER k;
BIGNUM *bnR, *bnN, *bnK, *bnT, *bnD;
BN_CTX *context;
const TPM2B *n;
EC_POINT *pR = NULL;
EC_GROUP *group = NULL;
CPRI_HASH_STATE hashState;
UINT16 digestSize = _cpri__GetDigestSize(hashAlg);
const ECC_CURVE_DATA *curveData = GetCurveData(curveId);
TPM2B_TYPE(T, MAX(MAX_DIGEST_SIZE, MAX_ECC_PARAMETER_BYTES));
TPM2B_T T2b;
BOOL OK = TRUE;
// Parameter checks
// Must have a place for the 'r' and 's' parts of the signature, a private
// key ('d')
pAssert( rOut != NULL && sOut != NULL && dIn != NULL
&& digest != NULL && curveData != NULL);
// to save key strokes
n = curveData->n;
// If the digest does not produce a hash, then null the signature and return
// a failure.
if(digestSize == 0)
{
rOut->t.size = 0;
sOut->t.size = 0;
return CRYPT_SCHEME;
}
// Allocate big number values
context = BN_CTX_new();
if(context == NULL)
FAIL(FATAL_ERROR_ALLOCATION);
BN_CTX_start(context);
bnR = BN_CTX_get(context);
bnN = BN_CTX_get(context);
bnK = BN_CTX_get(context);
bnT = BN_CTX_get(context);
bnD = BN_CTX_get(context);
if( bnD == NULL
// initialize the group parameters
|| (group = EccCurveInit(curveId, context)) == NULL
// allocate a local point
|| (pR = EC_POINT_new(group)) == NULL
)
FAIL(FATAL_ERROR_ALLOCATION);
if(BN_bin2bn(curveData->n->buffer, curveData->n->size, bnN) == NULL)
FAIL(FATAL_ERROR_INTERNAL);
while(OK)
{
// a) set k to a random value such that 1 k n-1
if(kIn != NULL)
{
Copy2B(&k.b, &kIn->b); // copy input k if testing
OK = FALSE; // not OK to loop
}
else
// If get a random value in the correct range
GetRandomPrivate(&k, n);
// Convert 'k' and generate pR = ['k']G
BnFrom2B(bnK, &k.b);
// b) compute E (xE, yE) [k]G
if(PointMul(group, pR, bnK, NULL, NULL, context) == CRYPT_NO_RESULT)
// c) if E is the point at infinity, go to a)
continue;
// d) compute e xE (mod n)
// Get the x coordinate of the point
EC_POINT_get_affine_coordinates_GFp(group, pR, bnR, NULL, context);
// make (mod n)
BN_mod(bnR, bnR, bnN, context);
// e) if e is zero, go to a)
if(BN_is_zero(bnR))
continue;
// Convert xR to a string (use T as a temp)
BnTo2B(&T2b.b, bnR, (UINT16)(BN_num_bits(bnR)+7)/8);
// f) compute r HschemeHash(P || e) (mod n)
_cpri__StartHash(hashAlg, FALSE, &hashState);
_cpri__UpdateHash(&hashState, digest->size, digest->buffer);
_cpri__UpdateHash(&hashState, T2b.t.size, T2b.t.buffer);
if(_cpri__CompleteHash(&hashState, digestSize, T2b.b.buffer) != digestSize)
FAIL(FATAL_ERROR_INTERNAL);
T2b.t.size = digestSize;
BnFrom2B(bnT, &T2b.b);
BN_div(NULL, bnT, bnT, bnN, context);
BnTo2B(&rOut->b, bnT, (UINT16)BN_num_bytes(bnT));
// We have a value and we are going to exit the loop successfully
OK = TRUE;
break;
}
// Cleanup
EC_POINT_free(pR);
EC_GROUP_free(group);
BN_CTX_end(context);
BN_CTX_free(context);
// If we have a value, finish the signature
if(OK)
return EcDaa(rOut, sOut, curveId, dIn, NULL, &k);
else
return CRYPT_NO_RESULT;
}
#endif //%
#ifdef TPM_ALG_SM2 //%
#ifdef _SM2_SIGN_DEBUG //%
static int
cmp_bn2hex(
BIGNUM *bn, // IN: big number value
const char *c // IN: character string number
)
{
int result;
BIGNUM *bnC = BN_new();
pAssert(bnC != NULL);
BN_hex2bn(&bnC, c);
result = BN_ucmp(bn, bnC);
BN_free(bnC);
return result;
}
static int
cmp_2B2hex(
TPM2B *a, // IN: TPM2B number to compare
const char *c // IN: character string
)
{
int result;
int sl = strlen(c);
BIGNUM *bnA;
result = (a->size * 2) - sl;
if(result != 0)
return result;
pAssert((bnA = BN_bin2bn(a->buffer, a->size, NULL)) != NULL);
result = cmp_bn2hex(bnA, c);
BN_free(bnA);
return result;
}
static void
cpy_hexTo2B(
TPM2B *b, // OUT: receives value
const char *c // IN: source string
)
{
BIGNUM *bnB = BN_new();
pAssert((strlen(c) & 1) == 0); // must have an even number of digits
b->size = strlen(c) / 2;
BN_hex2bn(&bnB, c);
pAssert(bnB != NULL);
BnTo2B(b, bnB, b->size);
BN_free(bnB);
}
#endif //% _SM2_SIGN_DEBUG
//
//
// SignSM2()
//
// This function signs a digest using the method defined in SM2 Part 2. The method in the standard will add
// a header to the message to be signed that is a hash of the values that define the key. This then hashed
// with the message to produce a digest (e) that is signed. This function signs e.
//
//
//
//
// Return Value Meaning
//
// CRYPT_SUCCESS sign worked
//
static CRYPT_RESULT
SignSM2(
TPM2B_ECC_PARAMETER *rOut, // OUT: r component of the signature
TPM2B_ECC_PARAMETER *sOut, // OUT: s component of the signature
TPM_ECC_CURVE curveId, // IN: the curve used in signing
TPM2B_ECC_PARAMETER *dIn, // IN: the private key
TPM2B *digest // IN: the digest to sign
)
{
BIGNUM *bnR;
BIGNUM *bnS;
BIGNUM *bnN;
BIGNUM *bnK;
BIGNUM *bnX1;
BIGNUM *bnD;
BIGNUM *bnT; // temp
BIGNUM *bnE;
BN_CTX *context;
TPM2B_ECC_PARAMETER k;
TPMS_ECC_POINT p2Br;
const ECC_CURVE_DATA *curveData = GetCurveData(curveId);
pAssert(curveData != NULL);
context = BN_CTX_new();
BN_CTX_start(context);
bnK = BN_CTX_get(context);
bnR = BN_CTX_get(context);
bnS = BN_CTX_get(context);
bnX1 = BN_CTX_get(context);
bnN = BN_CTX_get(context);
bnD = BN_CTX_get(context);
bnT = BN_CTX_get(context);
bnE = BN_CTX_get(context);
if(bnE == NULL)
FAIL(FATAL_ERROR_ALLOCATION);
BnFrom2B(bnE, digest);
BnFrom2B(bnN, curveData->n);
BnFrom2B(bnD, &dIn->b);
#ifdef _SM2_SIGN_DEBUG
BN_hex2bn(&bnE, "B524F552CD82B8B028476E005C377FB19A87E6FC682D48BB5D42E3D9B9EFFE76");
BN_hex2bn(&bnD, "128B2FA8BD433C6C068C8D803DFF79792A519A55171B1B650C23661D15897263");
#endif
// A3: Use random number generator to generate random number 1 <= k <= n-1;
// NOTE: Ax: numbers are from the SM2 standard
k.t.size = curveData->n->size;
loop:
{
// Get a random number
_cpri__GenerateRandom(k.t.size, k.t.buffer);
#ifdef _SM2_SIGN_DEBUG
BN_hex2bn(&bnK, "6CB28D99385C175C94F94E934817663FC176D925DD72B727260DBAAE1FB2F96F");
BnTo2B(&k.b,bnK, 32);
k.t.size = 32;
#endif
//make sure that the number is 0 < k < n
BnFrom2B(bnK, &k.b);
if( BN_ucmp(bnK, bnN) >= 0
|| BN_is_zero(bnK))
goto loop;
// A4: Figure out the point of elliptic curve (x1, y1)=[k]G, and according
// to details specified in 4.2.7 in Part 1 of this document, transform the
// data type of x1 into an integer;
if( _cpri__EccPointMultiply(&p2Br, curveId, &k, NULL, NULL)
== CRYPT_NO_RESULT)
goto loop;
BnFrom2B(bnX1, &p2Br.x.b);
// A5: Figure out r = (e + x1) mod n,
if(!BN_mod_add(bnR, bnE, bnX1, bnN, context))
FAIL(FATAL_ERROR_INTERNAL);
#ifdef _SM2_SIGN_DEBUG
pAssert(cmp_bn2hex(bnR,
"40F1EC59F793D9F49E09DCEF49130D4194F79FB1EED2CAA55BACDB49C4E755D1")
== 0);
#endif
// if r=0 or r+k=n, return to A3;
if(!BN_add(bnT, bnK, bnR))
FAIL(FATAL_ERROR_INTERNAL);
if(BN_is_zero(bnR) || BN_ucmp(bnT, bnN) == 0)
goto loop;
// A6: Figure out s = ((1 + dA)^-1 (k - r dA)) mod n, if s=0, return to A3;
// compute t = (1+d)-1
BN_copy(bnT, bnD);
if( !BN_add_word(bnT, 1)
|| !BN_mod_inverse(bnT, bnT, bnN, context) // (1 + dA)^-1 mod n
)
FAIL(FATAL_ERROR_INTERNAL);
#ifdef _SM2_SIGN_DEBUG
pAssert(cmp_bn2hex(bnT,
"79BFCF3052C80DA7B939E0C6914A18CBB2D96D8555256E83122743A7D4F5F956")
== 0);
#endif
// compute s = t * (k - r * dA) mod n
if( !BN_mod_mul(bnS, bnD, bnR, bnN, context) // (r * dA) mod n
|| !BN_mod_sub(bnS, bnK, bnS, bnN, context) // (k - (r * dA) mod n
|| !BN_mod_mul(bnS, bnT, bnS, bnN, context))// t * (k - (r * dA) mod n
FAIL(FATAL_ERROR_INTERNAL);
#ifdef _SM2_SIGN_DEBUG
pAssert(cmp_bn2hex(bnS,
"6FC6DAC32C5D5CF10C77DFB20F7C2EB667A457872FB09EC56327A67EC7DEEBE7")
== 0);
#endif
if(BN_is_zero(bnS))
goto loop;
}
// A7: According to details specified in 4.2.1 in Part 1 of this document, transform
// the data type of r, s into bit strings, signature of message M is (r, s).
BnTo2B(&rOut->b, bnR, curveData->n->size);
BnTo2B(&sOut->b, bnS, curveData->n->size);
#ifdef _SM2_SIGN_DEBUG
pAssert(cmp_2B2hex(&rOut->b,
"40F1EC59F793D9F49E09DCEF49130D4194F79FB1EED2CAA55BACDB49C4E755D1")
== 0);
pAssert(cmp_2B2hex(&sOut->b,
"6FC6DAC32C5D5CF10C77DFB20F7C2EB667A457872FB09EC56327A67EC7DEEBE7")
== 0);
#endif
BN_CTX_end(context);
BN_CTX_free(context);
return CRYPT_SUCCESS;
}
#endif //% TPM_ALG_SM2
//
//
// _cpri__SignEcc()
//
// This function is the dispatch function for the various ECC-based signing schemes.
//
// Return Value Meaning
//
// CRYPT_SCHEME scheme is not supported
//
LIB_EXPORT CRYPT_RESULT
_cpri__SignEcc(
TPM2B_ECC_PARAMETER *rOut, // OUT: r component of the signature
TPM2B_ECC_PARAMETER *sOut, // OUT: s component of the signature
TPM_ALG_ID scheme, // IN: the scheme selector
TPM_ALG_ID hashAlg, // IN: the hash algorithm if need
TPM_ECC_CURVE curveId, // IN: the curve used in the signature
// process
TPM2B_ECC_PARAMETER *dIn, // IN: the private key
TPM2B *digest, // IN: the digest to sign
TPM2B_ECC_PARAMETER *kIn // IN: k for input
)
{
switch (scheme)
{
case TPM_ALG_ECDSA:
// SignEcdsa always works
return SignEcdsa(rOut, sOut, curveId, dIn, digest);
break;
#ifdef TPM_ALG_ECDAA
case TPM_ALG_ECDAA:
if(rOut != NULL)
rOut->b.size = 0;
return EcDaa(rOut, sOut, curveId, dIn, digest, kIn);
break;
#endif
#ifdef TPM_ALG_ECSCHNORR
case TPM_ALG_ECSCHNORR:
return SchnorrEcc(rOut, sOut, hashAlg, curveId, dIn, digest, kIn);
break;
#endif
#ifdef TPM_ALG_SM2
case TPM_ALG_SM2:
return SignSM2(rOut, sOut, curveId, dIn, digest);
break;
#endif
default:
return CRYPT_SCHEME;
}
}
#ifdef TPM_ALG_ECDSA //%
//
//
// ValidateSignatureEcdsa()
//
// This function validates an ECDSA signature. rIn and sIn shoudl have been checked to make sure that
// they are not zero.
//
// Return Value Meaning
//
// CRYPT_SUCCESS signature valid
// CRYPT_FAIL signature not valid
//
static CRYPT_RESULT
ValidateSignatureEcdsa(
TPM2B_ECC_PARAMETER *rIn, // IN: r component of the signature
TPM2B_ECC_PARAMETER *sIn, // IN: s component of the signature
TPM_ECC_CURVE curveId, // IN: the curve used in the signature
// process
TPMS_ECC_POINT *Qin, // IN: the public point of the key
TPM2B *digest // IN: the digest that was signed
)
{
TPM2B_ECC_PARAMETER U1;
TPM2B_ECC_PARAMETER U2;
TPMS_ECC_POINT R;
const TPM2B *n;
BN_CTX *context;
EC_POINT *pQ = NULL;
EC_GROUP *group = NULL;
BIGNUM *bnU1;
BIGNUM *bnU2;
BIGNUM *bnR;
BIGNUM *bnS;
BIGNUM *bnW;
BIGNUM *bnV;
BIGNUM *bnN;
BIGNUM *bnE;
BIGNUM *bnQx;
BIGNUM *bnQy;
CRYPT_RESULT retVal = CRYPT_FAIL;
int t;
const ECC_CURVE_DATA *curveData = GetCurveData(curveId);
// The curve selector should have been filtered by the unmarshaling process
pAssert (curveData != NULL);
n = curveData->n;
// 1. If r and s are not both integers in the interval [1, n - 1], output
// INVALID.
// rIn and sIn are known to be greater than zero (was checked by the caller).
if( _math__uComp(rIn->t.size, rIn->t.buffer, n->size, n->buffer) >= 0
|| _math__uComp(sIn->t.size, sIn->t.buffer, n->size, n->buffer) >= 0
)
return CRYPT_FAIL;
context = BN_CTX_new();
if(context == NULL)
FAIL(FATAL_ERROR_ALLOCATION);
BN_CTX_start(context);
bnR = BN_CTX_get(context);
bnS = BN_CTX_get(context);
bnN = BN_CTX_get(context);
bnE = BN_CTX_get(context);
bnV = BN_CTX_get(context);
bnW = BN_CTX_get(context);
bnQx = BN_CTX_get(context);
bnQy = BN_CTX_get(context);
bnU1 = BN_CTX_get(context);
bnU2 = BN_CTX_get(context);
// Assume the size variables do not overflow, which should not happen in
// the contexts that this function will be called.
assert2Bsize(Qin->x.t);
assert2Bsize(rIn->t);
assert2Bsize(sIn->t);
// BN_CTX_get() is sticky so only need to check the last value to know that
// all worked.
if( bnU2 == NULL
// initialize the group parameters
|| (group = EccCurveInit(curveId, context)) == NULL
// allocate a local point
|| (pQ = EC_POINT_new(group)) == NULL
// use the public key values (QxIn and QyIn) to initialize Q
|| BN_bin2bn(Qin->x.t.buffer, Qin->x.t.size, bnQx) == NULL
|| BN_bin2bn(Qin->x.t.buffer, Qin->x.t.size, bnQy) == NULL
|| !EC_POINT_set_affine_coordinates_GFp(group, pQ, bnQx, bnQy, context)
// convert the signature values
|| BN_bin2bn(rIn->t.buffer, rIn->t.size, bnR) == NULL
|| BN_bin2bn(sIn->t.buffer, sIn->t.size, bnS) == NULL
// convert the curve order
|| BN_bin2bn(curveData->n->buffer, curveData->n->size, bnN) == NULL)
FAIL(FATAL_ERROR_INTERNAL);
// 2. Use the selected hash function to compute H0 = Hash(M0).
// This is an input parameter
// 3. Convert the bit string H0 to an integer e as described in Appendix B.2.
t = (digest->size > rIn->t.size) ? rIn->t.size : digest->size;
if(BN_bin2bn(digest->buffer, t, bnE) == NULL)
FAIL(FATAL_ERROR_INTERNAL);
// 4. Compute w = (s')^-1 mod n, using the routine in Appendix B.1.
if (BN_mod_inverse(bnW, bnS, bnN, context) == NULL)
FAIL(FATAL_ERROR_INTERNAL);
// 5. Compute u1 = (e' * w) mod n, and compute u2 = (r' * w) mod n.
if( !BN_mod_mul(bnU1, bnE, bnW, bnN, context)
|| !BN_mod_mul(bnU2, bnR, bnW, bnN, context))
FAIL(FATAL_ERROR_INTERNAL);
BnTo2B(&U1.b, bnU1, (INT16) BN_num_bytes(bnU1));
BnTo2B(&U2.b, bnU2, (INT16) BN_num_bytes(bnU2));
// 6. Compute the elliptic curve point R = (xR, yR) = u1G+u2Q, using EC
// scalar multiplication and EC addition (see [Routines]). If R is equal to
// the point at infinity O, output INVALID.
if(_cpri__EccPointMultiply(&R, curveId, &U1, Qin, &U2) == CRYPT_SUCCESS)
{
// 7. Compute v = Rx mod n.
if( BN_bin2bn(R.x.t.buffer, R.x.t.size, bnV) == NULL
|| !BN_mod(bnV, bnV, bnN, context))
FAIL(FATAL_ERROR_INTERNAL);
// 8. Compare v and r0. If v = r0, output VALID; otherwise, output INVALID
if(BN_cmp(bnV, bnR) == 0)
retVal = CRYPT_SUCCESS;
}
if(pQ != NULL) EC_POINT_free(pQ);
if(group != NULL) EC_GROUP_free(group);
BN_CTX_end(context);
BN_CTX_free(context);
return retVal;
}
#endif //% TPM_ALG_ECDSA
#ifdef TPM_ALG_ECSCHNORR //%
//
//
// ValidateSignatureEcSchnorr()
//
// This function is used to validate an EC Schnorr signature. rIn and sIn are required to be greater than
// zero. This is checked in _cpri__ValidateSignatureEcc().
//
// Return Value Meaning
//
// CRYPT_SUCCESS signature valid
// CRYPT_FAIL signature not valid
// CRYPT_SCHEME hashAlg is not supported
//
static CRYPT_RESULT
ValidateSignatureEcSchnorr(
TPM2B_ECC_PARAMETER *rIn, // IN: r component of the signature
TPM2B_ECC_PARAMETER *sIn, // IN: s component of the signature
TPM_ALG_ID hashAlg, // IN: hash algorithm of the signature
TPM_ECC_CURVE curveId, // IN: the curve used in the signature
// process
TPMS_ECC_POINT *Qin, // IN: the public point of the key
TPM2B *digest // IN: the digest that was signed
)
{
TPMS_ECC_POINT pE;
const TPM2B *n;
CPRI_HASH_STATE hashState;
TPM2B_DIGEST rPrime;
TPM2B_ECC_PARAMETER minusR;
UINT16 digestSize = _cpri__GetDigestSize(hashAlg);
const ECC_CURVE_DATA *curveData = GetCurveData(curveId);
// The curve parameter should have been filtered by unmarshaling code
pAssert(curveData != NULL);
if(digestSize == 0)
return CRYPT_SCHEME;
// Input parameter validation
pAssert(rIn != NULL && sIn != NULL && Qin != NULL && digest != NULL);
n = curveData->n;
// if sIn or rIn are not between 1 and N-1, signature check fails
// sIn and rIn were verified to be non-zero by the caller
if( _math__uComp(sIn->b.size, sIn->b.buffer, n->size, n->buffer) >= 0
|| _math__uComp(rIn->b.size, rIn->b.buffer, n->size, n->buffer) >= 0
)
return CRYPT_FAIL;
//E = [s]InG - [r]InQ
_math__sub(n->size, n->buffer,
rIn->t.size, rIn->t.buffer,
&minusR.t.size, minusR.t.buffer);
if(_cpri__EccPointMultiply(&pE, curveId, sIn, Qin, &minusR) != CRYPT_SUCCESS)
return CRYPT_FAIL;
// Ex = Ex mod N
if(Mod2B(&pE.x.b, n) != CRYPT_SUCCESS)
FAIL(FATAL_ERROR_INTERNAL);
_math__Normalize2B(&pE.x.b);
// rPrime = h(digest || pE.x) mod n;
_cpri__StartHash(hashAlg, FALSE, &hashState);
_cpri__UpdateHash(&hashState, digest->size, digest->buffer);
_cpri__UpdateHash(&hashState, pE.x.t.size, pE.x.t.buffer);
if(_cpri__CompleteHash(&hashState, digestSize, rPrime.t.buffer) != digestSize)
FAIL(FATAL_ERROR_INTERNAL);
rPrime.t.size = digestSize;
// rPrime = rPrime (mod n)
if(Mod2B(&rPrime.b, n) != CRYPT_SUCCESS)
FAIL(FATAL_ERROR_INTERNAL);
// if the values don't match, then the signature is bad
if(_math__uComp(rIn->t.size, rIn->t.buffer,
rPrime.t.size, rPrime.t.buffer) != 0)
return CRYPT_FAIL;
else
return CRYPT_SUCCESS;
}
#endif //% TPM_ALG_ECSCHNORR
#ifdef TPM_ALG_SM2 //%
//
//
// ValidateSignatueSM2Dsa()
//
// This function is used to validate an SM2 signature.
//
// Return Value Meaning
//
// CRYPT_SUCCESS signature valid
// CRYPT_FAIL signature not valid
//
static CRYPT_RESULT
ValidateSignatureSM2Dsa(
TPM2B_ECC_PARAMETER *rIn, // IN: r component of the signature
TPM2B_ECC_PARAMETER *sIn, // IN: s component of the signature
TPM_ECC_CURVE curveId, // IN: the curve used in the signature
// process
TPMS_ECC_POINT *Qin, // IN: the public point of the key
TPM2B *digest // IN: the digest that was signed
)
{
BIGNUM *bnR;
BIGNUM *bnRp;
BIGNUM *bnT;
BIGNUM *bnS;
BIGNUM *bnE;
BIGNUM *order;
EC_POINT *pQ;
BN_CTX *context;
EC_GROUP *group = NULL;
const ECC_CURVE_DATA *curveData = GetCurveData(curveId);
BOOL fail = FALSE;
//
if((context = BN_CTX_new()) == NULL || curveData == NULL)
FAIL(FATAL_ERROR_INTERNAL);
bnR = BN_CTX_get(context);
bnRp= BN_CTX_get(context);
bnE = BN_CTX_get(context);
bnT = BN_CTX_get(context);
bnS = BN_CTX_get(context);
order = BN_CTX_get(context);
if( order == NULL
|| (group = EccCurveInit(curveId, context)) == NULL)
FAIL(FATAL_ERROR_INTERNAL);
#ifdef _SM2_SIGN_DEBUG
cpy_hexTo2B(&Qin->x.b,
"0AE4C7798AA0F119471BEE11825BE46202BB79E2A5844495E97C04FF4DF2548A");
cpy_hexTo2B(&Qin->y.b,
"7C0240F88F1CD4E16352A73C17B7F16F07353E53A176D684A9FE0C6BB798E857");
cpy_hexTo2B(digest,
"B524F552CD82B8B028476E005C377FB19A87E6FC682D48BB5D42E3D9B9EFFE76");
#endif
pQ = EccInitPoint2B(group, Qin, context);
#ifdef _SM2_SIGN_DEBUG
pAssert(EC_POINT_get_affine_coordinates_GFp(group, pQ, bnT, bnS, context));
pAssert(cmp_bn2hex(bnT,
"0AE4C7798AA0F119471BEE11825BE46202BB79E2A5844495E97C04FF4DF2548A")
== 0);
pAssert(cmp_bn2hex(bnS,
"7C0240F88F1CD4E16352A73C17B7F16F07353E53A176D684A9FE0C6BB798E857")
== 0);
#endif
BnFrom2B(bnR, &rIn->b);
BnFrom2B(bnS, &sIn->b);
BnFrom2B(bnE, digest);
#ifdef _SM2_SIGN_DEBUG
// Make sure that the input signature is the test signature
pAssert(cmp_2B2hex(&rIn->b,
"40F1EC59F793D9F49E09DCEF49130D4194F79FB1EED2CAA55BACDB49C4E755D1") == 0);
pAssert(cmp_2B2hex(&sIn->b,
"6FC6DAC32C5D5CF10C77DFB20F7C2EB667A457872FB09EC56327A67EC7DEEBE7") == 0);
#endif
// a) verify that r and s are in the inclusive interval 1 to (n 1)
if (!EC_GROUP_get_order(group, order, context)) goto Cleanup;
fail = (BN_ucmp(bnR, order) >= 0);
fail = (BN_ucmp(bnS, order) >= 0) || fail;
if(fail)
// There is no reason to continue. Since r and s are inputs from the caller,
// they can know that the values are not in the proper range. So, exiting here
// does not disclose any information.
goto Cleanup;
// b) compute t := (r + s) mod n
if(!BN_mod_add(bnT, bnR, bnS, order, context))
FAIL(FATAL_ERROR_INTERNAL);
#ifdef _SM2_SIGN_DEBUG
pAssert(cmp_bn2hex(bnT,
"2B75F07ED7ECE7CCC1C8986B991F441AD324D6D619FE06DD63ED32E0C997C801")
== 0);
#endif
// c) verify that t > 0
if(BN_is_zero(bnT)) {
fail = TRUE;
// set to a value that should allow rest of the computations to run without
// trouble
BN_copy(bnT, bnS);
}
// d) compute (x, y) := [s]G + [t]Q
if(!EC_POINT_mul(group, pQ, bnS, pQ, bnT, context))
FAIL(FATAL_ERROR_INTERNAL);
// Get the x coordinate of the point
if(!EC_POINT_get_affine_coordinates_GFp(group, pQ, bnT, NULL, context))
FAIL(FATAL_ERROR_INTERNAL);
#ifdef _SM2_SIGN_DEBUG
pAssert(cmp_bn2hex(bnT,
"110FCDA57615705D5E7B9324AC4B856D23E6D9188B2AE47759514657CE25D112")
== 0);
#endif
// e) compute r' := (e + x) mod n (the x coordinate is in bnT)
if(!BN_mod_add(bnRp, bnE, bnT, order, context))
FAIL(FATAL_ERROR_INTERNAL);
// f) verify that r' = r
fail = BN_ucmp(bnR, bnRp) != 0 || fail;
Cleanup:
if(pQ) EC_POINT_free(pQ);
if(group) EC_GROUP_free(group);
BN_CTX_end(context);
BN_CTX_free(context);
if(fail)
return CRYPT_FAIL;
else
return CRYPT_SUCCESS;
}
#endif //% TPM_ALG_SM2
//
//
// _cpri__ValidateSignatureEcc()
//
// This function validates
//
// Return Value Meaning
//
// CRYPT_SUCCESS signature is valid
// CRYPT_FAIL not a valid signature
// CRYPT_SCHEME unsupported scheme
//
LIB_EXPORT CRYPT_RESULT
_cpri__ValidateSignatureEcc(
TPM2B_ECC_PARAMETER *rIn, // IN: r component of the signature
TPM2B_ECC_PARAMETER *sIn, // IN: s component of the signature
TPM_ALG_ID scheme, // IN: the scheme selector
TPM_ALG_ID hashAlg, // IN: the hash algorithm used (not used
// in all schemes)
TPM_ECC_CURVE curveId, // IN: the curve used in the signature
// process
TPMS_ECC_POINT *Qin, // IN: the public point of the key
TPM2B *digest // IN: the digest that was signed
)
{
CRYPT_RESULT retVal;
// return failure if either part of the signature is zero
if(_math__Normalize2B(&rIn->b) == 0 || _math__Normalize2B(&sIn->b) == 0)
return CRYPT_FAIL;
switch (scheme)
{
case TPM_ALG_ECDSA:
retVal = ValidateSignatureEcdsa(rIn, sIn, curveId, Qin, digest);
break;
#ifdef TPM_ALG_ECSCHNORR
case TPM_ALG_ECSCHNORR:
retVal = ValidateSignatureEcSchnorr(rIn, sIn, hashAlg, curveId, Qin,
digest);
break;
#endif
#ifdef TPM_ALG_SM2
case TPM_ALG_SM2:
retVal = ValidateSignatureSM2Dsa(rIn, sIn, curveId, Qin, digest);
#endif
default:
retVal = CRYPT_SCHEME;
break;
}
return retVal;
}
#if CC_ZGen_2Phase == YES //%
#ifdef TPM_ALG_ECMQV
//
//
// avf1()
//
// This function does the associated value computation required by MQV key exchange. Process:
// a) Convert xQ to an integer xqi using the convention specified in Appendix C.3.
// b) Calculate xqm = xqi mod 2^ceil(f/2) (where f = ceil(log2(n)).
// c) Calculate the associate value function avf(Q) = xqm + 2ceil(f / 2)
//
static BOOL
avf1(
BIGNUM *bnX, // IN/OUT: the reduced value
BIGNUM *bnN // IN: the order of the curve
)
{
// compute f = 2^(ceil(ceil(log2(n)) / 2))
int f = (BN_num_bits(bnN) + 1) / 2;
// x' = 2^f + (x mod 2^f)
BN_mask_bits(bnX, f); // This is mod 2*2^f but it doesn't matter because
// the next operation will SET the extra bit anyway
BN_set_bit(bnX, f);
return TRUE;
}
//
//
// C_2_2_MQV()
//
// This function performs the key exchange defined in SP800-56A 6.1.1.4 Full MQV, C(2, 2, ECC MQV).
// CAUTION: Implementation of this function may require use of essential claims in patents not owned by
// TCG members.
// Points QsB() and QeB() are required to be on the curve of inQsA. The function will fail, possibly
// catastrophically, if this is not the case.
//
//
//
// Return Value Meaning
//
// CRYPT_SUCCESS results is valid
// CRYPT_NO_RESULT the value for dsA does not give a valid point on the curve
//
static CRYPT_RESULT
C_2_2_MQV(
TPMS_ECC_POINT *outZ, // OUT: the computed point
TPM_ECC_CURVE curveId, // IN: the curve for the computations
TPM2B_ECC_PARAMETER *dsA, // IN: static private TPM key
TPM2B_ECC_PARAMETER *deA, // IN: ephemeral private TPM key
TPMS_ECC_POINT *QsB, // IN: static public party B key
TPMS_ECC_POINT *QeB // IN: ephemeral public party B key
)
{
BN_CTX *context;
EC_POINT *pQeA = NULL;
EC_POINT *pQeB = NULL;
EC_POINT *pQsB = NULL;
EC_GROUP *group = NULL;
BIGNUM *bnTa;
BIGNUM *bnDeA;
BIGNUM *bnDsA;
BIGNUM *bnXeA; // x coordinate of ephemeral party A key
BIGNUM *bnH;
BIGNUM *bnN;
BIGNUM *bnXeB;
const ECC_CURVE_DATA *curveData = GetCurveData(curveId);
CRYPT_RESULT retVal;
pAssert( curveData != NULL && outZ != NULL && dsA != NULL
&& deA != NULL && QsB != NULL && QeB != NULL);
context = BN_CTX_new();
if(context == NULL || curveData == NULL)
FAIL(FATAL_ERROR_ALLOCATION);
BN_CTX_start(context);
bnTa = BN_CTX_get(context);
bnDeA = BN_CTX_get(context);
bnDsA = BN_CTX_get(context);
bnXeA = BN_CTX_get(context);
bnH = BN_CTX_get(context);
bnN = BN_CTX_get(context);
bnXeB = BN_CTX_get(context);
if(bnXeB == NULL)
FAIL(FATAL_ERROR_ALLOCATION);
// Process:
// 1. implicitsigA = (de,A + avf(Qe,A)ds,A ) mod n.
// 2. P = h(implicitsigA)(Qe,B + avf(Qe,B)Qs,B).
// 3. If P = O, output an error indicator.
// 4. Z=xP, where xP is the x-coordinate of P.
// Initialize group parameters and local values of input
if((group = EccCurveInit(curveId, context)) == NULL)
FAIL(FATAL_ERROR_INTERNAL);
if((pQeA = EC_POINT_new(group)) == NULL)
FAIL(FATAL_ERROR_ALLOCATION);
BnFrom2B(bnDeA, &deA->b);
BnFrom2B(bnDsA, &dsA->b);
BnFrom2B(bnH, curveData->h);
BnFrom2B(bnN, curveData->n);
BnFrom2B(bnXeB, &QeB->x.b);
pQeB = EccInitPoint2B(group, QeB, context);
pQsB = EccInitPoint2B(group, QsB, context);
// Compute the public ephemeral key pQeA = [de,A]G
if( (retVal = PointMul(group, pQeA, bnDeA, NULL, NULL, context))
!= CRYPT_SUCCESS)
goto Cleanup;
if(EC_POINT_get_affine_coordinates_GFp(group, pQeA, bnXeA, NULL, context) != 1)
FAIL(FATAL_ERROR_INTERNAL);
// 1. implicitsigA = (de,A + avf(Qe,A)ds,A ) mod n.
// tA := (ds,A + de,A avf(Xe,A)) mod n (3)
// Compute 'tA' = ('deA' + 'dsA' avf('XeA')) mod n
// Ta = avf(XeA);
BN_copy(bnTa, bnXeA);
avf1(bnTa, bnN);
if(// do Ta = ds,A * Ta mod n = dsA * avf(XeA) mod n
!BN_mod_mul(bnTa, bnDsA, bnTa, bnN, context)
// now Ta = deA + Ta mod n = deA + dsA * avf(XeA) mod n
|| !BN_mod_add(bnTa, bnDeA, bnTa, bnN, context)
)
FAIL(FATAL_ERROR_INTERNAL);
// 2. P = h(implicitsigA)(Qe,B + avf(Qe,B)Qs,B).
// Put this in because almost every case of h is == 1 so skip the call when
// not necessary.
if(!BN_is_one(bnH))
{
// Cofactor is not 1 so compute Ta := Ta * h mod n
if(!BN_mul(bnTa, bnTa, bnH, context))
FAIL(FATAL_ERROR_INTERNAL);
}
// Now that 'tA' is (h * 'tA' mod n)
// 'outZ' = (tA)(Qe,B + avf(Qe,B)Qs,B).
// first, compute XeB = avf(XeB)
avf1(bnXeB, bnN);
// QsB := [XeB]QsB
if( !EC_POINT_mul(group, pQsB, NULL, pQsB, bnXeB, context)
// QeB := QsB + QeB
|| !EC_POINT_add(group, pQeB, pQeB, pQsB, context)
)
FAIL(FATAL_ERROR_INTERNAL);
// QeB := [tA]QeB = [tA](QsB + [Xe,B]QeB) and check for at infinity
if(PointMul(group, pQeB, NULL, pQeB, bnTa, context) == CRYPT_SUCCESS)
// Convert BIGNUM E to TPM2B E
Point2B(group, outZ, pQeB, (INT16)BN_num_bytes(bnN), context);
Cleanup:
if(pQeA != NULL) EC_POINT_free(pQeA);
if(pQeB != NULL) EC_POINT_free(pQeB);
if(pQsB != NULL) EC_POINT_free(pQsB);
if(group != NULL) EC_GROUP_free(group);
BN_CTX_end(context);
BN_CTX_free(context);
return retVal;
}
#endif // TPM_ALG_ECMQV
#ifdef TPM_ALG_SM2 //%
//
//
// avfSm2()
//
// This function does the associated value computation required by SM2 key exchange. This is different
// form the avf() in the international standards because it returns a value that is half the size of the value
// returned by the standard avf. For example, if n is 15, Ws (w in the standard) is 2 but the W here is 1. This
// means that an input value of 14 (1110b) would return a value of 110b with the standard but 10b with the
// scheme in SM2.
//
static BOOL
avfSm2(
BIGNUM *bnX, // IN/OUT: the reduced value
BIGNUM *bnN // IN: the order of the curve
)
{
// a) set w := ceil(ceil(log2(n)) / 2) - 1
int w = ((BN_num_bits(bnN) + 1) / 2) - 1;
// b) set x' := 2^w + ( x & (2^w - 1))
// This is just like the avf for MQV where x' = 2^w + (x mod 2^w)
BN_mask_bits(bnX, w); // as wiht avf1, this is too big by a factor of 2 but
// it doesn't matter becasue we SET the extra bit anyway
BN_set_bit(bnX, w);
return TRUE;
}
//
// SM2KeyExchange() This function performs the key exchange defined in SM2. The first step is to compute
// tA = (dsA + deA avf(Xe,A)) mod n Then, compute the Z value from outZ = (h tA mod n) (QsA +
// [avf(QeB().x)](QeB())). The function will compute the ephemeral public key from the ephemeral private
// key. All points are required to be on the curve of inQsA. The function will fail catastrophically if this is not
// the case
//
// Return Value Meaning
//
// CRYPT_SUCCESS results is valid
// CRYPT_NO_RESULT the value for dsA does not give a valid point on the curve
//
static CRYPT_RESULT
SM2KeyExchange(
TPMS_ECC_POINT *outZ, // OUT: the computed point
TPM_ECC_CURVE curveId, // IN: the curve for the computations
TPM2B_ECC_PARAMETER *dsA, // IN: static private TPM key
TPM2B_ECC_PARAMETER *deA, // IN: ephemeral private TPM key
TPMS_ECC_POINT *QsB, // IN: static public party B key
TPMS_ECC_POINT *QeB // IN: ephemeral public party B key
)
{
BN_CTX *context;
EC_POINT *pQeA = NULL;
EC_POINT *pQeB = NULL;
EC_POINT *pQsB = NULL;
EC_GROUP *group = NULL;
BIGNUM *bnTa;
BIGNUM *bnDeA;
BIGNUM *bnDsA;
BIGNUM *bnXeA; // x coordinate of ephemeral party A key
BIGNUM *bnH;
BIGNUM *bnN;
BIGNUM *bnXeB;
//
const ECC_CURVE_DATA *curveData = GetCurveData(curveId);
CRYPT_RESULT retVal;
pAssert( curveData != NULL && outZ != NULL && dsA != NULL
&& deA != NULL && QsB != NULL && QeB != NULL);
context = BN_CTX_new();
if(context == NULL || curveData == NULL)
FAIL(FATAL_ERROR_ALLOCATION);
BN_CTX_start(context);
bnTa = BN_CTX_get(context);
bnDeA = BN_CTX_get(context);
bnDsA = BN_CTX_get(context);
bnXeA = BN_CTX_get(context);
bnH = BN_CTX_get(context);
bnN = BN_CTX_get(context);
bnXeB = BN_CTX_get(context);
if(bnXeB == NULL)
FAIL(FATAL_ERROR_ALLOCATION);
// Initialize group parameters and local values of input
if((group = EccCurveInit(curveId, context)) == NULL)
FAIL(FATAL_ERROR_INTERNAL);
if((pQeA = EC_POINT_new(group)) == NULL)
FAIL(FATAL_ERROR_ALLOCATION);
BnFrom2B(bnDeA, &deA->b);
BnFrom2B(bnDsA, &dsA->b);
BnFrom2B(bnH, curveData->h);
BnFrom2B(bnN, curveData->n);
BnFrom2B(bnXeB, &QeB->x.b);
pQeB = EccInitPoint2B(group, QeB, context);
pQsB = EccInitPoint2B(group, QsB, context);
// Compute the public ephemeral key pQeA = [de,A]G
if( (retVal = PointMul(group, pQeA, bnDeA, NULL, NULL, context))
!= CRYPT_SUCCESS)
goto Cleanup;
if(EC_POINT_get_affine_coordinates_GFp(group, pQeA, bnXeA, NULL, context) != 1)
FAIL(FATAL_ERROR_INTERNAL);
// tA := (ds,A + de,A avf(Xe,A)) mod n (3)
// Compute 'tA' = ('dsA' + 'deA' avf('XeA')) mod n
// Ta = avf(XeA);
BN_copy(bnTa, bnXeA);
avfSm2(bnTa, bnN);
if(// do Ta = de,A * Ta mod n = deA * avf(XeA) mod n
!BN_mod_mul(bnTa, bnDeA, bnTa, bnN, context)
// now Ta = dsA + Ta mod n = dsA + deA * avf(XeA) mod n
|| !BN_mod_add(bnTa, bnDsA, bnTa, bnN, context)
)
FAIL(FATAL_ERROR_INTERNAL);
// outZ ? [h tA mod n] (Qs,B + [avf(Xe,B)](Qe,B)) (4)
// Put this in because almost every case of h is == 1 so skip the call when
// not necessary.
if(!BN_is_one(bnH))
{
// Cofactor is not 1 so compute Ta := Ta * h mod n
if(!BN_mul(bnTa, bnTa, bnH, context))
FAIL(FATAL_ERROR_INTERNAL);
}
// Now that 'tA' is (h * 'tA' mod n)
// 'outZ' = ['tA'](QsB + [avf(QeB.x)](QeB)).
// first, compute XeB = avf(XeB)
avfSm2(bnXeB, bnN);
// QeB := [XeB]QeB
if( !EC_POINT_mul(group, pQeB, NULL, pQeB, bnXeB, context)
// QeB := QsB + QeB
|| !EC_POINT_add(group, pQeB, pQeB, pQsB, context)
)
FAIL(FATAL_ERROR_INTERNAL);
// QeB := [tA]QeB = [tA](QsB + [Xe,B]QeB) and check for at infinity
if(PointMul(group, pQeB, NULL, pQeB, bnTa, context) == CRYPT_SUCCESS)
// Convert BIGNUM E to TPM2B E
Point2B(group, outZ, pQeB, (INT16)BN_num_bytes(bnN), context);
Cleanup:
if(pQeA != NULL) EC_POINT_free(pQeA);
if(pQeB != NULL) EC_POINT_free(pQeB);
if(pQsB != NULL) EC_POINT_free(pQsB);
if(group != NULL) EC_GROUP_free(group);
BN_CTX_end(context);
BN_CTX_free(context);
return retVal;
}
#endif //% TPM_ALG_SM2
//
//
// C_2_2_ECDH()
//
// This function performs the two phase key exchange defined in SP800-56A, 6.1.1.2 Full Unified Model,
// C(2, 2, ECC CDH).
//
static CRYPT_RESULT
C_2_2_ECDH(
TPMS_ECC_POINT *outZ1, // OUT: Zs
TPMS_ECC_POINT *outZ2, // OUT: Ze
TPM_ECC_CURVE curveId, // IN: the curve for the computations
TPM2B_ECC_PARAMETER *dsA, // IN: static private TPM key
TPM2B_ECC_PARAMETER *deA, // IN: ephemeral private TPM key
TPMS_ECC_POINT *QsB, // IN: static public party B key
TPMS_ECC_POINT *QeB // IN: ephemeral public party B key
)
{
BIGNUM *order;
BN_CTX *context;
EC_POINT *pQ = NULL;
EC_GROUP *group = NULL;
BIGNUM *bnD;
INT16 size;
const ECC_CURVE_DATA *curveData = GetCurveData(curveId);
context = BN_CTX_new();
if(context == NULL || curveData == NULL)
FAIL(FATAL_ERROR_ALLOCATION);
BN_CTX_start(context);
order = BN_CTX_get(context);
if((bnD = BN_CTX_get(context)) == NULL)
FAIL(FATAL_ERROR_INTERNAL);
// Initialize group parameters and local values of input
if((group = EccCurveInit(curveId, context)) == NULL)
FAIL(FATAL_ERROR_INTERNAL);
if (!EC_GROUP_get_order(group, order, context))
FAIL(FATAL_ERROR_INTERNAL);
size = (INT16)BN_num_bytes(order);
// Get the static private key of A
BnFrom2B(bnD, &dsA->b);
// Initialize the static public point from B
pQ = EccInitPoint2B(group, QsB, context);
// Do the point multiply for the Zs value
if(PointMul(group, pQ, NULL, pQ, bnD, context) != CRYPT_NO_RESULT)
// Convert the Zs value
Point2B(group, outZ1, pQ, size, context);
// Get the ephemeral private key of A
BnFrom2B(bnD, &deA->b);
// Initalize the ephemeral public point from B
PointFrom2B(group, pQ, QeB, context);
// Do the point multiply for the Ze value
if(PointMul(group, pQ, NULL, pQ, bnD, context) != CRYPT_NO_RESULT)
// Convert the Ze value.
Point2B(group, outZ2, pQ, size, context);
if(pQ != NULL) EC_POINT_free(pQ);
if(group != NULL) EC_GROUP_free(group);
BN_CTX_end(context);
BN_CTX_free(context);
return CRYPT_SUCCESS;
}
//
//
// _cpri__C_2_2_KeyExchange()
//
// This function is the dispatch routine for the EC key exchange function that use two ephemeral and two
// static keys.
//
// Return Value Meaning
//
// CRYPT_SCHEME scheme is not defined
//
LIB_EXPORT CRYPT_RESULT
_cpri__C_2_2_KeyExchange(
TPMS_ECC_POINT *outZ1, // OUT: a computed point
TPMS_ECC_POINT *outZ2, // OUT: and optional second point
TPM_ECC_CURVE curveId, // IN: the curve for the computations
TPM_ALG_ID scheme, // IN: the key exchange scheme
TPM2B_ECC_PARAMETER *dsA, // IN: static private TPM key
TPM2B_ECC_PARAMETER *deA, // IN: ephemeral private TPM key
TPMS_ECC_POINT *QsB, // IN: static public party B key
TPMS_ECC_POINT *QeB // IN: ephemeral public party B key
)
{
pAssert( outZ1 != NULL
&& dsA != NULL && deA != NULL
&& QsB != NULL && QeB != NULL);
// Initalize the output points so that they are empty until one of the
// functions decides otherwise
outZ1->x.b.size = 0;
outZ1->y.b.size = 0;
if(outZ2 != NULL)
{
outZ2->x.b.size = 0;
outZ2->y.b.size = 0;
}
switch (scheme)
{
case TPM_ALG_ECDH:
return C_2_2_ECDH(outZ1, outZ2, curveId, dsA, deA, QsB, QeB);
break;
#ifdef TPM_ALG_ECMQV
case TPM_ALG_ECMQV:
return C_2_2_MQV(outZ1, curveId, dsA, deA, QsB, QeB);
break;
#endif
#ifdef TPM_ALG_SM2
case TPM_ALG_SM2:
return SM2KeyExchange(outZ1, curveId, dsA, deA, QsB, QeB);
break;
#endif
default:
return CRYPT_SCHEME;
}
}
#else //%
//
// Stub used when the 2-phase key exchange is not defined so that the linker has something to associate
// with the value in the .def file.
//
LIB_EXPORT CRYPT_RESULT
_cpri__C_2_2_KeyExchange(
void
)
{
return CRYPT_FAIL;
}
#endif //% CC_ZGen_2Phase
#endif // TPM_ALG_ECC
Reference in a new issue View git blame Copy permalink