密码学初涉

密码学初涉

这学期不能混下去了，密码学好好学，立一个flag，每讲一个密码都会写一份程序放到博客上，欢迎大佬们监督。

caser

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/**
 * Created by xnianq on 17-2-21.
 */
import java.util.Scanner;
public class caser {
    public static void main(String[] args){
        String s = "i am xnianq";
        Caser(1,s);
    }
    public static  void Caser(int n, String s){
        String s1 = "";
        s = s.replace(" ","");
        System.out.println(s);
        char[] chars = s.toCharArray();
        for(int i=0;i<s.length();i++)
        {
            s1 = s1 + (char)(((int)chars[i]-(int)'a'+n)%26+(int)'a');
         }
            System.out.println(s1);
    }
}

仿射密码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
/**
 * Created by xnianq on 17-2-22.
 */
public class FSmima {
    public static void encrypy(String s,int a,int b){
        char[] chars = s.toCharArray();
        String s1 = "" ;
        if(gcd(a,26)==false){
            System.out.print("[*]"+a+"不与"+b+"互素，会产生错误，无法准确解密");
        }
        else {
            for(int i = 0;i <s.length();i++){
                if((int)chars[i]<='z'&&(int)chars[i]>='a')
                    s1 = s1 + (char)((((int)chars[i] - (int)'a')*a + b)%26 + (int)'a');
                if((int)chars[i]<='Z'&&(int)chars[i]>='A')
                    s1 = s1 + (char)((((int)chars[i] - (int)'A')*a + b)%26+ (int)'A');
            }
            System.out.println("亲，你的加密结果为："+s+"->"+s1);
        }
    }
    public static void decrypt(String s ,int a,int b){
            char[] chars = s.toCharArray();
            String s1 = "";
            int a1 = getreverse(a,26);
            for(int i = 0;i<s.length();i++){
                if((int)chars[i]<='z'&&(int)chars[i]>='a')
                    if(((int)chars[i] - (int)'a' - b)>0)
                        s1 = s1 + (char)((((int)chars[i] - (int)'a' - b)*a1)%26 + (int)'a');
                    else
                        s1 = s1 + (char)((((int)chars[i] - (int)'a' - b + 26)*a1)%26 + (int)'a');
                if((int)chars[i]<='Z'&&(int)chars[i]>='A')
                    if((int)chars[i]<='Z'&&(int)chars[i]>='A')
                        if(((int)chars[i] - (int)'a' - b)>0)
                            s1 = s1 + (char)((((int)chars[i] - (int)'A' - b)*a1)%26 + (int)'A');
                        else
                            s1 = s1 + (char)((((int)chars[i] - (int)'A' - b + 26)*a1)%26 + (int)'A');
            }
            System.out.print("亲，你的解密结果为："+s+"->"+s1);
    }
    public static int getreverse(int a,int b){
        for(int i=2;i<b;i++){
            if((a*i)%b==1){
                return i;
            }
        }
        return 0;
    }
    public static boolean gcd(int a,int b){
        for(int i=3;i<Math.sqrt(a);i++){
            if (b%i ==0){
                return false;
            }
        }
        return true;
    }
    public static void main(String[] args){
            encrypy("hoOt",7,3);
            decrypt("AxXg",7,3);
    }
}

维吉尼亚密码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
/**
 * Created by xnianq on 17-2-22.
 */
public class WJNYmima {
    public static void encrypt(String key,String s){
        char[] keys = key.toCharArray();
        char[] chars = s.toCharArray();
        String s1 = "";
        for(int i = 0; i<s.length();i++){
            s1 = s1 + (char)(((int)chars[i]+(int)keys[i%key.length()]-'a'-'a')%26 + (int)'a');
        }
        System.out.println("亲，你的加密结果为："+s+"->"+s1);
    }
    public static void decrypt(String key,String s){
        char[] keys = key.toCharArray();
        char[] chars = s.toCharArray();
        String s1 = "";
        for(int i=0;i<s.length();i++){
            if(((int)chars[i]-(int)keys[i%key.length()])>0)
            s1  =s1  + (char)(((int)chars[i]-(int)keys[i%key.length()])+ (int)'a');
            else
                s1 = s1 + (char)(((int)chars[i]-(int)keys[i%key.length()]+26)+(int)'a');
        }
        System.out.println("亲，你的解密结果为："+s+"->"+s1);
    }
    public static void main(String[] args){
        encrypt("cipher","thiscryptosystemisnotsecure");
        decrypt("cipher","vpxzgiaxivwpubttmjpwizitwzt");
    }
}

