Skip to content

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

16.9 KB
Raw Blame
#include "I2cService.h"
#include "driver/gpio.h"

void I2cService::configure(uint8_t sda, uint8_t scl, uint32_t frequency) {
    Wire.end();
    Wire.begin(sda, scl, frequency);
}

void I2cService::beginTransmission(uint8_t address) {
    Wire.beginTransmission(address);
}

void I2cService::write(uint8_t data) {
    Wire.write(data);
}

bool I2cService::endTransmission(bool sendStop) {
    return Wire.endTransmission(sendStop);
}

uint8_t I2cService::requestFrom(uint8_t address, uint8_t quantity, bool sendStop) {
    return Wire.requestFrom(address, quantity, sendStop);
}

int I2cService::read() {
    return Wire.read();
}

bool I2cService::available() const {
    return Wire.available();
}

bool I2cService::end() const {
    return Wire.end();
}

std::string I2cService::executeByteCode(const std::vector<ByteCode>& bytecodes) {
    std::string result;
    uint8_t currentAddress = 0;
    bool transmissionStarted = false;
    bool expectAddress = false;

    for (const auto& code : bytecodes) {
        switch (code.getCommand()) {
            case ByteCodeEnum::Start:
                expectAddress = true;
                break;

            case ByteCodeEnum::Stop:
                if (transmissionStarted) {
                    Wire.endTransmission();
                    transmissionStarted = false;
                }
                break;

            case ByteCodeEnum::Write:
                if (expectAddress) {
                    currentAddress = code.getData();
                    Wire.beginTransmission(currentAddress);
                    transmissionStarted = true;
                    expectAddress = false;
                } else {
                    if (!transmissionStarted) {
                        Wire.beginTransmission(currentAddress);
                        transmissionStarted = true;
                    }
                    for (uint32_t i = 0; i < code.getRepeat(); ++i) {
                        Wire.write(code.getData());
                    }
                }
                break;

                case ByteCodeEnum::Read: {
                    if (transmissionStarted) {
                        Wire.endTransmission(false);  // release bus
                        transmissionStarted = false;
                    }

                    uint8_t toRead = code.getRepeat();
                    uint8_t readAddr = currentAddress;

                    Wire.requestFrom(readAddr, toRead);
                    
                    for (uint8_t i = 0; i < toRead && Wire.available(); ++i) {
                        uint8_t val = Wire.read();
                        char hex[5];
                        snprintf(hex, sizeof(hex), "%02X ", val);
                        result += hex;
                    }
                    break;
                }

            case ByteCodeEnum::DelayMs:
                delay(code.getRepeat());
                break;

            case ByteCodeEnum::DelayUs:
                delayMicroseconds(code.getRepeat());
                break;

            default:
                break;
        }
    }

    // If no end stop
    if (transmissionStarted) {
        Wire.endTransmission();
    }

    return result;
}

bool I2cService::isReadableDevice(uint8_t addr, uint8_t startReg) {
    beginTransmission(addr);
    write(startReg);
    bool writeOk = (endTransmission(false) == 0);
    if (!writeOk) return false;

    uint8_t received = requestFrom(addr, 1, true);
    if (received != 1 || !available()) return false;

    read();  // read to flush
    return true;
}

/*
Slave
*/

void I2cService::beginSlave(uint8_t address, uint8_t sda, uint8_t scl, uint32_t freq) {
    Wire.end();
    Wire1.end();
    Wire1.begin(address, sda, scl, freq);

    Wire1.onReceive(onSlaveReceive);
    Wire1.onRequest(onSlaveRequest);
}

void I2cService::endSlave() {
    Wire1.end();
}

std::vector<std::string> I2cService::getSlaveLog() {
    portENTER_CRITICAL(&slaveLogMux);
    std::vector<std::string> copy = slaveLog;
    portEXIT_CRITICAL(&slaveLogMux);
    return copy;
}

uint32_t I2cService::getSlaveLogCount() {
    portENTER_CRITICAL(&slaveLogMux);
    uint32_t v = slaveLogTotal;
    portEXIT_CRITICAL(&slaveLogMux);
    return v;
}

