python寫程序加密

㈠ python寫的程序怎樣加密

對Python加密時可能會有兩種形式，一種是對Python轉成的exe進行保護，另一種是直接對.py或者.pyc文件進行保護，下面將列舉兩種形式的保護流程。

1、對python轉exe加殼

下載最新版VirboxProtector加殼工具，使用加殼工具直接對demo.exe進行加殼操作

2、對.py/.pyc加密

第一步，使用加殼工具對python安裝目錄下的python.exe進行加殼，將python.exe拖入到加殼工具VirboxProtector中，配置後直接點擊加殼。

第二步，對.py/.pyc進行加密，使用DSProtector對.py/.pyc進行保護。

安全技術：

l虛擬機外殼：精銳5的外殼保護工具，創新性的引入了預分析和自動優化引擎，有效的解決了虛擬化保護代碼時的安全性和性能平衡問題。

l碎片代碼執行：利用自身成熟的外殼中的代碼提取技術，抽取大量、大段代碼，加密混淆後在安全環境中執行，最大程度上減少加密鎖底層技術和功能的依賴，同時大量大段地移植又保證了更高的安全性。

lVirbox加密編譯引擎：集編譯、混淆等安全功能於一身，由於在編譯階段介入，可優化空間是普遍虛擬化技術無法比擬的，對代碼、變數的混淆程度也有了根本的提升。

l反黑引擎：內置R0級核心態反黑引擎，基於黑客行為特徵 的（反黑資料庫）反制手段。精準打擊調試、注入、內存修改等黑客行為，由被動挨打到主動防護。

加密效果：

加密之前

以pyinstall 的打包方式為例，使用pyinstxtractor.py文件對log_322.exe進行反編譯，執行後會生成log_322.exe_extracted文件夾，文件夾內會生成pyc文件。

成功之後會在同目錄下生成一個文件夾

㈡ 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

㈢ python字元串凱撒密碼加密編寫注意事項

• Python 字元串凱撒密碼加密編寫的注意事項如下：塌缺

  總之，在編寫 Python 字元串凱撒密碼加密程序時，需要考慮到各種情況，並使用合適的數據類型和函數進行處理。

• 確定加密規則：凱撒密碼加密是通過將明文中的每個字元按照一定規則進行移位來實現的。在編寫程序之前，需要確定移位的規則，例如移位的位數、移位的方向等。

• 處理邊界情況：在編寫程序時，需要考慮一些邊界情況，例如輸入為空字元串、移位位數為0等情況。需要對這些情況進行特殊處理，以避免程序出現異常。

• 處理大小寫字母：在凱撒磨孝密碼加密中，大小寫字母需要分別處理。可以通過將所有字母轉換為小寫字母來簡化處理。

• 使用 ASCII 碼進行移位：在凱撒密碼加密中，可以使用 ASCII 碼進行字元的移位。可以通過 ord() 函數將字元轉換為 ASCII 碼，通過 chr() 函數將 ASCII 碼轉換為字元。

• 使用循環結瞎衫稿構進行遍歷：在編寫程序時，需要使用循環結構對字元串中的每個字元進行遍歷，並進行移位操作。

• 輸出加密結果：在加密完成後，需要將加密結果輸出。可以使用 print() 函數將加密後的字元串輸出到控制台或者文件中。

㈣ Python 加密程序

#coding=utf-8
defencode_key_text(key,text):
alp=''
num_key=[alp.find(i)foriinkey]
num_text=[alp.find(i)foriintext]

iflen(num_key)<len(num_text):
num_long,num_short=num_text,num_key
else:
num_long,num_short=num_key,num_text

num_encode=[(num_short[i%len(num_short)]+num_long[i])%(len(alp))foriinxrange(len(num_long))]
printnum_encode
return''.join([alp[i]foriinnum_encode])

if__name__=="__main__":
key='lemon'
text='attackatdawn'
printencode_key_text(key,text)

當練手了，感興趣可以關注我的python課程

㈤ 怎樣對 Python 源碼加密

發布python源碼編譯生成的pyc文件就好了
python -m py_compile src.py
其實加密很簡單的,修改Python虛擬機的代碼,針對編譯出pyc的部分修改下虛擬碼,或者對調幾個.別人死都解不出來的.這個方法是來自於(雲風大俠的書<我的編程感悟>中的)
缺點也很顯而易見,執行時必須使用自己的修改的Python虛擬機.

㈥ python 寫異或加密

from random import seed,randint

str_in=input('請輸入一個字元串：')
you_seed=input('請輸入密碼：')
you_seed=int(you_seed)

