05_Signature

Example code to Generate Signature for the raw input message. More...

Collaboration diagram for 05_Signature:

Example code to Generate Signature for the raw input message.

/* Reader Library Headers. */
#include <phKeyStore.h>
#include <phCryptoASym.h>
 
/* Standard Header. */
#include <string.h>
 
#define CHECK_SUCCESS(x)                                                                             \
     if ( (x) != PH_ERR_SUCCESS )                                                                    \
     {                                                                                               \
             printf ( "\n\n" );                                                                      \
             printf ( "An error occurred: (0x%04X)\n", (x) );                                        \
             printf ( "Pressing any key will exit the demo.\n" );                                    \
             _getch ();                                                                              \
             return 0;                                                                               \
     }
 
#define KEY_ENTRIES              10
#define KEY_VERSION_PAIRS        3 * KEY_ENTRIES
#define KEY_USAGE_COUNTER        15
 
#define TRUE PH_ON
#define FALSE PH_OFF
 
#define KEY_ADDRESS              1
 
#define KEY_PAIR_PRIVATE_KEY     0
#define KEY_PAIR_PUBLIC_KEY      1
 
/* Variables */
phStatus_t wStatus = 0;
uint16_t wKeyInfo = 0;
uint8_t aSignature[64];
uint16_t wSignLen = 0;
uint8_t aPrivateKey[] =
{
     0x60, 0x0A, 0xC0, 0xBA, 0x0A, 0x5B, 0x79, 0xB6, 0x07, 0x25, 0xA9, 0xC8, 0xFF, 0xB3, 0xE7, 0x45,
     0x4A, 0x7C, 0x70, 0x2D, 0xB5, 0x65, 0x3A, 0x8A, 0xA6, 0x0E, 0x2E, 0x4C, 0x25, 0x6F, 0xF0, 0x5D
};
uint8_t aPublicKey[] =
{
     0x04, 0xC4, 0x18, 0x7C, 0x26, 0xA5, 0x95, 0xB1, 0x8B, 0x37, 0x03, 0x31, 0x2D, 0x80, 0x12, 0x99,
     0x9B, 0x88, 0xEB, 0x28, 0xBD, 0xB4, 0x1F, 0x30, 0x11, 0x28, 0x3D, 0xD8, 0x06, 0xEC, 0xDB, 0x09,
     0x24, 0x1B, 0xA9, 0x9D, 0x61, 0x2D, 0xA5, 0x4A, 0x6E, 0xAF, 0x14, 0x0F, 0x80, 0xAB, 0x5B, 0x19,
     0xE4, 0xBA, 0x66, 0x53, 0x5D, 0x12, 0xBE, 0x85, 0x3C, 0x98, 0x76, 0x7A, 0xDF, 0x7C, 0x13, 0x0C,
     0x1A
};
 
uint8_t aMessage[] = "ASymmetric Crypto Demonstration";
uint16_t wMsgLen = ( uint16_t )sizeof(aMessage);
 
phCryptoASym_Sw_DataParams_t stCryptoASym;
phKeyStore_Sw_DataParams_t stKeyStore;
phKeyStore_Sw_KeyEntry_t aKeyEntry[KEY_ENTRIES];
phKeyStore_Sw_KeyVersionPair_t aKeyVersion[KEY_VERSION_PAIRS];
phKeyStore_Sw_KUCEntry_t aKeyUsageCounter[KEY_USAGE_COUNTER];
 
/* Initialize software keystore component. */
CHECK_SUCCESS(phKeyStore_Sw_Init(&stKeyStore, sizeof(stKeyStore), aKeyEntry, KEY_ENTRIES, aKeyVersion, 2,
     aKeyUsageCounter, KEY_USAGE_COUNTER), TRUE);
 
/* Initialize ASymmetric component. */
CHECK_SUCCESS(phCryptoASym_Sw_Init(&stCryptoASym, sizeof(stCryptoASym), &stKeyStore, aInternalBuffer, wInternalBuffSize), TRUE);
 
/* Load keys to Keystore */
PH_CHECK_SUCCESS_FCT(wStatus, phKeyStore_FormatKeyEntry(&stKeyStore, bKeyNo, wKeyType));
 
