codext 1.16.0__tar.gz → 1.16.2__tar.gz

{codext-1.16.0 → codext-1.16.2}/.github/workflows/python-package.yml

@@ -18,12 +18,14 @@ jobs:
     runs-on: ubuntu-latest
     outputs:
       package: ${{ steps.pkg.outputs.package }}
+      pypi_url: ${{ steps.pkg.outputs.pypi_url }}
     steps:
       - name: Compute package name from the repository's
         id: pkg
         run: |
           name="${GITHUB_REPOSITORY##*/}"
           echo "package=${name#python-}" >> $GITHUB_OUTPUT
+          echo "pypi_url=https://pypi.org/p/${name#python-}" >> $GITHUB_OUTPUT
   build:
     needs: prepare
     runs-on: ${{ matrix.os }}
@@ -63,7 +65,7 @@ jobs:
     - uses: actions/checkout@v5
       with:
         fetch-depth: 0
-        ref: ${{ github.head_ref || github.ref_name }}
+        ref: ${{ (github.event_name == 'pull_request' || github.event_name == 'pull_request_target') && github.event.pull_request.head.sha || github.sha }}
     - name: Set up Python ${{ env.python_version }}
       uses: actions/setup-python@v6
       with:
@@ -96,6 +98,9 @@ jobs:
         git commit -m "Update coverage badge"
         git push origin coverage-badge --force
   deploy:
+    environment:
+      name: pypi
+      url: ${{ needs.prepare.outputs.pypi_url }}
     runs-on: ubuntu-latest
     needs: [prepare, coverage]
     steps:

{codext-1.16.0 → codext-1.16.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codext
-Version: 1.16.0
+Version: 1.16.2
 Summary: Native codecs extension
 Author-email: Alexandre D'Hondt <alexandre.dhondt@gmail.com>
 License:                     GNU GENERAL PUBLIC LICENSE
@@ -779,6 +779,8 @@ example-macro
 
 ## //img.shields.io/badge/Tweet%20(unbase)--lightgrey?logo=twitter&style=social" alt="Tweet on unbase" height="20"/></a>
 
+Playing with base encodings.
+
 ```session
 $ echo "Test string !" | base122
 *.7!ft9�-f9Â
@@ -804,9 +806,63 @@ $ echo "Test string !" | base91 | base85 | base36 | base58-flickr | unbase -f Te
 Test string !
 ```
 
+## Usage (CLI)
+
+Listing codecs.
+
+```session
+$ codext list encodings
+a1z26                      adler32               affine             alternative-rot        ascii           
+atbash                     autoclave             bacon              barbie                 base            
+base1                      base2                 base3              base4                  base8           
+<<snipped>>
+```
+
+Finding a codec based on a name.
+
+```session
+$ codext search bitcoin
+base58
+```
+
+Encoding a string.
+
+```sesssion
+$ echo -en "This is a test" | codext encode polybius
+44232443 2443 11 44154344
+```
+
+Encoding a file.
+
+```session
+$ echo -en "this is a test" > to_be_encoded.txt
+$ codext encode base64 < to_be_encoded.txt > text.b64
+$ cat text.b64 
+dGhpcyBpcyBhIHRlc3Q=
+```
+
+Chaining codecs.
+
+```session
+$ echo -en "mrdvm6teie6t2cq=" | codext encode upper | codext decode base32 | codext decode base64
+test
+```
+
+Iteratively guessing decodings.
+
+```session
+$ echo -en "test" | codext encode base64 gzip | codext guess
+Codecs: gzip
+dGVzdA==
+$ echo -en "test" | codext encode base64 gzip | codext guess gzip -i base
+Codecs: gzip, base64
+test
+```
+
+
 ## Usage (Python)
 
-Getting the list of available codecs:
+Getting the list of available codecs.
 
 ```python
 >>> import codext
@@ -814,6 +870,9 @@ Getting the list of available codecs:
 >>> codext.list()
 ['ascii85', 'base85', 'base100', 'base122', ..., 'tomtom', 'dna', 'html', 'markdown', 'url', 'resistor', 'sms', 'whitespace', 'whitespace-after-before']
 
+Playing with some base encodings.
+
+```python
 >>> codext.encode("this is a test", "base58-bitcoin")
 'jo91waLQA1NNeBmZKUF'
 
@@ -828,7 +887,21 @@ Getting the list of available codecs:
 
 >>> codecs.decode("👫👟👠👪🐗👠👪🐗👘🐗👫👜👪👫", "base100")
 'this is a test'
+```
+
+Playing with some cryptography-based codecs.
 
+```python
+>>> codext.encode("This is a test !", "vigenere-MYSECRETKET")
+'Ffaw kj e mowm !'
+
+>>> codext.encode("This is a test !", "autoclave-SECRET")
+'Llkj ml t amkb !'
+```
+
+Encoding/decoding with various other codecs.
+
+```python
 >>> for i in range(8):
         print(codext.encode("this is a test", "dna-%d" % (i + 1)))
 GTGAGCCAGCCGGTATACAAGCCGGTATACAAGCAGACAAGTGAGCGGGTATGTGA
@@ -856,30 +929,6 @@ CACTCGGTCGGCCATATGTTCGGCCATATGTTCGTCTGTTCACTCGCCCATACACT
 	f.read()
 'this is a test'
 
->>> codext.decode("""
-      =            
-              X         
-   :            
-      x         
-  n  
-    r 
-        y   
-      Y            
-              y        
-     p    
-         a       
- `          
-            n            
-          |    
-  a          
-o    
-       h        
-          `            
-          g               
-           o 
-   z      """, "whitespace-after+before")
-'CSC{not_so_invisible}'
-
 >>> print(codext.encode("An example test string", "baudot-tape"))
 ***.**
    . *
@@ -985,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] `phillips`: aka Phillips Cipher (polyalphabetic block cipher with 8 key squares)
 - [X] `polybius`: aka Polybius Square Cipher
 - [X] `railfence`: aka Rail Fence Cipher
 - [X] `rotN`: aka Caesar cipher (*N* belongs to [1,25])

