python破解教程（WingIDE 6破解教程哪里有）

：暂无数据 2026-10-16 21:00:06 ：0

今天给各位分享WingIDE 6破解教程哪里有的知识，其中也会对WingIDE 6破解教程哪里有进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录

WingIDE 6破解教程哪里有
Wing IDE Pro 6 for Mac(Python开发工具)哪里有破解版
python实现DES加密解密方法实例详解

WingIDE 6破解教程哪里有

Wing IDE Pro for Mac是一款运行在Mac平台上的Python开发工具，是专为专业程序员设计的全功能Python IDE，WingIDE 6 破解版包括强大的器，代码智能，重构，调试，搜索，单元测试，项目管理和版本控制功能，使交互式Python开发快速，准确，有趣，被广泛应用于桌面界面开发

WingIDE mac特别版安装教程

点击下载：WingIDE mac特别版

1、WingIDE mac破解版镜像包下载完成后打开，将左侧的【WingIDE】拖到右边的应用程序中进行安装。

2、将WingIDE mac破解版镜像包中的WingIDE 6注册机【kg.pyc】拖到桌面备用

3、打开安装在应用程序中的Wing IDE ，点击【accept】。

4、弹出Wing IDE激活界面，我们勾选【activate a purchase license....】，然后将这个界面放在一边，不要关闭。

5、打开你的终端。

6、在终端输入python+空格。然后将WingIDE 6 注册机【kg.pyc】拖到终端

7、按下回车键，此时会生成WingIDE 6 激活码。

8、将WingIDE 6 激活码填入到刚才的激活界面中。点击【continue】。

9、接着激活界面就会生成另一个激活码，我们将这个激活码复制终端中的request code位置并按下回车。

10、然后将这个Wing IDE 6注册码复制到刚刚的激活界面中。再点击【continue】。

Wing IDE Pro 6 for Mac(Python开发工具)哪里有破解版

WingIDE Pro 6 for Mac 破解版安装教程

WingIDE Pro 6 for Mac 破解版镜像包下载完成后打开，拖动软件【WingIDE】到右侧应用程序进行安装。

点击下载WingIDE Pro 6 for Mac 破解版

应用程序中打开WingIDE，点击【accept】

选择【Activate a purchased license】，先放一边待用。

打开终端，输入【python 】

将镜像包中的WingIDE破解工具【kg.pyc】拖到桌面。

把桌面上的WingIDE破解工具拖进终端。

WingIDE破解工具拖进去之后按回车.

此时终端会生成一串WingIDE注册码。

把WingIDE注册码复制到软件注册页面。

WingIDE注册码输入之后请点击【continue】

把WingIDE软件中生成的request code复制到终端中。

request code输入之后在终端中回车。

终端会生成另一串WingIDE注册密钥。

选择第二个选项“or:activate manually...”，把WingIDE密钥复制到软件注册页面的正确位置中，再点击【Continue】

WingIDE for Mac提示您注册成功！！

本文实例讲述了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=,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
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__=
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
l=i%key_len
run_key=code_key
#64位明文、密钥初始置换
run_code= self._codefirstchange(run_code)
run_key= self._keyfirstchange(run_key)
#16次迭代
for j in range(16):
#取出明文左右32位
code_r=run_code
code_l=run_code
#64左右交换
run_code=code_r
#右边32位扩展置换
code_r= self._functionE(code_r)
#获取本轮子密钥
key_l=run_key
key_r=run_key
key_l=key_l
key_r=key_r
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
code_l=run_code
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:
return_list+=0
else:
return_list+=1
return return_list
#密文或明文初始置换
def _codefirstchange(self,code):
changed_code=
for i in range(64):
changed_code+=code
return changed_code
#密钥初始置换
def _keyfirstchange (self,key):
changed_key=
for i in range(56):
changed_key+=key
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
return_list+=%x %int(list,2)
return return_list
#扩展置换
def _functionE(self,code):
return_list=
for i in range(48):
return_list+=code
return return_list
#置换P
def _functionP(self,code):
return_list=
for i in range(32):
return_list+=code
return return_list
#S盒代替选择置换
def _functionS(self, key):
return_list=
for i in range(8):
row=int( str(key),2)
raw=int(str( key),2)
return_list+=self._functionTos(s,4)
return return_list
#密钥置换选择2
def _functionKeySecondChange(self,key):
return_list=
for i in range(48):
return_list+=key
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,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刘)
#返回密文为: 84148584371a6a1fe99e1da0ce1e34649b88ed15098e8aa4b8eb0bf24885c658
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