InnoSetup Execute Shellcode PoC
This proof of concept demonstrate how to take advantage of InnoSetup Scripting Engine to host local/remote process shellcode payload then execute.
The idea behind this concept is to demonstrate the dangerosity of (self) installers. Not only they can contain malicious programsn, they can also run native code through their scripting engines and evade AV detections because of their natural aspect.
The most difficult part was to understand how to use pointers/refs. Basically from this example, it is possible to create any kind of Malware from scratch (even more complex ones). Feel free to try, if you have any technical questions, feel free to ask for some help.
Read more...
This code snippet demonstrate how Malware authors take advantage of certain Windows API's to detect the presence of Windows Services that might indicate the presence of Virtualization Technologies and/or Sandbox in order to adapt their behavior and escape detection.
Read more...This technique is often used by Malware to hide their presence on system after execution. The application self-delete after the end of its execution. The best method to archive a such goal is through process injection.
Read more...ADS (Alternate Data Stream) is a channel often abused by Malware authors to hide files by abusing the property of NTFS File Systems.
It is mainly used to store: additional payloads, collected data or settings.
An ADS file is completely hidden from explorer. In modern version of Windows, you can display ADS files using the command dir /r
or through using third part tools.
NASM Shell++ is an enhanced version of the Metasploit Framework NASM Shell.
You can edit instructions, specify bad characters and finally export your final payload in Python, C or CPP
Read more...This tool will help you to find code caves in target x86-32 bit Microsoft Windows PE files.
This tool automatically patch application entry point to redirect code execution to chosen code cave, where your payload is stored. When payload execution is over, code execution is redirected back to original program entry point.
Code Cave Helper supports main section encryption.
This tool is considered as a PoC, it was created during my preparation for OSCE Certification in order to master the art of Backdooring PE Files.
A good improvement would be to support x86-64 bit files and offer an option to create a new section instead of searching for natural code caves.
Read more...YASE (Yet Another Sub Encoder) is a tiny but efficient Sub Encoder to quickly encode your shellcode payloads and thus bypass some common restricted character while exploiting buffer overflows.
This tool will brute force any possible combination to achieve expected result. The advantage of a such approach is to have an output result that always look different.
Read more...Postgresql offer to developer the possibility to create their own plugins, often called UDF (User Defined Function).
In this paper we will demonstrate how we could take advantage of Postgresql UDF to run malicious code (in this example, shellcode) in a compromised database (Ex: through SQLi).
Notice, we must have sufficient privilege to register a new UDF. This is not always the case.
Read more...Weakness Description
Microsoft Windows suffer from a serious lack of protection in their authentication mechanism which could led in privilege escalation.
Indeed, in default installation of Windows (all version), the account lockdown policy is disabled plus authentication API's doesn't limit number of attempts per seconds which could led to a medium to fast brute-force attacks.
Using our PoC and depending of the number of cores available in the target system you could test from few thousands to dozen of thousands of password per second.
Considering that those kind of authentication API's could be used by any Windows account, even a Guest user could use the PoC to recover / crack the password of any local user and escalate his privilege.
Read more...Bellow script demonstrate how to create a very basic multithreaded web file and directory fuzzer.
It is far from being as fast as other famous web fuzzers (wfuzz, dirb, gobuster etc..) but it is at least a good start to understand how to create yours.
#!/bin/python3
'''
-= Just a web fuzzer example =-
(@DarkCoderSc)
Dependencies:
- pip install progressbar2
'''
import requests
import progressbar
from multiprocessing import Pool
from multiprocessing.dummy import Pool as ThreadPool
from multiprocessing import Lock
import argparse
#
# Acquire parameters
#
parser = argparse.ArgumentParser(description="Just a web fuzzer example")
parser.add_argument('-u', '--url', action="store", dest="base_url", required=True, help="Target base URL to fuzz (ex: http://example.com/")
parser.add_argument('-w', '--wordlist', action="store", dest="wordlist_file", metavar="in-file", type=argparse.FileType('r'), required=True, help="Plain text wordlist file location.")
parser.add_argument('-x', '--extensions', action="store", dest="extensions", nargs='*', required=False, help="Append file extension at the end of each candidates (ex: .php .php5 .html .html5)")
try:
argv = parser.parse_args()
except IOError:
parser.error()
#
# Log Defs
#
def success(message):
print("[\033[32mOK\033[39m] " + message)
def fail(message):
print("[\033[31mKO\033[39m] " + message)
def debug(message):
print("[\033[33m!!\033[39m] " + message)
#
# Fuzzer
#
def fuzz(args):
lock = args[0]
pbar = args[2]
global base_url
target_url = base_url + args[1]
req = requests.head(target_url)
status = req.status_code
message = "{} - {}".format(status, target_url)
if (status == 200):
success(message)
elif (status != 404):
debug(message)
lock.acquire()
try:
global progress
progress += 1
pbar.update(progress)
finally:
lock.release()
return
base_url = argv.base_url
if not base_url.endswith("/"):
base_url += "/"
with open(argv.wordlist_file.name, "r", errors="ignore") as file:
candidates = file.readlines()
widgets = [
' [', progressbar.Timer(), '] ',
progressbar.Bar(),
' (', progressbar.ETA(), ') ',
]
ext_count = 1
if argv.extensions:
ext_count = len(argv.extensions) +1
pbar = progressbar.ProgressBar(maxval=(len(candidates) * ext_count), widgets=widgets, redirect_stdout=True)
progress = 0
pbar.start()
try:
pool = ThreadPool()
try:
lock = Lock()
for index, candidate in enumerate(candidates):
candidate = candidate.strip()
if not candidate:
continue
pool.map(fuzz, [[lock, candidate, pbar]])
if (ext_count > 1):
for extension in argv.extensions:
pool.map(fuzz, [[lock, (candidate + extension), pbar]])
finally:
pool.close()
pool.join()
finally:
pbar.finish()
Read more...