分形加密


部落用户
2025-02-06 06:09:59 (7天前)
  1. 我听说可以使用Mandlebrot套装的图纸来加密数据,这就是这个


加密
</跨度>
算法是

量子
</跨度>

  • 安全(不能打破

    量子
    </跨度>
    电脑,不像许多常用的……

8 条回复
  1. 0# 淋了一整夜的雨 | 2019-08-31 10-32



    我听说过这种方法。但它更像是一个玩具而不是现实世界的算法:



    您使用mandelbrot设置的坐标窗口作为“填充”,输入您的输入或其他内容,因此窗口的坐标(以及样本的间距)将成为您的“密码”。如果你在集合中选择一个非常深的窗口,你将需要很多迭代来进行评估,从理论上讲,它很难用力。



    注意大量固体数字……也许是一个游程编码的mandlebrot。



    我猜有人认为这可能是“量子证明”,因为它是迭代的,你无法计算在没有实际迭代的情况下,mandlebrot集合上的位置需要多少次迭代才能收敛。如果那是真的,我不知道。



    但是,我认为这样做没有任何好处(除了称之为“分形”),并且存在许多创造漏洞的缺点和机会。使用经过充分研究的公钥/私钥加密算法会好得多。


  2. 1# Let us fly | 2019-08-31 10-32



    我想补充一点,你不妨看看

    多变量公钥加密系统

    (通常缩写为MVKP),这是量子计算抗性密码学领域中另一个感兴趣的领域。



    只是因为有些东西

    在星际迷航中引用

    不是最好的选择;)


  3. 2# v-star*위위 | 2019-08-31 10-32



    我听过的最安全的加密/解密方法是我的祖父在第二次世界大战后立即在美国空军工作。这是一个变种

    一次性垫

    , 被称为 (

    SIGSALY

    )。



    制备



    首先,使用盖革计数器检测环境背景辐射。使用没有大型音频部分的位置,无论是沉默还是来自附近辐射源的人为反应。我不确定它的统计数据,但它相当于记录宇宙微波背景。产生的音轨同时记录在双乙烯基专辑(键)上,然后进行标记。您将一个副本发送到发送器,另一个发送到接收器。生成大量具有完全随机且因此独特的记录的磁盘对并不需要花费太多时间或精力。



    履行



    当发送安全消息时,两个站同意使用哪个标记记录。然后,随机噪声被发射器用作载波,使得接收器可以通过在其密钥的副本与发送密钥,记录中的相同位置和相同的回放速度同步时抵消噪声来实现静默。



    摘要



    建立此运营商后,您可以保证在没有获得用于加密消息的双磁盘的情况下,没有人可以对消息进行解密。这将消息的安全性从数学转换为物理安全。只要您能够保护记录并且一次只使用每对记录,您就拥有了完美的安全性。



    跟进



    由于记录是以模拟方式完成的,它是否会影响量子计算机需要多少量子位来打破这种类型的消息呢?


  4. 3# 只怕再见是故人 | 2019-08-31 10-32



    没有一个加密系统是“量子计算机证明”,更不用说正常的计算机证明了。所有你改变的是破解加密所需的时间。尚未证明存在任何不存在这种反向算法的函数。



    到目前为止,我们唯一的“牢不可破的加密”基于量子模型,即便如此,当你看到量子计算机时,我们仍然没有你想到的东西。




    D-Wave Systems声称已生产
    一个128比特的计算机芯片,尽管如此
    索赔尚未得到核实。





    维基百科





    第一个电子量子处理器最近才创建。


  5. 4# ࿏自ོ༾由ོ༽人͙⃡⌇ | 2019-08-31 10-32



    这是概述过程的一般文章:




    http://www.techbriefs.com/content/view/2579/32/



    这是更深入的,提供了算法和示例:




    http://medwelljournals.com/fulltext/ajit/2007/567-575.pdf


    (备用网址):

    http://docsdrive.com/pdfs/medwelljournals/ajit/2007/567-575.pdf



    sci.crypt小组对它进行了一些讨论:




    http://groups.google.com/group/sci.crypt/browse_thread/thread/f7ce14c1f6c0df3f/559895f2f267644?hl=en&ie=UTF-8&q=mandelbrot+fractal+encryption+algorithm



    这是日本的一家提供代码和样品的公司(看起来套装价格为50美元):




    http://www.summersoftlabs.com/intro.htm



    这是几分钟左右的结果,所以你的里程可能会有所不同。不过,这个话题听起来很有趣。即使它不是立即实用的,也很好有研究人员在思考这个问题的不同方法。


  6. 5# 日耀九洲 | 2019-08-31 10-32



    现在有Code Project

    C#

    声称要实施

    分形加密





    分形加密算法使用着名的Mandelbrot分形来将加密密钥(由用户提供)转换为更长的密钥,该密钥随后与纯文本(由用户提供)进行异或,从而产生加密文本。下面解释和实现的算法是新的,由我在创造力的时刻发明(即午餐后,大约14.30,眼睛半闭),并在第二天早上编码:这意味着它可能偶然是一个非常强加密算法,但它也可能是相反的(即加密算法),因此它没有保修。




    当然在评论中:




    如果使用分形来生成密钥,但密钥只是与消息进行异或,则加密远非强大,引用维基百科(

    http://en.wikipedia.org/wiki/XOR_cipher

    ):



  7. 6# 撩心 | 2019-08-31 10-32



    首先,互联网上的大多数文章看起来如此晦涩的原因是它们似乎都来自少数专利申请。新配方和专利申请算法总是倾向于隐藏某些东西,因为它们是。众所周知,很难控制未经许可使用此类物品,申请人试图跨越专利保护和商业秘密保护之间的界线。这里的要点是它并不一定意味着它都是BS。



    其次,我所知道的所有Fractal映射在某种程度上都是“有损”的,因为映射不是严格的1比1.虽然这是一个很好的理由相信没有有效的方法来破解代码,它也意味着任何通过有损分形直接“加密”的东西,即使使用密钥也无法解密。因此,任何类型的直接分形散列都是不可逆的。



    因此,Fratcal Encryption并不意味着消息本身就是



    用分形加密。相反,它必须意味着分形被用作“主密钥”,以便能够同时生成“本地”或“顺序”密钥,然后用于加密和解密实际消息。



    在我们进一步讨论之前,让我们回顾一下加密的基础知识:



    加密算法原理



    假设您有j = 1到N的系列消息M(j),您希望能够安全地传输到接收方。你需要一个可逆的加密函数E,如下所示:




    1. E(M(j), k) —> X(j)

    2. </code>


    其中(k)是加密密钥,X(j)是相应的加密消息。然后将消息发送给我们的接收器,该接收器具有补充功能E’以解密加密消息:




    1. E’(X(j), k) —> M(j)

    2. </code>


    但是,AFAIK使用Fractals不能同时使用E()和E’()函数。另一方面,有一些函数,如XOR,它们是它们自己的补充:




    1. ( M(j) XOR k ) —> X(j) and also ( X(j) XOR k ) —> M(j)

    2. </code>


    但是XOR也是一个弱加密函数,虽然它对于单个消息是完全安全的,但如果我们使用相同的密钥(k)多次使用它,则反向工程(k)变得非常容易,从而使XOR不安全用于单密钥加密系统。这可以通过每次使用不同的密钥来解决:




    1. M(j) XOR K(j) —> X(j)

    2. </code>






    1. X(j) XOR K(j) —> M(j)

    2. </code>


    这解决了一个问题,但引入了另一个问题,即我们如何确保发送方和接收方都拥有相同的密钥集?传输一系列密钥是没有解决方案的,因为这使我们回到了安全传输一系列消息的原始问题。



    相反,我们希望独立地在发送器和接收器上生成一系列相同的密钥。但是我们需要能够生成一系列本身具有加密安全性的密钥。也就是说,即使外部观察者知道所有前面的键,他们仍然无法准确地预测系列中的下一个键。而且因为我们每次都需要完全不同的一系列密钥(使它们不可思议),我们实际上需要Key系列本身是基于密钥的。



    解决方案是使用主密钥MK和不同的加密函数H,为每条消息生成特定密钥:




    1. H(MK, j) —> K(j); M(j) XOR K(j) —> X(j)

    2. </code>






    1. H(MK, j) —> K(j); X(j) XOR K(j) —> M(j)

    2. </code>


    这就是我们的Fractals的用武之地,因为正如我们上面所看到的,H函数不需要互补函数H’。因此,我们可以自由地使用基于分形的函数和主密钥来生成我们的一系列本地密钥。



    示例实现和说明



    下面是一个演示这种方法的VB.NET类,它是Fractal Encryption的一个天真实现:




    1. Option Explicit On

    2. 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)

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

    4. 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

    5. Sr = ((SaltR - CrLower) Mod (CrUpper - CrLower)) + CrLower
    6. Si = ((SaltI - CiLower) Mod (CiUpper - CiLower)) + CiLower
    7. BaseSeq = SeqStart
    8. End Sub

    9. 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”) & “:”

    10. Dim EncryptedOffset As Integer = 0
    11. Do While EncryptedOffset < Len(Text)
    12.     'encrypt each 4 characters separately'
    13.     enc = enc & Encrypt4(Text, EncryptedOffset, CurSeq)
    14.     EncryptedOffset = EncryptedOffset + 4
    15. Loop
    16. Return enc
    17. End Function

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

    19. 'Extract the sequence'
    20. Dim Seq As Integer = CInt(Left(CrypText, 9))
    21. Dim CurSeq = BaseSeq + Seq
    22. 'Extract the encrypted message payload'
    23. CrypText = Mid(CrypText, 11)
    24. Debug.Print("Decrypt<" & Seq & ">" & Len(CrypText) & ":" & CrypText)
    25. 'Now decrypt it 4 characters at a time'
    26. Dim txt As String = ""
    27. Dim EncryptedOffset As Integer = 0
    28. Do While EncryptedOffset < Len(CrypText)
    29.     'encrypt each 4 characters separately'
    30.     txt = txt & Encrypt4(CrypText, EncryptedOffset, CurSeq)
    31.     EncryptedOffset = EncryptedOffset + 4
    32. Loop
    33. Return txt
    34. End Function

    35. 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

    36. 'generate the seeds from the current message sequence and the current string offset'
    37. '1.   define complex Seq as (CurSeq, StrOffs)'
    38. Dim SeedR As Double = (Sr * CurSeq) - (Si * StrOffs)
    39. Dim SeedI As Double = (Sr * StrOffs) + (Si * CurSeq)
    40. '2.   remap the result back into the valid range'
    41. SeedR = SeedR Mod (CrUpper - CrLower)
    42. SeedI = SeedI Mod (CiUpper - CiLower)
    43. 'generate the local keys from the master keys'
    44. Dim Zr As Double = SeedR, Zi As Double = SeedI
    45. Dim r As Double, i As Double, zx As Integer = 0, zy As Integer = 0
    46. '1.  apply the julia formula 16 times to hash it up good.'
    47. For j As Integer = 1 To 16
    48.     'Z(n+1) = Z(n)^2 - C:'
    49.     r = Zr * Zr - Zi * Zi - Cr
    50.     i = 2 * Zr * Zi - Ci
    51.     If Double.IsInfinity(r) Or Double.IsNaN(r) Then r = (zx \ zy) 'force an error'
    52.     If Double.IsInfinity(i) Or Double.IsNaN(i) Then i = (zx \ zy) 'force an error'
    53.     'put back into Z:'
    54.     Zr = r : Zi = i
    55. Next
    56. '2.  remap the back into our results window'
    57. Zr = ((Zr - CrLower) Mod (CrUpper - CrLower)) + CrLower
    58. Zi = ((Zi - CiLower) Mod (CiUpper - CiLower)) + CiLower
    59. 'Form the local keys into the Mask Keys variables (M).'
    60. Dim Mr As Integer, Mi As Integer
    61. '1.  scale them both into the range of about 2^30.'
    62. Mr = CInt((1024 * 1024 * 1024) * (Zr - CrLower) / (CrUpper - CrLower))
    63. Mi = CInt((1024 * 1024 * 1024) * (Zi - CiLower) / (CiUpper - CiLower))
    64. '2.  only use the lower 16 bits that are left:'
    65. Mr = Mr And 65535 : Mi = Mi And 65535
    66. 'encode the current 4 characters as a 2 * 2-byte integer'
    67. Dim R2 As Integer, I2 As Integer
    68. If StrOffs + 1 <= Len(text) Then R2 = Asc(Mid(text, StrOffs + 1, 1))
    69. If StrOffs + 2 <= Len(text) Then R2 = R2 + 256 * Asc(Mid(text, StrOffs + 2, 1))
    70. If StrOffs + 3 <= Len(text) Then I2 = Asc(Mid(text, StrOffs + 3, 1))
    71. If StrOffs + 4 <= Len(text) Then I2 = I2 + 256 * Asc(Mid(text, StrOffs + 4, 1))
    72. 'Encrypt (or Decrypt) the data by masking it with the local Keys'
    73. R2 = R2 Xor Mr
    74. I2 = I2 Xor Mi
    75. 'recode them as ascii strings again:'
    76. enc = Chr(R2 And 255) & Chr(R2 \ 256) & Chr(I2 And 255) & Chr(I2 \ 256)
    77. Return enc
    78. End Function
      End Class

    79. </code>


    可以在以下位置找到完整的Visual Studio Windows项目和Windows exe

    http://www.codeplex.com/FractalEncryptDemo



    该类使用基于复平面中的二次递归Z(i + 1)= Z(i)^ 2-C的Julia集。生成的主密钥由5个数字组成,4个双精度浮点值介于0和1之间,1个整数介于1和1,000,000,000之间。前两个双精度值定义了上述等式中C的实部和虚部。后两个双精度定义了用于生成起始Z的种子值的实部和虚部。



    将这两个值映射(通过模运算)到从(0.1,0.1)到大约(0.55,0.55)的小方块区域。这样做是为了尝试并确保这一点我们的分形计算不会溢出或下溢(尽管我不确定这是不可能的)。最后,整数值用作我们的序列值的偏移量(上面公式中的“j”)。



    消息一次编码四个ascii字符。首先将序列号(j)添加到序列偏移量中,该序列偏移量与消息中的4字节偏移量一起使用,作为复数值乘以复数种子值,然后重新映射回活动矩形以获得我们的开始Z值。然后将Julia集递归(Z = Z ^ 2 + C)应用16次,并将最终结果再次重新映射回活动矩形。



    然后将该最终复数值乘以2 ^ 30,将实部和虚部转换为整数,然后使用每个的底部16位来提供本地密钥的32位(4字节)。然后对发送方的相应4个消息字节进行异或,以对其进行加密,或者对接收方处的加密文本进行异或,以对其进行解密。


登录 后才能参与评论