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

sslscan - tests SSL/TLS enabled services to discover supported cipher suites

$
0
0

This is a fork of ioerror's version of sslscan (the original readme of which is included below). Changes are as follows:
  • Highlight SSLv2 and SSLv3 ciphers in output.
  • Highlight CBC ciphers on SSLv3 (POODLE).
  • Highlight 3DES and RC4 ciphers in output.
  • Highlight PFS+GCM ciphers as good in output.
  • Highlight NULL (0 bit), weak (<40 bit) and medium (40 < n <= 56) ciphers in output.
  • Highlight anonymous (ADH and AECDH) ciphers in output (purple).
  • Hide certificate information by default (display with --get-certificate ).
  • Hide rejected ciphers by default (display with --failed ).
  • Added TLSv1.1 and TLSv1.2 support (merged from twwbond/sslscan).
  • Compiles if OpenSSL does not support SSLv2 ciphers (merged from digineo/sslscan).
  • Supports IPv6 hostnames (can be forced with --ipv6 ).
  • Check for TLS compression (CRIME, disable with --no-compression ).
  • Disable cipher suite checking --no-ciphersuites .
  • Disable coloured output --no-colour .
  • Removed undocumented -p output option.
  • Added check for OpenSSL HeartBleed (CVE-2014-0160, disable with --no-heartbleed ).
  • Flag certificates signed with MD5 or SHA-1, or with short (<2048 bit) RSA keys.
  • Support scanning RDP servers with --rdp (credit skettler).
  • Added option to specify socket timeout.
  • Added option for static compilation (credit dmke).
  • Added --sleep option to pause between requests.
  • Disable output for anything than specified checks --no-preferred .
  • Determine the list of CAs acceptable for client certificates --show-client-cas .
  • Experimental build support on OSX (credit MikeSchroll).
  • Flag some self-signed SSL certificates.
  • Experimental Windows support (credit jtesta).
  • Display EC curve names and DHE key lengths with OpenSSL >= 1.0.2 --no-cipher-details .
  • Flag weak DHE keys with OpenSSL >= 1.0.2 --cipher-details .
  • Flag expired certificates.
  • Flag TLSv1.0 ciphers in output as weak.
  • Experimental OSX support (static building only).
  • Support for scanning PostgreSQL servers (credit nuxi).
  • Check for TLS Fallback SCSV support.
  • Added StartTLS support for LDAP --starttls-ldap .
  • Added SNI support --sni-name (credit Ken).

Building on Windows
Thanks to a patch by jtesta, sslscan can now be compiled on Windows. This can either be done natively or by cross-compiling from Linux. See INSTALL for instructions.
Note that sslscan was originally written for Linux, and has not been extensively tested on Windows. As such, the Windows version should be considered experimental.
Pre-build cross-compiled Windows binaries are available on the GitHub Releases Page .

Building on OS X
There is experimental support for statically building on OS X, however this should be considered unsupported. You may need to install any dependencies required to compile OpenSSL from source on OS X. Once you have, just run:
make static

OpenSSL issues

Statically linking a custom OpenSSL build
It is possible to ignore the OpenSSL system installation and ship your own version. Although this results in a more resource-heavy sslscan binary (file size, memory consumption, etc.), this allows to enable both SSLv2 and SSLv3 ciphers. In comparison to the method of repackaging the Debian build, this custom OpenSSL build won't affect other tools on the same system, as they would use the version packaged by the distro's maintainers.
To compile your own OpenSSL version, you'll probably need to install the OpenSSL build dependencies:
apt-get install build-essential git zlib1g-dev
apt-get build-dep openssl
then run
make static
which will clone the OpenSSL repository , and configure/compile/test OpenSSL prior to compiling sslscan .
Please note: Out of the box, OpenSSL cannot compiled with clang without further customization (which is not done by the provided Makefile ). For more information on this, see Modifying Build Settings in the OpenSSL wiki.
You can verify whether you have a statically linked OpenSSL version, if
./sslscan --version
looks a bit like
    1.x.y-...-static
OpenSSL 1.1.0-dev xx XXX xxxx
(pay attention to the -static suffix and the 1.1.0-dev OpenSSL version).

Building on Kali
Kali now ships with a statically built version of sslscan which supports SSLv2.
The package can be found in the Kali Git Repository .
If for whatever reason you can't install this package, follow the instructions above for statically building against OpenSSL.

Building on Debian
It is recommended that you statically build sslscan using the instructions listed above. If this is not an option and you want to compile your system OpenSSL with support for legacy protocols such as SSLv2 and SSLv3 then follow the instructions below.
Note that many modern distros (including Debian) ship with a version of OpenSSL that disables support for SSLv2 ciphers. If sslscan is compiled on one of these distros, it will not be able to detect SSLv2.
This issue can be resolved by rebuilding OpenSSL from source after removing the patch that disables SSLv2 support.
The build_openssl_debian.sh script automates this process for Debian systems. It has been tested on Debian Squeeze/Wheezy; it may work on other Debian based distros, but has not been tested. The built version of OpenSSL will be installed using dpkg .
If it is not possible to rebuild OpenSSL, sslscan will still compile (thanks to a patch from digineo/sslscan , based on the debian patch). However, a warning will be displayed in the output to notify the user that SSLv2 ciphers will not be detected.



Lobotomy - Android Reverse Engineering

$
0
0

Lobotomy is a command line based Android reverse engineering tool. What is in the repo, is currently in development. You should assume nothing works as expected until the official 2.0 release is finished.

Version Development
Author Benjamin Watson (rotlogix)

Features
Feature Description
Components Enumerate AndroidManifest.xml components
Permission Enumerate declared and used AndroidManifest.xml permissions
Strings List and search for strings within the target application
AttackSurface Enumerate the target Application's attack surface through parsing the AndroidManifest.xml
Surgical Find specific Android API usage throughout the application
Interact Drop into an IPython session to analyze the target application in a more granular fashion
UI A terminal based interface for navigating an application's class tree
Decompile Decompile the target application with Apktool
Debuggable Convert the target application into being debuggable when installed on a device
Dextra Wrapper around dextra for dumping odex and oat files
Socket Find local and listening sockets on a target Android device

Building

OSX

Building Requirements for python-adb
brew install openssl
brew install swig
env LDFLAGS="-L$(brew --prefix openssl)/lib" \
CFLAGS="-I$(brew --prefix openssl)/include" \
SWIG_FEATURES="-cpperraswarn -includeall -I$(brew --prefix openssl)/include" \
Create a Python Virtual Environment for Lobotomy
virtualenv -p /usr/bin/python2.7 lobotomy
cd lobotomy/
source bin/activate
Install the PIP Requirements
pip install -r requirements
Install Androguard
cd core/include/androguard
python setup.py install

Running

OSX
python lobotomy.py


: : :
t#, t#, t#,
i ;##W. . ;##W. ;##W.
LE :#L:WE Ef. :#L:WE GEEEEEEEL :#L:WE .. : f. ;WE.
L#E .KG ,#D E#Wi .KG ,#D ,;;L#K;;. .KG ,#D ,W, .Et E#, i#G
G#W. EE ;#f E#K#D: EE ;#f t#E EE ;#f t##, ,W#t E#t f#f
D#K. f#. t#iE#t,E#f. f#. t#i t#E f#. t#i L###, j###t E#t G#i
E#K. :#G GK E#WEE##Wt:#G GK t#E :#G GK .E#j##, G#fE#t E#jEW,
.E#E. ;#L LW. E##Ei;;;;.;#L LW. t#E ;#L LW. ;WW; ##,:K#i E#t E##E.
.K#E t#f f#: E#DWWt t#f f#: t#E t#f f#: j#E. ##f#W, E#t E#G
.K#D f#D#; E#t f#K; f#D#; t#E f#D#; .D#L ###K: E#t E#t
.W#G G#t E#Dfff##E, G#t t#E G#t :K#t ##D. E#t E#t
:W##########Wt t jLLLLLLLLL; t fE t ... #G .. EE.
:,,,,,,,,,,,,,. : j t

(lobotomy)
See the docs for more information.


Fluxion 0.23 - WPA/WPA2 Security Hacked Without Brute Force

$
0
0

Fluxion is a remake of linset by vk496 with (hopefully) less bugs and more functionality. It's compatible with the latest release of Kali (rolling). Latest builds (stable) and (beta) can be found here here . If you're new, or just don't understand much about the project, have a look at the wiki . The attack is mostly manual, but experimental versions will automatically handle most functionality from the stable releases.

"Clients are not automatically connected to the fake access point"
This is a social engineering attack and it's pointless to drag clients in automatically. The script relies on the fact that a user should be present in order to enter the wireless credentials.

