❶ python怎麼對用戶密碼進行MD5加密，或者是單向加密
importhashlib
password_r='abcd'
password_md5=hashlib.md5(password_r).hexdigest()
md5對password_r加密
❷ Python中的如何給一個字元串加密
import rsa rsaPublickey = int(pubkey, 16) key = rsa.PublicKey(rsaPublickey, 65537) #創建公鑰 message = str(servertime) + '\t' + str(nonce) + '\n' + str(password) #拼接明文js加密文件中得到 passwd = rsa.encrypt(message, key) #加密 passwd = binascii.b2a_hex(passwd) #將加密信息轉換為16進制。 return passwd
❸ 12:字元串加密、解密
編碼： 將計算機中的字元串按照一定的順序表示成二進制數據的過程
各國字元編碼都不一樣：
1、計算機-> 表示[英文字母、數字、部分特殊符號]-> ascii編碼 [0~256]
2、萬國碼，統一字元編碼[號稱可以統一全球范圍內任何語言的表示方式]
任何語言中的任何數據，都可以使用一個字元來表示 unicode編碼
3、中國有GB2312-> GBK -> GB18030
4、數據傳輸編碼：unicode transfer format 8 bit [UTF-8]
python中的編碼解碼：
要命的規則：字元串的編碼解碼，一直都是任何語言中一個難點和重點
任何字元串->都是由位元組組成的！
python3中：字元：(str)；位元組(bytes)
字元->位元組：encode 編碼：將一個字元串編碼成計算機可以操作的二進制數據
位元組->字元：decode 解碼：將一個二進制數據按照指定的編碼~解碼成自然數據
什麼是加密： 將一個明文數據，按照指定的演算法，運算得到一個其他的可以隱藏真實信息的密文數據，這個過程稱為加密；處理的演算法稱為加密演算法；用到的關鍵數據稱為密鑰
什麼是解密： 按照指定的演算法和關鍵數據，將一個密文數據進行逆向運算得到正確的明文數據的過程成為解密操作
（1）、單向加密演算法：只能加密，不能解密的演算法
如：用戶賬號密碼(單向加密)存儲，此時任何人都不能查看該用戶的明文密碼
流程->用戶輸入明文密碼->加密->和存儲的密文密碼進行比較->相等-成功
單向散列加密演算法-> MD5加密
單項哈希加密演算法-> SHAX加密
（2）、雙向加密演算法：可以加密，加密的數據可以解密得到明文數據
使用在更多的場景；數據進行加密傳輸->目標地址->解密得到明文數據進行處理
對稱加密：加密和解密使用相同的秘鑰；
非對稱加密：加密和解密使用不同的秘鑰；如HTTPS傳輸數據
hashlib主要提供字元加密功能，將md5和sha模塊整合到了一起，支持md5,sha1, sha224, sha256, sha384, sha512等演算法
注意： hashlib 加密啊的字元串類型為二進制編碼，直接加密字元串會報如下錯誤：
有兩種方式可以將字元串轉化為二進制數據
❹ 如何加密PYTHON程序
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
alp=' '
def num2alp(c):
a = alp[c]
return(a)
def alp2num(d):
if d != ' ':
return((ord(d)-97)%37)
else:
return 36
def envVigenere(key,plaintext):
m = len(plaintext)
n = len(key)
etext = ""
for i in range(m):
p = plaintext[i]
k = key[i%n]
num1 = alp2num(p)
num2 = alp2num(k)
num3 = (num1+num2)%37
f = num2alp(num3)
etext = etext + f
return(etext)
print(envVigenere('lemon','attack at dawn'))
❺ python字元串凱撒密碼加密編寫注意事項
Python 字元串凱撒密碼加密編寫的注意事項如下：塌缺
總之，在編寫 Python 字元串凱撒密碼加密程序時，需要考慮到各種情況，並使用合適的數據類型和函數進行處理。
確定加密規則：凱撒密碼加密是通過將明文中的每個字元按照一定規則進行移位來實現的。在編寫程序之前，需要確定移位的規則，例如移位的位數、移位的方向等。
處理邊界情況：在編寫程序時，需要考慮一些邊界情況，例如輸入為空字元串、移位位數為0等情況。需要對這些情況進行特殊處理，以避免程序出現異常。
處理大小寫字母：在凱撒磨孝密碼加密中，大小寫字母需要分別處理。可以通過將所有字母轉換為小寫字母來簡化處理。
使用 ASCII 碼進行移位：在凱撒密碼加密中，可以使用 ASCII 碼進行字元的移位。可以通過 ord() 函數將字元轉換為 ASCII 碼，通過 chr() 函數將 ASCII 碼轉換為字元。
使用循環結瞎衫稿構進行遍歷：在編寫程序時，需要使用循環結構對字元串中的每個字元進行遍歷，並進行移位操作。
輸出加密結果：在加密完成後，需要將加密結果輸出。可以使用 print() 函數將加密後的字元串輸出到控制台或者文件中。
❻ 求python中的愷撒密碼的加密，解密，以及破解的程序
凱撒密碼作為一種最為古老的對稱加密體制，在古羅馬的時候都已經很流行，他的基本思想是：通過把字母移動一定的位數來實現加密和解密。明文中的所有字母都在字母表上向後（或向前）按照一個固定數目進行偏移後被替換成密文。例如，當偏移量是3的時候，所有的字母A將被替換成D，B變成E，以此類推X將變成A，Y變成B，Z變成C。由此可見，位數就是凱撒密碼加密和解密的密鑰。
如下代碼是以偏移量為13展開計算的。123
源代碼如下：
sr1="abcdefghijklmnopqrstuvwxyz"sr2=sr1.upper()
sr=sr1+sr1+sr2+sr2
st="The Zen of Python"sResult=""for j in st: if j==" ":
sResult = sResult +" "
continue
i=sr.find(j) if(i>-1):
sResult=sResult+sr[i+13]print sResult12345678910111213
運行結果為：
Gur Mra bs Clguba
❼ python實現DES加密解密方法實例詳解
本文實例講述了python實現DES加密解密方法。分享給大念虛洞家供大家參考。具體分析如下：
實仔枯現功能：加譽薯密中文等字元串
密鑰與明文可以不等長
這里只貼代碼，加密過程可以自己網路，此處python代碼沒有優化
1. desstruct.py DES加密中要使用的結構體
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
ip= (58, 50, 42, 34, 26, 18, 10, 2,
60, 52, 44, 36, 28, 20, 12, 4,
62, 54, 46, 38, 30, 22, 14, 6,
64, 56, 48, 40, 32, 24, 16, 8,
57, 49, 41, 33, 25, 17, 9 , 1,
59, 51, 43, 35, 27, 19, 11, 3,
61, 53, 45, 37, 29, 21, 13, 5,
63, 55, 47, 39, 31, 23, 15, 7)
ip_1=(40, 8, 48, 16, 56, 24, 64, 32,
39, 7, 47, 15, 55, 23, 63, 31,
38, 6, 46, 14, 54, 22, 62, 30,
37, 5, 45, 13, 53, 21, 61, 29,
36, 4, 44, 12, 52, 20, 60, 28,
35, 3, 43, 11, 51, 19, 59, 27,
34, 2, 42, 10, 50, 18, 58, 26,
33, 1, 41, 9, 49, 17, 57, 25)
e =(32, 1, 2, 3, 4, 5, 4, 5,
6, 7, 8, 9, 8, 9, 10, 11,
12,13, 12, 13, 14, 15, 16, 17,
16,17, 18, 19, 20, 21, 20, 21,
22, 23, 24, 25,24, 25, 26, 27,
28, 29,28, 29, 30, 31, 32, 1)
p=(16, 7, 20, 21, 29, 12, 28, 17,
1, 15, 23, 26, 5, 18, 31, 10,
2, 8, 24, 14, 32, 27, 3, 9,
19, 13, 30, 6, 22, 11, 4, 25)
s=[ [[14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7],
[0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8],
[4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0],
[15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13]],
[[15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10],
[3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5],
[0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15],
[13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9]],
[[10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8],
[13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1],
[13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7],
[1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12]],
[[7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15],
[13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14,9],
[10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4],
[3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14]],
[[2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9],
[14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6],
[4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14],
[11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3]],
[[12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11],
[10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8],
[9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6],
[4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13]],
[[4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1],
[13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6],
[1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2],
[6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12]],
[[13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7],
[1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2],
[7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8],
[2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11]]]
pc1=(57, 49, 41, 33, 25, 17, 9,
1, 58, 50, 42, 34, 26, 18,
10, 2, 59, 51, 43, 35, 27,
19, 11, 3, 60, 52, 44, 36,
63, 55, 47, 39, 31, 33, 15,
7, 62, 54, 46, 38, 30, 22,
14, 6, 61, 53, 45, 37, 29,
21, 13, 5, 28, 20, 12, 4);
pc2= (14, 17, 11, 24, 1, 5, 3, 28,
15, 6, 21, 10, 23, 19, 12, 4,
26, 8, 16, 7, 27, 20, 13, 2,
41, 52, 31, 37, 47, 55, 30, 40,
51, 45, 33, 48, 44, 49, 39, 56,
34, 53, 46, 42, 50, 36, 29, 32)
d = ( 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1)
2. des.py 加密文件
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
#_*_ coding:utf-8 _*_
#!/usr/bin/env python
#Filename:des.py
from desstruct import *
import re
__all__=[desencode]
class DES():
des 加密
def __init__(self):
pass
#加密
def code(self,from_code,key,code_len,key_len):
output=
trun_len=0
#將密文和密鑰轉換為二進制
code_string=self._functionCharToA(from_code,code_len)
code_key=self._functionCharToA(key,key_len)
#如果密鑰長度不是16的整數倍則以增加0的方式變為16的整數倍
if code_len%16!=0:
real_len=(code_len/16)*16+16
else:
real_len=code_len
if key_len%16!=0:
key_len=(key_len/16)*16+16
key_len*=4
#每個16進制佔4位
trun_len=4*real_len
#對每64位進行一次加密
for i in range(0,trun_len,64):
run_code=code_string[i:i+64]
l=i%key_len
run_key=code_key[l:l+64]
#64位明文、密鑰初始置換
run_code= self._codefirstchange(run_code)
run_key= self._keyfirstchange(run_key)
#16次迭代
for j in range(16):
#取出明文左右32位
code_r=run_code[32:64]
code_l=run_code[0:32]
#64左右交換
run_code=code_r
#右邊32位擴展置換
code_r= self._functionE(code_r)
#獲取本輪子密鑰
key_l=run_key[0:28]
key_r=run_key[28:56]
key_l=key_l[d[j]:28]+key_l[0:d[j]]
key_r=key_r[d[j]:28]+key_r[0:d[j]]
run_key=key_l+key_r
key_y= self._functionKeySecondChange(run_key)
#異或
code_r= self._codeyihuo(code_r,key_y)
#S盒代替/選擇
code_r= self._functionS(code_r)
#P轉換
code_r= self._functionP(code_r)
#異或
code_r= self._codeyihuo(code_l,code_r)
run_code+=code_r
#32互換
code_r=run_code[32:64]
code_l=run_code[0:32]
run_code=code_r+code_l
#將二進制轉換為16進制、逆初始置換
output+=self._functionCodeChange(run_code)
return output
#異或
def _codeyihuo(self,code,key):
code_len=len(key)
return_list=
for i in range(code_len):
if code[i]==key[i]:
return_list+=0
else:
return_list+=1
return return_list
#密文或明文初始置換
def _codefirstchange(self,code):
changed_code=
for i in range(64):
changed_code+=code[ip[i]-1]
return changed_code
#密鑰初始置換
def _keyfirstchange (self,key):
changed_key=
for i in range(56):
changed_key+=key[pc1[i]-1]
return changed_key
#逆初始置換
def _functionCodeChange(self, code):
lens=len(code)/4
return_list=
for i in range(lens):
list=
for j in range(4):
list+=code[ip_1[i*4+j]-1]
return_list+=%x %int(list,2)
return return_list
#擴展置換
def _functionE(self,code):
return_list=
for i in range(48):
return_list+=code[e[i]-1]
return return_list
#置換P
def _functionP(self,code):
return_list=
for i in range(32):
return_list+=code[p[i]-1]
return return_list
#S盒代替選擇置換
def _functionS(self, key):
return_list=
for i in range(8):
row=int( str(key[i*6])+str(key[i*6+5]),2)
raw=int(str( key[i*6+1])+str(key[i*6+2])+str(key[i*6+3])+str(key[i*6+4]),2)
return_list+=self._functionTos(s[i][row][raw],4)
return return_list
#密鑰置換選擇2
def _functionKeySecondChange(self,key):
return_list=
for i in range(48):
return_list+=key[pc2[i]-1]
return return_list
#將十六進制轉換為二進制字元串
def _functionCharToA(self,code,lens):
return_code=
lens=lens%16
for key in code:
code_ord=int(key,16)
return_code+=self._functionTos(code_ord,4)
if lens!=0:
return_code+=0*(16-lens)*4
return return_code
#二進制轉換
def _functionTos(self,o,lens):
return_code=
for i in range(lens):
return_code=str(oi 1)+return_code
return return_code
#將unicode字元轉換為16進制
def tohex(string):
return_string=
for i in string:
return_string+=%02x%ord(i)
return return_string
def tounicode(string):
return_string=
string_len=len(string)
for i in range(0,string_len,2):
return_string+=chr(int(string[i:i+2],16))
return return_string
#入口函數
def desencode(from_code,key):
#轉換為16進制
from_code=tohex(from_code)
key=tohex(key)
des=DES()
key_len=len(key)
string_len=len(from_code)
if string_len1 or key_len1:
print error input
return False
key_code= des.code(from_code,key,string_len,key_len)
return key_code
#測試
if __name__ == __main__:
print desencode(我是12345678劉就是我abcdwfd,0f1571c947劉)
#返回密文為:
3. 解密文件
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
#_*_coding:utf-8_*_
#!/usr/bin/env python
#Filename:des.py
from dess