Fraktale Verschlüsselung

Erste, der Grund, dass die meisten die schreiben-USV über das internet scheinen so stumpf ist, dass Sie alle zu sein scheinen, gezeichnet von einer Handvoll von Patentanmeldungen. Patentanmeldungen für neue Formeln & algorithmen immer dazu neigen, scheinen etwas zu verheimlichen, weil Sie sind. Es ist notorisch schwierig zu Polizei, die nicht lizenzierte Verwendung von solchen Dingen und der Antragsteller versuchen, straddle die Grenze zwischen Patentschutz und Schutz von Betriebsgeheimnissen. Der Punkt hier ist, dass es nicht unbedingt bedeutet, dass es ist alle BS.

Zweitens, alle Fraktal-Zuordnungen, die ich kenne, sind zum Teil oder in ein anderes "lossy", weil die mapings sind nicht unbedingt 1 zu 1. Zwar ist dies ein guter Grund, zu glauben, dass es keine effiziente Weise, um den code knacken, es bedeutet auch, dass alles, was direkt "verschlüsselt", die durch eine verlustbehaftete Fraktale, können nicht entschlüsselt werden, selbst mit dem Schlüssel. Daher ist jede Art von direkten Fraktale Hash nicht umkehrbar ist.

Daher Fratcal Verschlüsselung kann nicht bedeuten, dass die Nachricht selbst ist direkt verschlüsselt mit dem fractal. Sie muss vielmehr bedeuten, dass das fraktal ist als "master-key" zu aktivieren gleichzeitigen Erzeugung von "local" oder "sequential" - Schlüssel wird dann zum verschlüsseln und entschlüsseln der eigentlichen Nachrichten.

Bevor wir weiter gehen, lasst uns die Grundlagen der Verschlüsselung:

Verschlüsselungsalgorithmus Prinzipien

Können sagen, Sie haben eine Reihe von Nachrichten M(j) für j=1 bis N, die Sie wollen in der Lage sein, um sicher zu übertragen, um eine Empfangende Partei. Sie benötigen eine reversible encryption-Funktion E so:

E(M(j), k) --> X(j)

Wo (k) ist ein Verschlüsselungsschlüssel und X(j) ist der entsprechende verschlüsselte Nachricht. Dann wird die Nachricht übertragen wird, zum Empfänger, wer hat eine Ergänzende Funktion E' zu entschlüsseln, die verschlüsselte Nachricht:

E'(X(j), k) --> M(j)

Aber AFAIK kann man nicht machen, beide ein E() und E' () - Funktion mithilfe von Fraktalen. Auf der anderen Seite, gibt es einige Funktionen wie XOR, die Ihre eigenen ergänzt:

( M(j) XOR k ) --> X(j)  *and also* ( X(j) XOR k ) --> M(j)

Aber XOR ist auch eine schwache Verschlüsselung-Funktion und es ist zwar absolut sicher, für eine einzelne Nachricht, wenn wir es verwenden, mehr als einmal mit dem gleichen key (k), wird es sehr einfach zu reverse-engineer (k), so dass XOR unsicher für den single-key-Verschlüsselungssysteme. Dieses Problem kann gelöst werden, indem eine andere Taste jedes mal:

M(j) XOR K(j) --> X(j)

und

X(j) XOR K(j) --> M(j)

Dies löst ein problem, aber führt eine andere, die ist, wie können wir versichern, dass sich sowohl Absender als auch Empfänger den gleichen Schlüssel? Übertragen der Reihe von Tasten ist keine Lösung, denn das führt uns zurück zu dem ursprünglichen problem der sicheren übertragung einer Reihe von Nachrichten.

Stattdessen wollen wir generieren eine Reihe von identischen Schlüssel auf den sender und Empfänger unabhängig voneinander. Aber wir müssen in der Lage sein zu generieren, die eine Reihe von Schlüsseln, die sind kryptografisch sicherer in Ihrem eigenen Recht. Das heißt, auch wenn ein externer Beobachter, der wusste, dass alle vorstehenden Tasten, Sie wären noch nicht in der Lage, vorherzusagen, die nächsten in der Reihe mit beliebiger Genauigkeit. Und da brauchen wir eine ganz andere Reihe von Tasten jedes mal (um Sie unguessable) brauchen wir eigentlich die Key-Serie selbst zu Schlüssel-basiert.

Die Lösung HIERFÜR ist die Verwendung eines Master-Schlüssel MK, und eine andere Verschlüsselung-Funktion H, die zum generieren der spezifischen Schlüssel für jede Nachricht:

H(MK, j) --> K(j);  M(j) XOR K(j) --> X(j)

und

H(MK, j) --> K(j);  X(j) XOR K(j) --> M(j)

Dies ist, wo unsere Fraktale kommen, denn wie wir oben sehen können, die H-Funktion nicht benötigen eine Ergänzende Funktion H'. So können wir frei verwenden, ein Fraktal-basierte Funktion mit einem master-Schlüssel zu generieren unsere Reihe von lokalen Schlüsseln.

Beispiel die Umsetzung und Erklärung

Unten ist ein VB.NET Klasse, die diesen Ansatz veranschaulicht, eine naive Implementierung der Fraktale Verschlüsselung:

Option Explicit On

Public Class FractalEncrypt
'Fractal Encryption /Decryption demo class'
' 2009-08-08    RBarryYoung Created.'
' note: '
'   Property of R. Barry Young & Proactive Performance Solutions, Inc.,'
'   protected under open source license'
Public Const CrLower As Double = 0.1
Public Const CrUpper As Double = Math.PI /(2 * Math.E)
Public Const CiLower As Double = 0.1
Public Const CiUpper As Double = Math.PI /(2 * Math.E)

Public ReadOnly Cr As Double, Ci As Double, Sr As Double, Si As Double
Public ReadOnly BaseSeq As Integer

Public Sub New(ByVal KeyR As Double, ByVal KeyI As Double, ByVal SaltR As Double _
        , ByVal SaltI As Double, ByVal SeqStart As Integer)
    Cr = ((KeyR - CrLower) Mod (CrUpper - CrLower)) + CrLower
    Ci = ((KeyI - CiLower) Mod (CiUpper - CiLower)) + CiLower

    Sr = ((SaltR - CrLower) Mod (CrUpper - CrLower)) + CrLower
    Si = ((SaltI - CiLower) Mod (CiUpper - CiLower)) + CiLower

    BaseSeq = SeqStart
End Sub

Public Function Encrypt(ByVal Text As String, ByVal Seq As Integer) As String
    'Encrypt the string passed, adding on the sequence as a header.'
    Debug.Print("Encrypt<" & Seq & ">" & Len(Text) & ":" & Text)
    Dim CurSeq = BaseSeq + Seq
    'make the sequence prefix'
    Dim enc As String = Format(Seq, "000000000") & ":"

    Dim EncryptedOffset As Integer = 0
    Do While EncryptedOffset < Len(Text)
        'encrypt each 4 characters separately'
        enc = enc & Encrypt4(Text, EncryptedOffset, CurSeq)
        EncryptedOffset = EncryptedOffset + 4
    Loop

    Return enc
End Function

Public Function Decrypt(ByVal CrypText As String) As String
    'Decrypt the string passed, extracting the Sequence header first.'

    'Extract the sequence'
    Dim Seq As Integer = CInt(Left(CrypText, 9))
    Dim CurSeq = BaseSeq + Seq

    'Extract the encrypted message payload'
    CrypText = Mid(CrypText, 11)
    Debug.Print("Decrypt<" & Seq & ">" & Len(CrypText) & ":" & CrypText)

    'Now decrypt it 4 characters at a time'
    Dim txt As String = ""
    Dim EncryptedOffset As Integer = 0
    Do While EncryptedOffset < Len(CrypText)
        'encrypt each 4 characters separately'
        txt = txt & Encrypt4(CrypText, EncryptedOffset, CurSeq)
        EncryptedOffset = EncryptedOffset + 4
    Loop

    Return txt
End Function

Public Function Encrypt4(ByVal text As String, ByVal StrOffs As Integer _
        , ByVal CurSeq As Integer) As String
    'Encrypt/Decrypt 4 characters of the string.'
    ' (note: encrypt and decrypt are the same because XOR is its own complement)'
    Dim str As String = Mid(text, StrOffs + 1, 4)
    Dim enc As String

    'generate the seeds from the current message sequence and the current string offset'
    '1.   define complex Seq as (CurSeq, StrOffs)'
    Dim SeedR As Double = (Sr * CurSeq) - (Si * StrOffs)
    Dim SeedI As Double = (Sr * StrOffs) + (Si * CurSeq)
    '2.   remap the result back into the valid range'
    SeedR = SeedR Mod (CrUpper - CrLower)
    SeedI = SeedI Mod (CiUpper - CiLower)

    'generate the local keys from the master keys'
    Dim Zr As Double = SeedR, Zi As Double = SeedI
    Dim r As Double, i As Double, zx As Integer = 0, zy As Integer = 0
    '1.  apply the julia formula 16 times to hash it up good.'
    For j As Integer = 1 To 16
        'Z(n+1) = Z(n)^2 - C:'
        r = Zr * Zr - Zi * Zi - Cr
        i = 2 * Zr * Zi - Ci
        If Double.IsInfinity(r) Or Double.IsNaN(r) Then r = (zx \ zy) 'force an error'
        If Double.IsInfinity(i) Or Double.IsNaN(i) Then i = (zx \ zy) 'force an error'
        'put back into Z:'
        Zr = r : Zi = i
    Next
    '2.  remap the back into our results window'
    Zr = ((Zr - CrLower) Mod (CrUpper - CrLower)) + CrLower
    Zi = ((Zi - CiLower) Mod (CiUpper - CiLower)) + CiLower

    'Form the local keys into the Mask Keys variables (M).'
    Dim Mr As Integer, Mi As Integer
    '1.  scale them both into the range of about 2^30.'
    Mr = CInt((1024 * 1024 * 1024) * (Zr - CrLower) /(CrUpper - CrLower))
    Mi = CInt((1024 * 1024 * 1024) * (Zi - CiLower) /(CiUpper - CiLower))
    '2.  only use the lower 16 bits that are left:'
    Mr = Mr And 65535 : Mi = Mi And 65535

    'encode the current 4 characters as a 2 * 2-byte integer'
    Dim R2 As Integer, I2 As Integer
    If StrOffs + 1 <= Len(text) Then R2 = Asc(Mid(text, StrOffs + 1, 1))
    If StrOffs + 2 <= Len(text) Then R2 = R2 + 256 * Asc(Mid(text, StrOffs + 2, 1))
    If StrOffs + 3 <= Len(text) Then I2 = Asc(Mid(text, StrOffs + 3, 1))
    If StrOffs + 4 <= Len(text) Then I2 = I2 + 256 * Asc(Mid(text, StrOffs + 4, 1))

    'Encrypt (or Decrypt) the data by masking it with the local Keys'
    R2 = R2 Xor Mr
    I2 = I2 Xor Mi

    'recode them as ascii strings again:'
    enc = Chr(R2 And 255) & Chr(R2 \ 256) & Chr(I2 And 255) & Chr(I2 \ 256)

    Return enc
