Improved codec: playfair

Author: dhondta

src/codext/VERSION.txt

@@ -1 +1 @@
-1.16.3
+1.16.4

src/codext/crypto/playfair.py

@@ -13,126 +13,131 @@
 
 Reference: https://www.dcode.fr/playfair-cipher
 """
+from string import ascii_uppercase as UC, digits as DG
+
 from ..__common__ import *
 
 
 __examples__ = {
-    # Classic example from Wikipedia (key "PLAYFAIR EXAMPLE"):
-    #   the EE in "TREE" is split with an X filler during encoding, so decoding
-    #   exposes the filler: "TREESTUMP" → encoded → decoded as "TREXESTUMP"
-    'enc(playfair-playfairexample)': {'HIDETHEGOLDINTHETREESTUMP': 'BMODZBXDNABEKUDMUIXMMOUVIF'},
-    'dec(playfair-playfairexample)': {'BMODZBXDNABEKUDMUIXMMOUVIF': 'HIDETHEGOLDINTHETREXESTUMP'},
-    'enc-dec(playfair-keyword)':     ['INSTRUMENT'],
+    '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 = "ABCDEFGHIKLMNOPQRSTUVWXYZ"
+_DEFAULT_ALPHABET = {
+    5: UC.replace("J", ""),
+    6: UC + DG,
+}
 
 
-def _build_grid(key=None):
-    """Build the 5×5 Playfair grid from an optional keyword."""
+def __build_grid(key=None, grid_size=5, replace_char=('J', 'I')):
+    """Build the Playfair grid from an optional keyword. """
     seen, grid = set(), []
-    if key:
-        for c in key.upper():
-            if c == 'J':
-                c = 'I'
-            if c.isalpha() and c not in seen:
-                seen.add(c)
-                grid.append(c)
-    for c in _DEFAULT_ALPHABET:
+    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)
-    pos = {grid[i]: (i // 5, i % 5) for i in range(25)}
-    return grid, pos
-
-
-def _filler(c):
-    """Return the filler character for a given letter (X, or Q when the letter is X)."""
-    return 'Q' if c == 'X' else 'X'
-
-
-def _make_bigrams(text):
-    """Convert plaintext to bigrams, inserting fillers for repeated-letter pairs."""
-    chars = []
-    for c in ensure_str(text).upper():
-        if c == 'J':
-            chars.append('I')
-        elif c.isalpha():
-            chars.append(c)
-    bigrams = []
-    i = 0
-    while i < len(chars):
-        a = chars[i]
-        if i + 1 < len(chars):
-            b = chars[i + 1]
-            if a == b:
-                bigrams.append((a, _filler(a)))
-                i += 1
-            else:
-                bigrams.append((a, b))
-                i += 2
-        else:
-            bigrams.append((a, _filler(a)))
-            i += 1
-    return bigrams
-
+    return grid, {grid[i]: (i // grid_size, i % grid_size) for i in range(grid_size ** 2)}
 
-def _encode_bigram(grid, pos, a, b):
-    r_a, c_a = pos[a]
-    r_b, c_b = pos[b]
-    if r_a == r_b:
-        return grid[r_a * 5 + (c_a + 1) % 5], grid[r_b * 5 + (c_b + 1) % 5]
-    elif c_a == c_b:
-        return grid[((r_a + 1) % 5) * 5 + c_a], grid[((r_b + 1) % 5) * 5 + c_b]
-    else:
-        return grid[r_a * 5 + c_b], grid[r_b * 5 + c_a]
 
+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 _decode_bigram(grid, pos, a, b):
-    r_a, c_a = pos[a]
-    r_b, c_b = pos[b]
-    if r_a == r_b:
-        return grid[r_a * 5 + (c_a - 1) % 5], grid[r_b * 5 + (c_b - 1) % 5]
-    elif c_a == c_b:
-        return grid[((r_a - 1) % 5) * 5 + c_a], grid[((r_b - 1) % 5) * 5 + c_b]
-    else:
-        return grid[r_a * 5 + c_b], grid[r_b * 5 + c_a]
 
-
-def playfair_encode(key=None):
-    grid, pos = _build_grid(key)
+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"):
-        t = ensure_str(text)
-        result = []
-        for a, b in _make_bigrams(t):
-            ea, eb = _encode_bigram(grid, pos, a, b)
+        _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])
-        r = "".join(result)
-        return r, len(t)
+            i += 1
+        return (r := "".join(result)), len(r)
     return encode
 
 
-def playfair_decode(key=None):
-    grid, pos = _build_grid(key)
+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"):
-        t = ensure_str(text)
-        chars = []
-        for c in t.upper():
-            if c == 'J':
-                chars.append('I')
-            elif c.isalpha():
-                chars.append(c)
-        result = []
-        for i in range(0, len(chars) - 1, 2):
-            da, db = _decode_bigram(grid, pos, chars[i], chars[i + 1])
+        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])
-        r = "".join(result)
-        return r, len(t)
+            i += 2
+        return (r := "".join(result)), len(r)
     return decode
 
 
-add("playfair", playfair_encode, playfair_decode, r"^playfair(?:[-_]cipher)?(?:[-_]([a-zA-Z]+))?$",
-    printables_rate=1.)
+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)
+

src/codext/crypto/vic.py

@@ -137,6 +137,6 @@ def _decode(text, errors="strict"):
     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)