cryptsmith 0.1.0__py3-none-any.whl

cryptsmith/__init__.py

@@ -0,0 +1,6 @@
+"""cryptsmith: crypto attack primitives and analysis toolkit."""
+
+from . import analysis, classical, encoding, hashid, pcap, rsa, xor
+
+__version__ = "0.1.0"
+__all__ = ["analysis", "classical", "encoding", "hashid", "pcap", "rsa", "xor"]

cryptsmith/analysis.py

@@ -0,0 +1,77 @@
+"""Statistical analysis: entropy, frequency, english scoring."""
+import math
+from collections import Counter
+
+ENGLISH_FREQ = {
+    "a": 0.08167, "b": 0.01492, "c": 0.02782, "d": 0.04253, "e": 0.12702,
+    "f": 0.02228, "g": 0.02015, "h": 0.06094, "i": 0.06966, "j": 0.00153,
+    "k": 0.00772, "l": 0.04025, "m": 0.02406, "n": 0.06749, "o": 0.07507,
+    "p": 0.01929, "q": 0.00095, "r": 0.05987, "s": 0.06327, "t": 0.09056,
+    "u": 0.02758, "v": 0.00978, "w": 0.02360, "x": 0.00150, "y": 0.01974,
+    "z": 0.00074,
+}
+
+
+def shannon_entropy(data: bytes) -> float:
+    """Shannon entropy in bits per byte. ~8.0 is random, ~4.7 is english text."""
+    if not data:
+        return 0.0
+    counts = Counter(data)
+    length = len(data)
+    return -sum((c / length) * math.log2(c / length) for c in counts.values())
+
+
+def frequency_analysis(text: str) -> list[tuple[str, float]]:
+    """Letter frequencies sorted most common first."""
+    letters = [c.lower() for c in text if c.isalpha()]
+    if not letters:
+        return []
+    counts = Counter(letters)
+    total = len(letters)
+    return sorted(((ch, n / total) for ch, n in counts.items()), key=lambda x: -x[1])
+
+
+def index_of_coincidence(text: str) -> float:
+    """IoC ~0.065 for english, ~0.038 for random. Useful to spot polyalphabetic ciphers."""
+    letters = [c.lower() for c in text if c.isalpha()]
+    n = len(letters)
+    if n < 2:
+        return 0.0
+    counts = Counter(letters)
+    return sum(c * (c - 1) for c in counts.values()) / (n * (n - 1))
+
+
+def chi_squared(text: str) -> float:
+    """Chi squared distance from english letter frequencies. Lower is more english."""
+    letters = [c.lower() for c in text if c.isalpha()]
+    n = len(letters)
+    if n == 0:
+        return float("inf")
+    counts = Counter(letters)
+    score = 0.0
+    for ch, expected in ENGLISH_FREQ.items():
+        observed = counts.get(ch, 0)
+        exp = n * expected
+        score += ((observed - exp) ** 2) / exp if exp else 0
+    return score
+
+
+def english_score(text: str) -> float:
+    """Higher is better. Combines chi squared with a bonus for common words and spaces."""
+    if not text:
+        return float("-inf")
+    try:
+        t = text if isinstance(text, str) else text.decode("latin1")
+    except Exception:
+        return float("-inf")
+    chi = chi_squared(t)
+    words = t.lower().split()
+    common = sum(1 for w in words if w.strip(".,!?;:\"'()") in {
+        "the", "and", "for", "with", "this", "that", "from", "have", "flag",
+        "key", "secret", "enroll", "hello", "server", "client",
+    })
+    space_bonus = t.count(" ") * 2
+    printable_ratio = sum(1 for c in t if 32 <= ord(c) < 127 or c in "\n\r\t") / max(len(t), 1)
+    if printable_ratio < 0.9:
+        return float("-inf")
+    return space_bonus + common * 25 - chi / 10

cryptsmith/classical.py

