Skip to content

A Hardware Hacking Tool with Web-Based CLI That Speaks Every Protocol

add health cmd to I2C for device timing check

Geo39a96b01489e
diff --git a/src/Controllers/I2cController.cpp b/src/Controllers/I2cController.cpp
index 9c2848d0..5180bf1c 100644
--- a/src/Controllers/I2cController.cpp
+++ b/src/Controllers/I2cController.cpp
@@ -38,6 +38,7 @@ void I2cController::handleCommand(const TerminalCommand& cmd) {
else if (cmd.getRoot() == "recover") handleRecover();
else if (cmd.getRoot() == "monitor") handleMonitor(cmd);
else if (cmd.getRoot() == "swap") handleSwap();
+ else if (cmd.getRoot() == "health") handleHealth(cmd);
else if (cmd.getRoot() == "config") handleConfig();
else handleHelp();
}
@@ -840,8 +841,9 @@ void I2cController::handleHelp() {
terminalView.println(" write <addr> [reg] [val]");
terminalView.println(" dump <addr> [len]");
terminalView.println(" glitch <addr>");
- terminalView.println(" jam");
terminalView.println(" flood <addr>");
+ terminalView.println(" health <addr>");
+ terminalView.println(" jam");
terminalView.println(" recover");
terminalView.println(" monitor <addr> [delay_ms]");
terminalView.println(" eeprom [addr]");
@@ -871,6 +873,165 @@ void I2cController::handleSwap() {
terminalView.println("");
}
+/*
+Health
+*/
+void I2cController::handleHealth(const TerminalCommand& cmd) {
+ // Validate subcommand (addr)
+ if (!argTransformer.isValidNumber(cmd.getSubcommand())) {
+ terminalView.println("Usage: health <addr>");
+ return;
+ }
+ uint8_t addr = argTransformer.parseHexOrDec(cmd.getSubcommand());
+ terminalView.println("I2C Health: Analyzing @ 0x" + argTransformer.toHex(addr) + "... Press [ENTER] to stop.\n");
+
+ /* PING ANALYZE */
+
+ // Warm up for more accurate timing on the next tests
+ i2cService.beginTransmission(addr);
+ (void)i2cService.endTransmission(true);
+ delay(1);
+
+ terminalView.println("[ACK latency (ping)]");
+
+ const int PING_TRIES = 50;
+ uint32_t pingMin = 0xFFFFFFFF, pingMax = 0, pingSum = 0;
+ int pingOk = 0, pingNack = 0;
+
+ for (int i = 0; i < PING_TRIES; ++i) {
+ char key = terminalInput.readChar();
+ if (key == '\r' || key == '\n') {
+ terminalView.println("\nI2C Health: Stopped by user.");
+ return;
+ }
+
+ uint32_t t0 = micros();
+ i2cService.beginTransmission(addr);
+ uint8_t r = i2cService.endTransmission(true);
+ uint32_t dt = micros() - t0;
+
+ if (r == 0) {
+ pingOk++;
+ pingSum += dt;
+ if (dt < pingMin) pingMin = dt;
+ if (dt > pingMax) pingMax = dt;
+ } else {
+ pingNack++;
+ }
+ delay(1);
+ }
+
+ if (pingOk == 0) {
+ terminalView.println(" ❌ No ACK received.\n");
+ return;
+ }
+
+ // Ping stats
+ uint32_t pingAvg = pingSum / pingOk;
+ terminalView.println(" Tries: 50 Ok: " + std::to_string(pingOk) +
+ " Nack: " + std::to_string(pingNack));
+ terminalView.println(" Min: " + std::to_string(pingMin) + " µs Avg: " +
+ std::to_string(pingAvg) + " µs Max: " +
+ std::to_string(pingMax) + " µs\n\r Jitter: " +
+ std::to_string(pingMax - pingMin) + " µs\n");
+
+ /* REGISTER READ ANALYZE */
+
+ bool regSupported = i2cService.isReadableDevice(addr, 0x00);
+
+ terminalView.println("[Register read probe]");
+ terminalView.println(std::string(" Supported: ") + (regSupported ? "yes" : "no\n"));
+
+ const int READ_TRIES = 50;
+ uint32_t readMin = 0xFFFFFFFF, readMax = 0, readSum = 0;
+ int readOk = 0, readNack = 0;
+
+ if (regSupported) {
+ for (int i = 0; i < READ_TRIES; ++i) {
+ char key = terminalInput.readChar();
+ if (key == '\r' || key == '\n') {
+ terminalView.println("\nI2C Health: Stopped by user.");
+ return;
+ }
+
+ uint32_t t0 = micros();
+ bool ok = false;
+
+ i2cService.beginTransmission(addr);
+ i2cService.write((uint8_t)0x00);
+ if (i2cService.endTransmission(false) == 0) {
+ if (i2cService.requestFrom(addr, (uint8_t)1, true) == 1 &&
+ i2cService.available()) {
+ i2cService.read();
+ ok = true;
+ }
+ }
+
+ uint32_t dt = micros() - t0;
+
+ if (ok) {
+ readOk++;
+ readSum += dt;
+ if (dt < readMin) readMin = dt;
+ if (dt > readMax) readMax = dt;
+ } else {
+ readNack++;
+ }
+
+ while (i2cService.available()) i2cService.read();
+ delay(1);
+ }
+
+ if (readOk > 0) {
+ uint32_t readAvg = readSum / readOk;
+
+ terminalView.println(" Tries: 50 Ok: " + std::to_string(readOk) +
+ " Nack: " + std::to_string(readNack));
+ terminalView.println(" Min: " + std::to_string(readMin) + " µs Avg: " +
+ std::to_string(readAvg) + " µs Max: " +
+ std::to_string(readMax) + " µs\n\r Jitter: " +
+ std::to_string(readMax - readMin) + " µs\n");
+ } else {
+ terminalView.println(" ❌ No successful register reads\n");
+ }
+ }
+
+ /* REPORT ANALYZE */
+
+ terminalView.println("[Health report for 0x" + argTransformer.toHex(addr) + "]");
+
+ uint32_t freq = state.getI2cFrequency();
+ uint32_t bitUs = (freq > 0) ? (1000000UL / freq) : 10; // fallback 10us
+ uint32_t pingJ = pingMax - pingMin;
+ uint32_t readJ = (readOk > 0) ? (readMax - readMin) : 0;
+ uint32_t pingThr = 20 * bitUs;
+ uint32_t readThr = 40 * bitUs;
+
+ // Ping info
+ bool pingStable = (pingOk > 0) && (pingNack == 0) && (pingJ <= pingThr);
+ terminalView.println(pingStable ? " ✅ Stable ACK" : " ⚠️ ACK variability");
+
+ // Read info
+ if (!regSupported) {
+ terminalView.println(" Skipped reads (non-standard device)");
+ } else {
+ bool readStable = (readOk > 0) && (readNack == 0) && (readJ <= readThr);
+ terminalView.println(readStable ? " ✅ Stable reads" : " ⚠️ Read variability");
+ }
+
+ // Context info
+ terminalView.println(" Freq=" + std::to_string(freq) + " Hz bit=" + std::to_string(bitUs) + " µs");
+
+ // If there are 0 NACK but large jitter
+ if (pingNack == 0 && pingJ > (200 * bitUs)) {
+ terminalView.println(" No NACKs but high latency variance.");
+ }
+ if (readOk > 0 && readNack == 0 && readJ > (300 * bitUs)) {
+ terminalView.println(" Reads are reliable but variable.");
+ }
+ terminalView.println("");
+}
+
/*
Config
*/
diff --git a/src/Controllers/I2cController.h b/src/Controllers/I2cController.h
index c26e3116..ebda2828 100644
--- a/src/Controllers/I2cController.h
+++ b/src/Controllers/I2cController.h
@@ -87,6 +87,9 @@ private:
// Identify I2C device based on address
void handleIdentify(const TerminalCommand& cmd);
+ // Perform health timing test
+ void handleHealth(const TerminalCommand& cmd);
+
// Dump I2C registers content
void handleDump(const TerminalCommand& cmd);
void performRegisterRead(uint8_t addr, uint16_t, uint16_t len,
diff --git a/src/Controllers/UtilityController.cpp b/src/Controllers/UtilityController.cpp
index 399f8627..550d50ff 100644
--- a/src/Controllers/UtilityController.cpp
+++ b/src/Controllers/UtilityController.cpp
@@ -539,10 +539,11 @@ void UtilityController::handleHelp() {
terminalView.println(" dump <addr> [len] - Read all registers");
terminalView.println(" glitch <addr> - Run attack sequence");
terminalView.println(" flood <addr> - Saturate target I/O");
- terminalView.println(" jam - Jam I2C bus with noise");
+ terminalView.println(" health <addr> - Perform timing test");
terminalView.println(" monitor <addr> [ms] - Monitor register changes");
terminalView.println(" eeprom [addr] - I2C EEPROM operations");
terminalView.println(" recover - Attempt bus recovery");
+ terminalView.println(" jam - Jam I2C bus with noise");
terminalView.println(" swap - Swap SDA and SCL pins");
terminalView.println(" config - Configure settings");
terminalView.println(" [0x13 0x4B 0x1] - Instruction syntax");