One-time-pad-Crypter

[murph]

doppelt hält besser^^
ich dachte mir, dass man "a.501" auch auf einem unsicherem wege übermitteln kann, da es schwer zu knacken ist, weil das ergebnis ja unkenntlich ist, sprich: der, der das versucht zu encrypten, wird als ergebnis jede menge sch***e erhalten. Das soll das ganze noch ein wenig erschweren, wenn man dann schonmal die datei "a.501" hat.

[Python 47]

doppelt hält besser^^
ich dachte mir, dass man "a.501" auch auf einem unsicherem wege übermitteln kann, da es schwer zu knacken ist, weil das ergebnis ja unkenntlich ist, sprich: der, der das versucht zu encrypten, wird als ergebnis jede menge sch***e erhalten. Das soll das ganze noch ein wenig erschweren, wenn man dann schonmal die datei "a.501" hat.

Dann ist es aber trotzdem kein One Time Pad, denn ein One Time Pad zeichnet sich aus, das es mathematisch absolut unknackbar ist. Und das wäre es nicht mehr, wenn jem. die Datei in die Finger bekommt.

[murph]

du weißt, dass du dir selbst widersprichst? wenn etwas mathematisch unknackbar ist, du aber die Lösung hast, ist es immer noch mathematisch unknackbar, aber es is trotzdem machbar, an den inhalt zu kommen!!!

[Python 47]

du weißt, dass du dir selbst widersprichst? wenn etwas mathematisch unknackbar ist, du aber die Lösung hast, ist es immer noch mathematisch unknackbar, aber es is trotzdem machbar, an den inhalt zu kommen!!!

Da wiedersprichst du dich ein bischen. Wenn ich die Lösung habe, sprich ich habe es entschlüsselt, dann ist die Verschlüsselung nicht länger unknackbar. Wie dem auch sei, trotzdem ist es kein One Time Pad, so wie du das machst.

Gruß Thomas

[mitsuhiko]

geht sterben -.-

[murph]

du hast ungenau gelesen: wenn man eine lösung hat, heißt das nicht, dass man die sich erhackt hat!

die betonung lag auf _mathematisch_. Nochmal lesen und glücklich sein

[BlackJack]

ich dachte mir, dass man "a.501" auch auf einem unsicherem wege übermitteln kann, da es schwer zu knacken ist, weil das ergebnis ja unkenntlich ist, sprich: der, der das versucht zu encrypten, wird als ergebnis jede menge sch***e erhalten. Das soll das ganze noch ein wenig erschweren, wenn man dann schonmal die datei "a.501" hat.

Wenn man die "a.501" hat, dann hängt es nur noch am Passwort. Wie Python Master schrieb: One Time Pad ist unknackbar wenn man die Pad-Daten nicht in die Finger bekommt. Die müssen auf einem sicheren Weg übertragen werden. Sonst ist das ganze einfach kein One-Time-Pad mehr.

One-Time-Pad sieht so aus:

Code: Alles auswählen

#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""One Time Pad."""
from __future__ import division
import os
import sys
from itertools import izip
from mmap import mmap, ACCESS_READ
from optparse import OptionParser

__author__ = "Marc 'BlackJack' Rintsch"
__version__ = '0.0.1'
__date__ = '$Date: 2006-05-27 22:08:57 +0200 (Sat, 27 May 2006) $'
__revision__ = '$Rev: 857 $'


BLOCK_SIZE = 1024 * 1024    # 1 Mib


def write_random_bytes(count, fileobj, block_size=BLOCK_SIZE):
    """Write cryptographically secure random data."""
    while count > 0:
        fileobj.write(os.urandom(min(block_size, count)))
        count -= block_size


def crypt(in_data, out_file, pad_data):
    """Encrypt `in_data` with `pad_data` and write to `out_file`."""
    for in_byte, pad_byte in izip(in_data, pad_data):
        out_file.write(chr(ord(in_byte) ^ ord(pad_byte)))


