A Hardware Hacking Tool with Web-Based CLI That Speaks Every Protocol
C arduinobluetoothcan-busdebuggingeepromesp32flipperzerogpiohardware-hackingi2cjtagopenocdprotocolspwmradiorfidspisubghzuartwifi
create smartcard shell to handle cmd
Geobb1fcaae2ef6
diff --git a/src/Shells/I2cEepromShell.cpp b/src/Shells/I2cEepromShell.cppindex 83522a49..19db9e81 100644--- a/src/Shells/I2cEepromShell.cpp+++ b/src/Shells/I2cEepromShell.cpp@@ -15,8 +15,8 @@ I2cEepromShell::I2cEepromShell(binaryAnalyzeManager(binaryAnalyzeManager) {}void I2cEepromShell::run(uint8_t addr) {- terminalView.println("I2C EEPROM Shell started...\n");-+ terminalView.println("\n=== I2C EEPROM Shell ===");+// Select EEPROM modelint selectedModelIndex = userInputManager.readValidatedChoiceIndex("Select EEPROM type", models, 0);if (selectedModelIndex < 0) {diff --git a/src/Shells/SmartCardShell.cpp b/src/Shells/SmartCardShell.cppnew file mode 100644index 00000000..220c6248--- /dev/null+++ b/src/Shells/SmartCardShell.cpp@@ -0,0 +1,288 @@++#include "SmartCardShell.h"++SmartCardShell::SmartCardShell(+ TwoWireService& twoWireService,+ ITerminalView& terminalView,+ IInput& terminalInput,+ ArgTransformer& argTransformer,+ UserInputManager& userInputManager+)+ : twoWireService(twoWireService),+ terminalView(terminalView),+ terminalInput(terminalInput),+ argTransformer(argTransformer),+ userInputManager(userInputManager)+{}++void SmartCardShell::run() {+ const std::vector<std::string> actions = {+ "π Probe",+ "π‘οΈ Security check",+ "π Unlock card",+ "π PSC Set",+ "π PSC Get",+ "βοΈ Write",+ "ποΈ Dump",+ "π« Protect",+ "πͺ Exit Shell"+ };++ while (true) {+ terminalView.println("\n=== SLE44XX SmartCard Shell ===");+ int index = userInputManager.readValidatedChoiceIndex("Select a SmartCard action", actions, 0);++ if (index == -1 || actions[index] == "πͺ Exit Shell") {+ terminalView.println("Exiting SmartCard Shell...\n");+ break;+ }++ switch (index) {+ case 0: cmdProbe(); break;+ case 1: cmdSecurity(); break;+ case 2: cmdUnlock(); break;+ case 3: cmdPsc("set"); break;+ case 4: cmdPsc("get"); break;+ case 5: cmdWrite(); break;+ case 6: cmdDump(); break;+ case 7: cmdProtect(); break;+ default:+ terminalView.println("Unknown choice.\n");+ break;+ }+ }+}++/*+Smartcard Security+*/+void SmartCardShell::cmdSecurity() {+ twoWireService.resetSmartCard();++ terminalView.println("2WIRE Security: Perfoming...\n");++ // Security memory+ terminalView.println(" [Security Memory] Command: 0x31 0x00 0x00");+ twoWireService.sendCommand(0x31, 0x00, 0x00);+ auto sec = twoWireService.readResponse(4);++ // Validate+ bool allZero = std::all_of(sec.begin(), sec.end(), [](uint8_t b) { return b == 0x00; });+ bool allFF = std::all_of(sec.begin(), sec.end(), [](uint8_t b) { return b == 0xFF; });+ if (sec.empty() || allZero || allFF) {+ terminalView.println("2WIRE Security: β No smartcard detected (response invalid)");+ return;+ }++ // Display+ std::stringstream secOut;+ secOut << " Security Bytes: ";+ for (auto b : sec) secOut << "0x" << std::hex << std::setw(2) << std::setfill('0') << (int)b << " ";+ terminalView.println(secOut.str());++ if (!sec.empty()) {+ uint8_t attempts = twoWireService.parseSmartCardRemainingAttempts(sec[0]);+ terminalView.println(" Remaining Unlock Attempts: " + std::to_string(attempts));+ }++ terminalView.println("\n2WIRE Security: β Completed.");+}++/*+Smartcard Probe (ATR)+*/+void SmartCardShell::cmdProbe() {+ terminalView.println("\n2WIRE ATR: Performing...\n");++ // ATR+ auto atr = twoWireService.performSmartCardAtr();+ std::stringstream ss;+ ss << "ATR: ";++ // Validate+ if (atr.empty() || atr[0] == 0x00 || atr[0] == 0xFF) {+ terminalView.println("2WIRE ATR: β No response received from smartcard");+ return;+ }++ // Decode and display+ auto decodedAtr = twoWireService.parseSmartCardAtr(atr);+ for (uint8_t b : atr) {+ ss << "0x" << std::hex << std::setw(2) << std::setfill('0') << static_cast<int>(b) << " ";+ }+ terminalView.println(decodedAtr);++ twoWireService.resetSmartCard();+ terminalView.println("2WIRE ATR: β Completed.");+}++/*+Smartcard Dump+*/+void SmartCardShell::cmdDump() {+ twoWireService.resetSmartCard();+ delay(10);+ terminalView.println("\n2WIRE Dump: Reading full memory (MAIN + SEC + PROTECT)...");++ // Dump 256 bytes + sec mem + protection mem+ auto dump = twoWireService.dumpSmartCardFullMemory();+ if (dump.size() != 264) {+ terminalView.println("\n2WIRE Dump: β Failed, unexpected size.");+ return;+ }++ // Validate data+ bool allZero = std::all_of(dump.begin(), dump.end(), [](uint8_t b) { return b == 0x00; });+ bool allFF = std::all_of(dump.begin(), dump.end(), [](uint8_t b) { return b == 0xFF; });+ if (allZero || allFF) {+ terminalView.println("\n2WIRE Dump: β Smartcard is blank or no smartcard detected");+ return;+ }++ // Main memory (0β255)+ terminalView.println("\n[Main Memory]");+ for (int i = 0; i < 256; i += 16) {+ std::stringstream line;+ line << std::hex << std::uppercase << std::setfill('0');+ line << std::setw(2) << i << ": ";+ for (int j = 0; j < 16; ++j) {+ line << std::setw(2) << static_cast<int>(dump[i + j]) << " ";+ }+ terminalView.println(line.str());+ }++ // Security memory (256β259)+ terminalView.println("\n[Security Memory]");+ std::stringstream sec;+ sec << "SEC: ";+ for (int i = 256; i < 260; ++i) {+ sec << "0x" << std::hex << std::setw(2) << std::setfill('0') << static_cast<int>(dump[i]) << " ";+ }+ uint8_t attempts = twoWireService.parseSmartCardRemainingAttempts(dump[256]);+ sec << "β Attempts Left: " << std::dec << (int)attempts;+ terminalView.println(sec.str());++ // Protection memory (260β263)+ terminalView.println("\n[Protection Memory]");+ std::stringstream prt;+ prt << "PRT: ";+ for (int i = 260; i < 264; ++i) {+ prt << "0x" << std::hex << std::setw(2) << std::setfill('0') << static_cast<int>(dump[i]) << " ";+ }+ terminalView.println(prt.str());++ twoWireService.resetSmartCard();+ terminalView.println("\n2WIRE Dump: β Completed.");+}++/*+Smartcard Protect+*/+void SmartCardShell::cmdProtect() {+ twoWireService.resetSmartCard();+ terminalView.println("β οΈ The smartcard will PERMANENTLY disable writes to main memory.");+ bool confirm = userInputManager.readYesNo("Are you sure you want to lock it PERMANENTLY?", false);+ if (!confirm) {+ terminalView.println("\nβ Lock cancelled.");+ return;+ }++ bool ok = twoWireService.protectSmartCard();+ if (ok) terminalView.println("\nβ Smartcard successfully locked (writes disabled).");+ else terminalView.println("\nβ Failed to lock smartcard.");+}++/*+Smartcard Unlock+*/+void SmartCardShell::cmdUnlock() {+ twoWireService.resetSmartCard();+ terminalView.println("2WIRE Unlock: Attempting unlock procedure...");++ // Prompt for PSC (PIN Code)+ auto pscStr = userInputManager.readValidatedHexString("Enter PSC (PIN Code) (ex: 123456)", 3);+ auto psc = argTransformer.parseHexList(pscStr);++ // Unlock+ bool success = twoWireService.unlockSmartCard(psc.data());++ if (success) {+ terminalView.println("\nβ Unlock successful: Access to main memory granted.");+ } else {+ terminalView.println("\nβ Unlock failed: PSC incorrect or no attempts remaining.");+ }++ // Number of attempts left+ auto secAfter = twoWireService.readSmartCardSecurityMemory();+ if (!secAfter.empty()) {+ uint8_t attempts = twoWireService.parseSmartCardRemainingAttempts(secAfter[0]);+ terminalView.println("β Remaining Attempts: " + std::to_string(attempts));+ }+}++/*+Smartcard PSC (PIN Code)+*/+void SmartCardShell::cmdPsc(const std::string& subcommand) {+ twoWireService.resetSmartCard();+ std::string arg = subcommand;++ if (arg.empty()) {+ arg = "get"; // Default to "get" if no argument provided+ }++ // GET PSC+ if (arg == "get") {+ uint8_t psc[3];+ bool ok = twoWireService.getSmartCardPSC(psc);+ if (ok) {+ terminalView.println("\nβΉοΈ Note: The PSC (PIN Code) can only be read if the smartcard is unlocked.");+ std::stringstream ss;+ ss << "π Current PSC (PIN Code): ";+ for (int i = 0; i < 3; ++i)+ ss << std::hex << std::setw(2) << std::setfill('0') << (int)psc[i] << " ";+ terminalView.println(ss.str());++ } else {+ terminalView.println("\nβ Failed to read PSC (PIN Code).");+ }++ // SET PSC+ } else if (arg == "set") {+ // Prompt for PSC (PIN Code)+ auto pscStr = userInputManager.readValidatedHexString("Enter PSC (PIN Code) (ex: 123456)", 3);+ auto psc = argTransformer.parseHexList(pscStr);++ bool ok = twoWireService.updateSmartCardPSC(psc.data());+ if (ok) {+ terminalView.println("\nβ PSC (PIN Code) updated successfully.");+ } else {+ terminalView.println("\nβΉοΈ Note: The PSC (PIN Code) can only be set if the smartcard is unlocked.");+ terminalView.println("β Failed to update PSC (PIN Code).");+ }+ }+}++// Smartcard Write+void SmartCardShell::cmdWrite() {+ twoWireService.resetSmartCard();++ int offset = userInputManager.readValidatedUint8("Enter offset (0β255 or 0x..)", 0);+ if (offset < 0 || offset >= 256) {+ terminalView.println("\nβ Invalid offset (must be between 0 and 255).");+ return;+ }++ int data = userInputManager.readValidatedUint8("Enter data byte (0β255 or 0x..)", 0);+ if (data < 0 || data > 0xFF) {+ terminalView.println("\nβ Invalid data byte.");+ return;+ }++ bool ok = twoWireService.writeSmartCardMainMemory(static_cast<uint8_t>(offset), static_cast<uint8_t>(data));+ if (ok) terminalView.println("\nβ Write successful.");+ else {+ terminalView.println("\nβΉοΈ Note: Unlock the smartcard if you are not able to write.");+ terminalView.println("β Write failed.");+ }+}\ No newline at end of filediff --git a/src/Shells/SmartCardShell.h b/src/Shells/SmartCardShell.hnew file mode 100644index 00000000..9f64ff2f--- /dev/null+++ b/src/Shells/SmartCardShell.h@@ -0,0 +1,36 @@++#pragma once++#include <vector>+#include <string>+#include "Services/TwoWireService.h"+#include "Managers/UserInputManager.h"+#include "Interfaces/IInput.h"+#include "Interfaces/ITerminalView.h"++class SmartCardShell {+public:+ SmartCardShell(+ TwoWireService& twoWireService,+ ITerminalView& terminalView,+ IInput& terminalInput,+ ArgTransformer& argTransformer,+ UserInputManager& userInputManager+ );+ void run();++private:+ TwoWireService& twoWireService;+ ITerminalView& terminalView;+ IInput& terminalInput;+ UserInputManager& userInputManager;+ ArgTransformer& argTransformer;++ void cmdProbe();+ void cmdSecurity();+ void cmdDump();+ void cmdUnlock();+ void cmdPsc(const std::string& subcommand);+ void cmdWrite();+ void cmdProtect();+};