void I2cService::clearSlaveLog() {
    portENTER_CRITICAL(&slaveLogMux);
    slaveLog.clear();
    slaveLogWriteIdx = 0;
    portEXIT_CRITICAL(&slaveLogMux);
}

void I2cService::onSlaveReceive(int len) {
    std::string entry = "Master wrote: 0x";
    while (Wire1.available()) {
        uint8_t b = Wire1.read();
        char hex[5];
        snprintf(hex, sizeof(hex), " %02X", b);
        entry += hex;
    }

    portENTER_CRITICAL(&slaveLogMux);

    if (slaveLog.size() < SLAVE_LOG_MAX) {
        slaveLog.push_back(entry);
    } else {
        slaveLog[slaveLogWriteIdx] = entry;
        slaveLogWriteIdx = (slaveLogWriteIdx + 1) % SLAVE_LOG_MAX;
    }
    slaveLogTotal++;

    portEXIT_CRITICAL(&slaveLogMux);
}

void I2cService::onSlaveRequest() {
    portENTER_CRITICAL(&slaveLogMux);

    const std::string entry = "Master requested read";

    if (slaveLog.size() < SLAVE_LOG_MAX) {
        slaveLog.push_back(entry);
    } else {
        slaveLog[slaveLogWriteIdx] = entry;
        slaveLogWriteIdx = (slaveLogWriteIdx + 1) % SLAVE_LOG_MAX;
    }
    slaveLogTotal++;

    portEXIT_CRITICAL(&slaveLogMux);

    // Send counter as data
    uint8_t v = (uint8_t)(slaveLogTotal & 0xFF);
    Wire1.write(&v, 1);
}

/*
Glitch
*/

void I2cService::i2cBitBangDelay(uint32_t delayUs) {
    if (delayUs > 0) esp_rom_delay_us(delayUs);
}

void I2cService::i2cBitBangSetLevel(uint8_t pin, bool level) {
    gpio_set_level((gpio_num_t)pin, level);
}

void I2cService::i2cBitBangSetOutput(uint8_t pin) {
    gpio_set_direction((gpio_num_t)pin, GPIO_MODE_OUTPUT);
}

void I2cService::i2cBitBangSetInput(uint8_t pin) {
    gpio_set_direction((gpio_num_t)pin, GPIO_MODE_INPUT);
}

void I2cService::i2cBitBangStartCondition(uint8_t scl, uint8_t sda, uint32_t delayUs) {
    i2cBitBangSetInput(sda);  // Pull-up
    i2cBitBangSetInput(scl);  // Pull-up
    i2cBitBangDelay(delayUs);

    i2cBitBangSetOutput(sda);
    i2cBitBangSetLevel(sda, LOW); // SDA low
    i2cBitBangDelay(delayUs);

    i2cBitBangSetOutput(scl);
    i2cBitBangSetLevel(scl, LOW); // SCL low
    i2cBitBangDelay(delayUs);
}

void I2cService::i2cBitBangStopCondition(uint8_t scl, uint8_t sda, uint32_t delayUs) {
    i2cBitBangSetOutput(sda);
    i2cBitBangSetLevel(sda, LOW); // SDA low
    i2cBitBangDelay(delayUs);

    i2cBitBangSetInput(scl);      // SCL high
    i2cBitBangDelay(delayUs);

    i2cBitBangSetInput(sda);      // SDA high
    i2cBitBangDelay(delayUs);
}

void I2cService::i2cBitBangWriteBit(uint8_t scl, uint8_t sda, bool bit, uint32_t d) {
    i2cBitBangSetOutput(sda);
    i2cBitBangSetLevel(sda, bit);
    i2cBitBangDelay(d);
    i2cBitBangSetLevel(scl, 1);
    i2cBitBangDelay(d);
    i2cBitBangSetLevel(scl, 0);
    i2cBitBangDelay(d);
}

void I2cService::i2cBitBangWriteByte(uint8_t scl, uint8_t sda, uint8_t byte, uint32_t d, bool& ack) {
    for (int i = 7; i >= 0; --i) {
        i2cBitBangWriteBit(scl, sda, (byte >> i) & 0x01, d);
    }

    // ACK/NACK
    i2cBitBangSetInput(sda);
    i2cBitBangDelay(d);
    i2cBitBangSetLevel(scl, 1);
    i2cBitBangDelay(d);
    ack = (gpio_get_level((gpio_num_t)sda) == 0); // ACK = SDA low
    i2cBitBangSetLevel(scl, 0);
    i2cBitBangDelay(d);
    i2cBitBangSetOutput(sda);
}