def crypt_file(in_name, out_name, pad_name, offset):
    """Encrypt a file.
    
    The three names are paths to the file to be processed, the file where the
    processed data should be written to and the file with the one time pad data.
    
    Additionally the `offset` into the one time pad file has to be given.  The
    return value is the `offset` plus the length of the processed data.
    
    The function maps the unencrypted file and the one time pad data into
    memory so both together must fit into virtual memory.
    """
    size = os.path.getsize(in_name)
    pad_size = os.path.getsize(pad_name)
    in_file = open(in_name, 'rb')
    out_file = open(out_name, 'wb')
    pad_file = open(pad_name, 'rb')
    in_data = mmap(in_file.fileno(), size, access=ACCESS_READ)
    pad_data = buffer(mmap(pad_file.fileno(), pad_size, access=ACCESS_READ),
                      offset)
    crypt(in_data, out_file, pad_data)
    for fileobj in (in_file, out_file, pad_file):
        fileobj.close()
    return size + offset


def cmd_generate_pad(options, args):
    """Implements the one time pad generation command."""
    if len(args) == 0:
        out_file = sys.stdout
    else:
        out_file = open(args[0], 'wb')
    write_random_bytes(options.pad_size * 1000000, out_file)


def cmd_crypt(options, args):
    """Implements the crypt command."""
    if len(args) != 3:
        sys.exit('need in-, out- and pad-filename')
    offset = options.offset
    print crypt_file(args[0], args[1], args[2], offset)


def main():
    """Main function."""
    usage = '%prog [options] command'
    parser = OptionParser(usage=usage, version=__version__)
    parser.add_option('-s', '--pad-size', type='int', default=1,
                      metavar='SIZE',
                      help='generate pad data with SIZE MB (%default)')
    parser.add_option('-o', '--offset', type='int', default=0,
                      help='offset into one time pad data')
    
    commands = { 'generate': cmd_generate_pad,
                 'crypt': cmd_crypt }

    (options, args) = parser.parse_args()
    
    if len(args) == 0:
        parser.error('Need at least one command %r' % commands.keys())
    
    try:
        command = commands[args[0]]
    except KeyError:
        parser.error('Unknown command %r' % args[0])
    
    command(options, args[1:])


if __name__ == '__main__':
    main()

Das Programm kann One-Time-Pad Zufallsdaten erzeugen und ver- und entschlüsseln. Zwischen ver- und entschlüsseln gibt's eigentlich keinen Unterschied, da beide Operationen symmetrisch sind. Liegt in der Natur der XOR-Operation.

Nehmen wir einmal an, Alice möchte Bob Nachrichten schicken. Als erstes müssen Zufallsdaten erzeugt werden. Alice nennt diese Datei bob.pad, damit sie weiss, dass sie diese Datei zum Verschlüsseln von Nachrichten an Bob verwenden muss.

Code: Alles auswählen

alice> onetimepad.py generate --pad-size 650 bob.pad

Damit werden 650MB Zufallsdaten erzeugt. Das sollte eine Weile reichen. Diese Daten brennt Alice auf eine CD und übergibt Bob diese bei einem persönlichen Treffen.

Dann kann Alice eine Nachricht verschlüssen:

Code: Alles auswählen

alice> onetimepad.py crypt --offset 0 klartext.txt verschluesselt-0.msg bob.pad
42

Damit wird die Datei klartext.txt verschlüsselt. Der Offset in die Zufallsdaten ist 0, da dies die erste Nachricht ist. Das Programm gibt den Offset plus die Länge der Nachricht wieder aus. Diese Zahl kann als Offset für die nächste Verschlüsselung benutzt werden. Das ist wichtig, damit niemals die gleichen Zufallsdaten zum Verschlüsseln benutzt werden. Die nächste Nachricht würde Alice wie folgt verschlüssen:

Code: Alles auswählen