/* Load a Private Key */
wKeyInfo = (uint16_t) ( ( ( KEY_PAIR_PRIVATE_KEY + 1 ) << 12 ) | wKeyFormat );
PH_CHECK_SUCCESS_FCT(wStatus, phKeyStore_SetKeyASym(&stKeyStore, KEY_ADDRESS, KEY_PAIR_PRIVATE_KEY, PH_KEYSTORE_KEY_TYPE_ECC, wKeyInfo,
     aPrivateKey, ( uint16_t ) sizeof(aPrivateKey)));
 
/* Load a Public Key */
wKeyInfo = (uint16_t) ( ( ( KEY_PAIR_PUBLIC_KEY + 1 ) << 12 ) | wKeyFormat );
PH_CHECK_SUCCESS_FCT(wStatus, phKeyStore_SetKeyASym(&stKeyStore, KEY_ADDRESS, KEY_PAIR_PUBLIC_KEY, PH_KEYSTORE_KEY_TYPE_ECC, wKeyInfo,
     aPublicKey, ( uint16_t ) sizeof(aPublicKey)));
 
/* Set the key format to CryptoASym Layer.
 *   Binary format is used in this example.
 *   Binary format is nothing but uncompressed point representation format in big endian.
 *   Its mandatory to set the curve type in case of binary format is used for loading of keys.
 */
CHECK_SUCCESS(phCryptoASym_SetConfig(&stCryptoASym, PH_CRYPTOASYM_CONFIG_CURVE_ID, PH_CRYPTOASYM_CURVE_ID_SECP256R1), TRUE);
 
/* Perfom LoadKey to load a private key from keystore */
CHECK_SUCCESS(phCryptoASym_LoadKey(&stCryptoASym, PH_CRYPTOASYM_KEYMODE_EPHEMERAL, KEY_ADDRESS, KEY_PAIR_PRIVATE_KEY, PH_CRYPTOASYM_KEY_TYPE_ECC), TRUE);
 
/* Perfom LoadKey to load a public key from keystore */
CHECK_SUCCESS(phCryptoASym_LoadKey(&stCryptoASym, PH_CRYPTOASYM_KEYMODE_EPHEMERAL, KEY_ADDRESS, KEY_PAIR_PUBLIC_KEY, PH_CRYPTOASYM_KEY_TYPE_ECC), TRUE);
 
/* Print the Message. */
printf("\tMessage\n");
printf("\t                 Hex: ");
PrintData(aMessage, (wMsgLen - 1), "%02X ", "\n");
PrintASCII(aMessage, wMsgLen);
printf("\n\n");
 
/*  Sign the message. */
CHECK_SUCCESS(phCryptoASym_Sign(&stCryptoASym, PH_EXCHANGE_DEFAULT, PH_CRYPTOASYM_HASH_ALGO_SHA256, aMessage, wMsgLen,
     aSignature, &wSignLen), TRUE);
 
/* Print the Signature. */
printf("\tSignature\n");
printf("\t                 Hex: ");
PrintData(aSignature, wSignLen, "%02X ", "\n");
printf("\n");
 
 
 
 
/* Function to print the bytes in ASCII. */
void PrintASCII(uint8_t * pBuffer, uint16_t wKeyLen)
{
     uint16_t wITeration = 0;
     printf("\t               ASCII: ");
 
     /* Null Character Removed. */
     --wKeyLen;
 
     for(wITeration = 0; wITeration < wKeyLen; wITeration++)
     {
         printf("%c", pBuffer[wITeration]);
 
         if(pBuffer[wITeration] == 0x0A)
             printf("\t                      ");
     }
 
     printf("\n");
}
 
 
 
/* Function to print the bytes. */
void PrintData(uint8_t* pBuffer, uint32_t dwLength, char* pFormat, char* pSpecialChar)
{
 uint32_t dwSplit_Count = 128;
 uint32_t dwIndex1 = 0;
 uint32_t dwIndex2 = 0;
 
 for(dwIndex1 = 0; dwIndex1 < dwLength;dwIndex1++)
 {
     printf(pFormat, pBuffer[dwIndex1]);
 
     dwIndex2++;
     if(dwIndex2 > (dwSplit_Count - 1))
     {
         printf("\n\t                      ");
         dwIndex2 = 0;
     }
 }
 
 printf(pSpecialChar);
}