void I2cService::i2cBitBangReadByte(uint8_t scl, uint8_t sda, uint32_t d, bool nackLast) {
    uint8_t data = 0;
    i2cBitBangSetInput(sda);
    for (int i = 7; i >= 0; --i) {
        i2cBitBangSetLevel(scl, 1);
        i2cBitBangDelay(d);
        if (gpio_get_level((gpio_num_t)sda)) {
            data |= (1 << i);
        }
        i2cBitBangSetLevel(scl, 0);
        i2cBitBangDelay(d);
    }

    // Send ACK/NACK
    i2cBitBangSetOutput(sda);
    i2cBitBangSetLevel(sda, nackLast ? 1 : 0); // NACK if last byte
    i2cBitBangDelay(d);
    i2cBitBangSetLevel(scl, 1);
    i2cBitBangDelay(d);
    i2cBitBangSetLevel(scl, 0);
    i2cBitBangSetLevel(sda, 1);
}

bool I2cService::i2cBitBangRecoverBus(uint8_t scl, uint8_t sda, uint32_t freqHz) {
    uint32_t delayUs = 500000 / freqHz; // demi periode

    // SCL/SDA input
    i2cBitBangSetInput(scl);
    i2cBitBangSetInput(sda);
    i2cBitBangDelay(delayUs);

    // SDA is low, bus is stuck
    if (gpio_get_level((gpio_num_t)sda) == 0) {
        // 16 pulses on SCL or until SDA is high
        i2cBitBangSetOutput(scl);
        for (int i = 0; i < 16; ++i) {
            i2cBitBangSetLevel(scl, 0);
            i2cBitBangDelay(delayUs);
            i2cBitBangSetLevel(scl, 1);
            i2cBitBangDelay(delayUs);

            if (gpio_get_level((gpio_num_t)sda) == 1) break;
        }
    }

    // STOP condition
    i2cBitBangStopCondition(scl, sda, delayUs);

    delay(20); // wait for bus to stabilize

    return gpio_get_level((gpio_num_t)sda) == 1;
}

void I2cService::rapidStartStop(uint8_t address, uint32_t freqHz, uint8_t scl, uint8_t sda) {
    uint32_t d = 500000 / freqHz;
    bool ack;
    for (int i = 0; i < 500; ++i) {
        i2cBitBangStartCondition(scl, sda, 0);
        i2cBitBangWriteByte(scl, sda, address << 1, d, ack);
        i2cBitBangStopCondition(scl, sda, 0);
    }
}

void I2cService::floodStart(uint8_t address, uint32_t freqHz, uint8_t scl, uint8_t sda) {
    uint32_t d = 500000 / freqHz;
    for (int i = 0; i < 1000; ++i) {
        i2cBitBangStartCondition(scl, sda, 0);
        bool ack;
        i2cBitBangWriteByte(scl, sda, address << 1, d, ack);
    }
}

void I2cService::floodRandom(uint8_t address, uint32_t freqHz, uint8_t scl, uint8_t sda) {
    uint32_t d = 500000 / freqHz;
    for (int i = 0; i < 100; ++i) {
        // START
        i2cBitBangStartCondition(scl, sda, 0);


        // Send address + data
        bool ack = false;
        i2cBitBangWriteByte(scl, sda, address << 1, d, ack);
        for (int j = 0; j < 20; ++j) {
            i2cBitBangWriteByte(scl, sda, rand() & 0xFF, d, ack);
        }

        // STOP
        i2cBitBangStopCondition(scl, sda, 0);
        delay(5);
    }
}

void I2cService::overReadAttack(uint8_t address, uint32_t freqHz, uint8_t scl, uint8_t sda) {
    uint32_t d = 500000 / freqHz;
    bool ack;

    // START
    i2cBitBangStartCondition(scl, sda, 0);


    i2cBitBangWriteByte(scl, sda, (address << 1) | 1, d, ack);

    for (int i = 0; i < 1024; ++i) {
        i2cBitBangReadByte(scl, sda, d, false);  // ACK
    }
    i2cBitBangReadByte(scl, sda, d, true); // NACK

    // STOP
    i2cBitBangStopCondition(scl, sda, 0);

}

