Skip to content

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

15.2 KB
Raw Blame
#include "ArgTransformer.h"
#include <array>

uint8_t ArgTransformer::parseByte(const std::string& str, int index) const {
    std::istringstream ss(str);
    int value = 0;

    if (str.rfind("0x", 0) == 0 || str.rfind("0X", 0) == 0)
        ss >> std::hex >> value;
    else
        ss >> std::dec >> value;

    if (ss.fail() || value < 0 || value > 255) {
        return 0xFF;
    }

    return static_cast<uint8_t>(value);
}

std::vector<uint8_t> ArgTransformer::parseByteList(const std::string& input) const {
    std::istringstream iss(input);
    std::string token;
    std::vector<uint8_t> bytes;

    int index = 0;
    while (iss >> token) {
        uint8_t parsed = parseByte(token, index);
        if (parsed == 0xFF && token != "0xFF" && token != "255") {
            continue; // ignore
        }
        bytes.push_back(parsed);
        index++;
    }

    return bytes;
}

std::vector<uint8_t> ArgTransformer::parseHexList(const std::string& input) const {
    std::vector<uint8_t> result;
    std::istringstream iss(input);
    std::string token;

    while (iss >> token) {
        try {
            // Convertir chaque token en uint8_t
            uint8_t value = static_cast<uint8_t>(std::stoul(token, nullptr, 16));
            result.push_back(value);
        } catch (...) {
        }
    }

    return result;
}

std::vector<uint16_t> ArgTransformer::parseHexList16(const std::string& input) const {
    std::vector<uint16_t> result;

    std::string normalized = input;
    for (char& c : normalized) {
        if (c == ',' || c == ';') c = ' ';
    }

    std::istringstream iss(normalized);
    std::string token;

    while (iss >> token) {
        try {
            size_t pos = 0;
            unsigned long v = std::stoul(token, &pos, 16);
            if (pos != token.size()) continue;
            if (v <= 0xFFFF) result.push_back(static_cast<uint16_t>(v));
        } catch (...) {
            // token invalide
        }
    }

    return result;
}


uint8_t ArgTransformer::parseHexOrDec(const std::string& str) const {
    if (str.empty()) return 0;

    int base = 10;
    const char* cstr = str.c_str();

    // Check Hex format
    if (str.size() > 2 && (str[0] == '0') && (str[1] == 'x' || str[1] == 'X')) {
        base = 16;
        cstr += 2; // prefix 0x
    }

    // Check chars
    for (size_t i = 0; i < strlen(cstr); ++i) {
        char c = cstr[i];
        if (base == 10 && !isdigit(c)) return 0;
        if (base == 16 && !isxdigit(c)) return 0;
    }

    long value = strtol(str.c_str(), nullptr, base);
    if (value < 0 || value > 255) return 0;

    return static_cast<uint8_t>(value);
}

uint16_t ArgTransformer::parseHexOrDec16(const std::string& str) const {
    uint32_t value = parseHexOrDec32(str);
    return static_cast<uint16_t>(value & 0xFFFF);
}

uint32_t ArgTransformer::parseHexOrDec32(const std::string& str) const {
    if (str.empty()) return 0;

    int base = 10;
    const char* cstr = str.c_str();

    // Check Hex format
    if (str.size() > 2 && str[0] == '0' && (str[1] == 'x' || str[1] == 'X')) {
        base = 16;
        cstr += 2;
    }

    // Check chars
    for (size_t i = 0; i < strlen(cstr); ++i) {
        char c = cstr[i];
        if (base == 10 && !isdigit(c)) return 0;
        if (base == 16 && !isxdigit(c)) return 0;
    }

    unsigned long value = strtoul(str.c_str(), nullptr, base);
    return static_cast<uint32_t>(value);
}



std::vector<std::string> ArgTransformer::splitArgs(const std::string& input) {
    std::vector<std::string> result;
    std::istringstream iss(input);
    std::string token;
    while (iss >> token) {
        result.push_back(token);
    }
    return result;
}