{codext-1.16.0 → codext-1.16.2}/README.md

@@ -81,6 +81,8 @@ example-macro
 
 ## //img.shields.io/badge/Tweet%20(unbase)--lightgrey?logo=twitter&style=social" alt="Tweet on unbase" height="20"/></a>
 
+Playing with base encodings.
+
 ```session
 $ echo "Test string !" | base122
 *.7!ft9�-f9Â
@@ -106,9 +108,63 @@ $ echo "Test string !" | base91 | base85 | base36 | base58-flickr | unbase -f Te
 Test string !
 ```
 
+## Usage (CLI)
+
+Listing codecs.
+
+```session
+$ codext list encodings
+a1z26                      adler32               affine             alternative-rot        ascii           
+atbash                     autoclave             bacon              barbie                 base            
+base1                      base2                 base3              base4                  base8           
+<<snipped>>
+```
+
+Finding a codec based on a name.
+
+```session
+$ codext search bitcoin
+base58
+```
+
+Encoding a string.
+
+```sesssion
+$ echo -en "This is a test" | codext encode polybius
+44232443 2443 11 44154344
+```
+
+Encoding a file.
+
+```session
+$ echo -en "this is a test" > to_be_encoded.txt
+$ codext encode base64 < to_be_encoded.txt > text.b64
+$ cat text.b64 
+dGhpcyBpcyBhIHRlc3Q=
+```
+
+Chaining codecs.
+
+```session
+$ echo -en "mrdvm6teie6t2cq=" | codext encode upper | codext decode base32 | codext decode base64
+test
+```
+
+Iteratively guessing decodings.
+
+```session
+$ echo -en "test" | codext encode base64 gzip | codext guess
+Codecs: gzip
+dGVzdA==
+$ echo -en "test" | codext encode base64 gzip | codext guess gzip -i base
+Codecs: gzip, base64
+test
+```
+
+
 ## Usage (Python)
 
-Getting the list of available codecs:
+Getting the list of available codecs.
 
 ```python
 >>> import codext
@@ -116,6 +172,9 @@ Getting the list of available codecs:
 >>> codext.list()
 ['ascii85', 'base85', 'base100', 'base122', ..., 'tomtom', 'dna', 'html', 'markdown', 'url', 'resistor', 'sms', 'whitespace', 'whitespace-after-before']
 
+Playing with some base encodings.
+
+```python
 >>> codext.encode("this is a test", "base58-bitcoin")
 'jo91waLQA1NNeBmZKUF'
 
