codext 1.16.3__tar.gz → 1.16.5__tar.gz

{codext-1.16.3 → codext-1.16.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codext
-Version: 1.16.3
+Version: 1.16.5
 Summary: Native codecs extension
 Author-email: Alexandre D'Hondt <alexandre.dhondt@gmail.com>
 License:                     GNU GENERAL PUBLIC LICENSE
@@ -1034,6 +1034,7 @@ This category also contains `ascii85`, `adobe`, `[x]btoa`, `zeromq` with the `ba
 - [X] `barbie-N`: aka Barbie Typewriter (*N* belongs to [1, 4])
 - [X] `beaufort`: aka Beaufort Cipher (variant of Vigenere Cipher)
 - [X] `citrix`: aka Citrix CTX1 password encoding
+- [X] `playfair`: aka Playfair Cipher
 - [X] `phillips`: aka Phillips Cipher (polyalphabetic block cipher with 8 key squares)
 - [X] `polybius`: aka Polybius Square Cipher
 - [X] `railfence`: aka Rail Fence Cipher

{codext-1.16.3 → codext-1.16.5}/README.md

@@ -336,6 +336,7 @@ This category also contains `ascii85`, `adobe`, `[x]btoa`, `zeromq` with the `ba
 - [X] `barbie-N`: aka Barbie Typewriter (*N* belongs to [1, 4])
 - [X] `beaufort`: aka Beaufort Cipher (variant of Vigenere Cipher)
 - [X] `citrix`: aka Citrix CTX1 password encoding
+- [X] `playfair`: aka Playfair Cipher
 - [X] `phillips`: aka Phillips Cipher (polyalphabetic block cipher with 8 key squares)
 - [X] `polybius`: aka Polybius Square Cipher
 - [X] `railfence`: aka Rail Fence Cipher

{codext-1.16.3 → codext-1.16.5}/docs/pages/enc/crypto.md

@@ -257,6 +257,25 @@ This is a dynamic encoding, that is, it can be called with an integer to define
 
 -----
 
+### Playfair Cipher
+
+The Playfair cipher is a symmetric encryption method using polygram substitution with bigrams (pairs of letters), invented in 1854 by Charles Wheatstone, but popularized by Lord Playfair.
+
+**Codec** | **Conversions** | **Aliases** | **Comment**
+:---: | :---: | --- | ---
+`playfair` | text <-> Playfair ciphertext | `playfair`, `playfair-playfairexample`, `playfair-keyword` | Dynamic key parameter ; letters only ; `J` is normalized to `I`
+
+```python
+>>> codext.encode("HIDETHEGOLDINTHETREESTUMP", "playfair-playfairexample")
+'BMODZBXDNABEKUDMUIXMMOUVIF'
+>>> codext.decode("BMODZBXDNABEKUDMUIXMMOUVIF", "playfair-playfairexample")
+'HIDETHEGOLDINTHETREXESTUMP'
+>>> codext.decode(codext.encode("INSTRUMENT", "playfair-keyword"), "playfair-keyword")
+'INSTRUMENT'
+```
+
+-----
+
 ### Trithemius Cipher
 
 This is a variant of the [Vigenere Cipher](#vigenere-cipher) with key `"ABCDEFGHIJKLMNOPQRSTUVWXYZ"`.
@@ -335,4 +354,3 @@ This is a dynamic encoding, that is, it can be called with an integer to define
 >>> codext.encode("~bcy*cy*k*~oy~", "xor-10")
 'this is a test'
 ```
-

codext-1.16.5/src/codext/VERSION.txt

@@ -0,0 +1 @@
+1.16.5

{codext-1.16.3 → codext-1.16.5}/src/codext/base/_base.py

@@ -125,8 +125,10 @@ def base_encode(input, charset, errors="strict", exc=BaseEncodeError):
         if i > SIZE_LIMIT:
             raise InputSizeLimitError("Input exceeded size limit")
         return i * charset[0]
-    if n == 10:
-        return str(i) if charset == digits else "".join(charset[int(x)] for x in str(i))
+    # keep this fast-path only for a non-standard 10-character charset ; the digits
+    # charset uses the generic loop below (leading zeros, bignums, no str/int round-trip)
+    if n == 10 and charset != digits:
+        return "".join(charset[int(x)] for x in str(i))
     while i > 0:
         i, c = divmod(i, n)
         r = charset[c] + r
@@ -148,8 +150,8 @@ def base_decode(input, charset, errors="strict", exc=BaseDecodeError):
     i, n, dec = 0, len(charset), lambda n: base_encode(n, [chr(x) for x in range(256)], errors, exc)
     if n == 1:
         return i2s(len(input))
-    if n == 10:
-        return i2s(int(input)) if charset == digits else "".join(str(charset.index(c)) for c in input)
+    if n == 10 and charset != digits:
+        return "".join(str(charset.index(c)) for c in input)
     for k, c in enumerate(input):
         try:
             i = i * n + charset.index(c)

{codext-1.16.3 → codext-1.16.5}/src/codext/checksums/crc.py

@@ -13,6 +13,7 @@ from ..__common__ import add
 
 CRC = {
     '': {
+        '':              (0x1021, 0xc6c6, True, True, 0, 0xbf05),
         'a':             (0x1021, 0xc6c6, True, True, 0, 0xbf05),
     },
     8: {
@@ -78,6 +79,7 @@ CRC = {
         'mpt1327':       (0x6815, 0, False, False, 1, 0x2566),
     },
     16: {
+        '':              (0x8005, 0, True, True, 0, 0xbb3d),
         'acorn':         (0x1021, 0, False, False, 0, 0x31c3),
         'arc':           (0x8005, 0, True, True, 0, 0xbb3d),
         'atom':          (0x002d, 0, True, True, 0, 0x4287),

{codext-1.16.3 → codext-1.16.5}/src/codext/crypto/__init__.py

@@ -4,6 +4,7 @@ from .atbash import *
 from .bacon import *
 from .barbie import *
 from .citrix import *
+from .playfair import *
 from .phillips import *
 from .polybius import *
 from .railfence import *
@@ -13,4 +14,3 @@ from .shift import *
 from .vic import *
 from .vigenere import *
 from .xor import *
-

{codext-1.16.3 → codext-1.16.5}/src/codext/crypto/phillips.py

@@ -25,7 +25,9 @@ from ..__common__ import *
 
 
 __examples__ = {
+    'dec(phillips)':               None,
     'enc(phillips)':               None,
+    'enc(phillips-key)':           {'ATTACK1': None},
     'enc(phillips-key)':           {'ATTACK': "HUUHLL", 'TESTME': "UFZUSM", 'ABCDEF': "HCLMFA"},
     'enc(phillips-key-5-1-2)':     {'This is a Test String': "KPVBVHTCRHCHCGQBT"},
     'dec(phillips-key-5-1-2)':     {'KPVBVHTCRHCHCGQBT': "THISISATESTSTRING"},
@@ -58,69 +60,45 @@ def __make_grids(key):
     return grids
 
 
-def _shift_text(text, grids, block_size, dh, dv, errors, decode=False):
-    t = ensure_str(text).upper().replace("J", "I")
-    pos_maps = [
-        {ch: (r, c) for r, row in enumerate(grid) for c, ch in enumerate(row)}
-        for grid in grids
-    ]
+def __set_params(key, block_size, dh, dv):
+    return (key or "").strip(), \
+           int(block_size) if block_size else 5, \
+           int(dh) if dh else 1, \
+           int(dv) if dv else 1, \
+           __make_grids(key) if key and key.isalpha() else None
+
+
+def __shift_text(text, grids, block_size, dh, dv, errors, decode=False):
+    pos_maps = [{ch: (r, c) for r, row in enumerate(grid) for c, ch in enumerate(row)} for grid in grids]
+    r, i, t = "", 0, ensure_str(text).upper().replace("J", "I").replace(" ", "")
     _h = handle_error("phillips", errors, decode=decode)
-    r, i = "", 0
     for pos, c in enumerate(t):
-        if c == " ":
-            continue
         if c not in set(_ALPHABET):
             r += _h(c, pos, r)
-            continue
-        grid_idx = (i // block_size) % 8
-        grid = grids[grid_idx]
-        s, col = pos_maps[grid_idx][c]
-        r += grid[(s + dv) % 5][(col + dh) % 5]
-        i += 1
-    return r, len(text)
-
-
-def _make_cipher(key, block_size, dh, dv):
-    _key = (key or "").strip()
-    try:
-        block_size = int(block_size) if block_size else 5
-    except (ValueError, TypeError):
-        raise LookupError(f"Bad parameter for encoding 'phillips': block_size must be an integer, got {block_size}")
-    if not (1 <= block_size <= 25):
-        raise LookupError("Bad parameter for encoding 'phillips': block_size must be between 1 and 25, got "
-                          f"{block_size}")
-    try:
-        dh = int(dh) if dh else 1
-    except (ValueError, TypeError):
-        raise LookupError(f"Bad parameter for encoding 'phillips': dh must be an integer, got {dh}")
-    if not (1 <= dh <= 4):
-        raise LookupError(f"Bad parameter for encoding 'phillips': dh must be between 1 and 4, got {dh}")
-    try:
-        dv = int(dv) if dv else 1
-    except (ValueError, TypeError):
-        raise LookupError(f"Bad parameter for encoding 'phillips': dv must be an integer, got {dv}")
-    if not (1 <= dv <= 4):
-        raise LookupError(f"Bad parameter for encoding 'phillips': dv must be between 1 and 4, got {dv}")
-    return _key, block_size, dh, dv, __make_grids(_key) if _key and _key.isalpha() else None
+        else:
+            grid_idx = (i // block_size) % 8
+            grid = grids[grid_idx]
+            s, col = pos_maps[grid_idx][c]
+            r += grid[(s + dv) % 5][(col + dh) % 5]
+            i += 1
+    return r, len(r)
 
 
 def phillips_encode(key, block_size=None, dh=None, dv=None):
-    _key, block_size, dh, dv, grids = _make_cipher(key, block_size, dh, dv)
+    _key, block_size, dh, dv, grids = __set_params(key, block_size, dh, dv)
     def encode(text, errors="strict"):
-        if grids is None:
-            raise LookupError("Bad parameter for encoding 'phillips': "
-                              "key must be a non-empty alphabetic string")
-        return _shift_text(text, grids, block_size, dh, dv, errors)
+        if _key == "":
+            raise LookupError("Bad parameter for encoding 'phillips': key cannot be empty")
+        return __shift_text(text, grids, block_size, dh, dv, errors)
     return encode
 
 
 def phillips_decode(key, block_size=None, dh=None, dv=None):
-    _key, block_size, dh, dv, grids = _make_cipher(key, block_size, dh, dv)
+    _key, block_size, dh, dv, grids = __set_params(key, block_size, dh, dv)
     def decode(text, errors="strict"):
-        if grids is None:
-            raise LookupError("Bad parameter for decoding 'phillips': "
-                              "key must be a non-empty alphabetic string")
-        return _shift_text(text, grids, block_size, -dh, -dv, errors, True)
+        if _key == "":
+            raise LookupError("Bad parameter for encoding 'phillips': key cannot be empty")
+        return __shift_text(text, grids, block_size, -dh, -dv, errors, True)
     return decode
 
 

codext-1.16.5/src/codext/crypto/playfair.py

@@ -0,0 +1,143 @@
+# -*- coding: UTF-8 -*-
+"""Playfair Cipher Codec - playfair content encoding.
+
+The Playfair cipher is a symmetric encryption method using polygram substitution
+with bigrams (pairs of letters), invented in 1854 by Charles Wheatstone, but
+popularized by his friend Lord Playfair.
+
+This codec:
+- en/decodes strings from str to str
+- en/decodes strings from bytes to bytes
+- decodes file content to str (read)
+- encodes file content from str to bytes (write)
+
+Reference: https://www.dcode.fr/playfair-cipher
+"""
+from string import ascii_uppercase as UC, digits as DG
+
+from ..__common__ import *
+
+
+__examples__ = {
+    'dec(playfair_cipher-testkey-4)': None,
+    'dec(playfair)':                  {'SIHTHTDQCUUTUSHOHW': "THISISATESTSTRINGX", '1a': None, 'a1b': None},
+    'dec(playfair-playfairexample)':  {'BMODZBXDNABEKUDMUIXMMOUVIF': 'HIDETHEGOLDINTHETREXESTUMP'},
+    'enc(playfair-*-5-XQ-IJ)':        {'UDTUTUTGMH': "TESTSTRJNG"},
+    'enc(playfair_cipher-*-5-XX)':    None,
+    'enc(playfair_cipher-*-5-X-JJ)':  None,
+    'enc(playfair)':                  {'String!': None, 'This is a test String': "SIHTHTDQCUUTUSHOHW"},
+    'enc(playfair-*-5-XQ-IJ)':        {'TESTSTRING': "UDTUTUTGMH"},
+    'enc(playfair-playfairexample)':  {'HIDETHEGOLDINTHETREESTUMP': 'BMODZBXDNABEKUDMUIXMMOUVIF'},
+    'enc-dec(playfair-keyword)':      ["TEST"],
+    'enc-dec(playfair-*-5-X-IJ)':     ["TEST", "TESTSENTENCE"],
+}
+__guess__ = ["playfair"]
+
+
+# Standard 5×5 Playfair alphabet (I and J share the same cell)
+_DEFAULT_ALPHABET = {
+    5: UC.replace("J", ""),
+    6: UC + DG,
+}
+
+
+def __build_grid(key=None, grid_size=5, replace_char=('J', 'I')):
+    """Build the Playfair grid from an optional keyword. """
+    seen, grid = set(), []
+    for c in key.upper():
+        if c == replace_char[0]:
+            c = replace_char[1]
+        if c.isalpha() and c not in seen:
+            seen.add(c)
+            grid.append(c)
+    for c in _DEFAULT_ALPHABET[grid_size]:
+        if c not in seen:
+            seen.add(c)
+            grid.append(c)
+    return grid, {grid[i]: (i // grid_size, i % grid_size) for i in range(grid_size ** 2)}
+
+
+def __set_params(key, grid_size, fill_chars, replace_char):
+    if len(fc := str(fill_chars or "XQ").upper()) == 2 and fc[0] == fc[1]:
+        raise LookupError("Bad parameter for encoding 'playfair': filling char must be a single letter or a pair of "
+                          "distinct letters")
+    if len(rc := str(replace_char or "JI").upper()) == 2 and rc[0] == rc[1]:
+        raise LookupError("Bad parameter for encoding 'playfair': replaced char must be a pair of distinct letters")
+    gs = int(grid_size or 5)
+    a = _DEFAULT_ALPHABET[gs]
+    if len(fc) == 1:
+        fc += a[(a.index(fc[0])+1) % len(a)]
+    return (a if key == "*" else a[::-1] if key == "^" else key).upper(), gs, tuple(fc), tuple(rc)
+
+
+def playfair_encode(key=None, grid_size=None, fill_chars=None, replace_char=None):
+    key, gsize, fchars, rchar = __set_params(key, grid_size, fill_chars, replace_char)
+    grid, pos = __build_grid(key, gsize, rchar)
+    def encode(text, errors="strict"):
+        _filler = lambda c: fchars[1] if c == fchars[0] else fchars[0]
+        chars = [rchar[1] if c == rchar[0] else c for c in ensure_str(text).upper().replace(" ", "")]
+        result, i, _h = [], 0, handle_error("playfair", errors)
+        while i < len(chars):
+            a = chars[i]
+            if a not in grid:
+                result.append(_h(a, i))
+                i += 1
+                continue
+            if i + 1 < len(chars):
+                b = chars[i+1]
+                if a == b:
+                    b = _filler(a)
+                else:
+                    i += 1
+            else:
+                b = _filler(a)
+            r_a, c_a = pos[a]
+            r_b, c_b = pos[b]
+            if r_a == r_b:
+                ea, eb = grid[r_a * 5 + (c_a + 1) % 5], grid[r_b * 5 + (c_b + 1) % 5]
+            elif c_a == c_b:
+                ea, eb = grid[((r_a + 1) % 5) * 5 + c_a], grid[((r_b + 1) % 5) * 5 + c_b]
+            else:
+                ea, eb = grid[r_a * 5 + c_b], grid[r_b * 5 + c_a]
+            result.extend([ea, eb])
+            i += 1
+        return (r := "".join(result)), len(r)
+    return encode
+
+
+def playfair_decode(key=None, grid_size=None, fill_chars=None, replace_char=None):
+    key, gsize, _, rchar = __set_params(key, grid_size, fill_chars, replace_char)
+    grid, pos = __build_grid(key, gsize, rchar)
+    def decode(text, errors="strict"):
+        chars = [rchar[1] if c == rchar[0] else c for c in ensure_str(text)]
+        result, i, _h = [], 0, handle_error("playfair", errors, decode=True)
+        while i < len(chars):
+            try:
+                r_a, c_a = pos[chars[i]]
+            except KeyError:
+                result.append(_h(chars[i], i, "".join(result)))
+                i += 1
+                continue
+            try:
+                r_b, c_b = pos[chars[i+1]]
+            except KeyError:
+                result.append(chars[i])
+                result.append(_h(chars[i+1], i+1, "".join(result)))
+                i += 2
+                continue
+            if r_a == r_b:
+                da, db = grid[r_a * 5 + (c_a - 1) % 5], grid[r_b * 5 + (c_b - 1) % 5]
+            elif c_a == c_b:
+                da, db = grid[((r_a - 1) % 5) * 5 + c_a], grid[((r_b - 1) % 5) * 5 + c_b]
+            else:
+                da, db = grid[r_a * 5 + c_b], grid[r_b * 5 + c_a]
+            result.extend([da, db])
+            i += 2
+        return (r := "".join(result)), len(r)
+    return decode
+
+
+add("playfair", playfair_encode, playfair_decode,
+    r"^playfair(?:[-_]cipher)?(?:[-_]([\^*]|[a-zA-Z]+))?(?:[-_]([56]))?(?:[-_]([A-Z]{1,2}))?(?:[-_]([A-Z]{2}))?$",
+    printables_rate=1., penalty=.1)
+

{codext-1.16.3 → codext-1.16.5}/src/codext/crypto/polybius.py

@@ -11,6 +11,8 @@ from ..__common__ import *
 
 
 __examples__ = {
+    'enc(polybius-ABCDEFGHIKLMNOPQRSTUVZZZZ)':       None,
+    'dec(polybius)':                                 {'4423244 24': None},
     'enc(polybius|polybius-square|polybius_square)': {'this is a test': "44232443 2443 11 44154344"},
     'enc(polybius-ABCDEFGHIKLMNOPQRSTUVWXYZ)':       {'this is a test': "44232443 2443 11 44154344"},
     'dec(polybius)':                                 {'44232443 2443 11 44154344': "THIS IS A TEST"},
@@ -59,15 +61,12 @@ def polybius_decode(alphabet=_DEFAULT_ALPHABET):
         _h = handle_error("polybius", errors, decode=True)
         r, t, i = "", ensure_str(text), 0
         while i < len(t):
-            if t[i] == " ":
-                r += " "
-                i += 1
-            elif i + 1 < len(t):
+            if t[i:i+2].isdigit():
                 r += decmap.get(t[i:i+2]) or _h(t[i:i+2], i, r)
-                i += 2
-            else:
-                r += _h(t[i], i, r)
                 i += 1
+            else:
+                r += " " if t[i] == " " else _h(t[i], i, r)
+            i += 1
         return r, len(t)
     return decode
 

{codext-1.16.3 → codext-1.16.5}/src/codext/crypto/vic.py

@@ -137,6 +137,6 @@ def vic_decode(key=None, blanks=None, numeric_key=None):
     return _decode
 
 
-add("vic", vic_encode, vic_decode, r"vic(?:[-_]([\^*./a-zA-Z]+))?(?:[-_]([0-9]{2}))?(?:[-_]([0-9]+T?))?$",
+add("vic", vic_encode, vic_decode, r"vic(?:[-_]([\^*]|[./a-zA-Z]+))?(?:[-_]([0-9]{2}))?(?:[-_]([0-9]+T?))?$",
     printables_rate=1., penalty=.1)
 

{codext-1.16.3 → codext-1.16.5}/src/codext/hashing/crypt.py

@@ -13,10 +13,10 @@ from ..__common__ import add, ensure_str, UNIX
 
 if UNIX:
     try:
-        import crypt
+        import legacycrypt as crypt
     except ImportError:
         try:
-            import legacycrypt as crypt
+            import crypt
         except ImportError:
             crypt = None
     

{codext-1.16.3 → codext-1.16.5}/src/codext/languages/ipsum.py

@@ -13,8 +13,9 @@ from ..__common__ import *
 
 
 __examples__ = {
-    'enc-dec(ipsum|lorem-ipsum)': ["This is a test !"],
+    'dec(lorem_ipsum)':           {'orci #': None, 'Auctor babel commodo#': None},
     'enc(ipsum)':                 {'Bad test#': None},
+    'enc-dec(ipsum|lorem-ipsum)': ["This is a test !"],
 }
 
 
@@ -59,7 +60,7 @@ SCHARS = "0123456789.,:;!?+=-*/\\"
 
 
 def ipsum_encode(text, errors="strict"):
-    s, strip = "", False
+    s, strip, _h = "", False, handle_error("ipsum", errors, " ")
     for i, c in enumerate(text):
         try:
             if c == " " or c in SCHARS:
@@ -70,13 +71,12 @@ def ipsum_encode(text, errors="strict"):
                 s += (w.capitalize() if c.isupper() else w) + " "
                 strip = True
         except KeyError:
-            s += handle_error("ipsum", errors, " ")(c, i)
-    return s[:-1] if strip else s, len(text)
+            s += _h(c, i, s)
+    return (s := s[:-1] if strip else s), len(s)
 
 
 def ipsum_decode(text, errors="strict"):
-    s = ""
-    words = text.split(" ")
+    s, words, _h = "", text.split(" "), handle_error("ipsum", errors, decode=True, item="word")
     for i, w in enumerate(words[:-1] if words[-1] == "" else words):
         if w.strip() == "":
             s += " "
@@ -88,8 +88,8 @@ def ipsum_decode(text, errors="strict"):
                     raise KeyError
                 s += w[:len(w)-len(w.lstrip(SCHARS))] + w.strip(SCHARS)[0] + w[len(w.rstrip(SCHARS)):len(w)]
             except KeyError:
-                s += handle_error("ipsum", errors, decode=True, item="word")(w, i)
-    return s, len(text)
+                s += _h(w, i, s)
+    return s, len(s)
 
 
 add("ipsum", ipsum_encode, ipsum_decode, pattern=r"^(?:lorem[-_]?)?ipsum$", printables_rate=1.,

{codext-1.16.3 → codext-1.16.5}/src/codext/others/uuencode.py

@@ -13,10 +13,10 @@ from ..__common__ import *
 
 
 __examples__ = {
-    'enc(uu|uu_codec)': {'this is a test': "begin 666 -\n.=&AI<R!I<R!A('1E<W0 \n \nend\n"},
-    'dec(uu-encode)':   {'.=&AI<R!I<R!A(\'1E<W0 ': "this is a test", '.=&AI<R!I<R!A(\'1E<W0`': "this is a test"},
     'dec(uu-codec)':    {'begin 666 -\n.=&AI<R!I<R!A(\'1E<W0`': None, '.=&AI<R!I<R!A(\'1E<W0`\n\n\n`\nend': None},
     'dec(uu_codec)':    {'begin 777 test.txt\n.=&AI<R!I<R!A(\'1E<W0`\n\n\n`\nend': "this is a test"},
+    'dec(uu-encode)':   {'.=&AI<R!I<R!A(\'1E<W0 ': "this is a test", '.=&AI<R!I<R!A(\'1E<W0`': "this is a test"},
+    'enc(uu|uu_codec)': {'this is a test': "begin 666 -\n.=&AI<R!I<R!A('1E<W0 \n \nend\n"},
     'enc-dec(uu)':      ["begin 666 -\n.=&AI<R!I<R!A(\'1E<W0`", "@random{512,1024,2048}"],
 }
 
@@ -25,11 +25,11 @@ def uu_encode(text, errors="strict"):
     r, t = b"begin 666 -\n", b(text)
     for i in range(0, len(t), 45):
         r += _enc(t[i:i+45])
-    return r + b" \nend\n", len(text)
+    return (r := r + b" \nend\n"), len(r)
 
 
 def uu_decode(text, errors="strict"):
-    h = handle_error("uu", "strict", decode=True, kind="token", item="line")
+    _h = handle_error("uu", "strict", decode=True, kind="token", item="line")
     lines = b(text).strip(b" \t\r\n\f").split(b"\n")
     start, end = re.match(b"^begin [1-7]{3} .*$", lines[0]), re.match(b"^end$", lines[-1])
     if start and end:
@@ -40,15 +40,15 @@ def uu_decode(text, errors="strict"):
         if errors == "ignore":
             lines = lines[1:] if start else lines[:-1]
         elif end:
-            h(lines[0], 0)
+            _h(lines[0], 0)
         elif start:
-            h(lines[-1], len(lines)-1)
+            _h(lines[-1], len(lines)-1)
     while len(lines) > 0 and lines[-1].strip(b" \t\r\n\f") in [b"", b"`"]:
         lines = lines[:-1]
     r = b""
     for l in lines:
         r += _dec(l.strip(b" \t\r\n\f"))
-    return r, len(text)
+    return r, len(r)
 
 
 add("uu", uu_encode, uu_decode, pattern=r"^uu(?:[-_]?encode|[-_]codec)?$",

{codext-1.16.3 → codext-1.16.5}/src/codext/stegano/hexagram.py

@@ -11,6 +11,7 @@ from ..__common__ import *
 
 
 __examples__ = {
+    'dec(hexagram)':                          {'䷕䷞䷈䷇t': None},
     'enc(hexagram|iching|i-ching-hexagrams)': {'this is a test': "䷰䷭䷚䷔䷞䷺䷗䷔䷞䷺䷗䷚䷏䷊䷂䷕䷞䷈䷇☯"},
 }
 
@@ -25,13 +26,13 @@ def hexagram_encode(input, errors="strict"):
 
 
 def hexagram_decode(input, errors="strict"):
-    r, ehandler = "", handle_error("hexagram", errors, decode=True)
+    r, _h = "", handle_error("hexagram", errors, decode=True)
     for i, c in enumerate(input):
         try:
             r += DECMAP[c]
         except KeyError:
-            r += ehandler(c, i, r)
-    return codecs.decode(r, "base64"), len(input)
+            r += _h(c, i, r)
+    return (r := codecs.decode(r, "base64")), len(r)
 
 
 add("hexagram", hexagram_encode, hexagram_decode, printables_rate=0.,

{codext-1.16.3 → codext-1.16.5}/src/codext/stegano/whitespace.py

@@ -18,6 +18,11 @@ __examples1__ = {
     'enc(whitespace|whitespaces)':             {'test': "\t   \t \t\t\t  \t\t \t \t   \t\t  \t   \t \t\t"},
     'enc(whitespace-inv|whitespace_inverted)': {'test': " \t\t\t \t   \t\t  \t \t \t\t\t  \t\t \t\t\t \t  "},
 }
+__examples2__ = {
+    'dec(whitespace+after-before)':     {'}         \n      a  \n  .   v  ': None},
+    'enc(whitespace+after-before)':     {'Test\r': None},
+    'enc-dec(whitespace+after-before)': ["Test", "TESTSTRING!"],
+}
 __guess1__ = ["whitespace", "whitespace-inv"]
 __guess2__ = ["whitespace+after-before", "whitespace-after+before"]
 
@@ -30,42 +35,38 @@ add_map("whitespace", ENCMAP, intype="bin", pattern=r"^whitespaces?([-_]inv(?:er
 def wsba_encode(p):
     eq = "ord(c)" + p
     def encode(text, errors="strict"):
-        r = []
+        r, _h = [], handle_error("whitespace" + p, errors, repl_char="\x00")
         for i, c in enumerate(text):
             if ord(c) < min(ord(c) for c in printable[:-6]):
-                r.append(handle_error("whitespace" + p, errors, repl_char="\x00")(c, i))
-                continue
-            enc = "\x00"
-            offset = random.randint(-10,10)
-            while enc not in printable[:-6]:
-                after = random.randint(0, 20)
-                before = random.randint(0, 20)
-                enc = chr(eval(eq) % 256)
-            r.append(" " * before + enc + " " * after)
-        s = "\n".join(r)
-        return s, len(s)
+                r.append(_h(c, i))
+            else:
+                enc, offset = "\x00", random.randint(-10,10)
+                while enc not in printable[:-6]:
+                    after, before = random.randint(0, 20), random.randint(0, 20)
+                    enc = chr(eval(eq) % 256)
+                r.append(" " * before + enc + " " * after)
+        return (s := "\n".join(r)), len(s)
     return encode
 
 
 def wsba_decode(p):
     eq = "ord(c)" + "".join({'-':"+",'+':"-"}.get(c, c) for c in p)
     def decode(text, errors="strict"):
-        s = ""
+        s, _h = "", handle_error("whitespace_after_before", errors, decode=True, item="line")
         for i, l in enumerate(text.split("\n")):
-            ll = len(l.strip())
-            if ll == 0:
+            if (ll := len(l.strip())) == 0:
                 continue
             if ll > 1:
-                s += handle_error("whitespace_after_before", errors, decode=True, item="line")(l, i)
-            after = len(l) - len(l.rstrip(" "))
-            before = len(l) - len(l.lstrip(" "))
+                s += _h(l, i)
+            after, before = len(l) - len(l.rstrip(" ")), len(l) - len(l.lstrip(" "))
             c = l[before]
             s += chr(eval(eq))
-        return s, len(text)
+        return s, len(s)
     return decode
 
 
 op = r"[+-](?:\d+(?:\.\d+)?[*/])?"
-add("whitespace_after_before", wsba_encode, wsba_decode, guess=__guess2__, entropy=1., printables_rate=1., penalty=.1,
-    expansion_factor=(22., 3.), pattern=r"whitespace("+op+r"before"+op+r"after|"+op+r"after"+op+r"before)$")
+add("whitespace_after_before", wsba_encode, wsba_decode, examples=__examples2__, guess=__guess2__,
+    printables_rate=1., penalty=.1, expansion_factor=(22., 3.), entropy=1.,
+    pattern=r"whitespace("+op+r"before"+op+r"after|"+op+r"after"+op+r"before)$")
 

{codext-1.16.3 → codext-1.16.5}/src/codext.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codext
-Version: 1.16.3
+Version: 1.16.5
 Summary: Native codecs extension
 Author-email: Alexandre D'Hondt <alexandre.dhondt@gmail.com>
 License:                     GNU GENERAL PUBLIC LICENSE
@@ -1034,6 +1034,7 @@ This category also contains `ascii85`, `adobe`, `[x]btoa`, `zeromq` with the `ba
 - [X] `barbie-N`: aka Barbie Typewriter (*N* belongs to [1, 4])
 - [X] `beaufort`: aka Beaufort Cipher (variant of Vigenere Cipher)
 - [X] `citrix`: aka Citrix CTX1 password encoding
+- [X] `playfair`: aka Playfair Cipher
 - [X] `phillips`: aka Phillips Cipher (polyalphabetic block cipher with 8 key squares)
 - [X] `polybius`: aka Polybius Square Cipher
 - [X] `railfence`: aka Rail Fence Cipher

{codext-1.16.3 → codext-1.16.5}/src/codext.egg-info/SOURCES.txt

@@ -12,6 +12,7 @@ requirements.txt
 .github/prompts/add_codec.prompt.md
 .github/workflows/python-package.yml
 docs/coverage.svg
+docs/hakin9-codext.pdf
 docs/mkdocs.yml
 docs/requirements.txt
 docs/pages/cli.md
@@ -86,6 +87,7 @@ src/codext/crypto/bacon.py
 src/codext/crypto/barbie.py
 src/codext/crypto/citrix.py
 src/codext/crypto/phillips.py
+src/codext/crypto/playfair.py
 src/codext/crypto/polybius.py
 src/codext/crypto/railfence.py
 src/codext/crypto/rot.py

{codext-1.16.3 → codext-1.16.5}/tests/test_base.py

@@ -112,7 +112,30 @@ class TestCodecsBase(TestCase):
         self.assertEqual(codecs.decode(B8, "base8-01234567"), STR)
         self.assertRaises(LookupError, codecs.encode, "test", "base8-0123456")
         self.assertRaises(LookupError, codecs.encode, "test", "base8-012345678")
-    
+
+    def test_codec_base10(self):
+        B10 = "2361031878030638688519054699098996"
+        self.assertEqual(codecs.encode(STR, "base10"), B10)
+        self.assertEqual(codecs.encode(b(STR), "base10"), b(B10))
+        self.assertEqual(codecs.decode(B10, "base10"), STR)
+        self.assertEqual(codecs.decode(b(B10), "base10"), b(STR))
+        for alias in ["int", "integer", "dec", "decimal"]:
+            self.assertEqual(codecs.encode(STR, alias), B10)
+            self.assertEqual(codecs.decode(B10, alias), STR)
+        # leading null bytes must be preserved as leading '0' characters
+        self.assertEqual(codecs.encode("\x00abc", "base10"), "06382179")
+        self.assertEqual(codecs.encode("\x00", "base10"), "0")
+        self.assertEqual(codecs.encode("\x00\x00abc", "base10"), "006382179")
+        self.assertEqual(codecs.decode("06382179", "base10"), "\x00abc")
+        self.assertEqual(codecs.decode("00", "base10"), "\x00\x00")
+        self.assertEqual(codecs.encode(b("\x00abc"), "base10"), b("06382179"))
+        self.assertEqual(codecs.decode(b("06382179"), "base10"), b("\x00abc"))
+        # a value whose big integer ends in a 0xe nibble must survive decoding
+        self.assertEqual(codecs.decode(codecs.encode(b"d\xc6\xfe", "base10"), "base10"), b"d\xc6\xfe")
+        # large inputs must not hit the int<->str conversion digit limit
+        for data in [b"\x00\xff\xfe", b"\x00\x00", b"\x2a" * 2048]:
+            self.assertEqual(codecs.decode(codecs.encode(data, "base10"), "base10"), data)
+
     def test_codec_base16(self):
         B16 = "7468697320697320612074657374"
         self.assertEqual(codecs.encode(STR, "base16"), B16)

{codext-1.16.3 → codext-1.16.5}/tests/test_manual.py

@@ -106,6 +106,25 @@ class ManualTestCase(TestCase):
         for s, r in [("", ""), ("0", "0"), ("1", "8"), ("7992739871", "3")]:
             self.assertEqual(codecs.encode(s, "luhn"), r)
         self.assertEqual(codecs.encode("-", "luhn", errors="ignore"), "")
+
+    def test_codec_crc_bare_defaults(self):
+        # a crc<width> used without a variant suffix must resolve to that family's default ;
+        # width 16 and the crc-a family had no default and crashed with KeyError instead
+        from codext.checksums.crc import CRC
+        for n in CRC.keys():
+            name = "crc%d" % n if isinstance(n, int) else "crc"
+            expected = "%0{}x".format(round((n or 16)/4+.5)) % CRC[n][""][5]
+            self.assertEqual(codecs.encode("123456789", name), expected)
+            self.assertEqual(codecs.encode(b"123456789", name), b(expected))
+        # bare crc-16 is CRC-16/ARC (poly 0x8005), the same as its arc/ibm/lha aliases
+        for name in ["crc16", "crc-16", "crc_16", "crc16-arc", "crc16-ibm", "crc16-lha"]:
+            self.assertEqual(codecs.encode("123456789", name), "bb3d")
+        # bare crc is CRC-A, the same as the crca alias
+        self.assertEqual(codecs.encode("123456789", "crc"), "bf05")
+        self.assertEqual(codecs.encode("123456789", "crca"), "bf05")
+        # adding a default must not make an unknown variant resolve
+        self.assertRaises(LookupError, codecs.encode, "123456789", "crc16-bad")
+        self.assertRaises(LookupError, codecs.encode, "123456789", "crc-bad")
     
     def test_codec_dummy_str_manips(self):
         STR = "this is a test"
@@ -152,8 +171,7 @@ class ManualTestCase(TestCase):
             METHODS = [x[7:].lower() for x in crypt.__dict__ if x.startswith("METHOD_")] \
                       if crypt is not None else []
             for m in METHODS:
-                h = "crypt-" + m
-                self.assertIsNotNone(codecs.encode(STR, h))
+                self.assertIsNotNone(codecs.encode(STR, h := f"crypt-{m}"))
                 self.assertRaises(NotImplementedError, codecs.decode, STR, h)
     
     def test_codec_markdown(self):

codext-1.16.3/src/codext/VERSION.txt

@@ -1 +0,0 @@
-1.16.3