bool ArgTransformer::parseInt(const std::string& input, int& output) {
    const char* str = input.c_str();
    char* end = nullptr;
    int base = 10;

    if (input.rfind("0x", 0) == 0 || input.rfind("0X", 0) == 0) {
        base = 16;
        str += 2;
    } else if (!input.empty() && (input.back() == 'h' || input.back() == 'H')) {
        base = 16;
        std::string trimmed = input.substr(0, input.size() - 1);
        str = trimmed.c_str();
    }

    long result = strtol(str, &end, base);
    if (*end != '\0') return false; // invalid characters found

    output = static_cast<int>(result);
    return true;
}

bool ArgTransformer::isValidNumber(const std::string& input) {
    std::string s = input;
    int base = 10;
    if (s.empty()) return false;

    if (s.rfind("0x", 0) == 0 || s.rfind("0X", 0) == 0) {
        base = 16;
        s = s.substr(2);
    }

    for (char c : s) {
        if ((base == 10 && !isdigit(c)) ||
            (base == 16 && !isxdigit(c))) {
            return false;
        }
    }

    return true;
}

bool ArgTransformer::isValidSignedNumber(const std::string& input) {
    if (input.empty()) return false;

    std::string s = input;
    int base = 10;
    size_t start = 0;

    // Optional sign
    if (s[0] == '-' || s[0] == '+') {
        if (s.size() == 1) return false;  // - or + alone is not valid
        start = 1;
    }

    // Check for hex prefix
    if (s.find("0x", start) == start || s.find("0X", start) == start) {
        base = 16;
        start += 2;
    }

    if (start >= s.size()) return false;

    for (size_t i = start; i < s.size(); ++i) {
        char c = s[i];
        if ((base == 10 && !isdigit(c)) || (base == 16 && !isxdigit(c))) {
            return false;
        }
    }

    return true;
}

uint8_t ArgTransformer::toUint8(const std::string& input) {
    return static_cast<uint8_t>(std::stoi(input));
}

int8_t ArgTransformer::toClampedInt8(const std::string& input) {
    int value = std::stoi(input);
    if (value < -127) value = -127;
    if (value > 127) value = 127;
    return static_cast<int8_t>(value);
}

uint32_t ArgTransformer::toUint32(const std::string& input) {
    return static_cast<uint32_t>(std::stoul(input));
}

std::string ArgTransformer::toLower(const std::string& input) {
    std::string result = input;
    std::transform(
        result.begin(), result.end(), result.begin(),
        [](unsigned char c) { return std::tolower(c); }
    );
    return result;
}

std::string ArgTransformer::filterPrintable(const std::string& input) {
    std::string result;
    for (char c : input) {
        if (std::isprint(static_cast<unsigned char>(c)) || c == '\n' || c == '\r' || c == '\t') {
            result += c;
        }
    }
    return result;
}

std::string ArgTransformer::decodeEscapes(const std::string& input) {
    std::ostringstream out;
    for (size_t i = 0; i < input.length(); ++i) {
        if (input[i] == '\\' && i + 1 < input.length()) {
            char next = input[++i];
            switch (next) {
                case 'n': out << '\n'; break;
                case 'r': out << '\r'; break;
                case 't': out << '\t'; break;
                case '0': out << '\0'; break;
                case '\\': out << '\\'; break;
                case 'x':
                    if (i + 2 < input.length()) {
                        std::string hex = input.substr(i + 1, 2);
                        try {
                            out << static_cast<char>(std::stoi(hex, nullptr, 16));
                        } catch (...) {
                            out << "\\x" << hex; // Invalid
                        }
                        i += 2;
                    } else {
                        out << "\\x"; // Incomplete
                    }
                    break;
                default:
                    out << '\\' << next; // Unrecognized,
                    break;
            }
        } else {
            out << input[i];
        }
    }
    return out.str();
}

std::string ArgTransformer::toHex(uint32_t value, int width) {
    std::stringstream ss;
    ss << std::hex << std::uppercase << std::setfill('0') << std::setw(width) << value;
    return ss.str();
}

std::string ArgTransformer::formatFloat(double value, int decimals) {
    char buf[32];
    snprintf(buf, sizeof(buf), ("%." + std::to_string(decimals) + "f").c_str(), value);
    return std::string(buf);
}