@@ -130,7 +189,21 @@ Getting the list of available codecs:
 
 >>> codecs.decode("👫👟👠👪🐗👠👪🐗👘🐗👫👜👪👫", "base100")
 'this is a test'
+```
+
+Playing with some cryptography-based codecs.
 
+```python
+>>> codext.encode("This is a test !", "vigenere-MYSECRETKET")
+'Ffaw kj e mowm !'
+
+>>> codext.encode("This is a test !", "autoclave-SECRET")
+'Llkj ml t amkb !'
+```
+
+Encoding/decoding with various other codecs.
+
+```python
 >>> for i in range(8):
         print(codext.encode("this is a test", "dna-%d" % (i + 1)))
 GTGAGCCAGCCGGTATACAAGCCGGTATACAAGCAGACAAGTGAGCGGGTATGTGA
@@ -158,30 +231,6 @@ CACTCGGTCGGCCATATGTTCGGCCATATGTTCGTCTGTTCACTCGCCCATACACT
 	f.read()
 'this is a test'
 
->>> codext.decode("""
-      =            
-              X         
-   :            
-      x         
-  n  
-    r 
-        y   
-      Y            
-              y        
-     p    
-         a       
- `          
-            n            
-          |    
-  a          
-o    
-       h        
-          `            
-          g               
-           o 
-   z      """, "whitespace-after+before")
-'CSC{not_so_invisible}'
-
 >>> print(codext.encode("An example test string", "baudot-tape"))
 ***.**
    . *
@@ -287,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] `phillips`: aka Phillips Cipher (polyalphabetic block cipher with 8 key squares)
 - [X] `polybius`: aka Polybius Square Cipher
 - [X] `railfence`: aka Rail Fence Cipher
 - [X] `rotN`: aka Caesar cipher (*N* belongs to [1,25])

{codext-1.16.0 → codext-1.16.2}/docs/pages/enc/crypto.md

@@ -162,6 +162,25 @@ This implements the Citrix CTX1 password encoding algorithm.
 
 -----
 
+### Phillips Cipher
+
+This implements Phillips cipher, a polyalphabetic code using 8 grids generated with one keyword.
+
+**Codec** | **Conversions** | **Aliases** | **Comment**
+:---: | :---: | --- | ---
+`phillips` | text <-> phillips ciphertext | `phillips-key`, `phillips_password`, ... |
+
+```python
+>>> codext.encode("this is a test", "phillips_mysuperkey")
+'ZCNM NM E XKMVZ'
+>>> codext.encode("Another Test String", "phillips-PaSsWoRd")
+'SMEZKBE LBON OLEHQHV'
+>>> codext.decode("SMEZKBE LBON OLEHQHV", "phillips-password")
+'ANOTHER TEST STRINGX'
+```
+
+-----
+
 ### Polybius Square Cipher
 
 This implements the well-known Polybius Square cipher, using the square with the alphabet in normal order as the default. It can be used dynamically with a custom alphabet.

codext-1.16.2/src/codext/VERSION.txt

@@ -0,0 +1 @@
+1.16.2

{codext-1.16.0 → codext-1.16.2}/src/codext/__common__.py

@@ -671,7 +671,7 @@ def list_categories():
             c.append(d.rstrip("s"))
     # particular category, hardcoded from base/_base.py
     c += ["base-generic"]
-    return c
+    return list(set(c))
 list_categories()
 
 

{codext-1.16.0 → codext-1.16.2}/src/codext/__init__.py

@@ -170,7 +170,7 @@ def main():
     listi = sparsers.add_parser("list", help="list items")
     lsparsers = listi.add_subparsers(dest="type", help="type of item to be listed", required=True)
     liste = lsparsers.add_parser("encodings", help="list encodings")
-    liste.add_argument("category", nargs="+", help="selected categories")
+    liste.add_argument("category", nargs="*", help="selected categories")
     listm = lsparsers.add_parser("macros", help="list macros")
     addm = sparsers.add_parser("add-macro", help="add a macro to the registry")
     addm.add_argument("name", help="macro's name")
@@ -198,13 +198,13 @@ def main():
         # list encodings or macros
         elif args.command == "list":
             if args.type == "encodings":
