DES算法的加密解密及其Ruby实现

AugustTheo

于 2021-12-31 17:21:23 发布

阅读量641

点赞数

分类专栏： Ruby 算法与加密文章标签：算法 ruby 开发语言

本文链接：https://blog.csdn.net/qq_34013974/article/details/122260075

版权

Ruby 同时被 2 个专栏收录

34 篇文章 2 订阅

订阅专栏

算法与加密

5 篇文章 0 订阅

订阅专栏

#3 一个64位随机二进制生成器（Ruby）

前言

关于DES算法的加解密流程网上的资料其实已经够多了，所以本文并不会再复述这些流程。而本文中实现DES算法的编程语言Ruby的语法与现行的主流语言语法存在较大差别，因而恐怕也很难让读者利用。所以相比于网上其他关于DES算法的文章，本文的侧重点在于数据：我会提供一组较为详尽的数据给想要调试算法的读者，帮助他们排除错误。

DES算法中的表格

1 IP与IP-1

$ip=[ 58,50,42,34,26,18,10,2,

        60,52,44,36,28,20,12,4,

        62,54,46,38,30,22,14,6,

        64,56,48,40,32,24,16,8,

        57,49,41,33,25,17,9,1,

        59,51,43,35,27,19,11,3,

        61,53,45,37,29,21,13,5,

        63,55,47,39,31,23,15,7 ] #ip置换表 8*8

    $ipr=[40, 8,48,16,56,24,64,32,

        39, 7,47,15,55,23,63,31,

        38, 6,46,14,54,22,62,30,

        37, 5,45,13,53,21,61,29,

        36, 4,44,12,52,20,60,28,

        35, 3,43,11,51,19,59,27,

        34, 2,42,10,50,18,58,26,

        33, 1,41, 9,49,17,57,25 ] #逆转ip置换表 8*8

2 PC1与PC2

$pc1=[57,49,41,33,25,17,9,

        1,58,50,42,34,26,18,

        10,2,59,51,43,35,27,

        19,11,3,60,52,44,36,

        63,55,47,39,31,23,15,

        7,62,54,46,38,30,22,

        14,6,61,53,45,37,29,

        21,13,5,28,20,12,4] #pc1置换表 8*7

    $pc2=[14,17,11,24,1,5,

        3,28,15,6,21,10,

        23,19,12,4,26,8,

        16,7,27,20,13,2,

        41,52,31,37,47,55,

        30,40,51,45,33,48,

        44,49,39,56,34,53,

        46,42,50,36,29,32 ] #pc2置换表 8*6

3 S盒、E盒、P盒