"There's no Internet connectivity in the fake access point"
There shouldn't be one. All of the traffic is being sinkholed to the built in captive portal via a fake DNS responder in order to capture the credentials.

"Fake sites don't work"
There might be a problem with lighttpd. The experimental version is tested on lighttpd 1.439-1, anything neweer may break functionality. If you have problems, please use the stable version. For more information check this fix out.

"Experimental menu is not responsive"
In the experimental version it will automatically check the handshake. I will fix the menu shortly. If you need a GUI, use the stable version (which doesn't automatically control handshakes).

"I need to sign in (on Android)"
This is how the script works. The fake captive portal is set up by the script itself to collect the credentials. Don't freak, it's al okay.

"The MAC address of the fake access point differs from the original"
The MAC address of the fake access point differs by one octet from the original in order to prevent fluxion deauthenticating clients from itself during the session.

"The redirection doesn't work for HTTPS websites"
HTTPS is not currently supported.

Updates
If you want to submit a feature, do so by labeling your issue as an "enhancement" or submit a PR. I don't have enough time to make daily changes to fluxion, sorry.

Included dependency versions
  1. Aircrack : 1:1.2-0~rc4-0parrot0
  2. Lighttpd : 1.439-1
  3. Hostapd : 1:2.3-2.3 If you want to compare this type dpkg -l | grep "name"

Changelog
Fluxion gets weekly updates with new features, improvements and bugfixes. Be sure to check out the changelog here .

How it works
  • Scan the networks.
  • Capture a handshake (can't be used without a valid handshake, it's necessary to verify the password)
  • Use WEB Interface *
  • Launch a FakeAP instance to imitate the original access point
  • Spawns a MDK3 process, which deauthenticates all users connected to the target network, so they can be lured to connect to the FakeAP and enter the WPA password.
  • A fake DNS server is launched in order to capture all DNS requests and redirect them to the host running the script
  • A captive portal is launched in order to serve a page, which prompts the user to enter their WPA password
  • Each submitted password is verified by the handshake captured earlier
  • The attack will automatically terminate, as soon as a correct password is submitted

Requirements
A Linux-based operating system. We recommend Kali Linux 2 or Kali 2016.1 rolling. Kali 2 & 2016 support the latest aircrack-ng versions. An external wifi card is recommended.

Credits
  1. Deltax - Fluxion main developer
  2. Strasharo - contributor
  3. l3op - contributor
  4. dlinkproto - contributor
  5. vk496 - developer of linset
  6. ApatheticEuphoria - @WPS-SLAUGHTER,Bruteforce Script,Help with Fluxion
  7. Derv82 - @Wifite/2
  8. Princeofguilty - @webpages
  9. Photos for wiki @ http://www.kalitutorials.net
  10. Ons Ali @wallpaper

Useful links
  1. Wifislax
  2. Kali Linux
  3. linset
  4. ares
  5. Closeme

Disclaimer
Fluxion is intended to be used for legal security purposes only, and you should only use it to protect networks/hosts you own or have permission to test. Any other use is not the responsibility of the developer(s). Be sure that you understand and are complying with the Fluxion licenses and laws in your area. In other words, don't be stupid, don't be an asshole, and use this tool responsibly and legally.


Parrot Security 3.3 - Security GNU/Linux distribution designed with cloud pentesting and IoT security in mind

$
0
0

Security GNU/Linux distribution designed with cloud pentesting and IoT security in mind.

It includes a full portable laboratory for security and digital forensics experts, but it also includes all you need to develop your own softwares or protect your privacy with anonymity and crypto tools.

Details

Security

Parrot Security includes a full arsenal of security oriented tools to perform penetration tests, security audits and more. With a Parrot usb drive in your pocket you will always be sure to have all you need with you.

Privacy

Parrot includes by default TOR, I2P, anonsurf, gpg, tccf, zulucrypt, veracrypt, truecrypt, luks and many other tecnologies designed to defend your privacy and your identity.

Development

If you need a comfortable environment with updated frameworks and useful libraries already installed, Parrot will amaze you as it includes a full development-oriented environment with some powerful editors and IDEs pre-installed and many other tools installable from our repository.

Features

System Specs
  • Debian GNU/Linux 9 (stretch)
  • Custom hardened Linux 4.8 kernel
  • Rolling release updates
  • Powerful worldwide mirror servers
  • High hardware compatibility
  • Community-driven development
  • free(libre) and open source project

System Requirements
  • CPU: at least 1Ghz dual core cpu
  • ARCH: 32bit, 64bit and ARMhf
  • RAM: minimum 256Mb - 2048Mb suggested
  • GPU: No graphic acceleration required
  • STORAGE lite/core: 4GB / 8GB
  • STORAGE Full: 16GB
  • BOOT: Legacy bios or UEFI

Cloud

Cloud Pentesting

Parrot Cloud is a special edition of our OS specifically designed for servers, it consists on a lightweight parrot system without graphic interfaces, wireless and forensic tools and any other tools that can be considered useless in a remote-controlled virtual environment.

Concept

The idea of Parrot Cloud is to have a VPS or a dedicated server with a special operating system full of useful security tools, neither relying all the dirty work to your local machine nor relying the security of your confidential data to a 3rd party provider. It can also be used to store private files (preferably encrypted), scan targets in the background and other stuff that you don't need to do with your own machines, allowing you to go everywhere you want with just a Parrot live USB and to do great penetration tests without having confidential data physically with you. 

Cryptography


Parrot includes many cryptographic softwares which are extremely useful when it comes to protect your confidential data and defend your privacy.

Parrot includes several cryptographic front-ends to work both with symmetric and asymmetric encryption, infact it natively supports volumes encryption with LUKS, TrueCrypt, VeraCrypt and the hidden TrueCrypt/VeraCrypt volumes with nested algorythms support.

The whole system can be installed inside an encrypted partition to protect your computer in case of theft.

Another swiss army knife of your privacy is GPG, the GNU Privacy Guard, an extremely powerful PGP software that lets you create a private/public pair of keys to apply digital signatures to your messages and to allow other people to send you encrypted messages that only your private key can decrypt, in can also handle multiple identities and subkeys, and its power resides in its ring of trust as PGP users can sign each other's keys to make other people know if a digital identity is valid or not.

Even our software repository is digitally signed by GPG, and the system automatically verifies if an update was altered or compromised and it refuses to upgrade or to install new software if our digital signature is not found or not valid.

Privacy


Your privacy is the most valuable thing you have in your digital life and the whole Parrot Team is exaggeratedly paranoid when it comes to users privacy, infact our system doesn't contain tracking systems, and it is hardened in deep to protect users from prying eyes.

Parrot has developed and implemented several tricks and softwares to achieve this goal, and AnonSurf is one of the most important examples, it is a software designed to start TOR and hijack all the internet traffic made by the system through the TOR network, we have also modified the system to make it use DNS servers different from those offered by your internet provider.

Parrot also includes torbrowser, torchat and other anonymous services, like I2P, a powerful alternative to TOR.

Programming


The main goal of an environment designed by hackers for hackers is the possibility to change it, adapt it, transform it and use it as a development platform to create new things, this is why Parrot comes out of the box with several tools for developers such as compilers, disassemblers, IDEs, comfortable editors and powerful frameworks.

Parrot includes QTCreator as its main C, C++ and Qt framework. Another very useful tool is Geany, a lightweight and simple IDE which supports a huge amount of programming languages, while we also include Atom, the opensource editor of the future developed by GitHub, and many compilers and interpreters with their most important libraries are pre-installed and ready to use.


And of course many other editors, development softwares and libraries are available through our software repository where we keep all the development tools always updated to their most cutting edge but reliable version. 

Changelog

From 3.2 to 3.3 (25/12/2016)
  • include linux 4.8 kernel
  • fix touchpad/multitouch support
  • fix mismatching kernel installer
  • update anonsurf
  • fix minor MATE bugs
  • include GCC 6.2
  • update metasploit-framework 4.13
  • switch to php 7
  • upgrade most of the tools to their latest version

Telegram BBBot - Telegram Bug Bounty Bot

$
0
0

Telegram Bug Bounty Bot
https://telegram.me/bug_bounty_channel

History
  • This bot adopted special for deploying to Heroku
  • General purposes of this got - "Be helpful for infosec community!"
  • Bot use https://github.com/maddevsio/bbcrawler for fetching information
  • Used heroku https://github.com/heroku/go-getting-started as a template for project
  • For bot used free account on heroku.com and firebase.com

Purpose
  • Purposes of bot:
    • "Deliver information as fast as possible!"
    • "Be helpful for infosec community"

Architecture
  • For web server used GIN
    • github.com/gin-gonic/gin
  • For Bot functionality used telegram-bot-api.v4
    • gopkg.in/telegram-bot-api.v4

Bot configuration
  • TELEGRAM_BBBOT_TOKEN - Telegram Api token received from @BotFather
  • TELEGRAM_BBBOT_URL - Webhook url to bot public web address
  • PORT - Standard heroku ENV variable for port number
  • TELEGRAM_BBBOT_FIREBASE_TOKEN - Firebase database token
  • TELEGRAM_BBBOT_FIREBASE_URL - Url to firebase project
  • TELEGRAM_BBBOT_HO_SEARCH_URL - HackerOne search url (crawler)
  • TELEGRAM_BBBOT_CHANNEL - Public channel identifier, for example @some_channel_name
  • TELEGRAM_BBBOT_HOST - Public bot host url for ping purposes (for disabling sleeping functionality after 30 min of inactivity)
  • TELEGRAM_BBBOT_H1_HACK_SEARCH_URL - HackerOne hacktivity url (crawler)
  • TELEGRAM_BBBOT_BUGCROWD_NEW_PROG_URL - BugCrowd url for crawling new programs (crawler)

Bot workflow
  • Bot started
  • Fetching data from firebase (synchronising)
  • Crawling programs from hackerone.com (in parallel)
  • Crawling hacktivity from hackerone.com (in parallel)
  • Crawling programs from bugcrowd.com (in parallel)
  • Determining new data from all crawled information (in parallel)
  • Publishing data to telegram channel from ENV variable
  • Note: If instance of bot at heroku.com restarted all data restored from firebase storage.

Commix 1.6 - Automated All-In-One OS Command Injection And Exploitation Tool

$
0
0


Commix (short for [ comm ]and [ i ]njection e[ x ]ploiter) is an automated tool written by Anastasios Stasinopoulos ( @ancst ) that can be used from web developers, penetration testers or even security researchers in order to test web-based applications with the view to find bugs, errors or vulnerabilities related to command injection attacks. By using this tool, it is very easy to find and exploit a command injection vulnerability in a certain vulnerable parameter or HTTP header.

Requirements
Python version 2.6.x or 2.7.x is required for running this program.

Installation
Download commix by cloning the Git repository:
git clone https://github.com/commixproject/commix.git commix
Commix comes packaged on the official repositories of the following Linux distributions, so you can use the package manager to install it!
Commix also comes as a plugin , on the following penetration testing frameworks:

Supported Platforms
  • Linux
  • Mac OS X
  • Windows (experimental)

Screenshots




Usage
To get a list of all options and switches use:
python commix.py -h
Q : Where can I check all the available options and switches?
A : Check the ' usage ' wiki page.

Usage Examples
Q : Can I get some basic ideas on how to use commix?
A : Just go and check the ' usage examples ' wiki page, where there are several test cases and attack scenarios.

Upload Shells
Q : How easily can I upload web-shells on a target host via commix?
A : Commix enables you to upload web-shells (e.g metasploit PHP meterpreter) easily on target host. For more, check the ' upload shells ' wiki page.

Modules Development
Q : Do you want to increase the capabilities of the commix tool and/or to adapt it to our needs?
A : You can easily develop and import our own modules. For more, check the ' module development ' wiki page.

Command Injection Testbeds
Q : How can I test or evaluate the exploitation abilities of commix?
A : Check the ' command injection testbeds ' wiki page which includes a collection of pwnable web applications and/or VMs (that include web applications) vulnerable to command injection attacks.

Exploitation Demos
Q : Is there a place where I can check for demos of commix?
A : If you want to see a collection of demos, about the exploitation abilities of commix, take a look at the ' exploitation demos ' wiki page.

Bugs and Enhancements
Q : I found a bug / I have to suggest a new feature! What can I do?
A : For bug reports or enhancements, please open an issue here .

Presentations and White Papers
Q : Is there a place where I can find presentations and/or white papers regarding commix?
A : For presentations and/or white papers published in conferences, check the ' presentations ' wiki page.

Support and Donations
Q : Except for tech stuff (bug reports or enhancements) is there any other way that I can support the development of commix?
A : Sure! Commix is the outcome of many hours of work and total personal dedication. Feel free to ' donate ' via PayPal to donations@commixproject.com and instantly prove your feelings for it! :).


