精华内容
下载资源
问答
  • 置换密码

    万次阅读 多人点赞 2018-04-04 20:35:50
    置换密码又称换位密码,是根据一定的规则重新排列明文,以便打破明文的结构特性。置换密码的特点是保持明文的 所有字符不变,只是利用置换打乱了明文字符的位置和次序。也就是说,改变了明文的结构,不改变明文的...

     置换密码又称换位密码,是根据一定的规则重新排列明文,以便打破明文的结构特性。置换密码的特点是保持明文的 所有字符不变,只是利用置换打乱了明文字符的位置和次序。也就是说,改变了明文的结构,不改变明文的内容。

    例如:明文:asdfghjklmnbvc

    密钥:31524

    首先把弄清密钥长度,然后将密文分组即

    明文矩阵: 

         a s d f g

         h j k l m

         n b v c

    不足的用空格代替

    得到密文:dkvahngm sjbflc; 

    其中解密密钥得到方式为用密钥的顺序(12345)写出下方正常排序的(12345)例1-2,2-4,3-1····

                  3 1 5 2 4

                  1 2 3 4 5

    解密密钥:2 4 1 5 3

    解密的时候也是一样,先求出转换为矩阵有多少行,然后先将列排满然后再将行排满;

    例如上面的密文 dkvahngm sjbflc,加上空格共有15个字符所以分为3行5列,得到矩阵:

               d a g s f

               k h m j l

               v n  b c ;

    然后用解密密钥逐行输出:第一行:asdfg

                    第二行:hjklm

                    第三行:nbvc  ;

    若有空格则跳过输出。

    代码:

    /*日期:2018.3.29*/
    /*编译:李威鹏*/
    /*作用:置换密码的实现*/
    /*使用函数:头文件:<conio.h>
                        <stdio.h>
                        <string.h>
                        <stdlib.h>
                        <algorithm>
                函数名:加密函数,解密函数*/
    #include<stdio.h>
    #include<conio.h>
    #include<string.h>
    #include<stdlib.h>
    #include<algorithm>
    using namespace std;
    char mingwen[10000],miwen[10000],mingwenjuzhen[1000][1000],miwenjuzhen[1000][1000],miyao[10000];
    void shouye()
    {
        system("cls");
        printf("欢迎使用置换密码转换程序!\n");
        printf("请选择使用功能:\n");
        printf("1:加密  2:解密\n");
        printf("  0:终止程序\n");
    }
    void jiemi();
    void jiami()
    {
        system("cls");
        printf("请输入明文\n");
        scanf("%s",mingwen);
        printf("请输入数字密钥n(0<n<10)\n");
        int n,l,k=0,l1=0,i,j,q=1,w=0,aa=0,bb=0,a[10000]= {0};
        scanf("%d",&n);
        while(n)
        {
            k++;
            miyao[k]=n%10;
            n/=10;
        }
        printf("密钥为:\n");
        for(i=k; i>=1; i--)
        {
            a[k-i+1]=miyao[i];
            printf("%d ",miyao[i]);
        }
        printf("\n");
        l=strlen(mingwen);
        if(l%k!=0)//计算矩阵行数
            aa=l/k+1;
        else
            aa=l/k;
        if(aa==1)
        {
            printf("密文为:\n\n");
            for(i=1; i<=k; i++)
            {
                for(j=0; j<l; j++)
                {
                    if(a[i]==j+1)
                    {
                        printf("%c",mingwen[j]);
                    }
                }
            }
        }
        else
        {
            for(i=0; i<aa;)
            {
                if(i==aa-1)
                    break;
                for(j=0; j<l; j++)
                {
                    mingwenjuzhen[i+1][q++]=mingwen[j];
                    w++;
                    if(w==k)
                    {
                        i++;
                        w=0;
                        q=1;
                    }
                }
            }
            printf("密文为:\n\n");
            for(i=k; i>=1; i--)
            {
                for(j=1; j<=aa; j++)
                {
                    printf("%c",mingwenjuzhen[j][miyao[i]]);
                }
            }
        }
        printf("\n\n");
        printf("解密密钥为:\n");
        for(i=1; i<=k; i++)
        {
            for(j=1; j<=k; j++)
            {
                if(i==a[j])
                {
                    printf("%d ",j);
                }
            }
        }
        printf("\n");
        printf("是否继续?\n");
        printf("1:继续  2:解密  3:返回主菜单\n");
        int mm;
        scanf("%d",&mm);
        if(mm==1)
            jiami();
        if(mm==2)
            jiemi();
        if(mm==3)
            shouye();
    }
    void jiemi()
    {
        system("cls");
        printf("请输入密文:\n");
        getchar();
        gets(miwen);
        int i,j,m,l,k=0,b[1000]= {0},aa=0,q=1,w=0,bb=0;
        char s1[1000]= {0};
        l=strlen(miwen);//密文长度
        printf("请输入解密密钥m(0<m<10)\n");
        scanf("%d",&m);
        while(m)
        {
            k++;
            miyao[k]=m%10;
            m/=10;
        }
        printf("解密密钥为:\n");
        for(i=k; i>=1; i--)
        {
            b[k-i+1]=miyao[i];
            printf("%d ",miyao[i]);
        }
        printf("\n");
        if(l%k==0)//计算矩阵行数
            aa=l/k;
        else
            aa=l/k+1;
        if(aa==1)
        {
            for(i=0; i<l; i++)
            {
                if(miwen[i]==' ')
                    continue;
                else
                    s1[bb++]=miwen[i];
            }
            printf("明文为:\n\n");
            for(i=1; i<=k; i++)
            {
                for(j=0; j<l; j++)
                {
                    if(b[i]==j+1)
                        printf("%c",s1[j]);
    
                }
            }
        }
        else
        {
            for(i=0; i<l;)
            {
                for(j=0; j<k; j++)
                {
                    for(int r=0; r<aa; r++)
                    {
                        miwenjuzhen[r+1][j+1]=miwen[i];
                        i++;
                    }
                }
            }
            printf("明文是:\n\n");
            for(i=1; i<=aa; i++)
            {
                for(j=1; j<=k; j++)
                {
                    if(miwenjuzhen[i][b[j]]==' ')
                        continue;
                    else
                        printf("%c",miwenjuzhen[i][b[j]]);
                }
            }
            printf("\n\n");
        }
        printf("密钥为:\n");
        for(i=1; i<=k; i++)
        {
            for(j=1; j<=k; j++)
            {
                if(i==b[j])
                {
                    printf("%d ",j);
                }
            }
        }
        printf("\n是否继续?\n");
        printf("1:继续  2:加密  3:返回主菜单\n");
        int mm;
        scanf("%d",&mm);
        if(mm==1)
            jiemi();
        if(mm==2)
            jiami();
        if(mm==3)
            shouye();
    }
    void choose()
    {
        int test=1;
        while(test)//对于菜单的选择
        {
            printf("请输入选择:\n");
            int n;
            scanf("%d",&n);
            if(n==1)
            {
                jiami();
            }
            else if(n==2)
            {
                jiemi();
            }
            else if(n==0)
            {
                printf("欢迎使用!!\n");
                test=0;
                return;
            }
            else
            {
                printf("输入错误!\n请重新输入!");
                choose();
            }
        }
    }
    int main()
    {
        shouye();
        choose();
        return 0;
    }
    

     

    展开全文
  • 古典密码——置换密码

    千次阅读 2019-02-28 22:02:26
    置换密码

    一、置换密码

    原理:把明文中的字母重新排列,字母本身不变,但其位置改变了,这样编成的密码成为置换密码。置换密码又称移位密码,因为对照明文来看,字母的位置被移动了。

    1.最简单就是把明文顺序倒过来,然后截成固定长度的字母组作为密文

    例如:
    明文:MINGCHENWUDIANFADONGFANGONG(明晨5点发动反攻)
    密文:GNOGN AFGNO DAFNA IDUWN EHCGN IM
    倒序的置换密码显然是很弱的。

    2.栅栏密码

    原理:所谓栅栏密码,就是把要加密的明文分成N个一组,然后把每组的第1个字连起来,形成一段无规律的话。 不过栅栏密码本身有一个潜规则,就是组成栅栏的字母一般不会太多。(一般不超过30个,也就是一、两句话),从本质上讲,栅栏密码是一种置换技术,即仅仅改变位置而不做替换。

    例如:

                 明文:THE LONGEST DAY MUST HAVE AN END
    
                加密:
                	 I:把将要传递的信息中的字母交替排成上下两行。
    
                       T E O G S D Y U T A E N N
                       H L N E T A M S H V A E D
                 	 II:将下面一行字母排在上面一行的后边。
                        
                        TEOGSDYUTAENNHLNETAMSHVAED
               解密:
                    I.先将密文分为两行
    
                        T E O G S D Y U T A E N N
                        H L N E T A M S H V A E D
    
    		       II.再按上下上下的顺序组合成一句话
             			THELONGESTDAYMUSTHAVEANEND
    

    扩展
    (1)在选择行数时可以使多行,这样对于加密强度有所提高
    (2)可以在加密之后在使用其他密码进行加密,增加强度

    3.带密钥的置换

    原理:首先选一个词语作为密钥,去掉重复字母,然后按字母的字典顺序给字母编号,于是得到一组与密钥词语对应的数字序列。最后据此数字序列中的数字顺序按列选出密文。
    例如:

    明文:MING CHEN WU DIAN FA DONG FAN GONG
    密钥:玉兰花
    	YU LAN HUA
    去掉重复字母:YULANH
    数字序列: 6 5 3 1 4 2
    矩阵:    M I N G C H
    	     E N W U D I
    	     A N F A D O
    	     N G F A N G
    	     O N G * * *
    密文:GUAA* HIOG* NWFFG CDDN* INNGN MEANO
    
    小结

    置换密码比较简单,但它经不起已知明文攻击。这是因为只要把明密文对照,便可以得出置换规律,便可确定出密钥。但是,把它与其他技术相结合,可以得到十分有效的密码

    展开全文
  • 置换密码 古典密码算法

    热门讨论 2011-11-21 23:08:48
    置换密码 置换密码算法的原理是不改变明文字符,而是按照某一规则重新排列消息中的比特或字符顺序,才而实现明文信息的加密。置换密码有时又称为换位密码。 矩阵换位法是实现置换密码的一种常用方法。它将明文中的...
  • 实验报告:通过编程实现替代密码算法和置换密码算法,算法描述,代码实现。
  • C++实现单置换密码

    2020-08-26 05:13:14
    主要为大家详细介绍了C++实现单置换密码,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 自己写的 呵呵 希望支持 信息安全 古典加密算法------置换密码 古典加密算法------代换密码------乘数密码
  • 周期置换密码

    千次阅读 2020-04-17 11:04:01
    周期置换密码 参考教材:《现代密码学教程》P47 3.1.2 加密解密过程 周期置换密码是将明文p串按固定长度m分组.然后对每组中的子串按1,2…,m的某个置换重新排列位置从而得到密文,其中密钥σ包含分组长度信息。解密...

    周期置换密码

    参考教材:《现代密码学教程》P47 3.1.2

    加密解密过程

    周期置换密码是将明文p串按固定长度m分组.然后对每组中的子串按1,2…,m的某个置换重新排列位置从而得到密文,其中密钥σ包含分组长度信息。解密时同样对密文c按长度m分组,并按σ的逆置换σ-1把每组子串重新排列位置从而得到明文p
    以例3.3为例
    在这里插入图片描述
    和上次提及的列置换密码类似

    代码

    
    import re
    
    class timeCode:
        __key=[] # 密钥
        __apaMsg="" # 明文
        __secMsg="" #密文
        __lenKey=0 #密钥长度 周期值
        def getKey(self,s): # 密钥形成函数
            Key={}
            antiKey={}
            s=re.split(r'[()]',s) #以()分界
            while '' in s: # 消除''
                s.remove('')
            temp=[]
            
            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]))
            maxtemp=max(temp) #密钥长度
            self.__lenKey=maxtemp
            lenKey={i+1 for i in range(maxtemp)} 
            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
            Key=self.__key[0]
            time=self.__lenKey
            p=p.replace(' ','') #去除空格
            if len(p)%time != 0:
                p+=' '*(time-len(p)%time) #末尾补齐
            n=len(p)//time
            M=[p[i*time:(i+1)*time] for i in range(n)] #分组生成
            M=[M[i][Key[j+1]-1] for i in range(n) for j in range(time)] #矩阵转换
            M=''.join(M) #列表转换为字符串
            self.__secMsg=M
            return M
        
        def deCode(self,q):
            self.__apaMsg=p
            m=self.__lenKey
            n=len(q)//m
            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.__key,self.__apaMsg,self.__secMsg,self.__lenKey)
    
    
    s='(15623)'
    p='State Key Laboratory of Networking and Switching'
    a=timeCode()
    a.getKey(s)
    q=a.enCode(p)
    a.deCode(q)
    a.Print()
    
    
    展开全文
  • 替换密码与置换密码

    千次阅读 2020-10-23 10:56:19
    替换密码与置换密码 经典密码体制是加密和解密使用相同密钥的密码系统。 替换密码 替换密码就是将明文中的每个字母由其它字母、数字或符号替代的一种方法。替换密码通常要建立一个替换表,加密时将需要加密的明文...

    替换密码与置换密码

    经典密码体制是加密和解密使用相同密钥的密码系统。

    替换密码

    替换密码就是将明文中的每个字母由其它字母、数字或符号替代的一种方法。替换密码通常要建立一个替换表,加密时将需要加密的明文依次通过查表,替换为相应的字符,明文字符被逐个替换后,生成无任何意义的字符串,即密文,这些替换表就作为密钥。

    (1)单表替换密码

    又称为单字母替换,明文字母表中的一个字符对应密文字母表中的一个字符。即对明文消息中出现的同一个字母,在加密时都使用同一固定的字母来代换。

    (2)多表替换密码

    指两个以上替换表依次对明文消息的字母进行替换。明文消息中出现的同一个字母,在加密时不是完全被同一固定的字母代换,而是根据其出现的位置次序,用不同的字母代换。例如,使用有5个替换表的替换密码,明文的第一个字母对应第一个替换表,第二个字母对应第二个替换表,以此类推。

    置换密码

    置换密码是根据一定的规则重新排列明文,以便打破明文的结构特性。置换密码的特点是保持明文的所有字符不变,只是利用置换打乱了明文字符的位置和次序

    例如,最简单的栅栏技术,将明文按对角线的顺序写下,然后按行读出即为密文。深度为2的栅栏密码加密消息“hello everybody”,写成如下形式:

    h l o v r b d

    e l e e y o y

    密文是:HLOVRBDELEEYOY

    展开全文
  • 密码学--置换密码

    千次阅读 2019-12-22 21:39:33
    置换密码置换密码算法的原理是不改变明文字符,只将字符在明文中的排列顺序改变,从而 实现明文信息的加密。置换密码有时又称为换位密码。 矩阵换位法是实现置换密码的一种常用方法。它将明文中的字母按照给的顺序...
  • 主要为大家详细介绍了java实现置换密码加密解密,具有一定的参考价值,感兴趣的小伙伴们可以参考一下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,095
精华内容 4,038
关键字:

置换密码