精华内容
下载资源
问答
  • 实现Hill密码的加密和解密
  • > `明文:`明文经过加密过程的变换所得的消息或字符串。 > `加密过程`:将明文变换成另一种不能被非授权者所理解的隐蔽信息。 > `密文`:明文经过加密过程的变化,所得的消息或字符串。 > `加密变换`:将明文变为密文...
  • 解密希尔密码
  • 希尔密码解密过程

    2018-07-01 11:49:52
    要点:1.要求求出A的模26逆矩阵2.将A、B······Y、Z与1、2······25、0,分别对应,然后将明文两两分组,分组方式任取,此处便以常用简单的两两分组,若为奇数个可在末尾添加任意字母
  • 通过实验,使学生对古典密码学有充分的认识;学会正确使用编程语言(C/C++、Java、Maple 等)实现希尔密码与攻击,验证课堂中所学的古典密码算法;为学习现代密码算法及其应用奠定基础。
  • java实现希尔密码

    2015-04-12 15:45:27
    java,希尔密码,密码程序,源代码可以修改,以实现更多功能,修改请在私有域中进行修改,十分感谢您的下载。希望多多指正。
  • 希尔密码的实现

    2014-10-23 16:40:29
    通过实验,对古典密码学有充分的认识;学会正确使用编程语言(C、Mathematica、Maple等)实现希尔密码,验证古典密码算法
  • 希尔密码

    2020-04-01 20:01:03
    希尔密码(Hill Cipher) 是运用基本矩阵论原理的替换密码,由Lester S. Hill在1929年发明。每个字母当作26进制数字:A=0, B=1, C=2… 一串字母当成n维向量,跟一个n×n的矩阵相乘,再将得出的结果mod26。 它并不是...

    希尔密码(Hill Cipher)

    是运用基本矩阵论原理的替换密码,由Lester S. Hill在1929年发明。每个字母当作26进制数字:A=0, B=1, C=2… 一串字母当成n维向量,跟一个n×n的矩阵相乘,再将得出的结果mod26。

    它并不是一种加密密码,而是一种替换密码

    产生原因

    随着科技的日新月异和人们对信用卡、计算机的依赖性的加强,密码学显得愈来愈重要。
    日常生活中使用信用卡、网络账号及密码、电子信箱、电子签名等都需要密码。为了方便记忆,许多人用生日、电话号码、门牌号码记做密码,但是这样安全性较差。


    为了使密码更加复杂,更难解密,产生了许多不同形式的密码。密码的函数特性是明文对密码为一对一或一对多的关系,即明文是密码的函数。传统密码中有一种叫移位法,移位法基本型态是加法加密系统C=P+s(mod m)。一般来说,我们以1表示A,2表示B,……,25表示Y,26表示Z,以此类推。由于s=0时相当于未加密,而0≤s≤m-1(s≥m都可用0≤s≤m-1取代),因此,整个系统只有m-1种变化。换言之,只要试过m-1次,机密的信息就会泄漏出去。


    由此看来,日常生活中的密码和传统的密码的可靠性较差,我们有必要寻求一种容易将字母的自然频度隐蔽或均匀化,从而有利于统计分析的安全可靠的加密方法。希尔密码诞生了。

    例子

    在这里插入图片描述


    重点是密钥矩阵必须可逆,不然无法逆向解密

    展开全文
  • 希尔密码_密码学中的希尔密码

    千次阅读 2020-07-30 15:40:57
    希尔密码It is a polygraphic substitution cipher that depends on linear algebra. Every letter from the alphabet is represented by several modulo 26. Simply, we write as A = 0, B = 1, ..., Z = 25 is ...

    希尔密码

    It is a polygraphic substitution cipher that depends on linear algebra. Every letter from the alphabet is represented by several modulo 26. Simply, we write as A = 0, B = 1, ..., Z = 25 is used, but this is not a correct feature of the cipher.

    这是一个依赖于线性代数的测谎替代密码。 字母表中的每个字母都由26为模。简单地,我们写为A = 0,B = 1,...,Z = 25 ,但这不是密码的正确特征。

    To encrypt a message, each block of n letters is multiplied by an invertible n × n matrix, against modulus 26 or we can say the multiple inverses of n.

    为了加密消息,将n个字母的每个块都乘以可逆n×n矩阵(模数为26)或我们可以说n的多个逆。

    To decrypt the message, every block is multiplied by the inverse of the matrix or inversed matrix used for encryption.

    为了解密该消息,将每个块乘以用于加密的矩阵或逆矩阵的逆。

    The matrix used for encryption is the plain text and one matrix is formed is cipher key when we combine or multiple them we get the new matrix called ciphertext, and the key should be chosen randomly from the set of invertible n × n matrices (modulo 26).

    用于加密的矩阵是纯文本,当我们将它们组合或相乘时,形成的一个矩阵是密码密钥,得到一个新的矩阵,称为密文,密钥应从可逆n×n矩阵集中随机选择(取模26 )。

    加密 (Encryption)

    We have to do encryption on the message 'ACT' (n=3). The key is 'GYBNQKURP' which can be written as the n x n matrix that is 3 x 3 matrix,

    我们必须对消息“ ACT”(n = 3)进行加密。 关键是“GYBNQKURP”,其可以被写为NxN矩阵是3×3矩阵,

    Hill Cipher

    The message for encryption 'ACT' is written as a vector,

    加密消息“ ACT”写为矢量,

    Hill Cipher 1

    The enciphered vector is given as,

    加密的向量为

    Hill Cipher 2

    In this, we just do the multiple matrices we just multiple the 1 row with 1 column as we can say 6*0+24*2+1*19=67 same as 13*0+16*2+10*19=222 and 20*0+17*2+15*19=319.

    在这里,我们只是做多个矩阵,我们只将1行与1列相乘,我们可以说6 * 0 + 24 * 2 + 1 * 19 = 6713 * 0 + 16 * 2 + 10 * 19 = 222相同20 * 0 + 17 * 2 + 15 * 19 = 319

    And that matrix does the mod 26 with particular column and made again the 3*1 matrix and we alphabetically write them with called ciphertext i.e "POH".

    然后,该矩阵使用特定的列进行mod 26运算,并再次制作3 * 1矩阵,然后按字母顺序将其写为密文,即“ POH”

    解密 (Decryption)

    To decrypt the message, we turn the ciphertext back into a plain text, then simply multiply by the inverse matrix of the key matrix as "IFKVIVVMI" in letters. The inverse of the matrix used in the encryption is,

    为了解密该消息,我们将密文转换回纯文本,然后简单地乘以密钥矩阵的逆矩阵,即字母“ IFKVIVVMI” 。 加密中使用的矩阵的逆是

    Hill Cipher 3

    For ciphertext which we already find we decrypt that and make plain text,

    对于我们已经发现的密文,我们将其解密并制成纯文本,

    Hill Cipher 4

    Now, we just find the inverse matrix then multiple it by key then it will give us back "ACT".

    现在,我们只需找到逆矩阵,然后将其乘以键,然后它将返回“ ACT”

    Let, K is DDCF

    设K为DDCF

    Hill Cipher 5

    be the key and suppose the plaintext is "HELP". Then this plaintext is represented by two pairs because n is 2.

    是键,并假定明文为“ HELP” 。 然后,此纯文本用两对表示,因为n2

    Hill Cipher 6

    Firstly we do encryption, then we will compute

    首先我们进行加密,然后我们将进行计算

    Hill Cipher 7

    and continue encryption as follows and written as,

    并继续如下加密并写为:

    Hill Cipher 8

    The matrix K is invertible, hence K-1 exists such that KK-1 = K-1K = I2 The inverse of K can be computed by using the formula,

    矩阵K是可逆的,因此存在K -1 ,使得KK -1 = K -1 K = I 2可以使用公式计算K的逆,

    Hill Cipher 9

    This formula still holds after a modular reduction if a modular multiplicative inverse is used to compute.

    如果使用模块化乘法逆来进行计算,则该公式在模块化归约后仍然成立。

    Now, we have to do decryption,

    现在,我们必须进行解密,

    Hill Cipher 10

    Then we compute,

    然后我们计算

    Hill Cipher 11

    And we get,

    我们得到

    Hill Cipher 12

    Security

    安全

    The basic Hill Cipher is vulnerable to a known-plaintext attack that attacks by key because it is completely linear algebra. An opposite site that intercepts n plaintext/ciphertext character pairs can set up a linear system that can be easily solved; if this will happen then this system is undefined, it is the only way is to add a few more plaintexts/ciphertext pairs. While when n x n matrix multiplication is a useful step when it will be combined with other non-linear operations because matrix multiplication can provide diffusion. For example, a unique chosen matrix can give security that minor differences before the matrix multiplication will give the answer in huge differences after the matrix multiplication. Otherwise, some new ciphers use a matrix multiplication step to gave diffusion. For example, the MixColumns matrix step in AES cipher is matrix multiplication. The function g in Twofish is a combination of non-linear algebra S-boxes i.e substitution boxes with a carefully chosen matrix multiplication (MDS) is used this.

    基本的希尔密码很容易受到已知明文攻击,因为它是完全线性的代数,因此会受到密钥的攻击。 截获n个纯文本/密文字符对的相对站点可以建立一个易于解决的线性系统; 如果将发生这种情况,则该系统是不确定的,唯一的方法是添加更多的明文/密文对。 当nxn矩阵乘法是有用的步骤时,它将与其他非线性运算结合使用,因为矩阵乘法可以提供扩散。 例如,唯一选择的矩阵可以确保矩阵乘法之前的微小差异将在矩阵乘法之后的巨大差异中给出答案。 否则,某些新密码将使用矩阵乘法步骤进行扩散。 例如,AES密码中的MixColumns矩阵步骤是矩阵乘法。 Twofish中的函数g是非线性代数S-box的组合,即,使用具有精心选择的矩阵乘法(MDS)的替换框。

    Reference: Hill Cipher

    参考: 希尔密码

    翻译自: https://www.includehelp.com/cryptography/hill-cipher.aspx

    希尔密码

    展开全文
  • 希尔密码Now, Hill Cipher is a very basic cryptographic technique which is used to convert a string into ciphertext. This technique was invented by an American Mathematician "Lester Sanders Hill". This...

    希尔密码

    Now, Hill Cipher is a very basic cryptographic technique which is used to convert a string into ciphertext. This technique was invented by an American Mathematician "Lester Sanders Hill". This is a polygraphic substitution cipher because the substitution or encryption is performed on the block on letters. It works on multiple letters at the same time. It was the first polygraphic cipher which was operable on more than 3 symbols.

    现在, Hill Cipher是一种非常基本的加密技术,用于将字符串转换为密文。 这项技术是由美国数学家“莱斯特·桑德斯·希尔(Lester Sanders Hill)”发明的。 这是一个多图形替换密码,因为替换或加密是在字母上的块上执行的。 它可以同时处理多个字母。 这是第一个可用于3个以上符号的多重密码。

    Implementation Technique

    实施技术

    加密 (Encryption )

    In Hill Cipher, each letter is represented by a number modulo 26. So according to this, A = 0, B = 1, C = 2, ..., Z = 25. A string will be given to you and you have to make a column matrix using the letter-numberer relationship shown above. We'll be given a key matrix as well. We must ensure that | Key | should not be zero otherwise we can not apply hill cipher technique. This key matrix will be used in decryption as well. We need to multiply these two matrices. The formula for the ciphertext using Hill Cipher is:

    Hill Cipher中 ,每个字母都由一个以26为模的数字表示。因此, A = 0,B = 1,C = 2,...,Z = 25 。 将为您提供一个字符串,您必须使用上面显示的字母-数字关系创建一个列矩阵。 我们还将获得一个密钥矩阵。 我们必须确保 关键 不应为零,否则我们将无法应用希尔密码技术 。 该密钥矩阵也将用于解密。 我们需要将这两个矩阵相乘。 使用希尔密码的密文公式为:

    Hill Cipher | 1

    Here, n is the order of matrix or we can say the n is the number of letters we are taking at once to encrypt. Now, you'll get column matrix of order n x 1 which will have numbers from 0 to 25. You just have to replace the number with the letters from the relationship shown above and your ciphertext is ready.

    在这里, n是矩阵的阶数,或者我们可以说n是我们一次要加密的字母数。 现在,您将获得顺序为nx 1的列矩阵,该列矩阵的数字从0到25。您只需要用上面显示的关系中的字母替换数字,即可准备好密文。

    解密 (Decryption)

    The letter-numberer relationship will remain the same in the decryption part. We'll use the inverse of the key matrix in decryption. Order of the matrix will remain the same. We need to multiply the inverse of the key matrix with the cipher text matrix we've got from the encryption technique. The formula is given below:

    字母-数字关系在解密部分将保持不变。 我们将在解密中使用密钥矩阵的逆函数。 矩阵的顺序将保持不变。 我们需要将密钥矩阵的逆乘以从加密技术获得的密文矩阵。 公式如下:

    Hill Cipher | 2

    Example:

    例:

    Let us take plain text: DOG and the key matrix is:

    让我们采用纯文本:DOG和密钥矩阵为:

    Hill Cipher | 3

    D = 3, O = 14 , G = 6 so our column matrix is:

    D = 3,O = 14,G = 6,所以我们的列矩阵为:

    Hill Cipher | 4

    Now we have to apply the multiplication as shown in the encryption formula. After multiplying and applying modulo 26 we got this cipher text matrix:

    现在,我们必须应用加密公式中所示的乘法。 在乘并应用模26之后,我们得到了这个密文矩阵:

    Hill Cipher | 5

    Now, 22 = W, 11 = L, 24 = Y

    现在,22 = W,11 = L,24 = Y

    So cipher text of DOG is WLY

    所以DOG的密文是WLY

    Now we'll do decryption and we'll use the generated ciphertext to convert it to plain text. First of all, we need to find the inverse of the key matrix. So the inverse of our key matrix is:

    现在我们将进行解密,并将使用生成的密文将其转换为纯文本。 首先,我们需要找到密钥矩阵的逆矩阵。 因此,我们的密钥矩阵的逆是:

    Hill Cipher | 6

    Now after multiplying the inverse matrix with the ciphertext matrix that we've generated in the encryption, we can get out plain text matrix again.

    现在,将逆矩阵与我们在加密中生成的密文矩阵相乘后,我们可以再次得到纯文本矩阵。

    So after multiplying and taking modulo 26, the decrypted matrix is:

    因此,在乘以26后,解密后的矩阵为:

    Hill Cipher | 7

    3 = D, 14 = 0 and 6 = G, So this is equal to the plain text it means our encryption and decryption both are right. Now, the Hill Cipher technique is over.

    3 = D,14 = 0和6 = G,所以这等于纯文本,这意味着我们的加密和解密都是正确的。 现在, 希尔密码技术已经结束。

    翻译自: https://www.includehelp.com/cyber-security/hill-cipher.aspx

    希尔密码

    展开全文
  • exe程序可以去希尔密码(Hill密码)转换工具.exe下载。 算法原理 每个字母当作26进制数字:A=0, B=1, C=2… 一串字母当成n维向量,跟一个n×n的矩阵相乘,再将得出的结果模26。 注意用作加密的矩阵(即密钥)必须是...

    前言

    这是之前的密码学课设,因为一直在忙期末考试,所以到现在才发出来。exe程序可以去希尔密码(Hill密码)转换工具.exe下载。

    算法原理

    每个字母当作26进制数字:A=0, B=1, C=2… 一串字母当成n维向量,跟一个n×n的矩阵相乘,再将得出的结果模26。
    注意用作加密的矩阵(即密钥)必须是可逆的,否则就不可能解码。只有矩阵的行列式和26互质,才是可逆的。

    请添加图片描述

    加解密代码

    import numpy as np
    import sys
    
    
    # 判断矩阵是否存在逆矩阵
    def judge_inverse_matrix(matrix):
        try:
            np.linalg.inv(matrix)
        except:
            return False
        return True
    
    
    # 输入列表并转换为矩阵
    def inputmatrix():
        row_num = int(input("请输入矩阵的行数:"))
        all_list = []
        for i in range(1, row_num + 1):
            row = input(f"请输入加密矩阵第{i}行(以空格为分隔):")
            if row[0] == ' ':
                print("输入有误,第一位不该为空格")
                sys.exit()
            else:
                row_list = row.split(' ')
            # 将列表中str转换为int
            if len(row_list) == row_num:
                for n in row_list:
                    row_list[row_list.index(n)] = int(row_list[row_list.index(n)])
                all_list.append(row_list)
            else:
                print("前后输入的行数不一致,请重修输入")
                break
        encrypt_matrix = np.array(all_list)
        if not judge_inverse_matrix(encrypt_matrix):
            print("该矩阵不存在逆矩阵,请重修输入")
        return encrypt_matrix
    
    
    # 生成矩阵的逆矩阵。如果逆矩阵含有小数,就四舍五入
    def generate_inverse_matrix(matrix):
        inverse_matrix = np.linalg.inv(matrix)
        for row in inverse_matrix:
            for num in row:
                num = round(num)
        print("加密矩阵的逆矩阵为:")
        for array in inverse_matrix:
            print(array)
        return inverse_matrix
    
    
    # 生成字母-数字对应的字典
    def alphabet_number():
        alphabet_number_dict = {}
        for i in range(97, 123):
            alphabet_number_dict[chr(i)] = i % 97
        return alphabet_number_dict
    
    
    def encrypt():
        # 明文字母转换成对应数字
        input_plaintext = input("请输入明文:")
        num_list = []
        dic = alphabet_number()
        for i in input_plaintext:
            num_list.append(dic[i])
    
        # 如果矩阵行数不能整除明文,则用'z'的数字25补全
        matrix = inputmatrix()
        row_num = len(matrix)
        supple_num = row_num - (len(num_list) % row_num)
        if len(num_list) % row_num != 0:
            for n in range(1, supple_num + 1):
                num_list.append(25)
        print(f"\n添加了{supple_num}个z补全明文")
    
        # 分组加密
        group_num = int(len(num_list) / row_num)
        whole_encrypt_num_list = []
        for g in range(0, group_num):
            plaintext_matrix = np.array(num_list[0 + g * row_num: (g + 1) * row_num])
            encrypt_num_list = np.matmul(plaintext_matrix, matrix)
            for num in encrypt_num_list:
                whole_encrypt_num_list.append(num)
    
        # 将加密后的数字转换为字母
        ciphertext = ""
        for ennum in whole_encrypt_num_list:
            # 对超出范围的数字取模
            if ennum > 25:
                ennum = ennum % 26
            for k in dic:
                if dic[k] == ennum:
                    ciphertext = ciphertext + k
        print("加密后密文为:", ciphertext, '\n')
    
    
    def decrypt():
        # 输入密文并转换为对应数字
        input_ciphertext = input("请输入密文:")
        num_list2 = []
        dic2 = alphabet_number()
        for i in input_ciphertext:
            num_list2.append(dic2[i])
    
        # 解密就不添加'z'来补全密文了
        matrix = inputmatrix()
        row_num2 = len(matrix)
        supple_num2 = row_num2 - (len(num_list2) % row_num2)
    
        # 用逆矩阵分组解密
        inserve_matrix = generate_inverse_matrix(matrix)
        group_num2 = int(len(num_list2) / row_num2)
        whole_decrypt_num_list = []
        for g in range(0, group_num2):
            plaintext_matrix = np.array(num_list2[0 + g * row_num2: (g + 1) * row_num2])
            decrypt_num_list = np.matmul(plaintext_matrix, inserve_matrix)
            for num in decrypt_num_list:
                whole_decrypt_num_list.append(num)
    
        # 将解密后的数字转换为对应字母
        plaintext = ""
        for denum in whole_decrypt_num_list:
            if denum > 25 or denum < -26:
                denum = denum % 26
    
            # 防止取模后是负数,字典中找不到对应的字母
            if denum < 0:
                denum = denum + 26
            # 字典中寻找与数字对应的字母
            for k in dic2:
                if dic2[k] == denum:
                    plaintext = plaintext + k
        print("解密后明文为:", plaintext, '\n')
    
    
    if __name__ == '__main__':
        while True:
            print("========Hill密码========\n")
            print("1.加密\n2.解密\n")
            print("注意:如果输入矩阵的逆矩阵中含有小数,采用四舍五入的方法\n")
            pattern = input("请选择模式:")
            if pattern == '1':
                encrypt()
            elif pattern == '2':
                decrypt()
            else:
                print("输入有误,请重修输入")
    
    • 这里主要是采用了numpy模块来实现判断输入矩阵的逆矩阵存在与否以及矩阵间的乘法;
    • 同时,因为输入的明文可能在分组后的列无法与矩阵的行数相等,所以当不相等时,自动在明文后用字母z补全;
    • 还有一个主要的问题就是输入矩阵的逆矩阵可能存在小数,因此这里采用了四舍五入的方法,当输入的矩阵数字过大时,可能会造成解密结果不准确。

    图形界面代码

    import numpy as np
    import sys
    from tkinter import *
    
    
    class MY_GUI():
        def __init__(self, init_window_name):
            self.init_window_name = init_window_name
    
        # 设置窗口
        def set_init_window(self):
            self.init_window_name.title("Hill密码转换工具")  # 窗口名
            self.init_window_name.geometry('700x500+300+120')
            self.init_window_name["bg"] = "Lavender"
    
            # 标签
            self.crypto_string_label = Label(self.init_window_name, text="加/解密字符串", font=13)
            self.crypto_string_label.place(x=80, y=60)
    
            self.row_num_label = Label(self.init_window_name, text="矩阵行数", font=13)
            self.row_num_label.place(x=120, y=120)
    
            self.encrypt_matrix_label = Label(self.init_window_name, text="加密矩阵", font=13)
            self.encrypt_matrix_label.place(x=120, y=220)
    
            self.encrypt_matrix_label = Label(self.init_window_name, text="(空格分隔)", font=13)
            self.encrypt_matrix_label.place(x=110, y=240)
    
            self.crypto_result_label = Label(self.init_window_name, text="加/解密结果", font=13)
            self.crypto_result_label.place(x=100, y=330)
    
            self.supple_string_label = Label(self.init_window_name, text="字符增补记录", font=13)
            self.supple_string_label.place(x=90, y=400)
    
            # 文本框
            self.crypto_string_Text = Text(self.init_window_name, width=40, height=2)  # 加/解密字符串
            self.crypto_string_Text.place(x=220, y=60)
    
            self.row_num_Text = Text(self.init_window_name, width=40, height=2)  # 矩阵行数
            self.row_num_Text.place(x=220, y=120)
    
            self.encrypt_matrix_Text = Text(self.init_window_name, width=40, height=9)  # 加密矩阵
            self.encrypt_matrix_Text.place(x=220, y=180)
    
            self.crypto_result_Text = Text(self.init_window_name, width=40, height=2)  # 加/解密结果
            self.crypto_result_Text.place(x=220, y=330)
    
            self.supple_string_Text = Text(self.init_window_name, width=40, height=2)
            self.supple_string_Text.place(x=220, y=400)
    
            # 按钮
            self.encrypt_button = Button(self.init_window_name, text="加密", bg="LavenderBlush", width=10,
                                         command=self.encrypt)
            self.encrypt_button.place(x=580, y=150)
    
            self.decrypt_button = Button(self.init_window_name, text="解密", bg="LavenderBlush", width=10,
                                         command=self.decrypt)
            self.decrypt_button.place(x=580, y=300)
    
        # 判断矩阵是否存在逆矩阵
        def judge_inverse_matrix(self, matrix):
            try:
                np.linalg.inv(matrix)
            except:
                return False
            return True
    
        # 输入列表并转换为矩阵
        def inputmatrix(self):
            row_num = int(self.row_num_Text.get("1.0", "end"))
            all_list = []
            num_list2 = []
            num_list = self.encrypt_matrix_Text.get("1.0", "end").split(' ')
            for a in num_list:
                # 文本框输入的最后一位有换行符,需要去掉
                num_list2.append(int(a.strip('\n')))
    
            # 生成矩阵
            for num in num_list2:
                num_list2[num_list2.index(num)] = int(num_list2[num_list2.index(num)])
            for i in range(0, len(num_list2), row_num):
                all_list.append(num_list2[i: i + row_num])
            encrypt_matrix = np.array(all_list)
            if not self.judge_inverse_matrix(encrypt_matrix):
                # print("该矩阵不存在逆矩阵,请重修输入")
                self.crypto_result_Text.delete("1.0", "end")
                self.crypto_result_Text.insert("1.0", "该矩阵不存在逆矩阵,请重修输入")
            return encrypt_matrix
    
        # 生成矩阵的逆矩阵。如果逆矩阵含有小数,就四舍五入
        def generate_inverse_matrix(self, matrix):
            inverse_matrix = np.linalg.inv(matrix)
            print("加密矩阵的逆矩阵为:")
            for array in inverse_matrix:
                print(array)
            return inverse_matrix
    
        # 生成字母-数字对应的字典
        def alphabet_number(self):
            alphabet_number_dict = {}
            for i in range(97, 123):
                alphabet_number_dict[chr(i)] = i % 97
            return alphabet_number_dict
    
        def encrypt(self):
            # 按下加密按钮后获取文本框内明文
            input_plaintext = self.crypto_string_Text.get("1.0", "end").strip('\n')
    
            # 明文字母转换成对应数字
            num_list = []
            dic = self.alphabet_number()
            for i in input_plaintext:
                num_list.append(dic[i])
    
            # 如果矩阵行数不能整除明文,则用'z'的数字25补全
            matrix = self.inputmatrix()
            row_num = len(matrix)
            supple_num = row_num - (len(num_list) % row_num)
            if len(num_list) % row_num != 0:
                for n in range(1, supple_num + 1):
                    num_list.append(25)
            output = f"添加了{supple_num}个z补全明文"
            self.supple_string_Text.delete("1.0", "end")
            self.supple_string_Text.insert("1.0", output)
    
            # 分组加密
            group_num = int(len(num_list) / row_num)
            whole_encrypt_num_list = []
            for g in range(0, group_num):
                plaintext_matrix = np.array(num_list[0 + g * row_num: (g + 1) * row_num])
                encrypt_num_list = np.matmul(plaintext_matrix, matrix)
                for num in encrypt_num_list:
                    whole_encrypt_num_list.append(num)
    
            # 将加密后的数字转换为字母
            ciphertext = ""
            for ennum in whole_encrypt_num_list:
                # 对超出范围的数字取模
                if ennum > 25:
                    ennum = ennum % 26
                for k in dic:
                    if dic[k] == ennum:
                        ciphertext = ciphertext + k
            self.crypto_result_Text.delete("1.0", "end")
            self.crypto_result_Text.insert("1.0", ciphertext)
            # print("加密后密文为:", ciphertext, '\n')
    
        def decrypt(self):
            # 输入密文并转换为对应数字
            input_ciphertext = self.crypto_string_Text.get("1.0", "end").strip('\n')
            num_list2 = []
    
            dic2 = self.alphabet_number()
            for i in input_ciphertext:
                num_list2.append(dic2[i])
    
            # 解密就不添加'z'来补全密文了
            matrix = self.inputmatrix()
            row_num2 = len(matrix)
            supple_num2 = row_num2 - (len(num_list2) % row_num2)
    
            # 用逆矩阵分组解密
            inserve_matrix = self.generate_inverse_matrix(matrix)
            group_num2 = int(len(num_list2) / row_num2)
            whole_decrypt_num_list = []
            for g in range(0, group_num2):
                plaintext_matrix = np.array(num_list2[0 + g * row_num2: (g + 1) * row_num2])
                decrypt_num_list = np.matmul(plaintext_matrix, inserve_matrix)
                for num in decrypt_num_list:
                    whole_decrypt_num_list.append(num)
    
            # 将矩阵中的数字四舍五入
            for j in range(len(whole_decrypt_num_list)):
                whole_decrypt_num_list[j] = round(whole_decrypt_num_list[j])
    
            # 将解密后的数字转换为对应字母
            plaintext = ""
            for denum in whole_decrypt_num_list:
                if denum > 25 or denum < -26:
                    denum = denum % 26
    
                # 防止取模后是负数,字典中找不到对应的字母
                if denum < 0:
                    denum = denum + 26
    
                # 字典中寻找与数字对应的字母
                for k in dic2:
                    if dic2[k] == denum:
                        plaintext = plaintext + k
            self.crypto_result_Text.delete("1.0", "end")
            self.crypto_result_Text.insert("1.0", plaintext)
            # print("解密后明文为:", plaintext, '\n')
            self.supple_string_Text.delete("1.0", "end")
    
    
    def gui_start():
        init_window = Tk()  # 实例化出一个父窗口
        ZMJ_PORTAL = MY_GUI(init_window)
        # 设置根窗口默认属性
        ZMJ_PORTAL.set_init_window()
    
        init_window.mainloop()  # 父窗口进入事件循环,可以理解为保持窗口运行,否则界面不展示
    
    
    if __name__ == '__main__':
        gui_start()
    

    运行效果图

    加密:
    请添加图片描述
    解密:
    请添加图片描述

    遇到的问题及解决方案

    当时最主要是遇到了以下的几个问题:

    1. 当时用的win10,python自带的pyinstaller编译成exe运行,打包过后程序太大,有160MB?
      答:原因是电脑中的python文件太多了,pyinstaller编译时把所有文件全部编译到exe程序中,导致程序占用空间过大,只需要在全新的虚拟机中编译,并用upx压缩,文件就只剩15MB左右了。

    2. win7电脑运行exe程序时出现api-ms-win-core-path-l1-1-0.dll 丢失?
      答:python3.9(最新版本)已经不支持win7操作系统了,可以选择低一些的版本(python3.7)来重新把py文件编译成exe程序。

    3. 在不同电脑上打开exe程序时,按键、文字分布在不同地方?
      答:原因是每台电脑的分辨率不同。

    展开全文
  • hill密码(希尔密码

    万次阅读 多人点赞 2019-12-21 15:29:09
    希尔密码是利用矩阵进行加密的一种加密算法,其本质是一种多表代换密码。 百科: 希尔密码是运用基本矩阵论原理的替换密码,由Lester S. Hill在1929年发明。 每个字母当作26进制数字:A=0, B=1, C=2… 一串字母当成...
  • Hill密码(希尔密码

    千次阅读 2020-12-18 15:30:50
    Hill密码(希尔密码希尔密码可以防止频率分析攻击(因为运用的是矩阵,可能密文中同一个字母翻译成明文是不一样的) 希尔密码隐藏了单字母的频率 字母和数字的对应可以修改成其他方案 抵抗频率攻击 易受...
  • c++实现希尔密码

    2021-05-18 17:53:32
    希尔密码的实现(c++版;本文只以26个大写英文字符作为加密后的密文的可选项) #实验原理: ##引用知识: 记 Zm={0,1,2,...,m-1} **定义1**:设A为定义在集合Zm 上的n阶方阵,若存在一个定义在Zm上的方阵B,使得 _<u...
  • 加密解密工具 之 希尔密码

    千次阅读 2020-05-24 15:25:35
    希尔密码(Hill Cipher),是运用基本矩阵论原理的替换密码,每个字母当作26进制数字:A=0, B=1, C=2... 一串字母当成n维向量,跟一个n×n的矩阵相乘,再将得出的结果mod26。用作加密的矩阵(即密匙)必须是可逆的,...
  • 简单的凯撒密码,希尔密码加解密,python实现
  • 希尔密码的加密、解密与破解

    千次阅读 2020-12-03 17:13:30
    希尔密码是运用基本矩阵论原理的替换密码,由Lester S. Hill在1929年发明。 每个字母当作26进制数字:A=0, B=1, C=2… 一串字母当成n维向量,跟一个n×n的矩阵相乘,再将得出的结果模26。(注意用作加密的矩阵(即...
  • 希尔密码(加密、解密、破解)

    千次阅读 2020-12-05 00:02:50
    希尔密码的加密、解密与破解 简介 希尔密码是运用基本矩阵论原理的替换密码,由Lester S. Hill在1929年发明。 每个字母当作26进制数字:A=0, B=1, C=2… 一串字母当成n维向量,跟一个n×n的矩阵相乘,再将得出的结果...
  • 希尔密码(Hill Cipher) 定义 设m>=2为正整数,P=C=(Z26)m,且K={定义在Z26上的m×m可逆矩阵},对任意的密钥K,定义:ek(x)=xK和dk(y)=yK-1 ,以上运算都是在Z26上进行的。 从一个例子开始希尔密码的学习。 引例 ...
  • 希尔密码加密、解密和破密

    热门讨论 2009-12-28 11:30:58
    VC环境下实现希尔密码的加密、解码和破译
  • 密码学原理与实践(第三版) 冯登国 1.21(b) 及1.24 维吉尼亚密码.py # -*- coding: utf-8 -*- ''' 代码中各个函数的说明如下 gcd(a, b) #获取两个数的最大公因数 multi_gcd(num) #获取数组中所有数的...
  • 希尔密码 原理

    2020-06-07 08:25:43
    希尔密码(Hill Cipher),是运用基本矩阵论原理的替换密码,每个字母当作26进制数字:A=0, B=1, C=2... 一串字母当成n维向量,跟一个n×n的矩阵相乘,再将得出的结果mod26。用作加密的矩阵(即密匙)必须是可逆的,...
  • 此脚本用于使用希尔密码加密文本
  • 维吉尼亚密码: 加密: void EnVirginia(char* plaintext, int* k) { int length = strlen(plaintext); int m, n; for (int i = 0; i < length; i++) { m = plaintext[i] - 'a'; n = m + k[i]; n >=...
  • 希尔密码---1

    千次阅读 2019-12-10 21:03:49
    在之前吧我们讲过了希尔密码的理论,接下来我们讲实战。 abcde…x y z 12345…242526 有的题a是从0开始的。 一、条件 首先,我们打ctf一般会给我们两个条件: 1.密文 2.矩阵(也叫解密矩阵) 二、目的 1、根据矩阵,...
  • 我们根据相关材料,根据希尔密码的相关知识总结了我们的思路。希尔密码是运用基本矩阵乘法原理的替换密码,我们以656565表示AAA,666666表示BBB,……,888888表示YYY,898989表示ZZZ(ASCIASCIASCI值),以此类推。...
  • 古典密码之希尔密码

    千次阅读 2017-09-17 23:10:28
    希尔密码C++实现

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,907
精华内容 1,162
关键字:

希尔密码