CrackNuts 0.0.1.dev2__py3-none-any.whl

cracknuts/cracker/protocol.py

@@ -0,0 +1,83 @@
+import struct
+
+__version__ = "1.0.0"
+
+DEFAULT_PORT = 9761
+
+MAGIC_STR = b"AHCC"
+
+# ┌───────────────────────────────────────────┬───────┐
+# │--------------Request Header---------------│-------│
+# │Magic │Version│Direction│Command│RFU│Length│PayLoad│
+# │-------------------------------------------│-------│
+# │ 4B   │  2B   │   1B    │   2B  │2B │  4B  │$Length│
+# │-------------------------------------------│-------│
+# │'AHCC'│   1   │   'S'   │       │   │      │       │
+# └───────────────────────────────────────────┴───────┘
+
+REQ_HEADER_FORMAT = ">4sH1sHHI"
+REQ_HEADER_SIZE = struct.calcsize(REQ_HEADER_FORMAT)
+
+# ┌──────────────────────────────────────┬───────┐
+# │--------------Response Header---------│-------│
+# │Magic │Version│Direction│Status│Length│PayLoad│
+# │--------------------------------------│-------│
+# │ 4B   │  2B   │   1B    │  2B  │  4B  │$Length│
+# │--------------------------------------│-------│
+# │'AHCC'│   1   │   'R'   │      │      │       │
+# └──────────────────────────────────────┴───────┘
+
+RES_HEADER_FORMAT = ">4sH1sHI"
+RES_HEADER_SIZE = struct.calcsize(RES_HEADER_FORMAT)
+
+DIRECTION_SEND = b"S"
+DIRECTION_RESPONSE = b"R"
+
+# Status Code
+STATUS_OK = 0x0000
+STATUS_BUSY = 0x0001
+STATUS_ERROR = 0x8000
+STATUS_UNSUPPORTED = 0x8001
+
+
+def version():
+    return __version__
+
+
+def _build_req_message(command: int, rfu: int = 0, payload: bytes = None):
+    content = struct.pack(
+        REQ_HEADER_FORMAT,
+        MAGIC_STR,
+        int(__version__.split(".")[0]),
+        DIRECTION_SEND,
+        command,
+        rfu,
+        0 if payload is None else len(payload),
+    )
+    if payload is not None:
+        content += payload
+
+    return content
+
+
+def _build_res_message(status: int, payload: bytes = None):
+    content = struct.pack(
+        RES_HEADER_FORMAT,
+        MAGIC_STR,
+        int(__version__.split(".")[0]),
+        DIRECTION_RESPONSE,
+        status,
+        0 if payload is None else len(payload),
+    )
+    if payload is not None:
+        content += payload
+
+    return content
+
+
+def build_send_message(command: int, rfu: int = 0, payload: bytes = None):
+    return _build_req_message(command, rfu, payload)
+
+
+def build_response_message(status: int, payload: bytes = None):
+    return _build_res_message(status, payload)

cracknuts/cracker/stateful_cracker.py

