42 | 43 |
49 | 50 |
56 | 57 |
16 |
17 | ### 务必注意，密文关键字与明文关键字不可以重合，重合会出现很多问题
18 | #### 修改任何配置以后都要去保存配置，否则不生效
19 | #### 修改任何配置以后都要去保存配置，否则不生效
20 | #### 修改任何配置以后都要去保存配置，否则不生效
21 |
22 | 3. 有代码基础的建议使用接口进行加解密，可以自定义请求的内容，自由替换；工具本身自带加解密满足不了现在大部分应用的加解密需求。
23 |
24 | 4. 可以参考下列文章进行使用，配合加解密靶场 https://github.com/SwagXz/encrypt-labs
25 | - 加密对抗靶场enctypt-labs通关 https://flowus.cn/share/a1d890c2-f72b-4534-93cf-37db6dab5d21
26 | - 加密对抗靶场enctypt-labs通关 https://mp.weixin.qq.com/s/ZgD7qAQAsNlZgLtdZVCoFw
27 |
28 | ## 0x02.在`repeater`模块出现解密错误问题
29 |
30 | 进入`Burp Suite`的`logger`模块(或者`logger++`模块)查看当前请求的实际数据包(在`repeater`内的数据包被autoDecoder处理过，所以会提示解密失败)，进而分析是什么原因
31 |
32 | 1. 可能使用了工具自带的加解密，目前工具仅支持请求包、响应包同时加解密，一旦响应包为非加密的，就会报解密的错误，而使用接口加解密，就可以很好解决此问题
33 | 2. 使用了接口加解密，考虑代码编写问题，如函数的入参、函数的返回值等错误
34 |
35 |
36 |
37 | ## 0x03.接口脚本参数
38 |
39 | 参考示例见[flasktestheader.py](https://github.com/f0ng/autoDecoder/blob/main/flasktestheader.py)(处理请求头)与[flasktest.py](https://github.com/f0ng/autoDecoder/blob/main/flasktest.py)(DES加解密示例)脚本
40 |
41 | 参数解释如下：
42 |
43 | ### 函数入参为
44 |
45 | #### 1.`dataBody` 请求体，传参为flask框架传参，使用`body = request.form.get('dataBody')`获取，以下示例为整个flask对象[打印request.form]：
46 |
47 | 正常POST格式(application/x-www-form-urlencoded)
48 |
49 | `ImmutableMultiDict([('dataBody', 'a=1&b=2&c=3')])`(原始数据为a=1&b=2&c=3)
50 |
51 | JSON格式(application/json)
52 |
53 | `ImmutableMultiDict([('dataBody', '{"f0ng":"onlysecurity"}')])`(原始数据为{"f0ng":"onlysecurity"})等
54 |
55 |
56 |
57 | #### 2.`dataHeaders `请求头，使用`headers = request.form.get('dataHeaders')`获取，以下示例为整个flask对象[打印request.form]：
58 |
59 | ```java
60 | ImmutableMultiDict([('dataBody', '{"id":"1"}'), ('dataHeaders', 'POST /0828/testsql.php HTTP/1.1\r\nHost: 10.211.55.4\r\nUser-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:104.0) Gecko/20100101 Firefox/104.0\r\nAccept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8\r\nAccept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2\r\nAccept-Encoding: gzip, deflate\r\nConnection: keep-alive\r\nUpgrade-Insecure-Requests: 1\r\nContent-Type: application/x-www-form-urlencoded\r\nContent-Length: 39\r\n')])
61 | ```
62 |
63 | 原始数据为（数据包的换行分隔符为`\r\n`）
64 |
65 | ```
66 | POST /0828/testsql.php HTTP/1.1
67 | Host: 10.211.55.4
68 | User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:104.0) Gecko/20100101 Firefox/104.0
69 | Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8
70 | Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
71 | Accept-Encoding: gzip, deflate
72 | Connection: keep-alive
73 | Upgrade-Insecure-Requests: 1
74 | Content-Type: application/x-www-form-urlencoded
75 | Content-Length: 39
76 |
77 | {"id":"1"}
78 | ```
79 |
80 | 获取相应参数的代码如下（flask框架的读取参数方法，也可以用其他框架，这里仅以flask进行举例）：
81 |
82 | ```
83 | body = request.form.get('dataBody') # 获取 post 参数 必需
84 | headers = request.form.get('dataHeaders') # 获取 post 参数 可选
85 | ```
86 |
87 | #### 3.`requestorresponse`标识为请求包还是响应包(可选为request和response)，使用`reqresp = request.form.get('requestorresponse')`获取参数，以下示例为整个flask对象[打印request.form]：
88 | ```Java
89 | ImmutableMultiDict([('dataBody', 'dCtLdlmk7wI='), ('requestorresponse', 'response')])
90 | ```
91 |
92 |
93 | ### 函数出参为
94 |
95 | #### 4.1`body`(当未勾选对请求头加密时)
96 |
97 | 传入的为请求体，传出的为处理后的请求体
98 |
99 | ```
100 | I9z1fsH5QQ2NUbJi/7a8lw==
101 | ```
102 |
103 |
104 |
105 | #### 4.2.`headers + "\r\n\r\n\r\n\r\n" + body`(当勾选对请求头加密时)
106 |
107 | 传入的为请求头与请求体，传出的为处理后的请求头与请求体（这里未处理请求体，所以请求体是未处理过的）
108 |
109 | 这里的`\r\n\r\n\r\n\r\n`是为了区分开headers与body，是必需的
110 |
111 | ```
112 | POST /0828/testsql.php HTTP/1.1
113 | Host: 10.211.55.4
114 | User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:104.0) Gecko/20100101 Firefox/104.0
115 | Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8
116 | Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
117 | Accept-Encoding: gzip, deflate
118 | Connection: keep-alive
119 | Upgrade-Insecure-Requests: 1
120 | Content-Type: application/x-www-form-urlencoded
121 | Content-Length: 39
122 | aaaa:bbbb
123 | f0ng:test
124 |
125 |
126 |
127 | {"id":"1"}
128 | ```
129 |
130 |
131 | ## 0x04 项目不支持`pkcs7`加密？
132 |
133 | 实际上是已经实现的，因为AES并没有64位的块, 如果采用PKCS5, 那么实质上就是采用PKCS7
134 |
135 | ## 0x05 在burp中不出现`autoDecoder`选项卡?
136 |
137 | 需要配置生效的域名
138 |
139 | ## 0x06 使用二进制base64后数据被损坏
140 |
141 | 需要修改一下burp的设置，具体修改如下：
142 |
143 | - 勾选User options->Character Sets中的`Use the platform default(UTF-8)`[Mac]，或者勾选`Display as raw bytes`[Windows]
144 |
145 |
146 | ~~## 0x07 调试模块有换行存在~~ 0.31版本删除
147 |
148 | ~~这里是为了方便调试，自动加的换行，在repeater、intruder模块是没有换行的，所以不必担心~~
149 |
150 |
151 | ## 0x08 调试模块可以正常进行加解密，但是在repeater、proxy模块没有获取正常变量(没有正常进行加解密)
152 |
153 | 1. 调试模块是textarea数据包是字符串格式，而在repeater里是http包格式，所以在repeater、proxy模块中会有\r\n，在获取字符串的时候可以进行\r\n的替换即可
154 | 2. 关键字问题，调试模块不会受到关键字的影响，只会根据使用者的按钮进行加密、解密，而在实际运用中，在repeater、proxy模块，会受到关键字的影响
155 |
156 | ## 0x09 明文关键字、密文关键字如何理解
157 |
158 | - 明文关键字
159 |
160 | 即解密后是明文的关键字，可以配合手工进行测试，当标识为明文关键字后，手动请求明文，会经过插件加密为密文再发送到服务端，服务端返回密文，插件自动解密至选项卡，做到明文请求，明文响应
161 | ，明文关键字可以是明文框里的任意一个字符，但是为了和字符区分开，一般取 { 或者 " 这种json数据的
162 |
163 | - 密文关键字
164 |
165 | 即标示为密文的关键字，这里设置了密文关键字以后，任何标示为密文的请求体就不会进行加密，防止二次加密的产生，比如上图中的，就无法进行密文关键字标识，因为密文是字符，不可预测
166 |
167 | 两个关键字设置的初衷，就是为了在同一种环境中，既有加密的包，又有不加密的包，来进行区分；也为了在加密环境下，应用程序会取上一个数据包的密文作为下一个数据包的参数进行发送请求，如果自动解密成明文下一个数据包的参数就无法获取，导致应用程序无法正常运行，而设置了明文关键字、密文关键字，可以很好解决该问题
168 |
169 | ## 0x10 明文修改后进行发包，但是请求包返回原来的明文
170 |
171 | 问题出现于2021.10.1以后(可能往前几个版本也有)，目前不知道什么原因，解决方法是把数据包粘贴在repeater模块的`raw`中，进行发包，不要在`autodecoder`选项卡中发包
172 |
173 |
174 |
175 | ~~0x11 自带的sm4加解密有问题？~~
176 |
177 | #### 0.50版本修复，之前的原因在于 JCE cannot authenticate the provider BC ，故抛弃三方库进行实现，完美避免这个报错
178 |
179 | ~~sm4模块确实有问题，特别是一些不可见字符的，目前用的是原生的代码实现的，用不了现成的三方库，用sm4的建议还是用接口加解密~~
180 |
181 |
182 | ## 0x12 正则模块使用问题
183 |
184 | 正则模块只对请求体、响应体有效，不作用于数据头，且正则需要按照案例中正则进行参考编写
185 |
186 |
187 | ## 0x13 插件是不是不支持识别get参数?(插件是不是没办法获取数据包的header?)
188 |
189 | 勾选对数据头进行处理，python-flask代码中示例`dataHeaders `请求头，使用`headers = request.form.get('dataHeaders')`获取
190 |
191 |
192 | ## 0x14 插件是不是不支持并发？
193 |
194 | 理论上支持，但是由于代码处理密文数据、明文数据需要时间，所以高并发【burp默认线程这种】会导致加密/解密报错，建议用低并发进行处理
195 |
196 | ## 0x15 使用接口加解密得到的数据包会多一个换行
197 |
198 | 可以检查headers或者body是否使用`strip()【python语言】`这种去除首尾换行函数进行处理了，可以参考模板文件`flasktest.py`和`flasktestheader.py`
199 |
200 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # autoDecoder
2 |
3 | [](https://github.com/f0ng/autoDecoder/stargazers)
4 | [](https://github.com/f0ng/autoDecoder/releases)
5 | [](https://github.com/f0ng/autoDecoder/tags)
6 | [](https://github.com/f0ng/autoDecoder/releases)
7 |
8 |
9 |
10 | 想维护成一个有很多用例、接口的项目，希望各位师傅有加解密之类的需求可以一起沟通，完善本项目。
11 |
12 | 工具针对人群：有一定代码基础的师傅、没有基础(但是愿意自主学习捣鼓自动加解密)的师傅
13 |
14 | # 关于autoDecoder的案例移步[autoDecoder-usages](https://github.com/f0ng/autoDecoder-usages)，对很多想自行编写接口的师傅会有帮助
15 | # 接口代码模板不要随便去改动获取参数和返回的格式，否则会出现乱码、无法正常运行等问题
16 |
17 |
18 |
19 | 交流群
20 |
21 | 
22 |
23 | 二维码失效请加微信`f-f0ng`、备注autoDecoder交流
24 |
25 | 关注主页公众号（only security），回复`autodecoder`获取下载地址】
26 |
27 | # 捐赠 （如果项目有帮助到您，可以选择捐赠一些费用用于autoDecoder的后续版本维护，本项目长期维护）
28 | |
39 |
42 | 43 | |
45 |
46 |
49 | 50 | |
52 |
53 |
56 | 57 | |
59 |
182 |
183 | 2. 增加自带算法加解密的正则提取，当正则表达式有内容时生效，针对两种情况:
184 | 1. 只有请求加密的情况
185 | 2. 在爆破攻击中，对账号密码加密
186 |
187 | 配置页面
188 |
189 | 
190 |
191 |
192 | 
193 |
194 |
195 | 原始请求
196 |
197 | 
198 |
199 | 真实请求
200 |
201 | 
202 |
203 | 解密后
204 |
205 | 
206 |
207 |
208 | 3. 增加接口加解密时的调试页面，方便代码进一步编写
209 |
210 | 正常解密请求包
211 |
212 | 
213 |
214 | 正常解密响应包
215 |
216 | 
217 |
218 |
219 | 处理请求头
220 |
221 | 
222 |
223 |
224 | ## 2023.2.14 更新0.21
225 | 1. 增加burp模块按钮，防止与其他模块(如插件Extender)产生的请求冲突
226 | 2. 优化插件解密读取密文方式，进行URL解码后读取
227 |
228 | ## 2023.1.5 更新0.20
229 | 1. 增加`RSA解密` 一个例子
230 | 2. 优化选项卡数据包设置，不影响repeater本身的数据包内容
231 |
234 | 
237 | 238 | |
240 |
241 | 
244 | 245 | |
247 |
255 |
256 | - 修改了ui，优化了在新版bp上`html`无法解析的问题
257 |
258 | ## 2022.5.18 更新0.18
259 |
260 | - 增加`3DES加密`、 `AES加密`、 `JSON嵌套加密`三个例子
261 |
262 | - 在明文发出请求的时候，如果响应包选中了默认选项卡，则无影响；但是当响应包选中了扩展选项卡，还会进行解密，导致请求包内的响应体报错，`0.18`修复该问题：明文发出请求，响应包只有明文。
263 | - 增加密文关键字，出现该关键字则不进行加密，具体可以查看例json嵌套加密
264 | ## 2022.5.15 更新0.17
265 | - 优化Desede(3DES)加密处理问题，3DES加密的密钥为24位，当输入超过24位将会报密钥长度错误，处理方式为对密钥长度进行了截取
266 |
267 | ## 2022.5.11 更新 0.16
268 | 1. 增加响应头处理，传入参数同样为`dataHeaders`
269 | ```
270 | # -*- coding:utf-8 -*-
271 | # author:f0ngf0ng
272 |
273 | from flask import Flask,Response,request
274 | from pyDes import *
275 | import base64
276 | app = Flask(__name__)
277 |
278 | @app.route('/encode',methods=["POST"])
279 | def encrypt():
280 | body = request.form.get('dataBody') # 获取 post 参数 必需
281 | headers = request.form.get('dataHeaders') # 获取 post 参数 可选
282 |
283 | if headers != None: # 开启了请求头加密
284 | headers = headers + "aaaa:bbbb\r\n"
285 | headers = headers + "f0ng:test"
286 | print(headers + "\r\n\r\n\r\n\r\n" + body)
287 | return headers + "\r\n\r\n\r\n\r\n" + body # 返回值为固定格式，不可更改
288 |
289 | return body
290 |
291 | @app.route('/decode',methods=["POST"]) # 不解密
292 | def decrypt():
293 | body = request.form.get('dataBody') # 获取 post 参数 必需
294 | headers = request.form.get('dataHeaders') # 获取 post 参数 可选
295 | if headers != None: # 开启了响应头加密
296 | print(headers + "\r\n\r\n\r\n\r\n" + body)
297 | headers = headers + "yyyy:zzzz\r\n"
298 | headers = headers + "f0ng:onlysecurity"
299 | return headers + "\r\n\r\n\r\n\r\n" + body # 返回值为固定格式，不可更改
300 |
301 | return body
302 |
303 | if __name__ == '__main__':
304 | app.debug = True # 设置调试模式，生产模式的时候要关掉debug
305 | app.run(host="0.0.0.0",port="8888")
306 | ```
307 |
308 | 原始请求响应
309 |
310 | 
311 |
312 |
313 | 经过autoDecoder处理后的响应
314 |
315 | 
316 |
317 |
318 | 2. 修复当请求体为空时候的报错
319 | 3. 修复当关键词置空时造成多出一个换行符的问题
320 | ## 2022.5.7 更新 0.15
321 |
322 | * 优化设置域名处的端口问题，两种模式：
323 |
324 | ①只输入域名，匹配域名与任意端口号
325 |
326 | 
327 |
328 | 匹配所有`www.baidu.com:端口号`，如`www.baidu.com:8080`、`www.baidu.com:8088`
329 |
330 | ②输入域名与端口号，匹配唯一域名与端口号host
331 |
332 | 
333 |
334 | 只匹配`www.baidu.com:8080`
335 |
336 |
337 |
338 | ## 2022.4.26更新 0.14
339 |
340 | 1. 增加对整个请求包的处理，具体怎么修改，根据个人需要不同进行自定义了，模板文件为`flasktestheader.py`
341 |
342 | 配置如下：
343 |
344 | 
345 |
346 | 原始请求包，捕捉整个请求如下，在请求包添加额外的请求头`aaaa:bbbb`、`f0ng:test`
347 |
348 | 
349 |
350 | 实际请求包
351 |
352 | 
353 |
354 | 2. 增加自定义设置明文关键字，当请求体中出现了相应的关键字则不对数据包进行处理，取`contains`进行判断
355 | ## 2022.4.22更新 0.13
356 |
357 | 1. 对于`\r\n`的请求包处理不够完善，0.13版本修复该问题
358 |
359 | 2. 增加案例1`登录口爆破之ldap的md5加密`，案例2`sql注入绕过之sqlmap的数据包换行问题`，方便更好使用工具进行渗透测试
360 | ## 0x01 背景
361 | - 当数据包里都是密文，我们无从下手；就算是获得了加解密的一些关键信息，能解密出来，但是每个数据包我们都需要慢慢解密，请求包需要解密，响应包也需要解密，比较麻烦
362 | - 其实取auto这个名字并不是真正的auto，加解密算法还是需要自己去逆出来的，只是相对于数据包里的密文来说，可以算是半自动
363 |
364 | ## 0x02 优点
365 | - 明文传，明文响应；密文传，密文响应，不影响原本通讯包的基础上，增加一个bp扩展页面查看明文信息
366 | - 自定义加解密的接口，当存在复杂数据加密的时候，可以自行编写python代码对接口进行加解密， 自定义需要加解密域名，即开即用
367 |
368 | ## 0x03 插件的加解密方式
369 | - 直接通过插件自带的算法去加解密数据包(较为简单，仅支持部分AES、DES、DESede加密)
370 | - 通过python的flask接口去编写加解密数据包的api（不一定是flask框架，也可以起其他框架，只需要接口地址正确且加解密流程正确即可）
371 |
372 | ## 0x04 文件介绍:
373 | - `users.sql` 为测试所用数据库
374 |
375 | - `testsql.php` 为加密请求数据、加密响应数据且存在注入的页面
376 |
377 | - `flasktest.py` 为测试文件编写的Python flask加解密接口。
378 |
379 | 详细举例可至公众号查看https://mp.weixin.qq.com/s/B-lBbVpJsPdCp1pjz2Rxdg
380 |
381 | >## 通过自带加解密算法进行解密
382 | 
383 |
384 | >## 通过flask接口进行解密
385 | 
386 |
387 | >## sqlmap进行加解密
388 | 
389 |
390 |
391 |
--------------------------------------------------------------------------------
/flasktest.py:
--------------------------------------------------------------------------------
1 | # -*- coding:utf-8 -*-
2 | # author:f0ngf0ng
3 |
4 | from flask import Flask,Response,request
5 | from pyDes import *
6 | import base64
7 |
8 | def des_encrypt(s):
9 | """
10 | DES 加密
11 | :param s: 原始字符串
12 | :return: 加密后字符串，16进制
13 | """
14 | secret_key = "f0ngtest"
15 | iv = "f0ngf0ng"
16 | k = des(secret_key, CBC, iv, pad=None, padmode=PAD_PKCS5)
17 | en = k.encrypt(s, padmode=PAD_PKCS5)
18 | return base64.encodebytes(en).decode()
19 |
20 | def des_decrypt(s):
21 | """
22 | DES 解密
23 | :param s: 加密后的字符串，16进制
24 | :return: 解密后的字符串
25 | """
26 | secret_key = "f0ngtest"
27 | iv = "f0ngf0ng"
28 | k = des(secret_key, CBC, iv, pad=None, padmode=PAD_PKCS5)
29 | de = k.decrypt(base64.decodebytes(bytes(s,encoding="utf-8")), padmode=PAD_PKCS5)
30 | return de.decode()
31 |
32 | app = Flask(__name__)
33 |
34 | @app.route('/encode',methods=["POST"])
35 | def encrypt():
36 | param = request.form.get('dataBody') # 获取 post 参数
37 | encry_param = des_encrypt(param.strip("\n"))
38 | print(param)
39 | print(encry_param)
40 | return encry_param
41 |
42 | @app.route('/decode',methods=["POST"])
43 | def decrypt():
44 | param = request.form.get('dataBody') # 获取 post 参数
45 | decrypt_param = des_decrypt(param.strip("\n"))
46 | print(param)
47 | print(decrypt_param)
48 | return decrypt_param
49 |
50 | if __name__ == '__main__':
51 | app.debug = True # 设置调试模式，生产模式的时候要关掉debug
52 | app.run(host="0.0.0.0",port="8888")
53 |
--------------------------------------------------------------------------------
/flasktestheader.py:
--------------------------------------------------------------------------------
1 | # -*- coding:utf-8 -*-
2 | # author:f0ngf0ng
3 |
4 | from flask import Flask,Response,request
5 | from pyDes import *
6 | import base64,re
7 | app = Flask(__name__)
8 |
9 | @app.route('/encode',methods=["POST"]) # 不要修改 不要修改 不要修改 永远都是POST获取参数，不管源数据包GET方法还是POST方法
10 | def encrypt():
11 | body = request.form.get('dataBody') # 获取 post 参数 必需必需必需 获取数据包内body的内容
12 | headers = request.form.get('dataHeaders') # 获取 post 参数 可选 获取数据包内的数据头，需要勾选<对数据头进行处理>按钮
13 | reqresp = request.form.get('requestorresponse') # 获取 requestorresponse 参数 可选 获取是请求还是响应包，需要勾选<请求响应不同加解密>按钮
14 | print(body)
15 | print(headers)
16 | print(reqresp)
17 |
18 | #被#隔开的部分是处理header头的部分
19 | ################################################################
20 | ################################################################
21 | if headers != None: # 开启了请求头加密
22 | print(headers)
23 | try:
24 | param_uri = re.findall(r'[POST|GET|PUT] /(.*?)[ ]', headers)[0] # 提取请求的uri及参数
25 | print(param_uri)
26 | param_uri_total = param_uri + "&b=22222222"
27 | headers = headers.replace(param_uri, param_uri_total, 1) # 用修改后的uri替换原参数中的uri
28 | except:
29 | pass
30 |
31 | headers = headers + "aaaa:bbbb\r\n"
32 | headers = headers + "f0ng:test"
33 | print(headers + "\r\n\r\n\r\n\r\n" + body)
34 | return headers.strip() + "\r\n\r\n\r\n\r\n" + body # 返回值为固定格式，不可更改 必需必需必需，共四个\r\n
35 | ################################################################
36 | ################################################################
37 |
38 | return body # 返回值为固定格式，不可更改 必需必需必需
39 |
40 | @app.route('/decode',methods=["POST"]) # 不要修改 不要修改 不要修改 永远都是POST获取参数，不管源数据包GET方法还是POST方法
41 | def decrypt():
42 | body = request.form.get('dataBody') # 获取 post 参数 必需必需必需 获取数据包内body的内容
43 | headers = request.form.get('dataHeaders') # 获取 post 参数 可选 获取数据包内的数据头，需要勾选<对数据头进行处理>按钮
44 | reqresp = request.form.get('requestorresponse') # 获取 requestorresponse 参数 可选 获取是请求还是响应包，需要勾选<请求响应不同加解密>按钮
45 | print(body)
46 | print(headers)
47 | print(reqresp)
48 | # 被#隔开的部分是处理header头的部分，需要勾选<对数据头进行处理>按钮
49 | ################################################################
50 | ################################################################
51 | if headers != None: # 开启了响应头加密
52 | print(headers)
53 | try:
54 | param_uri = re.findall(r'[POST|GET|PUT] /(.*?)[ ]', headers)[0] # 提取请求的uri及参数
55 | print(param_uri)
56 | param_uri_total = param_uri + "&b=22222222"
57 | headers = headers.replace(param_uri, param_uri_total, 1) # 用修改后的uri替换原参数中的uri
58 | except:
59 | pass
60 | headers = headers + "yyyy:zzzz\r\n"
61 | headers = headers + "f0ng:onlysecurity"
62 | return headers.strip() + "\r\n\r\n\r\n\r\n" + body # 返回值为固定格式，不可更改 必需必需必需，共四个\r\n
63 | ################################################################
64 | ################################################################
65 |
66 | return body # 返回值为固定格式，不可更改 必需必需必需
67 |
68 | if __name__ == '__main__':
69 | app.debug = True # 设置调试模式，生产模式的时候要关掉debug
70 | app.run(host="0.0.0.0",port="8888")
71 |
--------------------------------------------------------------------------------
/pom.xml:
--------------------------------------------------------------------------------
1 | true 传换成小写格式 ， false 传换成大写格式
199 | * @return 十六进制char[]
200 | */
201 | public static char[] encodeHex(byte[] data, boolean toLowerCase) {
202 | return encodeHex(data, toLowerCase ? DIGITS_LOWER : DIGITS_UPPER);
203 | }
204 |
205 | /**
206 | * 将字节数组转换为十六进制字符数组
207 | *
208 | * @param data byte[]
209 | * @param toDigits 用于控制输出的char[]
210 | * @return 十六进制char[]
211 | */
212 | protected static char[] encodeHex(byte[] data, char[] toDigits) {
213 | int l = data.length;
214 | char[] out = new char[l << 1];
215 | // two characters form the hex value.
216 | for (int i = 0, j = 0; i < l; i++) {
217 | out[j++] = toDigits[(0xF0 & data[i]) >>> 4];
218 | out[j++] = toDigits[0x0F & data[i]];
219 | }
220 | return out;
221 | }
222 |
223 | /**
224 | * 将字节数组转换为十六进制字符串
225 | *
226 | * @param data byte[]
227 | * @return 十六进制String
228 | */
229 | public static String encodeHexString(byte[] data) {
230 | return encodeHexString(data, true);
231 | }
232 |
233 | /**
234 | * 将字节数组转换为十六进制字符串
235 | *
236 | * @param data byte[]
237 | * @param toLowerCase true 传换成小写格式 ， false 传换成大写格式
238 | * @return 十六进制String
239 | */
240 | public static String encodeHexString(byte[] data, boolean toLowerCase) {
241 | return encodeHexString(data, toLowerCase ? DIGITS_LOWER : DIGITS_UPPER);
242 | }
243 |
244 | /**
245 | * 将字节数组转换为十六进制字符串
246 | *
247 | * @param data byte[]
248 | * @param toDigits 用于控制输出的char[]
249 | * @return 十六进制String
250 | */
251 | protected static String encodeHexString(byte[] data, char[] toDigits) {
252 | return new String(encodeHex(data, toDigits));
253 | }
254 |
255 | /**
256 | * 将十六进制字符数组转换为字节数组
257 | *
258 | * @param data 十六进制char[]
259 | * @return byte[]
260 | * @throws RuntimeException 如果源十六进制字符数组是一个奇怪的长度，将抛出运行时异常
261 | */
262 | public static byte[] decodeHex(char[] data) {
263 | int len = data.length;
264 |
265 | if ((len & 0x01) != 0) {
266 | throw new RuntimeException("Odd number of characters.");
267 | }
268 |
269 | byte[] out = new byte[len >> 1];
270 |
271 | // two characters form the hex value.
272 | for (int i = 0, j = 0; j < len; i++) {
273 | int f = toDigit(data[j], j) << 4;
274 | j++;
275 | f = f | toDigit(data[j], j);
276 | j++;
277 | out[i] = (byte) (f & 0xFF);
278 | }
279 |
280 | return out;
281 | }
282 |
283 | /**
284 | * 将十六进制字符转换成一个整数
285 | *
286 | * @param ch 十六进制char
287 | * @param index 十六进制字符在字符数组中的位置
288 | * @return 一个整数
289 | * @throws RuntimeException 当ch不是一个合法的十六进制字符时，抛出运行时异常
290 | */
291 | protected static int toDigit(char ch, int index) {
292 | int digit = Character.digit(ch, 16);
293 | if (digit == -1) {
294 | throw new RuntimeException("Illegal hexadecimal character " + ch
295 | + " at index " + index);
296 | }
297 | return digit;
298 | }
299 |
300 | /**
301 | * 数字字符串转ASCII码字符串
302 | *
303 | * @param String 字符串
304 | * @return ASCII字符串
305 | */
306 | public static String StringToAsciiString(String content) {
307 | String result = "";
308 | int max = content.length();
309 | for (int i = 0; i < max; i++) {
310 | char c = content.charAt(i);
311 | String b = Integer.toHexString(c);
312 | result = result + b;
313 | }
314 | return result;
315 | }
316 |
317 | /**
318 | * 十六进制转字符串
319 | *
320 | * @param hexString 十六进制字符串
321 | * @param encodeType 编码类型4：Unicode，2：普通编码
322 | * @return 字符串
323 | */
324 | public static String hexStringToString(String hexString, int encodeType) {
325 | String result = "";
326 | int max = hexString.length() / encodeType;
327 | for (int i = 0; i < max; i++) {
328 | char c = (char) hexStringToAlgorism(hexString
329 | .substring(i * encodeType, (i + 1) * encodeType));
330 | result += c;
331 | }
332 | return result;
333 | }
334 |
335 | /**
336 | * 十六进制字符串装十进制
337 | *
338 | * @param hex 十六进制字符串
339 | * @return 十进制数值
340 | */
341 | public static int hexStringToAlgorism(String hex) {
342 | hex = hex.toUpperCase();
343 | int max = hex.length();
344 | int result = 0;
345 | for (int i = max; i > 0; i--) {
346 | char c = hex.charAt(i - 1);
347 | int algorism = 0;
348 | if (c >= '0' && c <= '9') {
349 | algorism = c - '0';
350 | } else {
351 | algorism = c - 55;
352 | }
353 | result += Math.pow(16, max - i) * algorism;
354 | }
355 | return result;
356 | }
357 |
358 | /**
359 | * 十六转二进制
360 | *
361 | * @param hex 十六进制字符串
362 | * @return 二进制字符串
363 | */
364 | public static String hexStringToBinary(String hex) {
365 | hex = hex.toUpperCase();
366 | String result = "";
367 | int max = hex.length();
368 | for (int i = 0; i < max; i++) {
369 | char c = hex.charAt(i);
370 | switch (c) {
371 | case '0':
372 | result += "0000";
373 | break;
374 | case '1':
375 | result += "0001";
376 | break;
377 | case '2':
378 | result += "0010";
379 | break;
380 | case '3':
381 | result += "0011";
382 | break;
383 | case '4':
384 | result += "0100";
385 | break;
386 | case '5':
387 | result += "0101";
388 | break;
389 | case '6':
390 | result += "0110";
391 | break;
392 | case '7':
393 | result += "0111";
394 | break;
395 | case '8':
396 | result += "1000";
397 | break;
398 | case '9':
399 | result += "1001";
400 | break;
401 | case 'A':
402 | result += "1010";
403 | break;
404 | case 'B':
405 | result += "1011";
406 | break;
407 | case 'C':
408 | result += "1100";
409 | break;
410 | case 'D':
411 | result += "1101";
412 | break;
413 | case 'E':
414 | result += "1110";
415 | break;
416 | case 'F':
417 | result += "1111";
418 | break;
419 | }
420 | }
421 | return result;
422 | }
423 |
424 | /**
425 | * ASCII码字符串转数字字符串
426 | *
427 | * @param String ASCII字符串
428 | * @return 字符串
429 | */
430 | public static String AsciiStringToString(String content) {
431 | String result = "";
432 | int length = content.length() / 2;
433 | for (int i = 0; i < length; i++) {
434 | String c = content.substring(i * 2, i * 2 + 2);
435 | int a = hexStringToAlgorism(c);
436 | char b = (char) a;
437 | String d = String.valueOf(b);
438 | result += d;
439 | }
440 | return result;
441 | }
442 |
443 | /**
444 | * 将十进制转换为指定长度的十六进制字符串
445 | *
446 | * @param algorism int 十进制数字
447 | * @param maxLength int 转换后的十六进制字符串长度
448 | * @return String 转换后的十六进制字符串
449 | */
450 | public static String algorismToHexString(int algorism, int maxLength) {
451 | String result = "";
452 | result = Integer.toHexString(algorism);
453 |
454 | if (result.length() % 2 == 1) {
455 | result = "0" + result;
456 | }
457 | return patchHexString(result.toUpperCase(), maxLength);
458 | }
459 |
460 | /**
461 | * 字节数组转为普通字符串（ASCII对应的字符）
462 | *
463 | * @param bytearray byte[]
464 | * @return String
465 | */
466 | public static String byteToString(byte[] bytearray) {
467 | String result = "";
468 | char temp;
469 |
470 | int length = bytearray.length;
471 | for (int i = 0; i < length; i++) {
472 | temp = (char) bytearray[i];
473 | result += temp;
474 | }
475 | return result;
476 | }
477 |
478 | /**
479 | * 二进制字符串转十进制
480 | *
481 | * @param binary 二进制字符串
482 | * @return 十进制数值
483 | */
484 | public static int binaryToAlgorism(String binary) {
485 | int max = binary.length();
486 | int result = 0;
487 | for (int i = max; i > 0; i--) {
488 | char c = binary.charAt(i - 1);
489 | int algorism = c - '0';
490 | result += Math.pow(2, max - i) * algorism;
491 | }
492 | return result;
493 | }
494 |
495 | /**
496 | * 十进制转换为十六进制字符串
497 | *
498 | * @param algorism int 十进制的数字
499 | * @return String 对应的十六进制字符串
500 | */
501 | public static String algorismToHEXString(int algorism) {
502 | String result = "";
503 | result = Integer.toHexString(algorism);
504 |
505 | if (result.length() % 2 == 1) {
506 | result = "0" + result;
507 |
508 | }
509 | result = result.toUpperCase();
510 |
511 | return result;
512 | }
513 |
514 | /**
515 | * HEX字符串前补0，主要用于长度位数不足。
516 | *
517 | * @param str String 需要补充长度的十六进制字符串
518 | * @param maxLength int 补充后十六进制字符串的长度
519 | * @return 补充结果
520 | */
521 | static public String patchHexString(String str, int maxLength) {
522 | String temp = "";
523 | for (int i = 0; i < maxLength - str.length(); i++) {
524 | temp = "0" + temp;
525 | }
526 | str = (temp + str).substring(0, maxLength);
527 | return str;
528 | }
529 |
530 | /**
531 | * 将一个字符串转换为int
532 | *
533 | * @param s String 要转换的字符串
534 | * @param defaultInt int 如果出现异常,默认返回的数字
535 | * @param radix int 要转换的字符串是什么进制的,如16 8 10.
536 | * @return int 转换后的数字
537 | */
538 | public static int parseToInt(String s, int defaultInt, int radix) {
539 | int i = 0;
540 | try {
541 | i = Integer.parseInt(s, radix);
542 | } catch (NumberFormatException ex) {
543 | i = defaultInt;
544 | }
545 | return i;
546 | }
547 |
548 | /**
549 | * 将一个十进制形式的数字字符串转换为int
550 | *
551 | * @param s String 要转换的字符串
552 | * @param defaultInt int 如果出现异常,默认返回的数字
553 | * @return int 转换后的数字
554 | */
555 | public static int parseToInt(String s, int defaultInt) {
556 | int i = 0;
557 | try {
558 | i = Integer.parseInt(s);
559 | } catch (NumberFormatException ex) {
560 | i = defaultInt;
561 | }
562 | return i;
563 | }
564 |
565 | /**
566 | * 十六进制串转化为byte数组
567 | *
568 | * @return the array of byte
569 | */
570 | public static byte[] hexToByte(String hex)
571 | throws IllegalArgumentException {
572 | System.out.println(hex);
573 | if (hex.length() % 2 != 0) {
574 | // System.out.println(hex.length());
575 | throw new IllegalArgumentException();
576 | }
577 | char[] arr = hex.toCharArray();
578 | byte[] b = new byte[hex.length() / 2];
579 | for (int i = 0, j = 0, l = hex.length(); i < l; i++, j++) {
580 | String swap = "" + arr[i++] + arr[i];
581 | int byteint = Integer.parseInt(swap, 16) & 0xFF;
582 | b[j] = new Integer(byteint).byteValue();
583 | }
584 | return b;
585 | }
586 |
587 | /**
588 | * 字节数组转换为十六进制字符串
589 | *
590 | * @param b byte[] 需要转换的字节数组
591 | * @return String 十六进制字符串
592 | */
593 | public static String byteToHex(byte b[]) {
594 | if (b == null) {
595 | throw new IllegalArgumentException(
596 | "Argument b ( byte array ) is null! ");
597 | }
598 | String hs = "";
599 | String stmp = "";
600 | for (int n = 0; n < b.length; n++) {
601 | stmp = Integer.toHexString(b[n] & 0xff);
602 | if (stmp.length() == 1) {
603 | hs = hs + "0" + stmp;
604 | } else {
605 | hs = hs + stmp;
606 | }
607 | }
608 | return hs.toLowerCase();
609 | //return hs.toUpperCase();
610 | }
611 |
612 | public static byte[] subByte(byte[] input, int startIndex, int length) {
613 | byte[] bt = new byte[length];
614 | for (int i = 0; i < length; i++) {
615 | bt[i] = input[i + startIndex];
616 | }
617 | return bt;
618 | }
619 | }
620 |
--------------------------------------------------------------------------------
/src/com/autoDecoder/util/codeEncode.java:
--------------------------------------------------------------------------------
1 | package com.autoDecoder.util;
2 |
3 | import burp.BurpExtender;
4 |
5 | import static com.autoDecoder.util.RSAencode.encrypt;
6 | import static com.autoDecoder.util.codeDecode.*;
7 |
8 | import java.io.PrintWriter;
9 | import java.net.URLDecoder;
10 | import java.net.URLEncoder;
11 | import java.nio.charset.Charset;
12 | import java.security.KeyPair;
13 | import java.util.Arrays;
14 | //import java.util.Base64;
15 | import burp.IndexautoDecoder;
16 | import cn.hutool.crypto.SecureUtil;
17 | import cn.hutool.crypto.SmUtil;
18 | import cn.hutool.crypto.asymmetric.KeyType;
19 | import cn.hutool.crypto.asymmetric.SM2;
20 | import cn.hutool.crypto.symmetric.SymmetricCrypto;
21 | import org.apache.commons.codec.Charsets;
22 | import org.apache.commons.codec.binary.Base64;
23 | import org.bouncycastle.jce.provider.BouncyCastleProvider;
24 |
25 | import java.nio.charset.StandardCharsets;
26 | import java.security.Key;
27 | import java.security.Security;
28 | import javax.crypto.Cipher;
29 | import javax.crypto.spec.IvParameterSpec;
30 | import javax.crypto.spec.SecretKeySpec;
31 |
32 | public class codeEncode {
33 | static{
34 | Security.addProvider(new BouncyCastleProvider());
35 | }
36 | public static void main(String[] args) throws Exception {
37 |
38 | // String a = encryptKeyivmode("{\"id\":\"1''\"}",
39 | // "f0ngtestf0ngtest","f0ngf0ngf0ngf0ng","AES","CBC","PKCS5Padding","Base64","无");
40 |
41 | // String a = encryptKeyivmode("{\"mobile\":\"13888888888\"}",
42 | // "3d7bdda07326bb086de449838ec5c590","","SM4","ECB","PKCS5Padding","Hex","Hex");
43 | //
44 | // System.out.println(a);
45 | //
46 | String aa = encryptKeyivmode("{\"wxOpenId\":\"\",\"account\":\"\",\"password\":\"\",\"request_seq\":\"ZJOSS202404191143432890846955\"}",
47 | "j6slh8xin3yfhqbxmx46n53p","j6slh8xin3yfhqbxmx46n53p","DESede","ECB","PKCS5Padding","Hex","null");
48 | System.out.println(aa);
49 |
50 | // String aa = encryptKeyivmode("{\"mobile\":13812312355}\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000",
51 | // "1234567890123456","1234567890123456","AES","CBC","NoPadding","Base64","无");
52 | // System.out.println(aa);
53 |
54 | // String a = encryptKeyivmode("{\"loginstate\":null,\"data\":[],\"object\":null,\"token\":null,\"code\":null," +
55 | // "\"resultStatus\":\"success\",\"messageCode\":1009,\"devMessage\":\"\",\"message\":\"操作失败\"," +
56 | // "\"clientStyle\":1,\"dataCount\":0,\"key\":null,\"zip\":false,\"requestInfo\":{\"responseTime\":1}," +
57 | // "\"authStatus\":3,\"enabled\":1}", "12345645678iaweb","1234567812345678","AES","CBC","NoPadding","Base64","null");
58 |
59 | // String aa = encryptKeyivmode("{\"loginstate\":null,\"data\":[],\"object\":null,\"token\":null,\"code\":null,\"resultStatus\":\"success\",\"messageCode\":1009,\"devMessage\":\"\",\"message\":\"操作失败\",\"clientStyle\":1,\"dataCount\":0,\"key\":null,\"zip\":false,\"requestInfo\":{\"responseTime\":168022497401},\"authStatus\":3,\"enabled\":1}", "12345645678iaweb","1234567812345678","AES","CBC","NoPadding","Base64","null");
60 | // String aa = encryptKeyivmode("123456", "1234567890123456","1234567890123456","AES","CBC","NoPadding","Base64","null");
61 |
62 | // String aa = decryptKeyivmode("QEwd/DWmy/4yGncCqBofQQ==", "1234567890123456","1234567890123456","AES","CBC","NoPadding","Base64","null");
63 | // System.out.println(aa);
64 | }
65 |
66 | // public static String byte2hex(final byte[] array) {
67 | // String s = "";
68 | // for (int i = 0; i < array.length; ++i) {
69 | // final String hexString = Integer.toHexString(array[i] & 0xFF);
70 | // if (hexString.length() == 1) {
71 | // final StringBuilder sb = new StringBuilder();
72 | // sb.append(s);
73 | // sb.append("0");
74 | // sb.append(hexString);
75 | // s = sb.toString();
76 | // }
77 | // else {
78 | // final StringBuilder sb2 = new StringBuilder();
79 | // sb2.append(s);
80 | // sb2.append(hexString);
81 | // s = sb2.toString();
82 | // }
83 | // }
84 | // return s.toUpperCase();
85 | // }
86 | // public static byte[] byteMerger(final byte[] array, final byte[] array2) {
87 | // final byte[] array3 = new byte[array.length + array2.length];
88 | // System.arraycopy(array, 0, array3, 0, array.length);
89 | // System.arraycopy(array2, 0, array3, array.length, array2.length);
90 | // return array3;
91 | // }
92 |
93 | // public static String encrypt2(byte[] array) {
94 | // try {
95 | // byte[] array2 = toByteArray(new String(array));
96 | //
97 | // String key_str = "f7dd8981859e6b2932c72eddf39aec144dd43896ca95252f30293188fd033abc";
98 | // String iv_str = "dfb04ad776cc1ff90ea26e441a3949db";
99 | // byte[] iv = toByteArray(iv_str);
100 | // byte[] key = toByteArray(key_str);
101 | // final IvParameterSpec ivParameterSpec = new IvParameterSpec(iv);
102 | // final SecretKeySpec secretKeySpec = new SecretKeySpec(key, "AES");
103 | // final Cipher instance = Cipher.getInstance("AES/CFB/NoPadding");
104 | // instance.init(1, secretKeySpec, ivParameterSpec);
105 | // String array3 = byte2hex(byteMerger(instance.getIV(), instance.doFinal(array)));
106 | // return array3;
107 | // }
108 | // catch (Exception ex) {
109 | // ex.printStackTrace();
110 | // return null;
111 | // }
112 | // }
113 |
114 | // 将十六进制字符串转换为字节数组
115 | public static byte[] hexStringToByteArray(String hexString) {
116 | int len = hexString.length();
117 | byte[] data = new byte[len / 2];
118 | for (int i = 0; i < len; i += 2) {
119 | data[i / 2] = (byte) ((Character.digit(hexString.charAt(i), 16) << 4)
120 | + Character.digit(hexString.charAt(i+1), 16));
121 | }
122 | return data;
123 | }
124 |
125 |
126 |
127 | public static String encryptKeyivmode(String encryptedData,String sessionKey,String iv,String encodemode, String ivmode , String paddingmode ,String sSrcmode ,String keyivmode) throws Exception {
128 | encryptedData = encryptedData.trim();
129 |
130 | Boolean zero = false;
131 | if (paddingmode.equals("ZeroPadding")) {
132 | paddingmode = "NoPadding";
133 | zero = true;
134 | }
135 |
136 | if ( ivmode.equals("ECB") )
137 | iv = "";
138 |
139 | // BurpExtender.stdout.println(encodemode);
140 | if (encodemode.equals("null"))
141 | return encryptedData;
142 | else if (encodemode.equals("RSA")){
143 | try {
144 |
145 | if (IndexautoDecoder.getRadioButton12State())
146 | return URLEncoder.encode(encrypt(encryptedData, sessionKey), "utf-8");
147 | else
148 | return encrypt(encryptedData, sessionKey);
149 | }catch (Exception e){
150 | BurpExtender.stdout.println(Arrays.toString(e.getStackTrace()));
151 | return "RSA加密错误";
152 | }
153 | } else if ( encodemode.equals("SM4") ){ // SM4加密
154 | // BurpExtender.stdout.println(encryptedData);
155 | // BurpExtender.stdout.println(sessionKey);
156 | // BurpExtender.stdout.println(iv);
157 | // BurpExtender.stdout.println(encodemode);
158 | // BurpExtender.stdout.println(ivmode);
159 | // BurpExtender.stdout.println(paddingmode);
160 | // BurpExtender.stdout.println(sSrcmode);
161 | // BurpExtender.stdout.println(keyivmode);
162 | byte[] data = null;
163 | byte[] aseKey;
164 | byte[] ivData;
165 |
166 | if (keyivmode.equals("Base64")) {
167 | aseKey = Base64.decodeBase64(sessionKey);
168 | ivData = Base64.decodeBase64(iv);
169 | } else if (keyivmode.equals("Hex")) {
170 | aseKey = hexToByteArray(sessionKey);
171 | ivData = hexToByteArray(iv);
172 | } else {
173 | aseKey = sessionKey.getBytes(StandardCharsets.UTF_8);
174 | ivData = iv.getBytes(StandardCharsets.UTF_8);
175 | }
176 |
177 | if ( ivmode.equals("ECB") ) {
178 |
179 | String s = Util.byteToHex(encryptedData.getBytes());
180 | // System.out.println("原文" + s);
181 | SM4Utils sm42 = new SM4Utils();
182 | //sm4.secretKey = "JeF8U9wHFOMfs2Y8";
183 | sm42.secretKey = Util.byteToHex(aseKey);
184 | sm42.hexString = true;
185 | byte[] result = sm42.encryptData_ECB(encryptedData).getBytes();
186 | String final_result = "";
187 |
188 | if (sSrcmode.equals("Base64") ) {
189 | // System.out.println(Arrays.toString(hexStringToByteArray(new String(result))));
190 | final_result = new String((result)).replace("\n", "");
191 | System.out.println("final_result1:" + final_result);
192 | final_result = new String(Base64.encodeBase64(hexStringToByteArray(new String(result)))).replace("\n", "");
193 | System.out.println("final_result:" + final_result);
194 | }
195 |
196 | if (sSrcmode.equals("null") || sSrcmode.equals("Hex") ) {
197 | final_result = new String((result)).replace("\n", "");
198 | }
199 |
200 | return final_result;
201 | }else{ // CBC
202 | // String s = Util.byteToHex(encryptedData.getBytes());
203 | // System.out.println("原文" + s);
204 | SM4Utils sm42 = new SM4Utils();
205 | sm42.secretKey = Util.byteToHex(aseKey);
206 | sm42.hexString = true;
207 | sm42.iv = Util.byteToHex(ivData);
208 | byte[] result = sm42.encryptData_CBC(encryptedData).getBytes();
209 | String final_result = "";
210 |
211 | if (sSrcmode.equals("Base64")) {
212 | System.out.println((new String(result)));
213 | System.out.println(Arrays.toString(hexStringToByteArray(new String(result))));
214 | final_result = new String(Base64.encodeBase64(hexStringToByteArray(new String(result)))).replace("\n", "");
215 |
216 | }
217 |
218 | if (sSrcmode.equals("null") || sSrcmode.equals("Hex") ) {
219 | final_result = new String((result)).replace("\n", "");
220 | }
221 |
222 | if (IndexautoDecoder.getRadioButton12State())
223 | final_result = URLEncoder.encode(final_result, "utf-8");
224 |
225 | return final_result;
226 | }
227 |
228 | } else if ( encodemode.equals("SM2") ){
229 | try {
230 | SM2 sm2;
231 |
232 | if (sSrcmode.equals("Hex")){
233 | sm2 = SmUtil.sm2(Base64.decodeBase64("MQ=="), hexToByteArray(sessionKey));
234 |
235 | }else {
236 |
237 | sm2 = SmUtil.sm2(Base64.decodeBase64("MQ=="), Base64.decodeBase64(sessionKey));
238 | }
239 |
240 | if (IndexautoDecoder.getRadioButton12State())
241 | return URLEncoder.encode(sm2.encryptBcd(encryptedData, KeyType.PublicKey));
242 | else
243 | return sm2.encryptBcd(encryptedData, KeyType.PublicKey);
244 | }catch (Exception e){
245 | // BurpExtender.stdout.println(Arrays.toString(e.getStackTrace()));
246 | // System.out.println(Arrays.toString(e.getStackTrace()));
247 | // e.printStackTrace();
248 | return "SM2加密错误";
249 | }
250 | }else {
251 | try {
252 | byte[] data = null;
253 | byte[] aseKey;
254 | byte[] ivData;
255 |
256 | if (keyivmode.equals("null")) {
257 | if (encodemode.equals("DESede") ) {
258 | if (sessionKey.length() > 24) {
259 | sessionKey = sessionKey.substring(0, 24);
260 | }
261 | // if ( ivmode.equals("ECB") ){
262 | // sessionKey = sessionKey.substring(0, 8);
263 | // }else {
264 | // iv = iv.substring(0, 8);
265 | // }
266 | }
267 | else if(encodemode.equals("DES")){
268 | sessionKey = sessionKey.substring(0,8);
269 | if ( ivmode.equals("ECB") ){
270 | sessionKey = sessionKey.substring(0, 8);
271 | }else {
272 | iv = iv.substring(0, 8);
273 | }
274 | }
275 | }
276 |
277 | data = encryptedData.getBytes(StandardCharsets.UTF_8);
278 |
279 | if (keyivmode.equals("Base64")) {
280 | aseKey = Base64.decodeBase64(sessionKey);
281 | ivData = Base64.decodeBase64(iv);
282 | } else if (keyivmode.equals("Hex")) {
283 | aseKey = hexToByteArray(sessionKey);
284 | ivData = hexToByteArray(iv);
285 | } else {
286 | // System.out.println(sessionKey);
287 | aseKey = sessionKey.getBytes(StandardCharsets.UTF_8);
288 | ivData = iv.getBytes(StandardCharsets.UTF_8);
289 | }
290 |
291 |
292 |
293 | IvParameterSpec ivParameterSpec = new IvParameterSpec(ivData);
294 | // Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
295 | Cipher cipher = Cipher.getInstance(encodemode + "/" + ivmode + "/" + paddingmode);
296 | Key sKeySpec = new SecretKeySpec(aseKey, encodemode);
297 | //cipher.init(Cipher.ENCRYPT_MODE, sKeySpec,ivParameterSpec );// 初始化
298 | if (ivmode.equals("ECB") || ivmode.equals("GCM")) { // 如果为ECB模式，不进行偏移量加载
299 | cipher.init(Cipher.ENCRYPT_MODE, sKeySpec);
300 | } else {
301 | // try {
302 | cipher.init(Cipher.ENCRYPT_MODE, sKeySpec, ivParameterSpec);
303 | // }catch (Exception InvalidAlgorithmParameterException){
304 | //
305 | // }
306 | }
307 |
308 | byte[] result = null ;
309 | if (zero) {
310 | result = cipher.doFinal(formatWithZeroPadding(data, cipher.getBlockSize()));
311 | }else{
312 | // System.out.println(Arrays.toString(aseKey));
313 | result = cipher.doFinal(data);
314 | }
315 | String final_result = "";
316 |
317 | if (sSrcmode.equals("Base64") || sSrcmode.equals("null"))
318 | final_result = new String(Base64.encodeBase64(result)).replace("\n", "");
319 |
320 | if (sSrcmode.equals("Hex"))
321 | final_result = bytesToHex(result);
322 | // BurpExtender.stdout.println(final_result);
323 |
324 |
325 | // if (IndexautoDecoder.getRadioButton12State())
326 | // final_result = URLEncoder.encode(final_result, "utf-8");
327 |
328 | return final_result;
329 | } catch (Exception e) {
330 | // BurpExtender.stdout.println(e);
331 | return "加密错误，请确认选项无误!";
332 | }
333 | }
334 | }
335 |
336 | private static byte[] formatWithZeroPadding(byte[] data, final int blockSize) {
337 | final int length = data.length;
338 | final int remainLength = length % blockSize;
339 |
340 | if (remainLength > 0) {
341 | byte[] inputData = new byte[length + blockSize - remainLength];
342 | System.arraycopy(data, 0, inputData, 0, length);
343 | return inputData;
344 | }
345 | return data;
346 | }
347 |
348 |
349 |
350 | // 字节数组转hex
351 | public static String bytesToHex(byte[] bytes) {
352 | StringBuffer sb = new StringBuffer();
353 | for(int i = 0; i < bytes.length; i++) {
354 | String hex = Integer.toHexString(bytes[i] & 0xFF);
355 | if(hex.length() < 2){
356 | sb.append(0);
357 | }
358 | sb.append(hex);
359 | }
360 | return sb.toString();
361 | }
362 |
363 |
364 | }
365 |
--------------------------------------------------------------------------------
/src/com/autoDecoder/util/test.java:
--------------------------------------------------------------------------------
1 | import java.util.Base64;
2 |
3 | public class test {
4 |
5 | // Base64 编码的字符串转换为十六进制字符串
6 | public static String base64ToHex(String base64String) {
7 | // 解码 Base64 字符串得到原始字节数据
8 | byte[] decodedBytes = Base64.getDecoder().decode(base64String);
9 |
10 | // 使用 StringBuilder 存储结果
11 | StringBuilder hexBuilder = new StringBuilder();
12 |
13 | // 遍历字节数组，将每个字节转换为十六进制表示并拼接
14 | for (byte decodedByte : decodedBytes) {
15 | String hex = Integer.toHexString(0xff & decodedByte);
16 | if (hex.length() == 1) {
17 | hexBuilder.append('0'); // 如果是单个字符，前面补零
18 | }
19 | hexBuilder.append(hex);
20 | }
21 |
22 | // 返回最终的十六进制字符串
23 | return hexBuilder.toString();
24 | }
25 |
26 | public static void main(String[] args) {
27 | // Base64 编码的字符串示例
28 | String base64String = "SGVsbG8gV29ybGQ="; // 等于 "Hello World" 的 Base64 编码
29 |
30 | // 转换为十六进制字符串
31 | String hexString = base64ToHex(base64String);
32 |
33 | // 打印结果
34 | System.out.println("Hex: " + hexString);
35 | }
36 | }
--------------------------------------------------------------------------------
/src/main/resources/assembly.xml:
--------------------------------------------------------------------------------
1 |