void I2cService::invalidRegisterRead(uint8_t address, uint32_t freqHz, uint8_t scl, uint8_t sda) {
    uint32_t d = 500000 / freqHz;
    bool ack;

    for (int i = 0; i < 512; ++i) {
        // START
        i2cBitBangStartCondition(scl, sda, 0);

        i2cBitBangWriteByte(scl, sda, address << 1, d, ack);  // write
        i2cBitBangWriteByte(scl, sda, 0xFF, d, ack);          // invalid register

        // Repeated START
        i2cBitBangSetLevel(sda, 1); i2cBitBangSetLevel(scl, 1); i2cBitBangDelay(d);
        i2cBitBangSetLevel(sda, 0); i2cBitBangDelay(d);
        i2cBitBangSetLevel(scl, 0);

        i2cBitBangWriteByte(scl, sda, (address << 1) | 1, d, ack); // read
        i2cBitBangReadByte(scl, sda, d, true); // NACK

        // STOP
        i2cBitBangStopCondition(scl, sda, 0);
        delay(2);
    }
}

void I2cService::simulateClockStretch(uint8_t address, uint32_t freqHz, uint8_t scl, uint8_t sda) {
    uint32_t d = 500000 / freqHz;
    bool ack;

    for (int i = 0; i < 50; ++i) {
        i2cBitBangSetLevel(sda, 1); i2cBitBangSetLevel(scl, 1); i2cBitBangDelay(d);
        i2cBitBangSetLevel(sda, 0); i2cBitBangDelay(d);
        i2cBitBangSetLevel(scl, 0);

        i2cBitBangWriteByte(scl, sda, address << 1, d, ack);
        i2cBitBangWriteByte(scl, sda, 0xA5, d, ack);

        delay(2); // simulate slave clock stretch confusion

        i2cBitBangSetLevel(sda, 0); i2cBitBangDelay(d);
        i2cBitBangSetLevel(scl, 1); i2cBitBangDelay(d);
        i2cBitBangSetLevel(sda, 1); i2cBitBangDelay(d);

        delay(2); // simulate slave clock stretch confusion

    }
}

void I2cService::glitchAckInjection(uint8_t address, uint32_t freqHz, uint8_t scl, uint8_t sda) {
    uint32_t d = 500000 / freqHz;
    bool ack;

    // START
    i2cBitBangStartCondition(scl, sda, 0);

    i2cBitBangWriteByte(scl, sda, address << 1, d, ack);

    for (int i = 0; i < 10; ++i) {
        for (int b = 7; b >= 0; --b)
            i2cBitBangWriteBit(scl, sda, (0x00 >> b) & 1, d);

        // Simule ACK
        i2cBitBangSetOutput(sda);
        i2cBitBangSetLevel(sda, 0); i2cBitBangDelay(1);
        i2cBitBangSetLevel(scl, 1); i2cBitBangDelay(1);
        i2cBitBangSetLevel(scl, 0);
    }

    // STOP
    i2cBitBangStopCondition(scl, sda, 0);

}

void I2cService::sclSdaGlitch(uint8_t scl, uint8_t sda) {
    for (int i = 0; i < 20; ++i) {
        i2cBitBangSetOutput(scl);
        i2cBitBangSetLevel(scl, 0);
        i2cBitBangSetOutput(sda);
        i2cBitBangSetLevel(sda, 0);
        delayMicroseconds(5 + (esp_random() % 10));  // 5–15 µs

        i2cBitBangSetInput(scl);
        i2cBitBangSetInput(sda);
        delayMicroseconds(5 + (esp_random() % 10));
    }
}

void I2cService::randomClockPulseNoise(uint8_t scl, uint8_t sda, uint32_t freqHz) {
    uint32_t d = 500000 / freqHz;

    i2cBitBangSetOutput(scl);
    i2cBitBangSetOutput(sda);

    for (int i = 0; i < 100; ++i) {
        i2cBitBangSetLevel(scl, random(2));
        i2cBitBangSetLevel(sda, random(2));
        delayMicroseconds(random(d));
    }
}

