CrackNuts 0.0.1.dev2__py3-none-any.whl

cracknuts/solver/trace.py

@@ -0,0 +1,524 @@
+import abc
+import json
+import os.path
+import time
+import typing
+
+import numpy as np
+import zarr
+
+from cracknuts import logger
+
+
+class TraceDatasetData:
+    def __init__(self, level: int = 0, index: tuple = None, get_trace_data: typing.Callable[[any, any], tuple] = None):
+        self._level: int = level
+        self._index: tuple = index
+        self._get_trace_data = get_trace_data
+
+    def __getitem__(self, index):
+        if not isinstance(index, tuple):
+            index = (index,)
+
+        level = len(index) + self._level
+        index = index if self._index is None else (*self._index, *index)
+        if level < 2:
+            return TraceDatasetData(level, index, self._get_trace_data)
+        else:
+            return self._get_trace_data(*index)
+
+
+class TraceDataset(abc.ABC):
+    _channel_count: int
+    _trace_count: int
+    _sample_count: int
+    _data_length: int
+    _create_time: int
+    _version: str
+
+    @abc.abstractmethod
+    def get_origin_data(self): ...
+
+    @classmethod
+    @abc.abstractmethod
+    def load(cls, path: str, **kwargs) -> "TraceDataset": ...
+
+    @classmethod
+    @abc.abstractmethod
+    def new(
+        cls, path: str, channel_count: int, trace_count: int, sample_count: int, data_length: int, version, **kwargs
+    ) -> "TraceDataset": ...
+
+    @abc.abstractmethod
+    def dump(self, path: str = None, **kwargs): ...
+
+    @abc.abstractmethod
+    def set_trace(self, channel_index: int, trace_index: int, trace: np.ndarray, data: np.ndarray | None): ...
+
+    @property
+    def data(self) -> TraceDatasetData:
+        return TraceDatasetData(get_trace_data=self._get_trace_data)
+
+    @abc.abstractmethod
+    def _get_trace_data(self, channel_slice, trace_slice) -> tuple[list, list, np.ndarray, np.ndarray]: ...
+
+    def _parse_slice(self, channel_slice, trace_slice) -> tuple[list, list]:
+        if isinstance(channel_slice, slice):
+            start, stop, step = channel_slice.indices(self._channel_count)
+            channel_indexes = [i for i in range(start, stop, step)]
+        elif isinstance(channel_slice, int):
+            channel_indexes = [channel_slice]
+        elif isinstance(channel_slice, list):
+            channel_indexes = channel_slice
+        else:
+            channel_indexes = None
+
+        if isinstance(trace_slice, slice):
+            start, stop, step = trace_slice.indices(self._trace_count)
+            trace_indexes = [i for i in range(start, stop, step)]
+        elif isinstance(trace_slice, int):
+            trace_indexes = [trace_slice]
+        elif isinstance(trace_slice, list):
+            trace_indexes = trace_slice
+        else:
+            trace_indexes = None
+
+        return channel_indexes, trace_indexes
+
+    @property
+    def channel_count(self):
+        return self._channel_count
+
+    @property
+    def trace_count(self):
+        return self._trace_count
+
+    @property
+    def sample_count(self):
+        return self._sample_count
+
+    @property
+    def data_length(self):
+        return self._data_length
+
+    @property
+    def create_time(self):
+        return self._create_time
+
+
+class ScarrTraceDataset(TraceDataset):
+    _ATTR_METADATA_KEY = "metadata"
+    _GROUP_ROOT_PATH = "0"
+    _ARRAY_TRACES_PATH = "traces"
+    _ARRAY_DATA_PATH = "plaintext"
+
+    def __init__(
+        self,
+        zarr_path: str,
+        create_empty: bool = False,
+        channel_count: int = None,
+        trace_count: int = None,
+        sample_count: int = None,
+        data_length: int = None,
+        zarr_kwargs: dict = None,
+        zarr_trace_group_kwargs: dict = None,
+        zarr_data_group_kwargs: dict = None,
+        create_time: int = None,
+        version: str = None,
+    ):
+        if create_empty:
+            if channel_count is None or trace_count is None or sample_count is None or data_length is None:
+                raise ValueError(
+                    "channel_count and trace_count and sample_count and data_length "
+                    "must be specified when in write mode."
+                )
+        else:
+            if zarr_path is None:
+                raise ValueError("The zarr_path must be specified when in non-write mode.")
+
+        self._zarr_path: str = zarr_path
+        self._channel_count: int = channel_count
+        self._trace_count: int = trace_count
+        self._sample_count: int = sample_count
+        self._data_length: int = data_length
+        self._create_time: int = create_time
+        self._version: str = version
+
+        if zarr_kwargs is None:
+            zarr_kwargs = {}
+        if zarr_trace_group_kwargs is None:
+            zarr_trace_group_kwargs = {}
+        if zarr_data_group_kwargs is None:
+            zarr_data_group_kwargs = {}
+
+        mode = zarr_kwargs.pop("mode", "w" if create_empty else "r")
+        self._zarr_data = zarr.open(zarr_path, mode=mode, **zarr_kwargs)
+
+        if create_empty:
+            self._create_time = int(time.time())
+            group_root = self._zarr_data.create_group(self._GROUP_ROOT_PATH)
+            for i in range(self._channel_count):
+                channel_group = group_root.create_group(str(i))
+                channel_group.create(
+                    self._ARRAY_TRACES_PATH,
+                    shape=(self._trace_count, self._sample_count),
+                    dtype=np.int16,
+                    **zarr_trace_group_kwargs,
+                )
+                channel_group.create(
+                    self._ARRAY_DATA_PATH,
+                    shape=(self._trace_count, self._data_length),
+                    dtype=np.uint8,
+                    **zarr_data_group_kwargs,
+                )
+            self._zarr_data.attrs[self._ATTR_METADATA_KEY] = {
+                "create_time": self._create_time,
+                "channel_count": self._channel_count,
+                "trace_count": self._trace_count,
+                "sample_count": self._sample_count,
+                "data_length": self._data_length,
+                "version": self._version,
+            }
+        else:
+            metadata = self._zarr_data.attrs[self._ATTR_METADATA_KEY]
+            self._create_time = metadata.get("create_time")
+            self._channel_count = metadata.get("channel_count")
+            self._trace_count = metadata.get("trace_count")
+            self._sample_count = metadata.get("sample_count")
+            self._data_length = metadata.get("data_length")
+            self._version = metadata.get("version")
+
+    @classmethod
+    def load(cls, path: str, **kwargs) -> "TraceDataset":
+        kwargs["mode"] = "r"
+        return cls(path, zarr_kwargs=kwargs)
+
+    @classmethod
+    def new(
+        cls,
+        path: str,
+        channel_count: int,
+        trace_count: int,
+        sample_count: int,
+        data_length: int,
+        version: str,
+        **kwargs,
+    ) -> "TraceDataset":
+        kwargs["mode"] = "w"
+        return cls(
+            path,
+            create_empty=True,
+            channel_count=channel_count,
+            trace_count=trace_count,
+            sample_count=sample_count,
+            data_length=data_length,
+            version=version,
+            zarr_kwargs=kwargs,
+        )
+
+    def dump(self, path: str = None, **kwargs):
+        if path is not None and path != self._zarr_path:
+            zarr.copy_store(self._zarr_data, zarr.open(path, mode="w"))
+
+    def set_trace(self, channel_index: int, trace_index: int, trace: np.ndarray, data: np.ndarray | None):
+        if channel_index not in range(0, self._channel_count):
+            raise ValueError("channel index out range")
+        if trace_index not in range(0, self._trace_count):
+            raise ValueError("trace, index out of range")
+        self._get_under_root(channel_index, self._ARRAY_TRACES_PATH)[trace_index] = trace
+        self._get_under_root(channel_index, self._ARRAY_DATA_PATH)[trace_index] = data
+
+    def get_origin_data(self):
+        return self._zarr_data
+
+    def get_trace_by_indexes(self, channel_index: int, *trace_indexes: int) -> tuple[np.ndarray, np.ndarray] | None:
+        return (
+            self._get_under_root(channel_index, self._ARRAY_TRACES_PATH)[[i for i in trace_indexes]],
+            self._get_under_root(channel_index, self._ARRAY_DATA_PATH)[[i for i in trace_indexes]],
+        )
+
+    def get_trace_by_range(
+        self, channel_index: int, index_start: int, index_end: int
+    ) -> tuple[np.ndarray, np.ndarray] | None:
+        return (
+            self._get_under_root(channel_index, self._ARRAY_TRACES_PATH)[index_start:index_end],
+            self._get_under_root(channel_index, self._ARRAY_DATA_PATH)[index_start:index_end],
+        )
+
+    def _get_under_root(self, *paths: any):
+        paths = self._GROUP_ROOT_PATH, *paths
+        return self._zarr_data["/".join(str(path) for path in paths)]
+
+    def _get_trace_data(self, channel_slice, trace_slice) -> tuple[list, list, np.ndarray, np.ndarray]:
+        traces = []
+        data = []
+
+        channel_indexes, trace_indexes = self._parse_slice(channel_slice, trace_slice)
+
+        if isinstance(trace_slice, int):
+            trace_slice = slice(trace_slice, trace_slice + 1)
+
+        for channel_index in channel_indexes:
+            traces.append(self._get_under_root(channel_index, self._ARRAY_TRACES_PATH)[trace_slice])
+            data.append(self._get_under_root(channel_index, self._ARRAY_DATA_PATH)[trace_slice])
+
+        return channel_indexes, trace_indexes, np.array(traces), np.array(data)
+
+
+class NumpyTraceDataset(TraceDataset):
+    _ARRAY_TRACE_PATH = "trace.npy"
+    _ARRAY_DATA_PATH = "data.npy"
+    _METADATA_PATH = "metadata.json"
+
+    def __init__(
+        self,
+        npy_trace_path: str = None,
+        npy_data_path: str = None,
+        npy_metadata_path: str = None,
+        create_empty: bool = False,
+        channel_count: int = None,
+        trace_count: int = None,
+        sample_count: int = None,
+        data_length: int = None,
+        create_time: int = None,
+        version: str = None,
+    ):
+        self._logger = logger.get_logger(NumpyTraceDataset)
+
+        if create_empty:
+            if channel_count is None or trace_count is None or sample_count is None or data_length is None:
+                raise ValueError(
+                    "channel_count and trace_count and sample_count and data_length "
+                    "must be specified when in write mode."
+                )
+        else:
+            if npy_trace_path is None:
+                raise ValueError("The npy_trace_path must be specified when in non-write mode.")
+            elif npy_data_path is None or npy_metadata_path is None:
+                self._logger.warning(
+                    "npy_data_path or npy_metadata_path is not specified, data or metadata info will be not load."
+                )
+
+        self._npy_trace_path: str = npy_trace_path
+        self._npy_data_path: str = npy_data_path
+        self._npy_metadata_path: str = npy_metadata_path
+
+        self._channel_count: int = channel_count
+        self._trace_count: int = trace_count
+        self._sample_count: int = sample_count
+        self._data_length: int = data_length
+        self._create_time: int = create_time
+        self._version: str = version
+
+        if create_empty:
+            self._trace_array: np.ndarray = np.zeros(
+                shape=(self._channel_count, self._trace_count, self._sample_count), dtype=np.int16
+            )
+            self._data_array: np.ndarray = np.zeros(
+                shape=(self._channel_count, self._trace_count, self._data_length), dtype=np.uint8
+            )
+            self._create_time = int(time.time())
+
+        else:
+            self._data_array: np.ndarray = np.load(self._npy_data_path)
+            self._trace_array: np.ndarray = np.load(self._npy_trace_path)
+            self._load_metadata()
+
+    def _load_metadata(self):
+        with open(self._npy_metadata_path) as f:
+            metadata = json.load(f)
+            self._channel_count: int = metadata.get("channel_count")
+            self._trace_count: int = metadata.get("trace_count")
+            self._sample_count: int = metadata.get("sample_count")
+            self._data_length: int = metadata.get("data_length")
+            self._create_time: int = metadata.get("create_time")
+            self._version: str = metadata.get("version")
+
+    def _dump_metadata(self):
+        with open(self._npy_metadata_path, "w") as f:
+            json.dump(
+                {
+                    "channel_count": self._channel_count,
+                    "trace_count": self._trace_count,
+                    "sample_count": self._sample_count,
+                    "data_length": self._data_length,
+                    "create_time": self._create_time,
+                    "version": self._version,
+                },
+                f,
+            )
+
+    def get_origin_data(self):
+        return self._trace_array, self._data_array
+
+    @classmethod
+    def load(cls, path: str, **kwargs) -> "TraceDataset":
+        return cls(
+            os.path.join(path, cls._ARRAY_TRACE_PATH),
+            os.path.join(path, cls._ARRAY_DATA_PATH),
+            os.path.join(path, cls._METADATA_PATH),
+            **kwargs,
+        )
+
+    @classmethod
+    def load_from_numpy_array(cls, trace: np.ndarray, data: np.ndarray = None):
+        channel_count = None
+        trace_count = None
+        sample_count = None
+        data_length = None
+
+        shape = trace.shape
+
+        if data is not None and not shape == data.shape:
+            raise ValueError("trace and data must have the same shape.")
+
+        array_size = len(shape)
+
+        if array_size == 1:
+            channel_count = 1
+            trace_count = 1
+            sample_count = shape[0]
+            data_length = data.shape[0] if data is not None else 0
+        elif array_size == 2:
+            channel_count = 1
+            trace_count = shape[0]
+            sample_count = shape[1]
+            data_length = data.shape[1] if data is not None else 0
+        elif array_size == 3:
+            channel_count = shape[0]
+            trace_count = shape[1]
+            sample_count = shape[2]
+            data_length = data.shape[2] if data is not None else 0
+
+        ds = cls(
+            create_empty=True,
+            channel_count=channel_count,
+            trace_count=trace_count,
+            sample_count=sample_count,
+            data_length=data_length,
+        )
+
+        if array_size == 1:
+            ds.set_trace(0, 0, trace, data)
+        elif array_size == 2:
+            for t in range(shape[0]):
+                ds.set_trace(0, t, trace[t], data[t] if data is not None else None)
+        elif array_size == 3:
+            for c in range(shape[0]):
+                for t in range(shape[1]):
+                    ds.set_trace(c, t, trace[c, t], data[c, t] if data is not None else None)
+
+        return ds
+
+    @classmethod
+    def new(
+        cls,
+        path: str,
+        channel_count: int,
+        trace_count: int,
+        sample_count: int,
+        data_length: int,
+        version: str,
+        **kwargs,
+    ) -> "TraceDataset":
+        if not os.path.exists(path):
+            os.makedirs(path)
+        elif os.path.isfile(path):
+            raise Exception(f"{path} is not a file.")
+
+        npy_trace_path = os.path.join(path, cls._ARRAY_TRACE_PATH)
+        npy_data_path = os.path.join(path, cls._ARRAY_DATA_PATH)
+        npy_metadata_path = os.path.join(path, cls._METADATA_PATH)
+
+        return cls(
+            npy_trace_path=npy_trace_path,
+            npy_data_path=npy_data_path,
+            npy_metadata_path=npy_metadata_path,
+            create_empty=True,
+            channel_count=channel_count,
+            trace_count=trace_count,
+            sample_count=sample_count,
+            data_length=data_length,
+            version=version,
+            **kwargs,
+        )
+
+    def dump(self, path: str = None, **kwargs):
+        np.save(self._npy_trace_path, self._trace_array)
+        np.save(self._npy_data_path, self._data_array)
+        self._dump_metadata()
+
+    def set_trace(self, channel_index: int, trace_index: int, trace: np.ndarray, data: np.ndarray | None):
+        self._trace_array[channel_index, trace_index, :] = trace
+        if data is not None:
+            self._data_array[channel_index, trace_index, :] = data
+
+    def _get_trace_data(self, channel_slice, trace_slice) -> tuple[list, list, np.ndarray, np.ndarray]:
+        c, t = self._parse_slice(channel_slice, trace_slice)
+        if isinstance(channel_slice, int):
+            channel_slice = slice(channel_slice, channel_slice + 1)
+        if isinstance(trace_slice, int):
+            trace_slice = slice(trace_slice, trace_slice + 1)
+        return c, t, self._trace_array[channel_slice, trace_slice], self._data_array[channel_slice, trace_slice]
+
+
+# def add_trace(self, index: int, trace: np.ndarray, data: bytes):
+#     self._trace_array[index:] = trace
+#     self._data_array[index:] = data
+#
+# def load_from_numpy_data_file(self, path: str, transpose=False) -> "TraceDataset":
+#     """
+#     Load traces from numpy data file.
+#     :param path: file path.
+#     :param transpose: if axes 0 is not represent trace and axes 1 is not represent trace data(sample)
+#     """
+#     self.traces = np.load(path)
+#     if transpose:
+#         self.traces = self.traces.T
+#         sample_count, trace_count = self.traces.shape
+#     else:
+#         trace_count, sample_count = self.traces.shape
+#
+#     self._metadata.trace_count = trace_count
+#     self._metadata.sample_count = sample_count
+#
+#     return self
+#
+# def load_from_zarr(self, path: str, structure: str = "scarr"):
+#     if structure == "scarr":
+#         self.load_from_scarr(path)
+#     # todo other
+#
+# def load_from_scarr(self, path: str):
+#     scarr_data = zarr.open(path, "r")
+#     self.traces = scarr_data["0/0/traces"]
+#     trace_count = self.traces.shape[0]
+#     sample_count = self.traces.shape[1]
+#     data = scarr_data["0/0/plaintext"]
+#
+#     self._metadata.trace_count = trace_count
+#     self._metadata.sample_count = sample_count
+#     self.data = data
+#
+# def load_from_hdf5(self, path: str): ...
+#
+# # def add_trace(self, trace: np.ndarray, index: int = None):
+# #     if index is None:
+# #         index = self._current_create_trace_index
+# #         self._current_create_trace_index += 1
+# #     self.traces[index:] = trace
+#
+# def add_data(self, data: bytes, index: int = None):
+#     if index is None:
+#         index = self._current_create_data_index
+#         self._current_create_data_index += 1
+#     self.data[index:] = data
+#
+# def update_metadata_environment_info(self, cracknuts: str, cracker: str, nuts: str): ...
+#
+# def save_as_numpy_file(self, path):
+#     np.save(os.path.join(path, "trace.npy"), self.traces)
+#     np.save(os.path.join(path, "data.npy"), self.data)
+#
+# def save_as_zarr(self, path): ...  # todo
+# ...

