精华内容
下载资源
问答
  • 用c++语言实现的古典密码算法列置换的演示程序。
  • 这是列置换加密的c程序,有关密码学的加解密
  • 列置换密码

    千次阅读 2020-04-17 03:12:11
    列置换密码 参考教材:《现代密码学教程》P46 3.1.1 过程 加密过程 将明文p以设定的固定分组宽度m按行写出,即每行有m个字符;若明文长度不是m的整数倍,则不足部分用双方约定的方式填充,如双方约定用空格代替空缺处...

    列置换密码

    参考教材:《现代密码学教程》P46 3.1.1

    过程

    加密过程

    1. 将明文p以设定的固定分组宽度m按行写出,即每行有m个字符;若明文长度不是m的整数倍,则不足部分用双方约定的方式填充,如双方约定用空格代替空缺处字符,不妨设最后得字符矩阵[Mp]n×m
    2. 按1,2…,m的某一置换σ交换列的位置次序得字符矩阵[Mp]n×m
    3. 把矩阵按[Mp]n×m列的顺序依次读出得密文序列c

    解密过程

    1. 将密文c以分组宽度n按列写出得到字符矩阵[Mp]n×m
    2. 按加密过程用的置换σ的逆置换σ-1交换列的位置次序得字符矩阵[Mp]n×m
    3. 把矩阵[Mp]n×m按1,2…,n行的顺序依次读出得明文p

    说明

    以例3.2为例
    在这里插入图片描述
    σ=(143)(56)即每个括号里部分轮着相对应
    1→4→3→1
    5→6→5
    这里我是用字典表示

            for i in range(len(s)): 
                for j in range(len(s[i])-1):
                    Key[int(s[i][j])]=int(s[i][j+1]) #密钥字典
                    antiKey[int(s[i][j+1])]=int(s[i][j]) #反密钥字典
                Key[int(s[i][-1])]=int(s[i][0]) #解决最后一个的问题
                antiKey[int(s[i][0])]=int(s[i][-1])
                temp.append(int(s[i][-1]))
    

    当然,这儿σ=(143)(56)中没有2,因为2对应他自己即
    2→2
    所以要再单独表示

    sameKey=lenKey-set(temp) #找到没有变化的密钥
        for i in sameKey:
            Key[i]=i
            antiKey[i]=i
    

    而加密的时候,便是把明文先变为矩阵,载根据密钥进行转换
    比如本题便将矩阵第一列转换为第四列,第四列转换为第三列,第三列转换为第一列,以此类推
    这里可以用生成式完成

    M=[M[i][Key[j+1]-1] for i in range(n) for j in range(m)] #矩阵转换
    

    完整代码

    '''列置换密码
    Auher:Jarrycow
    time:2020-04-17
    '''
    import re
    
    class colCode:
        __m=0
        __n=0
        __key=[] # 密钥
        __apaMsg="" # 明文
        __secMsg="" #密文
        
        def __init__(self,m): # 初始化,定义矩阵宽
            self.__m=m
            __n=0
            __key=[] 
            __apaMsg="" 
            __secMsg="" 
        def getKey(self,s): # 密钥形成函数
            m=self.__m
            Key={}
            antiKey={}
            s=re.split(r'[()]',s) #以()分界
            while '' in s: # 消除''
                s.remove('')
            temp=[]
            lenKey={i+1 for i in range(m)} #密钥长度
            for i in range(len(s)): 
                for j in range(len(s[i])-1):
                    Key[int(s[i][j])]=int(s[i][j+1]) #密钥字典
                    antiKey[int(s[i][j+1])]=int(s[i][j]) #反密钥字典
                    temp.append(int(s[i][j])) #钥匙收录
                Key[int(s[i][-1])]=int(s[i][0]) #解决最后一个的问题
                antiKey[int(s[i][0])]=int(s[i][-1])
                temp.append(int(s[i][-1]))
            sameKey=lenKey-set(temp) #找到没有变化的密钥
            for i in sameKey:
                Key[i]=i
                antiKey[i]=i
            self.__key.append(Key)
            self.__key.append(antiKey)
    
        def enCode(self,p): #加密函数
            self.__apaMsg=p
            m=self.__m
            n=self.__n
            Key=self.__key[0]
            p=p.replace(' ','') #去除空格
            p+=' '*(m-len(p)%m) #末尾补齐
            n=len(p)//m #矩阵列数
            self.__n=n
            M=[p[i*m:(i+1)*m] for i in range(n)] #矩阵生成
            M=[M[i][Key[j+1]-1] for i in range(n) for j in range(m)] #矩阵转换
            M=''.join(M) #列表转换为字符串
            self.__secMsg=M
            return M
        
        def deCode(self,q):
            self.__apaMsg=p
            m=self.__m
            n=self.__n
            Key=self.__key[1]
            M=[q[i*m:(i+1)*m] for i in range(n)]
            M=[M[i][Key[j+1]-1] for i in range(n) for j in range(m)]
            M=''.join(M)
            self.__secMsg=M
            return M
        def Print(self):
            print(self.__m,self.__n,self.__key,self.__apaMsg,self.__secMsg)
    
    if __name__=='__main__':
        m=6
        p="Beijing 2008 Olympic Games"
        s='(143)(56)'
        a=colCode(m)
        a.getKey(s)
        q=a.enCode(p)
        e=a.deCode(q)
        a.Print()
    def main():
        pass
    
    
    展开全文
  • 用c语言实现的古典密码算法列置换的演示程序。
  • 数据加密——列置换加密

    千次阅读 2019-03-31 16:06:58
    刚刚看到考题中有个这样的题,考到了列置换加密,记录一下自己的理解。 列置换加密,概念性的东西就不说了,网上都有,直接写我自己的理解,干货。 从明文 ———— 密文 (加密) 现有明文:...

    刚刚看到考题中有个这样的题,考到了列置换加密,记录一下自己的理解。

    列置换加密,概念性的东西就不说了,网上都有,直接写我自己的理解,干货。

    1. 从明文 ———— 密文 (加密)

    现有明文:computrnetworkprinciple
    加密后密文为:cuerippnoriottknlmrwpce
    密钥为字符串: code
    过程:

    第一步先把密钥转换为一个数字,这个数字是加密的关键,转换方法为,首先得到字母的个数,这里code为4,然后得到1至这个数的所有数,这里为1,2,3,4.。然后按26个字母的顺序来,越靠前的,数字越小,若位置相同,则靠左边的越小,所以字符串code就等于 1423. 因为c最靠前,d其次,e第三,最后才是o, 所以c代表1,o代表4,e代表3,d代表2,连起来即1423.

    第二部,将明文转化为一个矩阵,矩阵的行元素个数为字母的个数,即为4,我们将明文转化后可得:
    c o m p
    u t r n
    e t w o
    r k p r
    i n c i
    p l e

    按1423的索引顺序读取即可
    先索引为1的列
    cuerip
    然后索引为4的列
    pnori
    然后2
    ottknl
    然后3
    mrwpce

    将上面的字符串连起来可得到密文。

    如果是解密的话,则反着填写矩阵就可以得到明文了。

    展开全文
  • 置换密码 代码如下: #置换密码 a = input('请输入明文:') print("逆序后的密文为:",a[::-1]) 结果如图: 代码如下: #栅栏技术(栏数为7) a = input('请输入明文:') b = [] c = [] b.extend(a) len = len(b...
    • 置换密码
      在这里插入图片描述
      代码如下:
    #置换密码
    a = input('请输入明文:')
    print("逆序后的密文为:",a[::-1])
    
    	结果如图:
    

    在这里插入图片描述
    在这里插入图片描述
    代码如下:

    #栅栏技术(栏数为7)
    a = input('请输入明文:')
    b = []
    c = []
    b.extend(a)
    len = len(b)
    for i in range(7):
        c.extend(b[i:len:7])
    print('栏数为7的密文为:')
    for temp in c:
        print(temp,end = '')
    print("\n")
    
    	结果如图:
    

    在这里插入图片描述
    在这里插入图片描述
    注意:加密的时候要把明文补成方阵,缺少字符的地方用空格占位,密文中也带有空格,否则该密文无法正确解密。(代码已做修改)
    代码如下:

    #include <iostream>
    #include<bits/stdc++.h>
    using namespace std;
    
    int main()
    {
        string s;
        int len;
        cout<<"请输入明文:"<<endl;
        getline(cin,s);
        len = s.length();
        char a[100][100];
        for(int i = 0; i < 100 ;i++)        //初始化一个100x100,值都为*的二维矩阵
        {
            for(int k = 0; k < 100;k++)
            {
                a[i][k] = '*';
            }
        }
    
        int j = 0,k = 0;
        int width = 5;  //设置默认宽度为5
        for(int i = 0; i < len ;i++)    //将输入的字符串存储在二维数组a[]里面,并去除空格
        {
            if(s[i] != ' ')
            {
                a[j][k] = s[i];
                k++;
                if(k >= width)
                {
                    k = k % width;
                    j++;
                }
            }
        }
        j++;
        cout<<"列值为"<<width<<"的矩阵是:"<<endl;
        for(int i = 0; i < j ;i++)
        {
            for(int k = 0; k < width;k++)
            {
                if (a[i][k] != '*')
                {
                    cout<<a[i][k];
                }
            }
            cout<<endl;
        }
        cout<<"列置换后的密文为:"<<endl;
        for(int k = 0; k < width;k++)       //输出列置换后的密文
        {
            for(int i = 0; i < j ;i++)
            {
                if (a[i][k] != '*')
                {
                    printf("%c",a[i][k]);
                }
                else{
                    printf(" ");
                }
            }
        }
    
        return 0;
    }
    
    
    
    	结果如图
    

    在这里插入图片描述

    • 代替密码
      在这里插入图片描述
      代码如下:
    #Caesar密码(加法加密)
    def encode(b,k):            #加密函数
        c = []
        for temp in b:
            if temp != ' ':
                if ord(temp)+k > ord('Z'):
                    c.extend(chr((ord(temp)+k)-26))
                else:
                    c.extend(chr(ord(temp)+k))
        return c
    def decode(b,k):            #解密函数
        c = []
        for temp in b:
            if temp != ' ':
                if ord(temp)-k < ord('A'):
                    c.extend(chr((ord(temp)-k)+26))
                else:
                    c.extend(chr(ord(temp)-k))
        return c
    
    a = input('请输入明文:\n')
    k = int(input('请输入移位值:'))
    b = []
    b.extend(a)
    len = len(b)
    en = []
    en = encode(b,k)
    print("经过"+str(k)+"移位后的密文为:")
    for temp in en:
        print(temp,end = ' ')
    de = decode(en,k)
    print("\n经过"+str(k)+"移位还原得到的明文为:")
    for temp in de:
        print(temp,end = ' ')
    
    	结果如图
    

    在这里插入图片描述
    在这里插入图片描述
    代码如下:

    #Caesar密码(乘法加密)
    #print(ord('A'))  #65
    #print(ord('Z'))  #90
    
    def judge(a,b):             #判断两个数是否互质
        temp = 0
        while(b != 0):
            temp = b;
            b = a % b
            a = temp
        if(a == 1):
            return True
        else:
            return False
    
    B = 26
    while(True):
        A = int(input("请输入一个与26互素的正整数:"))
        if(judge(A,B)):
            break;
        else:
            print("您输入的数字不符合要求,请按要求输入。")
    a = input('请输入明文:\n')
    info = {}
    j = 0
    for i in range(len(a)):
        if(a[i] != ' '):
            info[j] = a[i]
            j += 1
    print("K值为"+str(A)+"乘法加密的密文为:")
    for i in range(B):
        print(info[(i*A)%26],end = ' ')
    
    	结果如图:
    

    在这里插入图片描述

    展开全文
  • 凯撒密码/列置换密码

    千次阅读 2019-09-13 00:45:33
    设Bob 给Alice 发送了frgh 和cuerippnori$ottknlmrwpce 两段密文。 其中第一段密文为密钥k=3( 字符集为26...第二段密文是采用了第一段密文的明文作为加密密钥的列置换密码( 填充字符为$) 。 试求: (1) 第一段密文...

    设Bob 给Alice 发送了frgh 和cuerippnori$ottknlmrwpce 两段密文。

    其中第一段密文为密钥k=3( 字符集为26 个小写英文字母) 的恺撒密码,

    第二段密文是采用了第一段密文的明文作为加密密钥的列置换密码( 填充字符为$) 。

    试求:
    (1) 第一段密文的明文:
    (2) 第二段密文的明文( 写出解密过程) 。

    (1) 恺撒密码的替换方法是通过排列明文和密文字母表,密文字母表示通过将明文字母表向左或向右移动一个固定数目的位置。
    例如,当偏移量是左移3的时候(解密时的密钥就是3): 
    明文字母表:ABCDEFGHIJKLMNOPQRSTUVWXYZ ;
    密文字母表:DEFGHIJKLMNOPQRSTUVWXYZABC。
    由密文frgh和密钥k=3,知明文为密文向右移动了3位,明文为code。
    (2) 第二段密文的密钥为code。列置换密码为从上往下写密文,读取为从左到右得到明文。
    密钥code
    顺序1423
    明文cpom

    untr
    eotw
    rrkp
    iinc
    p$le

    得到明文    comp utrn etwo  rkpr inci ple$

    去掉填充字符整理后的到明文    computer network principle 

     

    转载于:https://my.oschina.net/u/3876440/blog/3019502

    展开全文
  • https://moriarty98.github.io/2019/06/09/%E7%BB%B4%E5%90%89%E5%B0%BC%E4%BA%9A%E8%A1%A8%E5%92%8C%E5%88%97%E7%BD%AE%E6%8D%A2%E7%BB%93%E5%90%88%E5%8A%A0%E5%AF%86/ 我将整个完整的实现过程发布在了我的博客...
  • 行置换密码 (列置换密码)

    万次阅读 2013-05-06 23:44:18
    很多教材上对于行置换密码、列置换密码的定义都不是完全相同,甚至核心思想根本不一样。笔者就自己学习的经历,简单介绍一种一些教材上所谓的“行置换密码”的算法,大家一起交流、学习。   利用这种加密方法,...
  • 置换密码(Permutation ...常见的置换密码有两种:列置换密码和周期置换密码。  一、列置换加密  将明文字符P以固定的分组宽度m按行写出,构成m x n的矩阵[M]mxn,不够的按双方约定的字符补充,比如空格字符。然...
  • 主要为大家详细介绍了java实现置换密码加密解密,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 通过编程实现Column permutation加密,更加深入的了解其原理,掌握Column permutation算法。...只能了解一下列置换密码的原理,也就是动手练习练习,不能实际应用。 程序运行如下:
  • java实现置换加密算法

    2012-12-19 21:38:00
    自己写的java实现的置换加密算法,信息安全课程上机实验,欢迎大家下载
  • 就当为CSDN这方面的python开源做点贡献哈哈哈 ... 算法原理 ... self.d=d#置换-加密函数(小写字母表示明文,大写字母表示密文) v=''.join(chr(i) for i in range(97,123)) """ d=dict(zip(''.join(chr
  • 置换密码的加密解密

    千次阅读 2018-12-19 21:27:34
    Java实现置换密码代码 代码 分组长度为7 加密顺序为{5, 3, 2, 0, 6, 4, 1} package com.jingfei.Encryptoin; import java.util.Scanner; public class ZhiHuan { public static void main(String[] args) { ...
  • C语言双重置换加密

    千次阅读 2016-11-25 17:30:25
    密钥:置换规则:(1,2,3,4,5,6,7,8)->(2,3,4,5,6,7,8,1)进行行置换,(1,2,3,4,5,6,7,8)->(3,4,5,6,7,8,1,2)进行列置换。#include #include int main(){ char yw[3][50] = {"大风起兮云飞扬,", "威加海内兮
  • python简单置换加密解密程序

    千次阅读 2020-04-15 20:14:07
    #置换密码:a<--->e b<--->f c--->g d<--->h ..... w<--->a x<--->b y<--->c z<--->d import math #声明类 class Cipher: #加密模块 def encrypt(self...
  • 根据李子臣老师编著的《 密码学--基础理论与应用》这本书,来简单的介绍三种古典密码(置换密码,代换密码,轮换密码) 由于博主也是初学者,理解不到位的地方还请各位大佬指出来,共同学习,相互进步。
  • 用C++实现置换密码的加密解密算法,此文档为代码实现
  • 置换密码的c++实现程序

    热门讨论 2011-03-26 15:00:01
    古典密码体系中最基本的一种密码机制,使用c++设计完成
  • C++实现置换算法通过矩阵变换加密解密,内容简单实用!

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 21,908
精华内容 8,763
关键字:

列置换