Migrating Keys From Software to a Luna PCIe HSM
Luna PCIe HSMs expect key material to be in PKCS#8 format. PKCS#8 format follows BER (Basic encoding rules)/DER (distinguished encoding rules) encoding. An example of this format can be found in the document "Some examples of PKCS standards" produced by RSA, and available on their web site (http://www.rsasecurity.com/rsalabs/pkcs/index.html at the bottom of the page, under “Related Documents”).
Here is an example of a formatted key:
0x30, 0x82, 0x04, 0xbc, 0x02, 0x01, 0x00, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x04, 0x82, 0x04, 0xa6, 0x30, 0x82, 0x04, 0xa2, 0x02, 0x01, 0x00, 0x02, 0x82, 0x01, 0x01, 0x00, 0xb8, 0xb5, 0x0f, 0x49, 0x46, 0xb5, 0x5d, 0x58, 0x04, 0x8e, 0x52, 0x59, 0x39, 0xdf, 0xd6, 0x29, 0x45, 0x6b, 0x6c, 0x96, 0xbb, 0xab, 0xa5, 0x6f, 0x72, 0x1b, 0x16, 0x96, 0x74, 0xd5, 0xf9, 0xb4, 0x41, 0xa3, 0x7c, 0xe1, 0x94, 0x73, 0x4b, 0xa7, 0x23, 0xff, 0x61, 0xeb, 0xce, 0x5a, 0xe7, 0x7f, 0xe3, 0x74, 0xe8, 0x52, 0x5b, 0xd6, 0x5d, 0x5c, 0xdc, 0x98, 0x49, 0xfe, 0x51, 0xc2, 0x7e, 0x8f, 0x3b, 0x37, 0x5c, 0xb3, 0x11, 0xed, 0x85, 0x91, 0x15, 0x92, 0x24, 0xd8, 0xf1, 0x7b, 0x3d, 0x2f, 0x8b, 0xcd, 0x1b, 0x30, 0x14, 0xa3, 0x6b, 0x1b, 0x4d, 0x27, 0xff, 0x6a, 0x58, 0x84, 0x9e, 0x79, 0x94, 0xca, 0x78, 0x64, 0x01, 0x33, 0xc3, 0x58, 0xfc, 0xd3, 0x83, 0xeb, 0x2f, 0xab, 0x6f, 0x85, 0x5a, 0x38, 0x41, 0x3d, 0x73, 0x20, 0x1b, 0x82, 0xbc, 0x7e, 0x76, 0xde, 0x5c, 0xfe, 0x42, 0xd6, 0x7b, 0x86, 0x4f, 0x79, 0x78, 0x29, 0x82, 0x87, 0xa6, 0x24, 0x43, 0x39, 0x74, 0xfe, 0xf2, 0x0c, 0x08, 0xbe, 0xfa, 0x1e, 0x0a, 0x48, 0x6f, 0x14, 0x86, 0xc5, 0xcd, 0x9a, 0x98, 0x09, 0x2d, 0xf3, 0xf3, 0x5a, 0x7a, 0xa4, 0xe6, 0x8a, 0x2e, 0x49, 0x8a, 0xde, 0x73, 0xe9, 0x37, 0xa0, 0x5b, 0xef, 0xd0, 0xe0, 0x13, 0xac, 0x88, 0x5f, 0x59, 0x47, 0x96, 0x7f, 0x78, 0x18, 0x0e, 0x44, 0x6a, 0x5d, 0xec, 0x6e, 0xed, 0x4f, 0xf6, 0x6a, 0x7a, 0x58, 0x6b, 0xfe, 0x6c, 0x5a, 0xb9, 0xd2, 0x22, 0x3a, 0x1f, 0xdf, 0xc3, 0x09, 0x3f, 0x6b, 0x2e, 0xf1, 0x6d, 0xc3, 0xfb, 0x4e, 0xd4, 0xf2, 0xa3, 0x94, 0x13, 0xb0, 0xbf, 0x1e, 0x06, 0x2e, 0x29, 0x55, 0x00, 0xaa, 0x98, 0xd9, 0xe8, 0x77, 0x84, 0x8b, 0x3f, 0x5f, 0x5e, 0xf7, 0xf8, 0xa7, 0xe6, 0x02, 0xd2, 0x18, 0xb0, 0x52, 0xd0, 0x37, 0x2e, 0x53, 0x02, 0x03, 0x01, 0x00, 0x01, 0x02, 0x82, 0x01, 0x00, 0x0c, 0xdf, 0xd1, 0xe8, 0xf1, 0x9c, 0xc2, 0x9c, 0xd7, 0xf4, 0x73, 0x98, 0xf4, 0x87, 0xbd, 0x8d, 0xb2, 0xe1, 0x01, 0xf8, 0x9f, 0xac, 0x1f, 0x23, 0xdd, 0x78, 0x35, 0xe2, 0xd6, 0xd1, 0xf3, 0x4d, 0xb5, 0x25, 0x88, 0x16, 0xd1, 0x1a, 0x18, 0x33, 0xd6, 0x36, 0x7e, 0xc4, 0xc8, 0xe5, 0x5d, 0x2d, 0x74, 0xd5, 0x39, 0x3c, 0x44, 0x5a, 0x74, 0xb7, 0x7c, 0x48, 0xc1, 0x1f, 0x90, 0xe3, 0x55, 0x9e, 0xf6, 0x29, 0xad, 0xb4, 0x6d, 0x93, 0x78, 0xb3, 0xdc, 0x25, 0x0b, 0x9c, 0x73, 0x78, 0x7b, 0x93, 0x4c, 0xd3, 0x47, 0x09, 0xda, 0xe6, 0x69, 0x18, 0xc6, 0x0f, 0xfb, 0xa5, 0x95, 0xf5, 0xe8, 0x75, 0xe1, 0x01, 0x1b, 0xd3, 0x1c, 0xa2, 0x57, 0x03, 0x64, 0xdb, 0xf9, 0x5d, 0xf3, 0x3c, 0xa7, 0xd1, 0x4b, 0xb0, 0x90, 0x1b, 0x90, 0x62, 0xb4, 0x88, 0x30, 0x4b, 0x40, 0x4d, 0xcf, 0x7d, 0x89, 0x7a, 0xfb, 0x29, 0xc9, 0x64, 0x34, 0x0a, 0x52, 0xf6, 0x70, 0x7c, 0x76, 0x5a, 0x2e, 0x8f, 0x50, 0xd4, 0x92, 0x15, 0x97, 0xed, 0x4c, 0x2e, 0xf2, 0x3a, 0xd0, 0x58, 0x7e, 0xdb, 0xf1, 0xf4, 0xdd, 0x07, 0x76, 0x04, 0xf0, 0x55, 0x8b, 0x72, 0x2b, 0xa7, 0xa8, 0x78, 0x78, 0x67, 0xe6, 0xd8, 0xa5, 0xde, 0xe7, 0xc9, 0x1f, 0x5a, 0xa0, 0x89, 0xc7, 0x24, 0xa2, 0x71, 0xb6, 0x7b, 0x3b, 0xe6, 0x92, 0x69, 0x22, 0xaa, 0xe2, 0x47, 0x4b, 0x80, 0x3f, 0x6a, 0xab, 0xce, 0x4e, 0xcd, 0xe8, 0x94, 0x6c, 0xf7, 0x84, 0x73, 0x85, 0xfd, 0x85, 0x1d, 0xae, 0x81, 0xf7, 0xec, 0x12, 0x31, 0x7d, 0xc1, 0x99, 0xc0, 0x3c, 0x51, 0xb0, 0xdc, 0xb0, 0xba, 0x9c, 0x84, 0xb8, 0x70, 0xc2, 0x09, 0x7f, 0x96, 0x3d, 0xa1, 0xe2, 0x64, 0x27, 0x7a, 0x22, 0xb8, 0x75, 0xb9, 0xd1, 0x5f, 0xa5, 0x23, 0xf9, 0x62, 0xe0, 0x41, 0x02, 0x81, 0x81, 0x00, 0xf4, 0xf3, 0x08, 0xcf, 0x83, 0xb0, 0xab, 0xf2, 0x0f, 0x1a, 0x08, 0xaf, 0xc2, 0x42, 0x29, 0xa7, 0x9c, 0x5e, 0x52, 0x19, 0x69, 0x8d, 0x5b, 0x52, 0x29, 0x9c, 0x06, 0x6a, 0x5a, 0x32, 0x8f, 0x08, 0x45, 0x6c, 0x43, 0xb5, 0xac, 0xc3, 0xbb, 0x90, 0x7b, 0xec, 0xbb, 0x5d, 0x71, 0x25, 0x82, 0xf8, 0x40, 0xbf, 0x38, 0x00, 0x20, 0xf3, 0x8a, 0x38, 0x43, 0xde, 0x04, 0x41, 0x19, 0x5f, 0xeb, 0xb0, 0x50, 0x59, 0x10, 0xe1, 0x54, 0x62, 0x5c, 0x93, 0xd9, 0xdc, 0x63, 0x24, 0xd0, 0x17, 0x00, 0xc0, 0x44, 0x3e, 0xfc, 0xd1, 0xda, 0x4b, 0x24, 0xf7, 0xcb, 0x16, 0x35, 0xe6, 0x9f, 0x67, 0x96, 0x5f, 0xb0, 0x94, 0xde, 0xfa, 0xa1, 0xfd, 0x8c, 0x8a, 0xd1, 0x5c, 0x02, 0x8d, 0xe0, 0xa0, 0xa0, 0x02, 0x1d, 0x56, 0xaf, 0x13, 0x3a, 0x65, 0x5e, 0x8e, 0xde, 0xd1, 0xa8, 0x28, 0x8b, 0x71, 0xc9, 0x65, 0x02, 0x81, 0x81, 0x00, 0xc1, 0x0a, 0x47, 0x39, 0x91, 0x06, 0x1e, 0xb9, 0x43, 0x7c, 0x9e, 0x97, 0xc5, 0x09, 0x08, 0xbc, 0x22, 0x47, 0xe2, 0x96, 0x8e, 0x1c, 0x74, 0x80, 0x50, 0x6c, 0x9f, 0xef, 0x2f, 0xe5, 0x06, 0x3e, 0x73, 0x66, 0x76, 0x02, 0xbd, 0x9a, 0x1c, 0xfc, 0xf9, 0x6a, 0xb8, 0xf9, 0x36, 0x15, 0xb5, 0x20, 0x0b, 0x6b, 0x54, 0x83, 0x9c, 0x86, 0xba, 0x13, 0xb7, 0x99, 0x54, 0xa0, 0x93, 0x0d, 0xd6, 0x1e, 0xc1, 0x12, 0x72, 0x0d, 0xea, 0xb0, 0x14, 0x30, 0x70, 0x73, 0xef, 0x6b, 0x4c, 0xae, 0xb6, 0xff, 0xd4, 0xbb, 0x89, 0xa1, 0xec, 0xca, 0xa6, 0xe9, 0x95, 0x56, 0xac, 0xe2, 0x9b, 0x97, 0x2f, 0x2c, 0xdf, 0xa3, 0x6e, 0x59, 0xff, 0xcd, 0x3c, 0x6f, 0x57, 0xcc, 0x6e, 0x44, 0xc4, 0x27, 0xbf, 0xc3, 0xdd, 0x19, 0x9e, 0x81, 0x16, 0xe2, 0x8f, 0x65, 0x34, 0xa7, 0x0f, 0x22, 0xba, 0xbf, 0x79, 0x57, 0x02, 0x81, 0x80, 0x2e, 0x21, 0x0e, 0xc9, 0xb5, 0xad, 0x31, 0xd4, 0x76, 0x0f, 0x9b, 0x0f, 0x2e, 0x70, 0x33, 0x54, 0x03, 0x58, 0xa7, 0xf1, 0x6d, 0x35, 0x57, 0xbb, 0x53, 0x66, 0xb4, 0xb6, 0x96, 0xa1, 0xea, 0xd9, 0xcd, 0xe9, 0x23, 0x9f, 0x35, 0x17, 0xef, 0x5c, 0xb8, 0x59, 0xce, 0xb7, 0x3c, 0x35, 0xaa, 0x42, 0x82, 0x3f, 0x00, 0x96, 0xd5, 0x9d, 0xc7, 0xab, 0xec, 0xec, 0x04, 0xb5, 0x15, 0xc8, 0x40, 0xa4, 0x85, 0x9d, 0x20, 0x56, 0xaf, 0x03, 0x8f, 0x17, 0xb0, 0xf1, 0x96, 0x22, 0x3a, 0xa5, 0xfa, 0x58, 0x3b, 0x01, 0xf9, 0xae, 0xb3, 0x83, 0x6f, 0x44, 0xd3, 0x14, 0x2d, 0xb6, 0x6e, 0xd2, 0x9d, 0x39, 0x0c, 0x12, 0x1d, 0x23, 0xea, 0x19, 0xcb, 0xbb, 0xe0, 0xcd, 0x89, 0x15, 0x9a, 0xf5, 0xe4, 0xec, 0x41, 0x06, 0x30, 0x16, 0x58, 0xea, 0xfa, 0x31, 0xc1, 0xb8, 0x8e, 0x08, 0x84, 0xaa, 0x3b, 0x19, 0x02, 0x81, 0x80, 0x70, 0x4c, 0xf8, 0x6e, 0x86, 0xed, 0xd6, 0x85, 0xd4, 0xba, 0xf4, 0xd0, 0x3a, 0x32, 0x2d, 0x40, 0xb5, 0x78, 0xb8, 0x5a, 0xf9, 0xc5, 0x98, 0x08, 0xe5, 0xc0, 0xab, 0xb2, 0x4c, 0x5c, 0xa2, 0x2b, 0x46, 0x9b, 0x3e, 0xe0, 0x0d, 0x49, 0x50, 0xbf, 0xe2, 0xa1, 0xb1, 0x86, 0x59, 0x6e, 0x7b, 0x76, 0x6e, 0xee, 0x3b, 0xb6, 0x6d, 0x22, 0xfb, 0xb1, 0x68, 0xc7, 0xec, 0xb1, 0x95, 0x9b, 0x21, 0x0b, 0xb7, 0x2a, 0x71, 0xeb, 0xa2, 0xb2, 0x58, 0xac, 0x6d, 0x5f, 0x24, 0xd3, 0x79, 0x42, 0xd2, 0xf7, 0x35, 0xdc, 0xfc, 0x0e, 0x95, 0x60, 0xb7, 0x85, 0x7f, 0xf9, 0x72, 0x8e, 0x4a, 0x11, 0xc3, 0xc2, 0x09, 0x40, 0x5c, 0x7c, 0x43, 0x12, 0x34, 0xac, 0x59, 0x99, 0x76, 0x34, 0xcf, 0x20, 0x88, 0xb0, 0xfb, 0x39, 0x62, 0x3a, 0x9b, 0x03, 0xa6, 0x84, 0x2c, 0x03, 0x5c, 0x0c, 0xca, 0x33, 0x85, 0xf5, 0x02, 0x81, 0x80, 0x56, 0x99, 0xe9, 0x17, 0xdc, 0x33, 0xe1, 0x33, 0x8d, 0x5c, 0xba, 0x17, 0x32, 0xb7, 0x8c, 0xbd, 0x4b, 0x7f, 0x42, 0x3a, 0x79, 0x90, 0xe3, 0x70, 0xe3, 0x27, 0xce, 0x22, 0x59, 0x02, 0xc0, 0xb1, 0x0e, 0x57, 0xf5, 0xdf, 0x07, 0xbf, 0xf8, 0x4e, 0x10, 0xef, 0x2a, 0x62, 0x30, 0x03, 0xd4, 0x80, 0xcf, 0x20, 0x84, 0x25, 0x66, 0x3f, 0xc7, 0x4f, 0x56, 0x8c, 0x1e, 0xe1, 0x18, 0x91, 0xc1, 0xfd, 0x71, 0x5f, 0x65, 0x9b, 0xe4, 0x4f, 0xe0, 0x1a, 0x3a, 0xf8, 0xc1, 0x69, 0xdb, 0xd3, 0xbb, 0x8d, 0x91, 0xd1, 0x11, 0x4f, 0x7e, 0x91, 0x1b, 0xb4, 0x27, 0xa5, 0xab, 0x7c, 0x7b, 0x76, 0xd4, 0x78, 0xfe, 0x63, 0x44, 0x63, 0x7e, 0xe3, 0xa6, 0x60, 0x4f, 0xb9, 0x55, 0x28, 0xba, 0xba, 0x83, 0x1a, 0x2d, 0x43, 0xd5, 0xf7, 0x2e, 0xe0, 0xfc, 0xa8, 0x14, 0x9b, 0x91, 0x2a, 0x36, 0xbf, 0xc7, 0x14
The example above contains the exponent, the modulus, and private key material.
Other Formats of Key Material
The format of key material depends on the application, and is therefore unpredictable. Key material commonly exists in any of the following formats; ASN1, PEM, P12, PFX, etc. Key material in those formats, or in another format, can likely be re-formatted to be acceptable for moving onto the Luna PCIe HSM.
Sample Program
The sample program below encrypts a known RSA private key, then unwraps the key pair onto the Luna PCIe HSM Partition.
/****************************************************************************\
*
* File: UnwrapKey.cpp*
* Encrypts a PrivateKeyInfo structure with a generated DES key and then
* unwraps the RSA key onto a token.
*
* This file is provided as an example only.
*
*
* Copyright (C) 2020, Thales Group.
*
* All rights reserved. This file contains information that is
* proprietary to SafeNet, Inc. and may not be
* distributed or copied without written consent from
* SafeNet, Inc.
*
\**************************************************************/
#ifdef UNIX
#define _POSIX_SOURCE 1
#endif
#ifdef USING_STATIC_CHRYSTOKI
# define STATIC ckdemo_cpp
#endif
#include <assert.h>
#include <iostream.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <time.h>
#ifdef _WINDOWS
#include <conio.h>
#include <io.h>
#include <windows.h>
#endif
#ifdef UNIX
#include <unistd.h>
#endif
#include "source/cryptoki.h"
#include "source/Ckbridge.h"
#define DIM(a) (sizeof(a)/sizeof(a[0]))
CK_BBOOL no = FALSE;
CK_BBOOL yes = TRUE;
const int MAX =100;
// Function Prototypes
CK_RV Pinlogin(CK_SESSION_HANDLE hSession);
int getPinString(CK_CHAR_PTR pw);
// Main
int main( void )
{int error = 0;
CK_RV retCode = CKR_OK;
CK_SESSION_HANDLE hSessionHandle;
CK_CHAR_PTR userPIN = (CK_CHAR_PTR)"default";
CK_USHORT lenuserPIN = 7;
CK_CHAR_PTR soPIN = (CK_CHAR_PTR)"default";
CK_USHORT lensoPIN = 7;
CK_USHORT usNumberOfSlots;
CK_SLOT_ID_PTR pSlotList;
CK_OBJECT_HANDLE hKey;
CK_MECHANISM mech;
CK_VERSION version;
struct
{CK_INFO info;
char reserved[100]; // This is in case the library that we are
// talking to requires a larger info structure
// then the one defined.
} protectedInfo;
//Disclaimer
cout << "\n\n\n\n";
cout << "THE SOFTWARE IS PROVIDED BY SAFENET INCORPORATED (SAFENET) ON AN 'AS IS' BASIS, \n";
cout << "WITHOUT ANY OTHER WARRANTIES OR CONDITIONS, EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED \n";
cout << "TO, WARRANTIES OF MERCHANTABLE QUALITY, SATISFACTORY QUALITY, MERCHANTABILITY OR FITNESS FOR\n";
cout << "A PARTICULAR PURPOSE, OR THOSE ARISING BY LAW, STATUTE, USAGE OF TRADE, COURSE OF DEALING OR\n";
cout << "OTHERWISE. SAFENET DOES NOT WARRANT THAT THE SOFTWARE WILL MEET YOUR REQUIREMENTS OR \n";
cout << "THAT OPERATION OF THE SOFTWARE WILL BE UNINTERRUPTED OR THAT THE SOFTWARE WILL BE ERROR-FREE.\n";
cout << "YOU ASSUME THE ENTIRE RISK AS TO THE RESULTS AND PERFORMANCE OF THE SOFTWARE. NEITHER \n";
cout << "SAFENET NOR OUR LICENSORS, DEALERS OR SUPPLIERS SHALL HAVE ANY LIABILITY TO YOU OR ANY\n";
cout << "OTHER PERSON OR ENTITY FOR ANY INDIRECT, INCIDENTAL, SPECIAL, CONSEQUENTIAL, PUNITIVE, \n";
cout << "EXEMPLARY OR AY OTHER DAMAGES WHATSOEVER, INCLUDING, BUT NOT LIMITED TO, LOSS OF REVENUE OR \n";
cout << "PROFIT, LOST OR DAMAGED DATA, LOSS OF USE OR OTHER COMMERCIAL OR ECONOMIC LOSS, EVEN IF \n";
cout << "SAFENET HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES, OR THEY ARE FORESEEABLE. \n";
cout << "SAFENET IS ALSO NOT RESPONSIBLE FOR CLAIMS BY A THIRD PARTY. THE MAXIMUM AGGREGATE \n";
cout << "LIABILITY OF SAFENET TO YOU AND THAT OF SAFENET’S LICENSORS, DEALERS AND SUPPLIERS \n";
cout << "SHALL NOT EXCEED FORTY DOLLARS ($40.00CDN). THE LIMITATIONS IN THIS SECTION SHALL APPLY \n";
cout << "WHETHER OR NOT THE ALLEGED BREACH OR DEFAULT IS A BREACH OF A FUNDAMENTAL CONDITION OR TERM \n";
cout << "OR A FUNDAMENTAL BREACH. SOME STATES/COUNTRIES DO NOT ALLOW THE EXCLUSION OR LIMITATION OF\n";
cout << "LIABILITY FOR CONSEQUENTIAL OR INCIDENTAL DAMAGES, SO THE ABOVE LIMITATION MAY NOT APPLY TO \n";
cout << "YOU.\n";
cout << "THE LIMITED WARRANTY, EXCLUSIVE REMEDIES AND LIMITED LIABILITY SET OUT HEREIN ARE FUNDAMENTAL \n";
cout << "ELEMENTS OF THE BASIS OF THE BARGAIN BETWEEN YOU AND SAFENET. \n";
cout << "NO SUPPORT. YOU ACKNOWLEDGE AND AGREE THAT THERE ARE NO SUPPORT SERVICES PROVIDED BY SAFENET\n";
cout << "INCORPORATED FOR THIS SOFTWARE\n" << endl;
// Display Generic Warning
cout << "\nInsert a token for the test...";
cout << "\n\nWARNING!!! This test initializes the first ";
cout << " token detected in the card reader.";
cout << "\nDo not use a token that you don't want erased.";
cout << "\nYou can use CTRL-C to abort now...Otherwise...";
cout << "\n\n... press <Enter> key to continue ...\n";
cout.flush();
getchar(); // Wait for keyboard hit
#ifndef STATIC
// Connect to Chrystoki
if(!CrystokiConnect())
{cout << "\n" "Unable to connect to Chrystoki. Error = " << LibError() << "\n";
error = -1;
goto exit_routine_1;
}
#endif
// Verify this is the version of the library required
retCode = C_GetInfo(&protectedInfo.info);
if( retCode != CKR_OK )
{cout << endl << "Unable to call C_GetInfo() before C_Initialize()\n";
error = -2;
goto exit_routine_2;
}
else
{CK_BYTE majorVersion = protectedInfo.info.version.major;
CK_BYTE expectedVersion;
#ifndef PKCS11_2_0
expectedVersion = 1;
#else
expectedVersion = 2;
#endif
if( expectedVersion != majorVersion )
{cout << endl << "This version of the program was built for Cryptoki version "
<< (int)expectedVersion << ".\n"
<< "The loaded Cryptoki library reports its version to be "
<< (int)majorVersion << ".\n"
<< "Program will terminate.\n";
// Wait to exit until user read message and acknowledges
cout << endl << "Press <Enter> key to end.";
getchar(); // Wait for keyboard hit
error = -3;
goto exit_routine_2;
}
}
// Initialize the Library
retCode = C_Initialize(NULL);
if(retCode != CKR_OK)
{cout << "\n" "Error 0x" << hex << retCode << " initializing cryptoki.\n";
error = -4;
goto exit_routine_3;
}
// Get the number of tokens possibly available
retCode = C_GetSlotList(TRUE, NULL, &usNumberOfSlots);
if(retCode != CKR_OK)
{cout << "\n" "Error 0x" << hex << retCode << " getting slot list.\n";
error = -5;
goto exit_routine_3;
}
// Are any tokens present?
if(usNumberOfSlots == 0)
{cout << "\n" "No tokens found\n";
error = -6;
goto exit_routine_3;
}
// Get a list of slots
pSlotList = new CK_SLOT_ID[usNumberOfSlots];
retCode = C_GetSlotList(TRUE, pSlotList, &usNumberOfSlots);
if(retCode != CKR_OK)
{cout << "\n" "Error 0x" << hex << retCode << " getting slot list.\n";
error = -7;
goto exit_routine_4;
}
// Open a session
retCode = C_OpenSession(pSlotList[0], CKF_RW_SESSION | CKF_SERIAL_SESSION,
NULL, NULL, &hSessionHandle);
if(retCode != CKR_OK)
{cout << "\n" "Error 0x" << hex << retCode << " opening session.\n";
error = -9;
goto exit_routine_4;
}
Pinlogin(hSessionHandle);
if(retCode != CKR_OK)
{cout << "\n" "Error 0x" << hex << retCode << " Calling PinLogin fn";
exit(hSessionHandle);
}
// Encrypt an RSA Key and then unwrap it onto the token
{// The following is an RSA Key that is formatted as a PrivateKeyInfo structure
//BER encoded format
const
CK_BYTE pRsaKey[] = {0x30, 0x82, 0x04, 0xbc, 0x02, 0x01, 0x00, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01,
0x01, 0x05, 0x00, 0x04,
0x82, 0x04, 0xa6, 0x30, 0x82, 0x04, 0xa2, 0x02, 0x01, 0x00, 0x02, 0x82, 0x01, 0x01, 0x00, 0xb8, 0xb5, 0x0f, 0x49,
0x46, 0xb5, 0x5d, 0x58,
0x04, 0x8e, 0x52, 0x59, 0x39, 0xdf, 0xd6, 0x29, 0x45, 0x6b, 0x6c, 0x96, 0xbb, 0xab, 0xa5, 0x6f, 0x72, 0x1b, 0x16,
0x96, 0x74, 0xd5, 0xf9,
0xb4, 0x41, 0xa3, 0x7c, 0xe1, 0x94, 0x73, 0x4b, 0xa7, 0x23, 0xff, 0x61, 0xeb, 0xce, 0x5a, 0xe7, 0x7f, 0xe3, 0x74,
0xe8, 0x52, 0x5b, 0xd6,
0x5d, 0x5c, 0xdc, 0x98, 0x49, 0xfe, 0x51, 0xc2, 0x7e, 0x8f, 0x3b, 0x37, 0x5c, 0xb3, 0x11, 0xed, 0x85, 0x91, 0x15,
0x92, 0x24, 0xd8, 0xf1,
0x7b, 0x3d, 0x2f, 0x8b, 0xcd, 0x1b, 0x30, 0x14, 0xa3, 0x6b, 0x1b, 0x4d, 0x27, 0xff, 0x6a, 0x58, 0x84, 0x9e, 0x79,
0x94, 0xca, 0x78, 0x64,
0x01, 0x33, 0xc3, 0x58, 0xfc, 0xd3, 0x83, 0xeb, 0x2f, 0xab, 0x6f, 0x85, 0x5a, 0x38, 0x41, 0x3d, 0x73, 0x20, 0x1b,
0x82, 0xbc, 0x7e, 0x76,
0xde, 0x5c, 0xfe, 0x42, 0xd6, 0x7b, 0x86, 0x4f, 0x79, 0x78, 0x29, 0x82, 0x87, 0xa6, 0x24, 0x43, 0x39, 0x74, 0xfe,
0xf2, 0x0c, 0x08, 0xbe,
0xfa, 0x1e, 0x0a, 0x48, 0x6f, 0x14, 0x86, 0xc5, 0xcd, 0x9a, 0x98, 0x09, 0x2d, 0xf3, 0xf3, 0x5a, 0x7a, 0xa4, 0xe6,
0x8a, 0x2e, 0x49, 0x8a, 0xde, 0x73, 0xe9, 0x37, 0xa0, 0x5b, 0xef,
0xd0, 0xe0, 0x13, 0xac, 0x88, 0x5f, 0x59, 0x47, 0x96, 0x7f, 0x78, 0x18, 0x0e, 0x44, 0x6a, 0x5d, 0xec, 0x6e, 0xed,
0x4f, 0xf6, 0x6a, 0x7a,
0x58, 0x6b, 0xfe, 0x6c, 0x5a, 0xb9, 0xd2, 0x22, 0x3a, 0x1f, 0xdf, 0xc3, 0x09, 0x3f, 0x6b, 0x2e, 0xf1, 0x6d, 0xc3,
0xfb, 0x4e, 0xd4, 0xf2,
0xa3, 0x94, 0x13, 0xb0, 0xbf, 0x1e, 0x06, 0x2e, 0x29, 0x55, 0x00, 0xaa, 0x98, 0xd9, 0xe8, 0x77, 0x84, 0x8b, 0x3f,
0x5f, 0x5e, 0xf7, 0xf8,
0xa7, 0xe6, 0x02, 0xd2, 0x18, 0xb0, 0x52, 0xd0, 0x37, 0x2e, 0x53, 0x02, 0x03, 0x01, 0x00, 0x01, 0x02, 0x82, 0x01,
0x00, 0x0c, 0xdf, 0xd1,
0xe8, 0xf1, 0x9c, 0xc2, 0x9c, 0xd7, 0xf4, 0x73, 0x98, 0xf4, 0x87, 0xbd, 0x8d, 0xb2, 0xe1, 0x01, 0xf8, 0x9f, 0xac,
0x1f, 0x23, 0xdd, 0x78,
0x35, 0xe2, 0xd6, 0xd1, 0xf3, 0x4d, 0xb5, 0x25, 0x88, 0x16, 0xd1, 0x1a, 0x18, 0x33, 0xd6, 0x36, 0x7e, 0xc4, 0xc8,
0xe5, 0x5d, 0x2d, 0x74,
0xd5, 0x39, 0x3c, 0x44, 0x5a, 0x74, 0xb7, 0x7c, 0x48, 0xc1, 0x1f, 0x90, 0xe3, 0x55, 0x9e, 0xf6, 0x29, 0xad, 0xb4,
0x6d, 0x93, 0x78, 0xb3,
0xdc, 0x25, 0x0b, 0x9c, 0x73, 0x78, 0x7b, 0x93, 0x4c, 0xd3, 0x47, 0x09, 0xda, 0xe6, 0x69, 0x18, 0xc6, 0x0f, 0xfb,
0xa5, 0x95, 0xf5, 0xe8,
0x75, 0xe1, 0x01, 0x1b, 0xd3, 0x1c, 0xa2, 0x57, 0x03, 0x64, 0xdb, 0xf9, 0x5d, 0xf3, 0x3c, 0xa7, 0xd1, 0x4b, 0xb0,
0x90, 0x1b, 0x90, 0x62,
0xb4, 0x88, 0x30, 0x4b, 0x40, 0x4d, 0xcf, 0x7d, 0x89, 0x7a, 0xfb, 0x29, 0xc9, 0x64, 0x34, 0x0a, 0x52, 0xf6, 0x70,
0x7c, 0x76, 0x5a, 0x2e,
0x8f, 0x50, 0xd4, 0x92, 0x15, 0x97, 0xed, 0x4c, 0x2e, 0xf2, 0x3a, 0xd0, 0x58, 0x7e, 0xdb, 0xf1, 0xf4, 0xdd, 0x07,
0x76, 0x04, 0xf0, 0x55,
0x8b, 0x72, 0x2b, 0xa7, 0xa8, 0x78, 0x78, 0x67, 0xe6, 0xd8, 0xa5, 0xde, 0xe7, 0xc9, 0x1f, 0x5a, 0xa0, 0x89, 0xc7,
0x24, 0xa2, 0x71, 0xb6,
0x7b, 0x3b, 0xe6, 0x92, 0x69, 0x22, 0xaa, 0xe2, 0x47, 0x4b, 0x80, 0x3f, 0x6a, 0xab, 0xce, 0x4e, 0xcd, 0xe8, 0x94,
0x6c, 0xf7, 0x84, 0x73,
0x85, 0xfd, 0x85, 0x1d, 0xae, 0x81, 0xf7, 0xec, 0x12, 0x31, 0x7d, 0xc1, 0x99, 0xc0, 0x3c, 0x51, 0xb0, 0xdc, 0xb0,
0xba, 0x9c, 0x84, 0xb8,
0x70, 0xc2, 0x09, 0x7f, 0x96, 0x3d, 0xa1, 0xe2, 0x64, 0x27, 0x7a, 0x22, 0xb8, 0x75, 0xb9, 0xd1, 0x5f, 0xa5, 0x23,
0xf9, 0x62, 0xe0, 0x41,
0x02, 0x81, 0x81, 0x00, 0xf4, 0xf3, 0x08, 0xcf, 0x83, 0xb0, 0xab, 0xf2, 0x0f, 0x1a, 0x08, 0xaf, 0xc2, 0x42, 0x29,
0xa7, 0x9c, 0x5e, 0x52,
0x19, 0x69, 0x8d, 0x5b, 0x52, 0x29, 0x9c, 0x06, 0x6a, 0x5a, 0x32, 0x8f, 0x08, 0x45, 0x6c, 0x43, 0xb5, 0xac, 0xc3,
0xbb, 0x90, 0x7b, 0xec,
0xbb, 0x5d, 0x71, 0x25, 0x82, 0xf8, 0x40, 0xbf, 0x38, 0x00, 0x20, 0xf3, 0x8a, 0x38, 0x43, 0xde, 0x04, 0x41, 0x19,
0x5f, 0xeb, 0xb0, 0x50,
0x59, 0x10, 0xe1, 0x54, 0x62, 0x5c, 0x93, 0xd9, 0xdc, 0x63, 0x24, 0xd0, 0x17, 0x00, 0xc0, 0x44, 0x3e, 0xfc, 0xd1,
0xda, 0x4b, 0x24, 0xf7,
0xcb, 0x16, 0x35, 0xe6, 0x9f, 0x67, 0x96, 0x5f, 0xb0, 0x94, 0xde, 0xfa, 0xa1, 0xfd, 0x8c, 0x8a, 0xd1, 0x5c, 0x02,
0x8d, 0xe0, 0xa0, 0xa0,
0x02, 0x1d, 0x56, 0xaf, 0x13, 0x3a, 0x65, 0x5e, 0x8e, 0xde, 0xd1, 0xa8, 0x28, 0x8b, 0x71, 0xc9, 0x65, 0x02, 0x81,
0x81, 0x00, 0xc1, 0x0a,
0x47, 0x39, 0x91, 0x06, 0x1e, 0xb9, 0x43, 0x7c, 0x9e, 0x97, 0xc5, 0x09, 0x08, 0xbc, 0x22, 0x47, 0xe2, 0x96, 0x8e,
0x1c, 0x74, 0x80, 0x50,
0x6c, 0x9f, 0xef, 0x2f, 0xe5, 0x06, 0x3e, 0x73, 0x66, 0x76, 0x02, 0xbd, 0x9a, 0x1c, 0xfc, 0xf9, 0x6a, 0xb8, 0xf9,
0x36, 0x15, 0xb5, 0x20,
0x0b, 0x6b, 0x54, 0x83, 0x9c, 0x86, 0xba, 0x13, 0xb7, 0x99, 0x54, 0xa0, 0x93, 0x0d, 0xd6, 0x1e, 0xc1, 0x12, 0x72,
0x0d, 0xea, 0xb0, 0x14,
0x30, 0x70, 0x73, 0xef, 0x6b, 0x4c, 0xae, 0xb6, 0xff, 0xd4, 0xbb, 0x89, 0xa1, 0xec, 0xca, 0xa6, 0xe9, 0x95, 0x56,
0xac, 0xe2, 0x9b, 0x97,
0x2f, 0x2c, 0xdf, 0xa3, 0x6e, 0x59, 0xff, 0xcd, 0x3c, 0x6f, 0x57, 0xcc, 0x6e, 0x44, 0xc4, 0x27, 0xbf, 0xc3, 0xdd,
0x19, 0x9e, 0x81, 0x16,
0xe2, 0x8f, 0x65, 0x34, 0xa7, 0x0f, 0x22, 0xba, 0xbf, 0x79, 0x57, 0x02, 0x81, 0x80, 0x2e, 0x21, 0x0e, 0xc9, 0xb5,
0xad, 0x31, 0xd4, 0x76,
0x0f, 0x9b, 0x0f, 0x2e, 0x70, 0x33, 0x54, 0x03, 0x58, 0xa7, 0xf1, 0x6d, 0x35, 0x57, 0xbb, 0x53, 0x66, 0xb4, 0xb6,
0x96, 0xa1, 0xea, 0xd9,
0xcd, 0xe9, 0x23, 0x9f, 0x35, 0x17, 0xef, 0x5c, 0xb8, 0x59, 0xce, 0xb7, 0x3c, 0x35, 0xaa, 0x42, 0x82, 0x3f, 0x00,
0x96, 0xd5, 0x9d, 0xc7,
0xab, 0xec, 0xec, 0x04, 0xb5, 0x15, 0xc8, 0x40, 0xa4, 0x85, 0x9d, 0x20, 0x56, 0xaf, 0x03, 0x8f, 0x17, 0xb0, 0xf1,
0x96, 0x22, 0x3a, 0xa5,
0xfa, 0x58, 0x3b, 0x01, 0xf9, 0xae, 0xb3, 0x83, 0x6f, 0x44, 0xd3, 0x14, 0x2d, 0xb6, 0x6e, 0xd2, 0x9d, 0x39, 0x0c,
0x12, 0x1d, 0x23, 0xea,
0x19, 0xcb, 0xbb, 0xe0, 0xcd, 0x89, 0x15, 0x9a, 0xf5, 0xe4, 0xec, 0x41, 0x06, 0x30, 0x16, 0x58, 0xea, 0xfa, 0x31,
0xc1, 0xb8, 0x8e, 0x08,
0x84, 0xaa, 0x3b, 0x19, 0x02, 0x81, 0x80, 0x70, 0x4c, 0xf8, 0x6e, 0x86, 0xed, 0xd6, 0x85, 0xd4, 0xba, 0xf4, 0xd0,
0x3a, 0x32, 0x2d, 0x40,
0xb5, 0x78, 0xb8, 0x5a, 0xf9, 0xc5, 0x98, 0x08, 0xe5, 0xc0, 0xab, 0xb2, 0x4c, 0x5c, 0xa2, 0x2b, 0x46, 0x9b, 0x3e,
0xe0, 0x0d, 0x49, 0x50,
0xbf, 0xe2, 0xa1, 0xb1, 0x86, 0x59, 0x6e, 0x7b, 0x76, 0x6e, 0xee, 0x3b, 0xb6, 0x6d, 0x22, 0xfb, 0xb1, 0x68, 0xc7,
0xec, 0xb1, 0x95, 0x9b,
0x21, 0x0b, 0xb7, 0x2a, 0x71, 0xeb, 0xa2, 0xb2, 0x58, 0xac, 0x6d, 0x5f, 0x24, 0xd3, 0x79, 0x42, 0xd2, 0xf7, 0x35,
0xdc, 0xfc, 0x0e, 0x95,
0x60, 0xb7, 0x85, 0x7f, 0xf9, 0x72, 0x8e, 0x4a, 0x11, 0xc3, 0xc2, 0x09, 0x40, 0x5c, 0x7c, 0x43, 0x12, 0x34, 0xac,
0x59, 0x99, 0x76, 0x34,
0xcf, 0x20, 0x88, 0xb0, 0xfb, 0x39, 0x62, 0x3a, 0x9b, 0x03, 0xa6, 0x84, 0x2c, 0x03, 0x5c, 0x0c, 0xca, 0x33, 0x85,
0xf5, 0x02, 0x81, 0x80,
0x56, 0x99, 0xe9, 0x17, 0xdc, 0x33, 0xe1, 0x33, 0x8d, 0x5c, 0xba, 0x17, 0x32, 0xb7, 0x8c, 0xbd, 0x4b, 0x7f, 0x42,
0x3a, 0x79, 0x90, 0xe3,
0x70, 0xe3, 0x27, 0xce, 0x22, 0x59, 0x02, 0xc0, 0xb1, 0x0e, 0x57, 0xf5, 0xdf, 0x07, 0xbf, 0xf8, 0x4e, 0x10, 0xef,
0x2a, 0x62, 0x30, 0x03,
0xd4, 0x80, 0xcf, 0x20, 0x84, 0x25, 0x66, 0x3f, 0xc7, 0x4f, 0x56, 0x8c, 0x1e, 0xe1, 0x18, 0x91, 0xc1, 0xfd, 0x71,
0x5f, 0x65, 0x9b, 0xe4,
0x4f, 0xe0, 0x1a, 0x3a, 0xf8, 0xc1, 0x69, 0xdb, 0xd3, 0xbb, 0x8d, 0x91, 0xd1, 0x11, 0x4f, 0x7e, 0x91, 0x1b, 0xb4,
0x27, 0xa5, 0xab, 0x7c,
0x7b, 0x76, 0xd4, 0x78, 0xfe, 0x63, 0x44, 0x63, 0x7e, 0xe3, 0xa6, 0x60, 0x4f, 0xb9, 0x55, 0x28, 0xba, 0xba, 0x83,
0x1a, 0x2d, 0x43, 0xd5,
0xf7, 0x2e, 0xe0, 0xfc, 0xa8, 0x14, 0x9b, 0x91, 0x2a, 0x36, 0xbf, 0xc7, 0x14
};
CK_BYTE
knownRSA1Modulus[]
= {0xb8, 0xb5, 0x0f, 0x49, 0x46, 0xb5, 0x5d, 0x58, 0x04, 0x8e, 0x52, 0x59, 0x39, 0xdf, 0xd6,
0x29,
0x45, 0x6b, 0x6c, 0x96, 0xbb, 0xab, 0xa5, 0x6f, 0x72, 0x1b, 0x16, 0x96, 0x74, 0xd5, 0xf9,
0xb4,
0x41, 0xa3, 0x7c, 0xe1, 0x94, 0x73, 0x4b, 0xa7, 0x23, 0xff, 0x61, 0xeb, 0xce, 0x5a, 0xe7,
0x7f,
0xe3, 0x74, 0xe8, 0x52, 0x5b, 0xd6, 0x5d, 0x5c, 0xdc, 0x98, 0x49, 0xfe, 0x51, 0xc2, 0x7e,
0x8f,
0x3b, 0x37, 0x5c, 0xb3, 0x11, 0xed, 0x85, 0x91, 0x15, 0x92, 0x24, 0xd8, 0xf1, 0x7b, 0x3d,
0x2f,
0x8b, 0xcd, 0x1b, 0x30, 0x14, 0xa3, 0x6b, 0x1b, 0x4d, 0x27, 0xff, 0x6a, 0x58, 0x84, 0x9e,
0x79,
0x94, 0xca, 0x78, 0x64, 0x01, 0x33, 0xc3, 0x58, 0xfc, 0xd3, 0x83, 0xeb, 0x2f, 0xab, 0x6f,
0x85,
0x5a, 0x38, 0x41, 0x3d, 0x73, 0x20, 0x1b, 0x82, 0xbc, 0x7e, 0x76, 0xde, 0x5c, 0xfe, 0x42,
0xd6,
0x7b, 0x86, 0x4f, 0x79, 0x78, 0x29, 0x82, 0x87, 0xa6, 0x24, 0x43, 0x39, 0x74, 0xfe, 0xf2,
0x0c,
0x08, 0xbe, 0xfa, 0x1e, 0x0a, 0x48, 0x6f, 0x14, 0x86, 0xc5, 0xcd, 0x9a, 0x98, 0x09, 0x2d,
0xf3,
0xf3, 0x5a, 0x7a, 0xa4, 0xe6, 0x8a, 0x2e, 0x49, 0x8a, 0xde, 0x73, 0xe9, 0x37, 0xa0, 0x5b,
0xef,
0xd0, 0xe0, 0x13, 0xac, 0x88, 0x5f, 0x59, 0x47, 0x96, 0x7f, 0x78, 0x18, 0x0e, 0x44, 0x6a,
0x5d,
0xec, 0x6e, 0xed, 0x4f, 0xf6, 0x6a, 0x7a, 0x58, 0x6b, 0xfe, 0x6c, 0x5a, 0xb9, 0xd2, 0x22,
0x3a,
0x1f, 0xdf, 0xc3, 0x09, 0x3f, 0x6b, 0x2e, 0xf1, 0x6d, 0xc3, 0xfb, 0x4e, 0xd4, 0xf2, 0xa3,
0x94,
0x13, 0xb0, 0xbf, 0x1e, 0x06, 0x2e, 0x29, 0x55, 0x00, 0xaa, 0x98, 0xd9, 0xe8, 0x77, 0x84,
0x8b,
0x3f, 0x5f, 0x5e, 0xf7, 0xf8, 0xa7, 0xe6, 0x02, 0xd2, 0x18, 0xb0, 0x52, 0xd0, 0x37, 0x2e,
0x53,
},
knownRSA1PubExponent[]
= { 0x01, 0x00, 0x01 };char *pPlainData = 0;
unsigned long ulPlainDataLength;
char *pEncryptedData = 0;
unsigned long ulEncryptedDataLength = 0;
CK_MECHANISM mech;
CK_USHORT usStatus=0,
usKeyLength;
CK_OBJECT_HANDLE hKey;
CK_OBJECT_CLASS SymKeyClass = CKO_SECRET_KEY;
CK_BBOOL bTrue = 1,
bFalse = 0,
bToken = bTrue,
bSensitive = bTrue,
bPrivate = bTrue,
bEncrypt = bTrue,
bDecrypt = bTrue,
bSign = bFalse, // "..."
bVerify = bFalse, //Will not allow sign/verify operation.
bWrap = bTrue,
bUnwrap = bTrue,
#ifdef EXTRACTABLE
bExtract = bTrue,
#endif //EXTRACTABLE
bDerive = bTrue;
CK_KEY_TYPE keyType;
CK_USHORT usValueBits;
char pbPublicKeyLabel[128];
CK_ATTRIBUTE_PTR pPublicTemplate;
CK_USHORT usPublicTemplateSize = 0;
char
iv[8] = { '1', '2', '3', '4', '5', '6', '7', '8' }; CK_ATTRIBUTE
SymKeyTemplate[] = { {CKA_CLASS,
0, sizeof(SymKeyClass)}, {CKA_KEY_TYPE,
0, sizeof(keyType)}, {CKA_TOKEN,
0, sizeof(bToken)}, {CKA_SENSITIVE,
0, sizeof(bSensitive)}, {CKA_PRIVATE,
0, sizeof(bPrivate)}, {CKA_ENCRYPT,
0, sizeof(bEncrypt)}, {CKA_DECRYPT,
0, sizeof(bDecrypt)}, {CKA_SIGN,
0, sizeof(bSign)}, {CKA_VERIFY,
0, sizeof(bVerify)}, {CKA_WRAP,
0, sizeof(bWrap)}, {CKA_UNWRAP,
0, sizeof(bUnwrap)}, {CKA_DERIVE,
0, sizeof(bDerive)}, {CKA_VALUE_LEN,0,
sizeof(usKeyLength)
}, {CKA_LABEL,
0, 0} //
Always keep last!!!#ifdef EXTRACTABLE //Conditional stuff must be at the end!!!!!
{CKA_EXTRACTABLE,
0, sizeof(bExtract)},#endif //EXTRACTABLE
};
CK_OBJECT_HANDLE hUnWrappedKey, hPublicRSAKey;
char *pbWrappedKey;
unsigned long ulWrappedKeySize;
CK_OBJECT_CLASS privateKey = CKO_PRIVATE_KEY,
publicKey = CKO_PUBLIC_KEY;
CK_KEY_TYPE rsaType = CKK_RSA;
CK_BYTE pLabel[] = "RSA private Key",
pbPublicRSAKeyLabel[] = "RSA Public Key";
CK_ATTRIBUTE *pTemplate;
CK_ULONG usTemplateSize,
ulPublicRSAKeyTemplateSize;
CK_ATTRIBUTE
pPublicRSAKeyTemplate[] = { {CKA_CLASS,
0,
sizeof(publicKey) }, {CKA_KEY_TYPE,
0, sizeof(rsaType)
}, {CKA_TOKEN,
0,
sizeof(bToken)
}, {CKA_PRIVATE,
0, sizeof(bPrivate)
}, {CKA_ENCRYPT,
0, sizeof(bEncrypt)
}, {CKA_VERIFY,
0,
sizeof(bSign)
}, {CKA_WRAP,
0,
sizeof(bWrap)
}, {CKA_MODULUS,
0, sizeof(knownRSA1Modulus) }, {CKA_PUBLIC_EXPONENT,
0, sizeof(knownRSA1PubExponent) }, {CKA_LABEL,
0,
sizeof(pbPublicRSAKeyLabel)
}};
CK_ATTRIBUTE
pPrivateKeyTemplate[] = { {CKA_CLASS,
&privateKey,
sizeof(privateKey) }, {CKA_KEY_TYPE,
&rsaType, sizeof(rsaType)
}, {CKA_TOKEN,
&bToken,
sizeof(bToken)
}, {CKA_SENSITIVE,&bSensitive,
sizeof(bSensitive) }, {CKA_PRIVATE,
&bPrivate,
sizeof(bPrivate)
}, {CKA_DECRYPT,
&bEncrypt,
sizeof(bEncrypt)
}, {CKA_SIGN,
&bSign,
sizeof(bSign)
}, //{CKA_SIGN_RECOVER,
&bTrue, sizeof(bTrue) }, {CKA_UNWRAP,
&bWrap,
sizeof(bWrap)
},{CKA_EXTRACTABLE, &bFalse, sizeof(bFalse) },{CKA_LABEL, pLabel,
sizeof(pLabel)
}};
// Generate a DES3 Key
SymKeyTemplate[0].pValue = &SymKeyClass;
SymKeyTemplate[1].pValue = &keyType;
SymKeyTemplate[2].pValue = &bToken;
SymKeyTemplate[3].pValue = &bSensitive;
SymKeyTemplate[4].pValue = &bPrivate;
SymKeyTemplate[5].pValue = &bEncrypt;
SymKeyTemplate[6].pValue = &bDecrypt;
SymKeyTemplate[7].pValue = &bSign;
SymKeyTemplate[8].pValue = &bVerify;
SymKeyTemplate[9].pValue = &bWrap;
SymKeyTemplate[10].pValue = &bUnwrap;
SymKeyTemplate[11].pValue = &bDerive;
SymKeyTemplate[12].pValue = &usKeyLength;
SymKeyTemplate[13].pValue = pbPublicKeyLabel;
#ifdef EXTRACTABLE
SymKeyTemplate[14].pValue = &bExtract;
#endif //EXTRACTABLE
mech.mechanism = CKM_DES3_KEY_GEN;
mech.pParameter = 0;
mech.usParameterLen = 0;
keyType = CKK_DES3;
usKeyLength = 24;
strcpy( pbPublicKeyLabel, "Generated DES3 Key" );
pPublicTemplate = SymKeyTemplate;
usPublicTemplateSize = DIM(SymKeyTemplate);
// Adjust size of label (ALWAYS LAST ENTRY IN ARRAY)
pPublicTemplate[usPublicTemplateSize-1].usValueLen = strlen(
pbPublicKeyLabel );
retCode = C_GenerateKey( hSessionHandle,
(CK_MECHANISM_PTR)&mech,
pPublicTemplate,
usPublicTemplateSize,
&hKey);
if(retCode == CKR_OK)
{cout << pbPublicKeyLabel << ": " << hKey << endl;
}
else
{cout << "\n" "Error 0x" << hex << retCode;
cout << " generating the DES3 Key.\n";
error = -11;
goto exit_routine_6;
}
// Encrypt the RSA Key
mech.mechanism = CKM_DES3_CBC;
mech.pParameter = iv;
mech.usParameterLen = sizeof(iv);
pPlainData = (char *)(pRsaKey);
ulPlainDataLength = sizeof(pRsaKey);
// Allocate memory for output buffer
if( retCode == CKR_OK )
{pEncryptedData = new char [ulPlainDataLength + 2048]; // Leave
// extra room for
// RSA Operations
if( !pEncryptedData )
{retCode = CKR_DEVICE_ERROR;
}
}
// Start encrypting
if( retCode == CKR_OK )
{retCode = C_EncryptInit(hSessionHandle, &mech, hKey);
}
// Continue encrypting
if( retCode == CKR_OK )
{CK_USHORT usInDataLen,
usOutDataLen = (CK_USHORT) (ulPlainDataLength + 2048);
CK_ULONG ulBytesRemaining = ulPlainDataLength;
char * pPlainTextPointer = pPlainData;
char * pEncryptedDataPointer = pEncryptedData;
while (ulBytesRemaining > 0)
{if (ulBytesRemaining > 0xfff0) // We are longer than a USHORT can handle
{usInDataLen = 0xfff0;
ulBytesRemaining -= usInDataLen;
}
else
{usInDataLen = (CK_USHORT) ulBytesRemaining;
ulBytesRemaining -= usInDataLen;
}
retCode = C_EncryptUpdate( hSessionHandle,
(CK_BYTE_PTR)pPlainTextPointer,
usInDataLen,
(CK_BYTE_PTR)pEncryptedDataPointer,
&usOutDataLen );
pPlainTextPointer += usInDataLen;
pEncryptedDataPointer += usOutDataLen;
ulEncryptedDataLength += usOutDataLen;
}
}
// Finish encrypting
if( retCode == CKR_OK )
{CK_USHORT usOutDataLen;
CK_BYTE_PTR pOutData = (CK_BYTE_PTR)pEncryptedData;
pOutData += ulEncryptedDataLength;
retCode = C_EncryptFinal(hSessionHandle, pOutData, &usOutDataLen);
ulEncryptedDataLength += usOutDataLen;
}
else
{cout << "\n" "Error 0x" << hex << retCode;
cout << " somewhere in the encrypting.\n";
if( pEncryptedData )
{delete pEncryptedData;
}
error = -12;
goto exit_routine_6;
}
mech.mechanism = CKM_DES3_CBC;
mech.pParameter = (void*) "12345678"; // 8 byte IV
mech.usParameterLen = 8;
pTemplate = pPrivateKeyTemplate;
usTemplateSize = DIM(pPrivateKeyTemplate);
pbWrappedKey = pEncryptedData;
ulWrappedKeySize = ulEncryptedDataLength;
if( retCode == CKR_OK )
{retCode = C_UnwrapKey( hSessionHandle,
&mech,
hKey,
(CK_BYTE_PTR)pbWrappedKey,
(CK_USHORT)ulWrappedKeySize,
pTemplate,
usTemplateSize,
&hUnWrappedKey);
}
// Report unwrapped key handle
if( retCode == CKR_OK )
{cout << "\n Private key Unwrapped key is:" << hUnWrappedKey <<"\n\n";
}
else
{cout << "\n" "Error 0x" << hex << retCode;
cout << " unwrapping.\n";
if( pEncryptedData )
{delete pEncryptedData;
}
error = -13;
goto exit_routine_6;
}
// Release temporary memory
if( pEncryptedData )
{delete pEncryptedData;
}
// Create the Public Key that goes with the Private Key
if( retCode == CKR_OK )
{// Unwrap it onto the token
pPublicRSAKeyTemplate[0].pValue = &publicKey;
pPublicRSAKeyTemplate[1].pValue = &rsaType;
pPublicRSAKeyTemplate[2].pValue = &bToken;
pPublicRSAKeyTemplate[3].pValue = &bPrivate;
pPublicRSAKeyTemplate[4].pValue = &bEncrypt;
pPublicRSAKeyTemplate[5].pValue = &bSign;
pPublicRSAKeyTemplate[6].pValue = &bWrap;
pPublicRSAKeyTemplate[7].pValue = knownRSA1Modulus;
pPublicRSAKeyTemplate[8].pValue = knownRSA1PubExponent;
pPublicRSAKeyTemplate[9].pValue = pbPublicRSAKeyLabel;
pTemplate = pPublicRSAKeyTemplate;
usTemplateSize = DIM(pPublicRSAKeyTemplate);
retCode = C_CreateObject( hSessionHandle,
pTemplate,
usTemplateSize,
&hPublicRSAKey);
if(retCode == CKR_OK)
{cout << pbPublicRSAKeyLabel << ": " << hPublicRSAKey << endl;
}
else
{cout << "\n" "Error 0x" << hex << retCode;
cout << " creating the RSA Public Key.\n";
error = -14;
goto exit_routine_6;
}
}
if( retCode == CKR_OK )
{CK_CHAR label[] = "RSA Key";
CK_ATTRIBUTE RSAFindPriTemplate[] =
{CKA_LABEL, label, sizeof(label)
};
CK_ULONG numHandles;
CK_OBJECT_HANDLE handles[1000];
retCode = C_FindObjectsInit( hSessionHandle, RSAFindPriTemplate, 1 );
if(retCode != CKR_OK)
{cout << "C_FindObjectsInit not returning OK ("
<< hex << retCode << ")\n\n";goto exit_routine_6;
}
retCode =C_FindObjects( hSessionHandle , handles, 90,
&numHandles );
if(retCode != CKR_OK)
{cout << "C_FindObjects not returning OK ("
<< hex << retCode << ")\n\n";
goto exit_routine_6;
}
cout << "Everything's GOOD\n\n";
for(int i=0; i < numHandles; i++)
{cout << handles[i] << "\n";
}
}
}
//CJM-> END OF TEST CODE
// Beginning of exit routines
exit_routine_6:
// Logout
retCode = C_Logout(hSessionHandle);
if(retCode != CKR_OK)
{cout << "\n" "Error 0x" << hex << retCode << " logging out.";
}
exit_routine_5:
// Close the session
retCode = C_CloseSession(hSessionHandle);
if(retCode != CKR_OK)
{cout << "\n" "Error 0x" << hex << retCode << " closing session.";
}
exit_routine_4:
delete pSlotList;
exit_routine_3:
#ifdef PKCS11_2_0
C_Finalize(0);
#else
C_Terminate();
#endif
exit_routine_2:
#ifndef STATIC
// No longer need Chrystoki
CrystokiDisconnect();
#endif
exit_routine_1:
cout
<< "\nDone. (" << dec << error << ")\n";cout.flush();
return error;
}
CK_RV Pinlogin(CK_SESSION_HANDLE hSession)
{CK_RV retCode;
unsigned char buffer[MAX];
int count =0;
cout << "Please enter the USER password : " << endl;
//calling get PinString to mask input, variable "count"
//holds length of "buffer"(password)
//needed for Login call
count = getPinString(buffer);
//Login as user on token in slot
retCode = C_Login(hSession, CKU_USER, buffer, count);
if(retCode != CKR_OK)
{cout << "\n" "Error 0x" << hex << retCode;
cout << " logging in as user.";
exit(hSession);
return -3;
}
cout << "logging into the token....";
cout << "\nlogged into token " << endl;
return retCode;
}
///////////////////////////////////////////////////////////////////////
// getPinString()
// ==============
//
// This function retrieves a pin string from the user. It modifies the
// console mode before starting so that the characters the user types are
// not echoed, and a '*' character is displayed for each typed character
// instead.
//
// Backspace is supported, but we don't get any fancier than that.
////////////////////////////////////////////////////////////////////////
int getPinString(CK_CHAR_PTR pw)
{int len=0;
char c=0;
// Unfortunately, the method of turning off character echo is
// different for Windows and Unix platforms. So we have to
// conditionally compile the appropriate section. Even the basic
// password retrieval is slightly different, since
// Windows and Unix use different character codes for the return key.
#ifdef WIN32
DWORD mode;
// This console mode stuff only applies to windows. We'll have to
// do something else when it comes to unix.
if
(GetConsoleMode(GetStdHandle(STD_INPUT_HANDLE), &mode)) { if
(SetConsoleMode(GetStdHandle(STD_INPUT_HANDLE), mode & (!ENABLE_ECHO_INPUT)))
{ while
(c != '\r')
{// wait for a character to be hit
while
(!_kbhit()) {Sleep(100);
}
// get it
c = _getch();
// check for carriage return
if
(c != '\r') {// check for backspace
if
(c!='\b') {// neither CR nor BS -- add it to the password string
printf("*");*pw++ = c;
len++;
}
else {// handle backspace -- delete the last character &
// erase it from the screen
if
(len > 0) {pw--;
len--;
printf("\b
\b");}
}
}
}
// Add the zero-termination
*pw = '\0';
SetConsoleMode(GetStdHandle(STD_INPUT_HANDLE), mode);
printf("\n");}
}
#endif
return len;
}