-                cats = args.category or list_categories()
-                for c in sorted(cats):
-                    l = list_encodings(c)
-                    if len(l) > 0:
-                        if len(cats) > 0:
+                if args.category:
+                    for c in sorted(args.category):
+                        if len(l := list_encodings(c)) > 0:
                             print(c.upper() + ":")
-                        __print_tabular(l)
+                            __print_tabular(l)
+                else:
+                    __print_tabular(list_encodings())
             elif args.type == "macros":
                 l = list_macros()
                 if len(l) > 0:

{codext-1.16.0 → codext-1.16.2}/src/codext/base/_base.py

@@ -130,6 +130,10 @@ def base_encode(input, charset, errors="strict", exc=BaseEncodeError):
     while i > 0:
         i, c = divmod(i, n)
         r = charset[c] + r
+    # preserve leading zero bytes: big-integer bases such as Base58 map each
+    # leading null byte of the input to a leading charset[0] character
+    if not isinstance(input, int):
+        r = charset[0] * (len(input) - len(input.lstrip("\x00"))) + r
     return r
 
 
@@ -151,7 +155,8 @@ def base_decode(input, charset, errors="strict", exc=BaseDecodeError):
             i = i * n + charset.index(c)
         except ValueError:
             handle_error("base", errors, exc, decode=True)(c, k, dec(i), "base%d" % n)
-    return dec(i)
+    # restore the leading zero bytes encoded as leading charset[0] characters
+    return chr(0) * (len(input) - len(input.lstrip(charset[0]))) + dec(i)
 
 
 # base codec factory functions

{codext-1.16.0 → codext-1.16.2}/src/codext/base/base45.py

@@ -34,7 +34,10 @@ def base45_encode(mode):
     b45 = _get_charset(B45, mode)
     def encode(text, errors="strict"):
         t, s = b(text), ""
-        for i in range(0, len(text), 2):
+        # iterate over the byte sequence (t), not len(text): when the input
+        # holds non-ASCII characters, b(text) is longer than text and using
+        # len(text) silently drops the trailing bytes
+        for i in range(0, len(t), 2):
             n = 256 * __ord(t[i])
             try:
                 n += __ord(t[i+1])
@@ -54,7 +57,7 @@ def base45_decode(mode):
     def decode(text, errors="strict"):
         t, s = b(text), ""
         ehandler = handle_error("base45", errors, decode=True)
-        for i in range(0, len(text), 3):
+        for i in range(0, len(t), 3):
             try:
                 n = b45[__chr(t[i])]
             except KeyError:

{codext-1.16.0 → codext-1.16.2}/src/codext/crypto/__init__.py

@@ -4,6 +4,7 @@ from .atbash import *
 from .bacon import *
 from .barbie import *
 from .citrix import *
+from .phillips import *
 from .polybius import *
 from .railfence import *
 from .rot import *

codext-1.16.2/src/codext/crypto/phillips.py

