Я бы добавил, что вы можете взглянуть на Multivariate Public Key Crypto Systems (часто сокращенно MVKP), которая является еще одной активной областью интереса в сфере криптографии, устойчивой к квантовым вычислениям.

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

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

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

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

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

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

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

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

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

Из Википедия

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

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

Подготовка

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

Реализация

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

Резюме

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

Followup

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

Во-первых, причина того, что большинство описаний в Интернете кажутся такими глупыми, заключается в том, что все они, похоже, взяты из нескольких патентных заявок. Патентные заявки на новые формулы и алгоритмы всегда имеют тенденцию что-то скрывать, потому что это так. Общеизвестно, что трудно контролировать нелицензионное использование таких вещей, и заявители пытаются балансировать между патентной защитой и защитой коммерческой тайны. Дело здесь в том, что это не обязательно означает, что это все 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 также является слабой функцией шифрования и, хотя он совершенно безопасен для одного сообщения, если мы используем его более одного раза с одним и тем же key (k), становится очень легко реконструировать (k), что делает XOR небезопасным для систем шифрования с одним ключом. Это можно решить, используя каждый раз другой ключ:

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

и

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

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

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

Решением этого является использование МК Мастер Ключа и другого функция шифрования 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

Полный проект Visual Studio для Windows и 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 в приведенном выше уравнении. Вторые два двойных значения определяют действительную и мнимую части начального значения, которое используется для генерации начальных 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 против зашифрованного текста в получателе, чтобы расшифровать его.

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

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