alice> onetimepad.py crypt --offset 42 nachtrag.txt verschluesselt-42.msg bob.pad
656

Wie man sieht schreibt Alice den Offset auch noch einmal in den Dateinamen der verschlüsselten Nachricht, damit weiss Bob mit welchem Offset er die Datei wieder entschlüsseln muss. Den Nachtrag entschlüsselt Bob also so:

Code: Alles auswählen

bob> onetimepad.py crypt --offset 42 verschluesselt-42.msg von_alice.txt  bob.pad
656

Das Programm hat einige Unzulänglichkeiten. Man muss sich für's Verschlüsseln die Offsets merken, es gibt keine Fehlerbehandlung und ich war zu faul ordentlichen Code für das Dateihandling zu schreiben. Deshalb werden die Eingabedatei und die Pad-Datei mit mmap.mmap() in den virtuellen Speicher abgebildet. Diese beiden Dateien zusammen dürfen folglich nicht grösser sein, als der virtuelle Speicher der einem Prozess zur Verfügung steht und einzeln nicht grösser als 2GB.

Aber es ist ja auch nur als einfaches Beispiel gedacht. Auf jeden Fall kann kein Angreifer eine abgefangene verschlüsselte Nachricht knacken. Die kann man ansonsten völlig ungesichert übertragen, die sind mathematisch unknackbar. Sogar wenn der Angreifer eine Plaintext Nachricht kennt oder sogar selber erzeugen darf, erlaubt ihm die verschlüsselte Nachricht keine Rückschlüsse auf den Inhalt folgender Nachrichten.

[Python 47]

Auf jeden Fall kann kein Angreifer eine abgefangene verschlüsselte Nachricht knacken. Die kann man ansonsten völlig ungesichert übertragen, die sind mathematisch unknackbar. Sogar wenn der Angreifer eine Plaintext Nachricht kennt oder sogar selber erzeugen darf, erlaubt ihm die verschlüsselte Nachricht keine Rückschlüsse auf den Inhalt folgender Nachrichten.

Es ist aber nicht 100% sicher. Die Zufallsdaten müssen absolut unabhängig sein und dürfen in keiner Abhängigkeit stehen. Sie müssten z.B. durch thermisches Rauschen.

[murph]

ich habe mich auch einmal damit auseinandergestzt, und am besten ist dafür radioaktives material...krebs lässt grüßen
aber vllt ein lauter transistor oder so ist fälhig genug, dass das nicht nachher ermittelt werden kann...

[Python 47]

Also mal ein kleines Beispiel:

Ich habe mir 1 Gb zufallsdaten genertiert. Ich verschlüssel damit jetzt sagen wir mal ein Film z.b. Ghostship. Jetzt will die NSA es wieder entschlüsseln und wir gehen mal davon aus, dass sie Genügend Geld hätten um sich genügend rechner zu kaufen. So jetzt starten sie eine Bruteforce Atacke um rauszubekommen welchen Schlüssel ich bentutzt habe. Ich habe die Zufallsdaten nochmal durch XOR laufen lassen. So jetzt bekommen die wieder die Zufallsdaten aber Sie haben keine Chance herauszubekommen was verschlüsselt wurde, weil die 1 GB daten alles sein können z.B. James Bond oder 1000 Alben Musik oder Ein Programm wie Office oder oder oder. Und eben alles mit GLEICHER Wahrscheinlichkeit.

Das kann aber nur sein, wenn die Zufallsdaten absolut unabhängig generiert wurden z.B. thermisches Rauschen

[STiGMaTa_ch]

[...]Das kann aber nur sein, wenn die Zufallsdaten absolut unabhängig generiert wurden z.B. thermisches Rauschen

Könnte man da auch Akustische Aufnahmen nehmen? Also z.B. ein billigst Mikrofon hinstellen und einfach einige Zeit die Umgebung aufnehmen?

Das ist doch auch völlig Zufällig was da aufgenommen wird und nicht reproduzierbar...

