Improved codec: railfence

dhondta · dhondta · commit 30313578fc75 · 2022-01-26T22:59:30.000+01:00
diff --git a/README.md b/README.md
@@ -259,7 +259,7 @@ o
 - [X] `bacon`: aka Baconian Cipher
 - [X] `barbie-N`: aka Barbie Typewriter (*N* belongs to [1, 4])
 - [X] `citrix`: aka Citrix CTX1 password encoding
-- [X] `rail`: aka Rail Fence Cipher 
+- [X] `railfence`: aka Rail Fence Cipher 
 - [X] `rotN`: aka Caesar cipher (*N* belongs to [1,25])
 - [X] `scytaleN`: encrypts using the number of letters on the rod (*N* belongs to [1,[)
 - [X] `shiftN`: shift ordinals (*N* belongs to [1,255])
diff --git a/codext/crypto/railfence.py b/codext/crypto/railfence.py
@@ -1,37 +1,39 @@
 # -*- coding: UTF-8 -*-
-"""Rail Fence Cipher Codec - rail fence encoding.
+"""Rail Fence Cipher Codec - rail fence content encoding.
 
 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)
 """
-
-
-
 from ..__common__ import *
 
 
 __examples__ = {
-    'enc(rail-5-3|rail_5_3)': {'this is a test' : 'it sss etiath '},
-    'enc(rail-5-3-up|rail_5_3-up)' :{'this is a test': 'h tiats e ssit'},
-    'dec(rail-7-4|rail_7_4)': {'a  stiet shsti': 'this is a test'}
+    'enc(rail_123|rail-2-123)':     {'this is a test': None},
+    'enc(railfence|zigzag)':        {'this is a test': "t ashsi  etist"},
+    'enc(rail-5|zigzag_5)':         {'this is a test': "tah  istsiet s"},
+    'enc(rail_5-3|rail_5_3)':       {'this is a test': "it sss etiath "},
+    'enc(rail-5-3-up|rail_5_3-up)': {'this is a test': "h tiats e ssit"},
+    'enc(rail-7-4|rail_7_4)':       {'this is a test': "a  stiet shsti"},
+    'dec(zigzag)':                  {'': ""},
 }
+__guess__ = ["railfence-%d" % i for i in range(1, 11)] + ["railfence-%d-up" % i for i in range(1, 11)]
 
 
-
-def __buildf(text, rails, offset = 0, up = 0) : 
+def __build(text, rails, offset, up):
     l, rail = len(text), offset
-    if up != '' :
+    # set the starting rail and direction
+    if up:
         dr = -1
         rail = rails - offset - 1
-    else : 
+    else: 
         dr = 1
-
-    f = [["#"] * l for i in range(rails)]
-
-    for x in range(l) : 
+    # create rails
+    f = [[None] * l for i in range(rails)]
+    # now zig-zag between rails
+    for x in range(l): 
         f[rail][x] = text[x]
         if rail >= rails - 1:
             dr = -1
@@ -40,37 +42,55 @@ def __buildf(text, rails, offset = 0, up = 0) :
         rail += dr
     return f
 
-def railfence_encode(rails = 3, offset = 0, up = 0) :  
-    def encode(text, errors="strict") : 
-        c,l = '', len(text)
-        f = __buildf(text, rails, offset, up)
-        for r in range(rails) : 
-            for x in range(l) :
-                if f[r][x] != '#' : 
-                    c += f[r][x]
-        return c, l
+
+def __check(length, rails, offset):
+    if rails > length:
+        raise ParameterError("Bad parameter for encoding 'railfence': rails=%d (should be >%d)" % (rails, length))
+    if offset > rails:
+        raise ParameterError("Bad parameter for encoding 'railfence': offset=%d (should be >%d)" % (offset, rails))
+
+
+def railfence_encode(rails, offset, up):
+    rails, offset, up = int(rails or 3), int(offset or 0), up is not None and up != ""
+    def encode(text, errors="strict"):
+        r, l = "", len(text)
+        __check(l, rails, offset)
+        f = __build(text, rails, offset, up)
+        for rail in range(rails): 
+            for x in range(l):
+                if f[rail][x] is not None: 
+                    r += f[rail][x]
+        return r, l
     return encode
 
-def railfence_decode(rails = 3, offset = 0, up = 0) : 
-    def decode(text, errors = 'strict') : 
-        f = __buildf("x" * len(text), rails, offset, up)
-        plain, i = '', 0
-        ra, l = range(rails), range(len(text))
 
-        #Put the characters in the right place
-        for r in ra:
-            for x in l :            
-                if f[r][x] == "x" : 
-                    f[r][x] = text[i]
+def railfence_decode(rails, offset, up):
+    rails, offset, up = int(rails or 3), int(offset or 0), up is not None and up != ""
+    def decode(text, errors="strict"):
+        # this if block is particularly useful with Python2 ; see codecs.py at line 492 in comparison with codecs.py
+        #  from Python3 at line 501: in Python2, a last block can be read while empty while in Python3 not
+        # as a consequence, in Python2, an error is triggered as an empty text cannot be decoded with Rail Fence with
+        #  a rails parameter > 0 (see the __check(length, rails, offset)) function
+        if text == "":
+            return "", 0
+        r, i, l = "", 0, len(text)
+        __check(l, rails, offset)
+        f = __build("." * len(text), rails, offset, up)
+        # put the characters in the right place
+        for rail in range(rails):
+            for x in range(l):            
+                if f[rail][x] == ".": 
+                    f[rail][x] = text[i]
                     i += 1
-        #Read the characters in the right order
-        for x in l : 
-            for r in ra:
-                if f[r][x] != '#' : 
-                    plain += f[r][x]
+        # read the characters in the right order
+        for x in range(l): 
+            for rail in range(rails):
+                if f[rail][x] is not None: 
+                    r += f[rail][x]
+        return r, len(text)
+    return decode
 
-        return plain, len(plain)
 
-    return decode
+add("railfence", railfence_encode, railfence_decode,
+    r"^(?:rail(?:[-_]?fence)?|zigzag)(?:[-_]([1-9]|[1-9]\d+)(?:[-_]([0-9]|[1-9]\d+))?(?:[-_](up))?)?$")
 
-add("rail", railfence_encode, railfence_decode, r"rail[-_](\d+)[-_](\d+)[-_]?(up)?$")
diff --git a/docs/enc/crypto.md b/docs/enc/crypto.md
@@ -130,15 +130,18 @@ This implements the Citrix CTX1 password encoding algorithm.
 
 ### Rail Fence Cipher
 
-This implements the Rail Fence encoding algorithm.
+This implements the Rail Fence encoding algorithm, using 3 rails and offset 0 as the default parameters. The encoding fence is built from the top ; the `up` flag can be used to build the fence from the bottom. Note that trying parameters that do not fit the input length will trigger a `ValueError` mentioning the bad value.
 
 **Codec** | **Conversions** | **Aliases** | **Comment**
 :---: | :---: | --- | ---
-`rail` | text <-> rail fence ciphertext, X rails and Y offset | `rail-X-Y`, `rail_X_Y`, `rail-X-Y-up`| The encoding fence is built from the top. Careful to trailing whitespaces. The `up` flag is used to build the fence from the bottom to the top.
+`rail` | text <-> rail fence ciphertext, X rails and Y offset | `rail-X-Y`, `rail_X_Y`, `rail-X-Y-up`, `zigzag`, ... | 
+
 ```python
+>>> codext.encode("this is a test", "zigzag")
+'t ashsi  etist'
 >>> codext.encode("this is a test", "rail-5-3")
 'it sss etiath '
->>> codext.decode("it sss etiath ", "rail-5-3")
+>>> codext.decode("it sss etiath ", "zigzag_5-3")
 'this is a test'
 ```
 