Hakku Framework - Simple Penetration Testing Framework

$
0
0

Hakku is simple framework that has been made for penetration testing tools. Hakku framework offers simple structure, basic CLI, and useful features for penetration testing tools developing. Hakku is on early stages and may be unstable, so please download the released versions from github or sourceforge, don't just clone github repository except you don't want stability, you want to try out latest features, or you just want to develop Hakku. Hakku is under MIT license, in other words you can do what you ever want with the source code.

What will i need to run Hakku framework?
Hakku framework is written in python 3, and developed mainly on Arch Linux. So you should get Hakku framework running with Linux based operating system, python 3.5, and the dependencies.

How i can get started?
If you are new to Hakku framework you should look at the official wiki.

OS support
  • Linux supported, and developed on/for linux
  • OS X support not planned
  • Windows support not planned

Basic features
Hakku framework features basic CLI to load up and run penetration testing tools, simple scripting interface, and python api.

Modules
total count of modules: 22
  • apache_users
  • arp_dos
  • arp_spoof
  • bluetooth_pod
  • cloudflare_resolver
  • dir_scanner
  • dns_spoof
  • email_bomber
  • hostname_resolver
  • mac_spoof
  • mitm
  • network_kill
  • pma_scanner
  • port_scanner
  • proxy_scout
  • whois
  • web_killer
  • web_scout
  • wifi_jammer
  • zip_cracker
  • rar_cracker
  • wordlist_gen

Dependencies
Hakku framework itself doesn't need nothing more than python 3.5, but it's network scanner requires tcpdump. Hakku includes all python dependencies so you don't have to install them. All module dependencies are listed below. ethtool, aircrack-ng, ettercap-text-only, dsniff, xterm, driftnet, tcpdump

Screenshots



Web pages

Contact
If you do have any questions etc. about Hakku Framework, then i don't mind if you send me email.

BARF - A multiplatform open source Binary Analysis and Reverse engineering Framework

$
0
0

The analysis of binary code is a crucial activity in many areas of the computer sciences and software engineering disciplines ranging from software security and program analysis to reverse engineering. Manual binary analysis is a difficult and time-consuming task and there are software tools that seek to automate or assist human analysts. However, most of these tools have several technical and commercial restrictions that limit access and use by a large portion of the academic and practitioner communities. BARF is an open source binary analysis framework that aims to support a wide range of binary code analysis tasks that are common in the information security discipline. It is a scriptable platform that supports instruction lifting from multiple architectures, binary translation to an intermediate representation, an extensible framework for code analysis plugins and interoperation with external tools such as debuggers, SMT solvers and instrumentation tools. The framework is designed primarily for human-assisted analysis but it can be fully automated.

The BARF project includes BARF and related tools and packages. So far the project is composed of the following items:
  • BARF : A multiplatform open source Binary Analysis and Reverse engineering Framework
  • PyAsmJIT : A JIT for the Intel x86_64 and ARM architecture.
  • Tools built upon BARF :
    • BARFgadgets : Lets you search , classifiy and verify ROP gadgets inside a binary program.
    • BARFcfg : Lets you recover the control-flow graph of the functions of a binary program.
    • BARFcg : Lets you recover the call graph of the functions of a binary program.
For more information, see:
  • BARF: A multiplatform open source Binary Analysis and Reverse engineering Framework (Whitepaper) [ en ]
  • BARFing Gadgets (ekoparty2014 presentation) [ es ]
Current status:
Latest Release v0.3
URL https://github.com/programa-stic/barf-project/releases/tag/v0.3
Change Log https://github.com/programa-stic/barf-project/blob/v0.3/CHANGELOG.md
All packages were tested on Ubuntu 16.04 (x86_64).

BARF
BARF is a Python package for binary analysis and reverse engineering. It can:
  • Load binary programs in different formats ( ELF , PE , etc),
  • It supports the Intel x86 architecture for 32 and 64 bits,
  • It supports the ARM architecture for 32 bits,
  • It operates on an intermediate language ( REIL ) thus all analysis algorithm are architecture-agnostic,
  • It has integration with Z3 and CVC4 SMT solvers which means that you can express fragments of code as formulae and check restrictions on them.
It is currently under development .

Installation
BARF depends on the following SMT solvers:
  • Z3 : A high-performance theorem prover being developed at Microsoft Research.
  • CVC4 : An efficient open-source automatic theorem prover for satisfiability modulo theories (SMT) problems.
