
Aber der Punkt, dass beide Seiten gleiche Zufallszahlen ermitteln und dann abgleichen und danach "wegwerfen", ist ja schon sehr schwer, also, wieviel Zufall ist das denn, wenn m´beide Seiten das gleiche ermitteln, ohne abzugleichen?
Dann würde ich dir mal empfehlen genauer zu lesenmurph hat geschrieben:dann hast du unsauber gelesen! Jedes mal wird ein neues Passwort vom System entworfen, auch wenn ich diese abspeicher, ist sie jedes mal neu, wenn ich was verschlüssele...
BlackJack hat geschrieben: Bei echtem One-Time-Pad braucht man keine Passwörter sondern nur die gleichen Zufallsdaten auf beiden Seiten.
Es werden nicht auf beiden Seiten gleiche Zufallszahlen ermittelt. Wenn man das könnte dann sind die Zahlen ja nicht mehr zufällig, sondern berechenbar.murph hat geschrieben: Aber der Punkt, dass beide Seiten gleiche Zufallszahlen ermitteln und dann abgleichen und danach "wegwerfen", ist ja schon sehr schwer, also, wieviel Zufall ist das denn, wenn m´beide Seiten das gleiche ermitteln, ohne abzugleichen?
Das heisst Du müsstest für jede Nachricht die gleiche Menge an Zufallsdaten in der "a.501" auf einem sowieso schon sicheren Weg übermitteln. Dann kannst Du doch über diesen Kanal gleich die eigentliche Nachricht übermitteln und die Verschlüsselung sparen. Und wozu brauchst Du das zusätzliche Passwort?murph hat geschrieben:aber ist dann "a.501" nicht ausreichend? die datei wird vertrauenswürdig überliefert und danach vom rechner am besten gelöscht,
bei der nächsten Datei werden dann neue Zufallszahlen ermittelt.
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 hat geschrieben: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.
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.murph hat geschrieben: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!!!
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.murph hat geschrieben: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.
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()
Code: Alles auswählen
alice> onetimepad.py generate --pad-size 650 bob.pad
Code: Alles auswählen
alice> onetimepad.py crypt --offset 0 klartext.txt verschluesselt-0.msg bob.pad
42
Code: Alles auswählen
alice> onetimepad.py crypt --offset 42 nachtrag.txt verschluesselt-42.msg bob.pad
656
Code: Alles auswählen
bob> onetimepad.py crypt --offset 42 verschluesselt-42.msg von_alice.txt bob.pad
656
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.BlackJack hat geschrieben: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.
Könnte man da auch Akustische Aufnahmen nehmen? Also z.B. ein billigst Mikrofon hinstellen und einfach einige Zeit die Umgebung aufnehmen?Python Master 47 hat geschrieben:[...]Das kann aber nur sein, wenn die Zufallsdaten absolut unabhängig generiert wurden z.B. thermisches Rauschen