void I2cService::injectRandomGlitch(uint8_t scl, uint8_t sda, uint32_t freqHz) {
    if (freqHz == 0) freqHz = 100000;

    switch (esp_random() % 3) {

        case 0:
            randomClockPulseNoise(scl, sda, freqHz);
            break;

        case 1:
            sclSdaGlitch(scl, sda);
            break;

        case 2:
            // Reserved address, no real device targeted
            rapidStartStop(0x7F, freqHz, scl, sda);
            break;
    }
}

bool I2cService::initEeprom(uint16_t chipSizeKb, uint8_t addr) {
    eeprom.setMemoryType(chipSizeKb);
    return eeprom.begin(addr);
}

bool I2cService::eepromWriteByte(uint16_t address, uint8_t value) {
    return eeprom.write(address, value);
}

uint8_t I2cService::eepromReadByte(uint16_t address) {
    return eeprom.read(address);
}

bool I2cService::eepromPutString(uint32_t address, const std::string& str) {
    String arduinoStr(str.c_str());
    return eeprom.putString(address, arduinoStr) > 0;
}

bool I2cService::eepromGetString(uint32_t address, std::string& outStr) {
    String arduinoStr;
    eeprom.getString(address, arduinoStr);
    outStr = std::string(arduinoStr.c_str());
    return true;
}

void I2cService::eepromErase(uint8_t fill) {
    eeprom.erase(fill);
}

bool I2cService::eepromDetectMemorySize() {
    uint32_t size = eeprom.detectMemorySizeBytes();
    if (size > 0) {
        eeprom.setMemorySizeBytes(size);
        return true;
    }
    return false;
}

uint8_t I2cService::eepromDetectAddressBytes() {
    uint8_t bytes = eeprom.detectAddressBytes();
    eeprom.setAddressBytes(bytes);
    return bytes;
}

uint16_t I2cService::eepromDetectPageSize() {
    uint16_t size = eeprom.detectPageSizeBytes();
    eeprom.setPageSizeBytes(size);
    return size;
}

uint8_t I2cService::eepromDetectWriteTime(uint8_t testCount) {
    return eeprom.detectWriteTimeMs(testCount);
}


uint32_t I2cService::eepromLength() {
    return eeprom.length();
}

uint32_t I2cService::eepromGetMemorySize()  {
    return eeprom.getMemorySizeBytes();
}

uint16_t I2cService::eepromPageSize()  {
    return eeprom.getPageSizeBytes();
}

uint8_t I2cService::eepromWriteTimeMs() {
    return eeprom.getWriteTimeMs();
}

uint8_t I2cService::eepromAddressBytes() {
    return eeprom.getAddressBytes();
}

bool I2cService::eepromIsConnected() {
    return eeprom.isConnected();
}

bool I2cService::eepromIsBusy() {
    return eeprom.isBusy();
}

bool I2cService::ping(uint8_t addr, bool sendStop, uint32_t* outDtUs) {
    uint32_t t0 = micros();
    beginTransmission(addr);
    uint8_t r = endTransmission(sendStop);
    uint32_t dt = micros() - t0;

    if (outDtUs) *outDtUs = dt;
    return (r == 0);
}

bool I2cService::readReg(uint8_t addr, uint8_t reg, uint8_t* outVal, uint32_t* outDtUs) {
    uint32_t t0 = micros();
    bool ok = false;

    beginTransmission(addr);
    write(reg);

    if (endTransmission(false) == 0) {
        if (requestFrom(addr, (uint8_t)1, true) == 1 && available()) {
            int v = read();
            if (v >= 0) {
                if (outVal) *outVal = (uint8_t)v;
                ok = true;
            }
        }
    }

    // flush
    while (available()) (void)read();

    uint32_t dt = micros() - t0;
    if (outDtUs) *outDtUs = dt;

    return ok;
}

bool I2cService::probeReadableReg(uint8_t addr, uint8_t reg) {
    beginTransmission(addr);
    write(reg);
    if (endTransmission(false) != 0) return false;

    uint8_t received = requestFrom(addr, (uint8_t)1, true);
    if (received != 1 || !available()) return false;

    (void)read(); // flush 1
    while (available()) (void)read();
    return true;
}