The following command installs BARF on your system:
$ sudo python setup.py install
You can also install it locally:
$ sudo python setup.py install --user

Notes
  • Only one SMT solver is needed in order to work. You may choose between Z3 and CVC4 or install both. You can use the barf-install-solver.sh script which downloads and install both solver.
  • To run some tests you need to install PyAsmJIT first.

Quickstart
This is a very simple example which shows how to open a binary file and print each instruction with its translation to the intermediate language ( REIL ).
from barf import BARF

# Open binary file.
barf = BARF("examples/bin/x86/branch1")

# Print assembly instruction.
for addr, asm_instr, reil_instrs in barf.translate():
print("0x{addr:08x} {instr}".format(addr=addr, instr=asm_instr))

# Print REIL translation.
for reil_instr in reil_instrs:
print("{indent:11s} {instr}".format(indent="", instr=reil_instr))
We can also recover the CFG and save it to a .dot file.
# Recover CFG.
cfg = barf.recover_cfg()

# Save CFG to a .dot file.
cfg.save("branch1_cfg")
We can check restrictions on code using a SMT solver. For instance, suppose you have the following code:
 80483ed:       55                      push   ebp
80483ee: 89 e5 mov ebp,esp
80483f0: 83 ec 10 sub esp,0x10
80483f3: 8b 45 f8 mov eax,DWORD PTR [ebp-0x8]
80483f6: 8b 55 f4 mov edx,DWORD PTR [ebp-0xc]
80483f9: 01 d0 add eax,edx
80483fb: 83 c0 05 add eax,0x5
80483fe: 89 45 fc mov DWORD PTR [ebp-0x4],eax
8048401: 8b 45 fc mov eax,DWORD PTR [ebp-0x4]
8048404: c9 leave
8048405: c3 ret
And you want to know what values you have to assign to memory locations ebp-0x4 , ebp-0x8 and ebp-0xc in order to obtain a specific value in eax register after executing the code.
First, we add the instructions to the analyzer component.
from barf import BARF

# Open ELF file
barf = BARF("examples/bin/x86/constraint1")

# Add instructions to analyze.
for addr, asm_instr, reil_instrs in barf.translate(0x80483ed, 0x8048401):
for reil_instr in reil_instrs:
barf.code_analyzer.add_instruction(reil_instr)
Then, we generate expressions for each variable of interest
# Get smt expression for eax and ebp registers
eap = barf.code_analyzer.get_register_expr("eax")
ebp = barf.code_analyzer.get_register_expr("ebp")

# Get smt expressions for memory locations (each one of 4 bytes)
a = barf.code_analyzer.get_memory_expr(ebp-0x8, 4)
b = barf.code_analyzer.get_memory_expr(ebp-0xc, 4)
c = barf.code_analyzer.get_memory_expr(ebp-0x4, 4)
And add the desired restrictions on them.
# Set range for variables
barf.code_analyzer.set_preconditions([a >= 2, a <= 100])
barf.code_analyzer.set_preconditions([b >= 2, b <= 100])

# Set desired value for the result
barf.code_analyzer.set_postcondition(c == 13)
Finally, we check is the restrictions we establish can be resolved.
# Check satisfiability.
if barf.code_analyzer.check() == 'sat':
print("SAT!")

# Get concrete value for expressions.
eax_val = barf.code_analyzer.get_expr_value(eax)
a_val = barf.code_analyzer.get_expr_value(a)
b_val = barf.code_analyzer.get_expr_value(b)
c_val = barf.code_analyzer.get_expr_value(c)

# Print values.
print("eax : 0x{0:%08x} ({0})".format(eax_val))
print("ebp : 0x{0:%08x} ({0})".format(ebp_val))
print(" a : 0x{0:%08x} ({0})".format(a_val))
print(" b : 0x{0:%08x} ({0})".format(b_val))
print(" c : 0x{0:%08x} ({0})".format(c_val))
else:
print("UNSAT!")
You can see these and more examples in the examples directory.

Overview
The framework is divided in three main components: core , arch and analysis .

Core
This component contains essential modules:
  • REIL : Provides definitions for the REIL language. It, also, implements an emulator and a parser .
  • SMT : Provides means to interface with Z3 SMT solver. Also, it provides functionality to translate REIL instructions to SMT expressions.
  • BI : The Binary Interface module is responsible for loading binary files for processing (it uses [PEFile] and [PyELFTools].)

Arch
Each supported architecture is provided as a subcomponent which contains the following modules.
  • Architecture : Describes the architecture, i.e., registers, memory address size.
  • Translator : Provides translators to REIL for each supported instruction.
  • Disassembler : Provides disassembling functionalities (it uses Capstone.)
  • Parser : Transforms instruction in string to object form (provided by the Instruction module.)

Analysis
So far this component consists of two modules: Control-Flow Graph , Call Graph and Code Analyzer . The first two, provides functionality for CFG and CG recovery, respectively. The latter, its a high-level interface to the SMT-solver-related functionalities.

Directory Structure
barf/       Framework's main directory.
doc/ Documentation.
examples/ Basic example scripts that show various functionalities.
scripts/ Installation scripts.
tests/ BARF package tests.
tools/ Tools build upon BARF.

Notes
SMT solver interfacing is provided by the file core/smt/smtlibv2.py taken from PySymEmu .

Tools

BARFgadgets
BARFgadgets is a Python script built upon BARF that lets you search , classifiy and verify ROP gadgets inside a binary program. The search stage finds all ret -, jmp - and call -ended gadgets inside the binary. The classification stage classifies previously found gadgets according to the following types:
  • No-Operation,
  • Move Register,
  • Load Constant,
  • Arithmetic/Logical Operation,
  • Load Memory,
  • Store Memory,
  • Arithmetic/Logical Load,
  • Arithmetic/Logical Store and
  • Undefined.
This is done through instruction emulation. Finally, the verification stage consists of using a SMT solver to verify the semantic assigned to each gadget in the second stage.
usage: BARFgadgets [-h] [--version] [--bdepth BDEPTH] [--idepth IDEPTH] [-u]
[-c] [-v] [-o OUTPUT] [-t] [--sort {addr,depth}] [--color]
[--show-binary] [--show-classification]
filename

Tool for finding, classifying and verifying ROP gadgets.

positional arguments:
filename Binary file name.

optional arguments:
-h, --help show this help message and exit
--version Display version.
--bdepth BDEPTH Gadget depth in number of bytes.
--idepth IDEPTH Gadget depth in number of instructions.
-u, --unique Remove duplicate gadgets (in all steps).
-c, --classify Run gadgets classification.
-v, --verify Run gadgets verification (includes classification).
-o OUTPUT, --output OUTPUT
Save output to file.
-t, --time Print time of each processing step.
--sort {addr,depth} Sort gadgets by address or depth (number of
instructions) in ascending order.
--color Format gadgets with ANSI color sequences, for output
in a 256-color terminal or console.
--show-binary Show binary code for each gadget.
--show-classification
Show classification for each gadget.
For more information, see README .

BARFcfg
BARFcfg is a Python script built upon BARF that lets you recover the control-flow graph of a binary program.
usage: BARFcfg [-h] [-s SYMBOL_FILE] [-a] [-o RECOVER_ONE] [-f {graph,text}]
[-t] [-d OUTPUT_DIR] [-b] [-r]
filename

Tool for recovering CFG of a binary.

positional arguments:
filename Binary file name.

optional arguments:
-h, --help show this help message and exit
-s SYMBOL_FILE, --symbol-file SYMBOL_FILE
Load symbols from file.
-a, --recover-all Recover all functions.
-o RECOVER_ONE, --recover-one RECOVER_ONE
Recover specified function.
-f {graph,text}, --format {graph,text}
Output format.
-t, --time Print process time.
-d OUTPUT_DIR, --output-dir OUTPUT_DIR
Ouput directory.
-b, --brief Brief output.
-r, --show-reil Show REIL translation.
For more information, see README .

BARFcg
BARFcg is a Python script built upon BARF that lets you recover the call graph of a binary program.
usage: BARFcg [-h] [-s SYMBOL_FILE] [-a] [-t] filename

Tool for recovering CG of a binary.

positional arguments:
filename Binary file name.

optional arguments:
-h, --help show this help message and exit
-s SYMBOL_FILE, --symbol-file SYMBOL_FILE
Load symbols from file.
-a, --recover-all Recover all functions.
-t, --time Print process time.
For more information, see README .