#lock
def my_lock(lock_str,lock_seed):
seed(lock_seed)
li_out=[]
for i in lock_str:
li_out.append(chr(ord(i)^randint(0,65535)))
return ''.join(li_out)
my_lock_str=my_lock(str_in,you_seed)
print('原字元串：',str_in)
print('加密字元串：',my_lock_str)
print('還原後字元串：',my_lock(my_lock_str,you_seed))
input()
#python 3.4

㈦ Python程序加密打包

步驟：
1、使用此文程序編譯激喚首python源程序為pyd
鏈接： https://www.jianshu.com/p/4465cf9283b6
2、編寫入口py文件，調用pyd模塊
注意點：
1、由於pyinstaller不會導入pyd程序依賴包，所以需要將pyd程序依賴包在入口py文件中導入一次，避免打包exe時pyd無法使用
2、打包exe後，路徑有所變化，pyd中路徑需使用絕對明數路徑
3、pyd文件不要寫入口調用，if main等，在入口py文件中導包及調用相關函數

優點：脫離python環境，包依賴
缺點：文件較大
步驟：
1、將入口py文件打包為exe可執行程序，會自動導入pyd文件並進行封裝
注意點：
1、打包exe後，cmd下運行程序，看是否有錯誤輸出，按提示解決相應鏈岩問題即可

㈧ python封裝成exe如何加密

可以直接用加密軟體加密。據了解加密軟體可以加密所有類型文件的，可以對文件進行透明加密，在內部環境文件是可以正常打開的，脫離這個環境則打不開或亂碼，可以禁止截屏、拷貝、復制、列印、修改等。文件外發需授權解密，未授權解密無論以任何形式發出都是無法正常打開的，還可設置文件外發的瀏覽次數和打開時間。在不影響日常使用的情況下保障文件安全。

㈨ Python加密程序

alp=''
defnum2alp(c):
a=alp[c]
return(a)

defalp2num(d):
ifd!='':
return((ord(d)-97)%37)
else:
return36


defenvVigenere(key,plaintext):
m=len(plaintext)
n=len(key)
etext=""
foriinrange(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','attackatdawn'))

試試這個，我發現你的問題有兩個：

1. alp2num
   函數有問題，應該再進行下mod37，並且應當對空格做特殊處理

2. key沒有使用正確使用

   
   

㈩ 為什麼python不可加密

可以加密。 python 代碼加密甚至可以做到比用匯編手寫混淆，用 c 手寫混淆更加難以解密。具體做法略復雜僅簡單說個過程。

第一級別是源碼級別的混淆，用 ast 和 astor ，再自己手寫一個混淆器，三五百行的腳本直接混淆到幾萬行，整個文件面目全非，基本可以做到就算直接放腳本給你拿去逆，除非你再寫出來一個逆向前面的混淆演算法的腳本來逆（在熟悉 python 的情況下需要花幾天，且不說需要了解程序構造原理），手動去調試腳本幾乎達到不可行的地步（話費時間再乘以 2 ）

第二級別是個性化定製 pyinstaller ， pyinstaller 會打包所有需要的庫，將腳本也包含進打包的 exe ，但是， pyinstaller 有一個 stub ，相當於一個啟動器，需要由這個啟動器來解密腳本和導入模塊，外面有直接導出腳本的工具，但是那是針對 pyinstaller 自帶的啟動器做的，完全可以自己修改這個啟動器再編譯，這樣逆向者就必須手動調試找到 main 模塊。配合第一級別加密，呵呵，中國就算是最頂尖的逆向專家也要花個一兩周，來破解我們的程序邏輯了，就我所知，實際上國內對於 py 程序的逆向研究不多。

第三級別是再上一層，將 py 翻譯為 c 再直接編譯 c 為 dll ，配合第一階段先混淆再轉 c 再編譯，在第一步混淆之後，會產生非常多垃圾（中間層）函數，這些中間層函數在 c 這里會和 py 解釋器互相調用，腳本和二進制之間交叉運行，本身混淆之後的源碼就極難復原，再混合這一層，想逆向，難。

第四級別是利用 py 的動態特性，絕大多數逆向者都是 c ，匯編出身，對於程序的第一直覺就是，程序就是一條一條的指令，後一條指令必然在這一條指令後面，然而， py 的動態特性可以讓代碼邏輯根本就不在程序裡面，這一點不想多講，涉及到我一個項目里的深度加密。

第五級別，數學做牆。了解過比特幣原理的知道要想用挖比特幣就得提供大量算力去幫網路計算 hash ，這個成為 pow ，那麼既然已經採用 py 了估計已經不考慮太多 cpu 利用率了，那就可以採用 pow （還有其他的手段）確保程序運行時擁有大量算力，如果程序被單步調試，呵呵，一秒鍾你也跑不出來幾個 hash 直接拉黑這個 ip （這個說法可能比較難理解，因為我第四層的加密沒有說明，不過意思就是拒絕執行就對了）