@@ -0,0 +1,91 @@
+"""Classical ciphers: caesar, vigenere, atbash, affine."""
+from .analysis import english_score
+
+
+def _shift_char(c: str, shift: int) -> str:
+    if "a" <= c <= "z":
+        return chr((ord(c) - 97 + shift) % 26 + 97)
+    if "A" <= c <= "Z":
+        return chr((ord(c) - 65 + shift) % 26 + 65)
+    return c
+
+
+def caesar_decrypt(text: str, shift: int) -> str:
+    return "".join(_shift_char(c, -shift) for c in text)
+
+
+def caesar_encrypt(text: str, shift: int) -> str:
+    return "".join(_shift_char(c, shift) for c in text)
+
+
+def caesar_bruteforce(text: str, top: int = 3) -> list[tuple[int, str, float]]:
+    """Try all 26 shifts, return the top scoring (shift, plaintext, score)."""
+    scored = [(s, caesar_decrypt(text, s), english_score(caesar_decrypt(text, s))) for s in range(26)]
+    scored.sort(key=lambda x: -x[2])
+    return scored[:top]
+
+
+def atbash(text: str) -> str:
+    def flip(c: str) -> str:
+        if "a" <= c <= "z":
+            return chr(122 - (ord(c) - 97))
+        if "A" <= c <= "Z":
+            return chr(90 - (ord(c) - 65))
+        return c
+    return "".join(flip(c) for c in text)
+
+
+def vigenere_decrypt(text: str, key: str) -> str:
+    key = key.lower()
+    out = []
+    ki = 0
+    for c in text:
+        if c.isalpha():
+            shift = ord(key[ki % len(key)]) - 97
+            out.append(_shift_char(c, -shift))
+            ki += 1
+        else:
+            out.append(c)
+    return "".join(out)
+
+
+def vigenere_encrypt(text: str, key: str) -> str:
+    key = key.lower()
+    out = []
+    ki = 0
+    for c in text:
+        if c.isalpha():
+            shift = ord(key[ki % len(key)]) - 97
+            out.append(_shift_char(c, shift))
+            ki += 1
+        else:
+            out.append(c)
+    return "".join(out)
+
+
+def affine_decrypt(text: str, a: int, b: int) -> str | None:
+    from math import gcd
+    if gcd(a, 26) != 1:
+        return None
+    a_inv = pow(a, -1, 26)
+    def dec(c: str) -> str:
+        if "a" <= c <= "z":
+            return chr((a_inv * (ord(c) - 97 - b)) % 26 + 97)
+        if "A" <= c <= "Z":
+            return chr((a_inv * (ord(c) - 65 - b)) % 26 + 65)
+        return c
+    return "".join(dec(c) for c in text)
+
+
+def affine_bruteforce(text: str, top: int = 5) -> list[tuple[int, int, str, float]]:
+    """Try all valid (a, b) pairs, return top scoring."""
+    from math import gcd
+    results = []
+    for a in range(1, 26):
+        if gcd(a, 26) != 1:
+            continue
+        for b in range(26):
+            pt = affine_decrypt(text, a, b)
+            results.append((a, b, pt, english_score(pt)))
+    results.sort(key=lambda x: -x[3])
+    return results[:top]

cryptsmith/encoding.py

@@ -0,0 +1,77 @@
+"""Encoding detection and layered auto decode (base64, hex, url, ...)."""
+import base64
+import re
+from urllib.parse import unquote
+
+_B64_RE = re.compile(r"^[A-Za-z0-9+/=\s]+$")
+_HEX_RE = re.compile(r"^(?:[0-9a-fA-F]{2})+$")
+
+
+def looks_like_base64(s: str) -> bool:
+    s = s.strip()
+    return len(s) >= 8 and len(s) % 4 == 0 and bool(_B64_RE.match(s))
+
+
+def looks_like_hex(s: str) -> bool:
+    s = s.strip()
+    return len(s) >= 8 and bool(_HEX_RE.match(s))
+
+
+def looks_like_urlencoded(s: str) -> bool:
+    return "%" in s and bool(re.search(r"%[0-9a-fA-F]{2}", s))
+
+
+def _try_b64(s: str) -> bytes | None:
+    try:
+        return base64.b64decode(s.strip(), validate=False)
+    except Exception:
+        return None
+
+
+def _try_hex(s: str) -> bytes | None:
+    try:
+        return bytes.fromhex(s.strip())
+    except Exception:
+        return None
+
+
+def smart_decode(data: bytes, max_depth: int = 4) -> list[tuple[str, bytes]]:
+    """Peel layered encodings. Returns list of (chain_label, decoded_bytes)."""
+    try:
+        text = data.decode("ascii").strip()
+    except Exception:
+        return []
+    results: list[tuple[str, bytes]] = []
+    stack = [(text, [])]
+    seen = set()
+    for _ in range(max_depth):
+        next_stack = []
+        for current, chain in stack:
+            if current in seen:
+                continue
+            seen.add(current)
+            candidates: list[tuple[str, bytes | None]] = []
+            if looks_like_base64(current):
+                candidates.append(("b64", _try_b64(current)))
+            if looks_like_hex(current):
+                candidates.append(("hex", _try_hex(current)))
+            if looks_like_urlencoded(current):
+                try:
+                    candidates.append(("url", unquote(current).encode("latin1")))
+                except Exception:
+                    pass
+            for label, decoded in candidates:
+                if decoded is None or decoded == current.encode():
+                    continue
+                new_chain = chain + [label]
+                results.append(("+".join(new_chain), decoded))
+                try:
+                    nxt = decoded.decode("ascii").strip()
+                    if nxt != current:
+                        next_stack.append((nxt, new_chain))
+                except Exception:
+                    pass
+        stack = next_stack
+        if not stack:
+            break
+    return results