@@ -0,0 +1,128 @@
+# -*- coding: UTF-8 -*-
+"""Phillips Cipher Codec - phillips content encoding.
+
+The Phillips cipher is a polyalphabetic substitution cipher using 8 key
+squares.  The first square is a 5×5 grid built from a keyword (I and J share
+one cell).  Seven additional squares are derived by rotating every row of the
+previous square one step to the left.  Plaintext is enciphered in bigrams,
+each pair using the next square in a cycle of 8.  Non-alphabetic characters
+are passed through unchanged; J is treated as I.
+
+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/phillips-cipher
+"""
+from ..__common__ import *
+
+
+__examples__ = {
+    'enc(phillips)':             None,
+    'enc(phillips-key)':         {'ATTACK': 'BSSBIC', 'TESTME': 'QBTPLY', 'ABCDEF': 'BKDFYD'},
+    'enc-dec(phillips-key)':     ['ATTACK', 'TESTME', 'ABCDEF'],
+    'enc-dec(phillips-secret)':  ['HELLOWORLD', 'ATTACKATDAWN'],
+}
+__guess__ = ["phillips-key", "phillips-secret", "phillips-password"]
+
+
+_ALPHABET = "ABCDEFGHIKLMNOPQRSTUVWXYZ"
+
+
+def __make_grids(key):
+    """Return all 8 grids: the initial grid plus 7 row-rotated variants."""
+    # build the initial 5×5 grid from a keyword (J treated as I)
+    seen, letters = set(), []
+    for c in key.upper().replace("J", "I") + _ALPHABET:
+        if c in set(_ALPHABET) and c not in seen:
+            letters.append(c)
+            seen.add(c)
+    grid = [letters[i * 5:(i + 1) * 5] for i in range(5)]
+    # now build the other 7 row-rotated variant grids
+    grids = [grid]
+    for _ in range(7):
+        grid = [row[1:] + [row[0]] for row in grid]
+        grids.append(grid)
+    return grids
+
+
+def __process_pair(a, b, grid, decode=False):
+    """Encode or decode a letter pair using Playfair substitution rules.
+
+    Same row   → each letter shifts one step right (encode) / left (decode).
+    Same col   → each letter shifts one step down  (encode) / up   (decode).
+    Rectangle  → each letter moves to the other's column (self-inverse).
+    """
+    pos = {ch: (r, c) for r, row in enumerate(grid) for c, ch in enumerate(row)}
+    r1, c1 = pos[a]
+    r2, c2 = pos[b]
+    d = -1 if decode else 1
+    if r1 == r2:
+        return grid[r1][(c1 + d) % 5], grid[r2][(c2 + d) % 5]
+    if c1 == c2:
+        return grid[(r1 + d) % 5][c1], grid[(r2 + d) % 5][c2]
+    return grid[r1][c2], grid[r2][c1]  # rectangle rule is its own inverse
+
+
+def phillips_encode(key):
+    _key = (key or "").strip()
+    # Compute grids eagerly if key is valid; otherwise defer error to call time
+    _grids = __make_grids(_key) if _key and _key.isalpha() else None
+    def encode(text, errors="strict"):
+        if _grids is None:
+            raise LookupError("Bad parameter for encoding 'phillips': "
+                              "key must be a non-empty alphabetic string")
+        t = ensure_str(text).upper().replace("J", "I")
+        alpha = [(i, c) for i, c in enumerate(t) if c in set(_ALPHABET)]
+        # Pad to an even count with a trailing X
+        padding_char = None
+        if len(alpha) % 2 == 1:
+            alpha.append((-1, "X"))
+        enc_map = {}
+        for pair_num, k in enumerate(range(0, len(alpha), 2)):
+            pos1, a = alpha[k]
+            pos2, b = alpha[k + 1]
+            e1, e2 = __process_pair(a, b, _grids[pair_num % 8])
+            enc_map[pos1] = e1
+            if pos2 >= 0:
+                enc_map[pos2] = e2
+            else:
+                padding_char = e2
+        result = [enc_map.get(i, c) for i, c in enumerate(t)]
+        if padding_char is not None:
+            result.append(padding_char)
+        return "".join(result), len(text)
+    return encode
+
+
+def phillips_decode(key):
+    _key = (key or "").strip()
+    # Compute grids eagerly if key is valid; otherwise defer error to call time
+    _grids = __make_grids(_key) if _key and _key.isalpha() else None
+    def decode(text, errors="strict"):
+        if _grids is None:
+            raise LookupError("Bad parameter for decoding 'phillips': "
+                              "key must be a non-empty alphabetic string")
+        t = ensure_str(text).upper().replace("J", "I")
+        alpha = [(i, c) for i, c in enumerate(t) if c in set(_ALPHABET)]
+        if len(alpha) % 2 == 1:
+            if errors == "strict":
+                raise ValueError("phillips: encoded text must contain an even "
+                                 "number of alphabetic characters")
+            alpha = alpha[:-1]
+        dec_map = {}
+        for pair_num, k in enumerate(range(0, len(alpha), 2)):
+            pos1, a = alpha[k]
+            pos2, b = alpha[k + 1]
+            d1, d2 = __process_pair(a, b, _grids[pair_num % 8], decode=True)
+            dec_map[pos1] = d1
+            dec_map[pos2] = d2
+        return "".join(dec_map.get(i, c) for i, c in enumerate(t)), len(text)
+    return decode
+
+
+add("phillips", phillips_encode, phillips_decode, r"^phillips(?:[-_]cipher)?(?:[-_]([a-zA-Z]+))?$", printables_rate=1.,
+    penalty=.1)
+