$eBox=[32, 1, 2, 3, 4, 5,

            4, 5, 6, 7, 8, 9,

            8, 9,10,11,12,13,

           12,13,14,15,16,17,

           16,17,18,19,20,21,

           20,21,22,23,24,25,

           24,25,26,27,28,29,

           28,29,30,31,32, 1] #E盒 6*8

    $sBox=[ 14,4,13,1,2,15,11,8,3,10,6,12,5,9,0,7,#des算法s盒

            0,15,7,4,14,2,13,1,10,6,12,11,9,5,3,8,

            4,1,14,8,13,6,2,11,15,12,9,7,3,10,5,0,

            15,12,8,2,4,9,1,7,5,11,3,14,10,0,6,13,

            15,1,8,14,6,11,3,4,9,7,2,13,12,0,5,10,

            3,13,4,7,15,2,8,14,12,0,1,10,6,9,11,5,

            0,14,7,11,10,4,13,1,5,8,12,6,9,3,2,15,

            13,8,10,1,3,15,4,2,11,6,7,12,10,5,14,9,

            10,0,9,14,6,3,15,5,1,13,12,7,11,4,2,8,

            13,7,0,9,3,4,6,10,2,8,5,14,12,11,15,1,

            13,6,4,9,8,15,3,0,11,1,2,12,5,10,14,7,

            1,10,13,0,6,9,8,7,4,15,14,3,11,5,2,12,

            7,13,14,3,0,6,9,10,1,2,8,5,11,12,4,15,

            13,8,11,5,6,15,0,3,4,7,2,12,1,10,14,9,

            10,6,9,0,12,11,7,13,15,1,3,14,5,2,8,4,

            3,15,0,6,10,1,13,8,9,4,5,11,12,7,2,14,

            2,12,4,1,7,10,11,6,8,5,3,15,13,0,14,9,

            14,11,2,12,4,7,13,1,5,0,15,10,3,9,8,6,

            4,2,1,11,10,13,7,8,15,9,12,5,6,3,0,14,

            11,8,12,7,1,14,2,13,6,15,0,9,10,4,5,3,

            12,1,10,15,9,2,6,8,0,13,3,4,14,7,5,11,

            10,15,4,2,7,12,9,5,6,1,13,14,0,11,3,8,

            9,14,15,5,2,8,12,3,7,0,4,10,1,13,11,6,

            4,3,2,12,9,5,15,10,11,14,1,7,6,0,8,13,

            4,11,2,14,15,0,8,13,3,12,9,7,5,10,6,1,

            13,0,11,7,4,9,1,10,14,3,5,12,2,15,8,6,

            1,4,11,13,12,3,7,14,10,15,6,8,0,5,9,2,

            6,11,13,8,1,4,10,7,9,5,0,15,14,2,3,12,

            13,2,8,4,6,15,11,1,10,9,3,14,5,0,12,7,

            1,15,13,8,10,3,7,4,12,5,6,11,0,14,9,2,

            7,11,4,1,9,12,14,2,0,6,10,13,15,3,5,8,

            2,1,14,7,4,10,8,13,15,12,9,0,3,5,6,11] #S盒 8*4*16

    $pBox=[16, 7,20,21,29,12,28,17,

            1,15,23,26, 5,18,31,10,

            2, 8,24,14,32,27, 3, 9,

            19,13,30, 6,22,11, 4,25] #P盒 4*8 32位

4 移位表

$move=[1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1] #移位表

数据组

1

密钥：0001001000111101101010110111011110011111011001011000000001100111

K 0 000011100011001001101100011011010010011100011101

K 1 011000011010010110010101101101101001011011100001

K 2 010101011000010010010011010110101010111101100111

K 3 011101111000000010110010001111101110110110011000

K 4 101111101000000010000110011010010111010101010011

K 5 001110100000001000011110111011111110000000101010

K 6 001011000001000000111100111001000101111101001110

K 7 100001100000100001111100100111001001001011111110

K 8 010100001100010111010011110010010110010101111100

K 9 011101011100000100000111011010011111101010001100

K10 001000111000000110000111111100000101010010111111

K11 001110010000000010110111100011110001101010101111

K12 101101010000000010111000100101100111101111110001

K13 100101100000001010110100001100111000101101110101

K14 100111100001101000010100110100111010110110010010

K15 011000010110110100000011100101011011001111001111

原文：0000000100100011010001010110011110001001101010111100110111101111

E(R1) 011110100001010101010101011110100001010101010101

E(R)^K 011101000010011100111001000101110011001001001000

S(E(R)^K) 00110001001011000010111001000110

P(S(E(R)^K)) 00010000001100100101001011101110

P(S(E(R)^K))^L 11011100001100101001111000010001

R1 11011100001100101001111000010001

L1 11110000101010101111000010101010

E(R2) 111011111000000110100101010011111100000010100011

E(R)^K 100011100010010000110000111110010101011001000010

S(E(R)^K) 11001110000111111110110100100010

P(S(E(R)^K)) 11010101110011101011010011011000

P(S(E(R)^K))^L 00100101011001000100010001110010

R2 00100101011001000100010001110010

L2 11011100001100101001111000010001

E(R3) 000100001010101100001000001000001000001110100100

E(R)^K 010001010010111110011011011110100010110011000011

S(E(R)^K) 10100111011110101001111001011111

P(S(E(R)^K)) 01111111111100110100101001111100

P(S(E(R)^K))^L 10100011110000011101010001101101

R3 10100011110000011101010001101101

L3 00100101011001000100010001110010

E(R4) 110100000111111000000011111010101000001101011011

E(R)^K 101001111111111010110001110101000110111011000011

S(E(R)^K) 01001001101010010000111100101111

P(S(E(R)^K)) 10011000001010101110110101101100

