Grundlagen der funktionsorientierten Programmierung mit SCHEME/Zickzack-Verschlüsselung

Wiki-Quelltext dieser Seite.

<language>SchemeJS</language>
<code id="5bcc2d413d117" hidden>
(define quotient
  (lambda (m n)
    (floor (/ m n))))

(define remainder quotient)

(define string-first
  (lambda (zk)
    (substring zk 0 1)))

(define string-last
  (lambda (zk)
    (let ([n (string-length zk)])
      (substring zk (- n 1) n))))

(define string-left
 (lambda (zk n)
   (substring zk 0 n)))

(define string-right
  (lambda (zk n)
    (let ([m (string-length zk)])
      (substring zk (- m n) m))))

(define string-car
  (lambda (zk)
    (string-ref zk 0)))

(define string-cdr
  (lambda (zk)
    (substring zk 1 (string-length zk))))

(define string-cons
  (lambda (z zk)
    (string-append (string z) zk)))

(define char-pos
  (lambda (z zk)
    (if (equal? (string z) (string-first zk))
        1
        (+ 1 (char-pos z (string-cdr zk))))))

(define char-in-string?
  (lambda (z zk)
    (cond
      [(= (string-length zk) 0) #f]
      [(equal? (string z) (string-first zk)) #t]
      [else
       (char-in-string? z (string-cdr zk))])))
</code>

Bereits das einfache Umordnen der Zeichen in einem Text erschwert Dritten das Lesen erheblich.<br />
In der Zickzack-Verschlüsselung werden alle Buchstaben, Ziffern, Satz- und Sonderzeichen wechselseitig in zwei neuen Zeichenketten abgelegt, die anschließend mieinander verknüpft werden, z.B.:

 "Brisante Texte müssen verschlüsselt werden!"
 --> Zeichenkette 1: "Biat et üsnvrclsetwre!" 
 --> Zeichenkette 2: "rsneTxemse eshüsl edn"
 --> "Biat et üsnvrclsetwre!rsneTxemse eshüsl edn"

Zum Entschlüseln muss dieser "Geheimtext" wieder in zwei Zeichenketten geteilt werden, aus deren Zeichen wechselseitig (d.h. im Zickzack) der Klartext zusamengesetzt wird.<br />
Implementieren Sie diesen Algorithmus mit den nachfolgenden Prozeduren.

'''Hinweis:''' Falls sie benötigt werden, stehen hier ebenfalls die Sprachelemente <tt>string-car</tt>, <tt>string-cdr</tt> und <tt>string-cons</tt> zur Verfügung.

== Verschlüsseln ==

<code id="5bcc2d413d1ab">
(define codieren
  (lambda (txt)
    ...))
</code>

<check>
(and (equal? (codieren "") "") (equal? (codieren "Informatik") "Ifrainomtk") (equal? (codieren "Das ist ein Geheimtext.") "DsitenGhitx.a s i eemet"))
</check>

<run id="5bcc3297ebd0f">
(define geheimtext (codieren "Brisante Texte müssen verschlüsselt werden!"))
geheimtext
</run>

== Entschlüsseln ==

<code id="5bcc3297ebc8c">
(define decodieren
  (lambda (txt)
    ...))
 
</code>

<check>
(and (equal? (decodieren "") "") (equal? (decodieren "Ifrainomtk") "Informatik") (equal? (decodieren "DsitenGhitx.a s i eemet") "Das ist ein Geheimtext."))
</check>

<run id="5bcc3297ebd78">
(decodieren geheimtext)
</run>

Uns ist klar, dass die Zickzack-Verschlüsselung noch keinem "echten" Verschlüsselungsvefahren entspricht, denn bei seiner Anwendung müsste man bei Dritten auf die Unkenntnis des Verfahrens spekulieren.<br />
Einige [[Grundlagen der funktionsorientierten Programmierung mit SCHEME/Ausgewählte Algorithmen der Kryptologie|ausgewählte Verfahren der Kryptologie]] wollen wir [[Grundlagen der funktionsorientierten Programmierung mit SCHEME/Ausgewählte Algorithmen der Kryptologie|später]] kennen lernen.

Zurück zu [[Grundlagen der funktionsorientierten Programmierung mit SCHEME/Komplexe Anwendungen: Von musizierenden Chinesen und Schüttelwörtern|komplexen Anwendungen: Von musizierenden Chinesen und Schüttelwörtern]].