Guten Tag,
Ich bin gerade auf eine neue Methode für One-Time-Pad Generierung gestoßen.
Ich werde es kurz erläutern und im Anschluss ein paar Fragen in den Raum werfen.
********************************
Key#1 - 110 (Länge 3)
Key#2 - 0101 (Länge 4)
Key#1 unendlich oft aneinandergereiht XOR
Key#2 unendlich oft aneinandergereiht
=
1101 1011 0110 1101 1011 0110 (..) XOR
0101 0101 0101 0101 0101 0101 (..)
-------------------------------
1000 1110 0011 1000 1110 0011 (..) = Key#3
Man merkt, das Key#3 ab der 12. Stelle sich wiederholt, dh.
Key#3 = 1000 1110 0011
Wir haben nun aus zwei kurzen Keys einen längeren generiert.
In der Quelle heißt es, dass der GGT beider Keys 1 sein soll, damit die Länge des generierten Schlüssels maximal wird.
Wenn GGT(Länge(Key#1), Länge(Key#2)) = 1 gilt, dann ist Länge(Key#3) = Länge(Key#1) * Länge(Key#2)
Ich habe mir Gedanken darüber gemacht, was passieren würde, wenn der GGT nicht 1 ist; auf folgendes bin ich gekommen:
Länge(Key#3) = Länge(Key#1) * Länge(Key#2) / GGT(Länge(Key#1),Länge(Key#2))
Bei unserem Beispiel kommen wir auf folgendes:
GGT(3, 4) = 1
Länge des gen. Keys = 3*4 = 12
Andere Beispiele:
GGT(2, 4) = 2
Länge = 4 * 2 / 2
= 4
GGT(768, 2048 ) = 256
Länge = 2048 * 768 / 256
= 2048 * 3
= 6144
Interessanteres Beispiel:
Länge(Key#1) ~ 32kb
Länge(Key#2) ~ 32kb
GGT = 1
Länge des gen. Schlüssels = 32kb * 32kb ~ 1gb
Key#1 und Key#2 können z.B. zwei verschiedene "Bilder" (jpg, bmp..) sein.
********************************
Soweit alles klar. Nun habe ich diesbezüglich zwei Fragen:
1. Inwiefern ist diese Methode der Schlüsselgenerierung besser/sinnvoller als z.B. die Generierung über einen Random Number Generator?
2. Welche Attribute hat der generierte Schlüssel? Ist er wirklich genauso sicher wie ein (pseudo~)zufällig generierter Schlüssel?
Quelle:
Inception E-Zine #1, 10.Power in simplicity
Ich bin gerade auf eine neue Methode für One-Time-Pad Generierung gestoßen.
Ich werde es kurz erläutern und im Anschluss ein paar Fragen in den Raum werfen.
********************************
Key#1 - 110 (Länge 3)
Key#2 - 0101 (Länge 4)
Key#1 unendlich oft aneinandergereiht XOR
Key#2 unendlich oft aneinandergereiht
=
1101 1011 0110 1101 1011 0110 (..) XOR
0101 0101 0101 0101 0101 0101 (..)
-------------------------------
1000 1110 0011 1000 1110 0011 (..) = Key#3
Man merkt, das Key#3 ab der 12. Stelle sich wiederholt, dh.
Key#3 = 1000 1110 0011
Wir haben nun aus zwei kurzen Keys einen längeren generiert.
In der Quelle heißt es, dass der GGT beider Keys 1 sein soll, damit die Länge des generierten Schlüssels maximal wird.
Wenn GGT(Länge(Key#1), Länge(Key#2)) = 1 gilt, dann ist Länge(Key#3) = Länge(Key#1) * Länge(Key#2)
Ich habe mir Gedanken darüber gemacht, was passieren würde, wenn der GGT nicht 1 ist; auf folgendes bin ich gekommen:
Länge(Key#3) = Länge(Key#1) * Länge(Key#2) / GGT(Länge(Key#1),Länge(Key#2))
Bei unserem Beispiel kommen wir auf folgendes:
GGT(3, 4) = 1
Länge des gen. Keys = 3*4 = 12
Andere Beispiele:
GGT(2, 4) = 2
Länge = 4 * 2 / 2
= 4
GGT(768, 2048 ) = 256
Länge = 2048 * 768 / 256
= 2048 * 3
= 6144
Interessanteres Beispiel:
Länge(Key#1) ~ 32kb
Länge(Key#2) ~ 32kb
GGT = 1
Länge des gen. Schlüssels = 32kb * 32kb ~ 1gb
Key#1 und Key#2 können z.B. zwei verschiedene "Bilder" (jpg, bmp..) sein.
********************************
Soweit alles klar. Nun habe ich diesbezüglich zwei Fragen:
1. Inwiefern ist diese Methode der Schlüsselgenerierung besser/sinnvoller als z.B. die Generierung über einen Random Number Generator?
2. Welche Attribute hat der generierte Schlüssel? Ist er wirklich genauso sicher wie ein (pseudo~)zufällig generierter Schlüssel?
Quelle:
Inception E-Zine #1, 10.Power in simplicity
Zuletzt bearbeitet: