‏إظهار الرسائل ذات التسميات Honeypot. إظهار كافة الرسائل
‏إظهار الرسائل ذات التسميات Honeypot. إظهار كافة الرسائل

الثلاثاء، 17 يناير 2017

MongoDB-HoneyProxy: A Honeypot Proxy For MongoDB Server

MongoDB-HoneyProxy: A Honeypot Proxy For MongoDB Server

When run, this will proxy and log all traffic to a dummy mongodb server. MongoDB-HoneyProxy was created in response to the 'MongoDB Apocolypse'

Pre-requisites:

  • sudo apt-get install nodejs npm gcc g++
  • You'll also need to install MongoDB for this to function, as this project works as a logging proxy.

Setup

  • Create a MongoDB database. Some good dummy data can be found here. Another good tool is JSON Generator, which generates fake json that can then be converted to bson.
  • Then, install the project
git clone https://github.com/Plazmaz/MongoDB-HoneyProxy.git
cd MongoDB-HoneyProxy
sudo npm install

To run the project, simply use node index.js

Download

الأربعاء، 12 أكتوبر 2016

tmux "Terminal Multiplexer" To Be Accessed and Controlled From A Single Terminal

tmux "Terminal Multiplexer" To Be Access and Controlled From A Single Terminal

tmux is a "terminal multiplexer", it enables a number of terminals (or windows) to be accessed and controlled from a single terminal. 


tmux is intended to be a simple, modern, BSD-licensed alternative to programs such as GNU screen.

This release runs on OpenBSD, FreeBSD, NetBSD, Linux, OS X and Solaris.

tmux depends on libevent 2.x. Download it from:

http://libevent.org

To build tmux from a release tarball, do:

       $ ./configure && make
   $ sudo make install

By default, tmux will use the utempter library to update utmp(5), if it is
installed. Run configure with --disable-utempter to disable this.

To get and build the latest from version control:

       $ git clone https://github.com/tmux/tmux.git
   $ cd tmux
   $ sh autogen.sh
   $ ./configure && make

For more information see http://git-scm.com. Patches should be sent by email to
the mailing list at tmux-users@googlegroups.com.

For documentation on using tmux, see the tmux.1 manpage. It can be viewed from
the source tree with:

$ nroff -mdoc tmux.1|less

Some common questions are answered in the FAQ file, a rough todo list is in the
TODO file and an example configuration in example_tmux.conf.

A vim(1) syntax file is available at:

https://github.com/keith/tmux.vim
https://raw.githubusercontent.com/keith/tmux.vim/master/syntax/tmux.vim

And a bash(1) completion file at:

https://github.com/imomaliev/tmux-bash-completion

For debugging, running tmux with -v or -vv will generate server and client log
files in the current directory.

Download

الأحد، 17 يوليو 2016

MARA: A Mobile Application Reverse Engineering and Analysis Framework Tool

Mobile Application Reverse engineering and Analysis Framework Tool


MARA: A Mobile Application Reverse Engineering And Analysis Framework Tool


MARA is a Mobile Application Reverse engineering and Analysis Framework. It is a tool that puts together commonly used mobile application reverse engineering and analysis tools, to assist in testing mobile applications against the OWASP mobile security threats. Its objective is to make this task easier and friendlier to mobile application developers and security professionals.

Features supported

  • Reverse engineer apk files to smali, java jar files, java source code and dalvik bytecode (jadx format)
  • Reverse engineer dex, jar and class files into java source code and dalvik bytecode (jadx format)
  • Statically Analyze java source code and dalvik bytecode
  • Scan for apk vulnerabilities via androbugs
  • Scan ssl domains found in the app via the standalone SSL scanner that makes use of pyssltest and testssl

To do list

MARA is still in the very early stages of development. Researchers intend to work on the following features:
  • Integrate dynamic mobile application analysis
  • Rewrite the MARA Framework in python
  • Integrate iOS, Blackberry and Windows phone application analysis
  • Develop web panel to display data
  • Include additional disassembly and analysis tools

Additional information about the framework, prerequisites and the installation guide is available on the wiki

Download

الخميس، 9 يونيو 2016

Santoku: Mobile Forensics, Malware Analysis And App Security Testing

Santoku: Mobile Forensics, Malware Analysis And App Security Testing


Santoku: Mobile Forensics, Malware Analysis, and App Security Testing


Santoku is an open-source platform that is also very simple to use as well as it dedicated to mobile forensics, analysis, and security.


The word Santoku means that “three virtues” or “three uses.” Santoku  Linux has been designed to you in these three achievements that are as follows:

Mobile Forensics: 

  • There are several tools required as well as analyze the data and that are as follows-
  • Firmware flashing tools that are used for multiple manufacturers
  • Imaging tools which are required for NAND, media cards, and RAM
  • There are also available free versions of some commercial forensics tools
  • Useful scripts and utilities specifically designed for mobile forensics

Mobile Malware:
  • In this tools are required for scanning mobile malware and that are as follows-
  • Mobile device emulators
  • Utilities to simulate network services for dynamic analysis
  • Decompilation and disassembly tools
  • Access to malware databases

Mobile Security:
  • There is some evaluation which is supporting for the security purpose of mobile apps -
  • Decompilation and disassembly tools
  • Scripts to detect common issues in mobile applications
  • Scripts to automate decrypting binaries, deploying apps, enumerating app details, and more

The Operating System:

A bootable Linux environment that is designed to make life easier.
  • Pre-installed platform SDKs, drivers, and utilities
  • Pre-configured GUI frameworks, such as PyGTK to support GUI tools
  • GUI tools for easy deployment and control of mobile apps
  • Auto Detection and setup of new connected mobile devices
DOWNLOAD HERE

الاثنين، 23 مايو 2016

Manalyze: A Static Analyzer For PE Executables

Manalyze: A Static Analyzer For PE Executables


Manalyze: A Static Analyzer For PE Executables

Manalyze was designed in C++ for Windows as well as for Linux and it is introduced under the terms of the GPLv3 license. It is a strong parser for PE files with an architecture of flexible plugin that permits users to statically analyze the files in-depth.


Features:

Manalyze has some new features which are as follows:
  • It identifies a PE's compiler
  • It can detect packed executables
  • Applies ClamAV signatures
  • It can identify for suspicious strings
  • Looks for malicious import combinations i.e. WriteProcessMemory + CreateRemoteThread
  • It can detect cryptographic constants such as IDA's find crypto plugin
  • Manalyze can submit hashes to VirusTotal
  • Verifies Authenticode signatures only on Windows.

Installation:

Manalyze as simple to build as possible. 

On Linux and BSD (tested on Debian Jessie and FreeBSD 10.2)

$> [sudo or as root] apt-get install libboost-regex-dev libboost-program-options-dev libboost-system-dev libboost-filesystem-dev build-essential cmake git
$> [alternatively, also sudo or as root] pkg install boost-libs-1.55.0_8 cmake
$> git clone https://github.com/JusticeRage/Manalyze.git && cd Manalyze
$> cmake .
$> make
$> cd bin && ./manalyze --version

On Windows-
  • Get the Boost libraries from boost.org and install CMake.
  • Build the boost libraries
  1. cd boost_1_XX_0 && ./bootstrap.bat && ./b2.exe --build-type=complete --with-regex --with-program_options --with-system --with-filesystem.
  2. Add an environment variable BOOST_ROOT which contains the path to your boost_1_XX_0 folder.
  • Download and install Git
  • git clone https://github.com/JusticeRage/Manalyze.git && cd Manalyze && cmake .
  • A Visual Studio project manalyze.sln should have appeared in the Manalyze folder. 
Offline Builds-
If you need to build Manalyze on a machine with no internet access, you have to manually check out the following projects:
  • Yara
  • hash-library

Place the two folders in the external folder as external/yara and external/hash-library respectively. Then run cmake . -DGitHub=OFF and continue as you normally would.

Binaries-

Windows x86 binaries

All the binaries in this archive are signed with a certificate ‎presenting the following fingerprint:26fc24c12b2d84f77615cf6299e3e4ca4f3878fc.

Generating ClamAV Rules-

Since ClamAV signatures are huge as well as regularly updated and it did not make a lot of sense to allocate them from GitHub or with the binary. When you try using the ClamAV plugin for the first time, you will similarly encounter the following error message: [!] Error: Could not load yara_rules/clamav.yara. In order to create them, simply run the update_clamav_signatures.py Python script situated in bin/yara_rules.



Run the script whenever you want to refresh the signatures.

Usage

$ ./manalyze.exe --help

  -h [ --help ]         Displays this message.
  -v [ --version ]      Prints the program's version.
  --pe arg              The PE to analyze. Also accepted as a positional
                        argument. Multiple files may be specified.
  -r [ --recursive ]    Scan all files in a directory (subdirectories will be
                        ignored).
  -o [ --output ] arg   The output format. May be 'raw' (default) or 'json'.
  -d [ --dump ] arg     Dump PE information. Available choices are any
                        combination of: all, summary, dos (dos header), pe (pe
                        header), opt (pe optional header), sections, imports,
                        exports, resources, version, debug, tls, config, delay
  --hashes              Calculate various hashes of the file (may slow down the
                        analysis!)
  -x [ --extract ] arg  Extract the PE resources to the target directory.
  -p [ --plugins ] arg  Analyze the binary with additional plugins. (may slow
                        down the analysis!)

Available plugins:
  - clamav: Scans the binary with ClamAV virus definitions.
  - compilers: Tries to determine which compiler generated the binary.
  - peid: Returns the PEiD signature of the binary.
  - strings: Looks for suspicious strings (anti-VM, process names...).
  - findcrypt: Detects embedded cryptographic constants.
  - packer: Tries to structurally detect packer presence.
  - imports: Looks for suspicious imports.
  - resources: Analyzes the program's resources.
  - mitigation: Displays the enabled exploit mitigation techniques (DEP, ASLR, etc.).
  - authenticode: Checks if the digital signature of the PE is valid.
  - virustotal: Checks existing AV results on VirusTotal.
  - all: Run all the available plugins.

Examples:
  manalyze.exe program.exe
  manalyze.exe -dresources -dexports -x out/ program.exe
  manalyze.exe --dump=imports,sections --hashes program.exe
  manalyze.exe -r malwares/ --plugins=peid,clamav --dump all

Download

الثلاثاء، 10 مايو 2016

Metasploitable: A Vulnerable Linux Virtual Machine

Metasploitable: A Vulnerable Linux Virtual Machine


Metasploitable: A Vulnerable Linux Virtual Machine

Metasploitable is a purposely vulnerable Linux virtual machine. This virtual machine can be used to perform the security training, tools of security test as well as carry out the regular dissemination testing techniques. 


Or you can say in other words that the Metasploitable virtual machine is an intentionally vulnerable version of Ubuntu Linux which is designed for testing the security tools as well as representing the common vulnerabilities. The version 2 of this virtual machine is present for download and transports with still there are more vulnerabilities than the real image. 

This virtual machine is well-matched with VMWare, VirtualBox as well as many other similar platforms of virtualization. By default, the network interfaces of Metasploitable are jumped to the NAT and the network adapters of the only Host and also the image should never be uncovered to a hostile network.

Vulnerable Web Services:

Metasploitable 2 has intentionally vulnerable web applications which are already pre-installed. Automatically the web server initiates, when Metasploitable 2 is booted. To contact the web applications that unlock a web browser as well as go through the URL HTTP://<IP> where <IP> is the IP address of Metasploitable 2. 

There is only one way to complete this and for is to install the Metasploitable 2 that is performed as a guest operating system in Virtual Box as well as modify the settings of the network interface from "NAT" to "Host Only".

To access a specific web application you just click on one of the offered links. Particular web applications that may furthermore be accessed by attaching the application with the directory name onto HTTP://<IP> to create URL HTTP://<IP>/<Application Folder>/. Such as - the Mutillidae application that may be accessed in this example at the address http://192.168.56.101/mutillidae/. The applications are already installed in Metasploitable 2 in the /var/www directory. Here are the applications which are available in the current version of this application which is as follows:

  • Mutillidae (NOWASP Mutillidae 2.1.19)
  • dvwa (Damn Vulnerable Web Application)
  • phpMyAdmin
  • tiki wiki (TWiki)
  • tiki wiki-old
  • dav (WebDav)

Download

الأحد، 1 مايو 2016

Low Orbit Ion Cannon LOIC: A Network Stress Testing Application Tool


LOIC: A Network Stress Testing Application Tool

LOIC(Low Orbit Ion Cannon) is an open source network stress testing as well as DoS(denial-of-service)attacks application which is written in C#. 


LOIC was primarily developed by Praetox Technologies but soon after it was revealed into the public domain and also now it is hosted on various open source platforms.

USES:

LOIC executes a task of doing many predictable virus that flood the host a DDoS attack on a target site by submerging the server with TCP or UDP packets with the targeting of troublemaking the service of a particular host. People have used LOIC to join intended botnets.

The software stimulated the establishment of an autonomous version of JavaScript that is known as  JS LOIC as well as LOIC-derived web version which is known as Low Orbit Web Cannon. These enable a DoS from a web browser.

COUNTERMEASURES:

The security experts extracted by the BBC specified that well-written rules of firewall that can sort out the most traffic from DDoS attacks by LOIC. Therefore protecting from the attacks for being fully valuable. 

Particularly, it has been declared that sorting out all UDP and ICMP traffic that effectively helps to address from attacks of LOIC. Due to the providers of  internet service that makes available not as much of bandwidth to each of their customers in order to offer guaranteed service levels for all of their customers at once. 

Even the rules of a firewall for sorting out that are more possibly to be valuable when it applied at a point upstream of an application internet uplink of the server. 

In other words you can say that it is simple to cause an ISP to jump down the traffic intended for a customer by transferring a greater amount of traffic than it is permitted on that link of the customer as well as any process of sorting out that arises on the side of the customers after the traffic pass through that link will not bring to an end of the service provider from reducing the traffic overloading the intended for that customer.

The attacks of LOIC are simply recognized in system logs as well as the attacks can be tracked down to the IP addresses which is used at the LOIC attacks.

BEGINNING OF NAME:

The LOIC application is named after the ion cannon that is an imagination weapon from many sci-fi performs as well as in specific after its namesake from the series of Command & Conquer of video games.

FEATURES:

•    It provides an effective security to the servers.

•    It has the capability of stress testing.

DOWNLOAD HERE

الأحد، 17 أبريل 2016

A New Debugger Tool To Find Security Bugs For Ruby On Rails Code In 64 Seconds

A New Debugger Tool Can Find Security Bugs For Ruby On Rails Code In 64 Seconds


A Researchers Team Found A New Debugger Can Discover Security Bugs in Ruby Code in 64 Seconds


There is a team of researchers from the MIT (Massachusetts Institute of Technology) that have manually put a new code which is used for debugging an application. It can find 23 vulnerabilities in Ruby on Rails framework in less than 64 seconds.


This new code debugger is known as Space is announced in a study paper that will be presented in May, at the International Conference on Software Engineering.

According to the team of the researchers that they have done efforted on the projects and they say that they have modified the whole code of the Ruby on Rails (Rails or RoR) framework so it could be defined by easy operations that could be logical.

According to Daniel Jackson who is a professor in the Department of Electrical Engineering and Computer Science said, that these operations would then be supplied to a fixed code analyzer that took into account seven ways by which users would interrelate with the context which is based on the data as well as based on also their permission levels.

Jackson describes that "The classic example of this is if you wanted to do an abstract analysis of a program that manipulates integers, you might divide the integers into the positive integers, the negative integers, and zero. The static analysis would then evaluate every operation in the program according to its effect on integers' signs. Adding two positives yields a positive; adding two negatives yields a negative; multiplying two negatives yields a positive; and so on.”

Jackson also says, "The problem with this is that it can't be completely accurate because you lose information. If you add a positive and a negative integer, you don't know whether the answer will be positive, negative, or zero. Most work on static analysis is focused on trying to make the analysis more scalable and accurate to overcome those sorts of problems."

He also added that "The program under analysis is just huge. Even if you wrote a small program, it sits atop a vast edifice of libraries and plug-ins and frameworks. So when you look at something like a Web application written in a language like Ruby on Rails, if you try to do a conventional static analysis, you typically find yourself mired in this huge bog. And this makes it really infeasible in practice."

If these communications were outside of a reasonable model of which Space was expecting, the debugger would believe that the operation as the source of a security bug in the fundamental code.
The researchers of MIT said that they have experienced Space on 50 popular Ruby on Rails applications as well as it discovered the 23 new security bugs. Throughout all tests, researchers say that Space never took more than 64 seconds to examine the each application.

Even though most of the community which have open source and buildup moving to the JavaScript and Node.js, the Ruby programming language as well as mainly Ruby on Rails that leaves one of the most solid, secure and also well-maintained frameworks on the market that is used to making Space which is a must-have tool for many developers. 

الخميس، 28 يناير 2016

Faraday A Multi-User Penetration Test and Vulnerability Management Platform

Faraday A Multi-User Penetration Test and Vulnerability Management Platform


Faraday 1.0.16 Is A Multiuser Penetration Test IDE


A new concept called IPE, or Integrated Penetration-Test Environment has been introduced by the Faraday 1.0.16. It is a multiuser penetration test IDE designed for distribution, indexation and analysis of the generated data during the process of a security audit. 


The main aim of Faraday is to re-use the available tools in the community to take advantage of them in a multiuser way.

The version comes up with a lot of changes in Web UI. It has the ability to group vulnerabilities by any field in our Status Report view. If you have a Pro or Corp license you can now create an Executive Report using only confirmed vulnerabilities, saving you, even more, time.

Changes Made In This New Version:

  • In our Status Report, it has added group vulnerabilities.

  • It also had added a port to Service type target.
  • It able to filter false-positives in all these (Dashboard, Status Report, and Executive Report).


Features:

  • Its design structure is simple.
  • Its unable for users to notice any difference between their own terminal application and the one included in Faraday. 
  • It is developed with a specialized set of functionalities that help users improve their own work. 
  • Faraday is same as IDE does for you when programming but from the perspective of a penetration test.


Plugins

There are 3 kinds of plugins:

  • First plugins can intercept commands, fired directly when a command is detected in the console. These are transparent to you and no additional action on your part is needed.
  • Second plugins can import file reports. You have to copy the report to $HOME/.faraday/report/[workspacename] (replacing [workspacename] with the actual name of your Workspace) and Faraday will automatically detect, process and add it to the HostTree.
  • Third plugin connectors or online (BeEF, Metasploit, Burp), these connect to external APIs or databases or talk directly to Faraday's RPC API.

Bug fixes:

  • Faraday wouldn't start when the last workspace was null.
  • CSV export/import in QT.
  • It can fix a bug that prevented the use of "reports" and "cwe" strings in Workspace names.
  • Unicode supports in Nexpose-full Plugin.
  • It also fixed bug get_installed_distributions from handler exceptions.
  • It enables to a fixed bug in the first run of Faraday with log path and API errors.


Installation:

This installation process applies only to Debian, Ubuntu, Kali and Backtrack OS. 

Download the latest tarball or clone the Faraday Git Project:

$ git clone https://github.com/infobyte/faraday.git faraday-dev
$ cd faraday-dev
$ ./install.sh
$ ./faraday.py



Download

الاثنين، 25 يناير 2016

Suricata IDPE 2.0.11 Is A Network Intrusion Detection And Prevention Engine

Suricata A Network Intrusion Detection And Prevention Engine

Suricata IDPE 2.0.11 Is A Network Intrusion Detection And Prevention Engine.


Suricata is developed by the Open Information Security Foundation, its supporting vendor and community for the purpose of network intrusion detection and prevention engine. 


The changes that the developer made in this new version was that "Multiple bug fixes have been implemented".The engine is multi-threaded and has native IPv6 support. It's capable of loading existing Snort rules and signatures and supports the Barnyard and Barnyard2 tools.

Features Of Suricata:

1. Engine
  • It provides Network Intrusion Detection System (NIDS) engine, Network Intrusion Prevention System (NIPS) engine and Network Security Monitoring (NSM) engine too.
  • It analyze the PCAP files.
  • It can also do a traffic recording using pcap logger.
  • It enables the Unix socket mode for automated PCAP file processing.
  • It also support Operating System(Linux, FreeBSD, OpenBSD, Mac OS X, Windows).

2. Configuration
  • The YAML config file is human and machine readable(both).
  • All the configuration are well commented and documented.

3. TCP/IP engines
  • It provides Scalable flow engine.
  • IPv6 is fully supported by the Suricata.
  • It also supports Tunnel decoding like(Teredo, IP-IP, IP6-IP4, IP4-IP6).
  • TCP stream engine
  • tracking sessions
  • stream reassembly
  • target based stream reassembly

4. Protocol Parsers
  • It Support packet decoding of(IPv4, IPv6, TCP, UDP, SCTP, ICMPv4, ICMPv6, GRE, Ethernet, PPP, PPPoE, Raw, SLL, VLAN, QINQ).
  • It also supports App layer decoding of(HTTP, SSL, TLS, SMB, SMB2, DCERPC, SMTP, FTP, SSH, DNS).


5. HTTP engine
  • It also provides Stateful HTTP parser built on libhtp.
  • It also supports HTTP request logger.
  • It enables the File identification, extraction and logging.
  • It also provides Keywords to match on buffers like (uri and raw uri, headers and raw headers, cookie, user-agent, request body and response body, method, status and status code, host)

6. Detection engine
  • It supports Protocol keywords, PCRE support, fast_pattern, Rule profiling, File matching.
  • It provides multiple pattern matcher algorithms that can be selected.
  • It also provides extensive tuning options.
  • It enables live rule reloads — use new rules w/o restarting Suricata.
  • It enables the delayed rules initialization.

7. Multi-Threading
  • It provides and support fully configurable threading — from single thread to dozens of threads.
  • It enables precooked “runmodes”, optional CPU affinity settings.
  • It also provides Use of fine-grained locking and atomic operations for optimal performance.
  • It also supports Optional lock profiling, IP Reputation, live reload support.
  • It can load large amounts host based reputation data.
  • It matches the reputation data in the rule language using the “iprep” keyword.

With 2.0, we introduced “Eve”, our all JSON event and alert output. This allows for easy integration with Logstash and similar tools.




Security

The TLS/DER parsing issue has CVE-2015-0971 assigned to it.


الجمعة، 22 يناير 2016

PacketFence: An Open Source Network Access Control (NAC)

PacketFence: An Open Source Network Access Control (NAC)


What is PacketFence?

PacketFence is a fully supported, trusted, Free and Open Source network access control (NAC) solution.

Released Versions:

The initial release is on December 22, 2004, and was written in Perl, Javascript.
The latest version of PacketFence is 5.6.0, which has been released on 2016-01-13. This version is considered stable and can be used in production environments.

Architecture Of PacketFence:


PacketFence Architecure



PacketFence Architecture Work

Features Of  PacketFence:

It includes following features like,

  • Registration
  • Centralized wired and wireless management
  • Detection of abnormal network activities
  • Proactive vulnerability scans
  • Isolation of problematic devices
  • Remediation through a captive portal
  • 802.1X
  • Wireless integration and User-Agent / DHCP fingerprinting

Different Market Where It Used:

PacketFence can be used to effectively secure networks small to very large heterogeneous networks.

  • Banks
  • Colleges and universities
  • Engineering companies
  • Convention and exhibition centers
  • Hospitals and medical centers
  • Hotels
  • Manufacturing businesses
  • School boards 
  • Telecommunications companies

Why we need PacketFence?

If you want to efficiently handle guests on your network and breeding ground for computer worms and viruses then you can use Packet Fence.
Here are some uses of it:

  • BYOD - It let people bring their own devices.
  • It provides guest access.
  • Role-based access control.
  • For performing compliance checks.
  • To eliminate malware.
  • It simplifies network management.
  • For WIFI offload / Hotspot.

Supported Network Devices:

Here are the most up-to-date wired and wireless equipment supported by PacketFence. Click

Here(http://www.packetfence.org/about/supported_switches_and_aps.html) to see this.


How To Download PacketFence?

1. By using Yum repository
If you are using a RedHat Enterprise Linux then you can use it to download Packetfence.

Create a file named as
/etc/yum.repos.d/PacketFence.repo

Write following content into it:

[PacketFence]
name=PacketFence Repository
baseurl=http://inverse.ca/downloads/PacketFence/RHEL$releasever/$basearch
gpgcheck=0

2. Download the below PacketFence latest versions
packetfence-5.6.0.tar.gz

الثلاثاء، 1 ديسمبر 2015

Malcom - Malware Communication Analyzer of Network Traffic


Malcom - Malware Communication Analyzer of Network Traffic.

Malcom is a tool designed to analyze a system's network communication using graphical representations of network traffic, and cross-reference them with known malware sources. 

This comes handy when analyzing how certain malware species try to communicate with the outside world.

Malcom can help you:


  • detect central command and control (C&C) servers
  • understand peer-to-peer networks
  • observe DNS fast-flux infrastructures
  • quickly determine if a network artifact is 'known-bad'
  • The aim of Malcom is to make malware analysis and intel gathering faster by providing a human-readable version of network traffic originating from a given host or network. Convert network traffic information to actionable intelligence faster.


Quick how-to Install

  • Make sure mongodb and redis-server are running
  • Elevate your privileges to root (yeah, I know, see disclaimer)
  • Start the webserver using the default configuration with ./malcom.py -c malcom.conf (or see options with ./malcom.py --help) ** For an example configuration file, you can copy malcom.conf.example to malcom.conf ** Default port is 8080 ** Alternatively, run the feeds from celery. 


Installation

Malcom is written in python. Provided you have the necessary libraries, you should be able to run it on any platform. I highly recommend the use of python virtual environments (virtualenv) so as not to mess up your system libraries.

The following was tested on Ubuntu server 14.04 LTS:

Install git, python and libevent libs, mongodb, redis, and other dependencies

$ sudo apt-get install build-essential git python-dev libevent-dev mongodb libxml2-dev libxslt-dev zlib1g-dev redis-server libffi-dev libssl-dev python-virtualenv

Clone the Git repo:

$ git clone https://github.com/tomchop/malcom.git malcom

Create your virtualenv and activate it:

$ cd malcom
$ virtualenv env-malcom
$ source env-malcom/bin/activate

Get and install scapy:

$ cd .. 
$ wget http://www.secdev.org/projects/scapy/files/scapy-latest.tar.gz
$ tar xvzf scapy-latest.tar.gz
$ cd scapy-2.1.0
$ python setup.py install

Still from your virtualenv, install necessary python packages from the requirements.txt file:

$ cd ../malcom
$ pip install -r requirements.txt

For IP geolocation to work, you need to download the Maxmind database and extract the file to the malcom/Malcom/auxiliary/geoIP directory. You can get Maxmind's free (and thus more or less accurate) database from the following link: http://dev.maxmind.com/geoip/geoip2/geolite2/:

$ cd Malcom/auxiliary/geoIP
$ wget http://geolite.maxmind.com/download/geoip/database/GeoLite2-City.mmdb.gz
$ gunzip -d GeoLite2-City.mmdb.gz
$ mv GeoLite2-City.mmdb GeoIP2-City.mmdb

Launch the webserver from the malcom directory using ./malcom.py. Check ./malcom.py --help for listen interface and ports.

For starters, you can copy the malcom.conf.example file to malcom.conf and run ./malcom.py -c malcom.conf

read more

Download

الاثنين، 5 أكتوبر 2015

MEMSCAN A Memory Scanning Tool For A Specific Sequence of Bytes



MEMSCAN A Memory Scanning Tool.. 
For A Specific Sequence of Bytes!

A memory scanning tool which uses mach_vm* to either dump memory or look for a specific sequence of bytes.
To build MEMSCAN, you will need to have the OS installed. Well, you don't really need it but it makes life easier.

Once Theos is installed, simply navigate to the MEMSCAN folder in terminal and run:

make package install

Usage

Dumping the memory of a process


  1. Obtain the target process PID, using ps.
  2. Provide the PID to memscan:

./memscan -p <PID> -d

Finding objects in memory

Open your target app or process in a disassembler, grab first ~16 bytes (customise this number as you will) of the method you want to hook and these bytes will be your "signature".

Write the signature to a file, make sure to encode the bytes like so:

echo -n -e '\x55\x48\x89\xE5\xB8\x15\x00\x00\x00\x5D' > needle

Run the scanner against the target process. It will locate the signature in memory and print it's address. The signature has to be passed in as bytes, not a literal string so use the scanner as shown:

./memscan -p <pid> -s <Path to file containing needle> 

e.g:

./memscan -p 1234 -s ./needle

MEMSCAN should then print the address where the needle is located in memory.


Download

الجمعة، 2 أكتوبر 2015

GitHub Announces To Support Universal 2nd Factor Authentication



GitHub Announces To Support Universal 2nd Factor Authentication (U2F) 
A rapidly growing open authentication standard!

When you insert them, these physical USB keys automatically generates a second-factor code. And you don't even enter a Six-digit code from Google Authentication and similar Apps. GitHub announced that its partnership with Yubico.

Two-factor authentication is a security process in which the user provides two means of identification from separate categories of credentials; one is typically a physical token, such as a card, and the other is typically something memorized, such as a security code.

The FIDO U2F Security Key by Yubico is a specially designed YubiKey, relying on high-security, public-key cryptography. U2F is built to protect against phishing and man-in-the-middle attacks, allowing one U2F authenticator to access any number of services without any shared secrets.

What is U2F — FIDO UNIVERSAL 2ND FACTOR

U2F is an open authentication standard that enables internet users  to securely access any number of online services, with one single device, instantly and with no drivers or client software needed.

U2F was created by Google and Yubico, with contribution from NXP, and is today hosted by the open-authentication industry consortium FIDO Alliance.



U2F is used with USB devices, including YubiKeys, as one of many authentication methods

In order to take advantage of the security improvements provided by U2F, you'll need to purchase a hardware key. You can purchase the U2F key of your choice from a range of vendors. GitHub are partnering with Yubico, inventor of the YubiKey, co-creator of the U2F protocol, and a leading provider of U2F authenticators.

Together with Yubico we are offering discounts to GitHub users for a limited time through a special offer page where you will verify your GitHub account and place your order:

  • While supplies last, GitHub users can purchase special edition U2F Security Keys for $5 plus shipping and handling (regular price $18; 5,000 special edition keys available).
  • After the special keys are gone, all GitHub users are eligible for a 20% discount on U2F-certified YubiKeys, for a limited time.
  • In addition, all students who are eligible for the Student Developer Pack will receive a 20% discount on any U2F-certified YubiKey.

الأربعاء، 30 سبتمبر 2015

Thug: A Tool For Python Low-Interaction Honeyclient


Thug: A Tool For Python Low-Interaction Honeyclient

Thug is a Python low-interaction honeyclient aimed at mimicing the behavior of a web browser in order to detect and emulate malicious contents.

The number of client-side attacks has grown significantly in the past few years shifting focus on poorly protected vulnerable clients. Just as the most known honeypot technologies enable research into server-side attacks, honeyclients allow the study of client-side attacks.

A complement to honeypots, a honeyclient is a tool designed to mimic the behavior of a user-driven network client application, such as a web browser, and be exploited by an attacker's content.


Download

الثلاثاء، 29 سبتمبر 2015

How To Test Security in IPv4 and IPv6 Data Networks?


How To Test Security in IPv4 and IPv6 Data Networks ?

Evil Foca is a tool for security pentesters and auditors whose purpose it is to test security in IPv4 and IPv6 data networks. 

Compared to IPv4 address space is 32 bits which resulting 4 billion addresses.IPv6 offers larger address space. Its addresses are 128 bits long, resulting in an address space of 340 undecillion addresses.


In addition, IPv6 provides other technical benefits, particularly, it permits hierarchical address allocation methods that facilitate route aggregation across the Internet, and thus limit the expansion of routing tables. The use of multicast addressing is expanded and simplified, and provides additional optimization for the delivery of services. Device mobility, security, and configuration aspects have been considered in the design of the protocol.

The tool is capable of carrying out various attacks such as:


  • MITM over IPv4 networks with ARP Spoofing and DHCP ACK Injection.
  • MITM on IPv6 networks with Neighbor Advertisement Spoofing, SLAAC attack, fake DHCPv6.
  • DoS (Denial of Service) on IPv4 networks with ARP Spoofing.
  • DoS (Denial of Service) on IPv6 networks with SLAAC DoS.
  • DNS Hijacking.


The software automatically scans the networks and identifies all devices and their respective network interfaces, specifying their IPv4 and IPv6 addresses as well as the physical addresses through a convenient and intuitive interface.

Man In The Middle (MITM) attack

The well-known “Man In The Middle” is an attack in which the wrongdoer creates the possibility of reading, adding, or modifying information that is located in a channel between two terminals with neither of these noticing. Within the MITM attacks in IPv4 and IPv6 Evil Foca considers the following techniques:

ARP Spoofing: Consists in sending ARP messages to the Ethernet network. Normally the objective is to associate the MAC address of the attacker with the IP of another device. Any traffic directed to the IP address of the predetermined link gate will be erroneously sent to the attacker instead of its real destination.

DHCP ACK Injection: Consists in an attacker monitoring the DHCP exchanges and, at some point during the communication, sending a packet to modify its behavior. Evil Foca converts the machine in a fake DHCP server on the network.

Neighbor Advertisement Spoofing: The principle of this attack is identical to that of ARP Spoofing, with the difference being in that IPv6 doesn’t work with the ARP protocol, but that all information is sent through ICMPv6 packets. There are five types of ICMPv6 packets used in the discovery protocol and Evil Foca generates this type of packets, placing itself between the gateway and victim.

SLAAC attack: The objective of this type of attack is to be able to execute an MITM when a user connects to Internet and to a server that does not include support for IPv6 and to which it is therefore necessary to connect using IPv4. This attack is possible due to the fact that Evil Foca undertakes domain name resolution once it is in the communication media, and is capable of transforming IPv4 addresses in IPv6.

Fake DHCPv6 server: This attack involves the attacker posing as the DCHPv6 server, responding to all network requests, distributing IPv6 addresses and a false DNS to manipulate the user destination or deny the service.

Denial of Service (DoS) attack: The DoS attack is an attack to a system of machines or network that results in a service or resource being inaccessible for its users. Normally it provokes the loss of network connectivity due to consumption of the bandwidth of the victim’s network, or overloads the computing resources of the victim’s system.

DoS attack in IPv4 with ARP Spoofing: This type of DoS attack consists in associating a nonexistent MAC address in a victim’s ARP table. This results in rendering the machine whose ARP table has been modified incapable of connecting to the IP address associated to the nonexistent MAC.
DoS attack in IPv6 with SLAAC attack: In this type of attack a large quantity of “router advertisement” packets are generated, destined to one or several machines, announcing false routers and assigning a different IPv6 address and link gate for each router, collapsing the system and making machines unresponsive.

DNS Hijacking: The DNS Hijacking attack or DNS kidnapping consists in altering the resolution of the domain names system (DNS). This can be achieved using malware that invalidates the configuration of a TCP/IP machine so that it points to a pirate DNS server under the attacker’s control, or by way of an MITM attack, with the attacker being the party who receives the DNS requests, and responding himself or herself to a specific DNS request to direct the victim toward a specific destination selected by the attacker.

Download

الاثنين، 14 سبتمبر 2015

AIDE (Advanced Intrusion Detection Environment) To Verify The Integrity Of Files


AIDE (Advanced Intrusion Detection Environment) To Verify The Integrity Of Files

AIDE is a file and directory integrity checker.

What does it do?

It creates a database from the regular expression rules that it finds from the config file(s). Once this database is initialized it can be used to verify the integrity of the files. It has several message digest algorithms (see below) that are used to check the integrity of the file. All of the usual file attributes can also be checked for inconsistencies. It can read databases from older or newer versions. See the manual pages within the distribution for further info.

Features

  • supported message digest algorithms: md5, sha1, rmd160, tiger, crc32, sha256, sha512, whirlpool (additionally with libmhash: gost, haval, crc32b)
  • supported file attributes: File type, Permissions, Inode, Uid, Gid, Link name, Size, Block count, Number of links, Mtime, Ctime and Atime
  • support for Posix ACL, SELinux, XAttrs and Extended file system attributes if support is compiled in
  • plain text configuration files and database for simplicity
  • powerful regular expression support to selectively include or exclude files and directories to be monitored
  • gzip database compression if zlib support is compiled in
  • stand alone static binary for easy client/server monitoring configurations


AIDE is included in the following distributions. Please use the corresponding command to install AIDE.

  • Debian GNU/Linux | Ubuntu: apt-get install aide or aptitude install aide
  • Gentoo: emerge aide
  • MacPorts: port install aide
  • FreeBSD: pkg_add -r aide
  • Red Hat | CentOS | Fedora: yum install aide
  • openSUSE: zypper install aide
  • IPCop: see here for installation guidelines

الجمعة، 28 أغسطس 2015

Toxy: Hackable HTTP Proxy To Simulate Server Failure Scenarios And Unexpected Network Conditions


Toxy: Hackable HTTP Proxy To Simulate Server Failure Scenarios And Unexpected Network Conditions

toxy is a fully programmatic and hackable HTTP proxy to simulate server failure scenarios and unexpected network conditions, built for node.js/io.js.

It was mainly designed for fuzzing/evil testing purposes, when toxy becomes particularly useful to cover fault tolerance and resiliency capabilities of a system, especially in service-oriented architectures, where toxy may act as intermediate proxy among services.

toxy allows you to plug in poisons, optionally filtered by rules, which essentially can intercept and alter the HTTP flow as you need, performing multiple evil actions in the middle of that process, such as limiting the bandwidth, delaying TCP packets, injecting network jitter latency or replying with a custom error or status code.

toxy can be fluently used programmatically or via HTTP API. It's compatible with connect/express, and it was built on top of rocky, a full-featured middleware-oriented HTTP proxy.

Requires node.js +0.12 or io.js +1.6


Why toxy?

There're some other similar solutions like toxy in the market, but most of them do not provide a proper programmatic control and usually are not easy to hack, configure and/or extend. Additionally, most of the those solutions only operate at TCP level stack instead of providing high-level abstraction to cover common requirements of the specific domain and nature of the HTTP protocol, like toxy does.

toxy provides a powerful hackable and extensible solution with a convenient abstraction, but also a low-level interface and programmatic capabilities exposed as a simple, concise and fluent API, with the implicit power, simplicity and fun of node.js.

Concepts

toxy introduces two core directives that you can plug in the proxy and should knowing before using: poisons and rules.

Poisons are the specific logic to infect an incoming or outgoing HTTP flow (e.g: injecting a latency, replying with an error). HTTP flow can be poisoned by one or multiple poisons, and poisons can be plugged to infect both global or route level incoming traffic.

Rules are a kind of validation filters that can be reused and applied to global incoming HTTP traffic, route level traffic or into a specific poison. Their responsability is to determine, via inspecting each incoming HTTP request, if the registered poisons should be enabled or not, and therefore infecting or not the HTTP traffic (e.g: match headers, query params, method, body...).

How it works

↓   ( Incoming request )  ↓
↓           |||           ↓
↓     ----------------    ↓
↓     |  Toxy Router |    ↓ --> Match the incoming request
↓     ----------------    ↓
↓           |||           ↓
↓     ----------------    ↓
↓     |  Exec Rules  |    ↓ --> Apply configured rules for the request
↓     ----------------    ↓
↓           |||           ↓
↓     ----------------    ↓
↓     | Exec Poisons |    ↓ --> If all rules passed, then poison the HTTP flow
↓     ----------------    ↓
↓        /       \        ↓
↓        \       /        ↓
↓   -------------------   ↓
↓   | HTTP dispatcher |   ↓ --> Proxy the HTTP traffic, either poisoned or not
↓   -------------------   ↓


Installation

npm install toxy


Download

الاثنين، 24 أغسطس 2015

SONAR: A Framework For Identifying And Launching Exploits Against Internal Network Hosts


SONAR: A Framework For Identifying And Launching Exploits Against Internal Network Hosts

Works via WebRTC IP scanning combined with external resource fingerprinting.

How does it work?

Upon loading the sonar payload in a modern web browser the following will happen:
  • sonar will use WebRTC to scan the internal network for live hosts.
  • If a live host is found, sonar begins to attempt to fingerprint the host by linking to it via <img src="x"> and <link rel="stylesheet" type="text/css" href="x"> and hooking the onload event. If the expected resources load successfully it will trigger the pre-set JavaScript callback to start the user-supplied exploit.
  • If the user changes networks, sonar starts the process all over again on the newly joined network.

Fingerprints

Sonar works off of a database of fingerprints. A fingerprint is simply a list of known resources on a device that can be linked to and detected via onload. Examples of this include images, CSS stylesheets, and even external JavaScript.

An example fingerprint database can be seen below:

var fingerprints = [
    {
        'name': "ASUS RT-N66U",
        'fingerprints': ["/images/New_ui/asustitle.png","/images/loading.gif","/images/alertImg.png","/images/New_ui/networkmap/line_one.png","/images/New_ui/networkmap/lock.png","/images/New_ui/networkmap/line_two.png","/index_style.css","/form_style.css","/NM_style.css","/other.css"],
        'callback': function( ip ) {
            // Insert exploit here
        },
    },
    {
        'name': "Linksys WRT54G",
        'fingerprints': ["/UILinksys.gif","/UI_10.gif","/UI_07.gif","/UI_06.gif","/UI_03.gif","/UI_02.gif","/UI_Cisco.gif","/style.css"],
        'callback': function( ip ) {
            // Insert exploit here
        },
    },
]

The above database contains fingerprints for two devices, the ASUS RT-N66U WiFi router and the Linksys WRT54G WiFi router.

Each database entry has the following:

  • name: A field to identify what device the fingerprint is for. This could be something like HP Officejet 4500 printer or Linksys WRT54G Router.
  • fingerprints: This is an array of relative links to resources such as CSS stylesheets, images, or even JavaScript files. If you expect these resources to be on a non-standard port such as 8080, set the resource with the port included: :8080/unique.css. Keep in mind using external resources with active content such as JavaScript is dangerous as it can interrupt the regular flow of execution.
  • callback: If all of these resources are found to exist on the enumerated host then the callback function is called with a single argument of the device's IP address.
  • By creating your own fingerprints you can build custom exploits that will be launched against internal devices once they are detected by sonar. Common exploits include things such as Cross-site Request Forgery (CSRF), Cross-site Scripting (XSS), etc. The idea being that you can use these vulnerabilities to do things such as modifying router DNS configurations, dumping files from an internal fileserver, and more.

For an easier way to create fingerprints, see the following Chrome extension which generates fingerprint template code automatically for the page you're on:

Click Here to Install Chrome Extension



What can be done using sonar?

By using sonar a pentesting team can build web exploits against things such as internal logging servers, routers, printers, VOIP phones, and more. Due to internal networks often being less guarded, attacks such as CSRF and XSS can be powerful to take over the configurations of devices on a hosts internal network.

Download