std::string ArgTransformer::toAsciiLine(uint32_t address, const std::vector<uint8_t>& line) {
    std::stringstream ss;

    // Address
    ss << std::hex << std::uppercase << std::setfill('0')
       << std::setw(6) << address << ": ";

    // Hex
    for (size_t i = 0; i < 16; ++i) {
        if (i < line.size()) {
            ss << std::setw(2) << (int)line[i] << " ";
        } else {
            ss << "   ";
        }
    }

    // ASCII
    ss << " ";
    for (size_t i = 0; i < line.size(); ++i) {
        char c = static_cast<char>(line[i]);
        ss << (isprint(c) ? c : '.');
    }

    return ss.str();
}

std::string ArgTransformer::toAsciiLine(uint32_t startAddr, const std::vector<uint16_t>& words) {
    std::stringstream line;

    // Adress
    line << std::hex << std::uppercase << std::setfill('0')
         << std::setw(6) << startAddr << ": ";

    // HEX : 8 x 16-bit (4 hex digits)
    for (size_t i = 0; i < words.size(); ++i) {
        line << std::setw(4) << words[i] << " ";
    }

    // Padding
    for (size_t i = words.size(); i < 8; ++i) {
        line << "     ";
    }

    // ASCII
    line << " ";
    for (uint16_t word : words) {
        char high = (word >> 8) & 0xFF;
        char low  = word & 0xFF;

        line << (isprint(high) ? high : '.');
        line << (isprint(low)  ? low  : '.');
    }

    return line.str();
}

std::string ArgTransformer::toBinString(uint32_t value) {
    std::string bin;
    bin.reserve(32 + 3);

    // find most significant non-zero byte
    int msbByte = 3; // 4 bytes for uint32_t
    for (; msbByte > 0; --msbByte) {
        if (((value >> (msbByte * 8)) & 0xFF) != 0) break;
    }

    // display from msbByte down to byte 0
    for (int b = msbByte; b >= 0; --b) {
        uint8_t byte = (value >> (b * 8)) & 0xFF;

        for (int i = 7; i >= 0; --i) {
            bin += ((byte >> i) & 1U) ? '1' : '0';
        }

        if (b != 0) bin += ' ';
    }

    return bin;
}

std::string ArgTransformer::toAsciiString(uint32_t value) {
    std::string ascii;
    bool hasLetter = false;

    // find most significant non-zero byte
    int msbByte = 3;
    for (; msbByte > 0; --msbByte) {
        if (((value >> (msbByte * 8)) & 0xFF) != 0) break;
    }

    // build ASCII view
    for (int b = msbByte; b >= 0; --b) {
        uint8_t byte = (value >> (b * 8)) & 0xFF;

        if ((byte >= 'A' && byte <= 'Z') ||
            (byte >= 'a' && byte <= 'z')) {
            hasLetter = true;
            ascii += static_cast<char>(byte);
        }
        else if (byte >= 0x20 && byte <= 0x7E) {
            ascii += static_cast<char>(byte);
        }
        else {
            ascii += '.';
        }
    }

    // Only show ASCII if there is at least one letter
    if (!hasLetter) {
        return "";
    }

    return ascii;
}

bool ArgTransformer::parseMac(const std::string& s, std::array<uint8_t,6>& out) {
    // Accept "AA:BB:CC:DD:EE:FF" or "AABBCCDDEEFF"
    std::string hex;
    hex.reserve(12);
    for (char c : s) {
        if (c == ':' || c == '-') continue;
        if (!isxdigit((unsigned char)c)) return false;
        hex.push_back(c);
    }
    if (hex.size() != 12) return false;

    auto hexVal = [](char c)->uint8_t {
        if (c >= '0' && c <= '9') return (uint8_t)(c - '0');
        if (c >= 'a' && c <= 'f') return (uint8_t)(10 + c - 'a');
        if (c >= 'A' && c <= 'F') return (uint8_t)(10 + c - 'A');
        return 0xFF;
    };

    for (int i=0; i<6; ++i) {
        uint8_t hi = hexVal(hex[2*i]);
        uint8_t lo = hexVal(hex[2*i+1]);
        if (hi == 0xFF || lo == 0xFF) return false;
        out[i] = (uint8_t)((hi<<4) | lo);
    }
    return true;
}