PyAsmJIT
PyAsmJIT is a Python package for x86_64/ARM assembly code generation and execution.
This package was developed in order to test BARF instruction translation from x86_64/ARM to REIL. The main idea is to be able to run fragments of code natively. Then, the same fragment is translated to REIL and executed in a REIL VM. Finally, both final contexts (the one obtained through native execution and the one from emulation) are compare for differences.
For more information, see PyAsmJit .



mitmAP - Simple Tool to Create a Fake AP and Sniff Data

$
0
0

           _ _              ___  ______ 
(_) | / _ \ | ___ \
_ __ ___ _| |_ _ __ ___ / /_\ \| |_/ /
| '_ ` _ \| | __| '_ ` _ \| _ || __/
| | | | | | | |_| | | | | | | | || |
|_| |_| |_|_|\__|_| |_| |_\_| |_/\_| 2.1

A python program to create a fake AP and sniff data.

new in 2.0:
  • SSLstrip2 for HSTS bypass
  • Image capture with Driftnet
  • TShark for command line .pcap capture

Features:
  • SSLstrip2
  • Driftnet
  • Tshark
  • Full featured access point, with configurable speed limit
  • mitmproxy
  • Wireshark
  • DNS Spoofing
  • Saving results to file

Requirements:
Kali Linux / Raspbian with root privileges
A wireless card and an ethernet adapter / 2 wireless card
Python3 (mitmAP will install the dependenices, you don't have to do it)

Downloading:
git clone https://github.com/xdavidhu/mitmAP

Starting:
  • Kali Linux -> "sudo python3 mitmAP.py"
  • Raspberry PI -> "sudo python3 mitmAP_rpi.py"

Important: At the first run, choose 'y' on installing dependencies and on creating the config files!


Wifijammer - Continuously Jam All Wifi Clients/Routers

$
0
0


Continuously jam all wifi clients and access points within range. The effectiveness of this script is constrained by your wireless card. Alfa cards seem to effectively jam within about a block radius with heavy access point saturation. Granularity is given in the options for more effective targeting.
Requires: python 2.7, python-scapy, a wireless card capable of injection

Usage

Simple
python wifijammer.py
This will find the most powerful wireless interface and turn on monitor mode. If a monitor mode interface is already up it will use the first one it finds instead. It will then start sequentially hopping channels 1 per second from channel 1 to 11 identifying all access points and clients connected to those access points. On the first pass through all the wireless channels it is only identifying targets. After that the 1sec per channel time limit is eliminated and channels are hopped as soon as the deauth packets finish sending. Note that it will still add clients and APs as it finds them after the first pass through.
Upon hopping to a new channel it will identify targets that are on that channel and send 1 deauth packet to the client from the AP, 1 deauth to the AP from the client, and 1 deauth to the AP destined for the broadcast address to deauth all clients connected to the AP. Many APs ignore deauths to broadcast addresses.
python wifijammer.py -a 00:0E:DA:DE:24:8E -c 2
Deauthenticate all devices with which 00:0E:DA:DE:24:8E communicates and skips channel hopping by setting the channel to the target AP's channel (2 in this case). This would mainly be an access point's MAC so all clients associated with that AP would be deauthenticated, but you can also put a client MAC here to target that one client and any other devices that communicate with it.

Advanced
python wifijammer.py -c 1 -p 5 -t .00001 -s DL:3D:8D:JJ:39:52 -d --world
  • -c , Set the monitor mode interface to only listen and deauth clients or APs on channel 1
  • -p , Send 5 packets to the client from the AP and 5 packets to the AP from the client along with 5 packets to the broadcast address of the AP
  • -t , Set a time interval of .00001 seconds between sending each deauth (try this if you get a scapy error like 'no buffer space')
  • -s , Do not deauth the MAC DL:3D:8D:JJ:39:52. Ignoring a certain MAC address is handy in case you want to tempt people to join your access point in cases of wanting to use LANs.py or a Pineapple on them.
  • -d , Do not send deauths to access points' broadcast address; this will speed up the deauths to the clients that are found
  • --world , Set the max channel to 13. In N. America the max channel standard is 11, but the rest of the world uses 13 channels so use this option if you're not in N. America

Walking/driving around
python wifijammer.py -m 10
The -m option sets a max number of client/AP combos that the script will attempt to deauth. When the max number is reached, it clears and repopulates its list based on what traffic it sniffs in the area. This allows you to constantly update the deauth list with client/AP combos who have the strongest signal in case you were not stationary. If you want to set a max and not have the deauth list clear itself when the max is hit, just add the -n option like: -m 10 -n
All options:
python wifijammer.py [-a AP MAC] [-c CHANNEL] [-d] [-i INTERFACE] [-m MAXIMUM] [-n] [-p PACKETS] [-s SKIP] [-t TIME INTERVAL]

Technical breakdown
How to kick everyone around you off wifi with python

    Steghide - Brute Force Attack to Find Hide Information and Password in a file

    $
    0
    0

    Execute a brute force attack with Steghide to file with hide information and password established.

    How it work
    Cloning this repo to your computer and typing in your terminal:
    git clone https://github.com/Va5c0/Steghide-Brute-Force-Tool.git

    To launch the script by typing:
    python steg_brute.py [option] [-f file]

    For more instructions type
    python steg_brute.py -h

    Version
    Steg Brute Force Tool V1.0


    xsscrapy - XSS/SQLi Spider

    $
    0
    0


    Fast, thorough, XSS/SQLi spider. Give it a URL and it'll test every link it finds for cross-site scripting and some SQL injection vulnerabilities. See FAQ for more details about SQLi detection.

    From within the main folder run:
    ./xsscrapy.py -u http://example.com
    If you wish to login then crawl:
    ./xsscrapy.py -u http://example.com/login_page -l loginname
    If you wish to login with HTTP Basic Auth then crawl:
    ./xsscrapy.py -u http://example.com/login_page -l loginname --basic
    If you wish to use cookies:
    ./xsscrapy.py -u http://example.com/login_page --cookie "SessionID=abcdef1234567890"
    If you wish to limit simultaneous connections to 20:
    ./xsscrapy.py -u http://example.com -c 20
    If you want to rate limit to 60 requests per minute:
    ./xsscrapy.py -u http://example.com/ -r 60
    XSS vulnerabilities are reported in xsscrapy-vulns.txt

    Dependencies
    wget -O https://bootstrap.pypa.io/get-pip.py
    python get-pip.py
    pip install -r requirements.txt
    May need additional libraries depending on OS. libxml2 libxslt zlib libffi openssl (sometimes libssl-dev)

    Tests
    • Cookies
    • User-Agent
    • Referer
    • URL variables
    • End of URL
    • URL path
    • Forms both hidden and explicit

    FAQ
    • If it gives an error : ImportError: cannot import name LinkExtractor . This means that you don't have the latest version of scrapy. You can install it using: sudo pip install --upgrade scrapy .
    • It's called XSScrapy, so why SQL injection detection too? There is overlap between dangerous XSS chars and dangerous SQL injection characters, namely single and double quotes. Detecting SQL injection errors in a response is also simple and nonCPU-intensive. So although 99% of this script is strongly geared toward high and accurate detection of XSS adding simple SQL injection detection through error message discovery is a simple and effective addition. This script will not test for blind sql injection. Error messages it looks for come straight from w3af's sqli audit plugin.

    Snuck - Automatic XSS filter bypass

    $
    0
    0

    snuck is an automated tool that can definitely help in finding XSS vulnerabilities in web applications. It is based on Selenium and supports Mozilla Firefox, Google Chrome and Internet Explorer. The approach, it adopts, is based on the inspection of the injection reflection context and relies on a set of specialized and obfuscated attack vectors for filter evasion. In addition, XSS testing is performed in-browser, a real web browser is driven in reproducing the attacker and possibly the victim's behavior.

    Description

    snuck is quite different from typical web security scanners, it basically tries to break a given XSS filter by specializing the injections in order to increase the success rate. The attack vectors are selected on the basis of the reflection context, that is the exact point where the injection falls in the reflection web page's DOM. Having access to the pages' DOM is possible through Selenium Web Driver, which is an automation framework, that allows to replicate operations in web browsers. Since many steps could be involved before an XSS filter is "activated", an XML configuration file should be filled in order to make snuck aware of the steps it needs to perform with respect to the tested web application. Practically speaking, the approach is similar to the iSTAR's one, but it focuses on one particular XSS filter.

    Download and first run

    snuck is an open-source software written in Java, released under the Apache 2.0 license, you can download the sources by using svn.
    svn checkout https://github.com/mauro-g/snuck snuck
    Once checked out, you can use the build.xml file for asking Ant to compile the source files and generate the jar file.
    cd snuck
    ant jar
    This will generate an executable jar file that is ready to run!
    You can also directly download a ready-to-run executable jar from here (released on October 2012, thus it may not work with recent browsers; this applies also in case of manual source code building, since the project is no longer under active development).
    Note: No particular prerequisites are required, in particular you just need a working JVM and Firefox installed. Furthermore, if you want to run a test with Google Chrome/Chromium, you should download the appropriate server, which is a bridge between the web browser and the driver - refer to http://code.google.com/p/chromedriver/downloads/list. A similar procedure is required for Internet Explorer too, refer to http://code.google.com/p/selenium/downloads/list. The tool has been tested with IE9 and has proven to work successfully; some issues could possibly appear with older versions of IE, but we are working to make snuck compatible with these too. Obviously since the tool is written in Java, you can run it in any platform.
    Once you downloaded/generated the jar file, you will need to become familiar with the command line options, here follow the available arguments and the correspondent description.
    > java -jar snuck.jar
    Usage: snuck [-start xmlconfigfile ] -config xmlconfigfile -report htmlreportfile [-d # ms_delay]
    [-proxy IP:port] [-chrome chromedriver ] [-ie iedriver] [-remotevectors URL] [-stop-first]
    [-reflected targetURL -p parameter_toTest] [-no-multi]

    Options :

    -start path to login use case (XML file)
    -config path to injection use case (XML file)
    -report report file name (html extension is required)
    -d delay (ms) between each injection
    -proxy proxy server (IP: port)
    -chrome perform a test with Google Chrome, instead of Firefox. It needs the path to the chromedriver
    -ie perform a test with Internet Explorer, instead of Firefox.
    Disable the built in XSS filter in advance
    -remotevectors use an up-to-date online attack vectors source instead of the local one
    -stop-first stop the test upon a successful vector is detected
    -no-multi deactivate multithreading for the reverse engineering process - a sequential approach will be adopted
    -reflected perform a reflected XSS test (without writing the XML config file)
    -p HTTP GET parameter to inject (useful if -reflected is set)
    -help show this help menu

    XSS Attack Vectors

    The tool keeps a set of XSS vectors, that you can find in the directory named payloads; this latter contains four files:
    • html_payloads. it stores HTML tags whose purpose is to generate an alert dialog window. Placeholders could be used within this set of vectors; for instance, if we have <script src=data:,%alert%></script>, then the tool will pick a javascript alert from the following attack vector set at random to be the substitute of %alert%. Something like <svg onload=%uri%> will be treated similarly, obviously the drawing will happen among the URIs vectors (see below).
    • js_alert payloads it stores many javascript approaches to trigger an alert dialog window, such as alert(1) or eval(alert(2)).
    • uri_payloads it stores malicious URIs, such as javascript:alert(1).
    • expression_alert_payloads it stores malicious expression payloads, such as expression(URL=0); in this case it is mandatory to produce a redirect to a new URL ending with "0" in order to catch whether a vulnerability exists. Unfortunately expression(alert(1)) would flood the web browser (IE), while expression(write(1)) makes the browser freeze, finally expression(alert(URL=1)) produces multiple alert dialogs and this is annoying from the web driver's perspective.

    Obviously the tester is allowed to add vectors in these sets by just adding a new line. Furthermore, it is possible to employ a remote attack vectors repository instead of the local one, this can be done by starting the tool with the -remotevectors argument. The remote repository should be a URL whose content is the directory called payloads - for instance if the repository is reachable at http://www.example.com/repository/, then the tool will look for the four payload files in http://www.example.com/repository/payloads/.


    Chromebackdoor - Backdoor C&C for Populars Browsers

    $
    0
    0

    Chromebackdoor is a pentest tool, this tool use a MITB technique for generate a windows executable ".exe" after launch run a malicious extension or script on most popular browsers, and send all DOM datas on command and control.

    VIDEO

    Require:
    • pip install crxmake
    • wine32
    Let's go
    python chromebackdoor.py


    web browser infection
    • pour rappel, infiltrer, surveiller, un système informatique sans autorisation est un délit
    • reminder, infiltrate, monitor, computer system without authorization is a crime

    KickThemOut - Kick Devices Off Your Network

    $
    0
    0

    A tool to kick devices out of your network and enjoy all the bandwidth for yourself. It allows you to select specific or all devices and ARP spoofs them off your local area network.
    Compatible with Python 2.6 & 2.7.
    Authors: Nikolaos Kamarinakis & David Schütz

    Installation
    You can download KickThemOut by cloning the Git Repo and simply installing its requirements:
    $ git clone https://github.com/k4m4/kickthemout.git

    $ cd kickthemout

    $ pip install -r requirements.txt

    Demo
    Here's a short demo:
    https://nikolaskama.me/content/images/2017/01/kickthemout_asciinema.png
    (For more demos click here )


    Disclaimer
    KickThemOut is provided as is under the MIT Licence (as stated below). It is built for educational purposes only. If you choose to use it otherwise, the developers will not be held responsible. In brief, do not use it with evil intent.



    AutoLocalPrivilegeEscalation - An automated script that download potential exploit for linux kernel from exploitdb, and compile them automatically

    $
    0
    0

    An automated script that download potential exploit for linux kernel from exploitdb, and compile them automatically
    This script is created due to Hackademics, there are so much possible exploit for that version of kernel, as a rookie OSCP student, I am not able to find out the correct exploit, also I am too lazy to test them one by one. So I hope this script can help me in the future.
    First, it search for linux pirvilege escalation from the exploitdb in local directory by searchsploit.
    Pass in the kernel version as first parameter, it lists potential exploit, and ask if you want to copy them from the local directory.

    After that, it asks if you want to compile the downloaded C file.
    Then, it will ask if you want to make a tar ball of the directory.
    And it will show the summary of the downloaded files.
    Script Environment: Kali 3.18.0 kali2
    Test result in Kali 4.0 is negative for this script, need to redesign the architecture, maybe python is more suitable to do this automation, need to think again.
    16 Mar 25 Updated with Python version of this idea, more adaptable to different kali environment and more easy to change the code in this way.
    16 Apr 30 After almost finishes with all the boxes in OSCP, I have to admit I have not use this script at all during my lab times. There is one thing I learnt from the labs, do not run exploit blindly, as exploits might cause the system to crash, or leaves your footprint in a way you cannot imagine etc. Always enumerate more and gather all the information you have to escalate. DO NOT run the exploit blindly without knowing what the exploit does.
    root@workstation:~/utilities# ./auto_priv_exploit.sh 
    [*] Usage: ./auto_priv_exploit.sh VERSION_OF_KERNEL
    root@workstation:~/utilities# ls
    auto_priv_exploit.sh
    root@workstation:~/utilities# ./auto_priv_exploit.sh 2.6
    [*] Possible Exploit

    Linux Kernel 2.4.x / 2.6.x - uselib() Local Privilege Escalation Exploit | /linux/local/895.c
    Linux Kernel 2.4 / 2.6 - bluez Local Root Privilege Escalation Exploit (3) | /linux/local/926.c
    Postfix <= 2.6-20080814 - (symlink) Local Privilege Escalation Exploit | /linux/local/6337.sh
    Linux Kernel < 2.6.29 - exit_notify() Local Privilege Escalation Exploit | /linux/local/8369.sh
    Linux Kernel 2.6 - UDEV Local Privilege Escalation Exploit | /linux/local/8478.sh
    Linux Kernel 2.6 UDEV < 141 - Local Privilege Escalation Exploit | /linux/local/8572.c
    Linux Kernel 2.6.x - ptrace_attach Local Privilege Escalation Exploit | /linux/local/8673.c
    Linux Kernel <= 2.6.34-rc3 ReiserFS xattr - Privilege Escalation | /linux/local/12130.py
    Linux Kernel < 2.6.36-rc1 CAN BCM - Privilege Escalation Exploit | /linux/local/14814.c
    Linux Kernel < 2.6.36-rc4-git2 - x86_64 ia32syscall Emulation Privilege Escalation | /linux/local/15023.c
    Linux Kernel <= 2.6.36-rc8 - RDS Protocol Local Privilege Escalation | /linux/local/15285.c
    Linux Kernel <= 2.6.37 - Local Privilege Escalation | /linux/local/15704.c
    Linux Kernel < 2.6.37-rc2 - ACPI custom_method Privilege Escalation | /linux/local/15774.c
    Linux Kernel 2.6.34 - CAP_SYS_ADMIN x86 - Local Privilege Escalation Exploit | /linux/local/15916.c
    Linux Kernel < 2.6.34 - CAP_SYS_ADMIN x86 & x64 - Local Privilege Escalation Exploit (2) | /linux/local/15944.c
    Linux Kernel < 2.6.36.2 - Econet Privilege Escalation Exploit | /linux/local/17787.c
    Linux Kernel 2.6.17 - Sys_Tee Local Privilege Escalation Vulnerability | /linux/local/29714.txt
    Linux Kernel 2.6.x - Ptrace Local Privilege Escalation Vulnerability | /linux/local/30604.c
    Linux Kernel 2.6.x - 'pipe.c' Local Privilege Escalation Vulnerability (1) | /linux/local/33321.c
    Linux Kernel 2.6.x - pipe.c Local Privilege Escalation Vulnerability (2) | /linux/local/33322.c
    Linux Kernel 2.6.x - Ext4 - 'move extents' ioctl Local Privilege Escalation Vulnerability | /linux/local/33395.txt
    Linux Kernel 2.6.x - 'fasync_helper()' Local Privilege Escalation Vulnerability | /linux/local/33523.c
    [*] Do you wish to download all the exploit script to current directory and compile if possible?
    1) Yes
    2) No
    #? 1
    [*] The base directory is /usr/share/exploitdb/platforms
    [*] Do you wish to compile all the exploit script written in C?
    1) Yes
    2) No
    #? 1
    **************************************************

    [*] Successfully Compiled 9 executable located in linux_2.6
    [*] Do you want to make a tar ball of the linux_2.6? (For convinient file transfer)
    1) Yes
    2) No
    #? 1
    [*] Auto Privilege Exploit Summary
    C file in /root/utilities/linux_2.6 has 16 files
    Python file in /root/utilities/linux_2.6 has 1 files
    Perl file in /root/utilities/linux_2.6 has 0 files
    Ruby file in /root/utilities/linux_2.6 has 0 files
    TXT file in /root/utilities/linux_2.6 has 2 files

    DAVScan - Fingerprints servers, finds exploits, scans WebDAV

    $
    0
    0

    DAVScan is a quick and lightweight webdav scanner designed to discover hidden files and folders on DAV enabled webservers. The scanner works by taking advantage of overly privileged/misconfigured WebDAV servers or servers vulnerable to various disclosure or authentication bypass vulnerabilities. The scanner attempts to fingerprint the target server and then spider
    the server based on the results of a root PROPFIND request.

    What works:
    Server header fingerprinting - If the webserver returns a server header, davscan can search for public exploits based on the response.
    Basic DAV scanning with PROPFIND - Quick scan to find anything that might be visible from DAV.
    Unicode Auth Bypass - Works using GET haven't added PROPFIND yet. Not fully tested so double check the work.
    Exclusion of DoS exploit results - You can exclude denial of service exploits from the searchsploit results.
    Exclusion of MSF modules from exploit results - Custom searchsploit is included in the repo for this. Either overwrite existing searchsploit or backup and replace. This feature may or may not end up in the real searchsploit script.

    What doesn't work:
    Authentication - I've started this, but it's not finished yet. I'll get to it when I actually need it.
    X header fingerprinting - It's in there, but isn't working right. Need to debug this.
    Probably a lot more that I haven't tested yet.

    What I want to do:
    Build a sqlite database instead of flat file - Currently output goes to file with a couple blurbs to the screen just to show it's working.
    Become a fighter pilot! - I saw Top Gun once and now I'm really stoked about going into the Air Force and living the dream. "I feel the need for speed!"

    Usage:
    usage: davscan.py [-h] -H HOST [-p PORT] [-a AUTH] [-u USER] [-P PASSWORD] [-o OUTFILE] [-d ] [-m ]
    -H HOST, --host HOST hostname or IP address of web server; -h foo.com
    optional arguments:
    -h, --help show this help message and exit
    -p PORT, --port PORT port to connect to the host on (defaults to port 80); -p 80
    -a AUTH, --auth AUTH Basic authentication required; -a basic
    -u USER, --user USER user; -u derp
    -P PASSWORD, --password PASSWORD password for user; -P 'hunter2'
    -o OUTFILE, --out OUTFILE output file. defaults to /tmp/davout; -o /foo/bar
    -d, --no-dos exclude DoS results from searchploit.
    -m, --no-msf exclude MSF modules from results.


    Acunetix Release Web Site Security Pen Testing Tools Free

    $
    0
    0

    HTTP editor, fuzzer and sniffer tools help pen testers identify vulnerabilities

    London, UK – January 2016 – Hot on the release of Acunetix Version 11, pioneering web application security software Acunetix, now delivering Manual Pen Testing Tools at no cost. Penetration testers can make use of an HTTP Editor to modify or craft HTTP requests and analyze responses; intercept and modify HTTP traffic on the fly using the integrated HTTP Sniffer; fuzz test HTTP requests using the HTTP Fuzzer and test Blind SQL Injection vulnerabilities further using the Blind SQL Injector, among others.
    “Acunetix has for the past decade been an excellent resource in the pentester’s tool kit. Prior to Acunetix v11, these Manual Pen Testing Tools were only available to Acunetix Customers. By releasing our manual tools separately, we aim to facilitate veteran testers as well as up and coming security researchers by making it easy to manually test web applications for logical flaws among others,” added Nicholas Sciberras, CTO, Acunetix.


    HTTP Editor: Allows you to create, analyze and edit client HTTP requests; as well as inspect server responses. It also includes an encoding and decoding tool to encode/decode text and URL’s to MD5 hashes, UTF-7 and other formats.
    HTTP Sniffer: A proxy that allows you to analyze HTTP requests and responses, and edit these while they are in transit. The HTTP sniffer can also be used to manually crawl a site, and use the manual crawl to seed an Acunetix scan.
    HTTP Fuzzer: A tool which allows you to automatically send a large number of HTTP requests including invalid, unexpected and random data to a website, to test input validation and handling of invalid data by the web application.
    Blind SQL Injector: An automated database data exfiltration tool. By using Blind SQL injection vulnerabilities discovered when scanning a website, it is possible to demonstrate the serious impact a Blind SQL injection vulnerability can have on the website. Used to enumerate databases, tables, fields and dump data from the vulnerable web application.
    Subdomain Scanner: Scans a top-level domain to discover subdomains configured in its hierarchy, by using the target domain’s DNS server, or any other DNS server specified by the user. While scanning, this tool will also automatically identify and inform the user if the domain being scanned is using some kind of wildcard characters, such as *.domain.com.
    Target Finder: An IP range / port scanner which can be used to discover running web servers on a given IP or within a specified range of IPs. The list of ports on which the web servers are listening can also be configured. The default ports the scanner will scan are port 80 for HTTP and port 443 for SSL.
    Authentication Tester: Used to test the strength of both usernames and passwords within HTTP and web forms authentication environments via a dictionary attack.

    Download the FREE Manual Pen Testing Tools


    custom-bytecode-analyzer - Java bytecode analyzer customizable via JSON rules

    $
    0
    0


    Java bytecode analyzer customizable via JSON rules. It is a command-line tool that receives a path containing one or more Jar files, analyzes them using the provided rules and generates HTML reports with the results.

    Usage
    usage: java -jar cba-cli.jar [OPTIONS] -a DIRECTORY_TO_ANALYZE
    -a,--analyze <pathToAnalyze> Path of the directory to run the
    analysis.
    -c,--checks <checks...> Space separated list of custom checks
    that are going to be run in the analysis.
    -f,--custom-file <customFile> Specify a file in JSON format to run
    custom rules. Read more in GitHub.
    -h,--help Print this message.
    -i,--items-report <maxItems> Max number of items per report. If the
    number of issues found exceeds this
    value, the report will be split into
    different files. Useful if expecting too
    many issues in the report. Default: 500.
    -o,--output <outputDir> Directory to save the report. Warning -
    if there are already saved reports in
    this directory they will be overwritten.
    Default is "report".
    -v,--verbose-debug Increase verbosity to debug mode.
    -vv,--verbose-trace Increase verbosity to trace mode.

    Custom JSON rules
    Rules file can be specified using -f,--custom-file argument . The file is in JSON format and has the following structure:
    • rules : array(rule)
      • name : string
      • interfaces : array(string)
      • superClass : string
      • methods : array(method)
        • name : string
        • visibility : [public|protected|private]
        • parameter : string (only one parameter is supported at the moment)
        • report : boolean (default: true)
      • invocations : array(invocation)
        • owner : string
        • method : method
          • name : string
          • visibility : [public|protected|private]
          • parameter : string (only one parameter is supported at the moment)
        • notFrom : method
          • name : string
          • visibility : [public|protected|private]
          • parameter : string (only one parameter is supported at the moment)
        • from : method
          • name : string
          • visibility : [public|protected|private]
          • parameter : string (only one parameter is supported at the moment)
        • report : boolean (default:true)
    You can also check net.nandgr.cba.custom.model.Rules.java to see the structure in Java code.

    Examples

    Find custom deserialization
    If we need to find classes with custom deserialization, we can do it quite easily. A class defines custom deserialization by implementing private void readObject(ObjectInputStream in) . So we only need to find all classes where that method is defined. It would be enough just to define a rule as:
    {
    "rules": [{
    "name": "Custom deserialization",
    "methods": [{
    "name": "readObject",
    "visibility": "private",
    "parameter": "java.io.ObjectOutputStream"
    }]
    }]
    }
    It will report methods with private visibility, readObject as name and a parameter of type java.io.ObjectOutputStream . Since we only have one rule, a report named: custom-deserialization-0.html will be created.

    Find custom serialization and deserialization
    In this case, one rule with two methods have to be defined. The same one than in the previous example for deserialization, and a new one to match private void writeObject(ObjectOutputStream out) . As shown in the JSON structure above, the property rules.rule.methods is an array of methods, so a rule like this can be written:
    {
    "rules": [{
    "name": "Custom serialization and deserialization",
    "methods": [{
    "name": "readObject",
    "visibility": "private",
    "parameter": "java.io.ObjectOutputStream"
    },{
    "name": "writeObject",
    "report": "false",
    "visibility": "private",
    "parameter": "java.io.ObjectOutputStream"
    }]
    }]
    }
    The property report was set to false to avoid reporting twice for the same rule. We are using the second method just as a condition, but reporting only readObject methods should be enough for the example purpose.

    Find all method definitions
    If a property is not defined, it will always match as true. For example, this rule would return all methods definitions:
    {
    "rules": [{
    "name": "Method definitions",
    "methods": [{
    }]
    }]
    }

    Find String.equals method invocations
    Method invocations can also be found. The JSON in this case would be:
    {
    "rules": [{
    "name": "String equals",
    "invocations": [{
    "owner": "java.lang.String",
    "method": {
    "name": "equals"
    }
    }]
    }]
    }
    The property owner specifies the class containing the method.

    Reflection method invoke
    Another method invocation example a bit more useful than the previous one:
    {
    "rules": [{
    "name": "Method invocation by reflection",
    "invocations": [{
    "owner": "java.lang.reflect.Method",
    "method": {
    "name": "invoke"
    }
    }]
    }]
    }

    Deserialization usage
    In this example, we want to find deserialization usages (not classes defining serialization behaviors like in the previous examples). Deserialization happens when ObjectInputStream.readObject() is invoked. for example in this code snippet:
    ObjectInputStream in = new ObjectInputStream(fileInputStream);
    Object o = in.readObject();
    So we need to find method invocations from ObjectInputStream named readObject . But it will find a lot of false positives in a researching context, because when a class defines custom deserialization, they make an invocation to this method inside a private void readObject(ObjectInputStream in) method, and that would pollute the report too much. If we want to exclude those cases and keep only genuine deserialization, notFrom property can be used:
    {
    "rules": [{
    "name": "Deserialization usage",
    "invocations": [{
    "owner": "java.io.ObjectInputStream",
    "method": {
    "name": "readObject"
    },
    "notFrom": {
    "name": "readObject",
    "visibility": "private",
    "parameter": "java.io.ObjectInputStream"
    },
    "report": true
    }]
    }]
    }
    This file will find java.io.ObjectInputStream.readObject() invocations if the invocation is not done inside private void readObject(ObjectInputStream in) method.
    A class compiled with this code will not be reported:
    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
    Object o = in.readObject();
    }
    But this one will be reported:
    public Object deserializeObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
    Object o = in.readObject();
    return o;
    }
    The property from can be set in invocations in exactly the same way than notFrom , but the result will be the opposite: it will only match if the invocation is made from the defined method.

    Java servlets
    The property superClass can be used in this case. If we want to find all classes extending javax.servlet.http.HttpServlet , a rule can be:
    {
    "rules": [{
    "name": "Java servlets",
    "superClass" : "javax.servlet.http.HttpServlet"
    }]
    }

    X509TrustManager implementations
    A rule can be written to find classes implementing an array of interfaces. if more than one interface is defined in the rule, the class has to implement all of them to be reported. If we want to find classes implementing javax.net.ssl.X509TrustManager , the rule would be:
    {
    "rules": [{
    "name": "X509TrustManager implementations",
    "interfaces" : ["javax.net.ssl.X509TrustManager"]
    }]
    }
    Please note that interfaces is an array , so make sure you add the strings between square brackets, e.g: ["interface1", "interface2", ...] .

    Define multiple rules
    Multiple rules can be defined in the same JSON file. They will be processed and reported separately and they will not affect each other. We can combine some of the previous examples rules:
    {
    "rules": [{
    "name": "Custom deserialization",
    "methods": [{
    "name": "readObject",
    "visibility": "private",
    "parameter": "java.io.ObjectOutputStream"
    }]
    },{
    "name": "Method invocation by reflection",
    "invocations": [{
    "owner": "java.lang.reflect.Method",
    "method": {
    "name": "invoke"
    }
    }]
    }]
    }
    Here, we have two rules ("Custom deserialization" and "Method invocation by reflection"). They will be processed as if you do it in two separated executions. And a report per rule will be generated.

    Custom Java rules
    The project can be downloaded and built to add more complex custom rules in Java code that are not covered by the JSON format. There are already three examples under the package net.nandgr.cba.visitor.checks . Those are CustomDeserializationCheck, DeserializationCheck and InvokeMethodCheck . You can create your own rules by extending net.nandgr.cba.custom.visitor.CustomAbstractVisitor . CustomAbstractVisitor is extending ASM org.objectweb.asm.ClassVisitor , so plenty of documentation can be found in the internet about it.

    Command line examples

    Run an analysis using a JSON file
    java -jar cba-cli-<version>.jar -a /path/with/jars -f /path/with/json/file/rules.json

    Run an analysis using a Java custom rule
    To use custom java rules, class names have to be specified as arguments of -c .
    java -jar cba-cli-<version>.jar -a /path/with/jars -c DeserializationCheck
    Accepts a space separated list, so multiple custom rules can be defined (each of the rules will create a separate report):
    java -jar cba-cli-<version>.jar -a /path/with/jars -c DeserializationCheck InvokeMethodCheck CustomDeserializationCheck YourCustomRule

    Combine JSON and custom Java rules
    java -jar cba-cli-<version>.jar -a /path/with/jars -f /path/with/json/file/rules.json -c YourCustomRule1 YourCustomRule2

    Increase verbosity
    To find errors, verbosity can be increased. Debug level:
    java -jar cba-cli-<version>.jar -a /path/with/jars -c YourCustomRule1 -v
    Trace level:
    java -jar cba-cli-<version>.jar -a /path/with/jars -c YourCustomRule1 -vv

    Build and run the project
    There is already an executable jar file under bin directory at: https://github.com/fergarrui/custom-bytecode-analyzer/blob/master/bin/cba-cli-0.1-SNAPSHOT.jar . If you want to do modifications or add custom rules, the project can be built doing:
    git clone https://github.com/fergarrui/custom-bytecode-analyzer.git
    cd custom-bytecode-analyzer
    mvn clean package
    Two jars will be generated under target folder. cba-cli-<version>.jar contains all dependencies and is executable. Can be run using java -jar cba-cli-<version>.jar


    Operative - The Fingerprint Framework

    $
    0
    0


                                   __  _          
    ____ ____ ___ _________ _/ /_(_) _____
    / __ \/ __ \/ _ \/ ___/ __ `/ __/ / | / / _ \
    / /_/ / /_/ / __/ / / /_/ / /_/ /| |/ / __/
    \____/ .___/\___/_/ \__,_/\__/_/ |___/\___/
    /_/

    This is a framework based on fingerprint action, this tool is used for get information on website or enterprise target

    Dependency & launching
    • pip install -r requirements.txt
    • python operative.py

    Youtube

    Core Modules
    • core/modules/cms_gathering
    • core/modules/domain_search
    • core/modules/email_to_domain
    • core/modules/https_gathering
    • core/modules/linkedin_search
    • core/modules/reverse_ipdomain
    • core/modules/search_db
    • core/modules/waf_gathering
    • core/modules/whois_domain
    • core/modules/generate_email
    • core/modules/viadeo_search

    SQL File forensics
    • import database in core/dbs/
    • read table
    • read columns
    • search information with pattern

    Write module
    For write module look core/modules/sample_module class

    This is only for testing purposes and can only be used where strict consent has been given. Do not use this for illegal purposes, period.


    Viewing all 5816 articles
    Browse latest View live


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