@@ -0,0 +1,214 @@
+import typing
+
+import numpy as np
+
+from cracknuts.cracker.cracker import Cracker, Config
+
+
+class StatefulCracker(Cracker):
+    def __init__(self, cracker: Cracker):
+        self._cracker = cracker
+        self._config: Config = self._cracker.get_default_config()
+
+    def get_current_config(self) -> Config:
+        return self._config
+
+    def sync_config_to_cracker(self):
+        """
+        Sync config to cracker.
+        To prevent configuration inconsistencies between the host and the device,
+        so all configuration information needs to be written to the device.
+        User should call this function before get data from device.
+        """
+        # if self._config.nut_voltage is not None:
+        #     self._cracker.nut_voltage(self._config.nut_voltage)
+        # if self._config.nut_clock is not None:
+        #     self._cracker.nut_clock(self._config.nut_clock)
+        # if self._config.nut_enable is not None:
+        #     self._cracker.nut_enable(self._config.nut_enable)
+        # if self._config.osc_analog_channel_enable is not None:
+        #     self._cracker.osc_set_analog_channel_enable(self._config.osc_analog_channel_enable)
+        ...  # comment for test.
+        # todo need complete...
+
+    def set_addr(self, ip, port) -> None:
+        return self._cracker.set_addr(ip, port)
+
+    def set_uri(self, uri: str) -> None:
+        return self._cracker.set_uri(uri)
+
+    def get_uri(self):
+        return self._cracker.get_uri()
+
+    def connect(self):
+        return self._cracker.connect()
+
+    def disconnect(self):
+        return self._cracker.disconnect()
+
+    def reconnect(self):
+        return self._cracker.reconnect()
+
+    def get_connection_status(self) -> bool:
+        return self._cracker.get_connection_status()
+
+    def send_and_receive(self, message) -> tuple[int, bytes]:
+        return self._cracker.send_and_receive(message)
+
+    def send_with_command(self, command: int, rfu: int = 0, payload: str | bytes = None) -> tuple[int, bytes | None]:
+        return self._cracker.send_with_command(command, rfu, payload)
+
+    def echo(self, payload: str) -> str:
+        return self._cracker.echo(payload)
+
+    def echo_hex(self, payload: str) -> str:
+        return self._cracker.echo_hex(payload)
+
+    def get_id(self) -> str:
+        return self._cracker.get_id()
+
+    def get_name(self) -> str:
+        return self._cracker.get_name()
+
+    def get_version(self) -> str:
+        return self._cracker.get_version()
+
+    def osc_set_analog_channel_enable(self, enable: dict[int, bool]):
+        self._config.osc_analog_channel_enable = enable
+        return self._cracker.osc_set_analog_channel_enable(enable)
+
+    def osc_set_analog_coupling(self, coupling: dict[int, int]):
+        return self._cracker.osc_set_analog_coupling(coupling)
+
+    def osc_set_analog_voltage(self, channel: int, voltage: int):
+        return self._cracker.osc_set_analog_voltage(channel, voltage)
+
+    def osc_set_analog_bias_voltage(self, channel: int, voltage: int):
+        return self._cracker.osc_set_analog_bias_voltage(channel, voltage)
+
+    def osc_set_digital_channel_enable(self, enable: dict[int, bool]):
+        return self._cracker.osc_set_digital_channel_enable(enable)
+
+    def osc_set_digital_voltage(self, voltage: int):
+        return self._cracker.osc_set_digital_voltage(voltage)
+
+    def osc_set_trigger_mode(self, source: int, stop: int):
+        return self._cracker.osc_set_trigger_mode(source, stop)
+
+    def osc_set_analog_trigger_source(self, channel: int):
+        return self._cracker.osc_set_analog_trigger_source(channel)
+
+    def osc_set_digital_trigger_source(self, channel: int):
+        return self._cracker.osc_set_digital_trigger_source(channel)
+
+    def osc_set_analog_trigger_voltage(self, voltage: int):
+        return self._cracker.osc_set_analog_trigger_voltage(voltage)
+
+    def osc_set_sample_delay(self, delay: int):
+        return self._cracker.osc_set_sample_delay(delay)
+
+    def osc_set_sample_len(self, length: int):
+        self._config.osc_sample_len = length
+        return self._cracker.osc_set_sample_len(length)
+
+    def get_default_config(self) -> typing.Optional["Config"]:
+        return self._cracker.get_default_config()
+
+    def osc_force(self):
+        return self._cracker.osc_force()
+
+    def osc_set_sample_clock(self, clock: int):
+        return self._cracker.osc_set_sample_clock(clock)
+
+    def osc_set_sample_phase(self, phase: int):
+        return self._cracker.osc_set_sample_phase(phase)
+
+    def osc_single(self):
+        return self._cracker.osc_single()
+
+    def osc_is_triggered(self):
+        return self._cracker.osc_is_triggered()
+
+    def osc_get_analog_wave(self, channel: int, offset: int, sample_count: int) -> tuple[int, np.ndarray]:
+        return self._cracker.osc_get_analog_wave(channel, offset, sample_count)
+
+    def osc_get_digital_wave(self, channel: int, offset: int, sample_count: int):
+        return self._cracker.osc_get_digital_wave(channel, offset, sample_count)
+
+    def osc_set_analog_gain(self, channel: int, gain: int):
+        return self._cracker.osc_set_analog_gain(channel, gain)
+
+    def nut_enable(self, enable: int):
+        self._config.cracker_nut_enable = enable
+        return self._cracker.nut_enable(enable)
+
+    def nut_voltage(self, voltage: int):
+        self._config.cracker_nut_voltage = voltage
+        return self._cracker.nut_voltage(voltage)
+
+    def osc_set_analog_gain_raw(self, channel: int, gain: int):
+        return self._cracker.osc_set_analog_gain_raw(channel, gain)
+
+    def nut_voltage_raw(self, voltage: int):
+        return self._cracker.nut_voltage_raw(voltage)
+
+    def nut_clock(self, clock: int):
+        self._config.cracker_nut_clock = clock
+        return self._cracker.nut_clock(clock)
+
+    def nut_interface(self, interface: dict[int, bool]):
+        return self._cracker.nut_interface(interface)
+
+    def nut_timeout(self, timeout: int):
+        return self._cracker.nut_timeout(timeout)
+
+    def cracker_serial_baud(self, baud: int):
+        return self._cracker.cracker_serial_baud(baud)
+
+    def cracker_serial_width(self, width: int):
+        return self._cracker.cracker_serial_width(width)
+
+    def cracker_serial_stop(self, stop: int):
+        return self._cracker.cracker_serial_stop(stop)
+
+    def cracker_serial_odd_eve(self, odd_eve: int):
+        return self._cracker.cracker_serial_odd_eve(odd_eve)
+
+    def cracker_serial_data(self, expect_len: int, data: bytes):
+        return self._cracker.cracker_serial_data(expect_len, data)
+
+    def cracker_spi_cpol(self, cpol: int):
+        return self._cracker.cracker_spi_cpol(cpol)
+
+    def cracker_spi_cpha(self, cpha: int):
+        return self._cracker.cracker_spi_cpha(cpha)
+
+    def cracker_spi_data_len(self, cpha: int):
+        return self._cracker.cracker_spi_data_len(cpha)
+
+    def cracker_spi_freq(self, freq: int):
+        return self._cracker.cracker_spi_freq(freq)
+
+    def cracker_spi_timeout(self, timeout: int):
+        return self._cracker.cracker_spi_timeout(timeout)
+
+    def cracker_spi_data(self, expect_len: int, data: bytes):
+        return self._cracker.cracker_spi_data(expect_len, data)
+
+    def cracker_i2c_freq(self, freq: int):
+        return self._cracker.cracker_i2c_freq(freq)
+
+    def cracker_i2c_timeout(self, timeout: int):
+        return self._cracker.cracker_i2c_timeout(timeout)
+
+    def cracker_i2c_data(self, expect_len: int, data: bytes):
+        return self._cracker.cracker_i2c_data(expect_len, data)
+
+    def cracker_can_freq(self, freq: int):
+        return self._cracker.cracker_can_freq(freq)
+
+    def cracker_can_timeout(self, timeout: int):
+        return self._cracker.cracker_can_timeout(timeout)
+
+    def cracker_can_data(self, expect_len: int, data: bytes):
+        return self._cracker.cracker_can_data(expect_len, data)