P(S(E(R)^K))^L 10111101010011101010100100011110

R4 10111101010011101010100100011110

L4 10100011110000011101010001101101

E(R5) 010111111010101001011101010101010010100011111101

E(R)^K 111000010010101011011011001111000101110110101110

S(E(R)^K) 00110111100110100001010010000010

P(S(E(R)^K)) 01100100010000100100001101011011

P(S(E(R)^K))^L 11000111100000111001011100110110

R5 11000111100000111001011100110110

L5 10111101010011101010100100011110

E(R6) 011000001111110000000111110010101110100110101101

E(R)^K 010110101111111000011001001001010000100110000111

S(E(R)^K) 11000010010100010100000011011000

P(S(E(R)^K)) 11001110100101011000000000000001

P(S(E(R)^K))^L 01110011110110110010100100011111

R6 01110011110110110010100100011111

L6 11000111100000111001011100110110

E(R7) 101110100111111011110110100101010010100011111110

E(R)^K 100101100110111011001010011100010111011110110000

S(E(R)^K) 10001011010101101110111000010000

P(S(E(R)^K)) 01010111111011010101000010001000

P(S(E(R)^K))^L 10010000011011101100011110111110

R7 10010000011011101100011110111110

L7 01110011110110110010100100011111

E(R8) 010010100000001101011101011000001111110111111101

E(R)^K 110011000000101100100001111111000110111100000011

S(E(R)^K) 10111111001100110011111110011111

P(S(E(R)^K)) 11111110111010100110101010111111

P(S(E(R)^K))^L 10001101001100010100001110100000

R8 10001101001100010100001110100000

L8 10010000011011101100011110111110

E(R9) 010001011010100110100010101000000111110100000001

E(R)^K 000101010110110001110001011010010001100001111101

S(E(R)^K) 01111101010010010000011001100110

P(S(E(R)^K)) 10000000001110111100011001111010

P(S(E(R)^K))^L 00010000010101010000000111000100

R9 00010000010101010000000111000100

L9 10001101001100010100001110100000

E(R10) 000010100000001010101010100000000011111000001000

E(R)^K 011111111100001110101101111010011100010010000100

S(E(R)^K) 10000010010111010011010111001000

P(S(E(R)^K)) 11101100100100010011000011001001

P(S(E(R)^K))^L 01100001101000000111001101101001

R10 01100001101000000111001101101001

L10 00010000010101010000000111000100

E(R11) 101100000011110100000000001110100110101101010010

E(R)^K 100100111011110010000111110010100011111111101101

S(E(R)^K) 11100101000101011001001111001000

P(S(E(R)^K)) 10101101101100001111001000010001

P(S(E(R)^K))^L 10111101111001011111001111010101

R11 10111101111001011111001111010101

L11 01100001101000000111001101101001

E(R12) 110111111011111100001011111110100111111010101011

E(R)^K 111001101011111110111100011101010110010000000100

S(E(R)^K) 10101111011110001000010000111000

P(S(E(R)^K)) 01001111100010010100011001011100

P(S(E(R)^K))^L 00101110001010010011010100110101

R12 00101110001010010011010100110101

L12 10111101111001011111001111010101

E(R13) 100101011100000101010010100110101010100110101010

E(R)^K 001000001100000111101010000011001101001001011011

S(E(R)^K) 00100011100110111011100101001110

P(S(E(R)^K)) 11111101010100100110001111100000

P(S(E(R)^K))^L 01000000101101111001000000110101

R13 01000000101101111001000000110101

L13 00101110001010010011010100110101

E(R14) 101000000001010110101111110010100000000110101010

E(R)^K 001101100001011100011011111110011000101011011111

S(E(R)^K) 11011101001010101110111001000010

P(S(E(R)^K)) 00010001111111101100000011011110

P(S(E(R)^K))^L 00111111110101111111010111101011

R14 00111111110101111111010111101011

L14 01000000101101111001000000110101

E(R15) 100111111111111010101111111110101011111101010110

E(R)^K 000000011110010010111011001010010001001011000100

S(E(R)^K) 11101010110101111010011010011000

P(S(E(R)^K)) 11001111111010011001001110001001

P(S(E(R)^K))^L 10001111010111100000001110111100

