во-первых, причина того, что большинство записей в интернете кажутся настолько тупыми, заключается в том, что все они, по-видимому, взяты из нескольких патентных заявок. Патентные заявки на новые формулы и алгоритмы всегда имеют тенденцию что-то скрывать, потому что они есть. Общеизвестно, как трудно контролировать нелицензированное использование таких вещей, и заявители пытаются преодолеть грань между патентной защитой и защитой коммерческой тайны. Дело в том, что это не обязательно означает, что это все чушь.

во-вторых, все фрактальные отображения, о которых я знаю, в той или иной степени "потеряны", потому что отображения не являются строго 1 к 1. Хотя это хорошая причина полагать, что нет эффективного способа сломать код, это также означает, что что-либо непосредственно "зашифрованное" фракталом с потерями, также не может быть расшифровано, даже с ключом. Таким образом, любой вид прямого фрактального хеширования необратим.

поэтому шифрование Fratcal не может означать, что само сообщение напрямую зашифровано с помощью фрактала. Скорее, это должно означать, что фрактал используется в качестве" главного ключа "для одновременной генерации" локальных "или" последовательных " ключей, которые затем используются для шифрования и дешифрования фактических сообщений.

прежде чем мы пойдем дальше, давайте рассмотрим основы шифрования:

Принципы Алгоритма Шифрования

допустим, у вас есть серия сообщений 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 класс, демонстрирующий этот подход, наивная реализация фрактального шифрования:

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

полный проект Windows Visual Studio и Windows exe можно найти по адресу http://www.codeplex.com/FractalEncryptDemo

этот класс использует множество Юлии, основанное на квадратичной рекурсии Z(i+1) = Z (i)^2 - C в комплексной плоскости. Сгенерированный мастер-ключ состоит из 5 чисел, 4 значений с плавающей запятой двойной точности между 0 и 1 и 1 целого числа между 1 и 1,000,000,000. Первые два двойных значения определяют действительную и мнимую части C в приведенном выше уравнении. Два вторых двойника определяют действительную и мнимую части семени значение, которое используется для генерации начального "я".

оба эти значения отображаются (через операции модуля) в небольшую квадратную область от (0.1, 0.1) до приблизительно (0.55, 0.55). Это делается для того, чтобы попытаться гарантировать, что наши фрактальные вычисления не переполняются или не перетекают (хотя я не уверен, что это все еще невозможно). Наконец, целочисленное значение служит смещением для наших значений последовательности (наше "j" в приведенных выше формулах).

сообщение кодируются четыре ascii персонажи за раз. Сначала порядковый номер (j) добавляется к смещению последовательности, которое используется вместе с 4-байтовым смещением в сообщение как комплексное число, которое умножается на комплексное начальное значение, а затем переназначается обратно в активный прямоугольник, чтобы получить наше начальное значение Z. Затем рекурсия набора Юлии (Z = Z^2 + C) применяется 16 раз, и конечный результат снова переназначается обратно в активный прямоугольник.

это конечное комплексное значение затем умножается на 2^30, как реальная, так и мнимая части преобразуются в целые числа, а затем нижние 16 бит каждого используются для предоставления 32 бит (4 байта) локального ключа. Это тогда XOR'D против соответствующих 4 байтов сообщения у отправителя, чтобы зашифровать его, или XOR'D против зашифрованного текста у получателя, чтобы расшифровать его.

Я слышал об этом подходе. Но это гораздо больше игрушка, чем алгоритм реального мира:

вы используете окно координат набора Мандельброта в качестве "пэда", фиксируя свой вход или что-то еще, и, таким образом, координаты окна (и интервал ваших образцов) становятся вашим"паролем". Если вы выберете очень глубокое окно в наборе, вам понадобится очень много итераций для оценки, и теоретически это трудно сделать.

следите за большими полосы сплошных чисел.. возможно, бег-длина закодированных mandlebrot.

