密码学学习笔记 3.传统加密技术——代替技术（三）置换技术

Hill密码

用连续的m个密文字母取代原有的m个连续的明文，而且这m个密文是用m个线性方程来决定的。这里就用例子来演示。

首先我们先为26个字母进行定义，a=0,b=1,......,z=25。然后我们来看一下公式：

                                                            

                                                            

                                                            

整理得:

                                                       

所以可以看到： 加密： ；解密：

实例：

加密:i'm growing like a seed, rains been falling on me.

密钥：

先分组然后再加密，这里直接给出代码：

import re
import sys
in_text=sys.argv[1:]
P_E_S=['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z']

Key=[[17,17,5],[21,18,21],[2,2,19]]
Key_I=[[4,9,15],[15,17,6],[24,0,17]]
def encryption(plaintex):
    ciphertext=[]
    flag=True
    while(flag):
        line=[]
        while(len(line)!=3):
            try:
                line.append(P_E_S.index(plaintex.pop(0))-P_E_S.index('a'))
            except:
                line.append(0)
                flag=False
        new_line=[]
        for i in range(3):
            new_line.append(0)
            for j in range(3):
                new_line[i]=new_line[i]+line[j]*Key[i][j]
        for i in range(3):
            ciphertext.append(P_E_S[new_line[i]%26])
    return ciphertext        
            

def decryption(ciphertext):
    plaintext=[]
    flag=True
    while(flag):
        line=[]
        while(len(line)!=3):
            try:
                line.append(P_E_S.index(ciphertext.pop(0))-P_E_S.index('a'))
            except:
                line.append(0)
                flag=False
        new_line=[]
        for i in range(3):
            new_line.append(0)
            for j in range(3):
                new_line[i]=new_line[i]+line[j]*Key_I[i][j]
        for i in range(3):
            plaintext.append(P_E_S[new_line[i]%26])
    return plaintext 
 


def Hill(in_text):
    print("此加密解密只涉及26个英文字母")
    print('---------------------------------')
    choice=input("1. 加密 2. 解密 ")
    in_text=''.join(in_text)
    in_text=re.compile('[^a-zA-Z]').sub('', in_text.lower())
    if choice is '1':
        print('加密结果: '+''.join(encryption(list(in_text))))
    elif choice is '2':
        print("解密结果: "+''.join(decryption(list(in_text))))
    else:
        print("输入错误")

        

if __name__ == '__main__':
    try:
        Hill(in_text)
    except EOFError:
        exit()

注：这个逆矩阵的求法，在后面的文章中会涉及，或者你可以尝试学习一下数论。

Hill密码的优势在于它屏蔽了单字母和双字母的频率特性，但是它很容易被已知明文攻击破解。

---

一次一密

两个基本难点：

1. 产生大规模随机密钥有困难。

2. 密钥的分配与保护有困难

---

置换技术

置换技术就是将原有的明文顺序进行打乱，通过多次的叠加，会增加破解的困难程度。

栅栏密码：

即设置分栏，然后将明文交叉存入，最后得到密码

实例： i'm growing like a seed, rains been falling on me. （栅栏为2）

栅栏1：i g o i g i e s e r i s e n a l n o m

栅栏2：m r w n l k a e d a n b e f l i g n e 

密文：igoigieserisenalnommrwnlkaedanbefligne

代码：

import re
import sys
from numpy import *
import numpy as np

in_text=sys.argv[1:]

def encryption(plaintex):
    ciphertext=[]
    c1=[]
    c2=[]
    i=0
    for item in plaintex:
        if i==0:
            c1.append(item)
            i+=1
        else:
            c2.append(item)
            i-=1
    ciphertext=c1+c2
    return ciphertext
            

def decryption(ciphertext):
    plaintext=[]
    length=len(ciphertext)
    cnt=0
    c1=[]
    c2=[]
    if length%2==0:
        for i in range(length//2):
            c1.append(ciphertext.pop(0))
        while(ciphertext):
            c2.append(ciphertext.pop(0))
    else:
        for i in range(length//2+1):
            c1.append(ciphertext.pop(0))
        while(ciphertext):
            c2.append(ciphertext.pop(0))
    cnt=0
    while(c1 or c2):
        if(cnt==0):
            plaintext.append(c1.pop(0))
            cnt+=1
        else:
            plaintext.append(c2.pop(0))
            cnt-=1
    return plaintext


def rail(in_text):
    print("此加密解密只涉及26个英文字母")
    print('---------------------------------')
    choice=input("1. 加密 2. 解密 ")
    in_text=''.join(in_text)
    in_text=re.compile('[^a-zA-Z]').sub('', in_text.lower())
    if choice is '1':
        print('加密结果: '+''.join(encryption(list(in_text))))
    elif choice is '2':
        print("解密结果: "+''.join(decryption(list(in_text))))
    else:
        print("输入错误")

        

if __name__ == '__main__':
    try:
        rail(in_text)
    except EOFError:
        exit()

如果只加密一次其实很容易就能发现结果了，那么多进行几次呢？比较一下

原文	i'm growing like a seed, rains been falling on me.
第一次	igoigieserisenalnommrwnlkaedanbefligne
第二次	iogeeieanmrnkeabfingiisrsnlomwladnelge
第三次	igeenrkafnisslmldegoeiamnebigirnowanle
第四次	ienkfismdgeanbgroalgeranslleoimeiinwne

这样的话解密难度就大大增加了。

---

转轮机 

转轮及就是将替代运算进行重复随机组合得到的结果。非常容易利用硬件实现。

我们来举个例子：

通过不同转速的密码盘，会随机生成不同的替代表，而且，每次都不是一样的。

---

 隐写术

这里仅仅举个例子，使用照片来存储一些重要的内容。我把一个简短的文字加入到了其中iloveyou

下面来看看，这两个文件有什么区别。

原图

更改后

 

---

博主还在学习密码学的相关内容，如有错误，还请各位指出，谢谢支持。