void CBuzzController::ProcessInMsgs() {
/* Reset neighbor information */
buzzneighbors_reset(m_tBuzzVM);
/* Go through RAB messages and add them to the FIFO */
const CCI_RangeAndBearingSensor::TReadings& tPackets = m_pcRABS->GetReadings();
for(size_t i = 0; i < tPackets.size(); ++i) {
/* Copy packet into temporary buffer */
CByteArray cData = tPackets[i].Data;
/* Get robot id and update neighbor information */
UInt16 unRobotId = cData.PopFront<UInt16>();
buzzneighbors_add(m_tBuzzVM,
unRobotId,
tPackets[i].Range,
tPackets[i].HorizontalBearing.GetValue(),
tPackets[i].VerticalBearing.GetValue());
/* Go through the messages until there's nothing else to read */
UInt16 unMsgSize;
do {
/* Get payload size */
unMsgSize = cData.PopFront<UInt16>();
/* Append message to the Buzz input message queue */
if(unMsgSize > 0 && cData.Size() >= unMsgSize) {
buzzinmsg_queue_append(m_tBuzzVM,
unRobotId,
buzzmsg_payload_frombuffer(cData.ToCArray(), unMsgSize));
/* Get rid of the data read */
for(size_t i = 0; i < unMsgSize; ++i) cData.PopFront<UInt8>();
}
}
while(cData.Size() > sizeof(UInt16) && unMsgSize > 0);
}
/* Process messages */
buzzvm_process_inmsgs(m_tBuzzVM);
}
void CBuzzController::ProcessOutMsgs() {
/* Send robot id */
CByteArray cData;
cData << m_tBuzzVM->robot;
/* Send messages from FIFO */
do {
/* Are there more messages? */
if(buzzoutmsg_queue_isempty(m_tBuzzVM->outmsgs)) break;
/* Get first message */
buzzmsg_payload_t m = buzzoutmsg_queue_first(m_tBuzzVM->outmsgs);
/* Make sure the next message fits the data buffer */
if(cData.Size() + buzzmsg_payload_size(m) + sizeof(UInt16)
>
m_pcRABA->GetSize()) {
buzzmsg_payload_destroy(&m);
break;
}
/* Add message length to data buffer */
cData << static_cast<UInt16>(buzzmsg_payload_size(m));
/* Add payload to data buffer */
cData.AddBuffer(reinterpret_cast<UInt8*>(m->data), buzzmsg_payload_size(m));
/* Get rid of message */
buzzoutmsg_queue_next(m_tBuzzVM->outmsgs);
buzzmsg_payload_destroy(&m);
} while(1);
/* Pad the rest of the data with zeroes */
while(cData.Size() < m_pcRABA->GetSize()) cData << static_cast<UInt8>(0);
/* Send message */
m_pcRABA->SetData(cData);
}
static long TestPteidCtrl(CReader & oReader, unsigned char ucVersion)
{
long lErrors = 0;
printf("\nTesting Ctrl()\n");
// CTRL_PTEID_GETCARDDATA
CByteArray oCardInfo = oReader.GetInfo();
CByteArray oUnsignedCardData = oReader.Ctrl(CTRL_PTEID_GETCARDDATA, CByteArray());
if (!oCardInfo.Equals(oUnsignedCardData))
ERR_LOG("ERR: Ctrl(CTRL_PTEID_GETCARDDATA) != GetInfo()\n", lErrors);
// CTRL_PTEID_GETSIGNEDCARDDATA
if (ucVersion >= 0x20)
{
CByteArray oSignedCardData = oReader.Ctrl(CTRL_PTEID_GETSIGNEDCARDDATA, CByteArray());
if (oSignedCardData.Size() != oUnsignedCardData.Size() + 128)
ERR_LOG("ERR: signed and unsigned card data should differ in size by 128 bytes\n", lErrors);
oSignedCardData.Chop(128);
if (!oUnsignedCardData.Equals(oSignedCardData))
ERR_LOG("ERR: start of unsigned card data should be the same as for unsigned card data\n", lErrors);
}
// CTRL_PTEID_GETSIGNEDPINSTATUS
if (ucVersion >= 0x20)
{
tPin pin = oReader.GetPin(0);
CByteArray oData(1);
oData.Append((unsigned char) pin.ulPinRef);
CByteArray oSignedPinStatus = oReader.Ctrl(CTRL_PTEID_GETSIGNEDPINSTATUS, oData);
if (oSignedPinStatus.Size() != 129)
ERR_LOG("ERR: signed pin status response should be (1 + 128) bytes\n", lErrors);
else if (oSignedPinStatus.GetByte(0) != oReader.PinStatus(pin))
ERR_LOG("ERR: signed pin status differs from unsigned PIN status\n", lErrors);
}
// CTRL_PTEID_INTERNAL_AUTH
CByteArray oData(21); // Key ref (1 byte) + challenge(20 bytes)
oData.Append(0x81);
for (int i = 0; i < 20; i++)
oData.Append((unsigned char) rand());
CByteArray oResp1 = oReader.Ctrl(CTRL_PTEID_INTERNAL_AUTH, oData);
if (oResp1.Size() != 128)
ERR_LOG("ERR: Internal Auth. didn't return 128 bytes\n", lErrors);
CByteArray oResp2 = oReader.Ctrl(CTRL_PTEID_INTERNAL_AUTH, oData);
if (!oResp1.Equals(oResp2))
ERR_LOG("ERR: Internal Auth. on the same data returns a different result\n", lErrors);
oData.SetByte(oData.GetByte(5) + 0x01, 5);
CByteArray oResp3 = oReader.Ctrl(CTRL_PTEID_INTERNAL_AUTH, oData);
if (oResp1.Equals(oResp3))
ERR_LOG("ERR: Internal Auth. on the different data returns the same result\n", lErrors);
return lErrors;
}
bool CByteArray::Equals(const CByteArray & oByteArray) const
{
if (m_bMallocError)
throw CMWEXCEPTION(EIDMW_ERR_MEMORY);
if (m_ulSize == 0 && oByteArray.Size() == 0)
return true;
return m_ulSize == oByteArray.Size() &&
memcmp(m_pucData, oByteArray.GetBytes(), m_ulSize) == 0;
}
void CPkiCard::WriteUncachedFile(const std::string & csPath,
unsigned long ulOffset, const CByteArray & oData)
{
CAutoLock autolock(this);
tFileInfo fileInfo = SelectFile(csPath, true);
const unsigned char *pucData = oData.GetBytes();
unsigned long ulDataLen = oData.Size();
for (unsigned long i = 0; i < ulDataLen; i += MAX_APDU_WRITE_LEN)
{
unsigned long ulLen = ulDataLen - i;
if (ulLen > MAX_APDU_WRITE_LEN)
ulLen = MAX_APDU_WRITE_LEN;
CByteArray oResp = UpdateBinary(ulOffset + i, CByteArray(pucData + i, ulLen));
unsigned long ulSW12 = getSW12(oResp);
if (ulSW12 == 0x6982)
throw CNotAuthenticatedException(
EIDMW_ERR_NOT_AUTHENTICATED, fileInfo.lWritePINRef);
else if (ulSW12 != 0x9000)
throw CMWEXCEPTION(m_poContext->m_oPCSC.SW12ToErr(ulSW12));
}
MWLOG(LEV_INFO, MOD_CAL, L"Written file %ls to card", utilStringWiden(csPath).c_str());
}
static long TestPteidSendApdu(CReader & oReader)
{
long lErrors = 0;
printf("\nTesting SendAPDU()\n");
// Send a Get Card Data APDU
unsigned char tucGetCardData[] = {0x80, 0xE4, 0x00, 0x00, 0x1C};
CByteArray oGetCardData(tucGetCardData, sizeof(tucGetCardData));
CByteArray oData = oReader.SendAPDU(oGetCardData);
// Serial nr. are the first 16 bytes of the Get Card Data APDU
std::string csSerialNr = oReader.GetSerialNr();
if (csSerialNr != oData.ToString(false, true, 0, 16))
ERR_LOG("SendAPDU(GetCardData) returns wrong data (bad serial nr.)\n", lErrors);
// Send a Select MF APDU
unsigned char tucSelectMF[] = {0x00, 0xa4, 0x02, 0x0C, 0x02, 0x3f, 0x00};
CByteArray oSelectMF(tucSelectMF, sizeof(tucSelectMF));
oData = oReader.SendAPDU(oSelectMF);
// Result should be 90 00
if (oData.Size() != 2 || oData.GetByte(0) != 0x90 || oData.GetByte(1) != 0x00)
{
ERR_LOG("SendAPDU(GetCardData) returns wrong data (bad serial nr.)\n", lErrors);
printf(" (result = %s\n", oData.ToString().c_str());
}
return lErrors;
}
CByteArray CPkiCard::GetRandom(unsigned long ulLen)
{
CAutoLock oAutoLock(this);
if (m_selectAppletMode == ALW_SELECT_APPLET)
{
SelectApplet();
}
CByteArray oRandom(ulLen);
try_again:
// Use a Get Challenge command to gather 8 bytes with each loop
for (unsigned long i = 0; i < ulLen; i += 20)
{
unsigned char ucLen = (unsigned char) (ulLen - i > 20 ? 20 : ulLen - i);
// Get challenge command
CByteArray oResp = SendAPDU(0x84, 0x00, 0x00, (unsigned char) ucLen);
if (ShouldSelectApplet(0x84, getSW12(oResp)))
{
// First try to select
if (SelectApplet())
{
m_selectAppletMode = ALW_SELECT_APPLET;
goto try_again;
}
}
getSW12(oResp, 0x9000);
oRandom.Append(oResp.GetBytes(), oResp.Size() - 2);
}
return oRandom;
}
static long UpdateFile(const std::vector <std::string> & vcsPaths,
const CByteArray & oData, unsigned long ulOffset)
{
long lRet = 0;
CReader &oReader = g_oCardLayer.getReader(g_csReaderName);
if (oReader.Connect())
{
printf("Reader \"%s\":\n", oReader.GetReaderName().c_str());
// Verify PIN if specified
lRet = VerifyPIN(oReader, 0);
if (lRet == 0)
{
oReader.WriteFile(vcsPaths[0], ulOffset, oData);
printf("Written %d bytes to file %s, starting at offset %d\n",
oData.Size(), vcsPaths[0].c_str(), ulOffset);
}
oReader.Disconnect();
}
else
printf(" No card found in the reader, exiting\n");
return lRet;
}
static long SendAPDUs(std::vector <std::string> & vcsAPDUs)
{
long lRet = 0;
CReader &oReader = g_oCardLayer.getReader(g_csReaderName);
if (oReader.Connect())
{
for (unsigned int i = 0; i < vcsAPDUs.size(); i++)
{
CByteArray oRequestAPDU(vcsAPDUs[i], true);
printf("\nIN: %s\n", oRequestAPDU.ToString().c_str());
CByteArray oResponseAPDU = oReader.SendAPDU(oRequestAPDU);
printf("OUT: %s\n", oResponseAPDU.Size() < 14 ? oResponseAPDU.ToString().c_str():
oResponseAPDU.ToString(true, false).c_str());
}
oReader.Disconnect();
}
else
printf(" No card found in the reader, exiting\n");
return lRet;
}
CByteArray CBeidCard::SignInternal(const tPrivKey & key, unsigned long algo,
const CByteArray & oData, const tPin *pPin)
{
CAutoLock autolock(this);
// For V1.7 cards, the Belpic dir has to be selected
if (m_ucAppletVersion >= 0x17)
SelectFile(key.csPath);
else if (m_selectAppletMode == ALW_SELECT_APPLET)
SelectApplet();
SetSecurityEnv(key, algo, oData.Size());
// Pretty unique for smart cards: first MSE SET, then verify PIN
// (needed for the nonrep key/pin, but also usable for the auth key/pin)
if (pPin != NULL)
{
//unsigned long ulRemaining = 0;
bool bOK = PinCmd(PIN_OP_VERIFY, *pPin, "", "", m_ulRemaining, &key);
if (!bOK)
throw CMWEXCEPTION(m_ulRemaining == 0 ? EIDMW_ERR_PIN_BLOCKED : EIDMW_ERR_PIN_BAD);
}
// PSO: Compute Digital Signature
CByteArray oResp = SendAPDU(0x2A, 0x9E, 0x9A, oData);
unsigned long ulSW12 = getSW12(oResp);
if (ulSW12 != 0x9000)
throw CMWEXCEPTION(m_poContext->m_oPCSC.SW12ToErr(ulSW12));
// Remove SW1-SW2 from the response
oResp.Chop(2);
return oResp;
}
static bool BeidCardSelectApplet(CContext *poContext, SCARDHANDLE hCard)
{
long lRetVal = 0;
unsigned char tucSelectApp[] = {0x00, 0xA4, 0x04, 0x00};
CByteArray oCmd(40);
oCmd.Append(tucSelectApp, sizeof(tucSelectApp));
oCmd.Append((unsigned char) sizeof(APPLET_AID));
oCmd.Append(APPLET_AID, sizeof(APPLET_AID));
CByteArray oResp;
try {
oResp = poContext->m_oPCSC.Transmit(hCard, oCmd, &lRetVal);
}
catch(CMWException e)
{
MWLOG(LEV_CRIT, MOD_CAL, L"Failed to select applet: 0x%0x", e.GetError());
return false;
}
catch(...)
{
MWLOG(LEV_CRIT, MOD_CAL, L"Failed to select applet");
return false;
}
return (oResp.Size() == 2 && (oResp.GetByte(0) == 0x61 || oResp.GetByte(0) == 0x90));
}
/**
* This is something you typically do just once, unless you
* want to check if new readers were inserted/removed.
* Note: PKCS#11 assumes that the number of readers never
* change, so you have to call this function only in
* C_GetSlotList().
*/
CReadersInfo CCardLayer::ListReaders()
{
CReadersInfo theReadersInfo;
CByteArray oReaders;
// Do an SCardEstablishContext() if not done yet
try
{
m_oPCSC.EstablishContext();
oReaders = m_oPCSC.ListReaders();
}
catch(CMWException & e)
{
unsigned long err = e.GetError();
if (err == EIDMW_ERR_NO_READER)
return theReadersInfo;
throw;
}
theReadersInfo = CReadersInfo(oReaders);
if (oReaders.Size() != 0)
{
m_szDefaultReaderName = (char *) oReaders.GetBytes();
}
return theReadersInfo;
}
void CCI_RangeAndBearingActuator::SetData(const CByteArray& c_data) {
if(m_cData.Size() == c_data.Size()) {
m_cData = c_data;
}
else {
THROW_ARGOSEXCEPTION("CCI_RangeAndBearingActuator::SetData() : data size does not match, expected " << m_cData.Size() << ", got " << c_data.Size());
}
}
void CRABEquippedEntity::SetData(const CByteArray& c_data) {
if(m_cData.Size() == c_data.Size()) {
m_cData = c_data;
}
else {
THROW_ARGOSEXCEPTION("CRABEquippedEntity::SetData() : data size does not match, expected " << m_cData.Size() << ", got " << c_data.Size());
}
}
CByteArray CPkiCard::ReadUncachedFile(const std::string & csPath,
unsigned long ulOffset, unsigned long ulMaxLen)
{
CByteArray oData(ulMaxLen);
CAutoLock autolock(this);
tFileInfo fileInfo = SelectFile(csPath, true);
// Loop until we've read ulMaxLen bytes or until EOF (End Of File)
bool bEOF = false;
for (unsigned long i = 0; i < ulMaxLen && !bEOF; i += MAX_APDU_READ_LEN)
{
unsigned long ulLen = ulMaxLen - i <= MAX_APDU_READ_LEN ?
ulMaxLen - i : MAX_APDU_READ_LEN;
CByteArray oResp = ReadBinary(ulOffset + i, ulLen);
unsigned long ulSW12 = getSW12(oResp);
// If the file is a multiple of the block read size, you will get
// an SW12 = 6B00 (at least with BE eID) but that OK then..
if (ulSW12 == 0x9000 || (i != 0 && ulSW12 == 0x6B00))
oData.Append(oResp.GetBytes(), oResp.Size() - 2);
else if (ulSW12 == 0x6982) {
throw CNotAuthenticatedException(
EIDMW_ERR_NOT_AUTHENTICATED, fileInfo.lReadPINRef);
}
else if (ulSW12 == 0x6B00)
throw CMWEXCEPTION(EIDMW_ERR_PARAM_RANGE);
else if (ulSW12 == 0x6D00)
throw CMWEXCEPTION(EIDMW_ERR_NOT_ACTIVATED);
else
throw CMWEXCEPTION(m_poContext->m_oPCSC.SW12ToErr(ulSW12));
// If the driver/reader itself did the 6CXX handling,
// we assume we're at the EOF
if (oResp.Size() < MAX_APDU_READ_LEN)
bEOF = true;
}
MWLOG(LEV_INFO, MOD_CAL, L" Read file %ls (%d bytes) from card",
utilStringWiden(csPath).c_str(), oData.Size());
return oData;
}
BOOL WINAPI
eidmwGetHashParam(
IN HCRYPTPROV hProv, //!< Handle to provider previously obtained through a call to CPAcquireContext
IN HCRYPTHASH hHash, //!< A reference to the hash object for which to set the parameter
IN DWORD dwParam, //!< Parameter to set
OUT LPBYTE pbData, //!< A data buffer in which the parameter data will be returned
IN OUT LPDWORD pcbDataLen, //!< Length of the data to be returned
IN DWORD dwFlags) //!< No flags currently defined
{
BOOL bReturnVal = FALSE;
DWORD dwLastError = 0;
__CSP_TRY__
MWLOG(LEV_INFO, MOD_CSP, L"CPGetHashParam(hProv = %d) called", hProv);
MWLOG(LEV_INFO, MOD_CSP, L" - IN: hHash = %d", hHash);
MWLOG(LEV_INFO, MOD_CSP, L" - IN: dwParam = 0x%0x", dwParam);
MWLOG(LEV_INFO, MOD_CSP, L" - IN: pbData = %p", pbData);
CProviderContext *poProvCtx = g_oProviderContextPool.GetProviderContext(hProv);
CProviderHash *poProvHash = poProvCtx->GetHash(hHash);
switch(dwParam)
{
case HP_ALGID:
{
DWORD dwAlgID = (DWORD) poProvHash->GetAlgid();
bReturnVal = FillProvParam(pbData, pcbDataLen, &dwAlgID, sizeof(DWORD));
break;
}
case HP_HASHSIZE:
{
DWORD dwHashSize = (DWORD) poProvHash->GetLengthBytes();
bReturnVal = FillProvParam(pbData, pcbDataLen, &dwHashSize, sizeof(DWORD));
break;
}
case HP_HASHVAL:
{
CByteArray oHashValue = poProvHash->GetHashValue();
bReturnVal = FillProvParam(pbData, pcbDataLen, oHashValue.GetBytes(), oHashValue.Size());
break;
}
default:
dwLastError = NTE_BAD_TYPE;
}
__STORE_LASTERROR__
MWLOG(LEV_INFO, MOD_CSP, L" Returning CPGetHashParam(hProv = %d) with code 0x%0x",
hProv, bReturnVal ? 0 : dwLastError);
if (bReturnVal)
MWLOG(LEV_INFO, MOD_CSP, L" - OUT: *pcbDataLen = %d", *pcbDataLen);
__CSP_CATCH_SETLASTERROR__
return (bReturnVal);
}
void CBuzzController::ProcessOutMsgs() {
/* Process outgoing messages */
buzzvm_process_outmsgs(m_tBuzzVM);
/* Send robot id */
CByteArray cData;
cData << m_tBuzzVM->robot;
/* Send messages from FIFO */
do {
/* Are there more messages? */
if(buzzoutmsg_queue_isempty(m_tBuzzVM)) break;
/* Get first message */
buzzmsg_payload_t m = buzzoutmsg_queue_first(m_tBuzzVM);
/* Make sure the message is smaller than the data buffer
* Without this check, large messages would clog the queue forever
*/
size_t unMsgSize = buzzmsg_payload_size(m) + sizeof(UInt16);
if(unMsgSize < m_pcRABA->GetSize() - sizeof(UInt16)) {
/* Make sure the next message fits the data buffer */
if(cData.Size() + unMsgSize > m_pcRABA->GetSize()) {
buzzmsg_payload_destroy(&m);
break;
}
/* Add message length to data buffer */
cData << static_cast<UInt16>(buzzmsg_payload_size(m));
/* Add payload to data buffer */
cData.AddBuffer(reinterpret_cast<UInt8*>(m->data), buzzmsg_payload_size(m));
}
else {
RLOGERR << "Discarded oversize message ("
<< unMsgSize
<< " bytes). Max size is "
<< m_pcRABA->GetSize() - sizeof(UInt16)
<< " bytes."
<< std::endl;
}
/* Get rid of message */
buzzoutmsg_queue_next(m_tBuzzVM);
buzzmsg_payload_destroy(&m);
} while(1);
/* Pad the rest of the data with zeroes */
while(cData.Size() < m_pcRABA->GetSize()) cData << static_cast<UInt8>(0);
/* Send message */
m_pcRABA->SetData(cData);
}
void SODParser::ParseSodEncapsulatedContent(const CByteArray & contents){
ASN1_ITEM xLev0Item;
ASN1_ITEM xLev1Item;
ASN1_ITEM xLev2Item;
ASN1_ITEM xLev3Item;
ASN1_ITEM xLev4Item;
xLev0Item.p_data = (unsigned char*)contents.GetBytes();
xLev0Item.l_data = contents.Size();
if ((asn1_next_item(&xLev0Item, &xLev1Item)!= 0) ||(xLev1Item.tag != ASN_SEQUENCE))
throw CMWEXCEPTION(EIDMW_SOD_UNEXPECTED_ASN1_TAG);
if ((xLev1Item.l_data < 2)|| (asn1_next_item(&xLev1Item, &xLev2Item)!= 0) ||(xLev2Item.tag != ASN_INTEGER))
throw CMWEXCEPTION(EIDMW_SOD_UNEXPECTED_ASN1_TAG);
if (bin2int(xLev2Item.p_data, xLev2Item.l_data)!=0)
throw CMWEXCEPTION(EIDMW_SOD_UNEXPECTED_VALUE);
if ((xLev1Item.l_data < 2)|| (asn1_next_item(&xLev1Item, &xLev2Item)!= 0) ||(xLev2Item.tag != ASN_SEQUENCE))
throw CMWEXCEPTION(EIDMW_SOD_UNEXPECTED_ASN1_TAG);
if ((xLev2Item.l_data < 2)|| (asn1_next_item(&xLev2Item, &xLev3Item)!= 0) ||(xLev3Item.tag != ASN_OID))
throw CMWEXCEPTION(EIDMW_SOD_UNEXPECTED_ASN1_TAG);
// martinho: not the intended way, but for now it will do just fine.
if (memcmp(xLev3Item.p_data, OID_SHA256_ALGORITHM, xLev3Item.l_data) != 0)
throw CMWEXCEPTION(EIDMW_SOD_UNEXPECTED_ALGO_OID);
if ((xLev2Item.l_data < 2)|| (asn1_next_item(&xLev2Item, &xLev3Item)!= 0) ||(xLev3Item.tag != ASN_NULL))
throw CMWEXCEPTION(EIDMW_SOD_UNEXPECTED_ASN1_TAG);
if ((xLev1Item.l_data < 2)|| (asn1_next_item(&xLev1Item, &xLev2Item)!= 0) ||(xLev2Item.tag != ASN_SEQUENCE))
throw CMWEXCEPTION(EIDMW_SOD_UNEXPECTED_ASN1_TAG);
attr = new SODAttributes();
int i=0;
while(xLev2Item.l_data > 0){
if ((xLev2Item.l_data < 2)|| (asn1_next_item(&xLev2Item, &xLev3Item)!= 0) ||(xLev3Item.tag != ASN_SEQUENCE))
throw CMWEXCEPTION(EIDMW_SOD_UNEXPECTED_ASN1_TAG);
if ((xLev3Item.l_data < 2)|| (asn1_next_item(&xLev3Item, &xLev4Item)!= 0) ||(xLev4Item.tag != ASN_INTEGER))
throw CMWEXCEPTION(EIDMW_SOD_UNEXPECTED_ASN1_TAG);
if (bin2int(xLev4Item.p_data, xLev4Item.l_data)!=(i+1))
throw CMWEXCEPTION(EIDMW_SOD_UNEXPECTED_VALUE);
if ((xLev3Item.l_data < 2)|| (asn1_next_item(&xLev3Item, &xLev4Item)!= 0) ||(xLev4Item.tag != ASN_OCTET_STRING))
throw CMWEXCEPTION(EIDMW_SOD_UNEXPECTED_ASN1_TAG);
attr->hashes[i].Append(xLev4Item.p_data,xLev4Item.l_data);
i++;
}
}
bool APL_CryptoFwk::VerifyRoot(const CByteArray &cert, const unsigned char *const *roots)
{
const unsigned char *const *proot;
for(proot=roots;*proot!=NULL;proot++)
{
if(memcmp(cert.GetBytes(),*proot,cert.Size())==0)
return true;
}
return false;
}
static void WriteFile(const std::string & csSerial, const std::string & csPath, const CByteArray &oData)
{
std::string csFileName;
if (csSerial != "")
csFileName += csSerial + "_";
csFileName += csPath;
#ifdef WIN32
FILE *f;
fopen_s(&f,csFileName.c_str(), "wb");
#else
FILE *f = fopen(csFileName.c_str(), "wb");
#endif
if (f != NULL)
{
fwrite(oData.GetBytes(), 1, oData.Size(), f);
printf(" - Written %d bytes to %s\n", oData.Size(), csFileName.c_str());
fclose(f);
}
else
printf(" - ERR: couldn't write file %s\n", csFileName.c_str());
}
CByteArray CPkiCard::Sign(const tPrivKey & key, const tPin & Pin,
unsigned long algo, const CByteArray & oData)
{
// If SSO (Single Sign-On) is false and we didn't verify the
// PIN yet, then we do this first without trying if it's
// realy needed.
if (!m_poContext->m_bSSO)
{
bool bFound = false;
for (size_t i = 0; i < m_verifiedPINs.size() && !bFound; i++)
bFound = (m_verifiedPINs[i] == Pin.ulID);
if (!bFound)
{
MWLOG(LEV_INFO, MOD_CAL, L" No SSO: ask PIN and sign (key: ID=0x%0x, algo=0x%0x, "
L"%d bytes input)", key.ulID, algo, oData.Size());
return SignInternal(key, algo, oData, &Pin);
}
}
// First try to sign.
// If this returns a "Security conditions not satisfied"
// then first do a Pin verify and then try again
MWLOG(LEV_INFO, MOD_CAL, L" Trying to Sign (key: ID=0x%0x, algo=0x%0x, "
L"%d bytes input)", key.ulID, algo, oData.Size());
try
{
return SignInternal(key, algo, oData);
}
catch(CMWException & e)
{
if ((unsigned)e.GetError() == EIDMW_ERR_NOT_AUTHENTICATED)
{
MWLOG(LEV_INFO, MOD_CAL, L" Couldn't sign, asking PIN and trying again");
return VerifyAndSign(key, Pin, algo, oData);
}
else
throw e;
}
}
void CBuzzController::Init(TConfigurationNode& t_node) {
try {
/* Get pointers to devices */
m_pcRABA = GetActuator<CCI_RangeAndBearingActuator>("range_and_bearing");
m_pcRABS = GetSensor <CCI_RangeAndBearingSensor >("range_and_bearing");
try {
m_pcPos = GetSensor <CCI_PositioningSensor>("positioning");
}
catch(CARGoSException& ex) {}
/* Get the script name */
std::string strBCFName;
GetNodeAttributeOrDefault(t_node, "bytecode_file", strBCFName, strBCFName);
/* Get the script name */
std::string strDbgFName;
GetNodeAttributeOrDefault(t_node, "debug_file", strDbgFName, strDbgFName);
/* Initialize the rest */
bool bIDSuccess = false;
m_unRobotId = 0;
/* Find Buzz ID */
size_t tStartPos = GetId().find_last_of("_");
if(tStartPos != std::string::npos){
/* Checks for ID after last "_" ie. footbot_group3_10 -> 10 */
m_unRobotId = FromString<UInt16>(GetId().substr(tStartPos+1));
bIDSuccess = true;
}
/* FromString() returns 0 if passed an invalid string */
if(!m_unRobotId || !bIDSuccess){
/* Checks for ID after first number footbot_simulated10 -> 10 */
tStartPos = GetId().find_first_of("0123456789");
if(tStartPos != std::string::npos){
m_unRobotId = FromString<UInt16>(GetId().substr(tStartPos));
bIDSuccess = true;
}
}
if(!bIDSuccess) {
THROW_ARGOSEXCEPTION("Error in finding Buzz ID from name \"" << GetId() << "\"");
}
if(strBCFName != "" && strDbgFName != "")
SetBytecode(strBCFName, strDbgFName);
else
m_tBuzzVM = buzzvm_new(m_unRobotId);
UpdateSensors();
/* Set initial robot message (id and then all zeros) */
CByteArray cData;
cData << m_tBuzzVM->robot;
while(cData.Size() < m_pcRABA->GetSize()) cData << static_cast<UInt8>(0);
m_pcRABA->SetData(cData);
}
catch(CARGoSException& ex) {
THROW_ARGOSEXCEPTION_NESTED("Error initializing the Buzz controller", ex);
}
}
static CByteArray ReadInternal(CPCSC *poPCSC, SCARDHANDLE hCard, unsigned long ulOffset, unsigned long ulMaxLen)
{
unsigned long ulLen = ulMaxLen > 252 ? 252 : ulMaxLen;
long lretVal = 0;
unsigned char tucReadDat[5] = {0xFF, 0xB2};
tucReadDat[2] = (unsigned char)(ulOffset/256);
tucReadDat[3] = (unsigned char)(ulOffset%256);
tucReadDat[4] = (unsigned char)(ulLen);
CByteArray oCmd(tucReadDat, sizeof(tucReadDat));
CByteArray oData = poPCSC->Transmit(hCard, oCmd, &lretVal);
oData.Chop(2); // remove SW12
// If we read enough, or there isn't more to read, return
if (ulMaxLen == ulLen || oData.Size() < ulLen)
{
MWLOG(LEV_INFO, MOD_CAL, L" Read %d bytes from the SIS card", oData.Size());
return oData;
}
ulLen = oData.Size();
ulOffset += ulLen;
ulMaxLen -= ulLen;
ulLen = ulMaxLen > 252 ? 252 : ulMaxLen;
tucReadDat[2] = (unsigned char)(ulOffset/256);
tucReadDat[3] = (unsigned char)(ulOffset%256);
tucReadDat[4] = (unsigned char)(ulLen);
oCmd = CByteArray(tucReadDat, sizeof(tucReadDat));
CByteArray oData2 = poPCSC->Transmit(hCard, oCmd,&lretVal);
oData2.Chop(2); // remove SW12
oData.Append(oData2);
MWLOG(LEV_INFO, MOD_CAL, L" Read %d bytes from the SIS card", oData.Size());
return oData;
}
static long TestReadShortFile(CReader & oReader, const std::string & csPath)
{
long lErrors = 0;
printf("\nTesting CReader::ReadFile() for short files\n");
try
{
CByteArray oFullData = oReader.ReadFile(csPath, 0, FULL_FILE);
CByteArray oData1 = oReader.ReadFile(csPath, 2, FULL_FILE);
if (oData1.Size() + 2 != oFullData.Size() ||
memcmp(oData1.GetBytes(), oFullData.GetBytes() + 2, oData1.Size()) != 0)
{
ERR_LOG("ERR: CReader::ReadFile(offset != 0) failed\n", lErrors);
}
CByteArray oData2 = oReader.ReadFile(csPath, 2, oFullData.Size() - 3);
if (oData2.Size() + 3 != oFullData.Size() ||
memcmp(oData2.GetBytes(), oFullData.GetBytes() + 2, oData2.Size()) != 0)
{
ERR_LOG("ERR: CReader::ReadFile(length != FULL_FILE) failed\n", lErrors);
}
CByteArray oData3 = oReader.ReadFile(csPath, 0, oFullData.Size() + 1);
if (!oData3.Equals(oFullData))
ERR_LOG("ERR: CReader::ReadFile(length = too long) returned a wrong data\n", lErrors);
bool bExceptionCaught = false;
try
{
CByteArray oData4 = oReader.ReadFile(csPath, oFullData.Size() + 1, 1);
}
catch(CMWException & e) {
bExceptionCaught = true;
if ( (unsigned) e.GetError() != EIDMW_ERR_PARAM_RANGE)
ERR_LOG("ERR: CReader::ReadFile(offset = too long) has thrown the wrong exception\n", lErrors);
}
if (!bExceptionCaught)
ERR_LOG("ERR: CReader::ReadFile(offset = too long) didn't throw an exception\n", lErrors);
CByteArray oData5 = oReader.ReadFile(csPath, 0, oFullData.Size());
if (!oData5.Equals(oFullData))
ERR_LOG("ERR: CReader::ReadFile(length = file size) failed\n", lErrors);
}
catch(const CMWException &e)
{
ERR_LOG("ERR: CReader::ReadFile() threw an MWException\n", lErrors);
printf(" MWException code: 0x%0x\n", (unsigned) e.GetError());
}
catch (...)
{
ERR_LOG("ERR: CReader::ReadFile() threw an Exception\n", lErrors);
}
return lErrors;
}
CByteArray GetData(const std::string & csData)
{
CByteArray oData;
// If it starts with "file:", we have to read a file
if (csData.substr(0, 7) == "file://")
{
const char *csFileName = csData.c_str() + 7;
#ifdef WIN32
FILE *f;
fopen_s(&f,csFileName, "rb");
#else
FILE *f = fopen(csFileName, "rb");
#endif
if (f != NULL)
{
unsigned char tucBuf[1000];
size_t len = fread(tucBuf, 1, sizeof(tucBuf), f);
while (len != 0)
{
oData.Append(tucBuf, (unsigned long) len);
len = fread(tucBuf, 1, sizeof(tucBuf), f);
}
printf("Read %d bytes from file \"%s\"\n", oData.Size(), csFileName);
fclose(f);
}
else
printf("Couldn't open file \"%s\", using empty data\n", csFileName);
}
else
{
oData = CByteArray(csData.c_str());
printf("Input: %d bytes\n", oData.Size());
}
return oData;
}
std::string * CCardLayer::GetDefaultReader()
{
std::string * pRet = &m_szDefaultReaderName;
if (m_szDefaultReaderName.size() == 0)
{
CByteArray csReaders = m_oPCSC.ListReaders();
if (csReaders.Size() != 0)
{
m_szDefaultReaderName = (char *)csReaders.GetBytes();
}
}
return pRet;
}
CSISCard::CSISCard(
SCARDHANDLE hCard,
CContext *poContext,
CPinpad *poPinpad,
const CByteArray & oData // is either the first 26 bytes, or the whole 404 bytes
) :CCard(hCard, poContext, poPinpad)
{
if (oData.Size() == 26)
m_oCardAtr = oData;
else
{
m_oCardAtr = CByteArray(oData.GetBytes(), 26);
m_oCardData = oData;
}
}
BOOL WINAPI
eidmwGenRandom(
IN HCRYPTPROV hProv, //!< Handle to provider previously obtained through a call to CPAcquireContext
IN DWORD cbLen, //!< Number of bytes of random data requested
OUT LPBYTE pbBuffer) //!< Buffer to store the random data
{
BOOL bReturnVal = FALSE;
DWORD dwLastError = 0;
__CSP_TRY__
MWLOG(LEV_INFO, MOD_CSP, L"CPGenRandom(hProv = %d) called", hProv);
MWLOG(LEV_INFO, MOD_CSP, L" - IN: cbLen = %d", cbLen);
CProviderContext *poProvCtx = g_oProviderContextPool.GetProviderContext(hProv);
std::string csContainerName = poProvCtx->GetContainerName();
if (csContainerName == "")
{
dwLastError = NTE_NO_KEY;
}
else
{
CAutoMutex oAutoMutex(&g_oCalMutex);
CReader *poReader = FindCard(poProvCtx);
if (poReader == NULL)
{
dwLastError = NTE_FAIL;
}
else
{
CByteArray oRandom = poReader->GetRandom(cbLen);
memcpy(pbBuffer, oRandom.GetBytes(), oRandom.Size());
bReturnVal = TRUE;
}
}
__STORE_LASTERROR__
MWLOG(LEV_INFO, MOD_CSP, L" Returning CPGenRandom(hProv = %d) with code 0x%0x",
hProv, bReturnVal ? 0 : dwLastError);
__CSP_CATCH_SETLASTERROR__
return (bReturnVal);
}
bool CEmulationCard::TransmitSpecified(
IN LPCBYTE pbSendBuffer,
IN DWORD cbSendLength,
OUT LPBYTE pbRecvBuffer,
IN OUT LPDWORD pcbRecvLength,
LONG & lRet)
{
return false;
CByteArray *poResp = NULL;
bool bFound = true;
if (m_bEnforce)
{
poResp = &m_oDefaultResponseAPDU;
lRet = m_lDefaultRet;
}
else
{
CByteArray oReq(pbSendBuffer, cbSendLength);
int i;
for (i = (int) m_Commands.size() - 1; i >= 0; i--)
{
if (m_Commands[i].m_oReq.Equals(oReq))
{
poResp = &m_Commands[i].m_oReq;
lRet = m_Commands[i].m_lRet;
break;
}
}
if (i < 0)
bFound = false;
else
{
if (poResp->Size() > *pcbRecvLength)
lRet = SCARD_E_INSUFFICIENT_BUFFER;
else
{
*pcbRecvLength = m_oDefaultResponseAPDU.Size();
memcpy(pbRecvBuffer, m_oDefaultResponseAPDU.GetBytes(), *pcbRecvLength);
lRet = SCARD_S_SUCCESS;
}
}
}
return bFound;
}
CCard *SISCardGetInstance(unsigned long ulVersion, const char *csReader,
SCARDHANDLE hCard, CContext *poContext, CPinpad *poPinpad)
{
CCard *poCard = NULL;
bool bIsSisCard = false;
CByteArray oData;
// Check if it's a SIS card by reading the ATR and serial number
try
{
poContext->m_oPCSC.BeginTransaction(hCard);
#ifndef SWITCH_TO_ASYNC_AFTER_READ
unsigned long ulReadLen = 26; // read only the first part
#else
unsigned long ulReadLen = 404; // read everything
try {
#endif
oData = ReadInternal(&poContext->m_oPCSC, hCard, 0, ulReadLen);
bIsSisCard =
(oData.Size() >= 26) &&
(oData.GetByte(21) == 0xA0) && (oData.GetByte(22) == 0x00) &&
(oData.GetByte(23) == 0x00) && (oData.GetByte(24) == 0x00) && (oData.GetByte(25) == 0x33);
#ifdef SWITCH_TO_ASYNC_AFTER_READ
} catch (...) {
// Switch back to asynchronous mode.
BackToAsyncMode(hCard, &poContext->m_oPCSC, csReader);
throw;
}
// Switch back to asynchronous mode.
BackToAsyncMode(hCard, &poContext->m_oPCSC, csReader);
#endif
if (bIsSisCard)
poCard = new CSISCard(hCard, poContext, poPinpad, oData);
poContext->m_oPCSC.EndTransaction(hCard);
}
catch(...)
{
poContext->m_oPCSC.EndTransaction(hCard);
//printf("Exception in cardPluginSIS.SISCardGetInstance()\n");
}
return poCard;
}