Refined codec: vigenere (2)

Author: dhondta

README.md

@@ -282,6 +282,7 @@ This category also contains `ascii85`, `adobe`, `[x]btoa`, `zeromq` with the `ba
 
 - [X] `affine`: aka Affine Cipher
 - [X] `atbash`: aka Atbash Cipher
+- [X] `autoclave`: aka Autoclave/Autokey Cipher (variant of Vigenere Cipher)
 - [X] `bacon`: aka Baconian Cipher
 - [X] `barbie-N`: aka Barbie Typewriter (*N* belongs to [1, 4])
 - [X] `beaufort`: aka Beaufort Cipher (variant of Vigenere Cipher)

docs/pages/enc/crypto.md

@@ -71,6 +71,23 @@ It implements the monoalphabetic substitution cipher used for the Hebrew alphabe
 
 -----
 
+### Autoclave/Autokey Cipher
+
+This is a variant of the [Vigenere Cipher](#vigenere-cipher) using a key stream generated from the primer key and the message appended.
+
+**Codec** | **Conversions** | **Aliases** | **Comment**
+:---: | :---: | --- | ---
+`autoclave` | text <-> Autoclave ciphertext | `autoclave-cipher`, `autokey` | 
+
+```python
+>>> codext.encode("This is a test !", "autoclave-test")
+'Mlal bz i lmkt !'
+>>> codext.decode("Mlal bz i lmkt !", "autokey_cipher-test")
+'This is a test !'
+```
+
+-----
+
 ### Baconian Cipher
 
 It support only letters.

src/codext/crypto/vigenere.py

@@ -11,54 +11,77 @@
 
 from ..__common__ import *
 
-__examples__ = {
-    'enc(beaufort)':             None,
-    'enc(beaufort-lemon)':       {'ATTACKATDAWN': 'LLTOLBETLNPR'},
-    'enc(beaufort-key)':         {'hello': 'danzq'},
-    'enc(beaufort_key)':         {'Hello World': 'Danzq Cwnnh'},
-    'enc(trithemius-cipher)':    {'this is a test': "tikv mx g ambd"},
-    'enc(trithemius)':           {'HELLO': "HFNOS", '12345!@#$': "12345!@#$"},
-    'enc(vigenere)':             None,
-    'enc(vigenere-lemon)':       {'ATTACKATDAWN': 'LXFOPVEFRNHR'},
-    'enc(vigenere-key)':         {'hello': 'rijvs'},
-    'enc(vigenère_key)':         {'Hello World': 'Rijvs Uyvjn'},
-    'enc-dec(beaufort-secret)':  ['hello world', 'ATTACK AT DAWN', 'Test 1234!'],
-    'enc-dec(trithemius)':       ["Hello, World!", "@random"],
-    'enc-dec(vigenere-secret)':  ['hello world', 'ATTACK AT DAWN', 'Test 1234!'],
+__examples1__ = {
+    'enc(autoclave)':         None,
+    'enc(autokey-queenly)':   {'ATTACKATDAWN': 'QNXEPVYTWTWP'},
+    'enc-dec(autoclave-key)': ['hello world', 'ATTACK AT DAWN', 'Test 1234!', 'Mixed Case 123'],
 }
-__guess__ = ["beaufort-key", "beaufort-secret", "beaufort-password", "trithemius",
-             "vigenere-key", "vigenere-secret", "vigenere-password"]
+__examples2__ = {
+    'enc(beaufort)':            None,
+    'enc(beaufort-lemon)':      {'ATTACKATDAWN': 'LLTOLBETLNPR'},
+    'enc(beaufort-key)':        {'hello': 'danzq'},
+    'enc(beaufort_key)':        {'Hello World': 'Danzq Cwnnh'},
+    'enc-dec(beaufort-secret)': ['hello world', 'ATTACK AT DAWN', 'Test 1234!'],
+}
+__examples3__ = {
+    'enc(trithemius-cipher)': {'this is a test': "tikv mx g ambd"},
+    'enc(trithemius)':        {'HELLO': "HFNOS", '12345!@#$': "12345!@#$"},
+    'enc-dec(trithemius)':    ["Hello, World!", "@random"],
+}
+__examples4__ = {
+    'enc(vigenere)':            None,
+    'enc(vigenere-lemon)':      {'ATTACKATDAWN': 'LXFOPVEFRNHR'},
+    'enc(vigenere-key)':        {'hello': 'rijvs'},
+    'enc(vigenère_key)':        {'Hello World': 'Rijvs Uyvjn'},
+    'enc-dec(vigenere-secret)': ['hello world', 'ATTACK AT DAWN', 'Test 1234!'],
+}
+__guess1__ = ["autoclave-key", "autoclave-password", "autoclave-secret"]
+__guess2__ = ["beaufort-key", "beaufort-password", "beaufort-secret"]
+__guess3__ = ["trithemius"]
+__guess4__ = ["vigenere-key", "vigenere-password", "vigenere-secret"]
+
+
+bchar = lambda c, k, i, d=False: (LC if (b := c in LC) else UC)[(ord(k[i % len(k)]) - ord('a') - \
+                                                                 (ord(c) - ord("Aa"[b]))) % 26]
+vchar = lambda c, k, i, d=False: (LC if (b := c in LC) else UC)[(ord(c) - ord("Aa"[b]) + \
+                                                                 [1, -1][d] * (ord(k[i % len(k)]) - ord('a'))) % 26]
 
 
-def __make(enc, cfunc):
-    def code(decode=False):
+def __make(enc, char_func, key_stream=False):
+    def _code(decode=False):
         def _wrapper(key):
             def _subwrapper(text, errors="strict"):
-                k = key.lower()
-                if not k or not k.isalpha():
+                if not (k := key.lower()) or not k.isalpha():
                     raise LookupError(f"Bad parameter for encoding '{enc}': key must be a non-empty alphabetic string")
+                if key_stream and not decode:
+                    k += "".join(c.lower() for c in ensure_str(text) if c in LC or c in UC)
                 result, i = [], 0
+                if key_stream and decode:
+                    k = list(k)
                 for c in ensure_str(text):
                     if c in LC or c in UC:
-                        result.append(cfunc(c, k, i, decode))
+                        result.append(dc := char_func(c, k, i, decode))
+                        if key_stream and decode:
+                            k.append(dc.lower())
                         i += 1
                     else:
                         result.append(c)
-                r = "".join(result)
-                return r, len(r)
+                return (r := "".join(result)), len(r)
             return _subwrapper
         return _wrapper
-    return code(), code(True)
+    return _code(), _code(True)
 
 
-bchar = lambda c, k, i, d=False: (LC if (b := c in LC) else UC)[(ord(k[i % len(k)]) - ord('a') - \
-                                                                 (ord(c) - ord("Aa"[b]))) % 26]
-add("beaufort", *__make("beaufort", bchar), r"beaufort(?:[-_]cipher)?(?:[-_]([a-zA-Z]+))?$", penalty=.1)
+add("autoclave", *__make("autoclave", vchar, True), r"auto(?:clave|key)(?:[-_]cipher)?(?:[-_]([a-zA-Z]+))?$",
+    examples=__examples1__, guess=__guess1__, penalty=.1)
+
+add("beaufort", *__make("beaufort", bchar), r"beaufort(?:[-_]cipher)?(?:[-_]([a-zA-Z]+))?$",
+    examples=__examples2__, guess=__guess2__, penalty=.1)
 
-vchar = lambda c, k, i, d=False: (LC if (b := c in LC) else UC)[(ord(c) - ord("Aa"[b]) + \
-                                                                 [1, -1][d] * (ord(k[i % len(k)]) - ord('a'))) % 26]
 enc, dec = __make("trithemius", vchar)
-add("trithemius", enc(k := "ABCDEFGHIJKLMNOPQRSTUVWXYZ"), dec(k), r"trithemius(?:[-_]cipher)?$", penalty=.1)
+add("trithemius", enc(k := "ABCDEFGHIJKLMNOPQRSTUVWXYZ"), dec(k), r"trithemius(?:[-_]cipher)?$",
+    examples=__examples3__, guess=__guess3__, penalty=.1)
 
-add("vigenere", *__make("vigenere", vchar), r"vigen[eè]re(?:[-_]cipher)?(?:[-_]([a-zA-Z]+))?$", penalty=.1)
+add("vigenere", *__make("vigenere", vchar), r"vigen[eè]re(?:[-_]cipher)?(?:[-_]([a-zA-Z]+))?$",
+    examples=__examples4__, guess=__guess4__, penalty=.1)