/*
// Expects
// SEQUENCE {
// macKeyName [1] OCTET STRING OPTIONAL,
// macKey OCTET STRING,
// cipherKeyName [2] OCTET STRING OPTIONAL,
// cipherKey OCTET STRING OPTIONAL
// }
*/
SKYETEK_STATUS
Iso14443ATag_SetupSecureMemoryTag(
LPSKYETEK_READER lpReader,
LPSKYETEK_TAG lpTag,
LPSKYETEK_KEY lpKeyHMAC,
LPSKYETEK_KEY lpKeyCipher,
int useKeyDerivationFunction
)
{
LPPROTOCOLIMPL lppi;
SKYETEK_STATUS status;
LPSKYETEK_DATA lpDataS;
st_asn1_context context;
if( lpReader == NULL || lpReader->lpProtocol == NULL ||
lpReader->lpProtocol->internal == NULL ||
lpReader->lpDevice == NULL || lpTag == NULL ||
lpKeyHMAC == NULL || lpKeyHMAC->lpData == NULL || lpKeyHMAC->lpData->data == NULL || lpKeyHMAC->lpData->size < 1 )
return SKYETEK_INVALID_PARAMETER;
lpDataS = SkyeTek_AllocateData(1024);
if( lpDataS == NULL )
return SKYETEK_OUT_OF_MEMORY;
st_asn1_allocate_context(&context);
st_asn1_init(context, ST_ASN1_ENCODE,lpDataS->data,lpDataS->size);
st_asn1_start_sequence(context);
if( lpKeyHMAC->name != NULL && _tcslen(lpKeyHMAC->name) > 0) {
st_asn1_start_context_specific(context, 1);
st_asn1_write_octet_string(context, (unsigned char *)lpKeyHMAC->name, _tcslen(lpKeyHMAC->name)*sizeof(TCHAR));
st_asn1_finish_context_specific(context, 1);
}
st_asn1_write_octet_string(context, lpKeyHMAC->lpData->data, lpKeyHMAC->lpData->size);
if( lpKeyCipher != NULL && lpKeyCipher->lpData != NULL && lpKeyCipher->lpData->data != NULL && lpKeyCipher->lpData->size > 0 ) {
if( lpKeyCipher->name != NULL && _tcslen(lpKeyCipher->name) > 0) {
st_asn1_start_context_specific(context, 2);
st_asn1_write_octet_string(context, (unsigned char *)lpKeyCipher->name, _tcslen(lpKeyCipher->name)*sizeof(TCHAR));
st_asn1_finish_context_specific(context, 2);
}
st_asn1_write_octet_string(context, lpKeyCipher->lpData->data, lpKeyCipher->lpData->size);
}
if (useKeyDerivationFunction)
st_asn1_write_boolean(context, 1);
st_asn1_finish_sequence(context);
lpDataS->size = st_asn1_finalize(context);
st_asn1_free_context(&context);
lppi = (LPPROTOCOLIMPL)lpReader->lpProtocol->internal;
status = lppi->SetupSecureMemoryTag(lpReader,lpTag,lpDataS,10000);
SkyeTek_FreeData(lpDataS);
return status;
}
int
GetReaderVersion(
LPSKYETEK_DEVICE lpDevice
)
{
LPDEVICEIMPL lpDI = NULL;
LPSKYETEK_DATA lpData = NULL;
TCHAR *msg = NULL;
int bytes = 0, len = 0;
if( lpDevice == NULL || lpDevice->internal == NULL )
return 0;
lpDI = (LPDEVICEIMPL)lpDevice->internal;
lpData = SkyeTek_AllocateData(64);
lpData->data[0] = 0x02;
lpData->data[1] = 0x00;
lpData->data[2] = 0x01;
bytes = lpDI->Write(lpDevice,lpData->data,3,500);
if( bytes != 3 )
{
SkyeTek_FreeData(lpData);
return 0;
}
lpDI->Flush(lpDevice);
SkyeTek_Debug(_T("Sent: 020001\r\n"));
SKYETEK_Sleep(100);
bytes = lpDI->Read(lpDevice,lpData->data,3,500);
lpData->size = bytes;
msg = SkyeTek_GetStringFromData(lpData);
if( msg != NULL )
{
SkyeTek_Debug(_T("Read: %s\r\n"), msg);
SkyeTek_FreeString(msg);
msg = NULL;
}
// not a reader
if( bytes == 0 )
{
SkyeTek_FreeData(lpData);
return 0;
}
// bootloader mode
if( bytes == 2 && lpData->data[1] == 0xFF )
{
SkyeTek_FreeData(lpData);
return -1;
}
else if( bytes == 3 && lpData->data[0] == 0x00 && lpData->data[1] == 0x03 )
{
SkyeTek_FreeData(lpData);
return -1;
}
// something else?
if( bytes != 3 )
{
SkyeTek_FreeData(lpData);
return 0;
}
/* Version 2 */
if( lpData->data[0] == 0x02 && lpData->data[1] == 0x01 && lpData->data[2] == 0x82 )
{
SkyeTek_FreeData(lpData);
return 2;
}
if( lpData->data[0] == 0x02 && lpData->data[1] == 0x01 && lpData->data[2] == 0x81 )
{
SkyeTek_FreeData(lpData);
return 2;
}
if( lpData->data[0] == 0x02 && lpData->data[1] == 0x04 && lpData->data[2] == 0x88 )
{
bytes = lpDI->Read(lpDevice,lpData->data+3,3,500);
lpData->size = 3 + bytes;
SkyeTek_FreeData(lpData);
return 2;
}
if( lpData->data[0] == 0x02 && lpData->data[1] == 0x03 && lpData->data[2] == 0x88 )
{
bytes = lpDI->Read(lpDevice,lpData->data+3,2,500);
lpData->size = 3 + bytes;
SkyeTek_FreeData(lpData);
return 2;
}
/* Sanity check */
if( lpData->data[0] != 0x02 && lpData->data[1] != 0x00 )
{
SkyeTek_FreeData(lpData);
return 0;
}
/* Get length */
len = lpData->data[2];
if( len > 60 || len == 0 )
{
/* Garbage */
SkyeTek_FreeData(lpData);
return 0;
}
/* Assume Version 3 and read remaining bytes */
bytes = lpDI->Read(lpDevice,lpData->data+3,len,500);
lpData->size = 3+ bytes;
msg = SkyeTek_GetStringFromData(lpData);
if( msg != NULL )
{
SkyeTek_Debug(_T("Read: %s\r\n"), msg);
SkyeTek_FreeString(msg);
msg = NULL;
}
if( bytes != len )
{
SkyeTek_FreeData(lpData);
return 0;
}
/* Version 3 */
if( lpData->data[3] == 0x80 || lpData->data[3] == 0x90 )
{
SkyeTek_FreeData(lpData);
return 3;
}
SkyeTek_FreeData(lpData);
return 0;
}
// chngintf [numTimes]
int _tmain(int argc, TCHAR* argv[])
{
LPSKYETEK_READER lpReader = NULL;
LPSKYETEK_DEVICE *devices = NULL;
LPSKYETEK_READER *readers = NULL;
LPSKYETEK_TAG *lpTags = NULL;
LPSKYETEK_DATA lpData = NULL;
LPSKYETEK_DATA lpDataOrig = NULL;
SKYETEK_ADDRESS addr;
SKYETEK_STATUS st;
TCHAR *str = NULL;
unsigned short count;
unsigned int numDevices;
unsigned int numReaders;
unsigned int i = 0;
double f = 0.0;
int numTimes = 10;
int failures = 0;
int index = 0;
unsigned char tto;
unsigned char ctl;
// Initialize debugging
fp = _tfopen(_T("debug.txt"),_T("w"));
if( fp == NULL )
{
_tprintf(_T("ERROR: could not open debug.txt output file\n"));
return 0;
}
output(_T("SkyeTek API Change EM Config Example\n"));
SkyeTek_SetDebugger(debug);
// Get command line arguments
if( argc >= 2 )
{
numTimes = _ttoi(argv[1]);
}
// Discover reader
output(_T("Discovering reader...\n"));
numDevices = SkyeTek_DiscoverDevices(&devices);
if( numDevices == 0 )
{
output(_T("*** ERROR: No devices found.\n"));
fclose(fp);
return 0;
}
output(_T("Discovered %d devices\n"), numDevices);
numReaders = SkyeTek_DiscoverReaders(devices, numDevices, &readers);
if( numReaders == 0 )
{
SkyeTek_FreeDevices(devices,numDevices);
output(_T("*** ERROR: No readers found.\n"));
fclose(fp);
return 0;
}
lpReader = NULL;
for( int i = 0; i < (int)numReaders; i++ )
{
output(_T("Found reader: %s [%s]\n"), readers[i]->friendly, readers[i]->lpDevice->address);
output(_T("Firmware: %s\n"), readers[i]->firmware);
if( _tcscmp(readers[0]->model,_T("M9")) == 0 )
{
lpReader = readers[i];
break;
}
}
if( lpReader == NULL )
{
output(_T("*** ERROR: No M9 found; this test is only for M9 readers.\n"));
SkyeTek_FreeReaders(readers, numReaders);
SkyeTek_FreeDevices(devices, numDevices);
fclose(fp);
return 0;
}
// Increase the timeout
output(_T("Setting additional timeout: 5 seconds\n"));
SkyeTek_SetAdditionalTimeout(lpReader->lpDevice,5000);
// Set retry count
lpData = SkyeTek_AllocateData(1);
lpData->data[0] = 20;
st = SkyeTek_SetSystemParameter(lpReader,SYS_COMMAND_RETRY,lpData);
SkyeTek_FreeData(lpData);
lpData = NULL;
if( st != SKYETEK_SUCCESS )
{
output(_T("*** ERROR: failed to set M9 retries to 20: %s\n"), STPV3_LookupResponse(st));
SkyeTek_FreeReaders(readers, numReaders);
SkyeTek_FreeDevices(devices, numDevices);
fclose(fp);
return 0;
}
output(_T("Set M9 retries to 20\n"), STPV3_LookupResponse(st));
// Discover tags
lpTags = NULL;
count = 0;
st = SkyeTek_GetTags(lpReader,EM4444,&lpTags,&count);
if( st != SKYETEK_SUCCESS )
{
output(_T("*** ERROR: SkyeTek_GetTags failed to find an EM4444 tag: %s\n"), readers[0]->friendly);
SkyeTek_FreeReaders(readers, numReaders);
SkyeTek_FreeDevices(devices, numDevices);
fclose(fp);
return 0;
}
if( count == 0 )
{
output(_T("*** ERROR: Could not find any EM4444 tags in the field\n"));
SkyeTek_FreeReaders(readers, numReaders);
SkyeTek_FreeDevices(devices, numDevices);
fclose(fp);
return 0;
}
output(_T("Tag ID: %s\n"), lpTags[0]->friendly);
output(_T("Tag Type: %s\n"), SkyeTek_GetTagTypeNameFromType(lpTags[0]->type));
// Loop and read and write config
for( int i = 0; i < numTimes; i++ )
{
// Loop
output(_T("Loop %d...\n"),i);
// Read configuration
output(_T("Reading tag current configuration\n"));
addr.start = 0x000F;
addr.blocks = 1;
st = SkyeTek_ReadTagData(lpReader,lpTags[0],&addr,0,0,&lpDataOrig);
if( st != SKYETEK_SUCCESS )
{
output(_T("*** ERROR: Failed to read tag configuration: %s\n"),STPV3_LookupResponse(st));
failures++;
continue;
}
str = SkyeTek_GetStringFromData(lpDataOrig);
output(_T("Current system page: %s\n"),str);
SkyeTek_FreeString(str);
lpData = NULL;
// Adjust index
index++;
if( index >= 8 )
index = 0;
addr.start = 7;
addr.blocks = 1;
lpData = SkyeTek_AllocateData(1);
lpData->data[0] = ctlVals[index];
//lpDataOrig->data[0] &= 0xC3;
//lpData->data[0] |= lpDataOrig->data[0];
ctl = lpData->data[0];
st = SkyeTek_WriteTagConfig(lpReader,lpTags[0],&addr,lpData);
if( st != SKYETEK_SUCCESS )
{
output(_T("*** ERROR: Could not set control bits to 0x%02X: %s\n"),
ctl, STPV3_LookupResponse(st));
SkyeTek_FreeData(lpData);
lpData = NULL;
SkyeTek_FreeData(lpDataOrig);
lpDataOrig = NULL;
failures++;
continue;
}
// Write configuration
addr.start = 6;
addr.blocks = 1;
lpData->data[0] = ttoVals[index];
tto = lpData->data[0];
st = SkyeTek_WriteTagConfig(lpReader,lpTags[0],&addr,lpData);
if( st != SKYETEK_SUCCESS )
{
output(_T("*** ERROR: Could not set TTO to 0x%02X: %s\n"),
tto, STPV3_LookupResponse(st));
SkyeTek_FreeData(lpData);
lpData = NULL;
SkyeTek_FreeData(lpDataOrig);
lpDataOrig = NULL;
failures++;
continue;
}
SkyeTek_FreeData(lpData);
lpData = NULL;
SkyeTek_FreeData(lpDataOrig);
lpDataOrig = NULL;
// Read the configuration
addr.start = 6;
addr.blocks = 1;
st = SkyeTek_ReadTagConfig(lpReader,lpTags[0],&addr,&lpData);
if( st != SKYETEK_SUCCESS )
{
output(_T("*** ERROR: Could not read TTO configuration: %s\n"),STPV3_LookupResponse(st));
failures++;
continue;
}
if( lpData->data[0] != tto )
{
output(_T("*** ERROR: TTO does not match what was written: read: 0x%02X != written: 0x%02X\n"),
lpData->data[0], tto);
SkyeTek_FreeData(lpData);
lpData = NULL;
failures++;
continue;
}
output(_T("TTO matches what was written: read: 0x%02X == written: 0x%02X\n"),
lpData->data[0], tto);
SkyeTek_FreeData(lpData);
lpData = NULL;
addr.start = 7;
addr.blocks = 1;
st = SkyeTek_ReadTagConfig(lpReader,lpTags[0],&addr,&lpData);
if( st != SKYETEK_SUCCESS )
{
output(_T("*** ERROR: Could not read control bits configuration: %s\n"),STPV3_LookupResponse(st));
failures++;
continue;
}
lpData->data[0] &= 0x3C;
ctl &= 0x3C;
if( lpData->data[0] != ctl )
{
output(_T("*** ERROR: Control bits do not match what was written: read: 0x%02X != written: 0x%02X\n"),
lpData->data[0], ctl);
SkyeTek_FreeData(lpData);
lpData = NULL;
failures++;
continue;
}
output(_T("Control bits matches what was written: read: 0x%02X == written: 0x%02X\n"),
lpData->data[0], ctl);
SkyeTek_FreeData(lpData);
lpData = NULL;
} // end loop
// Report result
if( numTimes > 0 )
{
double percent = 0.0;
percent = 100*((double)(numTimes-failures))/((double)numTimes);
output(_T("Failed %d times out of %d attempts\n"), failures, numTimes);
output(_T("RESULTS: Loop success percentage: %.01f %%\n"), percent);
}
SkyeTek_FreeTags(lpReader,lpTags,count);
SkyeTek_FreeReaders(readers, numReaders);
SkyeTek_FreeDevices(devices, numDevices);
output(_T("Done.\n"));
fclose(fp);
return 1;
}
/*
// Expects
// SEQUENCE {
// interface ENUMERATED { 7816-4(1) }
// CHOICE {
// iso7816-4 [1] SEQUENCE {
// CLA OCTET-STRING,
// INS OCTET-STRING,
// P1_P2 OCTET-STRING,
// DATA OCTET-STRING OPTIONAL,
// Le INTEGER }
// }
// }
// Returns
// OCTET-STRING
*/
SKYETEK_STATUS
Iso14443ATag_TransportSend(
LPSKYETEK_READER lpReader,
LPSKYETEK_TAG lpTag,
SKYETEK_TRANSPORT transport,
SKYETEK_BLOCK block,
LPSKYETEK_DATA lpCla,
LPSKYETEK_DATA lpIns,
LPSKYETEK_DATA lpP1p2,
LPSKYETEK_DATA lpData,
unsigned int le,
LPSKYETEK_DATA *lpRecvData
)
{
LPPROTOCOLIMPL lppi;
SKYETEK_STATUS status;
LPSKYETEK_DATA lpDataS;
LPSKYETEK_DATA lpDataR = NULL;
st_asn1_context context;
int64 w;
if( lpReader == NULL || lpReader->lpProtocol == NULL ||
lpReader->lpProtocol->internal == NULL ||
lpReader->lpDevice == NULL || lpTag == NULL ||
lpCla == NULL || lpCla->data == NULL || lpCla->size == 0 ||
lpIns == NULL || lpIns->data == NULL || lpIns->size == 0 ||
lpP1p2 == NULL || lpP1p2->data == NULL || lpP1p2->size == 0 ||
lpRecvData == NULL )
return SKYETEK_INVALID_PARAMETER;
lpDataS = SkyeTek_AllocateData(1024);
if( lpDataS == NULL )
return SKYETEK_OUT_OF_MEMORY;
st_asn1_allocate_context(&context);
st_asn1_init(context, ST_ASN1_ENCODE,lpDataS->data,lpDataS->size);
st_asn1_start_sequence(context);
w = transport;
st_asn1_write_enumerated(context,w);
if( transport == T7816D4 )
{
st_asn1_start_context_specific(context, 1);
st_asn1_start_sequence(context);
st_asn1_write_octet_string(context, lpCla->data, lpCla->size);
st_asn1_write_octet_string(context, lpIns->data, lpIns->size);
st_asn1_write_octet_string(context, lpP1p2->data, lpP1p2->size);
if( lpData != NULL && lpData->data != NULL && lpData->size > 0 )
st_asn1_write_octet_string(context, lpData->data, lpData->size);
w = le;
st_asn1_write_integer(context,w);
st_asn1_finish_sequence(context);
st_asn1_finish_context_specific(context, 1);
}
st_asn1_finish_sequence(context);
lpDataS->size = st_asn1_finalize(context);
st_asn1_free_context(&context);
lppi = (LPPROTOCOLIMPL)lpReader->lpProtocol->internal;
status = lppi->InterfaceSend(lpReader,lpTag,lpDataS,&lpDataR,5000);
if( status != SKYETEK_SUCCESS )
{
SkyeTek_FreeData(lpDataS);
return status;
}
if( lpDataR == NULL || lpDataR->data == NULL || lpDataR->size == 0 )
return SKYETEK_SUCCESS;
*lpRecvData = SkyeTek_AllocateData(lpDataR->size);
if( *lpRecvData == NULL )
return SKYETEK_OUT_OF_MEMORY;
st_asn1_allocate_context(&context);
st_asn1_init(context, ST_ASN1_ENCODE,lpDataR->data,lpDataR->size);
st_asn1_read_octet_string(context, (*lpRecvData)->data, &(*lpRecvData)->size);
st_asn1_free_context(&context);
return SKYETEK_SUCCESS;
}