R15 10001111010111100000001110111100

L15 00111111110101111111010111101011

E(R16) 010001011110101011111100000000000111110111111001

E(R)^K 001001001000011111111111100101011100111000110110

S(E(R)^K) 11100110000111101100010100001101

P(S(E(R)^K)) 01001101110001001011101001111000

P(S(E(R)^K))^L 01110010000100110100111110010011

R16 01110010000100110100111110010011

L16 10001111010111100000001110111100

密文：1001110111111101101001101010011001110011010000100110010010000011

2

密钥：1110000110000000010011001100011110011111110001011101100100100000

K 0 000010101101101100111011101010010100011000000001

K 1 101111111100001011000001001100110001101000100000

K 2 000110110101001110011110000100000000100100110110

K 3 001111000001000111011101000001010010100010010100

K 4 000101110100100001101101011000010010000011010001

K 5 100010110110100110110100001000111000000000001111

K 6 100111000010111110101101000001100001010110000110

K 7 110100110011011000101001000011000000000111100101

K 8 011110001010100010101111011001000110000001100000

K 9 101100011010010000111010011000001010100001001010

K10 111001000000111010110110101001001001010000011010

K11 111101101011101000010100000011010001011001100010

K12 000011101011011001110010000111001100100001100000

K13 111011100101010001111110000000001100110001010100

K14 111011101100001101001000100010011010010010010000

K15 111101110001000111110011100000010011001000111001

原文：1011101100111011000101001110001010011101110100100010000111101101

E(R1) 110111110011111001010111110010100110100101010111

E(R)^K 110101011110010101101100011000110010111101010110

S(E(R)^K) 00111010010101111101000000111110

P(S(E(R)^K)) 11101111010011110001011000100010

P(S(E(R)^K))^L 01000111011110001000001011110001

R1 01000111011110001000001011110001

L1 10111001110010111001001100101011

E(R2) 101000001110101111110001010000000101011110100010

E(R)^K 000111110010100100110000011100110100110110000010

S(E(R)^K) 01001000010011111110010010000010

P(S(E(R)^K)) 10000001010011111001000011001001

P(S(E(R)^K))^L 00111000100001000000001111100010

R2 00111000100001000000001111100010

L2 01000111011110001000001011110001

E(R3) 000111110001010000001000000000000111111100000100

E(R)^K 000001000100011110010110000100000111011000110010

S(E(R)^K) 00001000100001010100001001010110

P(S(E(R)^K)) 10000010001111100001000100100000

P(S(E(R)^K))^L 11000101010001101001001111010001

R3 11000101010001101001001111010001

L3 00111000100001000000001111100010

E(R4) 111000001010101000001101010010100111111010100011

E(R)^K 110111001011101111010000010011110101011000110111

S(E(R)^K) 11100010011100010000000101010000

P(S(E(R)^K)) 11000110100100011010001000000100

P(S(E(R)^K))^L 11111110000101011010000111100110

R4 11111110000101011010000111100110

L4 11000101010001101001001111010001

E(R5) 011111111100000010101011110100000011111100001101

E(R)^K 011010001000100011000110101100010001111111011100

S(E(R)^K) 10010110101000110111011011001100

P(S(E(R)^K)) 11101000111101000000000110111111

P(S(E(R)^K))^L 00101101101100101001001001101110

R5 00101101101100101001001001101110

L5 11111110000101011010000111100110

E(R6) 000101011011110110100101010010100100001101011100

E(R)^K 100111101101010000010001011010011100001101010011

S(E(R)^K) 00100100000101000000010100010101

P(S(E(R)^K)) 00000110000000000011101000111000

P(S(E(R)^K))^L 11111000000101011001101111011110

R6 11111000000101011001101111011110

L6 00101101101100101001001001101110

E(R7) 011111110000000010101011110011110111111011111101

E(R)^K 111000110010111100000110110010010110101101111011

S(E(R)^K) 00111000111000111001010010100101

P(S(E(R)^K)) 10100001010010010000111100101111

P(S(E(R)^K))^L 10001100111110111001110101000001

R7 10001100111110111001110101000001

L7 11111000000101011001101111011110

E(R8) 110001011001011111110111110011111010101000000011

