python - password - Cifrado de cercas ferroviarias: buscando una mejor solución

python cipher password

Question

He codificado Rail Fence Cipher en Python. Me preguntaba si podría haber una mejor solución.

Para aquellos que no saben qué es el cifrado de cercas ferroviarias, es básicamente un método de escribir texto simple de una manera que crea un patrón lineal en forma de espiral. Ejemplo: cuando "FOOBARBAZ" está vallado con una llave de 3.

F . . . A . . . Z . . .
. O . B . R . A . Q . X
. . O . . . B . . . U .

Al leer la espiral anterior línea por línea, el texto de cifrado se convierte en "FAZOBRAQXOBU". Lea más en - Rail fence - Wikipedia .

def cipher(s, key, graph=False) :
    down=True
    raw_out=[]
    out=''''
    i=0
    for x in range(key) :
        raw_out.append({})
    for pos in range(len(s)) :
        raw_out[i][pos]=s[pos]
        if i==key-1 :
            down=False
        if i==0 :
            down=True
        if down :
            i=i+1
        else :
            i=i-1
    for p in raw_out :
        for q in p :
            out+=p[q]
    if graph :
        return raw_out
    return out

def decipher(s, key) :
    map_list=cipher(s, key, True) #CREATING JUST FOR MAPPING - WHICHth CHARACTER OF THE STRING - IS WHICHth CHARACTER OF THE CIPHER
    new={}
    out=''''
    s_counter=0
    for x in map_list :
        for y in x :
            new[y]=s[s_counter]
            s_counter+=1
    for p in new :
        out+=new[p]
    return map_list

Me preguntaba si había alguna forma mejor de hacerlo, ya que mi procedimiento es muy costoso, usa un par de diccionarios.

Se da la bienvenida al código en cualquier idioma.

Answer 1

Sólo por el gusto de hacerlo...

def fence(lst, numrails):
    fence = [[None] * len(lst) for n in range(numrails)]
    rails = range(numrails - 1) + range(numrails - 1, 0, -1)
    for n, x in enumerate(lst):
        fence[rails[n % len(rails)]][n] = x

    if 0: # debug
        for rail in fence:
            print ''''.join(''.'' if c is None else str(c) for c in rail)

    return [c for rail in fence for c in rail if c is not None]

def encode(text, n):
    return ''''.join(fence(text, n))

def decode(text, n):
    rng = range(len(text))
    pos = fence(rng, n)
    return ''''.join(text[pos.index(n)] for n in rng)

z = encode(''ATTACK.AT.DAWN'', 3)    
print z # ACTWTAKA.ANT.D
y = decode(z, 3)
print y # ATTACK.AT.DAWN

Answer 2

Ver una explicación en mi blog .

(define (waves str h)
  (define (down str)
    (if (>= h (length str))
        (list (fill h str))
        (cons (take h str) (up (drop h str)))))
  (define (up str)
    (if (>= (- h 2) (length str))
        (list (pad (fill (- h 2) str)))
        (cons (pad (take (- h 2) str)) (down (drop (- h 2) str)))))
  (define (pad str) (append (list X) (reverse str) (list X)))
  (define (fill h str) (append str (make-list (- h (length str)) X)))
  (down str))

(define (fence lox h)
  (define a (apply append (transpose (waves lox h))))
  (filter (lambda (e) (not (eq? X e))) a))

(define (encipher str h)
  (list->string (fence (string->list str) h)))

(define (decipher str h)
  (define e (fence (range (string-length str)) h))
  (define x (map list e (string->list str)))
  (define y (sort (lambda (i j) (<= (car i) (car j))) x))
  (define z (map cadr y))
  (list->string z))