/********************************************************************************/ /* */ /* conversion functions that will convert TPM2B to/from internal format */ /* Written by Ken Goldman */ /* IBM Thomas J. Watson Research Center */ /* $Id: BnConvert.c 1519 2019-11-15 20:43:51Z kgoldman $ */ /* */ /* Licenses and Notices */ /* */ /* 1. Copyright Licenses: */ /* */ /* - Trusted Computing Group (TCG) grants to the user of the source code in */ /* this specification (the "Source Code") a worldwide, irrevocable, */ /* nonexclusive, royalty free, copyright license to reproduce, create */ /* derivative works, distribute, display and perform the Source Code and */ /* derivative works thereof, and to grant others the rights granted herein. */ /* */ /* - The TCG grants to the user of the other parts of the specification */ /* (other than the Source Code) the rights to reproduce, distribute, */ /* display, and perform the specification solely for the purpose of */ /* developing products based on such documents. */ /* */ /* 2. Source Code Distribution Conditions: */ /* */ /* - Redistributions of Source Code must retain the above copyright licenses, */ /* this list of conditions and the following disclaimers. */ /* */ /* - Redistributions in binary form must reproduce the above copyright */ /* licenses, this list of conditions and the following disclaimers in the */ /* documentation and/or other materials provided with the distribution. */ /* */ /* 3. Disclaimers: */ /* */ /* - THE COPYRIGHT LICENSES SET FORTH ABOVE DO NOT REPRESENT ANY FORM OF */ /* LICENSE OR WAIVER, EXPRESS OR IMPLIED, BY ESTOPPEL OR OTHERWISE, WITH */ /* RESPECT TO PATENT RIGHTS HELD BY TCG MEMBERS (OR OTHER THIRD PARTIES) */ /* THAT MAY BE NECESSARY TO IMPLEMENT THIS SPECIFICATION OR OTHERWISE. */ /* Contact TCG Administration (admin@trustedcomputinggroup.org) for */ /* information on specification licensing rights available through TCG */ /* membership agreements. */ /* */ /* - THIS SPECIFICATION IS PROVIDED "AS IS" WITH NO EXPRESS OR IMPLIED */ /* WARRANTIES WHATSOEVER, INCLUDING ANY WARRANTY OF MERCHANTABILITY OR */ /* FITNESS FOR A PARTICULAR PURPOSE, ACCURACY, COMPLETENESS, OR */ /* NONINFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS, OR ANY WARRANTY */ /* OTHERWISE ARISING OUT OF ANY PROPOSAL, SPECIFICATION OR SAMPLE. */ /* */ /* - Without limitation, TCG and its members and licensors disclaim all */ /* liability, including liability for infringement of any proprietary */ /* rights, relating to use of information in this specification and to the */ /* implementation of this specification, and TCG disclaims all liability for */ /* cost of procurement of substitute goods or services, lost profits, loss */ /* of use, loss of data or any incidental, consequential, direct, indirect, */ /* or special damages, whether under contract, tort, warranty or otherwise, */ /* arising in any way out of use or reliance upon this specification or any */ /* information herein. */ /* */ /* (c) Copyright IBM Corp. and others, 2016 - 2019 */ /* */ /********************************************************************************/ /* 10.2.2 BnConvert.c */ /* 10.2.2.1 Introduction */ /* This file contains the basic conversion functions that will convert TPM2B to/from the internal format. The internal format is a bigNum, */ /* 10.2.2.2 Includes */ #include "Tpm.h" /* 10.2.2.3 Functions */ /* 10.2.2.3.1 BnFromBytes() */ /* This function will convert a big-endian byte array to the internal number format. If bn is NULL, then the output is NULL. If bytes is null or the required size is 0, then the output is set to zero */ LIB_EXPORT bigNum BnFromBytes( bigNum bn, const BYTE *bytes, NUMBYTES nBytes ) { const BYTE *pFrom; // 'p' points to the least significant bytes of source BYTE *pTo; // points to least significant bytes of destination crypt_uword_t size; // size = (bytes != NULL) ? BYTES_TO_CRYPT_WORDS(nBytes) : 0; // If nothing in, nothing out if(bn == NULL) return NULL; // make sure things fit pAssert(BnGetAllocated(bn) >= size); if(size > 0) { // Clear the topmost word in case it is not filled with data bn->d[size - 1] = 0; // Moving the input bytes from the end of the list (LSB) end pFrom = bytes + nBytes - 1; // To the LS0 of the LSW of the bigNum. pTo = (BYTE *)bn->d; for(; nBytes != 0; nBytes--) *pTo++ = *pFrom--; // For a little-endian machine, the conversion is a straight byte // reversal. For a big-endian machine, we have to put the words in // big-endian byte order #if BIG_ENDIAN_TPM { crypt_word_t t; for(t = (crypt_word_t)size - 1; t >= 0; t--) bn->d[t] = SWAP_CRYPT_WORD(bn->d[t]); } #endif } BnSetTop(bn, size); return bn; } /* 10.2.2.3.2 BnFrom2B() */ /* Convert an TPM2B to a BIG_NUM. If the input value does not exist, or the output does not exist, or the input will not fit into the output the function returns NULL */ LIB_EXPORT bigNum BnFrom2B( bigNum bn, // OUT: const TPM2B *a2B // IN: number to convert ) { if(a2B != NULL) return BnFromBytes(bn, a2B->buffer, a2B->size); // Make sure that the number has an initialized value rather than whatever // was there before BnSetTop(bn, 0); // Function accepts NULL return NULL; } /* 10.2.2.3.3 BnFromHex() */ /* Convert a hex string into a bigNum. This is primarily used in debugging. */ #ifdef _SM2_SIGN_DEBUG // libtpms added LIB_EXPORT bigNum BnFromHex( bigNum bn, // OUT: const char *hex // IN: ) { #define FromHex(a) ((a) - (((a) > 'a') ? ('a' + 10) \ : ((a) > 'A') ? ('A' - 10) : '0')) unsigned i; unsigned wordCount; const char *p; BYTE *d = (BYTE *)&(bn->d[0]); // pAssert(bn && hex); i = (unsigned)strlen(hex); wordCount = BYTES_TO_CRYPT_WORDS((i + 1) / 2); if((i == 0) || (wordCount >= BnGetAllocated(bn))) BnSetWord(bn, 0); else { bn->d[wordCount - 1] = 0; p = hex + i - 1; for(;i > 1; i -= 2) { BYTE a; a = FromHex(*p); p--; *d++ = a + (FromHex(*p) << 4); p--; } if(i == 1) *d = FromHex(*p); } #if !BIG_ENDIAN_TPM for(i = 0; i < wordCount; i++) bn->d[i] = SWAP_CRYPT_WORD(bn->d[i]); #endif // BIG_ENDIAN_TPM BnSetTop(bn, wordCount); return bn; } #endif // libtpms added /* 10.2.2.3.4 BnToBytes() */ /* This function converts a BIG_NUM to a byte array. It converts the bigNum to a big-endian byte string and sets size to the normalized value. If size is an input 0, then the receiving buffer is guaranteed to be large enough for the result and the size will be set to the size required for bigNum (leading zeros suppressed). */ /* The conversion for a little-endian machine simply requires that all significant bytes of the bigNum be reversed. For a big-endian machine, rather than unpack each word individually, the bigNum is converted to little-endian words, copied, and then converted back to big-endian. */ LIB_EXPORT BOOL BnToBytes( bigConst bn, BYTE *buffer, NUMBYTES *size // This the number of bytes that are // available in the buffer. The result // should be this big. ) { crypt_uword_t requiredSize; BYTE *pFrom; BYTE *pTo; crypt_uword_t count; // // validate inputs pAssert(bn && buffer && size); requiredSize = (BnSizeInBits(bn) + 7) / 8; if(requiredSize == 0) { // If the input value is 0, return a byte of zero *size = 1; *buffer = 0; } else { #if BIG_ENDIAN_TPM // Copy the constant input value into a modifiable value BN_VAR(bnL, LARGEST_NUMBER_BITS * 2); BnCopy(bnL, bn); // byte swap the words in the local value to make them little-endian for(count = 0; count < bnL->size; count++) bnL->d[count] = SWAP_CRYPT_WORD(bnL->d[count]); bn = (bigConst)bnL; #endif if(*size == 0) *size = (NUMBYTES)requiredSize; pAssert(requiredSize <= *size); // Byte swap the number (not words but the whole value) count = *size; // Start from the least significant word and offset to the most significant // byte which is in some high word pFrom = (BYTE *)(&bn->d[0]) + requiredSize - 1; pTo = buffer; // If the number of output bytes is larger than the number bytes required // for the input number, pad with zeros for(count = *size; count > requiredSize; count--) *pTo++ = 0; // Move the most significant byte at the end of the BigNum to the next most // significant byte position of the 2B and repeat for all significant bytes. for(; requiredSize > 0; requiredSize--) *pTo++ = *pFrom--; } return TRUE; } /* 10.2.2.3.5 BnTo2B() */ /* Function to convert a BIG_NUM to TPM2B. The TPM2B size is set to the requested size which may require padding. If size is non-zero and less than required by the value in bn then an error is returned. If size is zero, then the TPM2B is assumed to be large enough for the data and a2b->size will be adjusted accordingly. */ LIB_EXPORT BOOL BnTo2B( bigConst bn, // IN: TPM2B *a2B, // OUT: NUMBYTES size // IN: the desired size ) { // Set the output size if(bn && a2B) { a2B->size = size; return BnToBytes(bn, a2B->buffer, &a2B->size); } return FALSE; } #if ALG_ECC /* 10.2.2.3.6 BnPointFrom2B() */ /* Function to create a BIG_POINT structure from a 2B point. A point is going to be two ECC values in the same buffer. The values are going to be the size of the modulus. They are in modular form. */ LIB_EXPORT bn_point_t * BnPointFrom2B( bigPoint ecP, // OUT: the preallocated point structure TPMS_ECC_POINT *p // IN: the number to convert ) { if(p == NULL) return NULL; if(NULL != ecP) { BnFrom2B(ecP->x, &p->x.b); BnFrom2B(ecP->y, &p->y.b); BnSetWord(ecP->z, 1); } return ecP; } /* 10.2.2.3.7 BnPointTo2B() */ /* This function converts a BIG_POINT into a TPMS_ECC_POINT. A TPMS_ECC_POINT contains two TPM2B_ECC_PARAMETER values. The maximum size of the parameters is dependent on the maximum EC key size used in an implementation. The presumption is that the TPMS_ECC_POINT is large enough to hold 2 TPM2B values, each as large as a MAX_ECC_PARAMETER_BYTES */ LIB_EXPORT BOOL BnPointTo2B( TPMS_ECC_POINT *p, // OUT: the converted 2B structure bigPoint ecP, // IN: the values to be converted bigCurve E // IN: curve descriptor for the point ) { UINT16 size; // pAssert(p && ecP && E); pAssert(BnEqualWord(ecP->z, 1)); // BnMsb is the bit number of the MSB. This is one less than the number of bits size = (UINT16)BITS_TO_BYTES(BnSizeInBits(CurveGetOrder(AccessCurveData(E)))); BnTo2B(ecP->x, &p->x.b, size); BnTo2B(ecP->y, &p->y.b, size); return TRUE; } #endif // TPM_ALG_ECC