corePKCS11 管理和随机数演示

/* The CK_FUNCTION_LIST is a structure that contains the Cryptoki version


 * and a function pointer to each function in the Cryptoki API. If the


 * function pointer is NULL it is unimplemented. 


 */

CK_FUNCTION_LIST_PTR pxFunctionList = NULL;



/* We use the function list returned by C_GetFunctionList to see what functions


 * the Cryptoki library supports. We use asserts to ensure that all the


 * functionality needed in this demo is available. 


 */

xResult = C_GetFunctionList( &pxFunctionList );

configASSERT( xResult == CKR_OK );

configASSERT( pxFunctionList != NULL );

configASSERT( pxFunctionList->C_Initialize != NULL );

configASSERT( pxFunctionList->C_GetSlotList != NULL );

configASSERT( pxFunctionList->C_OpenSession != NULL );

configASSERT( pxFunctionList->C_Login != NULL );

configASSERT( pxFunctionList->C_GenerateRandom != NULL );

configASSERT( pxFunctionList->C_CloseSession != NULL );

configASSERT( pxFunctionList->C_Finalize != NULL ); 

/* This Cryptoki library does not implement any initialization arguments. At the time of


 * writing this demo, the purpose of these optional arguments is to provide


 * function pointers for mutex operations.  


 */

CK_C_INITIALIZE_ARGS xInitArgs = { 0 };



/* C_Initialize will initialize the Cryptoki library and the hardware it


 * abstracts. 


 */

xResult = pxFunctionList->C_Initialize( &xInitArgs );

configASSERT( xResult == CKR_OK ); 

/* A slot ID is an integer that defines a slot. The Cryptoki definition of


 * a slot is "A logical reader that potentially contains a token."


 *


 * Essentially it is an abstraction for accessing the token. The reason for


 * this is some tokens are a physical "card' that needs to be inserted into


 * a slot for the device to read.


 *


 * A concrete example of a slot could be a USB Hardware Security Module (HSM),


 * which generally appears as a singular slot, and abstracts it's internal "token".


 *


 * Some implementations have multiple slots mapped to a single token, or maps


 * a slot per token. 


 */

CK_SLOT_ID * pxSlotId = NULL;



/* CK_ULONG is a long unsigned integer as defined by PKCS #11. */

CK_ULONG xSlotCount = 0;



/* C_GetSlotList will retrieve an array of CK_SLOT_IDs.


 * This Cryptoki library does not implement slots, but it is important to


 * highlight how Cryptoki can be used to interface with real hardware.


 *


 * By setting the first argument "tokenPresent" to true, we only retrieve


 * slots that have a token. If the second argument "pSlotList" is NULL, the


 * third argument "pulCount" will be modified to contain the total slots. 


 */

xResult = pxFunctionList->C_GetSlotList( CK_TRUE,

                                         NULL,

                                         &xSlotCount );

configASSERT( xResult == CKR_OK );



/* Since C_GetSlotList does not allocate the memory itself for getting a list


 * of CK_SLOT_ID, we allocate one for it to populate with the list of


 * slot ids. 


 */

pxSlotId = pvPortMalloc( sizeof( CK_SLOT_ID ) * ( xSlotCount ) );

configASSERT( pxSlotId != NULL );



/* Now since pSlotList is not NULL, C_GetSlotList will populate it with the


 * available slots. 


 */

xResult = pxFunctionList->C_GetSlotList( CK_TRUE,

                                         pxSlotId,

                                         &xSlotCount );

configASSERT( xResult == CKR_OK );

/* A session is defined to be "The logical connection between an application


 * and a token."


 *


 * The session can either be private or public, and differentiates


 * your application from the other users of the token. 


 */

CK_SESSION_HANDLE hSession = CK_INVALID_HANDLE;



/* Since this Cryptoki library does not actually implement the concept of slots,


 * but we will use the first available slot, so the demo code conforms to


 * Cryptoki.


 *


 * C_OpenSession will establish a session between the application and


 * the token and we can then use the returned CK_SESSION_HANDLE for


 * cryptographic operations with the token.


 *


 * For legacy reasons, Cryptoki demands that the CKF_SERIAL_SESSION bit


 * is always set. 


 */

xResult = pxFunctionList->C_OpenSession( pxSlotId[0],

                                         CKF_SERIAL_SESSION | CKF_RW_SESSION,

                                         NULL, /* Application defined pointer. */

                                         NULL, /* Callback function. */

                                         &hSession );

configASSERT( xResult == CKR_OK );

/* CK_BYTE is a PKCS #11 type that is defined as an unsigned char. */

CK_BYTE xRandomData[ 10 ] = { 0 };



/* C_GenerateRandom generates random or pseudo random data. As arguments it


 * takes the application session, and a pointer to a byte buffer, as well as


 * the length of the byte buffer. Then it will fill this buffer with random


 * bytes. 


 */

xResult = pxFunctionList->C_GenerateRandom( hSession,

                                            xRandomData,

                                            sizeof( xRandomData ) );

configASSERT( xResult == CKR_OK );



for( ulIndex = 0; ulIndex < sizeof( xRandomData ); ulIndex++ )

{

    configPRINTF( ( "Generated random number: %x\r\n", xRandomData[ ulIndex ] ) );

}

/* C_CloseSession closes the session that was established between the


 * application and the token. This will clean up the resources that maintained


 * the link between the application and the token. If the application wishes


 * to use the token again, it will need to open a new session. 


 */

xResult = pxFunctionList->C_CloseSession( hSession );

configASSERT( xResult == CKR_OK );



/* C_Finalize signals to the Cryptoki library that the application is done


 * using it. It should always be the last call to the Cryptoki library.


 * NULL should always be passed as the argument, as the parameter is currently


 * just reserved for future revisions.


 *


 * Calling this function in a multi threaded environment can lead to undefined


 * behavior if other threads are accessing the Cryptoki library. 


 */

xResult = pxFunctionList->C_Finalize( NULL );

configASSERT( xResult == CKR_OK );