Я думаю, кто-то думает, что это может быть "квантовое доказательство", потому что это итеративно, вы не можете подсчитать, сколько итераций потребуется для местоположения в наборе мандлеброта, чтобы сходиться без итерации. Не знаю, правда это или нет.

тем не менее, я не думаю, что есть какие-либо преимущества в этом (кроме того, называя его "фракталом"), и есть тонны недостатков и возможностей для создания vulnerablities. Вам было бы намного лучше использовать хорошо изученный алгоритм шифрования с открытым/закрытым ключом.

Я бы добавил, что вы, возможно, захотите взглянуть на Многомерные Криптосистемы С Открытым Ключом (часто сокращенно MVKP), который является еще одной активной областью интереса в области устойчивой к квантовым вычислениям криптографии.

просто потому что что-то ссылка в Star Trek не делает его лучшим выбором;)

нет системы шифрования, которая является "квантовым компьютерным доказательством", не говоря уже о нормальном компьютерном доказательстве. Все, что вы меняете, - это время, необходимое для взлома шифрования. Еще не доказано, что существует функция, для которой не существует таких обратных алгоритмов.

единственное "Нерушимое шифрование", которое у нас есть до сих пор, основано на квантовой модели, и даже тогда у нас все еще нет того, о чем вы думаете, когда видите квантовый компьютер.

системы D-Wave утверждают, что произвели компьютерный чип 128 кубитов, хотя это заявка еще не проверена.

с Википедия

первый электронный квантовый процессор был создан совсем недавно.

теперь есть проект кода с C# претендуя на реализацию Фрактальное Шифрование.

алгоритм фрактального шифрования использует знаменитый фрактал Мандельброта для преобразования ключа шифрования (предоставленного Пользователем) в более длинный ключ, который впоследствии XORed с простым текстом (предоставленным пользователем), что приводит к зашифрованному тексту. Алгоритм, описанный и реализованный ниже, является новым, изобретенным мной в момент творчества (т. е. после обеда, около 14.30, с полузакрытыми глазами), и закодирован на следующее утро: это означает, что это может быть случайно очень сильный алгоритм шифрования, но он также может быть противоположным (т. е. алгоритм захвата), и, таким образом, он поставляется без гарантии.

конечно в комментариях:

если фрактал используется для генерации ключа, но ключ просто XORed с сообщением, шифрование далеко не сильное, цитируя Википедию (http://en.wikipedia.org/wiki/XOR_cipher):

самый безопасный метод шифрования / дешифрования, который я когда-либо слышал, был один мой дед работал в ВВС США сразу после Второй мировой войны. Это вариация одноразовый pad, известная как (SIGSALY).

подготовка

во-первых, обнаружить фоновое излучение окружающей среды с помощью Гейгера-счетчика. Используйте место, где нет больших звуковых секций тишины или искусственной реакции от близлежащего источника излучения. Я не уверен статистика этого, но это был эквивалент записи космического микроволнового фона. Полученный саундтрек одновременно записывается на виниловые альбомы twin (the keys), а затем помечается. Одну копию посылаешь в передатчик, другую-в приемник. Не требуется много времени или усилий для создания большого количества пар дисков с совершенно случайными и, следовательно, уникальными записями.

реализация

когда приходит время передать безопасное сообщение, две станции договариваются, какую запись использовать. Случайный шум после этого использован как несущая передатчиком таким что приемник может достигнуть безмолвия путем отменять вне шум когда их экземпляр ключа в синхронизации с передавая ключом, таким же положением в записи и такой же скоростью воспроизведения.

резюме

с этой установленной несущей, вы можете гарантировать что никто не может расшифровать сообщение без получать твиновский диск используемый для того чтобы зашифровать сообщение. Это переводит безопасность сообщения из математической в физическую. Пока вы можете защитить записи и использовать каждую пару только один раз, у вас есть идеальная безопасность.

Followup

поскольку запись выполняется в аналоговом режиме, влияет ли это на то, сколько кубитов потребуется квантовому компьютеру, чтобы разбить этот тип сообщения?