E(R)^K 000101101010000111011110110000111010101111100110

S(E(R)^K) 01110100100111111111110101110001

P(S(E(R)^K)) 10110111010101001011111111011010

P(S(E(R)^K))^L 01001111010000010010010000000100

R8 01001111010000010010010000000100

L8 10001100111110111001110101000001

E(R9) 001001011110101000000010100100001000000000001000

E(R)^K 010111010100001010101101111101001110000001101000

S(E(R)^K) 10110010001111010101100011011001

P(S(E(R)^K)) 11111110100101000001101001000111

P(S(E(R)^K))^L 01110010011011111000011100000110

R9 01110010011011111000011100000110

L9 01001111010000010010010000000100

E(R10) 001110100100001101011111110000001110100000001100

E(R)^K 100010111110011101100101101000000100000001000110

S(E(R)^K) 00011111111100001010101011010100

P(S(E(R)^K)) 01010111001110010100000110110111

P(S(E(R)^K))^L 00011000011110000110010110110011

R10 00011000011110000110010110110011

L10 01110010011011111000011100000110

E(R11) 100011110000001111110000001100001011110110100110

E(R)^K 011010110000110101000110100101000010100110111100

S(E(R)^K) 10010101111000111100000111010101

P(S(E(R)^K)) 10000011110101010110100100110111

P(S(E(R)^K))^L 11110001101110101110111000110001

R11 11110001101110101110111000110001

L11 00011000011110000110010110110011

E(R12) 111110100011110111110101011101011100000110100011

E(R)^K 000011001000011111100001011110001101011111000001

S(E(R)^K) 11110110000100111001100101100001

P(S(E(R)^K)) 11110101110100001010111000010010

P(S(E(R)^K))^L 11101101101010001100101110100001

R12 11101101101010001100101110100001

L12 11110001101110101110111000110001

E(R13) 111101011011110101010001011001010111110100000011

E(R)^K 111110110000101100100011011110011011010101100011

S(E(R)^K) 00000101001111111001101101010001

P(S(E(R)^K)) 10110111011100000111100001010100

P(S(E(R)^K))^L 01000110110010101001011001100101

R13 01000110110010101001011001100101

L13 11101101101010001100101110100001

E(R14) 101000001101011001010101010010101100001100001010

E(R)^K 010011101000001000101011010010100000111101011110

S(E(R)^K) 01101010011000010101100100110111

P(S(E(R)^K)) 11110010000011111010111000100100

P(S(E(R)^K))^L 00011111101001110110010110000101

R14 00011111101001110110010110000101

L14 01000110110010101001011001100101

E(R15) 100011111111110100001110101100001011110000001010

E(R)^K 011000010011111001000110001110010001100010011010

S(E(R)^K) 01010000101100110110011001000000

P(S(E(R)^K)) 10000100011101001000000110001110

P(S(E(R)^K))^L 11000010101111100001011111101011

R15 11000010101111100001011111101011

L15 00011111101001110110010110000101

E(R16) 111000000101010111111100000010101111111101010111

E(R)^K 000101110100010000001111100010111100110101101110

S(E(R)^K) 01111100000100110010101100000010

P(S(E(R)^K)) 10010100011010101010001010010010

P(S(E(R)^K))^L 10001011110011011100011100010111

R16 10001011110011011100011100010111

L16 11000010101111100001011111101011

密文：0101111111101111001111010111001000101001001000101001011011110110

#3 一个64位随机二进制生成器（Ruby）

a=Array.new(64,3)

a.each do 

    case rand

    when 0...0.5

        a=0

    when 0.5..1

        a=1

    end

    print a

end

DES算法加解密的Ruby实现

由于我的环境是windows下，加解密不便使用经过编码的字符串，这里的函数输入输出的都是64位二进制。

1 算法文件构成

-DES_Primo.rb DES函数的类

-DES_main.rb 相当于main函数在的文件

2 DES_primo.rb

本文件中方法的“fromBinary”与“toBinary”实际并未用到，但是有规范输入输出的作用。

#----------------------------------------------

#des算法的类 #实在是看不懂Ruby为什么要给模块设置私有 

#----------------------------------------------

class DES

#----------------------------------------------

#全局变量范围