cracknuts/logger.py

@@ -0,0 +1,88 @@
+import logging
+from types import ModuleType
+
+
+_LOG_LEVEL = logging.WARNING
+_LOG_FORMATTER = logging.Formatter("[%(levelname)s] %(asctime)s %(module)s.%(funcName)s:%(lineno)d %(message)s")
+_LOGGERS: dict[str, logging.Logger] = {}
+
+
+def set_level(
+    level: str | int = logging.WARNING,
+    logger: str | type | ModuleType | object | None = None,
+) -> None:
+    global _LOG_LEVEL
+    if isinstance(level, str):
+        level = level.upper()
+        if level == "DEBUG":
+            _LOG_LEVEL = logging.DEBUG
+        elif level == "INFO":
+            _LOG_LEVEL = logging.INFO
+        elif level == "WARN":
+            _LOG_LEVEL = logging.WARNING
+        elif level == "ERROR":
+            _LOG_LEVEL = logging.ERROR
+        elif level == "CRITICAL":
+            _LOG_LEVEL = logging.CRITICAL
+        else:
+            raise ValueError(f"Unrecognized log level {level}.")
+    elif level not in [
+        logging.DEBUG,
+        logging.INFO,
+        logging.WARNING,
+        logging.ERROR,
+        logging.CRITICAL,
+    ]:
+        raise ValueError(f"Unrecognized log level {level}.")
+    else:
+        _LOG_LEVEL = level
+
+    _logger = None
+
+    if logger:
+        if isinstance(logger, ModuleType):
+            logger = logger.__name__
+        elif isinstance(logger, type):
+            logger = logger.__module__ + "." + logger.__name__
+        elif isinstance(logger, str):
+            logger = logger
+        else:
+            logger = logger.__class__.__module__ + "." + logger.__class__.__name__
+
+        _logger = _LOGGERS.get(logger)
+
+    if not _logger:
+        for _logger in _LOGGERS.values():
+            _logger.setLevel(_LOG_LEVEL)
+    else:
+        _logger.setLevel(_LOG_LEVEL)
+
+
+def get_logger(name: str | type | object | ModuleType, level: int | None = None) -> logging.Logger:
+    if isinstance(name, ModuleType):
+        name = name.__name__
+    elif isinstance(name, type):
+        name = name.__module__ + "." + name.__name__
+    elif isinstance(name, str):
+        name = name
+    else:
+        name = name.__class__.__module__ + "." + name.__class__.__name__
+
+    if name in _LOGGERS:
+        return _LOGGERS[name]
+
+    logger = logging.getLogger(name)
+    if level is None:
+        logger.setLevel(_LOG_LEVEL)
+    else:
+        logger.setLevel(level)
+    stream_handler = logging.StreamHandler()
+    stream_handler.setFormatter(_LOG_FORMATTER)
+    logger.addHandler(stream_handler)
+    _LOGGERS[name] = logger
+    logger.propagate = False
+    return logger
+
+
+def default_logger() -> logging.Logger:
+    return get_logger("cracknuts")