Во-первых, причина того, что большинство статей в Интернете кажутся такими тупыми, заключается в том, что все они, похоже, взяты из нескольких патентных заявок. Патентные заявки на новые формулы и алгоритмы всегда имеют тенденцию скрывать что-то, потому что они есть. Общеизвестно, что полиция нелицензионно использует такие вещи, и заявители пытаются преодолеть границу между патентной защитой и защитой коммерческой тайны. Дело в том, что это не обязательно означает, что все это BS.
Во-вторых, все известные мне фрактальные отображения в той или иной степени являются «потерями», потому что отображения не строго 1 к 1. Хотя это хорошая причина полагать, что не существует эффективного способа сломать код, это также означает, что все, что непосредственно "зашифровано" фракталом с потерями, также не может быть расшифровано, даже с помощью ключа. Таким образом, любой вид прямого фрактального хеширования необратим.
Следовательно, Fratcal Encryption не может означать, что само сообщение напрямую зашифровано с помощью фрактала. Скорее, это должно означать, что фрактал используется в качестве «главного ключа» для одновременной генерации «локальных» или «последовательных» ключей, которые затем используются для шифрования и дешифрования фактических сообщений.
Прежде чем мы продолжим, давайте рассмотрим основы шифрования:
Принципы алгоритма шифрования
Допустим, у вас есть серии сообщений M (j) для j = 1 до N, которые вы хотите безопасно передавать Получающей стороне. Вам понадобится функция обратимого шифрования E, например:
E(M(j), k) --> X(j)
Где (k) - ключ шифрования, а X (j) - соответствующее зашифрованное сообщение. Затем сообщение передается нашему получателю, у которого есть дополнительная функция E 'для расшифровки зашифрованного сообщения:
E'(X(j), k) --> M(j)
Однако, AFAIK, вы не можете использовать функции E () и E '() с помощью фракталов. С другой стороны, есть некоторые функции, такие как XOR, которые являются собственными дополнениями:
( M(j) XOR k ) --> X(j) *and also* ( X(j) XOR k ) --> M(j)
Но XOR также является слабой функцией шифрования, и, хотя она совершенно безопасна для одного сообщения, если мы используем его более одного раза с одним и тем же ключом (k), обратная инженерия (k) становится очень простой, таким образом делая XOR небезопасным для систем шифрования с одним ключом. Это можно решить, используя каждый раз другой ключ:
M(j) XOR K(j) --> X(j)
и
X(j) XOR K(j) --> M(j)
Это решает одну проблему, но вводит другую, то есть как мы можем гарантировать, что и отправитель, и получатель имеют одинаковый набор ключей? Передача серии ключей не является решением, потому что это возвращает нас к первоначальной проблеме безопасной передачи серии сообщений.
Вместо этого мы хотим создать серию идентичных ключей как для отправителя, так и для получателя независимо. Но нам нужно иметь возможность генерировать ряд ключей, которые криптографически безопасны сами по себе. То есть, даже если внешний наблюдатель знает все предыдущие ключи, он все равно не сможет предсказать следующий ключ в серии с какой-либо точностью. И поскольку каждый раз нам понадобятся совершенно разные серии ключей (чтобы сделать их неосуществимыми), нам действительно нужна сама серия ключей на основе ключей.
Решением этой проблемы является использование мастер-ключа MK и другой функции шифрования H для генерации специальных ключей для каждого сообщения:
H(MK, j) --> K(j); M(j) XOR K(j) --> X(j)
и
H(MK, j) --> K(j); X(j) XOR K(j) --> M(j)
Это то место, куда приходят наши Фракталы, потому что, как мы видим выше, функция H не нуждается в дополнительной функции H '. Таким образом, мы можем свободно использовать функцию на основе фрактала с главным ключом для генерации нашей серии локальных ключей.
Пример реализации и пояснения
Ниже приведен класс VB.NET, демонстрирующий этот подход, наивная реализация Fractal Encryption:
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
Полный проект Visual Studio для Windows и exe для Windows можно найти по адресу http://www.codeplex.com/FractalEncryptDemo
Этот класс использует множество Джулии, основанное на квадратичной рекурсии Z (i + 1) = Z (i) ^ 2 - C в комплексной плоскости. Сгенерированный мастер-ключ состоит из 5 чисел, 4 значений с плавающей запятой двойной точности от 0 до 1 и 1 целого числа от 1 до 1 000 000 000. Первые два двойных значения определяют действительную и мнимую части C в приведенном выше уравнении. Вторые два двойных определяют действительную и мнимую части начального значения, которое используется для генерации начальных Z.
Оба эти значения отображаются (посредством операций модуля) в небольшую квадратную область от (0,1, 0,1) до приблизительно (0,55, 0,55). Это сделано для того, чтобы убедиться, что наши расчеты фракталов не переполнены или не переполнены (хотя я не уверен, что это все еще невозможно). Наконец, целочисленное значение служит смещением для наших значений последовательности (наш «j» в формулах выше).
Сообщение кодируется четырьмя символами ascii одновременно. Сначала порядковый номер (j) добавляется к смещению последовательности, которое используется вместе с 4-байтовым смещением в сообщении как комплексное число, которое умножается на комплексное значение Seed, а затем снова отображается в активный прямоугольник, чтобы получить начальное значение Z Затем рекурсия множества Джулии (Z = Z ^ 2 + C) применяется 16 раз, и окончательный результат снова возвращается в активный прямоугольник.
Затем это окончательное комплексное значение умножается на 2 ^ 30, и действительная, и мнимая части преобразуются в целые числа, а затем нижние 16 бит каждой используются для предоставления 32 бит (4 байта) локального ключа. Тогда это XOR против соответствующих 4 байтов сообщения у отправителя, чтобы зашифровать его, или XOR против зашифрованного текста у получателя, чтобы его расшифровать.