#----------------------------------------------

    $mode #运算模式

    $cipher="" #密钥

    $ncalculate_text="" #用户输入的raw data

    $block=[] #输入的数据组织成64位块的形式

    $k=Array.new(16) {Array.new 48} #循环密钥

    $calculate_text="" #结果

    $len=0 #块的数量

    $eBox=[32, 1, 2, 3, 4, 5,

            4, 5, 6, 7, 8, 9,

            8, 9,10,11,12,13,

           12,13,14,15,16,17,

           16,17,18,19,20,21,

           20,21,22,23,24,25,

           24,25,26,27,28,29,

           28,29,30,31,32, 1] #E盒 6*8

    $sBox=Array.new(8) {Array.new(4) {Array.new 16}} #S盒 8*4*16 它的置换算法很特别 #为了我的手，这只是个表面上的三维数组

    $sBox=[ 14,4,13,1,2,15,11,8,3,10,6,12,5,9,0,7,#des算法s盒

            0,15,7,4,14,2,13,1,10,6,12,11,9,5,3,8,

            4,1,14,8,13,6,2,11,15,12,9,7,3,10,5,0,

            15,12,8,2,4,9,1,7,5,11,3,14,10,0,6,13,

            15,1,8,14,6,11,3,4,9,7,2,13,12,0,5,10,

            3,13,4,7,15,2,8,14,12,0,1,10,6,9,11,5,

            0,14,7,11,10,4,13,1,5,8,12,6,9,3,2,15,

            13,8,10,1,3,15,4,2,11,6,7,12,10,5,14,9,

            10,0,9,14,6,3,15,5,1,13,12,7,11,4,2,8,

            13,7,0,9,3,4,6,10,2,8,5,14,12,11,15,1,

            13,6,4,9,8,15,3,0,11,1,2,12,5,10,14,7,

            1,10,13,0,6,9,8,7,4,15,14,3,11,5,2,12,

            7,13,14,3,0,6,9,10,1,2,8,5,11,12,4,15,

            13,8,11,5,6,15,0,3,4,7,2,12,1,10,14,9,

            10,6,9,0,12,11,7,13,15,1,3,14,5,2,8,4,

            3,15,0,6,10,1,13,8,9,4,5,11,12,7,2,14,

            2,12,4,1,7,10,11,6,8,5,3,15,13,0,14,9,

            14,11,2,12,4,7,13,1,5,0,15,10,3,9,8,6,

            4,2,1,11,10,13,7,8,15,9,12,5,6,3,0,14,

            11,8,12,7,1,14,2,13,6,15,0,9,10,4,5,3,

            12,1,10,15,9,2,6,8,0,13,3,4,14,7,5,11,

            10,15,4,2,7,12,9,5,6,1,13,14,0,11,3,8,

            9,14,15,5,2,8,12,3,7,0,4,10,1,13,11,6,

            4,3,2,12,9,5,15,10,11,14,1,7,6,0,8,13,

            4,11,2,14,15,0,8,13,3,12,9,7,5,10,6,1,

            13,0,11,7,4,9,1,10,14,3,5,12,2,15,8,6,

            1,4,11,13,12,3,7,14,10,15,6,8,0,5,9,2,

            6,11,13,8,1,4,10,7,9,5,0,15,14,2,3,12,

            13,2,8,4,6,15,11,1,10,9,3,14,5,0,12,7,

            1,15,13,8,10,3,7,4,12,5,6,11,0,14,9,2,

            7,11,4,1,9,12,14,2,0,6,10,13,15,3,5,8,

            2,1,14,7,4,10,8,13,15,12,9,0,3,5,6,11]

    $pBox=[16, 7,20,21,29,12,28,17,

            1,15,23,26, 5,18,31,10,

            2, 8,24,14,32,27, 3, 9,

            19,13,30, 6,22,11, 4,25] #P盒 4*8 32位

    $ip=[ 58,50,42,34,26,18,10,2,

        60,52,44,36,28,20,12,4,

        62,54,46,38,30,22,14,6,

        64,56,48,40,32,24,16,8,

        57,49,41,33,25,17,9,1,

        59,51,43,35,27,19,11,3,

        61,53,45,37,29,21,13,5,

        63,55,47,39,31,23,15,7 ] #ip置换表 8*8

    $ipr=[40, 8,48,16,56,24,64,32,

        39, 7,47,15,55,23,63,31,

        38, 6,46,14,54,22,62,30,

        37, 5,45,13,53,21,61,29,

        36, 4,44,12,52,20,60,28,

        35, 3,43,11,51,19,59,27,

        34, 2,42,10,50,18,58,26,

        33, 1,41, 9,49,17,57,25 ] #逆转ip置换表 8*8

    $pc1=[57,49,41,33,25,17,9,

        1,58,50,42,34,26,18,

        10,2,59,51,43,35,27,

        19,11,3,60,52,44,36,

        63,55,47,39,31,23,15,

        7,62,54,46,38,30,22,

        14,6,61,53,45,37,29,

        21,13,5,28,20,12,4] #pc1置换表 8*7

    $move=[1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1] #移位表

    $pc2=[14,17,11,24,1,5,

        3,28,15,6,21,10,

        23,19,12,4,26,8,

        16,7,27,20,13,2,

        41,52,31,37,47,55,

        30,40,51,45,33,48,

        44,49,39,56,34,53,

        46,42,50,36,29,32 ] #pc2置换表 8*6