Lieber Gruss
STiGMaTa

[murph]

also wenn du den schlüssel schon geheim überreichen kannst, musst du den nicht auch noch verschlüsseln!
nur wenn die überreichung unsicher ist, hat das noch sinn, wenn auch nur geringfügig^^
außerdem sollte man das noch immer auffüllen, genaue dateigrößen sinf auch schon verräterisch!

[Python 47]

@STiGMaTa_ch

Ja das geht auch. Das sollte absolut zufällig sein.

@murph

Aus deinem Post kann ich schließen das du One Time Pad absolut nicht verstehst.

[murph]

welchen part sollte ich nicht verstehen?
solange eine feste regel gilt, aus wie vielen zeichen wie viele werden,
kannst du diese größe ausrechnen und hast dann die länge der datei!
genau gleich lang sind kaum dateien, (fast) immer sind es bei der gleichen länge die gleiche datei!
das war abert ein exkurs, wie man verhindert, das zu encrypten, wenn man eine kleine auswahl hat.

[Python 47]

Du verstehst es wirklich nicht.

Wenn die Zufallsdaten ABSOLUT zufällig sind, dann kann alles mit gleicher Wahrscheinlichkeit in der Datei sein.

Man hat z.B. die Größe von 1GB, dann kann alles in der Datei sein, was 1 GB groß ist, z.B. ein komprmierter Film James Bond oder Gozilla oder XMen3 oder Friedhof der Kuscheltiere oder Enemy at the Gates oder The Ring1 oder ein 1 GB großés Programm oder ein 1Gb großes Rainbowtable oder 1 GB lange Wordlist oder Moto GP 3 oder Mafia oder oder oder. Da gibt es 1000 te Möglichkeiten, woher willst du wissen was es nun ist?

Noch ein Beispiel:

Größe 20 Bytes

Das kann sein:

Hallo wie geht es dir
HeuteistSonnigerTag!!!
aabbccddeeffgghhiijj
lollollollollollollola
Pythonistabsolutgeil
Was ist One Time Pad
Wie heiß ich nochmal
usw.

Sonst wäre One Time Pad unter den Bedingungen, dass die Zufallsdaten sicher übergeben werden, nie 2 mal benutzt werden und absolut zufällig ohne jede Abhängigkeit sind, nicht unknackbar.

[STiGMaTa_ch]

@murph
Beim durchlesen deiner Posts habe ich auch das Gefühl bekommen, dass du nicht verstanden hast wie ein One-Time Pad funktioniert.

In einem früheren Post schreibst du, dass wenn es eine feste Regel zum verschlüsseln gibt und man die Verschlüsselung hat, man den Ursprungstext auch mathematisch knacken kann.

Dann machen wir doch mal folgendes Experiment:

Python Master 47 und ich haben uns kurz getroffen. Dabei habe ich ihm einen 4 Byte grossen Schlüssel übergeben, welcher aus einer absolut zufälligen Sequenz besteht.

Weiterhin habe ich ihm gesagt, dass ich ihm hier im Forum mitteilen werde, was er mir einkaufen soll.

Das werde ich hiermit tun:

Python Master 47, kaufe mir den Gegenstand: Turm

Deine Aufgabe lieber murph ist es nun, zu sagen was ich anstelle Turm gemeint habe.

Und damit du möglichst viele Anhaltspunkte hast um das Rätsel zu knacken, hier mal eine Auflistung was du alles weisst (oder gleich erfährst):

- Das Objekt das ich haben möchte hat genau 4 Buchstaben.
- Zufälligerweise ergibt mein gewünschtes Objekt verschlüsselt mit dem ausgetauschten Schlüssel genau Turm, Es hätte aber auch Xgh8 sein können oder sonstwas.
- Den Verschlüsselungsmechanismus lege ich offen:
Für jeden Buchstaben verwende ich dessen Ascii Code. Genau so verfahre ich auch mit dem Schlüssel, welchen ich vorab ausgetauscht habe. Dann verwende ich jeweils ein xor und aus der erhaltenen Zahl mache ich wieder einen Ascii Wert. Hier ein Codebeispiel:

Code: Alles auswählen

#!/usr/bin/python

import operator

cleartext = ['G','e','k','n','a','c','k','t']
ciphertxt = ['R','a','M','l','p','o','e','B']

for a in range(len(cleartext)):
    print chr(operator.xor(ord(cleartext[a]), ord(ciphertxt[a]))),

- Und als Non-Plus-Ultra liefere ich dir sogar noch den Unverschlüsselten Text. Allerdings musst du herausfinden welcher der Drei Worte nun das gewünschte Objekt ist und welche davon hinzugedichtet sind: Buch, Bett, Bank.

Du hast also von mir Eine Gruppe von Wörtern, von denen EINES mein gewünschtes Objekt darstellt. Du hast den Verschlüsselungsmechanismus (ein XOR kehrt man mit einem XNOR um) und du weisst wie der verschlüsselte Text lautet.

Somit hast du eigentlich alles bis auf den zufällig erstellten Verschlüsselungs Text. Und trotzdem wirst du es nicht schaffen sagen zu können, was mir der Python Master 47 denn nun besorgen soll.

Lieber Gruss
STiGMaTa

[Python 47]

Da warst du aber sehr freundlich Sigma!

Nur um das nochmal zu ergänzen:

Murph:
Du hast alles 3 und wirste es nicht rausbekommen(Unter der Vorraussetzung, das die Zufallsdaten wirklich zufällig sind) du könntest nur raten.

Jetzt könntest du ja folgendes sagen:

Ja und ist mir doch egal, ich kann zwar nicht das richtige Wort rausbekommen, aber ich nehme einfach alle 3 Möglichkeiten.

Dazu muss man folgendes sagen. Du wirst nie soviel Infos bekommen sprich die Ausgangsworte etc. Du bekommst in der Realität nur die Verschlüsselte Nachricht. Das heißt es kann nicht nur Bett, Bank und Buch sein sondern auch Ball, Keks, Tuch, Hemd, Hose, Bild, Saft, Band, Dvds, Geld etc.
Da gibt es 1000 te Möglichkeiten und alle sind gleich Wahrscheinlich.

[murph]

naja, das ist aber auch eine möglichkeit, dateien zusammzufassen.
wer sich schon einmal kaza, sheraza, xmule uä angekuckt hat, wird sehen, dass die lieder nur dadurch zusammengefasst werden, dass sie die gleiche länge haben. der name ist egal, solange jedes lied 3,258,561 bytes lang ist...
also filme, deren qualität man kennt, kann man entschlüsseln.
das war aber auch nur ein gedankenspiel ohne realer anwendung, da wenn man weiß, was es ist, man es nicht mehr zu entschlüsseln bbrauch (mit dem passwort kann man ja auch nichts anfangen )

[Python 47]

Ok ich gebs auf. Les dir am besten nochmal alles Posts durch und geh auf wikipedia und google mal nach One Time Pad.

Waren meine Erklären denn so schlecht, das man die Beispiele nicht versteht?

[Leonidas]

wer sich schon einmal kaza, sheraza, xmule uä angekuckt hat, wird sehen, dass die lieder nur dadurch zusammengefasst werden, dass sie die gleiche länge haben. der name ist egal, solange jedes lied 3,258,561 bytes lang ist...

Falsch: xMule ist ein eDonkey-Client, der Dateien anhand eines Hashes identifiziert, dieser wird aus dem Inhalt der Datei generiert, nicht aus ihrer Länge. Shareaza unterstützt ebenso das eDonkey-Protokoll und auch das BitTorrent-Protokoll, welches die Datei in Chunks teilt und diese Chunks haben selbst nochmal Hashes.

Davon abgesehen hat das mit One-Time-Pad nichts zu tun.