维吉尼亚密码破解以及解密

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
# coding:utf-8
"""
author:xnianq
date:2017/03/01
"""
dict = {'A':0.082,'B':0.015,'C':0.028,'D':0.043,'E':0.127,'F':0.022,'G':0.02,'H':0.061,'I':0.07,'J':0.002,'K':0.008,'L':0.04,'M':0.024,'N':0.067,'O':0.075,'P':0.019,'Q':0.001,'R':0.060,'S':0.063,'T':0.091,'U':0.028,'V':0.010,'W':0.023,'X':0.001,'Y':0.020,'Z':0.001}
def GetStr(s,n):   # 将密文进行分组
    list =[]
    for i in range(0,n):
        list.append('')
    for i in range(0,len(s)):
        list[i%n] = list[i%n]+s[i]
    return list
def GetIc(s):
    p = 0
    for x in range(65,91):
        p = p + float(s.count(chr(x))*(s.count(chr(x))-1)/ float(len(s)*(len(s)-1)))
    return p
def Getkey(n,m):
    key =""
    n1 =len(n)/int(m)
    m =int(m)
    list = GetStr(n,m)
    for z in range(0,list.__len__()):
        list3 = []
        list4 = []
        for y in range(0,26):
            p = 0.0
            for x in range(65, 91):
                p = p + float(list[z].count(chr((x-65+y)%26+65))*dict[chr(x)])/ float(n1)
            list3.append(p)
        for n in range(0,list3.__len__()):
            abslist = abs(list3[n]-0.065)
            list4.append(abslist)
        key = key+chr(list4.index(min(list4))+65)
    return key
def Decrypt(s,key):
    final = ""
    for i in range(0,len(s)):
        if (ord(s[i])-ord(key[i%len(key)]))>=0 :
            final = final + chr(ord(s[i])-ord(key[i%len(key)])+ord("A"))
        else:
            final = final + chr(ord(s[i])-ord(key[i%len(key)])+26+ord("A"))
    return final
if __name__=='__main__':
    s = raw_input("亲，请输入你需要猜解密的字符串：")
    s = s.replace(" ","")
    s = s.upper()
    for i in range(1,10):
        list2 = []
        ave = 0.0
        list = GetStr(s,i)
        for x in range(0,list.__len__()):
            #print list[x]
            list2.append(GetIc(list[x]))
        for x in range(0,list2.__len__()):
            ave = ave + float(list2[x])
        print "当m="+str(i)+"时，重合指数(平均)为："+str(float(ave)/list2.__len__())
        #print list2
    m = raw_input("请输入重合指数最接近0.065的m值：")
    key = Getkey(s,m)
    print "亲，你的密钥为："+key
    plaintext = Decrypt(s,key)
    print "亲，明文为：\n"+plaintext

hill密码中两阶矩阵和逆矩阵相同的个数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#coding:utf-8
"""
author:xnianq
date:2017/03/04
"""
import numpy
def Create():
    count =0
    for i in range(0,26):
        for j in range(0,26):
            for x in range(0,26):
                for z in range(0,26):
                    if((i*z-x*j)%26)==1:
                         if(z%26==i%26 and (26-j)%26==j%26 and (26-x)%26==x%26):
                            count = count + 1
                            print "第"+str(count)+"组key为："+str(i),str(j),str(x),str(z)
                    if ((i*z-x*j+26)%26) == 25:
                        if ((-z)%26 == (i)%26 ):
                            count = count + 1
                            print "第" + str(count) + "组key为：" + str(i), str(j), str(x), str(z)