#-----------------------------------------------

#方法范围

#-----------------------------------------------

    def toBinary(str) #将字符串转换成n*八位二进制字符串

        # str :输入的字符串

        re=""

        str.each_char do |i|

            x=i.ord.to_s(2) #转换成二进制字符串

            (1..8-x.length).each do

                re+='0' #补足0

            end

            re+=x #加上字符串，现在它的长度为8的倍数

        end

        return re

    end

    def fromBinary(code) #将二进制以8位为一组转换成字符串

        re=""

        (0...code.length/8).each do |m|

            re+=code[m*8+0...m*8+8].to_i(2).chr #ascii转字母

        end

        return re

    end 

    def substitute(arr,rect) #算法中所有压缩/转置操作

        # arr :待压缩的串

        # rect:转置/压缩的矩阵(其实就是个数组)

        re=""

        rect.each do |m|

            re+=arr[m-1]

        end

        return re

    end

    def toCipher(cipher) #将用户输入的密码转换为循环密钥

        # cipher :用户输入的密码

        if cipher.length>64

            cipher=cipher[0...64] #截取64位

        elsif cipher.length<64

            (0...64-cipher.length).each do

                cipher+="0"

            end

        end #密码规整为64位

        re=pc1_sub cipher #pc1压缩 压缩后为56位

        c0=re[0...28]

        d0=re[28...56] #分割出c0、d0（各28位）

        c=Array.new 17 

        d=Array.new 17 #分割后的迭代密钥

        c[0]=c0

        d[0]=d0

        (1..16).each do |m|

            n=$move[m-1] #对于第m轮密钥，其相比于上一轮要左移的位数n

            _x=c[m-1][0...n] #切割下来的数组

            c[m]=c[m-1][n...28]+_x #这是什么，这是左移

            _y=d[m-1][0...n]

            d[m]=d[m-1][n...28]+_y

        end #对cd左右移16轮，得到16轮密钥 #记住是十六轮，也就是c0d0不算的

        sk=Array.new(16)

        (1..16).each do |m|

            sk[m-1]=c[m]+d[m] #合并两个迭代过的部分

        end

        x=Array.new(16) {Array.new 48} #我随意取，也请读者将就看看

        (0...16).each do |m|

            (0...48).each do |n|

                x[m][n]=sk[m][$pc2[n]-1] 

            end 

        end#pc2压缩 压缩后为48位

        $k=x

    end

    M,X,Y=16*4,16,1 #在模仿亲爱的三维数组

    def SSubstitute(arr) #S盒置换

        # arr :某个xor运算过后的Rn

        re=""

        (0...arr.length/6).each do |m|

            x=(arr[m*6+0]+arr[m*6+5]).to_i 2 #取出第一位和第六位合成十进制

            y=arr[m*6+1..m*6+4].to_i 2

            _re=$sBox[m*M+x*X+y*Y].to_s 2

            (0...4-_re.length).each do

                re+='0'

            end #规范位数

            re+=_re  

        end

        return re

    end

    def getBinary64 #将用户的输入完整的转换为n个64位块

        bina=$ncalculate_text #输入转换为二进制串

        len=(bina.length/64).to_i  #取整

        oro_len=bina.length

        re64=Array.new(len) #这是返回的64位数组

        (0..len).each do |m|

            re64[m]=bina[m*64...m*64+64]

        end

        (oro_len-len*64...64).each do

            re64[len]+="0" 

        end #填充到64的倍数

        $block=re64

        if oro_len%64 != 0 then len+=1 end #获取真正的规范后的长度，要考虑刚好整除的情况

        $len64=len

    end

    def code #整个运算过程

        # 根据传入的块决定是加密（$k）还是解密（倒转$k）

        re=""

        getBinary64

        (0...$len64).each do |m| #遍历所有输入的64位块

            ipmain=ip_sub $block[m] #对第n个块进行IP置换

            ipL=ipmain[0...32]

            ipR=ipmain[32...64] #切片 

            (0...16).each do |n| #16轮运算，也就是f

                ipR_e=e_sub ipR #Rn经过E盒扩展成48位 

                ipR_xor=DESxor(ipR_e,$k[yield n]) #扩展后的右半部分与Kn进行异或（解密时是K15-n） 

                ipR_s=SSubstitute ipR_xor #S盒置换 压缩到32位

                ipR_p=p_sub ipR_s #P盒置换

                ipR_p_xor=DESxor(ipR_p,ipL) #置换回32位后后右边与左边异或

                ipL=ipR

                ipR=ipR_p_xor #交换左右部分

            end

            ipR16=ipL

            ipL16=ipR #最后的交换

            _cipher=ipL16+ipR16 #与最后密文差一个ip-1的密文

            re+=ipr_sub _cipher #ip-1置换

        end

        return re #返回所有密文的二进制

    end