cracknuts/utils/hex_util.py

@@ -0,0 +1,38 @@
+def get_bytes_matrix(data):
+    hex_matrix = ""
+
+    bytes_per_line = 16
+
+    hex_matrix += f"Total bytes: {len(data)}\n"
+
+    hex_matrix += "          00 01 02 03 04 05 06 07  08 09 0A 0B 0C 0D 0E 0F   01234567 89ABCDEF\n"
+    hex_matrix += "          ------------------------------------------------- -------------------\n"
+
+    for i in range(0, len(data), bytes_per_line):
+        chunk = data[i : i + bytes_per_line]
+
+        hex_matrix_line = ""
+
+        hex_matrix_line += f"{i:08X}: "
+
+        hex_values = " ".join([f"{byte:02X}" for byte in chunk[:8]])
+        hex_values += "  " if len(chunk) > 8 else ""
+        hex_values += " ".join([f"{byte:02X}" for byte in chunk[8:]])
+        hex_matrix_line += f"{hex_values:<49}"
+
+        ascii_values = "".join([chr(byte) if 32 <= byte <= 126 else "." for byte in chunk[:8]])
+        ascii_values += " " if len(chunk) > 8 else ""
+        ascii_values += "".join([chr(byte) if 32 <= byte <= 126 else "." for byte in chunk[8:]])
+        hex_matrix_line += f"| {ascii_values:<17} |"
+
+        hex_matrix += hex_matrix_line + "\n"
+
+    return hex_matrix
+
+
+def get_hex(b: bytes):
+    return " ".join(f"{byte:02x}" for byte in b)
+
+
+if __name__ == "__main__":
+    get_bytes_matrix(bytes(range(256)))

cracknuts-0.0.1.dev2.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [2024] [Cracknuts org]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cracknuts-0.0.1.dev2.dist-info/METADATA

@@ -0,0 +1,63 @@
+Metadata-Version: 2.1
+Name: cracknuts
+Version: 0.0.1.dev2
+Summary: A library for cracknuts device.
+Author-email: Dingzb <dingzibiao@gmail.com>
+Maintainer-email: Dingzb <dingzibiao@gmail.com>
+License: MIT License
+        
+        Copyright (c) [2024] [Cracknuts org]
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+Project-URL: homepage, https://cracknuts.io
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy ~=1.26.4
+Requires-Dist: pandas ~=2.2.2
+Requires-Dist: click ~=8.1.7
+Requires-Dist: zarr ~=2.18.2
+Provides-Extra: dev
+Requires-Dist: ruff >=0.6.3 ; extra == 'dev'
+Requires-Dist: typos ~=1.24.4 ; extra == 'dev'
+Requires-Dist: build ~=1.2.1 ; extra == 'dev'
+Requires-Dist: pre-commit ~=3.8.0 ; extra == 'dev'
+Provides-Extra: test
+Requires-Dist: pytest ~=8.3.2 ; extra == 'test'
+
+# Cracknuts
+
+A library for cracknuts device.  
+
+## Install
+
+```shell
+pip install cracknuts
+```
+
+And then execute the following script. A successful output of the version number indicates a successful installation.
+
+```python
+import cracknuts
+cracknuts.version()
+```
+
+## Usage
+
+***More details will be available soon.***  