if __name__ == '__main__':
    Create()

AES密钥还有明文是书上的作业。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
#coding:utf-8
Sbox = [
        0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
        0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
        0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
        0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
        0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
        0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
        0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
        0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
        0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
        0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
        0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
        0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
        0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
        0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
        0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
        0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16]
R_Sbox = [
    0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38, 0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB,
    0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87, 0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB,
    0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D, 0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E,
    0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2, 0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25,
    0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92,
    0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA, 0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84,
    0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A, 0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06,
    0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02, 0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B,
    0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA, 0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73,
    0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85, 0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E,
    0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89, 0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B,
    0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20, 0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4,
    0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31, 0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F,
    0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D, 0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF,
    0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0, 0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61,
    0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26, 0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D,
       ]
RCon = (0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80,0x1b,0x36)
key   = "2B7E151628AED2A6ABF7158809CF4F3C"
plain = "328831E0435A3137F6309807A88DA234"
Alpha = {'0':0,'1':1,'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9,'A':10,'B':11,'C':12,'D':13,'E':14,'F':15}
def Key_Expansion(key):
    w = []
    for i in range(0,4):
        key1 = []
        key1.append(key[4*i])
        key1.append(key[4*i+1])
        key1.append(key[4*i+2])
        key1.append(key[4*i+3])
        #print key[4*i+1]
        w.append(key1)
    for i in range(4,44):
        temp = []
        #print w[i-1]
        for j in range(0,4):
            temp.append(w[i-1][j])
        if i%4 ==0:
            temp = Subword(Rotword(temp))
            temp[0] = temp[0]^RCon[i/4-1]&0xff
        p = []
        for  j in range(0,4):
            p.append(w[i-4][j]^temp[j]&0xff)
        w.append(p)
    #print w
    return w
def _initKey(key):
    w = []
    for i in range(0,len(key)-1,2):
        num = Alpha[key[i+1]]+16*Alpha[key[i]]
        w.append(num)
    return w
def Rotword(list):
    list[0],list[1],list[2],list[3] = list[1],list[2],list[3],list[0]
    return list
def Subword(list):
    list[0],list[1],list[2],list[3] = Sbox[int(list[0])],Sbox[int(list[1])],int(Sbox[int(list[2])]),int(Sbox[int(list[3])])
    return list
def SubBytes(number):
    return  Sbox[number]
def FieldMult(x,t):
    y  = []
    for i in range(0,8):
        z = x
        if (t&(1<< i)&0xff)!=0:#
            for j in range(0,i):
                if (z & (0x80) & 0xff) != 0:
                    z = z << 1 & 0xff
                    z = z ^ 0x1b & 0xff
                else:
                    z = z << 1 & 0xff
            y.append(z)
    if len(y)>=2:
        z = y[0]^y[1]&0xff
        for i in range(2,len(y)):
            z = z^y[i]
    elif len(y)==1:
        z = y[0]
    else:
        z=0
    return z
def addkey(plain,w):
    #print w
    for i in range(0,len(plain)):
        #print w[i/4]
        plain[i] = plain[i]^w[i%4][i/4]&0xff
    return plain
def MixColumn(c):
    z = []
    u0 = FieldMult(0x02,c[0])^FieldMult(0x03,c[1])^c[2]^c[3]&0xff
    u1 = FieldMult(0x02, c[1]) ^ FieldMult(0x03, c[2]) ^ c[3] ^ c[0] & 0xff
    u2 = FieldMult(0x02, c[2]) ^ FieldMult(0x03, c[3]) ^ c[0] ^ c[1] & 0xff
    u3 = FieldMult(0x02, c[3]) ^ FieldMult(0x03, c[0]) ^ c[1] ^ c[2] & 0xff
    z.append(u0)
    z.append(u1)
    z.append(u2)
    z.append(u3)
    return z
def printhex(list):
    z = []
    for i in range(0,len(list)):
        z.append(hex(list[i]))
    print z
def shift_rows(plain):
    plain[4],plain[5],plain[6],plain[7] = plain[5],plain[6],plain[7],plain[4]
    plain[8],plain[9],plain[10],plain[11] = plain[10],plain[11],plain[8],plain[9]
    plain[12],plain[13],plain[14],plain[15] = plain[15],plain[12],plain[13],plain[14]
    return plain
def GetMix(plain):
    z = []
    z1 =[]
    z2 =[]
    z3 = []
    z4 = []
    for i in range(0,4):
        z1.append(plain[0+4*i])
        z2.append(plain[1+4*i])
        z3.append(plain[2+4*i])
        z4.append(plain[3+4*i])
    z.append(z1)
    z.append(z2)
    z.append(z3)
    z.append(z4)
    return z
def GetPlain(plain):
    z = []
    for i in range(0,4):
        for j in range(0,4):
            z.append(plain[j][i])
    return z
def encrypt():
    key1 = Key_Expansion(_initKey(key))
    plain1  = _initKey(plain)
    Initkey = []
    for i in range(4):
        Initkey.append(key1[i])
    print Initkey
    plain1 = addkey(plain1,Initkey)
    print "第一轮密钥加"
    printhex(plain1)
    for i in range(0,9):
        for j in range(0,len(plain1)):
            plain1[j] = SubBytes(plain1[j])
        print "第"+str(i+1)+"轮subBytes："
        printhex(plain1)
        plain1 = shift_rows(plain1)
        printhex(plain1)
        plain1 = GetMix(plain1)
        for h in range(0,4):
            plain1[h] = MixColumn(plain1[h])
        plain1 = GetPlain(plain1)
        printhex(plain1)
        keyadd = []
        for j in range(0,4):
            keyadd.append(key1[4*(i+1)+j])
        print "第"+str(i+1)+"轮密钥"
        print keyadd
        plain1 = addkey(plain1,keyadd)
        printhex(plain1)
    for j in range(0,len(plain1)):
        plain1[j] = SubBytes(plain1[j])
    plain1 = shift_rows(plain1)
    keyadd = []
    for j in range(0,4):
        keyadd.append(key1[40+j])
    Ciphertext = addkey(plain1,keyadd)
    CiphertextFinal = ""
    for i in range(0,len(Ciphertext)):
        CiphertextFinal += hex(Ciphertext[i]).replace("0x","")
    print CiphertextFinal
    print FieldMult(54,0)
if __name__ == '__main__':
    encrypt()

AES对文件进行加密解密

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
#coding:utf-8
import os,random
from Crypto.Cipher import AES
from Crypto.Hash import SHA256
modes = {'1':2,'2':3,'3':6,'4':1,'5':5,'6':4}
def encrypt(key,filename,mode):
    chunksize = 64*1024
    outFile = "AESEn"+filename
    filesize = str(os.path.getsize(filename)).zfill(16) #返回16
    IV = ''
    for i in range(16):
        IV = IV + chr(random.randint(0,0xff))
    encryptor = AES.new(key,AES.MODE_CBC,IV)
    with open(filename,'rb') as infile:
        with open(outFile,'wb') as outfile:
            outfile.write(filesize)
            outfile.write(IV)
            while True:
                chunk = infile.read(chunksize)
                if len(chunk) ==0:
                    break
                elif len(chunk)%16 !=0:
                    chunk = chunk + (16-len(chunk)%16)*' '
                print "DOne"
                outfile.write(encryptor.encrypt(chunk))
def decrypt(key,filename,mode):
    chunksize = 64*1024
    outfile = "De"+filename
    with open(filename) as infile:
        with open(outfile,"wb") as outfile:
            filesize = long(infile.read(16))
            IV  = infile.read(16)
            decryptor = AES.new(key,mode,IV)
            while True:
                chunk = infile.read(chunksize)
                if len(chunk) == 0:
                    break
                outfile.write(decryptor.decrypt(chunk))
            outfile.truncate(filesize)
def getkey(password):
    key = SHA256.new(password)
    return key.digest()
def main():
    choice = raw_input("加密请输入：1,解密请输入：2")
    password = raw_input("请输入您的密钥：")
    mode = raw_input("加密模式：[1]CBC,[2]CFB,[3]CTR,[4]ECB,[5]OFB,[6]PGP")
    mode = modes[mode]
    key = getkey(password)
    if choice == '1':
        file = raw_input("请输入要加密文件的绝对路径:")
        encrypt(key,file,mode)
    if choice =='2':
        file = raw_input("请输入要解密文件的绝对路径：")
        decrypt(key,file,mode)
if __name__ == '__main__':
    main()

RC4实现对文件以及文字的加密解密

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
#coding:utf-8
"""
author:xnianq
"""
def initsbox(key):
    sbox = range(256)
    j = 0
    for i in range(0,256):
        j = (j+sbox[i]+ord(key[i%len(key)]))%256
        sbox[i],sbox[j] = sbox[j],sbox[i]
    return sbox
def initkey(key,data):
    i = 0
    j = 0
    k = []
    for x in range(0,len(data)):
        i = (i+1)%256
        j = (j+key[i])%256
        key[i],key[j] = key[j],key[i]
        k.append(key[(key[i]+key[j])%256])
    return k
def encrypt(text,key):
    c = []
    for i in range(0,len(text)):
        c.append(chr(ord(text[i])^key[i]))
    return ''.join(c)
def readfile(file):
    a = open(file, 'r')
    try:
        content = a.read()
    finally:
        a.close()
    return content
def writefile(file,text):
    f = open(file,'w')
    try:
        f.write(text)
    finally:
        f.close()
def main():
    key  = raw_input("请输入密钥：")
    ty = raw_input("请输入要加密的类型,文字：[1],文件:[2]")
    if ty == '1':
        data = raw_input("请输入要加密的文字")
    elif ty =='2' :
        filename = raw_input("请输入要加密的文件(绝对路径)")
        data = readfile(filename)
    sbox = initsbox(key)
    pay = initkey(sbox,data=data)
    cipher = encrypt(data,pay)
    if ty == '1':
        print "密文为："+cipher
    if ty == '2':
         writefile(file="RC4en"+filename,text=cipher)
         print "文件已经加密，请查看:"+"RC4en"+filename
if __name__ == '__main__':
    main()

python不借助hashlib生成md5

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
#coding:utf-8
import  math
import struct
import hashlib
A=0x67452301
B=0xefcdab89
C=0x98badcfe
D=0x10325476
T =  tuple(int(4294967296*abs(math.sin(x))) for x in range(65))
def F(x,y,z):
    return (x&y)|((~x)&z)
def G(x,y,z):
    return (x&z)|(y&(~z))
def H(x,y,z):
    return x^y^z
def I(x,y,z):
    return y^(x|(~z))
def FF(a,b,c,d,Mj,s,ti):
    a = b+XHYW(s,(a+(F(b,c,d)+Mj+ti))&0xffffffff)
    return a&0xffffffff
def GG(a,b,c,d,Mj,s,ti):
    a = b+XHYW(s,(a+G(b,c,d)+Mj+ti))
    return a&0xffffffff
def HH(a,b,c,d,Mj,s,ti):
    a = b+XHYW(s,(a+H(b,c,d)+Mj+ti))
    return a&0xffffffff
def II(a,b,c,d,Mj,s,ti):
    a = b+XHYW(s,(a+I(b,c,d)+Mj+ti))
    return a&0xffffffff
def XHYW(n,m):#循环移位
    #print bin(m)
    #print ((m<<n)&0xffffffff)|((m&0xffffffff)>>(32-n))
    return ((m<<n)&0xffffffff)|((m&0xffffffff)>>(32-n))
def extend(s):##小端拓展
    bitlen = len(s)*8
    # 将字符串长度以64位二进制保存
    hexlen1 = hex(bitlen)[2:].zfill(16)
    hexlen = hexlen1.decode('hex')[::-1].encode('hex')##将字符串反转,hex编码
    extlen = [chr(int(hexlen[i:i+2],16)) for i in range(0, 16, 2)]
    mod = bitlen%512
    if(mod>=448):#如果余数大于448,重新添加一组0。
        padding = chr(0x80)+chr(0)*(55-mod/8+64)
    else:
        padding = chr(0x80)+chr(0)*(55-mod/8)
    # for i in range(0,len(s+padding+''.join(extlen))):
    #     print ord((s+padding+''.join(extlen))[i])
    #print ''.join(extlen)
    return s+padding+''.join(extlen)
def Froud(i,s,M):#i=0
    global A,B,C,D,T
    for t in range(0,4):
        #print s[i+1]
        A = FF(A,B,C,D,M[i],s[i%4],T[i+1])
        D = FF(D,A,B,C,M[(i+1)%16],s[(i+1)%4],T[i+2])
        C = FF(C,D,A,B,M[(i+2)%16],s[(i+2)%4],T[i+3])
        B = FF(B,C,D,A,M[(i+3)%16],s[(i+3)%4],T[i+4])
        i = i+4
def Groud(i,j,s,M):#i=16
    global A,B,C,D, T
    for t in range(0,4):
        #print j%16
        A = GG(A,B,C,D,M[(j)%16],s[0],T[i+1])
        D = GG(D,A,B,C,M[(j+5)%16],s[1],T[i+2])
        C = GG(C,D,A,B,M[(j+10)%16],s[2],T[i+3])
        B = GG(B,C,D,A,M[(j+15)%16],s[3],T[i+4])
        i = i+4
        j = j + 20
def Hroud(i,j,s,M):#i=32,j=5
    global A,B,C,D, T
    for t in range(0,4):
        #print (j)%16
        A = HH(A,B,C,D,M[(j)%16],s[0],T[i+1])
        D = HH(D,A,B,C,M[(j+3)%16],s[1],T[i+2])
        C = HH(C,D,A,B,M[(j+6)%16],s[2],T[i+3])
        B = HH(B,C,D,A,M[(j+9)%16],s[3],T[i+4])
        i = i+4
        j = j+12
def Iroud(i,j,s,M):#i=48,j=0
    global A,B,C,D,T
    for t in range(0,4):
        #print (j)%16
        A = II(A,B,C,D,M[(j)%16],s[0],T[i+1])
        D = II(D,A,B,C,M[(j+7)%16],s[1],T[i+2])
        C = II(C,D,A,B,M[(j+14)%16],s[2],T[i+3])
        B = II(B,C,D,A,M[(j+21)%16],s[3],T[i+4])
        i = i+4
        j = j+28
def encrypt(s):
    s = extend(s)
    global A,B,C,D
    #print s.__len__()
    for i in range(0,len(s),64):#每64个字节分一组
        M = []
        AA, BB, CC, DD = A, B, C, D
        for j in range(0,64,4):#再将一组分为16个小组,每一小组4个字节
            #print s[i + j:i + j + 4]
            M.append(struct.unpack("i",s[i+j:i+j+4])[0])
        #print M
        Froud(0,[7,12,17,22],M)
       # print A, B, C, D
        Groud(16,1,[5,9,14,20],M)
        #print A, B, C, D
        Hroud(32,5,[4,11,16,23],M)
        #print A, B, C, D
        Iroud(48,0,[6,10,15,21],M)
        #print A, B, C, D
        A,B,C,D = (A+AA)&0xffffffff,(B+BB)&0xffffffff,(C+CC)&0xffffffff,(D+DD)&0xffffffff
        #print A, B, C, D
        #
    #print hex(A)
    result = ""
    for i  in (A,B,C,D):
        result = result+ hex(i)[2:].zfill(8).decode('hex')[::-1].encode('hex')
    return result
if __name__ == '__main__':
    test1 = raw_input("请输入您要加密的md5值")
    mtest1 = encrypt(test1)
    mtest2 = hashlib.md5(test1).hexdigest()
    print "使用本函数进行加密的值为:"+ mtest1
    print "使用hashlib系统自带的函数加密的值为:"+mtest2
    if(mtest1 == mtest2):
        print test1+"MD5值是:"+mtest1+",验证成功";

计算雅克比符号的两种方法

第一种 常规方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#coding:utf-8
sushu  = [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97]
def Gettwo(a,p):
    t = pow(a,(p-1)/2)
    if t%p ==0:
        return 0
    elif t%p ==1:
        return 1
    else :
        return -1
def Getsim(a):
    s = []
    for i in sushu:
        while(1):
            if a%i==0:
                s.append(i)
                a = a/i
            else:
                break
    return s
def Jacbi(a,b):
    list = Getsim(b)
    final = 1
    for i in list:
        final = final*Gettwo(a,i)
    return final
if __name__ == '__main__':
        print Jacbi(20964,1987)

第二种 利用性质

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
#coding:utf-8
"""
author:xnianq
date:2017/04/05
"""
def pro1(a,b):
    a = a%b
    return a,b
def pro2(a,b):
    if b%8==1 or b%8 == 7:
        return 1
    if b%8==3 or b%8 == 5:
        return -1
def pro3(a,b):
    i = 0
    while 1:
        if a%2 ==0:
            a = a/2
            i = i+1
        else:
            break
    return a,i
def pro4(a,b):
    if a%4==3 and b%4==3:
        return False
    else:
        return True
def Jacobi(a,b):
    f = 1
    while 1 :
        if a==1:
            break
        elif(a>b):
            a,b = pro1(a,b)
            a,i = pro3(a,b)
            f = f*pow(pro2(2,b),i)
        elif (a<b):
            if pro4(a,b):
                a,b = b,a
                a,b = pro1(a,b)
                a,i = pro3(a,b)
                f = f*pow(pro2(2,b),i)
            else:
                a,b = b,a
                f = f*-1
                a,b = pro1(a,b)
                a,i =pro3(a,b)
                f = f*pow(pro2(2,b),i)
    return f
if __name__ == '__main__':
    print Jacobi(20964,1987)

RSA加密解密

需要借助米勒拉丁算法生成大素数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
#coding:utf-8
"""
author:xnianq
date:2017/04/05
"""
from math import sqrt
from Miller_Rabin import *
def GetChr(num):
    last = num%pow(26,2)%26
    medium = (num-last)%pow(26,2)/26
    first = (num-last-medium*26)/pow(26,2)
    return chr(ord('A')+first)+chr(ord('A')+medium)+chr(ord('A')+last)
def GetNum(cipher):
    #print cipher
    num = 0
    num = num+(ord(cipher[0])-ord('A'))*pow(26,2)
    num = num + (ord(cipher[1])-ord('A'))*26
    num = num+ord(cipher[2])-ord('A')
    return num
def gcd(a,b):#欧几里徳求最大公约数
    if b ==0:
        return a
    else:
        return gcd(b,a%b)
def ex_gcd(a,b,x,y):#欧几里徳拓展算法求逆元
    if b==0:
        return a,1,0
    r,t,y = ex_gcd(b,a%b,x,y)
    x,y = y,t-a/b*y
    return r,x,y
def Getpq(n):#破解n时需要调用
    for i in range(2,int(sqrt(n))):
        if n%i ==0:
            return i,n/i
def Getfy(n):#求fy,破解时调用.
    p,q = Getpq(n);
    fy = (p-1)*(q-1)
    return fy
def Geta(b,fy):#取逆元
    return  (ex_gcd(b,fy,1,0)[1]+fy)%fy
def Encrypt(plaintext,b,n):
    cipher = quickPowMod(plaintext,b,n)
    return cipher
def Decrypt(m,a,n):
    plaintext = quickPowMod(m,a,n)
    return plaintext
def Getcipher():
    f = open('cipher.txt','r')
    cipher = []
    text = f.read()
    text = text.replace("\n","").split(" ")
    for i in range(0,len(text)):
        cipher.append(int(text[i]))
    return cipher
if __name__ == '__main__':
    # cipher = Getcipher()
    # plaintext = ""
    # fy = Getfy(18923)
    # a = Geta(1261,fy)
    # for i in range(0,len(cipher)):
    #     plaintext = plaintext + GetChr(Decrypt(cipher[i],a,18923))
    # print plaintext
    p = getBigPrime(random.randrange(10,30,2)**random.randint(150,160) + 1)#生成大素数
    q = getBigPrime(random.randrange(10,30,2)**random.randint(150,160) + 1)
    n = p*q
    fy = (p-1)*(q-1)
    b = random.randrange(100,1000,2)+1#一定是奇数
    while 1:
        if gcd(fy,b)==1:
            break
        b = b+2
    a = Geta(b,fy)
    print "欢迎使用xnianq'RSA加密解密，您的公钥是:b ="+str(b)+",\nn="+str(n)+"，\n私钥是：a ="+str(a)+",\np:"+str(p)+",\nq:"+str(q)+".\n"
    cipher = raw_input("请输入要加密的密文")
    shengyu = 3-len(cipher)%3
    if len(cipher)%3!=0:
        cipher = cipher+"A"*(3-len(cipher)%3)
    plaintext = []
    Ci  = []
    for i in range(0,len(cipher),3):
        plaintext.append(GetNum(cipher[i:i+3]))
    print plaintext
    mingwen = ""
    for i in range(0,len(plaintext)):
        mingwen = mingwen+str(plaintext[i])
    print "您输入的字符串转换成数字为："+mingwen
    miwen = ""
    for i in range(0,len(plaintext)):
        Ci.append(Encrypt(plaintext[i],b,n))
        miwen = miwen + str(Encrypt(plaintext[i],b,n))
    for i in range(0,len(Ci)):
        print Ci[i]
    print "您加密的密文为："+miwen
    Pl = []
    for i in range(0,len(Ci)):
        Pl.append(Decrypt(Ci[i],a,n))
    mingwen = ""
    for i in range(0,len(Pl)):
        mingwen = mingwen+ GetChr(Pl[i])
        #mingwen = mingwen+str(Pl[i])
    ##print en
    print "您解密出的密文为:" +mingwen[:-1*shengyu]
    #print de

米勒拉丁算法以及快速幂取模算法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
#coding:utf-8
import random
def Miller_Rabin(n):
    r, d = 0, n - 1
    while d & 1 == 0:
        r += 1
        d >>= 1
    for k in range(5):
        a = random.randint(2, n - 2)
        x = quickPowMod(a, d, n)
        if x == 1 or x + 1 == n:
            continue
        for i in range(r - 1):
            x = x * x % n
            if x == 1:
                return False
            if x + 1 == n:
                break
        if x + 1 != n:
            return False
    return True
##快速幂取模 pow(a,b) mod c = pow((a mod c),b) moc c
def quickPowMod(a, n, m):
  ans = 1
  while n:
    if n & 1:
      ans = ans * a % m
    a = a * a % m
    n >>= 1
  return ans # a^n %
# 米勒-罗宾算法求大质数
def getBigPrime(n):
    while 1:
        if Miller_Rabin(n):
            return n
        n = n+2

RSA winner低指数破解：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#coding:utf-8
from sympy import *
def Ojld(b,n):
    list = []
    while 1:
        if b%n ==0:
            list.append(b)
            break
        else:
            list.append(b/n)
            t = b
            b = n
            n = t%n
    return list
def Wiener(b,n):
    list = Ojld(b,n)
    c = []
    #print list
    c.append(1)
    c.append(list[0])
    d = []
    d.append(0)
    d.append(1)
    for j in range(1,len(list)):
        f = list[j]*c[j]+c[j-1]
        g = list[j]*d[j]+d[j-1]
        #print g,b,f
        c.append(f)
        d.append(g)
        if (g*b-1)%f ==0:
            n1 = (g*b-1)/f
            x = symbols("x")
            solves =  solve(Eq(x**2-(n-n1+1)*x+n,0),x)
            if int(solves[1])==solves[1]:
                return n1,solves[0],solves[1]
if __name__ == '__main__':
    print Wiener(77537081,317940011)

本文出自”xnianq Blog”：www.xnianq.cn/2017/02/22/密码学初涉/

赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true