#----------------------------------------------

#二阶引用（也就是比较简单的派生方法）

#----------------------------------------------

    def ip_sub(arr) #ip转置

        # arr :被转置的64位数组

        return substitute(arr,$ip)

    end

    def ipr_sub(arr) #ip-1转置

        # arr :被转置的64位数组

        return substitute(arr,$ipr)

    end

    def e_sub(arr) #E盒替换

        # arr :被替换的Rn

        return substitute(arr,$eBox)

    end

    def pc1_sub(arr) #pc1置换

        # arr :被置换的初始key

        return substitute(arr,$pc1)

    end

    def DESxor(arr1,arr2) #两个数组间的异或

        # arr1、arr2:两个异或数组输入

        re=""

        (0...arr1.length).each do |m|

            re+=(arr1[m].to_i^arr2[m].to_i).to_s

        end

        return re

    end

    def p_sub(arr) #P盒置换

        # arr :被置换的Rn

        return substitute(arr,$pBox)

    end

    def ui

        puts "请输入你的密钥："

        toCipher gets.chomp #密钥的输入 #顺便转换为16循环二进制串了

        choc="1"

        until choc=='y'

            puts "请输入待加密/解密的数据："

            $ncalculate_text=gets.chomp #数据的输入

            getBinary64 #$ncalculate_text转换到$block

            puts "需要加密还是解密呢？(t/f)"

            case gets[0]

            when "t"

                puts code {|m| m}

            when "f"

                puts code {|m| 15-m}

            end

            puts "是否跳出？（y/n）"

            choc=gets[0]

        end

    end

end

3 DES_main.rb

$LOAD_PATH << '.'

require 'DES_Primo'

DES.new.ui

AugustTheo

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
DES算法的加密解密及其Ruby实现

目录前言DES算法中的表格1 IP与IP-12 PC1与PC23 S盒、E盒、P盒4 移位表数据组12#3 一个64位随机二进制生成器（Ruby）DES算法加解密的Ruby实现1 算法文件构成2 DES_primo.rb3 DES_main.rb前言关于DES算法的加解密流程网上的资料其实已经够多了，所以本文并不会再复述这些流程。而本文中实现DES算法的编程语言Ruby的语法与现行的主流语言语法存在较大差别，因而恐怕也很难让读者利用。...
复制链接

扫一扫