cryptsmith/hashid.py

@@ -0,0 +1,22 @@
+"""Identify hash algorithms by digest length and charset."""
+import re
+
+_HASHES = [
+    (32, "md5", "md4"),
+    (40, "sha1", "ripemd160"),
+    (56, "sha224"),
+    (64, "sha256", "sha3_256", "blake2s"),
+    (96, "sha384", "sha3_384"),
+    (128, "sha512", "sha3_512", "blake2b", "whirlpool"),
+]
+
+
+def identify(digest: str) -> list[str]:
+    """Return likely hash names for a hex digest string."""
+    d = digest.strip().lower()
+    if not re.fullmatch(r"[0-9a-f]+", d):
+        return []
+    for length, *names in _HASHES:
+        if len(d) == length:
+            return list(names)
+    return []

cryptsmith/pcap.py

@@ -0,0 +1,331 @@
+"""Pure python pcap reading, TCP stream reassembly, and payload carving.
+
+No dependencies. Handles the classic libpcap format (little and big endian,
+microsecond and nanosecond), Ethernet + IPv4 + TCP.
+"""
+import re
+import struct
+from dataclasses import dataclass, field
+
+
+@dataclass
+class Packet:
+    ts: float
+    data: bytes
+
+
+class PcapReader:
+    """Iterate packets from a pcap file."""
+
+    def __init__(self, path: str):
+        self.path = path
+        with open(path, "rb") as f:
+            magic = f.read(4)
+        if magic == b"\xd4\xc3\xb2\xa1":
+            self._endian = "<"
+        elif magic == b"\xa1\xb2\xc3\xd4":
+            self._endian = ">"
+        elif magic in (b"\x4d\x3c\xb2\xa1", b"\xa1\xb2\x3c\x4d"):
+            self._endian = "<" if magic == b"\x4d\x3c\xb2\xa1" else ">"
+            self._nanosec = True
+        else:
+            raise ValueError("not a pcap file (bad magic)")
+        self._nanosec = getattr(self, "_nanosec", magic in (b"\x4d\x3c\xb2\xa1", b"\xa1\xb2\x3c\x4d"))
+
+    def packets(self):
+        e = self._endian
+        with open(self.path, "rb") as f:
+            f.read(24)  # global header
+            while True:
+                hdr = f.read(16)
+                if len(hdr) < 16:
+                    return
+                ts_sec, ts_frac, incl_len, _ = struct.unpack(e + "IIII", hdr)
+                data = f.read(incl_len)
+                if len(data) < incl_len:
+                    return
+                ts = ts_sec + ts_frac / (1e9 if self._nanosec else 1e6)
+                yield Packet(ts=ts, data=data)
+
+
+@dataclass
+class TCPFlow:
+    src: str
+    sport: int
+    dst: str
+    dport: int
+    payload: bytes = b""
+
+    @property
+    def label(self) -> str:
+        return f"{self.src}:{self.sport} -> {self.dst}:{self.dport}"
+
+
+@dataclass
+class TCPStream:
+    """Both directions of one TCP conversation, reassembled."""
+    endpoint_a: tuple[str, int] = field(default=("", 0))
+    endpoint_b: tuple[str, int] = field(default=("", 0))
+    a_to_b: bytes = b""
+    b_to_a: bytes = b""
+    packet_count: int = 0
+
+    @property
+    def label(self) -> str:
+        a = f"{self.endpoint_a[0]}:{self.endpoint_a[1]}"
+        b = f"{self.endpoint_b[0]}:{self.endpoint_b[1]}"
+        return f"{a} <-> {b}"
+
+    @property
+    def payload(self) -> bytes:
+        return self.a_to_b + b"\n--- direction flip ---\n" + self.b_to_a
+
+
+def _parse_ipv4(data: bytes):
+    if len(data) < 20:
+        return None
+    ihl = (data[0] & 0x0F) * 4
+    if len(data) < ihl or data[9] != 6:  # protocol 6 = TCP
+        return None
+    src = ".".join(str(b) for b in data[12:16])
+    dst = ".".join(str(b) for b in data[16:20])
+    return src, dst, data[ihl:]
+
+
+def _parse_tcp(data: bytes):
+    if len(data) < 20:
+        return None
+    sport, dport, seq = struct.unpack("!HHI", data[:8])
+    data_offset = (data[12] >> 4) * 4
+    if len(data) < data_offset:
+        return None
+    return sport, dport, seq, data[data_offset:]
+
+
+def parse_packet(raw: bytes) -> TCPFlow | None:
+    """Parse one link layer frame into a TCPFlow. Returns None if not TCP/IPv4."""
+    if len(raw) < 14:
+        return None
+    ethertype = struct.unpack("!H", raw[12:14])[0]
+    if ethertype != 0x0800:  # IPv4 only
+        return None
+    ip = _parse_ipv4(raw[14:])
+    if ip is None:
+        return None
+    src, dst, tcp_seg = ip
+    tcp = _parse_tcp(tcp_seg)
+    if tcp is None:
+        return None
+    sport, dport, seq, payload = tcp
+    flow = TCPFlow(src=src, sport=sport, dst=dst, dport=dport, payload=b"")
+    flow.seq = seq  # type: ignore[attr-defined]
+    flow.payload = payload
+    return flow
+
+
+def reassemble_streams(reader: PcapReader) -> list[TCPStream]:
+    """Reassemble TCP streams from a pcap. Returns streams with payloads in order."""
+    # key: frozenset of endpoints -> stream; per direction seq buckets
+    streams: dict[frozenset, TCPStream] = {}
+    buckets: dict[frozenset, dict[tuple, list[tuple[int, bytes]]]] = {}
+
+    for pkt in reader.packets():
+        flow = parse_packet(pkt.data)
+        if flow is None or not flow.payload:
+            continue
+        key = frozenset({(flow.src, flow.sport), (flow.dst, flow.dport)})
+        if key not in streams:
+            eps = sorted(key)
+            streams[key] = TCPStream(endpoint_a=eps[0], endpoint_b=eps[1])
+            buckets[key] = {}
+        direction = ((flow.src, flow.sport), (flow.dst, flow.dport))
+        buckets[key].setdefault(direction, []).append((flow.seq, flow.payload))
+        streams[key].packet_count += 1
+
+    for key, stream in streams.items():
+        for direction, segs in buckets[key].items():
+            segs.sort(key=lambda x: x[0])
+            merged = bytearray()
+            next_seq = None
+            for seq, payload in segs:
+                if next_seq is None:
+                    merged += payload
+                    next_seq = seq + len(payload)
+                elif seq >= next_seq:
+                    merged += payload
+                    next_seq = seq + len(payload)
+                elif seq + len(payload) > next_seq:
+                    merged += payload[next_seq - seq:]
+                    next_seq = seq + len(payload)
+            data = bytes(merged)
+            if direction[0] == stream.endpoint_a:
+                stream.a_to_b = data
+            else:
+                stream.b_to_a = data
+    return list(streams.values())
+
+
+def carve_strings(data: bytes, min_len: int = 4) -> list[str]:
+    """Extract printable ascii strings like the `strings` utility."""
+    out = []
+    cur = []
+    for b in data:
+        if 32 <= b < 127:
+            cur.append(chr(b))
+        else:
+            if len(cur) >= min_len:
+                out.append("".join(cur))
+            cur = []
+    if len(cur) >= min_len:
+        out.append("".join(cur))
+    return out
+
+
+def opaque_runs(data: bytes, min_len: int = 12) -> list[bytes]:
+    """Maximal runs of non printable bytes. Obfuscated blobs hide in these."""
+    runs = []
+    cur = bytearray()
+    for b in data:
+        if 32 <= b < 127:
+            if len(cur) >= min_len:
+                runs.append(bytes(cur))
+            cur = bytearray()
+        else:
+            cur.append(b)
+    if len(cur) >= min_len:
+        runs.append(bytes(cur))
+    return runs
+
+
+def suspicious_spans(data: bytes, min_len: int = 16, max_printable: float = 0.7) -> list[bytes]:
+    """Spans that look obfuscated: mixed binary where xor'd text often hides.
+
+    Xor obfuscation with a byte key leaves some bytes printable, so strict
+    non printable runs miss it. These spans tolerate printable bytes up to
+    max_printable ratio.
+    """
+    flags = [32 <= b < 127 for b in data]
+    n = len(data)
+    spans = []
+    i = 0
+    while i < n:
+        if flags[i]:
+            i += 1
+            continue
+        j = i
+        while j < n:
+            seg = flags[i:j + 1]
+            if sum(seg) / len(seg) > max_printable and (j - i + 1) >= min_len:
+                break
+            j += 1
+        if j - i >= min_len:
+            spans.append(data[i:j])
+        i = j if j > i else i + 1
+    return spans
+
+
+def hunt_alpha_tokens(data: bytes, length: int = 12) -> list[str]:
+    """Find alpha only tokens of exactly `length` chars, e.g. enrollment keys.
+
+    Looks at raw bytes and at printable strings, deduped, in order of appearance.
+    """
+    text = data.decode("latin1")
+    pattern = re.compile(rf"(?<![A-Za-z])[A-Za-z]{{{length}}}(?![A-Za-z])")
+    seen = set()
+    hits = []
+    for m in pattern.finditer(text):
+        tok = m.group(0)
+        if tok not in seen:
+            seen.add(tok)
+            hits.append(tok)
+    return hits
+
+
+def hunt_alpha_runs(data: bytes, min_length: int = 12) -> list[str]:
+    """Find alpha only runs of at least min_length chars.
+
+    Looser than hunt_alpha_tokens: for decoded or deobfuscated text where
+    token boundaries are unreliable, e.g. a key glued to framing bytes.
+    """
+    text = data.decode("latin1")
+    seen = set()
+    hits = []
+    for m in re.finditer(r"[A-Za-z]+", text):
+        tok = m.group(0)
+        if len(tok) >= min_length and tok not in seen:
+            seen.add(tok)
+            hits.append(tok)
+    return hits
+
+
+_ALPHA = set(b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")
+
+# BYTE_MASKS[b]: bitmask of xor keys k where (b ^ k) is an ascii letter.
+# Precomputed once; key k corresponds to bit (1 << k).
+_BYTE_MASKS: list[int] = []
+for _b in range(256):
+    _m = 0
+    for _c in _ALPHA:
+        _m |= 1 << (_b ^ _c)
+    _BYTE_MASKS.append(_m)
+
+
+def xor_token_scan(data: bytes, min_length: int = 12) -> list[tuple[int, int, str]]:
+    """Find (offset, key, token) where data[offset:] xored with key starts with
+    an alpha only run of at least min_length chars.
+
+    This catches xor obfuscated tokens buried in mixed binary traffic, where
+    whole blob english scoring fails because plaintext and obfuscated regions
+    mix. Bitmask sliding window makes it O(n): for each byte, the set of keys
+    yielding a letter; AND the sets across the window. Any nonzero result
+    means some key decodes the whole window to letters.
+    """
+    n = len(data)
+    if n < min_length:
+        return []
+    masks = [_BYTE_MASKS[b] for b in data]
+    hits: list[tuple[int, int, str]] = []
+    for start in range(n - min_length + 1):
+        window_and = masks[start]
+        for i in range(start + 1, start + min_length):
+            window_and &= masks[i]
+            if not window_and:
+                break
+        if not window_and:
+            continue
+        mm, k = window_and, 0
+        while mm:
+            if mm & 1:
+                end = start + min_length
+                while end < n and (data[end] ^ k) in _ALPHA:
+                    end += 1
+                token = bytes(b ^ k for b in data[start:end]).decode("ascii")
+                # skip trivial keys: the token is already sitting in the raw
+                # bytes (e.g. key 0x00 identity or 0x20 case flip on plaintext)
+                raw = data[start:end].decode("latin1")
+                if raw.lower() != token.lower():
+                    hits.append((start, k, token))
+            mm >>= 1
+            k += 1
+    # dedupe by (key, token), keep earliest offset
+    seen = set()
+    deduped = []
+    for offset, k, token in hits:
+        if (k, token) not in seen:
+            seen.add((k, token))
+            deduped.append((offset, k, token))
+    return deduped
+
+
+def hunt_pattern(data: bytes, pattern: str) -> list[str]:
+    """Find all matches of a custom regex against the payload as latin1 text."""
+    rx = re.compile(pattern)
+    text = data.decode("latin1")
+    seen = set()
+    hits = []
+    for m in rx.finditer(text):
+        tok = m.group(0)
+        if tok not in seen:
+            seen.add(tok)
+            hits.append(tok)
+    return hits

cryptsmith/rsa.py

@@ -0,0 +1,123 @@
+"""RSA attacks: Wiener, Hastad broadcast, common modulus, small exponent."""
+import math
+
+
+def egcd(a: int, b: int) -> tuple[int, int, int]:
+    if b == 0:
+        return (a, 1, 0)
+    g, x, y = egcd(b, a % b)
+    return (g, y, x - (a // b) * y)
+
+
+def modinv(a: int, m: int) -> int:
+    g, x, _ = egcd(a, m)
+    if g != 1:
+        raise ValueError("no modular inverse")
+    return x % m
+
+
+def int_nthroot(x: int, n: int) -> tuple[int, bool]:
+    """Integer nth root. Returns (root, exact)."""
+    if x < 0:
+        raise ValueError("negative")
+    if x == 0:
+        return (0, True)
+    bits = x.bit_length()
+    high = 1 << ((bits + n - 1) // n + 1)
+    low = 0
+    while low < high:
+        mid = (low + high) // 2
+        p = mid ** n
+        if p == x:
+            return (mid, True)
+        if p < x:
+            low = mid + 1
+        else:
+            high = mid
+    return (low - 1, (low - 1) ** n == x)
+
+
+def _continued_fraction(num: int, den: int) -> list[int]:
+    cf = []
+    while den:
+        q = num // den
+        cf.append(q)
+        num, den = den, num - q * den
+    return cf
+
+
+def _convergents(cf: list[int]):
+    convs = []
+    for i in range(len(cf)):
+        num, den = cf[i], 1
+        for j in range(i - 1, -1, -1):
+            num, den = den + num * cf[j], num
+        convs.append((den, num))  # (k, d) style: returns denominator, numerator
+    return convs
+
+
+def wiener_attack(n: int, e: int) -> int | None:
+    """Recover d when d < n^0.25 / 3 via Wiener's continued fraction attack."""
+    cf = _continued_fraction(e, n)
+    for d, k in _convergents(cf):
+        if k == 0:
+            continue
+        if (e * d - 1) % k != 0:
+            continue
+        phi = (e * d - 1) // k
+        s = n - phi + 1
+        disc = s * s - 4 * n
+        if disc < 0:
+            continue
+        t = math.isqrt(disc)
+        if t * t != disc:
+            continue
+        if (s + t) % 2 == 0:
+            return d
+    return None
+
+
+def hastad_broadcast(ns: list[int], e: int, cts: list[int]) -> int | None:
+    """Hastad broadcast attack: same m, small e, e+ ciphertexts under different moduli."""
+    if len(ns) < e or len(cts) < e:
+        return None
+    crt_val = _crt(cts[:e], ns[:e])
+    m, exact = int_nthroot(crt_val, e)
+    return m if exact else None
+
+
+def _crt(remainders: list[int], moduli: list[int]) -> int:
+    m_prod = 1
+    for m in moduli:
+        m_prod *= m
+    result = 0
+    for r, m in zip(remainders, moduli):
+        p = m_prod // m
+        result += r * modinv(p, m) * p
+    return result % m_prod
+
+
+def common_modulus(n: int, e1: int, e2: int, c1: int, c2: int) -> int | None:
+    """Recover m when the same m was encrypted under the same n with coprime exponents."""
+    g, a, b = egcd(e1, e2)
+    if g != 1:
+        return None
+    if a < 0:
+        c1 = modinv(c1, n)
+        a = -a
+    if b < 0:
+        c2 = modinv(c2, n)
+        b = -b
+    return (pow(c1, a, n) * pow(c2, b, n)) % n
+
+
+def small_exponent_decrypt(n: int, e: int, c: int) -> int | None:
+    """Decrypt when m^e < n (no modular wraparound happened)."""
+    m, exact = int_nthroot(c, e)
+    return m if exact and pow(m, e, n) == c else None
+
+
+def int_to_bytes(n: int) -> bytes:
+    if n == 0:
+        return b"\x00"
+    return n.to_bytes((n.bit_length() + 7) // 8, "big")

cryptsmith/xor.py

@@ -0,0 +1,96 @@
+"""XOR cryptanalysis: single byte bruteforce and repeating key break."""
+from .analysis import english_score
+
+
+def xor_bytes(data: bytes, key: bytes) -> bytes:
+    return bytes(b ^ key[i % len(key)] for i, b in enumerate(data))
+
+
+def single_byte_xor_break(data: bytes, top: int = 5) -> list[tuple[int, bytes, float]]:
+    """Bruteforce all 256 single byte keys, return top scoring (key, plaintext, score)."""
+    results = []
+    for key in range(256):
+        pt = bytes(b ^ key for b in data)
+        results.append((key, pt, english_score(pt.decode("latin1"))))
+    results.sort(key=lambda x: -x[2])
+    return results[:top]
+
+
+def hamming_distance(a: bytes, b: bytes) -> int:
+    return sum(bin(x ^ y).count("1") for x, y in zip(a, b))
+
+
+def guess_keysize(data: bytes, max_keysize: int = 40, top: int = 3) -> list[tuple[int, float]]:
+    """Guess repeating xor keysize via normalized hamming distance. Lower is better."""
+    guesses = []
+    for ks in range(2, min(max_keysize + 1, len(data) // 8 + 1)):
+        nblocks = min(8, len(data) // ks)
+        blocks = [data[i * ks:(i + 1) * ks] for i in range(nblocks)]
+        dists = [hamming_distance(blocks[i], blocks[i + 1]) / ks for i in range(nblocks - 1)]
+        guesses.append((ks, sum(dists) / len(dists)))
+    guesses.sort(key=lambda x: x[1])
+    return guesses[:top]
+
+
+def _refine_key(data: bytes, key: bytes) -> tuple[bytes, float]:
+    """Hill climb each key byte against the full plaintext english score."""
+    best = bytearray(key)
+    best_score = english_score(xor_bytes(data, bytes(best)).decode("latin1"))
+    improved = True
+    while improved:
+        improved = False
+        for i in range(len(best)):
+            for b in range(256):
+                if b == best[i]:
+                    continue
+                cand = bytearray(best)
+                cand[i] = b
+                s = english_score(xor_bytes(data, bytes(cand)).decode("latin1"))
+                if s > best_score:
+                    best, best_score = cand, s
+                    improved = True
+    return bytes(best), best_score
+
+
+def _partial_score(data: bytes, key: bytes, keysize: int) -> float:
+    """Score text decrypted with a partial key (first len(key) bytes of each keysize block)."""
+    m = len(key)
+    dec = bytearray()
+    for t in range(len(data)):
+        if t % keysize < m:
+            dec.append(data[t] ^ key[t % keysize])
+    if not dec:
+        return float("-inf")
+    return english_score(bytes(dec).decode("latin1"))
+
+
+def _beam_search_key(data: bytes, keysize: int, width: int = 50, per_block: int = 8) -> bytes:
+    """Beam search over per-block key candidates, scored on progressively decrypted text."""
+    cands = [
+        [k for k, _, _ in single_byte_xor_break(data[i::keysize], top=per_block)]
+        for i in range(keysize)
+    ]
+    beam: list[bytes] = [b""]
+    for i in range(keysize):
+        expanded = []
+        for partial in beam:
+            for b in cands[i]:
+                full = partial + bytes([b])
+                expanded.append((full, _partial_score(data, full, keysize)))
+        expanded.sort(key=lambda x: -x[1])
+        beam = [k for k, _ in expanded[:width]]
+    return beam[0]
+
+
+def repeating_key_xor_break(data: bytes, max_keysize: int = 40) -> list[tuple[bytes, bytes, float]]:
+    """Break repeating key xor. Returns (key, plaintext, score) for top keysize guesses."""
+    results = []
+    for keysize, _ in guess_keysize(data, max_keysize, top=6):
+        if keysize <= 12:
+            key = _beam_search_key(data, keysize)
+        else:
+            key = bytes(single_byte_xor_break(data[i::keysize], top=1)[0][0] for i in range(keysize))
+        key, score = _refine_key(data, key)
+        results.append((key, xor_bytes(data, key), score))
+    results.sort(key=lambda x: -x[2])
+    return results

cryptsmith-0.1.0.dist-info/METADATA

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: cryptsmith
+Version: 0.1.0
+Summary: Crypto attack primitives and analysis toolkit for CTF players and security researchers. Zero dependencies.
+Author: Jake Burre
+License: MIT
+Project-URL: Homepage, https://github.com/burrejak22/cryptsmith
+Project-URL: Repository, https://github.com/burrejak22/cryptsmith
+Keywords: crypto,ctf,cryptanalysis,rsa,pcap,security
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Information Technology
+Classifier: Topic :: Security :: Cryptography
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# cryptsmith
+
+Crypto attack primitives and analysis toolkit for CTF players and security researchers. Zero dependencies, stdlib only.
+
+Built for challenges like NSA Codebreakers style pcaps: custom protocols, hidden enrollment keys, obfuscated traffic.
+
+## What it does
+
+* **Classical ciphers** — caesar bruteforce with english scoring, vigenere, atbash, affine
+* **XOR** — single byte bruteforce, repeating key break via hamming distance keysize guessing
+* **RSA attacks** — Wiener's attack, Hastad broadcast, common modulus, small exponent
+* **Analysis** — shannon entropy, index of coincidence, chi squared english scoring, frequency analysis
+* **Encoding** — layered auto decode for base64, hex, url encoding, with the decode chain reported
+* **Hash ID** — identify hash algorithms by digest length and charset
+* **PCAP** — pure python pcap reader, IPv4/TCP parsing, TCP stream reassembly, payload carving, token hunting
+
+## Install
+
+```bash
+pip install cryptsmith
+```
+
+## Quick use
+
+```python
+from cryptsmith import xor, rsa, pcap, analysis
+
+# break single byte xor
+for key, plaintext, score in xor.single_byte_xor_break(data)[:3]:
+    print(key, plaintext)
+
+# wiener attack on weak rsa
+d = rsa.wiener_attack(n, e)
+
+# pull tcp streams out of a pcap and hunt 12 char alpha tokens
+streams = pcap.reassemble_streams(pcap.PcapReader("capture.pcap"))
+for s in streams:
+    for token in pcap.hunt_alpha_tokens(s.payload, length=12):
+        print(s.label, token)
+```
+
+## Companion project
+
+**flaghunter** builds on cryptsmith: point it at a challenge file or a pcap and it runs a full battery of attacks automatically and writes you a report.
+
+## License
+
+MIT

cryptsmith-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+cryptsmith/__init__.py,sha256=8NamAnJITCQWI-GMna4ePJ_kN0ihdUSb3w0tfv_C13s,237
+cryptsmith/analysis.py,sha256=1giN8Q0aQ-YDy61z-d4NIOyw4zyqsVgT0RAmfdyzUIE,2802
+cryptsmith/classical.py,sha256=mAIz3cY1FVzi4W0IM9uCMo9mjlyJ0MxMe5by26ebIJ8,2633
+cryptsmith/encoding.py,sha256=h15TxYaCnRp5Z_2pX2kONKzqJ6BgzVrXHQyy8IdRTFk,2412
+cryptsmith/hashid.py,sha256=cu8v7n-CA8T7di4Ji6SUeC1Qsi31di0OyOlAcPQdycc,595
+cryptsmith/pcap.py,sha256=9Wm33JOkGsH5moGaDwXM-kc-b5F-QgGB2_qR6UGYa6U,10780
+cryptsmith/rsa.py,sha256=thy3lIP6Q7SFLjjIJIQu0gxBxPShWJizRxBagPgUp_E,3284
+cryptsmith/xor.py,sha256=yGGySG6f_EArFerIYAQUwf_0X164ZT3e6Xl6ySVf9d8,3810
+cryptsmith-0.1.0.dist-info/licenses/LICENSE,sha256=sauKnEpDyq_Syg9gI1eycBqYqRY7xmcYeema4pkzTaA,1067
+cryptsmith-0.1.0.dist-info/METADATA,sha256=Sk-vZ1UKl0QWNG4ZCGIuV0bmPXckgULrkHa_aLD1o3c,2411
+cryptsmith-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+cryptsmith-0.1.0.dist-info/top_level.txt,sha256=OhPB71yD-k2tIzRl6zeN4fxezfCOF9ZXCRlya7Hxdn8,11
+cryptsmith-0.1.0.dist-info/RECORD,,

cryptsmith-0.1.0.dist-info/WHEEL

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

cryptsmith-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jake Burre
+
+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.

cryptsmith-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+cryptsmith