End Function
End Class

Einer kompletten Visual Studio-Windows-Projekt und eine Windows exe finden Sie unter http://www.codeplex.com/FractalEncryptDemo

Diese Klasse verwendet die Julia-Menge auf der Grundlage der Quadratische Rekursion Z(i+1) = Z(i)^2 - C in der komplexen Ebene. Der Master-Key generiert und besteht aus 5 zahlen, 4 Double precision Fließkomma-Werte zwischen 0 und 1, und 1 ganze Zahl zwischen 1 und 1.000.000.000. Die ersten beiden double-Werte definieren den real-und Imaginärteil von C in der Gleichung oben. Die zweiten zwei Doppelzimmer definieren Sie die realen und imaginären Teile einer seed-Wert, der verwendet wird zum generieren der Start Z ist.

Diese beiden Werte zugeordnet sind (über modulo-Operationen) in ein kleines Quadrat-Bereich von (0.1, 0.1) auf rund (0.55, 0.55). Dies geschieht, um zu versuchen und sicherzustellen, dass unsere fraktalen Berechnungen nicht überlauf oder Unterlauf (obwohl ich bin nicht sicher, dass dies nicht immer möglich). Endlich, der integer-Wert dient als offset für unsere Sequenz Werte (unser "j" in den Formeln oben).

Nachricht codiert werden vier ascii-Zeichen in einer Zeit. Zuerst wird die Sequenz-Nummer (j) wird Hinzugefügt, um die Sequenz-offset, der verwendet wird, zusammen mit der 4-byte-offset in der Nachricht als eine komplexe Zahl, die multipliziert mit dem komplexen Saatgut-Wert und dann neu zugeordnet, zurück in das aktive Rechteck, um unsere Start Z-Wert. Dann die Julia-Menge der Rekursion Z = Z^2 + C) angewendet wird 16 mal und das Ergebnis ist wieder neu zugeordnet, zurück in das aktive Rechteck.

Dieser Letzte komplexe Wert wird dann multipliziert mit 2^30, die beide von real-und Imaginärteil werden in Ganzzahlen konvertiert und anschließend die unteren 16 bits jedes werden verwendet, um die 32 bits (4 bytes) der lokale Schlüssel. Das ist dann XOR würde gegen die entsprechende Mitteilung 4 bytes beim sender zu verschlüsseln, oder XOR würde gegen den verschlüsselten text an den Empfänger zu entschlüsseln.

Möchte ich hinzufügen, möchten Sie vielleicht werfen Sie einen Blick auf Multivariate Public Key Crypto-Systems (oft abgekürzt MVKP), ist ein weiteres aktives Gebiet von Interesse in den Bereich der Quanten-computing resistant cryptography.

Nur weil etwas verwiesen wird in Star Trek macht es nicht die beste Wahl 😉

Gibt es Code-Projekt jetzt mit C# zu fordern, zu implementieren Fraktale Verschlüsselung.

Den fraktalen Verschlüsselungsalgorithmus verwendet die berühmte Mandelbrot-fraktal zu konvertieren Schlüssel für die Verschlüsselung (vom Benutzer bereitgestellt), um eine längere Schlüssel ist anschließend XORed mit dem plain-text (vom Benutzer bereitgestellt), die sich in einem verschlüsselten text. Der Algorithmus, wie beschrieben und implementiert, die hierin nachfolgend ist neu, erfunden von mir in einem moment der Kreativität (also nach dem Mittagessen, um 14.30 Uhr, mit Augen, die halb geschlossen ist), und kodiert in den nächsten morgen: das bedeutet, dass es könnte Zufall sein, eine sehr starke Verschlüsselungs-Algorithmus, ABER es könnte auch das Gegenteil sein (D. H. ein encrAption-Algorithmus), und so kommt es mit keine Garantie.

natürlich in die Kommentare:

Wenn Fraktale gebilde erzeugen einen Schlüssel, aber der Schlüssel ist nur XORed mit der Nachricht die Verschlüsselung ist weit von starken, Zitat von wikipedia (http://en.wikipedia.org/wiki/XOR_cipher):