std::string ArgTransformer::ensureHttpScheme(std::string u) {
    if (u.rfind("http://", 0) != 0 && u.rfind("https://", 0) != 0) {
        u = "https://" + u;   // defaut https
    }
    return u;
}

std::string ArgTransformer::normalizeLines(const std::string& in) {
    std::string out;
    out.reserve(in.size() * 2);
    for (size_t i = 0; i < in.size(); i++) {
        if (in[i] == '\n') {
            out += "\r\n";
        } else {
            out += in[i];
        }
    }
    return out;
}

std::string ArgTransformer::extractHostFromUrl(const std::string& url) {
    size_t s = url.find("://");
    std::string host = (s == std::string::npos) ? url : url.substr(s + 3);
    size_t slash = host.find('/');
    if (slash != std::string::npos) host.erase(slash);
    return host;
}

std::vector<uint8_t> ArgTransformer::parse01List(const std::string& line) {
  std::vector<uint8_t> bits;
  auto toks = splitArgs(line);
  if (toks.size() > 1) {
    for (auto& t : toks) {
      if (t == "0" || t == "1") bits.push_back(t == "1" ? 1 : 0);
      else return {};
    }
  } else {
    for (char c : line) {
      if (c=='0' || c=='1') bits.push_back(c=='1' ? 1 : 0);
    }
  }
  return bits;
}

std::vector<uint8_t> ArgTransformer::packLsbFirst(const std::vector<uint8_t>& bits) {
    std::vector<uint8_t> out((bits.size() + 7) / 8, 0);
    for (size_t i = 0; i < bits.size(); ++i) {
        if (bits[i] & 1) out[i / 8] |= (1u << (i % 8));
    }
    return out;
}

bool ArgTransformer::unpackLsbFirst(const std::vector<uint8_t>& bytes,
                                    size_t qty,
                                    std::vector<uint8_t>& outBits) {
    const size_t need = (qty + 7) / 8;
    if (bytes.size() < need) return false;    // too short
    outBits.resize(qty);
    for (size_t i = 0; i < qty; ++i) {
        outBits[i] = (bytes[i / 8] >> (i % 8)) & 0x1;
    }
    return true;
}

std::string ArgTransformer::toFixed2(float f) {
    std::ostringstream oss; oss.setf(std::ios::fixed); oss.precision(2); oss << f;
    return oss.str();
}

bool ArgTransformer::parsePattern(const std::string& patternRaw,
                                             std::string& outTextPattern,
                                             std::vector<uint8_t>& outHexPattern,
                                             std::vector<uint8_t>& outHexMask,
                                             bool& outIsHex) 
{
    outTextPattern.clear();
    outHexPattern.clear();
    outHexMask.clear();
    outIsHex = false;

    if (patternRaw.empty()) return false;

    // hex{ ... }
    if (patternRaw.size() >= 5 && patternRaw.rfind("hex{", 0) == 0 && patternRaw.back() == '}') {
        outIsHex = true;

        std::string inner = patternRaw.substr(4, patternRaw.size() - 5);
        auto toks = splitArgs(inner);
        if (toks.empty()) return false;

        for (auto tok : toks) {
            tok = toLower(tok);

            if (tok == "??") {
                outHexPattern.push_back(0x00);
                outHexMask.push_back(0);
                continue;
            }

            if (tok.rfind("0x", 0) == 0) tok = tok.substr(2);
            if (tok.size() != 2) return false;

            auto isHexDigit = [](char c) {
                return (c >= '0' && c <= '9') ||
                       (c >= 'a' && c <= 'f') ||
                       (c >= 'A' && c <= 'F');
            };
            if (!isHexDigit(tok[0]) || !isHexDigit(tok[1])) return false;

            uint8_t b = parseHexOrDec("0x" + tok);
            outHexPattern.push_back(b);
            outHexMask.push_back(1);
        }

        return !outHexPattern.empty();
    }

    // text
    outIsHex = false;
    outTextPattern = decodeEscapes(patternRaw);
    return !outTextPattern.empty();
}