int main(int ac, char **av) { using namespace logicalaccess; prologue(ac, av); introduction(); ReaderProviderPtr provider; ReaderUnitPtr readerUnit; ChipPtr chip; std::tie(provider, readerUnit, chip) = pcsc_test_init(); PRINT_TIME("Chip identifier: " << logicalaccess::BufferHelper::getHex(chip->getChipIdentifier())); PRINT_TIME("Chip type = " << chip->getCardType()); //LLA_ASSERT(chip->getCardType() == "GENERIC_T_CL", // "Chip is not GENERIC_T_CL"); LLA_ASSERT(chip->getCommands(), "No command object."); using namespace logicalaccess; auto mpu = std::dynamic_pointer_cast<MifarePlusSL0Commands>(chip->getCommands()); assert(mpu); PRINT_TIME("Boap: " << mpu->detectSecurityLevel()); pcsc_test_shutdown(readerUnit); return EXIT_SUCCESS; }
int main(int ac, char **av) { using namespace logicalaccess; prologue(ac, av); introduction(); ReaderProviderPtr provider; ReaderUnitPtr readerUnit; ChipPtr chip; std::tie(provider, readerUnit, chip) = lla_test_init(); PRINT_TIME( "Chip identifier: " << BufferHelper::getHex(chip->getChipIdentifier())); std::shared_ptr<AccessControlCardService> acs = std::dynamic_pointer_cast<AccessControlCardService>( chip->getService(CST_ACCESS_CONTROL)); std::array<uint8_t, 64> buffer = {0}; auto ret = acs->readFormat(std::make_shared<Wiegand26Format>(), std::make_shared<ProxLocation>(), nullptr); ret->getLinearData(&buffer[0], buffer.size()); std::cout << "Format: " << std::vector<uint8_t>(buffer.begin(), buffer.end()) << std::endl; pcsc_test_shutdown(readerUnit); return 0; }
int main(int ac, char **av) { prologue(ac, av); introduction(); ReaderProviderPtr provider; ReaderUnitPtr readerUnit; ChipPtr chip; std::tie(provider, readerUnit, chip) = pcsc_test_init(); PRINT_TIME("Chip identifier: " << logicalaccess::BufferHelper::getHex(chip->getChipIdentifier())); PRINT_TIME("Chip type = " << chip->getCardType()); auto mfp_sl1_cmd = std::dynamic_pointer_cast<MifarePlusSL1Commands>(chip->getCommands()); LLA_ASSERT(mfp_sl1_cmd, "No (or invalid) command object."); std::shared_ptr<AES128Key> aes_key = std::make_shared<AES128Key>(); //aes_key->fromString("ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff"); aes_key->fromString("00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00"); // LLA_ASSERT(mfp_sl1_cmd->AESAuthenticateSL1(aes_key), "AES Authentication failed"); aes_key->fromString("00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F"); //LLA_ASSERT(mfp_sl1_cmd->switchLevel2(aes_key), "Failed to switch to level 2"); LLA_ASSERT(mfp_sl1_cmd->switchLevel3(aes_key), "Failed to switch to level 3"); LLA_SUBTEST_PASSED("AES_Auth"); pcsc_test_shutdown(readerUnit); return EXIT_SUCCESS; }
void Drawer::drawMap( ) { PlayPtr play = Play::getTask( ); ChipPtr chip = play->getChipPtr( ); for ( int i = 0; i < Map::MAP_MAX; i++ ) { chip->drawChip( i, -3 ); } for ( int i = 0; i < Map::MAP_MAX; i++ ) { if ( chip->getChip( i ).status != STATUS::STATUS_NONE ) { chip->drawChip( i, 3 ); } } }
int main(int ac, char **av) { prologue(ac, av); introduction(); ReaderProviderPtr provider; ReaderUnitPtr readerUnit; ChipPtr chip; std::tie(provider, readerUnit, chip) = lla_test_init(); PRINT_TIME("CHip identifier: " << logicalaccess::BufferHelper::getHex(chip->getChipIdentifier())); LLA_ASSERT(chip->getCardType() == "ISO15693", "Chip is not a ISO15693, but is " + chip->getCardType() + " instead."); auto cmd = std::dynamic_pointer_cast<ISO15693Commands>(chip->getCommands()); LLA_ASSERT(cmd, "Cannot retrieve correct command object"); auto sysinfo = cmd->getSystemInformation(); // Our unittest card is supposed to have the blocksize/nbblock available. // However, this doesn't work with OK5427 and doesn't work with OK5321 on Linux. if (pcsc_reader_unit_name(readerUnit) == "OKXX21" && get_os_name() == "Win") { LLA_ASSERT(sysinfo.hasVICCMemorySize, "Doesn't have VICCMemorySize information"); LLA_ASSERT(sysinfo.blockSize == 4, "Unexpected block size"); LLA_ASSERT(sysinfo.nbBlocks == 40, "Unexpected block number"); LLA_SUBTEST_PASSED("SystemInformation"); } if ((get_os_name() == "Win" && pcsc_reader_unit_name(readerUnit) == "OKXX21") || pcsc_reader_unit_name(readerUnit) == "OKXX27") { write_read_test(readerUnit, cmd); } pcsc_test_shutdown(readerUnit); return EXIT_SUCCESS; }
int main(int ac, char **av) { using namespace logicalaccess; prologue(ac, av); introduction(); ReaderProviderPtr provider; ReaderUnitPtr readerUnit; ChipPtr chip; std::tie(provider, readerUnit, chip) = init(); PRINT_TIME("CHip identifier: " << logicalaccess::BufferHelper::getHex(chip->getChipIdentifier())); LLA_ASSERT(chip->getCardType() == "MifareUltralightC", "Chip is not an MifareUltralight(C), but is " + chip->getCardType() + " instead."); auto cmd = std::dynamic_pointer_cast<logicalaccess::MifareUltralightCommands>( chip->getCommands()); LLA_ASSERT(cmd, "Cannot get command from chip"); auto cmdUltraC = std::dynamic_pointer_cast<logicalaccess::MifareUltralightCCommands>( chip->getCommands()); LLA_ASSERT(cmdUltraC, "Cannot cast command to MifareUltralightCCommands"); auto profile = std::dynamic_pointer_cast<logicalaccess::MifareUltralightCProfile>( chip->getProfile()); LLA_ASSERT(profile, "Cannot fetch profile from chip"); //std::shared_ptr<logicalaccess::TripleDESKey> key(new logicalaccess::TripleDESKey("00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00")); std::shared_ptr<logicalaccess::TripleDESKey> key; cmdUltraC->authenticate(key); LLA_SUBTEST_PASSED("Authenticate"); std::vector<unsigned char> data(4), tmp; data[0] = 0x11; data[3] = 0xff; cmd->writePage(10, data); LLA_SUBTEST_PASSED("WritePage"); tmp = cmd->readPage(10); LLA_SUBTEST_PASSED("ReadPage"); LLA_ASSERT(std::equal(data.begin(), data.end(), tmp.begin()), "read and write data are different!"); LLA_SUBTEST_PASSED("WriteRead"); pcsc_test_shutdown(readerUnit); return EXIT_SUCCESS; }
int main(int ac, char **av) { using namespace logicalaccess; prologue(ac, av); introduction(); ReaderProviderPtr provider; ReaderUnitPtr readerUnit; ChipPtr chip; std::tie(provider, readerUnit, chip) = lla_test_init(); PRINT_TIME("Chip identifier: " << logicalaccess::BufferHelper::getHex(chip->getChipIdentifier())); // LLA_ASSERT(chip->getCardType() == "Mifare1K", // "Chip is not a Mifare1K, but is " + chip->getCardType() + // " instead."); auto storage = std::dynamic_pointer_cast<logicalaccess::StorageCardService>( chip->getService(logicalaccess::CST_STORAGE)); std::shared_ptr<logicalaccess::Location> location; std::shared_ptr<logicalaccess::AccessInfo> aiToUse; std::shared_ptr<logicalaccess::AccessInfo> aiToWrite; // We want to write data on sector 1. std::shared_ptr<logicalaccess::MifareLocation> mlocation( new logicalaccess::MifareLocation()); mlocation->sector = 4; mlocation->block = 0; location = mlocation; // Key to use for sector authentication std::shared_ptr<logicalaccess::MifareAccessInfo> maiToUse( new logicalaccess::MifareAccessInfo()); maiToUse->keyA->fromString("00 00 00 00 00 00"); // Default key maiToUse->keyB->fromString("00 00 00 00 00 00"); maiToUse->sab.setAReadBWriteConfiguration(); aiToUse = maiToUse; // Change the sector key with the following key std::shared_ptr<logicalaccess::MifareAccessInfo> maiToWrite( new logicalaccess::MifareAccessInfo()); maiToWrite->keyA->fromString("00 00 00 00 00 00"); maiToWrite->keyB->fromString("00 00 00 00 00 00"); maiToWrite->sab.setAReadBWriteConfiguration(); // Configure the sector access bits aiToWrite = maiToWrite; // Data to write std::vector<uint8_t> writedata(16, 'e'); // Data read std::vector<uint8_t> readdata; // Write data on the specified location with the specified key storage->writeData(location, aiToUse, aiToWrite, writedata, logicalaccess::CB_DEFAULT); using namespace logicalaccess; // required for overload of std::ostrean(vector &) PRINT_TIME("Wrote: " << writedata); LLA_SUBTEST_PASSED("WriteService") const int mifare_block_size = 16; // We read the data on the same location. Remember, the key is now changed. readdata = storage ->readData(location, aiToWrite, mifare_block_size, logicalaccess::CB_DEFAULT); PRINT_TIME("Read: " << readdata); LLA_SUBTEST_PASSED("ReadService") LLA_ASSERT(std::equal(writedata.begin(), writedata.end(), readdata.begin()), "Data read is not what we wrote."); LLA_SUBTEST_PASSED("CorrectWriteRead"); pcsc_test_shutdown(readerUnit); return 0; }
int main(int ac, char **av) { prologue(ac, av); introduction(); ReaderProviderPtr provider; ReaderUnitPtr readerUnit; ChipPtr chip; std::tie(provider, readerUnit, chip) = lla_test_init("EPass"); PRINT_TIME("Chip identifier: " << logicalaccess::BufferHelper::getHex(chip->getChipIdentifier())); LLA_ASSERT(chip->getCardType() == "EPass", "Chip is not a EPass, but is " + chip->getCardType() + " instead."); auto srv = std::dynamic_pointer_cast<IdentityCardService>(chip->getService(CST_IDENTITY)); LLA_ASSERT(srv, "Cannot retrieve identity service from the chip"); // Prepare the service. auto ai = std::make_shared<EPassAccessInfo>(); ai->mrz_ = "W7GCH9ZY24UTO7904107F2006187<<<<<<<<<<<<<<<2"; srv->setAccessInfo(ai); std::string name; LLA_ASSERT(srv->get(IdentityCardService::MetaData::NAME, name), "Failed to fetch name"); LLA_ASSERT("ANDERSON JANE" == name, "Name doesn't match."); LLA_SUBTEST_PASSED("GetName"); ByteVector picture_data; LLA_ASSERT(srv->get(IdentityCardService::MetaData::PICTURE, picture_data), "Failed to" "get picture bytes"); // We check the hash of the picture rather than the full picture bytes. Easier for tests. LLA_ASSERT(openssl::SHA1Hash(picture_data) == BufferHelper::fromHexString("9cb474bfb578a9c8defa8eb6fe9ea2cd643be308"), "Retrieved image picture doesn't match expected picture."); LLA_SUBTEST_PASSED("GetPicture"); std::string nationality; LLA_ASSERT(srv->get(IdentityCardService::MetaData::NATIONALITY, nationality), "Failed to fetch nationality"); LLA_ASSERT("UTO" == nationality, "Nationality doesn't match."); LLA_SUBTEST_PASSED("GetNationality"); std::string docno; LLA_ASSERT(srv->get(IdentityCardService::MetaData::DOC_NO, docno), "Failed to fetch document number."); LLA_ASSERT(docno == "W7GCH9ZY2", "Document number doesn't match."); LLA_SUBTEST_PASSED("GetDocNo"); std::chrono::system_clock::time_point tp; LLA_ASSERT(srv->get(IdentityCardService::MetaData::BIRTHDATE, tp), "Failed to " "fetch birthdate"); std::time_t tp_t = std::chrono::system_clock::to_time_t(tp); std::tm tm = *std::localtime(&tp_t); char buff[512]; std::strftime(buff, sizeof(buff), "%c", &tm); PRINT_TIME("Birthdate: " << buff); pcsc_test_shutdown(readerUnit); return EXIT_SUCCESS; }
int main(int, char **) { introduction(); ReaderProviderPtr provider; ReaderUnitPtr readerUnit; ChipPtr chip; std::tie(provider, readerUnit, chip) = pcsc_test_init(); PRINT_TIME("CHip identifier: " << logicalaccess::BufferHelper::getHex(chip->getChipIdentifier())); LLA_ASSERT(chip->getCardType() == "DESFireEV1", "Chip is not an DESFireEV1, but is " + chip->getCardType() + " instead."); auto location_root_node = chip->getRootLocationNode(); auto cmd = std::dynamic_pointer_cast<logicalaccess::DESFireISO7816Commands>( chip->getCommands()); auto cmdev1 = std::dynamic_pointer_cast<logicalaccess::DESFireEV1ISO7816Commands>( chip->getCommands()); LLA_ASSERT(cmd && cmdev1, "Cannot get correct command object from chip."); cmd->selectApplication(0x00); cmd->authenticate(0); cmd->erase(); cmdev1->createApplication(0x521, logicalaccess::DESFireKeySettings::KS_DEFAULT, 3, logicalaccess::DESFireKeyType::DF_KEY_AES, logicalaccess::FIDS_NO_ISO_FID, 0, std::vector<unsigned char>()); cmd->selectApplication(0x521); std::shared_ptr<logicalaccess::DESFireKey> key(new logicalaccess::DESFireKey()); key->setKeyType(logicalaccess::DESFireKeyType::DF_KEY_AES); cmd->authenticate(0, key); LLA_SUBTEST_PASSED("Authenticate"); logicalaccess::DESFireAccessRights ar; ar.readAccess = logicalaccess::TaskAccessRights::AR_KEY2; ar.writeAccess = logicalaccess::TaskAccessRights::AR_KEY1; ar.readAndWriteAccess = logicalaccess::TaskAccessRights::AR_KEY1; ar.changeAccess = logicalaccess::TaskAccessRights::AR_KEY1; cmdev1->createStdDataFile(0x00, logicalaccess::EncryptionMode::CM_ENCRYPT, ar, 4, 0); cmd->authenticate(1, key); std::vector<unsigned char> data = {0x01, 0x02, 0x03, 0x04}, tmp; cmdev1->writeData(0, 0, data, logicalaccess::EncryptionMode::CM_ENCRYPT); cmd->authenticate(2, key); tmp = cmdev1->readData(0, 0, 4, logicalaccess::EncryptionMode::CM_ENCRYPT); LLA_ASSERT(std::equal(data.begin(), data.end(), tmp.begin()), "read and write data are different!"); LLA_SUBTEST_PASSED("WriteRead"); cmd->authenticate(0x00, key); cmd->deleteFile(0x00); cmd->authenticate(0x00, key); std::shared_ptr<logicalaccess::DESFireKey> newkey( new logicalaccess::DESFireKey("00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 03")); cmd->changeKey(0x00, newkey); LLA_SUBTEST_PASSED("ChangeKey"); cmd->selectApplication(0x00); cmd->authenticate(0); cmd->deleteApplication(0x521); auto service = std::dynamic_pointer_cast<logicalaccess::AccessControlCardService>( chip->getService(logicalaccess::CardServiceType::CST_ACCESS_CONTROL)); LLA_ASSERT(service, "Cannot retrieve access control service from chip."); auto location = std::make_shared<logicalaccess::DESFireLocation>(); location->aid = 0x522; location->file = 0; auto ai = std::make_shared<logicalaccess::DESFireAccessInfo>(); auto format = std::make_shared<logicalaccess::Wiegand26Format>(); format->setUid(1000); format->setFacilityCode(67); service->writeFormat(format, location, ai, ai); auto formattmp = std::make_shared<logicalaccess::Wiegand26Format>(); auto rformat = std::dynamic_pointer_cast<logicalaccess::Wiegand26Format>( service->readFormat(formattmp, location, ai)); if (!rformat || rformat->getUid() != 1000 || rformat->getFacilityCode() != 67) THROW_EXCEPTION_WITH_LOG(std::runtime_error, "Bad format"); LLA_SUBTEST_PASSED("ReadFormat"); pcsc_test_shutdown(readerUnit); return EXIT_SUCCESS; }