cracknuts-0.0.1.dev2.dist-info/RECORD

@@ -0,0 +1,21 @@
+cracknuts/__init__.py,sha256=h3yCE4BlO4TKuUMMjq4B4oRYE_CZKcYnqihPXPhtOQo,67
+cracknuts/__main__.py,sha256=Wz3b38yV0iZK1Yf8v-TCQEuqaDN86aEKe9I08pa4-EM,1000
+cracknuts/logger.py,sha256=7QiIyrnfYIoB2t3wbs5HrDOWDKsxiu8tuCA8dwb--qQ,2557
+cracknuts/acquisition/__init__.py,sha256=PKBH5o0Uj3Alvt9wee8VW4tdTegBi3WaRjWA-HAz0Jg,127
+cracknuts/acquisition/acquisition.py,sha256=3uWxpecGgoKrZoQI2_uyyXE6fp_T7GzzywPUTzkdaJg,20393
+cracknuts/cracker/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cracknuts/cracker/basic_cracker.py,sha256=x2DFbGZZ9VYnd8FdJAJ44FW_NDgeIxzfwgtiqzxCnnA,14905
+cracknuts/cracker/cracker.py,sha256=owQV24WqMPZpSFx7V2RrmRcCWn9SpPFoVOjEV7VIsRU,15929
+cracknuts/cracker/mock_cracker.py,sha256=on4MTfUTu6CLUUrTSDdo3-QwgKLisV0mfvb6G7PsRk8,6159
+cracknuts/cracker/protocol.py,sha256=UJQFr0qfRsXfQtRo4iy0QqaGe243irf76OcMhLix4do,2796
+cracknuts/cracker/stateful_cracker.py,sha256=uLmi8SmRoCsf2IAUpKx_j03BuDDx1hvPfLZ_nXplVKA,7811
+cracknuts/solver/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cracknuts/solver/trace.py,sha256=tNTjXIzzQk1p7ayhL2Bijjs8UFIOVvdJ-IKg8RDcUGI,18802
+cracknuts/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cracknuts/utils/hex_util.py,sha256=mhXxtpGnIBzFGUwFG9cXh0FY9Jqfhh7QxxT19oyEPpU,1246
+cracknuts-0.0.1.dev2.dist-info/LICENSE,sha256=nGKiJWWtbS6GzTuavzxssXHjF5GLIAjm1wRcMVBXUVU,1073
+cracknuts-0.0.1.dev2.dist-info/METADATA,sha256=JAN-D74c4JN7Gk26zvofwM10Q7y4gFAUH6XTfaTDF9E,2283
+cracknuts-0.0.1.dev2.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+cracknuts-0.0.1.dev2.dist-info/entry_points.txt,sha256=nEPlDyUvGueBi_4lFft6Fls_tt7Q029gY5JRBeurYPM,54
+cracknuts-0.0.1.dev2.dist-info/top_level.txt,sha256=7Gl3DJme_PYVJnFM800XseM1lHOFNswZqwrAP3KgzYw,10
+cracknuts-0.0.1.dev2.dist-info/RECORD,,

cracknuts-0.0.1.dev2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

cracknuts-0.0.1.dev2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cracknuts = cracknuts.__main__:main

cracknuts-0.0.1.dev2.dist-info/top_level.txt

@@ -0,0 +1 @@
+cracknuts