Leaderboard

USENIX Publicat pe 15 sept. 2017 Philipp Koppe, Benjamin Kollenda, Marc Fyrbiak, Christian Kison, Robert Gawlik, Christof Paar, and Thorsten Holz, Ruhr-University Bochum Microcode is an abstraction layer on top of the physical components of a CPU and present in most general-purpose CPUs today. In addition to facilitate complex and vast instruction sets, it also provides an update mechanism that allows CPUs to be patched in-place without requiring any special hardware. While it is well-known that CPUs are regularly updated with this mechanism, very little is known about its inner workings given that microcode and the update mechanism are proprietary and have not been throughly analyzed yet. In this paper, we reverse engineer the microcode semantics and inner workings of its update mechanism of conventional COTS CPUs on the example of AMD’s K8 and K10 microarchitectures. Furthermore, we demonstrate how to develop custom microcode updates. We describe the microcode semantics and additionally present a set of microprograms that demonstrate the possibilities offered by this technology. To this end, our microprograms range from CPU-assisted instrumentation to microcoded Trojans that can even be reached from within a web browser and enable remote code execution and cryptographic implementation attacks. View the full program: https://www.usenix.org/sec17/program

Asta-i HACKING! Nu apostrof si pupacel in site-ul lui Maruta sau mai stiu eu ce labar nenorocit.

New surveillance campaigns utilizing FinFisher, infamous spyware known also as FinSpy and sold to governments and their agencies worldwide, are in the wild. Besides featuring technical improvements, some of these variants have been using a cunning, previously-unseen infection vector with strong indicators of major internet service provider (ISP) involvement. FinFisher has extensive spying capabilities, such as live surveillance through webcams and microphones, keylogging, and exfiltration of files. What sets FinFisher apart from other surveillance tools, however, are the controversies around its deployments. FinFisher is marketed as a law enforcement tool and is believed to have been used also by oppressive regimes. We discovered these latest FinFisher variants in seven countries; unfortunately, we cannot name them so as not to put anyone in danger. Infecting the targets FinFisher campaigns are known to have used various infection mechanisms, including spearphishing, manual installations with physical access to devices, 0-day exploits, and so-called watering hole attacks – poisoning websites the targets are expected to visit (which we observed to serve a mobile version of FinFisher, for example). What’s new – and most troubling – about the new campaigns in terms of distribution is the attackers’ use of a man-in-the-middle attack with the “man” in the middle most likely operating at the ISP level. We have seen this vector being used in two of the countries in which ESET systems detected the latest FinFisher spyware (in the five remaining countries, the campaigns have relied on traditional infection vectors). When the user – the target of surveillance – is about to download one of several popular (and legitimate) applications, they are redirected to a version of that application infected with FinFisher. The applications we have seen being misused to spread FinFisher are WhatsApp, Skype, Avast, WinRAR, VLC Player and some others. It is important to note that virtually any application could be misused in this way. The attack starts with the user searching for one of the affected applications on legitimate websites. After the user clicks on the download link, their browser is served a modified link and thus redirected to a trojanized installation package hosted on the attacker’s server. When downloaded and executed, it installs not only the intended legitimate application, but also the FinFisher spyware bundled with it. Figure 1: Infection mechanism of latest FinFisher variants The redirection is achieved by the legitimate download link being replaced by a malicious one. The malicious link is delivered to the user’s browser via an HTTP 307 Temporary Redirect status response code indicating that the requested content has been temporarily moved to a new URL. The whole redirection process occurs without the user’s knowledge and is invisible to the naked eye. Figure 2: Detailed infection mechanism of latest FinFisher variants FinFisher: All about flying under the radar The latest version of FinFisher has also received technical improvements, its authors putting even greater focus on stealth. The spyware uses custom code virtualization to protect the majority of its components, including the kernel-mode driver. In addition, the entire code is filled with anti-disassembly tricks. We found numerous anti-sandboxing, anti-debugging, anti-virtualization and anti-emulation tricks in the spyware. All this makes the analysis more complicated. After overcoming the first level of protection (anti-disassembly), the next level – code virtualization – awaits. The virtual machine dispatcher has 34 handlers; the spyware is executed almost entirely within an interpreter, which adds another layer to be dealt with during the analysis. Figure 3: Visualization of the many virtual machine handlers that complicate code analysis We will release a more detailed technical analysis of the latest FinFisher variant in an upcoming whitepaper. Special treatment for privacy-concerned users While analyzing the recent campaigns, we discovered an interesting sample: FinFisher spyware masqueraded as an executable file named “Threema”. Such a file could be used to target privacy-concerned users, as the legitimate Threema application provides secure instant messaging with end-to-end encryption. Ironically, getting tricked into downloading and running the infected file would result in the privacy-seeking user being spied upon. This special focus on users seeking encryption software is not limited solely to end-to-end communicators, apparently. During our research, we have also found an installation file of TrueCrypt – the once-very-popular disk encryption software – trojanized with FinFisher. Who is the “man” in the middle? It would be technically possible for the “man” in these man-in-the-middle attacks to be situated at various positions along the route from the target’s computer to the legitimate server (e.g. compromised Wi-Fi hotspots). However, the geographical dispersion of ESET’s detections of latest FinFisher variants suggests the MitM attack is happening at a higher level – an ISP arises as the most probable option. This assumption is supported by a number of facts: First, according to leaked internal materials that have been published by WikiLeaks, the FinFisher maker offered a solution called “FinFly ISP” to be deployed on ISP networks with capabilities matching those necessary for performing such a MitM attack. Second, the infection technique (using the HTTP 307 redirect) is implemented in the very same way in both of the affected countries, which is very unlikely unless it was developed and/or provided by the same source. Third, all affected targets within a country are using the same ISP. Finally, the very same redirection method and format have been used for internet content filtering by internet service providers in at least one of the affected countries. The deployment of the ISP-level MitM attack technique mentioned in the leaked documents has never been revealed – until now. If confirmed, these FinFisher campaigns would represent a sophisticated and stealthy surveillance project unprecedented in its combination of methods and reach. Has my computer been infected? / Am I being spied on? All ESET products detect and block this threat as Win32/FinSpy.AA and Win32/FinSpy.AB. Using ESET’s Free Online Scanner, you can check your computer for its presence and remove it if detected. ESET customers are protected automatically. IoCs ESET detection names: Win32/FinSpy.AA Win32/FinSpy.AB Redirect: HTTP/1.1 307 Temporary Redirect\r\nLocation:URL\r\nConnection: close\r\n\r\n List of URL’s we found during our investigation: hxxp://108.61.165.27/setup/TrueCrypt-7.2.rar hxxp://download.downloading.shop/pcdownload.php?a=dad2f8ed616d2bfe2e9320a821f0ee39 hxxp://download.downloading.shop/pcdownload.php?a=84619b1b3dc8266bc8878d2478168baa hxxp://download.downloading.shop/pcdownload.php?a=ddba855c17da36d61bcab45b042884be hxxp://download.downloading.shop/pcdownload.php?a=d16ef6194a95d4c8324c2e6673be7352 hxxp://download.downloading.shop/pcdownload.php?a=95207e8f706510116847d39c32415d98 hxxp://download.downloading.shop/pcdownload.php?a=43f02726664a3b30e20e39eb866fb1f8 hxxp://download.downloading.shop/pcdownload.php?a=cb858365d08ebfb029083d9e4dcf57c2 hxxp://download.downloading.shop/pcdownload.php?a=8f8383592ba080b81e45a8913a360b27 hxxp://download.downloading.shop/pcdownload.php?a=e916ba5c43e3dd6adb0d835947576123 hxxp://download.downloading.shop/pcdownload.php?a=96362220acc8190dcd5323437d513215 hxxp://download.downloading.shop/pcdownload.php?a=84162502fa8a838943bd82dc936f1459 hxxp://download.downloading.shop/pcdownload.php?a=974b73ee3c206283b6ee4e170551d1f7 hxxp://download.downloading.shop/pcdownload.php?a=cd32a3477c67defde88ce8929014573d hxxp://download.downloading.shop/pcdownload.php?a=36a5c94ffd487ccd60c9b0db4ae822cf hxxp://download.downloading.shop/pcdownload.php?a=0ebb764617253fab56d2dd49b0830914 hxxp://download.downloading.shop/pcdownload.php?a=f35e058c83bc0ae6e6c4dffa82f5f7e7 hxxp://download.downloading.shop/pcdownload.php?a=64f09230fd56149307b35e9665c6fe4c hxxp://download.downloading.shop/pcdownload.php?a=b3cc01341cb00d91bcc7d2b38cedc064 hxxp://download.downloading.shop/pcdownload.php?a=5fc0440e395125bd9d4c318935a6b2b0 hxxp://download.downloading.shop/pcdownload.php?a=5ca93ad295c9bce5e083faab2e2ac97a hxxp://download.downloading.shop/pcdownload.php?a=f761984bb5803640aff60b9bc2e53db7 hxxp://download.downloading.shop/pcdownload.php?a=5ca93ad295c9bce5e083faab2e2ac97a hxxp://download.downloading.shop/pcdownload.php?a=514893fa5f3f4e899d2e89e1c59096f3 hxxp://download.downloading.shop/pcdownload.php?a=a700af6b8a49f0e1a91c48508894a47c hxxp://download.downloading.shop/pcdownload.php?a=36a5c94ffd487ccd60c9b0db4ae822cf hxxp://download.downloading.shop/pcdownload.php?a=a700af6b8a49f0e1a91c48508894a47c hxxp://download.downloading.shop/pcdownload.php?a=395ce676d1ebc1048004daad855fb3c4 hxxp://download.downloading.shop/pcdownload.php?a=cd32a3477c67defde88ce8929014573d hxxp://download.downloading.shop/pcdownload.php?a=49d6d828308e99fede1f79f82df797e9 hxxp://download.downloading.shop/pcdownload.php?a=d16ef6194a95d4c8324c2e6673be7352 Samples (SHA-1) ca08793c08b1344ca67dc339a0fb45e06bdf3e2f 417072b246af74647897978902f7d903562e0f6f c4d1fb784fcd252d13058dbb947645a902fc8935 e3f183e67c818f4e693b69748962eecda53f7f88 d9294b86b3976ddf89b66b8051ccf98cfae2e312 a6d14b104744188f80c6c6b368b589e0bd361607 417072b246af74647897978902f7d903562e0f6f f82d18656341793c0a6b9204a68605232f0c39e7 df76eda3c1f9005fb392a637381db39cceb2e6a8 5f51084a4b81b40a8fcf485b0808f97ba3b0f6af 4b41f36da7e5bc1353d4077c3b7ef945ddd09130 1098ba4f3da4795f25715ce74c556e3f9dac61fc d3c65377d39e97ab019f7f00458036ee0c7509a7 c0ad9c242c533effd50b51e94874514a5b9f2219 a16ef7d96a72a24e2a645d5e3758c7d8e6469a55 c33fe4c286845a175ee0d83db6d234fe24dd2864 cfa8fb7c9c3737a8a525562853659b1e0b4d1ba8 9fc71853d3e6ac843bd36ce9297e398507e5b2bd 66eccea3e8901f6d5151b49bca53c126f086e437 400e4f843ff93df95145554b2d574a9abf24653f fb4a4143d4f32b0af4c2f6f59c8d91504d670b41 f326479a4aacc2aaf86b364b78ed5b1b0def1fbe 275e76fc462b865fe1af32f5f15b41a37496dd97 df4b8c4b485d916c3cadd963f91f7fa9f509723f 220a8eacd212ecc5a55d538cb964e742acf039c6 3d90630ff6c151fc2659a579de8d204d1c2f841a Source: https://www.welivesecurity.com/2017/09/21/new-finfisher-surveillance-campaigns/

Hijacker Hijacker is a Graphical User Interface for the penetration testing tools Aircrack-ng, Airodump-ng, MDK3 and Reaver. It offers a simple and easy UI to use these tools without typing commands in a console and copy&pasting MAC addresses. This application requires an ARM android device with a wireless adapter that supports Monitor Mode. A few android devices do, but none of them natively. This means that you will need a custom firmware. Nexus 5 and any other device that uses the BCM4339 chipset (MSM8974, such as Xperia Z2, LG G2 etc) will work with Nexmon (it also supports some other chipsets). Devices that use BCM4330 can use bcmon. An alternative would be to use an external adapter that supports monitor mode in Android with an OTG cable. The required tools are included for armv7l and aarch64 devices as of version 1.1. The Nexmon driver and management utility for BCM4339 are also included. Root is also necessary, as these tools need root to work. Features Information Gathering View a list of access points and stations (clients) around you (even hidden ones) View the activity of a specific network (by measuring beacons and data packets) and its clients Statistics about access points and stations See the manufacturer of a device (AP or station) from the OUI database See the signal power of devices and filter the ones that are closer to you Save captured packets in .cap file Attacks Deauthenticate all the clients of a network (either targeting each one (effective) or without specific target) Deauthenticate a specific client from the network it's connected MDK3 Beacon Flooding with custom options and SSID list MDK3 Authentication DoS for a specific network or to everyone Capture a WPA handshake or gather IVs to crack a WEP network Reaver WPS cracking (pixie-dust attack using NetHunter chroot and external adapter) Other Leave the app running in the background, optionally with a notification Copy commands or MAC addresses to clipboard Includes the required tools, no need for manual installation Includes the nexmon driver and management utility for BCM4339 devices Set commands to enable and disable monitor mode automatically Crack .cap files with a custom wordlist Create custom actions and run them on an access point or a client easily Sort and filter Access Points with many parameters Export all the gathered information to a file Add an alias to a device (by MAC) for easier identification More Screenshots Installation Make sure: you are on Android 5+ you are rooted (SuperSU is required, if you are on CM/LineageOS install SuperSU) have a firmware to support Monitor Mode on your wireless interface Download the latest version here. When you run Hijacker for the first time, you will be asked whether you want to install the nexmon firmware or go to home screen. If you have installed your firmware or use an external adapter, you can just go to the home screen. Otherwise, click 'Install Nexmon' and follow the instructions. Keep in mind that on some devices, changing files in /system might trigger an Android security feature and your system partition will be restored when you reboot. After installing the firmware you will land on the home screen and airodump will start. Make sure you have enabled your WiFi and it's in monitor mode. Troubleshooting This app is designed and tested for ARM devices. All the binaries included are compiled for that architecture and will not work on anything else. You can check by going to settings: if you have the option to install nexmon, then you are on the correct architecture, otherwise you will have to install all the tools manually (busybox, aircrack-ng suite, mdk3, reaver, wireless tools, libfakeioctl.so library) and set the 'Prefix' option for the tools to preload the library they need. In settings, there is an option to test the tools. If something fails, then you can click 'Copy test command' and select the tool that fails. This will copy a test command to your clipboard, which you can run in a terminal and see what's wrong. If all the tests pass and you still have a problem, feel free to open an issue here to fix it, or use the 'Send feedback' feature of the app in settings. If the app happens to crash, a new activity will start which will generate a report in your external storage and give you the option to send it directly or by email. I suggest you do that, and if you are worried about what will be sent you can check it out yourself, it's just a txt file in your external storage directory. The part with the most important information is shown in the activity. Please do not report bugs for devices that are not supported or when you are using an outdated version. Keep in mind that Hijacker is just a GUI for these tools. The way it runs the tools is fairly simple, and if all the tests pass and you are in monitor mode, you should be getting the results you want. Also keep in mind that these are AUDITING tools. This means that they are used to TEST the integrity of your network, so there is a chance (and you should hope for it) that the attacks don't work on your network. It's not the app's fault, it's actually something to be happy about (given that this means that your network is safe). However, if an attack works when you type a command in a terminal, but not with the app, feel free to post here to resolve the issue. This app is still under development so bugs are to be expected. Warning Legal It is highly illegal to use this application against networks for which you don't have permission. You can use it only on YOUR network or a network that you are authorized to. Using a software that uses a network adapter in promiscuous mode may be considered illegal even without actively using it against someone, and don't think for a second it's untracable. I am not responsible for how you use this application and any damages you may cause. Device The app gives you the option to install the nexmon firmware on your device. Even though the app performs a chipset check, you have the option to override it, if you believe that your device has the BCM4339 wireless adapter. However, installing a custom firmware intended for BCM4339 on a different chipset can possibly damage your device (and I mean hardware, not something that is fixable with factory reset). I am not responsible for any damage caused to your device by this software. Consider yourself warned. Donate If you like my work, you can buy me a beer. Sursa: https://github.com/chrisk44/Hijacker

HACK THE HACKER – FUZZING MIMIKATZ ON WINDOWS WITH WINAFL & HEATMAPS (0DAY) On 22. Sep In this blogpost, I want to explain two topics from a theoretical and practical point of view: How to fuzz windows binaries with source code available (this part is for developers) and How to deal with big input files (aka heatmap fuzzing) and crash analysis (for security consultants; more technical) Since this blog post got too long and I didn’t want to remove important theory, I marked background knowledge with grey color. Feel free to skip these sections if you are already familiar with this knowledge. If you are only interested in the exploitable mimikatz flaws you can jump to chapter “Practice: Analysis of the identified crashes“. I (René Freingruber from SEC Consult Vulnerability Lab) am going to give a talk at heise devSec (and IT-SECX and DefCamp) about fuzzing binaries for developers and therefore I wanted to test different approaches to fuzz windows applications where source code is available (the audience are most likely developers). To my knowledge there are several blog posts talking about fuzzing Linux applications with AFL or libfuzzer (just compile the application with afl-gcc instead of gcc or add some flags to clang), but there is no blog post explaining the concept and setup for Windows. This blog post tries to fill this gap. Fuzzing is a very important concept during development and therefore all developers should know how to do it correctly and that such a setup can be simple and fast! WHY I CHOSE MIMIKATZ AS FUZZING TARGET To demonstrate fuzzing I had to find a good target where source code is available. At the same time, I wanted to learn more about the internals of the application by reading the source code. Therefore, my decision fell on mimikatz because it’s an extremely useful tool for security consultants (and hackers) and I always wanted to understand how mimikatz internally works. Mimikatz is a powerful hacker tool for Windows which can be used to extract plaintext credentials, hashes of currently logged on users, machine certificates and many other things. Moreover, mimikatz contains over 261 000 lines of code, must parse many different data structures and is therefore likely to be affected by vulnerabilities itself. At this point I also want to say that penetration testing would not be the same without the amazing work of Benjamin Delpy gentilkiwi, the author of mimikatz. The next thing I need is a good attack vector. Why should I search for vulnerabilities if there is no real attack vector which can trigger the vulnerability? Mimikatz can be used to dump cleartext credentials and hashes of currently logged in users from the LSASS process. But if there exists a bug in the parsing code of mimikatz, what exactly could I achieve with this? I could just exploit myself because mimikatz gets executed on the same system. Well, not always. As it turns out, well-educated security consultants and hackers do not directly invoke mimikatz on the owned system. Instead, it’s nowadays widespread practice to create a minidump of the LSASS process on the owned system, download it and invoke mimikatz locally (on the attacker system). Why do we do this? Because dropping mimikatz on the owned system could trigger all kind of alerts (AntiVirus, Application Whitelisting, Windows Logs, …) and because we want to stay under the radar, we don’t want these alerts. Instead, we can use Microsoft signed binaries to dump the LSASS process (e.g.: Task manager, procdump.exe, msbuild.exe or sqldumper.exe). Now we have a good attack vector! We can create a honeypot, inject some malicious stuff into our own LSASS process, wait until a hacker owns it, dumps the LSASS process and invokes mimikatz on his own system reading our manipulated memory dump file and watch reverse shells coming in! This and similar attack vectors can be interesting features in the future for deception technologies such as CyberTrap (https://www.cybertrap.com/). To be fair, exploiting this scenario can be quite difficult because mimikatz is compiled with protections, such as ASLR and DEP, and exploitation of such a client-side application is extremely challenging (we don’t have the luxury of a remote memory leak nor of scripting possibilities such as with browsers or PDF readers). However, such client-side scriptless exploits are not impossible, for example see https://scarybeastsecurity.blogspot.co.at/2016/11/0day-exploit-advancing-exploitation.html. To my surprise, mimikatz contained a very powerful vulnerability which allows us to bypass ASLR (and DEP). THEORY: FUZZING WINDOWS BINARIES We don’t want to write a mimikatz-specific fuzzer (with knowledge about the parsing structures, implemented checks and so on), instead, we want to use something which is called “coverage-guided fuzzing” (or feedback-based fuzzing). This means we want to extract code coverage information during fuzzing. If one of our mutated input files (the memory dump files) generate more code coverage in mimikatz, we want to add it to our fuzzing queue and fuzz this input later as well. That means we start with one dump file and the fuzzer identifies different code paths itself (ideally all) for us and therefore “learn” all the internal parsing logic autonomously! This also means that we only have to write a fuzzer one time and can use it against nearly all kinds of applications! Luckily for us, we don’t even have to write such a fuzzer because someone else already did an excellent job! Currently the most commonly used fuzzer is called AFL (American fuzzy lop) and implements exactly this idea. It turned out that AFL is extremely effective in identifying vulnerabilities. In my opinion, this is because of four major characteristics of AFL: It is extremely fast. It extracts edge coverage (with hit count) and not only code coverage which simplified means that we try to maximize executed “paths” and not “code” (E.g. if we have an IF statement, code coverage would put the input file which executes the code inside the IF into the queue. Edge coverage on the other side would put one entry with, and one entry without the IF body-code into the queue.). Because of 1) it can implement deterministic mutation (do every operation on every byte/bit of the input). More on this later when talking about heatmap fuzzing. It’s extremely simple to use. Fuzzing can be started within several minutes! The big question is now: How does AFL extract the code/edge coverage information? The answer depends on the configured mode of AFL. The default option is to “hack” generated object files from gcc and insert at all possible code locations instrumentation code. There is also a LLVM mode where a LLVM compiler pass is used to insert the instrumentation. And then there is a qemu mode if source code is not available which emulates the binary and adds instrumentation via qemu. There are several forks which extend AFL with other instrumentation possibilities. For example, hardware features can also be used to extract code coverage (WinAFL-IntelPT, kAFL). Another idea is to use dynamic instrumentation frameworks such as PIN or DynamoRio (e.g. WinAFL). These frameworks can dynamically instrument (during runtime) the target binary which means that a dispatcher loads the next instructions which should be executed and adds additional instrumentation code before (and after) them. All that requires dynamic relocation of the instructions while being completely transparent to the target application. This is quite complicated but the framework hides all that logic from the user. Obviously, this approach is not fast (but works on Windows and has many cool features for the future!). When source code is available, I thought that there should be the same possibility as AFL does on Linux (with GCC). My first attempt was to use “libfuzzer” on Windows. Libfuzzer is a fuzzer like AFL but it acts on function level fuzzing and is therefore more suitable for developers. AFL fuzzes full binaries per default but can also be started in a persistent mode where it fuzzes on function level. Libfuzzer uses the feature “Source-based code coverage” from the LLVM clang compiler which is exactly what I wanted to use for coverage-information on Windows. After some initial errors I could compile mimikatz with LLVM on Windows. When adding the flags for “source-based code coverage” I got again some errors which can be fixed by adding the required libraries to the linker include paths. However, this flag added the same functions to all object files which resulted in linker errors. The only way I could solve this was to merge all .c files into one huge file. Since this approach was more a pain than anything else, I didn’t pursue it further for the talk. Note that using LLVM for application analysis on Windows could be a very interesting approach in the future! The next thing I tested was WinAFL in syzygy mode and this was exactly what I was looking for! For a more detailed description of syzygy see https://doar-e.github.io/blog/2017/08/05/binary-rewriting-with-syzygy/. At this point I want to thank Ivan Fratric (developer of WinAFL) and Axel 0vercl0k Souchet (developer of the syzygy mode) for their amazing job and of course Michal Zalewski for AFL! PRACTICE: FUZZING WINDOWS BINARIES You can download WinAFL from here: https://github.com/ivanfratric/winafl All we must do is include the header and add the code: While(__afl_persistent_loop()) { // code to fuzz } to the project which we want to fuzz and compile a 32-bit application with the /PROFILE linker flag (Visual Studio -> project properties -> Linker -> Advanced -> Profile). For mimikatz I removed the command prompt code from the wmain function (inside mimikatz.c) and just called kuhl_m_sekurlsa_all(argc,argc) because I wanted to directly dump the hashes/passwords from the minidump (issue the sekurlsa::logonpasswords command at program invocation). Since mimikatz would extract this information per default from the LSASS process I added a line inside kuhl_m_sekurlsa_all() to load the dump instead. Moreover, I added the persistent loop inside this function. Here is how my new kuhl_m_sekurlsa_all() function looks: NTSTATUS kuhl_m_sekurlsa_all(int argc, wchar_t *argv[]) { While(__afl_persistent_loop()) { kuhl_m_sekurlsa_reset(); // sekurlsa::minidump command pMinidumpName = argv[1]; // sekurlsa::minidump command kuhl_m_sekurlsa_getLogonData(lsassPackages, ARRAYSIZE(lsassPackages); // sekurlsa::logonpasswords command } Return NT_SUCCESS; } Hint: Do not use the above code during fuzzing. I added a subtle flaw, which I’m going to explain later. Can you already spot it? After compilation, we can start the binary and see some additional messages: The next step is to instrument the code. For this to work we must register “msdia140.dll”. This can be done via the command: Regsvr32 C:\path\to\msdia140.dll Then we can call the downloaded instrument.exe binary with the generated mimikatz.exe and mimikatz.pdb file to add the instrumentation: We can start the instrumented binary and see the adapted status message: Now we can generate a minidump file for mimikatz (on a Windows 7 x86 test system I used task manager to dump the LSASS process), put it into the input directory and start fuzzing: As we can see, we have a file size problem! THEORY: FUZZING AND THE INPUT FILE SIZE PROBLEM We can see that AFL restricts input files to a maximum size of 1 MB. Why? Recall, that AFL is doing deterministic fuzzing before switching to random fuzzing for each queue input. That means that it is doing specific bit and byte flips/additions/removals/… for every (!) byte/bit in the input! This includes several strategies like bitflip 1/1, bitflip 2/1, …, arith 8/8, arith 16/8 and so on. For example, bitflip 1/1 means that AFL flips 1 bit per execution and then walks forward 1 bit to flip the next bit. Whereas 2/1 means that 2 bits are flipped and the step length is 1 bit. Arith 16/8 means that the step is 8 and that AFL tries to add interesting values to a value treated as 16-bit integer. And there are several more such deterministic fuzzing strategies. All these strategies have in common that the number of required application executions depend on the file size! Let’s just assume that AFL only (!) does the bitflip 1/1 deterministic strategy. This means that we must execute the target application exactly input-filesize (bit) number of times. WinAFL is doing in-memory fuzzing which means that we don’t have to start the application every time, but let’s forget this for now so that our discussion does not get too complicated. Let’s say that our input binary has a size of 10 kB. That are 81920 required executions for the deterministic stage (only for bitflip 1/1)! AFL conducts many more deterministic strategies. For AFL on Linux this is not very huge, it’s not uncommon to get execution speeds of 1000 – 8000 executions / second (because of the fork-server, persistent-mode, …) per core. This fast execution speed together with deterministic fuzzing (and edge coverage) made AFL so successful. So, if we have 16 cores we can easily do this strategy for one input file within a second. Now let’s assume that our input has a size of 1 MB (AFL limit), which means 8 388 608 required executions for the bitflip 1/1 and that our target application is a little bit slower because it’s bigger and running on Windows (200 exec / sec) and that we just have one core available for fuzzing. Then we need 11,5 hours only to finish the bitflip 1/1 for one input entry! Recall that we must conduct this deterministic stage for every new queue entry (every time we identify new coverage, we must do this again! It’s not uncommon that the queue grows up to several thousand inputs). And if we consider all the other deterministic operations which must be performed, the situation becomes even worse. And in our case the input (memory dump) has a size of 27 MB! This would be 216 036 224 required executions only for bitflip 1/1. AFL detects this and directly aborts because this would just take too long (and AFL would never find vulnerabilities because it’s stuck inside deterministic fuzzing). Of course, we can tell AFL to skip deterministic fuzzing, but that would not be very good because we still have to find the special byte/bit flip which triggers the vulnerability. And the likelihood for this in such a big input file is not very high…. Here is a cite from Michal Zalewski (author of AFL) from the perf_tips.txt document: To illustrate, let’s say that you’re randomly flipping bits in a file, one bit at a time. Let’s assume that if you flip bit #47, you will hit a security bug; flipping any other bit just results in an invalid document. Now, if your starting test case is 100 bytes long, you will have a 71% chance of triggering the bug within the first 1,000 execs – not bad! But if the test case is 1 kB long, the probability that we will randomly hit the right pattern in the same timeframe goes down to 11%. And if it has 10 kB of non-essential cruft, the odds plunge to 1%. The key learning is that input file size is very important during fuzzing! At least as important as plain execution speed of the fuzzer! There are tools and scripts shipped with AFL (cmin/tmin) to minimize the number of input files and the file size. However, I don’t want to talk about them in this blog post. They shrink files via a fuzzing attempt and since the problem is NP-hard they use heuristics. Tmin is also very slow (execution time depends on the file size…) and often leads to problems with files containing offsets (like our dump file) and checksums. Another idea could be to start WinAFL with an empty input file. However, memory dumps are quite complex and I don’t want to “waste” time while WinAFL identifies the format. And here is where heatmaps come into play. PRACTICE: FUZZING AND HEATMAPS My first attempt to minimize the input file was to read the source code of mimikatz and understand how it finds the important memory regions (containing the plaintext passwords and hashes) in the memory dump. I assumed some kind of pattern-search, however, mimikatz parses and uses lots of structures and I quickly discarded the idea of manually creating a smaller input binary by understanding mimikatz. During fuzzing we also don’t want to understand the application to write a specific fuzzer, instead we want that the fuzzer learns everything itself. If we could somehow give the fuzzer the same ability to detect the “important input bytes”… During reading the code I identified something interesting. Mimikatz loads the memory dump via kernel32!MapViewOfFile(). After that it reads nearly all required information from there (sometimes it also copies it via kull_m_minidump_copy, but let’s not get too complicated for the moment). If we can log all memory access attempts to this memory region, we can easily reduce the number of required executions drastically! If mimikatz does not touch a specific memory region, why should we even fuzz the bytes there? Here is a heat map which I generated based on memory read operations from mimikatz on my 27 MB input file (generated via a plotly python script): The black area is never read by mimikatz. The brighter the area, the more memory read operations accessed this region. The start of the file is located at the left bottom of the picture. I print 1000 bytes per line (from left to right), then go one line up and print the next 1000 bytes and so on. At this zoom level, we do not see access attempts to the start (header) of the memory dump. However, this is only because the file size is 27 MB and therefore the smaller red/yellow/white dots are not visible. But we can zoom in: The most important message from the above pictures: We do not have to fuzz the bytes from the black area! But we can even do better, we can start fuzzing the white bytes (many read attempts, like offset 0xaa00 which gets read several thousand times), then continue with yellow bytes (e.g.: offset 0x08 is read several hundred times) and then red areas (which are only read 1-5 times). This itself is not a perfect approach (more read attempts also mean that the likelihood that the input becomes invalid gets higher and therefore it’s maybe not the best idea to start with white areas but since we must do the full deterministic step it basically does not matter with which offsets we start; Hint: A better strategy is to also consider the triggering read-instruction address together with the hitcounts). You are maybe wondering how I extracted the memory-read information. For mimikatz I just used a stupid PoC debugger script, however, I’m currently developing a more sophisticated script with the use of dynamic instrumentation frameworks which can extract such information from any application. The use of a debugger script is “stupid” because it’s very slow and does not work for every application. However, for mimikatz it worked fine because mimikatz reads most of the time from the region which is mapped via MapViewOfFile(). My WinAppDbg script is very simple, I just use the Api-Hooking mechanism of WinAppDbg to hook the post-routine of MapViewOfFile. The return value contains the memory address where the input memory dump is loaded. I placed a memory breakpoint on it and at every breakpoint hit I just log the relative offset and increment the hit counter. You can also extend this script to become more complex (e.g.: hook kull_m_memory_search() or kull_m_minidump_copy(). For reference, here is the script: We start mimikatz via the debugger, as soon as mimikatz finishes (debug.loop() returns), we just sort the offsets based on the hit counts and dump them to a log file. This is the code which hooks MapViewOfFile to obtain the base address of our input in-memory. This code also adds the memory breakpoint (watch_buffer() method) and invokes memory_breakpoint_callback every time an instruction reads from our input. Hint: WinAppDbg has a bug inside watch_buffer() which does not return the bw variable. If the script should be extended (e.g. to disable the memory breakpoint for search-functions), the WinAppDbg source must be modified to return the “bw” variable in the watch_buffer() function. All left is the callback function: I used capstone to disassemble the triggering instruction to obtain the size of the read operation to update the offsets correctly. As you can see, there is no magic involved and the script is really simple (at least this one which only works with mimikatz). The downside of the debugger memory breakpoint approach is that it is extremely slow. On my test system, this script executes approximately 30 minutes to execute mimikatz one time which is really slow (mimikatz without the script executes in under 1 second). However, we only have to do this once. Another down-side is that it does not work for all applications because typically applications copy input-bytes to other buffers and access them there. A more general approach is to write such a script with a dynamic instrumentation framework which is also much faster (on which I’m currently working on). Developing such a script is much harder because we have to use shadow memory for taint tracking, follow copies of tainted memory (this taint propagation is a complex part because it requires correct semantic understanding of the x86 instruction set) but store at the same time which byte depends on which input byte and this should be as fast as possible (for fuzzing) and does not consume too much memory (so it’s useable for big and complex applications like Adobe Reader or web browsers). Please note that there are some similiar solutions, most notable TaintScope (however, no source code or tool public available and it was just a PoC) or VUzzer (based on DataTracker/libdft which themself are based on PIN) and some other frameworks such as Triton (based on PIN) or Panda (based on Qemu) can also do taint analysis. The problem with these tools is that either source code and the tool is not public available, or it is very slow or it does not work on Windows or it does not propagate the file offset information (just marks data is tainted or not tainted) or they are written with PIN which itself is slower than DynamoRio. I’m developing my own tool here to fulfil the above mentioned conditions so that it is useful during fuzzing (works on Windows and Linux, is as fast as possible and does not consume too much memory for huge applications). Please also bear in mind that AFL ships with Tmin, which also tries to reduce the input file size. However, it does this via a fuzzy approach which is very slow (and can’t handle checksums and file offsets so well). We can also verify that the black bytes don’t matter by just removing (zeroing them out) from the input file: The above figure shows that the output of both files is exactly the same, therefore the black bytes really don’t matter. Now we can start fuzzing with a much smaller input file – only 91KB instead of 27MB! PRACTICE: FUZZING RESULTS / READING THE AFL STATUS SCREEN I first started a simple fuzzer (not WinAFL) because I first had to modify the WinAFL code to only fuzz the identified bytes. I recommend to start fuzzing as soon as possible with a simple fuzzer and while it is running work on a better version of the fuzzer. My first fuzzer was a 50 LoC python script which flipped bytes, invoked mimikatz over WinDbg and parsed the output to detect crashes. I started 8 parallel fuzzing jobs with this fuzzer on my 12 core home system (4 cores for private stuff). Three days later I had 28 unique crashes identified by WinDbg. My analysis scripts reduced them to 4 unique bugs in code (the 28 crashes are just variations of the same 4 bugs in the code). Execution speed was approximately 2 exec/sec per job, therefore 16 exec/sec in total on all cores (which is really slow). The first exploitable bug from the next chapter was found after 3 hours, the second exploitable bug was not found at all with this approach. I also modified WinAFL to fuzz only the heatmap bytes. My first approach was to use the “post_handler” which can be used for test-case post-processing (e.g. fixing checksums, however, it’s better to remove the checksum verification code from the target application). Since this handler is not called for dry-runs (the first executions from AFL) this will not work. Instead, write_to_testcase() can be modified. Inside the main function I copy the full memory dump to a heap buffer. In the input directory I stored a file containing only the heatmap bytes and therefore the file size is much smaller like 91KB or 3KB. Next I added code to write_to_testcase where I copy all bytes from the input file over the heap buffer at the correct positions. Therefore, AFL only sees the small files but passes the correct memory dumps to mimikatz. This approach has a little drawback though. As soon as one queue entry has a different size, fuzzing could become ineffective, but for this PoC it was enough. Later I’m going to invoke the heatmap calculation for every queue entry if a heuristic detects this as more efficient. Please also bear in mind that AFL and WinAFL write every testcase to disk. This means we have to write a 27 MB file per execution (also per in-memory execution like a simple bit flip!!). From performance perspective it would be way better if we modify the testcase inside the target application in-memory (we already do in-memory fuzzing and therefore this is possible). Then we can also skip all the process-switches from WinAFL to the target application and back and then we really get the benefit of in-memory fuzzing! We can do this by injecting the AFL code (or even python code… into the target application, an area on which I’m also currently working on. Here is a screenshot of my WinAFL output (running on a RAMDisk): Look at the different stats of the fuzzer. What do you see? Is this type of fuzzing good or not? Should we stop or continue? Here is the same screenshot with some colored boxes: First the good thing: We already identified 16 unique crashes and a total of 137 unique paths (inputs which result in unique coverage; see the green area). Now the bad: Fuzzing speed is only 13 exec / sec (blue) which is extremly slow for AFL (but much faster than the self-written fuzzer which had 2 exec/sec per core). And now the really bad stuff: We are running for 14,5 hours and it didn’t finish the bitflip 1/1 stage yet for the first input file (and 136 others are in queue). You can see this in the red area because we just finished 97% of this stage. And after that 2/1 and 4/1 must be executed, then byte flips, arithmetics and so on. So we can see that continuing will not be very efficient. For demonstration I kept the fuzzer running, but modified my WinAppDbg script to filter better and started a new fuzzing job. The new WinAppDbg script reduced the number of “hot bytes” to 3KB (first we had 27 MB, then we had 91KB and now we just have 3KB to fuzz). This was possible because the new script does not count hits from search or copy functions, but also log access attempts from copied memory regions. This WinAppDbg script was approximatly 800 LoC (because I have to follow copies which go to heap and stack variables and I have to disable logging when the variables are freed). Here is a screenshot of the above job (with the “big” 91KB input files) after 2 days and 7 hours: We can see that the fuzzer finished bitflip 1/1 and 2/1 and is now inside 4/1 (with 98% finished). You can also see that the bitflip 1/1 strategy required 737k executions and 159 of these 737k executions resulted in new coverage (or crashes). Same for 2/1 where the stats are 29/737k. And we found 22 unique crashes in 2 days and 7 hours. And now the fuzzing of the smaller 3KB files after 2 hours: We can see that we already have 30 unique crashes after 2 hours! (Compare this with only 22 crashes after 2 days and 7 hours with the 91KB file!) We can also see that for example the bitflip 1/1 stage only required 17.9k executions (instead of 737k) because of the reduced input file size. Moreover, we can see that we found 245 unique paths and this with just 103k total executions (compared to 184 unique paths with 2.17 million executions from the 91KB test input). And now consider how long it would have taken us to fuzz the full 27MB file (!!) and what results we would have seen after some days of fuzzing. Now you should understand the importance of the input file size. Here is one more demonstration of the different input file sizes. The following animated image (created via Veles https://github.com/wapiflapi/veles) shows a visualization of the 27 MB original minidump file: And now the 27 MB minidump file where all unimportant (not read) bytes are replaced with 0x00 so we only see the 3 KB bytes which we fuzz with WinAFL; you maybe have to zoom in to see them. Look at the intersection of the 3 coordinate axes. However, in my opinion even the 3KB fuzzing job is too slow / inefficient. If we can start the job on multiple cores and let it run over one or two weeks, we should get into deeper levels and the result should be OK. But why are we even so slow? Why do we only have an execution speed of 13 or 16 exec / sec? Later queue entries will result in faster execution speeds because mimikatz will not execute the full code because the inputs trigger error-conditions (which result in execution speeds like 60 exec / sec). But on Linux we often deal with execution speeds of several thousand executions per second. A major point is that we have to load and search a 27MB file with every execution, so reducing this file size could really be a good idea (but requires lots of manual work). On the other hand, we can compare the execution speeds of different setups: Execution speed with WinAFL in syzygy mode: ~13 exec / sec Native execution speed without WinAFL and without instrumentation (in-memory): ~335 exec / sec Execution without WinAFL but with instrumented (syzygy) binary: ~50 exec / sec Execution of native binary (Instrumentation via DynamoRio drcov): ~163 exec / sec So we can see that syzygy instrumentation results in a slow-down factor of approximatly 6. And syzygy+WinAFL a factor of approximatly 25. This is mainly because of the process switches and file writes / reads because we are not doing full in-memory fuzzing, but there is also another big problem! We can see that instrumentation via DynamoRio is faster than syzygy (163 exec/sec vs. 50 exec/sec) and we can also start WinAFL with the DynamoRio mode (which does not require source code at all). If we do this, we get an execution speed of 0,05 – 2 exec/sec with WinAFL. At this point you should recognize that something is not working correctly because DynamoRio mode should be much faster! The reason can be found in our modification of the kull_m_sekurlsa_all() function. I added the two code lines kuhl_m_sekurlsa_reset() and pMinidumpName = argv[1] at the start because this is exactly what the “sekurlsa::minidump” command is doing. What I wanted to achieve is to immediatly execute the “sekurlsa::minidump” command and after that the “sekurlsa::logonpasswords” command and that’s why I used this sequence of code calls. However, this is a huge problem because we exit the function (DynamoRio mode) or the __afl_persistent_loop (syzygy mode) with a state where the input file is still open! This is because we call the kuhl_m_sekurlsa_reset() function at the start of the function and not at the end! That means that we only execute one “execution” in-memory, then WinAFL tries to modify the input file, detects that the file is still open and can’t be written to and then terminates the running process (via TerminateProcess from afl-fuzz.c:2186 in syzygy mode or nudges in DynamoRio mode from afl-fuzz.c:2195) to write to the file. Therefore, we do not do real in-memory fuzzing because we execute the application one time and then the application must be closed and restarted to write the next test case. That’s why the DynamoRio mode is so slow because the application must be started again for every testcase which means the application must be instrumented again and again (DynamoRio is a dynamic instrumentation framework). And because syzygy instrumented statically it’s not affected so heavily by this flaw (it still has to restart the application, but does not have to instrument again). Let’s fix the problem by reordering kuhl_m_sekurlsa_reset() to the end of the function: NTSTATUS kuhl_m_sekurlsa_all(int argc, wchar_t *argv[]) { While(__afl_persistent_loop()) { pMinidumpName = argv[1]; kuhl_m_sekurlsa_getLogonData(lsassPackages, ARRAYSIZE(lsassPackages); kuhl_m_sekurlsa_reset(); } Return NT_SUCCESS; } If we execute this, we still face the same problem. The reason is a bug inside mimikatz in the kuhl_m_sekurlsa_reset() function. Mimikatz opens the input file via three calls: CreateFile CreateFileMapping MapViewOfFile Therefore, we have to close all these three handles / mappings. However, mimikatz fails at closing the CreateFile handle. Here is the important code from kuhl_m_sekurlsa_reset() case KULL_M_MEMORY_TYPE_PROCESS_DMP: toClose = cLsass.hLsassMem->pHandleProcessDmp->hMinidump; break; ... } cLsass.hLsassMem = kull_m_memory_close(cLsass.hLsassMem); CloseHandle(toClose); Kull_m_memory_close() correctly closes the file mapping, but the last CloseHandle(toClose) call should close the handle received from CreateFile. However, toClose stores a heap address from (kull_m_minidump_open()): *hMinidump = (PKULL_M_MINIDUMP_HANDLE) LocalAlloc(LPTR, sizeof(KULL_M_MINIDUMP_HANDLE)); That means the code calls CloseHandle on a heap address and never calls CloseHandle on the original file handle (which gets never stored). After fixing this issue it starts to work and WinAFL gets 30-50 exec / sec! However, these executions are very inconsistent, sometimes drop down to under 1 execution per second (when the application must be restarted like after crashes). Because of this we got overall better fuzzing performance with the syzygy mode (which now has a speed of ~25 exec / sec) which also uses edge coverage. Screenshot of WinAFL DynamoRio mode (please bear in mind that the default mode is basic block coverage and not edge coverage with DynamoRio): Screenshot of WinAFL syzygy mode: Even if DynamoRio mode has a higher execution speed (29.91 exec / sec vs. 24.02 exec / sec) it’s in total slower because the execution speed is inconsistent. We can see this because DynamoRio mode is running since 25 minutes and just got total executions of 13.9k and syzygy mode just runs for 13 minutes but already got 16.6k executions. We can see that currently it’s more efficent to fuzz with syzygy mode if source code is available (especially if the target application crashes very often). And also very important: We had a bug in the code which slowed down the fuzzing process (at least by a factor of 2) and we didn’t see it during syzygy fuzzing! (A status screen entry with in-memory executions vs application restarts would be a great feature!) Please also note that the WinAFL documentation explicitly mentions this in the “How to select a target function” chapter: Close the input file. This is important because if the input file is not closed WinAFL won’t be able to rewrite it. Return normally (So that WinAFL can “catch” this return and redirect execution. “returning” via ExitProcess() and such won’t work) The second point is also very important. If an error condition triggers code which calls ExitProcess during fuzzing, we also end up starting the application again and again (and do not get the benefit of in-memory fuzzing). This is no problem with mimikatz. However, mimikatz crashes very often (e.g. 1697 times out of 16600 executions) and with every crash we have to restart the application. This mainly affects the performance of the DynamoRio mode because of the dynamic instrumentation and then it’s better to use the syzygy mode. Please also note that we can “fix” this by storing the stack pointer in the pre-fuzzing-handler of DynamoRio, implementing a crash handler where we restore the stack and instruction pointer, free the file mappings and handles and just continue fuzzing as if nothing had happend. Memory leaks can also be handled by hooking and replacing the heap implementation to free all allocations from the fuzzing-loop. Only global variables could become a probem, but this discussion goes too far here. At the end I started a fuzzing job with syzygy mode, one master (deterministic fuzzing) and 7 slaves (non-deterministic fuzzing) and let it run for 3 days (plus one day with page heap). In total I identified ~130 unique AFL crash signatures, which can be reduced to 42 unique WinDbg crash signatures. Most of them are not security-relevant, however, two crashes are critical. PRACTICE: ANALYSIS OF THE IDENTIFIED CRASHES Vulnerability 1: Arbitrary partial relative stack overwrites In this chapter I only want to describe the two critical crashes in depth. After fuzzing I had several unique crashes (based on the callstack of the crash) which I sorted with a simple self-written heuristic. From this list of crashes I took the first one (the one where I thought it’s the most likely to be exploitable) and analysed it. Here are the exact steps: This is the code with the vulnerability: The variable “myDir” is completly under our control. myDir points into our memory dump, we can therefore control all content of this struct. You maybe want to find the problem yourself before continuing, here are some hints: The argument length is always 0x40 (64) which is exactly the length of the destination argument buffer The argument source is also under our full control Obviously we want to reach RtlCopyMemory() from line 29 with some malicious arguments Now try to think how we can exploit this. My thoughts Step-by-Step: I want to reach line 29 (RtlCopyMemory() and therefore the IF statement from line 9-13 must be true. We can exploit the situation if “lengthToRead” (size argument) from the RtlCopyMemory call is bigger than 0x40 or if offsetToWrite is bigger than 0x40. The second case would be better for us because such relative writes are extremely powerful (e.g. just partially overwriting return addresses to bypass ASLR or to skip stack cookies and so on). So I decided to try exactly this, somehow control “offsetToWrite” which is only set in line 18 and 23. Line 23 is bad because it sets it to zero, so we take line 18. Since we want to come to line 18, the IF statement from line 15 must become true. First condition: Source < memory64→StartOfMemory This is no problem because we control both values completely. So far, so simple. Now lets check the first IF statement (line 9-13). One of the three conditions (line 10, 11 or 12) must evaluate to true. Lets focus on line 12 because from the IF from line 15 we know that Source < memory64→StartOfMemory must be true which is exactly what the first check is here for. So this one is true. That means we only have to ensure the second check: Second condition: Source + Length > (memory64→StartOfMemoryRange + memory64→DataSize) I leave this condition for one moment and think about line 25-27. What I want in RtlCopyMemory is to get as much control as possible. That means I want to control the target address (if possible, relative to an address to deal with ASLR), the source address to point into my own buffer and the size – that would really be great. The size is exactly lengthToRead and this variable can be set via line 25 and 27. 25 would be a bad choice because Length is fixed and offsetToWrite is already “used” to control the target address. So we must come to line 27. OffsetToRead is always zero because of line 17 and therefore memory64→DataSize completly controls lengthToRead. Now we can fix the next value and say that we want memory64→DataSize to be always 1 (to make 1-byte partial overwrites; or we set it to 4 / 8 to control full addresses). Now we are ready and take the second condition and fill in the known values. What we get is: Second condition: Source + 0x40 > (memory64→StartOfMemoryRange + 1) This check (together with the first condition) is exactly the check which should ensure that dataSize (the number of bytes which we write) is within the size of the buffer (0x40). However, we can force an integer overflow :). We can just set memory64→StartOfMemoryRange to 0xffffffffffffffff and therefore we survive the check because after adding one to it we get zero and that means Source + 0x40 is always bigger than zero (If we don’t overflow source+0x40). At the same time we survive the first condition because source will be smaller than 0xffffffffffffffff. Now we can also control offsetToWrite via line 18: offsetToWrite = 0xffffffffffffffff – source You might think that we can’t fully control offsetToWrite because the source variable is on x86 mimikatz just 32-bit (and the 0xffff… is 64-bit), however, because of integer truncation the upper 32-bit will be removed and therefore we can really address any byte in the address space relative to the destination buffer (on x64 mimikatz it’s 64-bit and therefore it’s also no problem). This is an extremely powerful primitive! We can overwrite bytes on the stack via relative offsets (ASLR is no obstacle here), we have full control over the size of the write-operation and full control over the values! The code can also be triggered multiple times (loop at line 7 is not useful because the destination pointer is not incremented) via loops which call this function (with some limitations). The next question is what offset do we use? Since we write relative to a stack variable we are going to target a return address. The destination variable is passed as argument inside the kull_m_process_ntheaders() function and this is exactly where we place a breakpoint on the first kull_m_memory_copy() call. Then we can extract the “destination” argument address and the address where the return address is stored and subtract them. What we get is the required offset to overwrite the return address. For reference, here are the offsets which I used for my dump file (dump files from other operating systems require very likely different offsets). Offset 0x6B4 stores the “source” variable. I use 0xffffff9c here because this is exactly the correct offset from “destination” to “return address” on the current release version of mimikatz (mimikatz 2.1.1 from Aug 13 2017; However, this offset should also work for older versions!). Offset 0xF0 stores the “myDir” struct content. The first 8 bytes store the NumberOfMemoryRanges (this controls the number of loops and therefore how often we can write). Since we just want to demonstrate the vulnerability we set it to one to make exactly one write operation (overwrite the return address). The next 8 bytes are the BaseRVA. This value controls “ptr” in line 6 which is the source from where we copy stuff. So we have to store there the relative offset in our dump file where we store the new return address (which should overwrite the original one). I’am using the value 0x90 here but we can use any value. It’s only important that we store the new return address at that offset (in my case offset 0x90) then. I therefore wrote 0x41414141 to offset 0x90. The next 8 bytes control the “StartOfMemoryRange” variable. I originally used 0xffffffffffffffff (like in the above example), however, for demonstration purpose I wanted to overwrite 4 bytes of the return address (and not only 1) and therefore had to subtract 4 (the DataSize, check the second condition in line 12). The next 8 bytes control the “DataSize” and as already explained I set this to 4 to write 4 bytes. Here is the file: Hint: In the above figure the malicious bytes start at offset 0xF0. This offset can differ in your minidump file. If we check the byte at 0x0C (= 0x20) we can see that this is the offset to the “streams” directory. Therefore, the above minidump has a streams directory starting at offset 0x20. Every entry there consists of 3 DWORDS (on x86), the first is the type and the last is the offset. We search for the entry with type 0x09 (=Memory64ListStream). This can be found in our figure at offset 0x50. If we take the 3rd DWORD from there we can see that this is exactly 0xF0 – the offset where our malicious bytes start. If this offset is different in your minidump file you may want to patch it first. And here is the proof that we really have control over the return address: Please note that full exploitation is still tricky because we have to find a way around ASLR. Because of DEP our data is marked as not executable, therefore we can’t jump into shellcode. The default bypass technique is to apply ROP which means that we instead invoke already existing code. However, because of ASLR this code is always loaded at randomized addresses. And here is what we can do with the above vulnerability is: We can make a relative write on the stack which means we can overwrite the return address (or arguments or local variables like loop counters or destination pointers). Because of the relative write we can bypass stack ASLR. Next we can choose the size of the write operation which means we can make a partial overwrite. We can therefore overwrite only the two lower bytes of the return address which means we can bypass module level ASLR (These two conditions make the vulnerability so useful). We can check the ranges which we can reach by checking the call-stack to the vulnerable code (every return address on this stack trace can be targeted via a partial overwrite) and we have multiple paths to come to the vulnerable code (and therefore different call-stacks with different ranges; We can even create more different call-stacks by overwriting a return address with an address which creates another call-stack to the vulnerable code). For example, a simple exploit could be to overwrite one of the return addresses with the address of code which calls LoadLibraryA() (e.g. 0x455DF3 which is in range) or LoadLibraryW (e.g. 0x442145). The address must be chosen in a way that the function argument is a pointer to the stack because then we can use the vulnerability to write the target path (UNC Path to a malicious library) to this address on the stack. Next, this exploit could be extended to first call kull_m_file_writeData() to write a library to the file system which gets later loaded via LoadLibrary (this way UNC paths are not required for exploitation). Another idea would be to make a specific write which exchanges the destination and source arguments from the vulnerable code. Then the first write operations can be used to write the upper bytes of return addresses (which are randomized by ASLR) to the memory dump buffer. After that these bytes can be written back to the stack (with the vulnerability) and full ROP chains can be built because we can now write ROP gadget addresses after each other. Without this idea we cannot execute multiple ROP gadgets after each other because they are not stored adjacent on the stack (return addresses are not stored next to each other on stack because there is other memory stored there like arguments, local variables and so on). However, I believe that this exploitation scenario is much more difficult because it requires multiple writes (which must be sorted to surive all checks in the mimikatz code), so the first approach with LoadLibrary should be more simple to implement. Vulnerability 2: Heap overflow The major cause of the second vulnerability can be found inside kull_m_process_getUnicodeString(). The first parameter (string) is a structure with the fields buffer (data pointer), a maximum length of bytes the string can hold and the length (currently stored characters). The content is completely under attacker control because it is parsed from the minidump. Moreover, the source (the second argument) also points to the minidump (attacker controlled). Mimikatz always extracts the string structure from the minidump and calls after that kull_m_process_getUnicodeString() to fill string->buffer with the real string from the minidump. Can you spot the problem? Line 9 allocates space for string->MaximumLength bytes and after that it copies exactly the same number of bytes from the minidump to the heap (line 11). However, the code never checks string->Length and therefore string->Length can be bigger than string->MaximumLength because this value is retrieved from the minidump. If later code uses string->Length a heap overflow can occur. This is for example the case when MSV1.0 (dpapi) credentials are stored in the minidump. Then mimikatz uses the string as input (and output) inside the decryption function in kuhl_m_sekurlsa_nt6_LsaEncryptMemory() and the manipulated length value leads to a heap overflow (however, the MSV1.0 execution path is not trivial/possible to exploit in my opinion, but there are many other paths which use kull_m_process_getUnicodeString()). Vulnerabilities patch status At time of publication (2017-09-22) there is no fix available for mimikatz. I informed the author on 2017-08-26 about the problems and received on 2017-08-28 a very friendly answer, that he will fix the flaws if it does not expand the code base too much. He also pointed out that mimikatz was developed as a proof-of-concept and it could be more secure by using a higher level language on which I totally agree on. On 2017-08-28 I sent the SMIME encrypted vulnerability details (together with this blog post). Since I didn’t receive answers on further emails or twitter messages, I informed him on 2017-09-06 about the blog post release on 2017-09-21. If you are a security consultant and using mimikatz in minidump mode, make sure to only use it inside a special mimikatz-virtual machine which is not connected to the internet/intranet and does not store important information (I hope you are already doing this anyway). To further mitigate the risk (e.g. a VM escape) I recommend to fix the above mentioned vulnerabilities. THEORY: RECOMMENDED FUZZING WORKFLOW In this last chapter, I want to quickly summarize the fuzzing workflow which I recommend: Download as many input files as possible. Calculate a minset of input files which still trigger the full code/edge coverage (corpus distillation). Use a Bloom-Filter for fast detection of different coverage. Minimize the file size of all input files in the minset. For the generated minset, calculate the code coverage (no Bloom-Filter). Now we can statically add breakpoints (byte 0xCC) at all basic blocks which were not hit yet. This modified application can be started with all files from the input and should not crash. However, we can continue downloading more files from the internet and start the modified binary (or just fuzz it). As soon as the application crashes (and our Just-in-Time configured compiler script kicks in) we know that a new code path was taken. Using this approach, we can achieve native execution speed but extract the information about new coverage! (downside: Checksums from files break; Moreover, a fork-server should also be used.) During fuzzing I recommend extraction of edge coverage (which requires instrumentation) and therefore we should fuzz with instrumentation (and sanitizers / heap libraries). For every input, we conduct an analysis phase before fuzzing. This analysis phase does the following: First identify the common code which gets executed for most inputs (for this we had to log the code coverage without the bloom-filter). Then get the code coverage for the current input and subtract the common code coverage from it. What we get is the code coverage which makes this fuzzing input “important” (code which only gets executed for this input). Next, we start our heatmap analysis but we just log the read operations conducted by this “important code”! What we get from this are the bytes which make our input “important”. Now we don’t have to fuzz the full input file, nor we have to fuzz the bytes which are read by the application, instead we only have to fuzz the few bytes which make the file “special”! I recommend focusing on these “special” bytes but also fuzz the other bytes afterwards (Fuzzing the special bytes fuzzes the new code, fuzzing all bytes fuzzes the old code with the new state resulting from the new code). Moreover, we can add additional slow checks which must be done only once for a new input (e.g. log all heap allocations and check for dangling-pointers after a free-operation; similar concept to Edge’s MemGC). Of course, some additional feedback and symbolic execution. Want to learn more about fuzzing? Come to one of my fuzzing talks (heise devSec or IT-SeCX for fuzzing applications with source code available and DefCamp for fuzzing closed-source applications!) or just follow me on Twitter. Sursa: https://www.sec-consult.com/en/blog/2017/09/hack-the-hacker-fuzzing-mimikatz-on-windows-with-winafl-heatmaps-0day/index.html

# Awesome Hacking Tools ___________________________________________________________________________________________________________ * __0trace__ 1.5 A hop enumeration tool http://jon.oberheide.org/0trace/ * __3proxy__ 0.7.1.1 Tiny free proxy server. http://3proxy.ru/ * __3proxy-win32__ 0.7.1.1 Tiny free proxy server. http://3proxy.ru/ * __42zip 42__ Recursive Zip archive bomb. http://blog.fefe.de/?ts=b6cea88d * __acccheck__ 0.2.1 A password dictionary attack tool that targets windows authentication via the SMB protocol. http://labs.portcullis.co.uk/tools/acccheck/ * __ace 1.10__ Automated Corporate Enumerator. A simple yet powerful VoIP Corporate Directory enumeration tool that mimics the behavior of an IP Phone in order to download the name and extension entries that a given phone can display on its screen interface http://ucsniff.sourceforge.net/ace.html * __admid-pack 0.1__ ADM DNS spoofing tools - Uses a variety of active and passive methods to spoof DNS packets. Very powerful. http://packetstormsecurity.com/files/10080/ADMid-pkg.tgz.html * __adminpagefinder 0.1__ This python script looks for a large amount of possible administrative interfaces on a given site. http://packetstormsecurity.com/files/112855/Admin-Page-Finder-Script.html * __admsnmp 0.1__ ADM SNMP audit scanner. * __aesfix 1.0.1__ A tool to find AES key in RAM http://citp.princeton.edu/memory/code/ * __aeskeyfind 1.0__ A tool to find AES key in RAM http://citp.princeton.edu/memory/code/ * __aespipe 2.4c__ Reads data from stdin and outputs encrypted or decrypted results to stdout. http://loop-aes.sourceforge.net/aespipe/ * __afflib 3.7.3__ An extensible open format for the storage of disk images and related forensic information. http://www.afflib.org * __afpfs-ng 0.8.1__ A client for the Apple Filing Protocol (AFP) http://alexthepuffin.googlepages.com/ * __against 0.2__ A very fast ssh attacking script which includes a multithreaded port scanning module (tcp connect) for discovering possible targets and a multithreaded brute-forcing module which attacks parallel all discovered hosts or given ip addresses from a list. http://nullsecurity.net/tools/cracker.html * __aiengine 339.58dfb85__ A packet inspection engine with capabilities of learning without any human intervention. https://bitbucket.org/camp0/aiengine/ * __aimage 3.2.5__ A program to create aff-images. http://www.afflib.org * __air 2.0.0__ A GUI front-end to dd/dc3dd designed for easily creating forensic images. http://air-imager.sourceforge.net/ * __airflood 0.1__ A modification of aireplay that allows for a DOS in in the AP. This program fills the table of clients of the AP with random MACs doing impossible new connections. http://packetstormsecurity.com/files/51127/airflood.1.tar.gz.html * __airgraph-ng 2371__ Graphing tool for the aircrack suite http://www.aircrack-ng.org * __airoscript 45.0a122ee__ A script to simplify the use of aircrack-ng tools. http://midnightresearch.com/projects/wicrawl/ * __airpwn 1.4__ A tool for generic packet injection on an 802.11 network. http://airpwn.sourceforge.net * __allthevhosts 1.0__ A vhost discovery tool that scrapes various web applications http://labs.portcullis.co.uk/tools/finding-all-the-vhosts/ * __american-fuzzy-lop 0.89b__ A practical, instrumentation-driven fuzzer for binary formats. https://code.google.com/p/american-fuzzy-lop/ * __androguard 1.9__ Reverse engineering, Malware and goodware analysis of Android applications and more. https://code.google.com/p/androguard/ * __androick 5.35048d7__ A python tool to help in forensics analysis on android. https://github.com/Flo354/Androick * __android-apktool 1.5.2__ A tool for reengineering Android apk files. http://forum.xda-developers.com/showthread.php?t=1755243 * __android-ndk r9c__ Android C/C++ developer kit. http://developer.android.com/sdk/ndk/index.html * __android-sdk-platform-tools r19__ Platform-Tools for Google Android SDK (adb and fastboot) http://developer.android.com/sdk/index.html * __android-sdk r22.3__ Google Android SDK http://developer.android.com/sdk/index.html * __android-udev-rules 8340.db8ef4a__ Android udev rules. https://github.com/bbqlinux/android-udev-rules * __androidsniffer 0.1__ A perl script that lets you search for 3rd party passwords, dump the call log, dump contacts, dump wireless configuration, and more. http://packetstormsecurity.com/files/97464/Andr01d-Magic-Dumper.1.html * __anontwi 1.0__ A free software python client designed to navigate anonymously on social networks. It supports Identi.ca and Twitter.com. http://anontwi.sourceforge.net/ * __aphopper 0.3__ AP Hopper is a program that automatically hops between access points of different wireless networks. http://aphopper.sourceforge.net/ * __apnbf 0.1__ A small python script designed for enumerating valid APNs (Access Point Name) on a GTP-C speaking device. http://www.c0decafe.de/ * __arachni 1.0.6__ A feature-full, modular, high-performance Ruby framework aimed towards helping penetration testers and administrators evaluate the security of web applications. https://www.arachni-scanner.com * __arduino 1.0.5__ Arduino SDK (includes patched avrdude and librxtx) http://arduino.cc/en/Main/Software * __argus 3.0.8__ Network monitoring tool with flow control. http://qosient.com/argus/ * __argus-clients 3.0.8__ Network monitoring client for Argus. http://qosient.com/argus/ * __armitage 141120__ A graphical cyber attack management tool for Metasploit. http://www.fastandeasyhacking.com/ * __arp-scan 1.9__ A tool that uses ARP to discover and fingerprint IP hosts on the local network http://www.nta-monitor.com/tools/arp-scan/ * __arpalert 2.0.12__ Monitor ARP changes in ethernet networks http://www.arpalert.org/ * __arpantispoofer 1.0.1.32__ A utility to detect and resist BIDIRECTIONAL ARP spoofing. It can anti-spoof for not only the local host, but also other hosts in the same subnet. It is also a handy helper for gateways which don't work well with ARP. http://arpantispoofer.sourceforge.net/ * __arpoison 0.6__ The UNIX arp cache update utility http://www.arpoison.net * __arpon 2.7__ A portable handler daemon that make ARP protocol secure in order to avoid the Man In The Middle (MITM) attack through ARP Spoofing, ARP Cache Poisoning or ARP Poison Routing (APR) attacks. http://arpon.sourceforge.net/ * __arpwner 26.f300fdf__ GUI-based python tool for arp posioning and dns poisoning attacks. https://github.com/ntrippar/ARPwner * __artillery 1.0.2__ A combination of a honeypot, file-system monitoring, system hardening, and overall health of a server to create a comprehensive way to secure a system https://www.trustedsec.com/downloads/artillery/ * __asleap 2.2__ Actively recover LEAP/PPTP passwords. http://www.willhackforsushi.com/Asleap.html * __asp-audit 2BETA__ An ASP fingerprinting tool and vulnerability scanner. http://seclists.org/basics/2006/Sep/128 * __athena-ssl-scanner 0.5.2__ a SSL cipher scanner that checks all cipher codes. It can identify about 150 different ciphers. http://packetstormsecurity.com/files/93062/Athena-SSL-Cipher-Scanner.html * __atstaketools 0.1__ This is an archive of various @Stake tools that help perform vulnerability scanning and analysis, information gathering, password auditing, and forensics. http://packetstormsecurity.com/files/50718/AtStakeTools.zip.html * __auto-xor-decryptor 3.6a1f8f7__ Automatic XOR decryptor tool. http://www.blog.mrg-effitas.com/publishing-of-mrg-effitas-automatic-xor-decryptor-tool/ * __autopsy 2.24__ A GUI for The Sleuth Kit. http://www.sleuthkit.org/autopsy * __azazel 10.401e3aa__ A userland rootkit based off of the original LD_PRELOAD technique from Jynx rootkit. https://github.com/chokepoint/azazel * __b2sum 20140114__ BLAKE2 file hash sum check. Computes the BLAKE2 (BLAKE2b or -s, -bp, -sp) cryptographic hash of a given file. https://blake2.net/ * __backcookie 44.cbf5b8b__ Small backdoor using cookie. https://github.com/mrjopino/backcookie * __backdoor-factory 98.89d87b2__ Patch win32/64 binaries with shellcode. https://github.com/secretsquirrel/the-backdoor-factory * __backfuzz 36.8e54ed6__ A network protocol fuzzing toolkit. https://github.com/localh0t/backfuzz * __balbuzard 65.546c5dcf629c__ A package of malware analysis tools in python to extract patterns of interest from suspicious files (IP addresses, domain names, known file headers, interesting strings, etc). https://bitbucket.org/decalage/balbuzard/ * __bamf-framework 35.30d2b4b__ A modular framework designed to be a platform to launch attacks against botnets. https://github.com/bwall/BAMF * __basedomainname 0.1__ Tool that can extract TLD (Top Level Domain), domain extensions (Second Level Domain + TLD), domain name, and hostname from fully qualified domain names. http://www.morningstarsecurity.com/research * __batman-adv 2013.4.0__ batman kernel module, (included upstream since .38) http://www.open-mesh.net/ * __bbqsql 1.2__ SQL injection exploitation tool. https://github.com/neohapsis/bbqsql * __bdfproxy 38.43e83e4__ Patch Binaries via MITM: BackdoorFactory + mitmProxy https://github.com/secretsquirrel/BDFProxy * __bed 0.5__ Collection of scripts to test for buffer overflows, format string vulnerabilities. http://www.aldeid.com/wiki/Bed * __beef 0.4.5.0.181.g80a9f8e__ The Browser Exploitation Framework that focuses on the web browser http://beefproject.com/ * __beholder 0.8.9__ A wireless intrusion detection tool that looks for anomalies in a wifi environment. http://www.beholderwireless.org/ * __beleth 36.0963699__ A Multi-threaded Dictionary based SSH cracker. https://github.com/chokepoint/Beleth * __bfbtester 2.0.1__ Performs checks of single and multiple argument command line overflows and environment variable overflows http://sourceforge.net/projects/bfbtester/ * __bgp-md5crack 0.1__ RFC2385 password cracker http://www.c0decafe.de/ * __bing-ip2hosts 0.4__ Enumerates all hostnames which Bing has indexed for a specific IP address. http://www.morningstarsecurity.com/research/bing-ip2hosts * __bing-lfi-rfi 0.1__ This is a python script for searching Bing for sites that may have local and remote file inclusion vulnerabilities. http://packetstormsecurity.com/files/121590/Bing-LFI-RFI-Scanner.html * __binwalk 2.0.1__ A tool for searching a given binary image for embedded files. http://binwalk.org * __binwally 3.ca092a7__ Binary and Directory tree comparison tool using the Fuzzy Hashing concept (ssdeep). https://github.com/bmaia/binwally * __bios_memimage 1.2__ A tool to dump RAM contents to disk (aka cold boot attack). http://citp.princeton.edu/memory/code/ * __birp 60.1d7c49f__ A tool that will assist in the security assessment of mainframe applications served over TN3270. https://github.com/sensepost/birp * __bittwist 2.0__ A simple yet powerful libpcap-based Ethernet packet generator. It is designed to complement tcpdump, which by itself has done a great job at capturing network traffic. http://bittwist.sourceforge.net/ * __bkhive 1.1.1__ Program for dumping the syskey bootkey from a Windows NT/2K/XP system hive. http://sourceforge.net/projects/ophcrack * __blackarch-menus 0.2__ BlackArch specific XDG-compliant menu http://www.blackarch.org/ * __blackhash 0.2__ Creates a filter from system hashes http://16s.us/blackhash/ * __bletchley 0.0.1__ A collection of practical application cryptanalysis tools. https://code.google.com/p/bletchley/ * __blindelephant 7__ A web application fingerprinter. Attempts to discover the version of a (known) web application by comparing static files at known locations http://blindelephant.sourceforge.net/ * __blindsql 1.0__ Set of bash scripts for blind SQL injection attacks http://www.enye-sec.org/programas.html * __bluebox-ng 66.4a73bb4__ A GPL VoIP/UC vulnerability scanner. https://github.com/jesusprubio/bluebox-ng * __bluebugger 0.1__ An implementation of the bluebug technique which was discovered by Martin Herfurt. http://packetstormsecurity.com/files/54024/bluebugger.1.tar.gz.html * __bluelog 1.1.1__ A Bluetooth scanner and sniffer written to do a single task, log devices that are in discoverable mode. http://www.digifail.com/software/bluelog.shtml * __bluepot 0.1__ A Bluetooth Honeypot written in Java, it runs on Linux https://code.google.com/p/bluepot/ * __blueprint 0.1_3__ A perl tool to identify Bluetooth devices. http://trifinite.org/trifinite_stuff_blueprinting.html * __blueranger 1.0__ A simple Bash script which uses Link Quality to locate Bluetooth device radios. http://www.hackfromacave.com/projects/blueranger.html * __bluesnarfer 0.1__ A bluetooth attacking tool http://www.alighieri.org/project.html * __bmap-tools 3.2__ Tool for copying largely sparse files using information from a block map file. http://git.infradead.org/users/dedekind/bmap-tools.git * __bob-the-butcher 0.7.1__ A distributed password cracker package. http://btb.banquise.net/ * __bokken 376.caaa65c431a8__ GUI for radare2 and pyew. http://inguma.eu/projects/bokken/ * __bowcaster 0.1__ This framework, implemented in Python, is intended to aid those developing exploits by providing useful set of tools and modules, such as payloads, encoders, connect-back servers, etc. Currently the framework is focused on the MIPS CPU architecture, but the design is intended to be modular enough to support arbitrary architectures. https://github.com/zcutlip/bowcaster * __braa 0.82__ A mass snmp scanner http://s-tech.elsat.net.pl/braa/ * __braces 0.4__ A Bluetooth Tracking Utility. http://braces.shmoo.com/ * __browser-fuzzer__ 3 Browser Fuzzer 3 http://www.krakowlabs.com/dev.html * __brutessh 0.5__ A simple sshd password bruteforcer using a wordlist, it's very fast for internal networks. It's multithreads. http://www.edge-security.com/edge-soft.php * __brutus 2__ One of the fastest, most flexible remote password crackers you can get your hands on. http://www.hoobie.net/brutus/ * __bsdiff 4.3__ bsdiff and bspatch are tools for building and applying patches to binary files. http://www.daemonology.net/bsdiff/ * __bsqlbf 2.7__ Blind SQL Injection Brute Forcer. http://code.google.com/p/bsqlbf-v2/ * __bss 0.8__ Bluetooth stack smasher / fuzzer http://www.secuobs.com/news/15022006-bss_0_8.shtml * __bt_audit 0.1.1__ Bluetooth audit http://www.betaversion.net/btdsd/download/ * __btcrack 1.1__ The world's first Bluetooth Pass phrase (PIN) bruteforce tool. Bruteforces the Passkey and the Link key from captured Pairing exchanges. http://www.nruns.com/_en/security_tools_btcrack.php * __btscanner 2.1__ Bluetooth device scanner. http://www.pentest.co.uk * __bulk-extractor 1.5.5__ Bulk Email and URL extraction tool. https://github.com/simsong/bulk_extractor * __bully 19.ba33677__ A wifi-protected-setup (WPS) brute force attack tool. http://code.google.com/p/bully/ * __bunny 0.93__ A closed loop, high-performance, general purpose protocol-blind fuzzer for C programs. http://code.google.com/p/bunny-the-fuzzer/ * __burpsuite 1.6__ An integrated platform for attacking web applications (free edition). http://portswigger.net/burp/ * __buttinsky 138.1a2a1b2__ Provide an open source framework for automated botnet monitoring. https://github.com/buttinsky/buttinsky * __bvi 1.4.0beta__ A display-oriented editor for binary files operate like "vi" editor. http://bvi.sourceforge.net/ * __cadaver 0.23.3__ Command-line WebDAV client for Unix http://www.webdav.org/cadaver * __canari 1.1__ A transform framework for maltego http://www.canariproject.com/ * __cansina 93.abc6577__ A python-based Web Content Discovery Tool. https://github.com/deibit/cansina * __capstone 3.0__ A lightweight multi-platform, multi-architecture disassembly framework. http://www.capstone-engine.org/index.html * __carwhisperer 0.2__ Intends to sensibilise manufacturers of carkits and other Bluetooth appliances without display and keyboard for the possible security threat evolving from the use of standard passkeys. http://trifinite.org/trifinite_stuff_carwhisperer.html * __casefile 1.0.1__ The little brother to Maltego without transforms, but combines graph and link analysis to examine links between manually added data to mind map your information http://www.paterva.com/web6/products/casefile.php * __cdpsnarf 0.1.6__ Cisco discovery protocol sniffer. https://github.com/Zapotek/cdpsnarf * __cecster 5.15544cb__ A tool to perform security testing against the HDMI CEC (Consumer Electronics Control) and HEC (HDMI Ethernet Channel) protocols https://github.com/nccgroup/CECster * __centry 72.6de2868__ Cold boot & DMA protection https://github.com/0xPoly/Centry * __cewl 4.3__ A custom word list generator http://www.digininja.org/projects/cewl.php * __cflow 1.4__ A C program flow analyzer. http://www.gnu.org/software/cflow/ * __chaosmap 1.3__ An information gathering tool and dns / whois / web server scanner http://freecode.com/projects/chaosmap * __chaosreader 0.94__ A freeware tool to trace tcp, udp etc. sessions and fetch application data from snoop or tcpdump logs. http://chaosreader.sourceforge.net/ * __chapcrack 17.ae2827f__ A tool for parsing and decrypting MS-CHAPv2 network handshakes. https://github.com/moxie0/chapcrack * __check-weak-dh-ssh 0.1__ Debian OpenSSL weak client Diffie-Hellman Exchange checker. http://packetstormsecurity.com/files/66683/check_weak_dh_ssh.pl.bz2.html * __checkiban 0.2__ Checks the validity of an International Bank Account Number (IBAN). http://kernel.embedromix.ro/us/ * __checkpwd 1.23__ Oracle Password Checker (Cracker) http://www.red-database-security.com/software/checkpwd.html * __checksec 1.5__ The checksec.sh script is designed to test what standard Linux OS and PaX security features are being used. http://www.trapkit.de/tools/checksec.html * __chiron 0.7__ An all-in-one IPv6 Penetration Testing Framework. http://www.secfu.net/tools-scripts/ * __chkrootkit 0.50__ Checks for rootkits on a system http://www.chkrootkit.org/ * __chntpw 140201__ Offline NT Password Editor - reset passwords in a Windows NT SAM user database file http://pogostick.net/~pnh/ntpasswd/ * __chownat 0.08b__ Allows two peers behind two separate NATs with no port forwarding and no DMZ setup on their routers to directly communicate with each other http://samy.pl/chownat/ * __chrome-decode 0.1__ Chrome web browser decoder tool that demonstrates recovering passwords. http://packetstormsecurity.com/files/119153/Chrome-Web-Browser-Decoder.html * __chromefreak 22.336e323__ A Cross-Platform Forensic Framework for Google Chrome http://osandamalith.github.io/ChromeFreak/ * __cidr2range 0.9__ Script for listing the IP addresses contained in a CIDR netblock http://www.cpan.org/authors/id/R/RA/RAYNERLUC * __ntruder 0.2.0__ An automatic pentesting tool to bypass captchas. http://cintruder.sourceforge.net/ * __ciphertest 14.7f49ea7__ A better SSL cipher checker using gnutls. https://github.com/OpenSecurityResearch/ciphertest * __cirt-fuzzer 1.0__ A simple TCP/UDP protocol fuzzer. http://www.cirt.dk/ * __cisco-auditing-tool 1__ Perl script which scans cisco routers for common vulnerabilities. Checks for default passwords, easily guessable community names, and the IOS history bug. Includes support for plugins and scanning multiple hosts. http://www.scrypt.net * __cisco-global-exploiter 1.3__ A perl script that targets multiple vulnerabilities in the Cisco Internetwork Operating System (IOS) and Catalyst products. http://www.blackangels.it * __cisco-ocs 0.2__ Cisco Router Default Password Scanner. http://www.question-defense.com/2013/01/11/ocs-version-2-release-ocs-cisco-router-default-password-scanner * __cisco-router-config 1.1__ copy-router-config and merge-router-config to copy and merge Cisco Routers Configuration * __cisco-scanner 0.2__ Multithreaded Cisco HTTP vulnerability scanner. Tested on Linux, OpenBSD and Solaris. http://wayreth.eu.org/old_page/ * __cisco-torch 0.4b__ Cisco Torch mass scanning, fingerprinting, and exploitation tool. http://www.arhont.com * __cisco5crack 2.c4b228c__ Crypt and decrypt the cisco enable 5 passwords. https://github.com/madrisan/cisco7crack * __cisco7crack 2.f1c21dd__ Crypt and decrypt the cisco enable 7 passwords. https://github.com/madrisan/cisco7crack * __ciscos 1.3__ Scans class A, B, and C networks for cisco routers which have telnet open and have not changed the default password from cisco. * __climber 23.f614304__ Check UNIX/Linux systems for privilege escalation. https://github.com/raffaele-forte/climber * __clusterd 129.0f04a49__ Automates the fingerprinting, reconnaissance, and exploitation phases of an application server attack. https://github.com/hatRiot/clusterd * __cmospwd 5.0__ Decrypts password stored in CMOS used to access BIOS setup. http://www.cgsecurity.org/wiki/CmosPwd * __cms-explorer 1.0__ Designed to reveal the specific modules, plugins, components and themes that various cms driven websites are running http://code.google.com/p/cms-explorer * __cms-few 0.1__ Joomla, Mambo, PHP-Nuke, and XOOPS CMS SQL injection vulnerability scanning tool written in Python. http://packetstormsecurity.com/files/64722/cms_few.py.txt.html * __codetective 37.f94d9e8__ A tool to determine the crypto/encoding algorithm used according to traces of its representation. https://www.digitalloft.org/init/plugin_wiki/page/codetective * __complemento 0.7.6__ A collection of tools for pentester: LetDown is a powerful tcp flooder ReverseRaider is a domain scanner that use wordlist scanning or reverse resolution scanning Httsquash is an http server scanner, banner grabber and data retriever http://complemento.sourceforge.net * __conpot 0.3.1__ ICS honeypot with the goal to collect intelligence about the motives and methods of adversaries targeting industrial control systems url="http://conpot.org" * __conscan 1.1__ A blackbox vulnerability scanner for the Concre5 CMS. http://nullsecurity.net/tools/scanner.html * __cookie-cadger 1.07__ An auditing tool for Wi-Fi or wired Ethernet connections. https://cookiecadger.com/ * __cowpatty 4.6__ Wireless WPA/WPA2 PSK handshake cracking utility http://www.wirelessdefence.org/Contents/Files/ * __cpfinder 0.1__ This is a simple script that looks for administrative web interfaces. http://packetstormsecurity.com/files/118851/Control-Panel-Finder-Script.html * __cppcheck 1.67__ A tool for static C/C++ code analysis http://cppcheck.wiki.sourceforge.net/ * __cpptest 1.1.2__ A portable and powerful, yet simple, unit testing framework for handling automated tests in C++. http://cpptest.sourceforge.net/ * __crackhor 2.ae7d83f__ A Password cracking utility. https://github.com/CoalfireLabs/crackHOR * __crackle 39.3e93196__ Crack and decrypt BLE encryption https://github.com/mikeryan/crackle/ * __crackserver 31.c268a80__ An XMLRPC server for password cracking. https://github.com/averagesecurityguy/crack * __create-ap 112.1c89b44__ This script creates a NATed or Bridged WiFi Access Point. https://github.com/oblique/create_ap * __creddump 0.3__ A python tool to extract various credentials and secrets from Windows registry hives. https://code.google.com/p/creddump/ * __creds 8340.db8ef4a__ Harvest FTP/POP/IMAP/HTTP/IRC credentials along with interesting data from each of the protocols. https://github.com/DanMcInerney/creds.py * __creepy 137.9f60449__ A geolocation information gatherer. Offers geolocation information gathering through social networking platforms. http://github.com/ilektrojohn/creepy.git * __crunch 3.6__ A wordlist generator for all combinations/permutations of a given character set. http://sourceforge.net/projects/crunch-wordlist/ * __cryptcat 1.2.1__ A lightweight version of netcat with integrated transport encryption capabilities. http://sourceforge.net/projects/cryptcat * __crypthook__ 17.0728cd1 TCP/UDP symmetric encryption tunnel wrapper. https://github.com/chokepoint/CryptHook * __cryptonark 0.4.9__ SSL security checker. http://blog.techstacks.com/cryptonark.html * __csrftester 1.0__ The OWASP CSRFTester Project attempts to give developers the ability to test their applications for CSRF flaws. http://www.owasp.org/index.php/Category:OWASP_CSRFTester_Project * __ctunnel 0.6__ Tunnel and/or proxy TCP or UDP connections via a cryptographic tunnel. http://nardcore.org/ctunnel * __cuckoo 1.1.1__ A malware analysis system. http://cuckoosandbox.org/ * __cupp 3.0__ Common User Password Profiler http://www.remote-exploit.org/?page_id=418 * __cutycapt 10__ A Qt and WebKit based command-line utility that captures WebKit's rendering of a web page. http://cutycapt.sourceforge.net/ * __cvechecker 3.5__ The goal of cvechecker is to report about possible vulnerabilities on your system, by scanning the installed software and matching the results with the CVE database. http://cvechecker.sourceforge.net/ * __cymothoa 1__ A stealth backdooring tool, that inject backdoor's shellcode into an existing process. http://cymothoa.sourceforge.net/ * __darkbing 0.1__ A tool written in python that leverages bing for mining data on systems that may be susceptible to SQL injection. http://packetstormsecurity.com/files/111510/darkBing-SQL-Scanner.1.html * __darkd0rk3r 1.0__ Python script that performs dork searching and searches for local file inclusion and SQL injection errors. http://packetstormsecurity.com/files/117403/Dark-D0rk3r.0.html * __darkjumper 5.8__ This tool will try to find every website that host at the same server at your target http://sourceforge.net/projects/darkjumper/ * __darkmysqli 1.6__ Multi-Purpose MySQL Injection Tool https://github.com/BlackArch/darkmysqli * __darkstat 3.0.718__ Network statistics gatherer (packet sniffer) http://dmr.ath.cx/net/darkstat/ * __davoset 1.2.3__ A tool for using Abuse of Functionality and XML External Entities vulnerabilities on some websites to attack other websites. http://websecurity.com.ua/davoset/ * __davtest 1.0__ Tests WebDAV enabled servers by uploading test executable files, and then (optionally) uploading files which allow for command execution or other actions directly on the target http://code.google.com/p/davtest/ * __dbd 1.50__ A Netcat-clone, designed to be portable and offer strong encryption. It runs on Unix-like operating systems and on Microsoft Win32. https://github.com/gitdurandal/dbd * __dbpwaudit 0.8__ A Java tool that allows you to perform online audits of password quality for several database engines http://www.cqure.net/wp/dbpwaudit/ * __dc3dd 7.1.614__ A patched version of dd that includes a number of features useful for computer forensics http://sourceforge.net/projects/dc3dd * __dcfldd 1.3.4.1__ DCFL (DoD Computer Forensics Lab) dd replacement with hashing http://dcfldd.sourceforge.net/ * __ddrescue 1.19__ GNU data recovery tool http://www.gnu.org/software/ddrescue/ddrescue.html * __deblaze 0.3__ A remote method enumeration tool for flex servers http://deblaze-tool.appspot.com/ * __delldrac 0.1a__ DellDRAC and Dell Chassis Discovery and Brute Forcer. https://www.trustedsec.com/september/owning-dell-drac-awesome-hack/ * __depant 0.3a__ Check network for services with default passwords. http://midnightresearch.com/projects/depant/ * __device-pharmer__ 35.c1d449e Opens 1K+ IPs or Shodan search results and attempts to login. https://github.com/DanMcInerney/device-pharmer * __dex2jar 0.0.9.13__ A tool for converting Android's .dex format to Java's .class format http://code.google.com/p/dex2jar * __dff-scanner 1.1__ Tool for finding path of predictable resource locations. http://netsec.rs/70/tools.html * __dhcdrop 0.5__ Remove illegal dhcp servers with IP-pool underflow. Stable version http://www.netpatch.ru/dhcdrop.html * __dhcpig 69.cc4109a__ Enumerates hosts, subdomains, and emails from a given domain using google https://github.com/kamorin/DHCPig * __dinouml 0.9.5__ A network simulation tool, based on UML (User Mode Linux) that can simulate big Linux networks on a single PC http://kernel.embedromix.ro/us/ * __dirb 2.04__ A web content scanner, brute forceing for hidden files http://dirb.sourceforge.net/ * __dirbuster 1.0_RC1__ An application designed to brute force directories and files names on web/application servers http://www.owasp.org/index.php/Category:OWASP_DirBuster_Project * __directorytraversalscan 1.0.1.0__ Detect directory traversal vulnerabilities in HTTP servers and web applications. http://sourceforge.net/projects/httpdirscan/ * __dirs3arch 119.6a3b68a__ HTTP(S) directory/file brute forcer. https://github.com/maurosoria/dirs3arch * __dirscanner 0.1__ This is a python script that scans webservers looking for administrative directories, php shells, and more. http://packetstormsecurity.com/files/117773/Directory-Scanner-Tool.html * __dislocker 0.3__ A tool to exploit the hash length extension attack in various hashing algorithms. With FUSE capabilities built in. http://www.hsc.fr/ressources/outils/dislocker/ * __dissector 1__ This code dissects the internal data structures in ELF files. It supports x86 and x86_64 archs and runs under Linux. http://packetstormsecurity.com/files/125972/Coloured-ELF-File-Dissector.html * __dissy 10__ A graphical frontend to the objdump disassembler for compiler-generated code. http://dissy.googlecode.com/ * __dizzy 0.8.2__ A Python based fuzzing framework with many features. http://www.c0decafe.de/ * __dmitry 1.3a__ Deepmagic Information Gathering Tool. Gathers information about hosts. It is able to gather possible subdomains, email addresses, and uptime information and run tcp port scans, whois lookups, and more. http://www.mor-pah.net/ * __dnmap 0.6__ The distributed nmap framework http://sourceforge.net/projects/dnmap/ * __dns-spoof 12.3918a10__ Yet another DNS spoof utility. https://github.com/maurotfilho/dns-spoof * __dns2geoip 0.1__ A simple python script that brute forces DNS and subsequently geolocates the found subdomains. http://packetstormsecurity.com/files/118036/DNS-GeoIP.html * __dns2tcp 0.5.2__ A tool for relaying TCP connections over DNS. http://www.hsc.fr/ressources/outils/dns2tcp/index.html.en * __dnsa 0.5__ DNSA is a dns security swiss army knife http://packetfactory.openwall.net/projects/dnsa/index.html * __dnsbf 0.2__ search for available domain names in an IP range http://code.google.com/p/dnsbf * __dnsbrute 2.b1dc84a__ Multi-theaded DNS bruteforcing, average speed 80 lookups/second with 40 threads. https://github.com/d4rkcat/dnsbrute * __dnschef 0.3__ A highly configurable DNS proxy for pentesters. http://thesprawl.org/projects/dnschef/ * __dnsdrdos 0.1__ Proof of concept code for distributed DNS reflection DoS http://nullsecurity.net/tools/dos.html * __dnsenum 1.2.4.1__ Script that enumerates DNS information from a domain, attempts zone transfers, performs a brute force dictionary style attack, and then performs reverse look-ups on the results. http://www2.packetstormsecurity.org/cgi-bin/search/search.cgi?searchvalue=dnsenum * __dnsgoblin 0.1__ Nasty creature constantly searching for DNS servers. It uses standard dns querys and waits for the replies http://nullsecurity.net/tools/scanner.html * __dnsmap 0.30__ Passive DNS network mapper http://dnsmap.googlecode.com * __dnspredict 0.0.2__ DNS prediction http://johnny.ihackstuff.com * __dnsrecon 0.8.8__ Python script for enumeration of hosts, subdomains and emails from a given domain using google. https://github.com/darkoperator/dnsrecon * __dnsspider 0.5__ A very fast multithreaded bruteforcer of subdomains that leverages a wordlist and/or character permutation. http://nullsecurity.net/tools/scanner.html * __dnstracer 1.9__ Determines where a given DNS server gets its information from, and follows the chain of DNS servers http://www.mavetju.org/unix/dnstracer.php * __dnsutils 9.9.2.P2__ DNS utilities: dig host nslookup http://www.isc.org/software/bind/ * __dnswalk 2.0.2__ A DNS debugger http://sourceforge.net/projects/dnswalk/ * __domain-analyzer 0.8.1__ Finds all the security information for a given domain name. http://sourceforge.net/projects/domainanalyzer/ * __doona 118.ff1e17b__ A fork of the Bruteforce Exploit Detector Tool (BED). https://github.com/wireghoul/doona * __dotdotpwn 3.0__ The Transversal Directory Fuzzer http://dotdotpwn.blogspot.com * __dpeparser beta002__ Default password enumeration project http://www.toolswatch.org/dpe/ * __dpscan 0.1__ Drupal Vulnerabilty Scanner. https://github.com/insaneisnotfree/Blue-Sky-Information-Security * __dradis 2.9.0__ An open source framework to enable effective information sharing. http://dradisframework.org/ * __driftnet 0.1.6__ Listens to network traffic and picks out images from TCP streams it observes. http://www.ex-parrot.com/~chris/driftnet/ * ___dripper v1.r1.gc9bb0c9__ A fast, asynchronous DNS scanner; it can be used for enumerating subdomains and enumerating boxes via reverse DNS. http://www.blackhatlibrary.net/Dripper * __dscanner 709.f00026f__ Swiss-army knife for D source code. https://github.com/Hackerpilot/Dscanner * __dsd 84.60807e0__ Digital Speech Decoder https://github.com/szechyjs/dsd * __dsniff 2.4b1__ Collection of tools for network auditing and penetration testing http://www.monkey.org/~dugsong/dsniff/ * __dumb0 19.1493e74__ A simple tool to dump users in popular forums and CMS. https://github.com/0verl0ad/Dumb0 * __dump1090 386.bff92c4__ A simple Mode S decoder for RTLSDR devices. https://github.com/MalcolmRobb/dump1090 * __dumpacl 0.0__ Dumps NTs ACLs and audit settings. http://www.systemtools.com/cgi-bin/download.pl?DumpAcl * __dumpzilla 03152013__ A forensic tool for firefox. http://www.dumpzilla.org/ * __eapmd5pass 1.4__ An implementation of an offline dictionary attack against the EAP-MD5 protocol http://www.willhackforsushi.com/?page_id=67 * __easy-creds 3.9 A__ bash script that leverages ettercap and other tools to obtain credentials. https://github.com/brav0hax/easy-creds * __easyfuzzer 3.6__ A flexible fuzzer, not only for web, has a CSV output for efficient output analysis (platform independant). http://www.mh-sec.de/downloads.html.en * __eazy 0.1__ This is a small python tool that scans websites to look for PHP shells, backups, admin panels, and more. http://packetstormsecurity.com/files/117572/EAZY-Web-Scanner.html * __edb 0.9.20__ A QT4-based binary mode debugger with the goal of having usability on par with OllyDbg. http://www.codef00.com/projects.php#Debugger * __eindeutig 20050628_1__ Examine the contents of Outlook Express DBX email repository files (forensic purposes) http://www.jonesdykstra.com/ * __elettra 1.0__ Encryption utility by Julia Identity http://www.winstonsmith.info/julia/elettra/ * __elettra-gui 1.0__ Gui for the elettra crypto application. http://www.winstonsmith.info/julia/elettra/ * __elite-proxy-finder 42.b92f75a__ Finds public elite anonymity proxies and concurrently tests them. https://github.com/DanMcInerney/elite-proxy-finder * __enabler 1__ attempts to find the enable password on a cisco system via brute force. http://packetstormsecurity.org/cisco/enabler.c * __encodeshellcode 0.1b__ This is an encoding tool for 32-bit x86 shellcode that assists a researcher when dealing with character filter or byte restrictions in a buffer overflow vulnerability or some kind of IDS/IPS/AV blocking your code. http://packetstormsecurity.com/files/119904/Encode-Shellcode.1b.html * __ent 1.0__ Pseudorandom number sequence test. http://www.fourmilab.ch/random * __enum-shares 7.97cba5a__ Tool that enumerates shared folders across the network and under a custom user account. https://github.com/dejanlevaja/enum_shares * __enum4linux 0.8.9__ A tool for enumerating information from Windows and Samba systems. http://labs.portcullis.co.uk/application/enum4linux/ * __enumiax 1.0__ IAX enumerator http://sourceforge.net/projects/enumiax/ * __enyelkm 1.2__ Rootkit for Linux x86 kernels v2.6. http://www.enye-sec.org/programas.html * __epicwebhoneypot 2.0a__ Tool which aims to lure attackers using various types of web vulnerability scanners by tricking them into believing that they have found a vulnerability on a host. http://sourceforge.net/projects/epicwebhoneypot/ * __erase-registrations 1.0__ IAX flooder http://www.hackingexposedvoip.com/ * __etherape 0.9.13__ A graphical network monitor for various OSI layers and protocols http://etherape.sourceforge.net/ * __ettercap 0.8.1__ A network sniffer/interceptor/logger for ethernet LANs - console http://ettercap.github.com/ettercap/ * __evilgrade 2.0.0__ Modular framework that takes advantage of poor upgrade implementations by injecting fake updates http://www.infobyte.com.ar/developments.html * __evilmaid 1.01__ TrueCrypt loader backdoor to sniff volume password http://theinvisiblethings.blogspot.com * __exiv2 0.24__ Exif and Iptc metadata manipulation library and tools http://exiv2.org * __exploit-db 1.6__ The Exploit Database (EDB) – an ultimate archive of exploits and vulnerable software - A collection of hacks http://www.exploit-db.com * __extracthosts 14.ec8b89c__ Extracts hosts (IP/Hostnames) from files. https://github.com/bwall/ExtractHosts * __extundelete 0.2.4__ Utility for recovering deleted files from ext2, ext3 or ext4 partitions by parsing the journal http://extundelete.sourceforge.net * __eyepwn 1.0__ Exploit for Eye-Fi Helper directory traversal vulnerability http://www.pentest.co.uk * __eyewitness 278.e72c21e__ Designed to take screenshots of websites, provide some server header info, and identify default credentials if possible. https://github.com/ChrisTruncer/EyeWitness * __facebot 23.57f6025__ A facebook profile and reconnaissance system. https://github.com/pun1sh3r/facebot * __facebrute 7.ece355b__ This script tries to guess passwords for a given facebook account using a list of passwords (dictionary). https://github.com/emerinohdz/FaceBrute * __fakeap 0.3.2__ Black Alchemy's Fake AP generates thousands of counterfeit 802.11b access points. Hide in plain sight amongst Fake AP's cacophony of beacon frames. http://www.blackalchemy.to/project/fakeap/ * __fakedns 17.87d4216__ A regular-expression based python MITM DNS server with correct DNS request passthrough and "Not Found" responses. https://github.com/Crypt0s/FakeDns * __fakemail 1.0__ Fake mail server that captures e-mails as files for acceptance testing. http://sourceforge.net/projects/fakemail/ * __fakenetbios 7.b83701e__ A family of tools designed to simulate Windows hosts (NetBIOS) on a LAN. https://github.com/mubix/FakeNetBIOS * __fang 1.2__ A multi service threaded MD5 cracker. https://github.com/evilsocket/fang * __fbht r12.a284878__ A Facebook Hacking Tool https://github.com/chinoogawa/fbht-linux * __fcrackzip 1.0__ Zip file password cracker http://oldhome.schmorp.de/marc/fcrackzip.html * __fern-wifi-cracker 219__ WEP, WPA wifi cracker for wireless penetration testing http://code.google.com/p/fern-wifi-cracker/ * __fernmelder 6.c6d4ebe__ Asynchronous mass DNS scanner. https://github.com/stealth/fernmelder * __fgscanner 11.893372c__ An advanced, opensource URL scanner. http://www.fantaghost.com/fgscanner * __fhttp 1.3__ This is a framework for HTTP related attacks. It is written in Perl with a GTK interface, has a proxy for debugging and manipulation, proxy chaining, evasion rules, and more. http://packetstormsecurity.com/files/104315/FHTTP-Attack-Tool.3.html * __fierce 0.9.9__ A DNS scanner http://ha.ckers.org/fierce/ * __fiked 0.0.5__ Fake IDE daemon http://www.roe.ch/FakeIKEd * __filibuster 161.37b7f9c__ A Egress filter mapping application with additional functionality. https://github.com/subinacls/Filibuster * __fimap 1.00__ A little tool for local and remote file inclusion auditing and exploitation http://code.google.com/p/fimap/ * __findmyhash 1.1.2__ Crack different types of hashes using free online services http://code.google.com/p/findmyhash/ * __firewalk 5.0__ An active reconnaissance network security tool http://packetfactory.openwall.net/projects/firewalk/ * __firmware-mod-kit 099__ Modify firmware images without recompiling! http://code.google.com/p/firmware-mod-kit * __firstexecution 6.a275793__ A Collection of different ways to execute code outside of the expected entry points. https://github.com/nccgroup/firstexecution * __fl0p 0.1__ A passive L7 flow fingerprinter that examines TCP/UDP/ICMP packet sequences, can peek into cryptographic tunnels, can tell human beings and robots apart, and performs a couple of other infosec-related tricks. http://lcamtuf.coredump.cx/ * __flare 0.6__ Flare processes an SWF and extracts all scripts from it. http://www.nowrap.de/flare.html * __flasm 1.62__ Disassembler tool for SWF bytecode http://www.nowrap.de/flasm.html * __flawfinder 1.31__ Searches through source code for potential security flaws. http://www.dwheeler.com/flawfinder * __flowinspect 94.01c8921__ A network traffic inspection tool. https://github.com/7h3rAm/flowinspect * __flunym0us 2.0__ A Vulnerability Scanner for Wordpress and Moodle. http://code.google.com/p/flunym0us/ * __foremost 1.5.7__ A console program to recover files based on their headers, footers, and internal data structures http://foremost.sourceforge.net/ * __fpdns 0.9.3__ Program that remotely determines DNS server versions http://code.google.com/p/fpdns/ * __fping 3.10__ A utility to ping multiple hosts at once http://www.fping.org/ * __fport 2.0__ Identify unknown open ports and their associated applications. http://www.foundstone.com/us/resources/proddesc/fport.htm * __fraud-bridge 10.775c563__ ICMP and DNS tunneling via IPv4 and IPv6. https://github.com/stealth/fraud-bridge * __freeipmi 1.4.5__ Sensor monitoring, system event monitoring, power control, and serial-over-LAN (SOL). http://www.gnu.org/software/freeipmi/ * __freeradius 3.0.4__ The premier open source RADIUS server http://www.freeradius.org/ * __frisbeelite 1.2__ A GUI-based USB device fuzzer. https://github.com/nccgroup/FrisbeeLite * __fs-nyarl 1.0__ A network takeover & forensic analysis tool - useful to advanced PenTest tasks & for fun and profit. http://www.fulgursecurity.com/en/content/fs-nyarl * __fsnoop 3.3__ A tool to monitor file operations on GNU/Linux systems by using the Inotify mechanism. Its primary purpose is to help detecting file race condition vulnerabilities and since version 3, to exploit them with loadable DSO modules (also called "payload modules" or "paymods"). http://vladz.devzero.fr/fsnoop.php * __fstealer 0.1__ Automates file system mirroring through remote file disclosur vulnerabilities on Linux machines. http://packetstormsecurity.com/files/106450/FStealer-Filesystem-Mirroring-Tool.html * __ftester 1.0__ A tool designed for testing firewall filtering policies and Intrusion Detection System (IDS) capabilities. http://www.inversepath.com/ftester.html * __ftp-fuzz 1337__ The master of all master fuzzing scripts specifically targeted towards FTP server sofware http://nullsecurity.net/tools/fuzzer.html * __ftp-scanner 0.2.5__ Multithreaded ftp scanner/brute forcer. Tested on Linux, OpenBSD and Solaris. http://wayreth.eu.org/old_page/ * __ftp-spider 1.0__ FTP investigation tool - Scans ftp server for the following: reveal entire directory tree structures, detect anonymous access, detect directories with write permissions, find user specified data within repository. http://packetstormsecurity.com/files/35120/ftp-spider.pl.html * __ftpmap 0.4__ scans remote FTP servers to identify what software and what versions they are running. http://wcoserver.googlecode.com/files/ * __fusil 1.4__ Fusil the fuzzer is a Python library used to write fuzzing programs. It helps to start process with a prepared environment (limit memory, environment variables, redirect stdout, etc.), start network client or server, and create mangled files http://bitbucket.org/haypo/fusil/wiki/Home * __fuzzap 14.f13932c__ A python script for obfuscating wireless networks. https://github.com/lostincynicism/FuzzAP * __fuzzball2 0.7__ A little fuzzer for TCP and IP options. It sends a bunch of more or less bogus packets to the host of your choice. http://nologin.org/ * __fuzzdb 1.09__ Attack and Discovery Pattern Database for Application Fuzz Testing https://code.google.com/p/fuzzdb/ * __fuzzdiff 1.0__ A simple tool designed to help out with crash analysis during fuzz testing. It selectively 'un-fuzzes' portions of a fuzzed file that is known to cause a crash, re-launches the targeted application, and sees if it still crashes. http://vsecurity.com/resources/tool * __fuzztalk 1.0.0.0__ An XML driven fuzz testing framework that emphasizes easy extensibility and reusability. https://code.google.com/p/fuzztalk * __g72x++ 1__ Decoder for the g72x++ codec. http://www.ps-auxw.de/ * __galleta 20040505_1__ Examine the contents of the IE's cookie files for forensic purposes http://www.jonesdykstra.com/ * __gdb 7.8.1__ The GNU Debugger http://www.gnu.org/software/gdb/ * __genlist 0.1__ Generates lists of IP addresses. * __geoedge 0.2__ This little tools is designed to get geolocalization information of a host, it get the information from two sources (maxmind and geoiptool). * __geoip 1.6.2__ Non-DNS IP-to-country resolver C library & utils http://www.maxmind.com/app/c * __geoipgen 0.4__ GeoIPgen is a country to IP addresses generator. http://code.google.com/p/geoipgen/ * __getsids 0.0.1__ Getsids tries to enumerate Oracle Sids by sending the services command to the Oracle TNS listener. Like doing ‘lsnrctl service’. http://www.cqure.net/wp/getsids/ * __gggooglescan 0.4__ A Google scraper which performs automated searches and returns results of search queries in the form of URLs or hostnames. http://www.morningstarsecurity.com/research/gggooglescan * __ghettotooth 1.0__ Ghettodriving for bluetooth http://www.oldskoolphreak.com/tfiles/ghettotooth.txt * __ghost-phisher 1.62__ GUI suite for phishing and penetration attacks http://code.google.com/p/ghost-phisher * __ghost-py 0.1b3__ Webkit based webclient (relies on PyQT). http://jeanphix.github.com/Ghost.py/ * __giskismet 20110805__ A program to visually represent the Kismet data in a flexible manner. http://www.giskismet.org * __gnuradio 3.7.5.1__ General purpose DSP and SDR toolkit. With drivers for usrp and fcd. http://gnuradio.org * __gnutls2 2.12.23__ A library which provides a secure layer over a reliable transport layer (Version 2) http://gnutls.org/ * __goldeneye 16.7a38fe9__ A HTTP DoS test tool. Attack Vector exploited: HTTP Keep Alive + NoCache. https://github.com/jseidl/GoldenEye * __golismero 2.0__ Opensource web security testing framework. https://github.com/golismero/golismero * __goodork 2.2__ A python script designed to allow you to leverage the power of google dorking straight from the comfort of your command line. http://goo-dork.blogspot.com/ * __goofile 1.5__ Command line filetype search https://code.google.com/p/goofile/ * __goog-mail 1.0__ Enumerate domain emails from google. http://www.darkc0de.com/others/goog-mail.py * __googlesub 1.2__ A python script to find domains by using google dorks. https://github.com/zombiesam/googlesub * __gooscan 1.0.9__ A tool that automates queries against Google search appliances, but with a twist. http://johnny.ihackstuff.com/downloads/task,doc_details&Itemid=/gid,28/ * __gqrx 2.3.1__ Interactive SDR receiver waterfall for many devices. http://gqrx.dk/ * __grabber 0.1__ A web application scanner. Basically it detects some kind of vulnerabilities in your website. http://rgaucher.info/beta/grabber/ * __grepforrfi 0.1__ Simple script for parsing web logs for RFIs and Webshells v1.2 http://www.irongeek.com/downloads/grepforrfi.txt * __grokevt 0.5.0__ A collection of scripts built for reading Windows® NT/2K/XP/2K eventlog files. http://code.google.com/p/grokevt/ * __gtalk-decode 0.1__ Google Talk decoder tool that demonstrates recovering passwords from accounts. http://packetstormsecurity.com/files/119154/Google-Talk-Decoder.html * __gtp-scan 0.7__ A small python script that scans for GTP (GPRS tunneling protocol) speaking hosts. http://www.c0decafe.de/ * __guymager 0.7.4__ A forensic imager for media acquisition. http://guymager.sourceforge.net/ * __gwcheck 0.1__ A simple program that checks if a host in an ethernet network is a gateway to Internet. http://packetstormsecurity.com/files/62047/gwcheck.c.html * __gwtenum 7.f27a5aa__ Enumeration of GWT-RCP method calls. http://www.gdssecurity.com/l/t/d.php?k=GwtEnum * __hackersh 0.2.0__ A shell for with Pythonect-like syntax, including wrappers for commonly used security tools http://www.hackersh.org/ * __halberd 0.2.4__ Halberd discovers HTTP load balancers. It is useful for web application security auditing and for load balancer configuration testing. http://halberd.superadditive.com/ * __halcyon 0.1__ A repository crawler that runs checksums for static files found within a given git repository. http://www.blackhatlibrary.net/Halcyon * __hamster 2.0.0__ Tool for HTTP session sidejacking. http://hamster.erratasec.com/ * __handle 0.0__ An small application designed to analyze your system searching for global objects related to running proccess and display information for every found object, like tokens, semaphores, ports, files,.. http://www.tarasco.org/security/handle/index.html * __hasere 1.0__ Discover the vhosts using google and bing. https://github.com/galkan/hasere * __hash-identifier 1.1__ Identifies the different types of hashes used to encrypt data, especially passwords http://code.google.com/p/hash-identifier * __hashcat 0.47__ A multithreaded cross platform hash cracker. http://hashcat.net/hashcat/ * ___hashcat-utils 1.0__ Utilites for Hashcat http://hashcat.net/wiki/doku.php?id=hashcat_utils * __hasher 32.e9d1394__ A tool that allows you to quickly hash plaintext strings, or compare hashed values with a plaintext locally. https://github.com/ChrisTruncer/Hasher * __hashid 2.6.0__ Software to identify the different types of hashes used to encrypt data https://github.com/psypanda/hashID * __hashpump 34.0b3c286__ A tool to exploit the hash length extension attack in various hashing algorithms. https://github.com/bwall/HashPump * __hashtag 0.41__ A python script written to parse and identify password hashes. https://github.com/SmeegeSec/HashTag * __haystack 1035.ac2ffa4__ A Python framework for finding C structures from process memory - heap analysis - Memory structures forensics. https://github.com/trolldbois/python-haystack * __hbad 1.0__ This tool allows you to test clients on the heartbleed bug. http://www.curesec.com/ * __hcraft 1.0.0__ HTTP Vuln Request Crafter http://sourceforge.net/projects/hcraft/ * __hdcp-genkey 18.e8d342d__ Generate HDCP source and sink keys from the leaked master key. https://github.com/rjw57/hdcp-genkey * __hdmi-sniff 5.f7fbc0e__ HDMI DDC (I2C) inspection tool. It is designed to demonstrate just how easy it is to recover HDCP crypto keys from HDMI devices. https://github.com/ApertureLabsLtd/hdmi-sniff * __heartbleed-honeypot 0.1__ Script that listens on TCP port 443 and responds with completely bogus SSL heartbeat responses, unless it detects the start of a byte pattern similar to that used in Jared Stafford's http://packetstormsecurity.com/files/126068/hb_honeypot.pl.txt * __hex2bin 1.0.7__ Converts Motorola and Intel hex files to binary. http://hex2bin.sourceforge.net/ * __hexinject 1.5__ A very versatile packet injector and sniffer that provides a command-line framework for raw network access. http://hexinject.sourceforge.net * __hexorbase 6__ A database application designed for administering and auditing multiple database servers simultaneously from a centralized location. It is capable of performing SQL queries and bruteforce attacks against common database servers (MySQL, SQLite, Microsoft SQL Server, Oracle, PostgreSQL). https://code.google.com/p/hexorbase/ * __hharp 1beta__ This tool can perform man-in-the-middle and switch flooding attacks. It has 4 major functions, 3 of which attempt to man-in-the-middle one or more computers on a network with a passive method or flood type method. http://packetstormsecurity.com/files/81368/Hackers-Hideaway-ARP-Attack-Tool.html * __hidattack 0.1__ HID Attack (attacking HID host implementations) http://mulliner.org/bluetooth/hidattack.php * __honeyd 1.6.7__ A small daemon that creates virtual hosts on a network. https://github.com/DataSoft/Honeyd/ * __honssh 47.0de60ec__ A high-interaction Honey Pot solution designed to log all SSH communications between a client and server. https://code.google.com/p/honssh/ * __hookanalyser 3.0__ A hook tool which can be potentially helpful in reversing applications and analyzing malware. It can hook to an API in a process and search for a pattern in memory or dump the buffer. http://hookanalyser.blogspot.de/ * __host-extract 9__ Ruby script tries to extract all IP/Host patterns in page response of a given URL and JavaScript/CSS files of that URL. https://code.google.com/p/host-extract/ * __hostbox-ssh 0.1.1__ A ssh password/account scanner. http://stridsmanit.wordpress.com/2012/12/02/brute-forcing-passwords-with-hostbox-ssh-1-1/ * __hotpatch 0.2__ Hot patches executables on Linux using .so file injection http://www.selectiveintellect.com/hotpatch.html * __hotspotter 0.4___ Hotspotter passively monitors the network for probe request frames to identify the preferred networks of Windows XP clients, and will compare it to a supplied list of common hotspot network names. http://www.remote-exploit.org/?page_id=418 * __hpfeeds__ 138.249b2f7 Honeynet Project generic authenticated datafeed protocol. https://github.com/rep/hpfeeds * __hping 3.0.0__ A command-line oriented TCP/IP packet assembler/analyzer. http://www.hping.org * __hqlmap 35.081395e__ A tool to exploit HQL Injections. https://github.com/PaulSec/HQLmap * __htexploit 0.77__ A Python script that exploits a weakness in the way that .htaccess files can be configured to protect a web directory with an authentication process http://www.mkit.com.ar/labs/htexploit/ * __htrosbif 134.9dc3f86__ Active HTTP server fingerprinting and recon tool. https://github.com/lkarsten/htrosbif * __htshells 760b5e9__ Self contained web shells and other attacks via .htaccess files. https://github.com/wireghoul/htshells * __http-enum 0.3__ A tool to enumerate the enabled HTTP methods supported on a webserver. https://www.thexero.co.uk/tools/http-enum/ * __http-fuzz 0.1__ A simple http fuzzer. none * __http-put 1.0__ Simple http put perl script * __http-traceroute 0.5__ This is a python script that uses the Max-Forwards header in HTTP and SIP to perform a traceroute-like scanning functionality. http://packetstormsecurity.com/files/107167/Traceroute-Like-HTTP-Scanner.html * __httpbog 1.0.0.0__ A slow HTTP denial-of-service tool that works similarly to other attacks, but rather than leveraging request headers or POST data Bog consumes sockets by slowly reading responses. http://sourceforge.net/projects/httpbog/ * __httpforge 11.02.01__ A set of shell tools that let you manipulate, send, receive, and analyze HTTP messages. These tools can be used to test, discover, and assert the security of Web servers, apps, and sites. An accompanying Python library is available for extensions. http://packetstormsecurity.com/files/98109/HTTPForge.02.01.html * __httping 2.3.4__ A 'ping'-like tool for http-requests. http://www.vanheusden.com/httping/ * __httprint 301__ A web server fingerprinting tool. http://www.net-square.com/httprint.html * __httprint-win32__ 301 A web server fingerprinting tool (Windows binaries). http://net-square.com/httprint * __httpry 0.1.8__ A specialized packet sniffer designed for displaying and logging HTTP traffic. http://dumpsterventures.com/jason/httpry/ * __httpsniff 0.4__ Tool to sniff HTTP responses from TCP/IP based networks and save contained files locally for later review. http://www.sump.org/projects/httpsniff/ * __httpsscanner 1.2__ A tool to test the strength of a SSL web server. https://code.google.com/p/libre-tools/ * __httptunnel 3.3__ Creates a bidirectional virtual data connection tunnelled in HTTP requests http://www.nocrew.org/software/httptunnel * __hulk 11.a9b9ad4__ A webserver DoS tool (Http Unbearable Load King) ported to Go with some additional features. https://github.com/grafov/hulk * __hwk 0.4__ Collection of packet crafting and wireless network flooding tools http://www.nullsecurity.net/ * __hydra 8.1__ A very fast network logon cracker which support many different services. http://www.thc.org/thc-hydra/ * __hyenae 0.36_1__ flexible platform independent packet generator http://sourceforge.net/projects/hyenae/ * __hyperion 1.1__ A runtime encrypter for 32-bit portable executables. http://nullsecurity.net/tools/binary.html * __iaxflood 0.1__ IAX flooder. http://www.hackingexposedvoip.com/ * __iaxscan 0.02__ A Python based scanner for detecting live IAX/2 hosts and then enumerating (by bruteforce) users on those hosts. http://code.google.com/p/iaxscan/ * __ibrute 12.3a6a11e__ An AppleID password bruteforce tool. It uses Find My Iphone service API, where bruteforce protection was not implemented. https://github.com/hackappcom/ibrute/ * __icmpquery 1.0__ Send and receive ICMP queries for address mask and current time. http://www.angio.net/security/ * __icmptx 0.01__ IP over ICMP http://thomer.com/icmptx/ * __iheartxor 0.01__ iheartxor is a tool for bruteforcing encoded strings within a boundary defined by a regular expression. It will bruteforce the key value range of 0x1 through 0x255. http://hooked-on-mnemonics.blogspot.com.es/p/iheartxor.html * __ike-scan 1.9__ A tool that uses IKE protocol to discover, fingerprint and test IPSec VPN servers http://www.nta-monitor.com/tools/ike-scan/ * __ikecrack 1.00__ An IKE/IPSec crack tool designed to perform Pre-Shared-Key analysis of RFC compliant aggressive mode authentication http://sourceforge.net/projects/ikecrack/ * __ikeprobe 0.1__ Determine vulnerabilities in the PSK implementation of the VPN server. http://www.ernw.de/download/ikeprobe.zip * __ikeprober 1.12__ Tool crafting IKE initiator packets and allowing many options to be manually set. Useful to find overflows, error conditions and identifiyng vendors http://ikecrack.sourceforge.net/ * __ilty 1.0__ An interception phone system for VoIP network. http://chdir.org/~nico/ilty/ * __imagejs 48.1faf262__ Small tool to package javascript into a valid image file. https://github.com/jklmnn/imagejs * __inception 416.2e7b723__ A FireWire physical memory manipulation and hacking tool exploiting IEEE 1394 SBP DMA. http://www.breaknenter.org/projects/inception/ * __indxparse 150.1b50750__ A Tool suite for inspecting NTFS artifacts. http://www.williballenthin.com/forensics/mft/indxparse/ * __inetsim 1.2.5__ A software suite for simulating common internet services in a lab environment, e.g. for analyzing the network behaviour of unknown malware samples. http://www.inetsim.org * __infip 0.1__ A python script that checks output from netstat against RBLs from Spamhaus. http://packetstormsecurity.com/files/104927/infIP.1-Blacklist-Checker.html * __inguma 0.1.1__ A free penetration testing and vulnerability discovery toolkit entirely written in python. Framework includes modules to discover hosts, gather information about, fuzz targets, brute force usernames and passwords, exploits, and a disassembler. http://inguma.sourceforge.net * __intercepter-ng 0.9.8__ A next generation sniffer including a lot of features: capturing passwords/hashes, sniffing chat messages, performing man-in-the-middle attacks, etc. http://intercepter.nerf.ru/#down * __interrogate 0.0.4__ A proof-of-concept tool for identification of cryptographic keys in binary material (regardless of target operating system), first and foremost for memory dump analysis and forensic usage. https://github.com/carmaa/interrogate * __intersect 2.5__ Post-exploitation framework https://github.com/ohdae/Intersect.5 * __intrace 1.5__ Traceroute-like application piggybacking on existing TCP connections http://intrace.googlecode.com * __inundator 0.5__ An ids evasion tool, used to anonymously inundate intrusion detection logs with false positives in order to obfuscate a real attack. http://inundator.sourceforge.net/ * __inviteflood 2.0__ Flood a device with INVITE requests https://launchpad.net/~wagungs/+archive/kali-linux/+build/4386635 * __iodine 0.7.0__ Tunnel IPv4 data through a DNS server http://code.kryo.se/iodine * __iosforensic 1.0__ iOS forensic tool https://www.owasp.org/index.php/Projects/OWASP_iOSForensic https://github.com/Flo354/iOSForensic * __ip-https-tools 5.b22e2b3__ Tools for the IP over HTTPS (IP-HTTPS) Tunneling Protocol. https://github.com/takeshixx/ip-https-tools * __ipaudit 1.0BETA2__ IPAudit monitors network activity on a network. http://ipaudit.sourceforge.net * __ipba2 032013__ IOS Backup Analyzer http://www.ipbackupanalyzer.com/ * __ipdecap 69.f3a08f6__ Can decapsulate traffic encapsulated within GRE, IPIP, 6in4, ESP (ipsec) protocols, and can also remove IEEE 802.1Q (virtual lan) header. http://www.loicp.eu/ipdecap#dependances * __iphoneanalyzer 2.1.0__ Allows you to forensically examine or recover date from in iOS device. http://www.crypticbit.com/zen/products/iphoneanalyzer * __ipscan 3.3.2__ Angry IP scanner is a very fast IP address and port scanner. http://www.angryziber.com/ * __iputils 20121221__ Network monitoring tools, including ping http://www.skbuff.net/iputils/ * __ipv6toolkit 2.0beta__ SI6 Networks' IPv6 Toolkit http://www.si6networks.com/tools/ipv6toolkit/ * __ircsnapshot 93.9ba3c6c__ Tool to gather information from IRC servers. https://github.com/bwall/ircsnapshot * __irpas 0.10__ Internetwork Routing Protocol Attack Suite. http://phenoelit-us.org/irpas * __isr-form 1.0__ Simple html parsing tool that extracts all form related information and generates reports of the data. Allows for quick analyzing of data. http://www.infobyte.com.ar/ * __jad 1.5.8e__ Java decompiler http://www.varaneckas.com/jad * __javasnoop 1.1__ A tool that lets you intercept methods, alter data and otherwise hack Java applications running on your computer https://code.google.com/p/javasnoop/ * __jboss-autopwn 1.3bc2d29__ A JBoss script for obtaining remote shell access. https://github.com/SpiderLabs/jboss-autopwn * __jbrofuzz 2.5__ Web application protocol fuzzer that emerged from the needs of penetration testing. http://sourceforge.net/projects/jbrofuzz/ * __jbrute 0.99__ Open Source Security tool to audit hashed passwords. http://sourceforge.net/projects/jbrute/ * __jd-gui 0.3.5__ A standalone graphical utility that displays Java source codes of .class files http://java.decompiler.free.fr/?q=jdgui * __jhead 2.97__ EXIF JPEG info parser and thumbnail remover http://www.sentex.net/~mwandel/jhead/ * __jigsaw 1.3__ A simple ruby script for enumerating information about a company's employees. It is useful for Social Engineering or Email Phishing. https://github.com/pentestgeek/jigsaw * __jnetmap 0.5.3__ A network monitor of sorts http://www.rakudave.ch/jnetmap/?file=introduction * __john 1.7.9__ John The Ripper - A fast password cracker (jumbo included) http://www.openwall.com/john/ * __johnny 20120424__ GUI for John the Ripper. http://openwall.info/wiki/john/johnny * __jomplug 0.1__ This php script fingerprints a given Joomla system and then uses Packet Storm's archive to check for bugs related to the installed components. http://packetstormsecurity.com/files/121390/Janissaries-Joomla-Fingerprint-Tool.html * __joomlascan 1.2__ Joomla scanner scans for known vulnerable remote file inclusion paths and files. http://packetstormsecurity.com/files/62126/joomlascan.2.py.txt.html * __joomscan 2012.03.10__ Detects file inclusion, sql injection, command execution vulnerabilities of a target Joomla! web site. http://joomscan.sourceforge.net/ * __js-beautify 1.4.2__ This little beautifier will reformat and reindent bookmarklets, ugly JavaScript, unpack scripts packed by Dean Edward?s popular packer, as well as deobfuscate scripts processed by javascriptobfuscator.com. https://github.com/einars/js-beautify * __jsql__ 0.5 A lightweight application used to find database information from a distant server. https://code.google.com/p/jsql-injection/ * __junkie 1338.baa4524__ A modular packet sniffer and analyzer. https://github.com/securactive/junkie * __jwscan 6.b0306f0__ Scanner for Jar to EXE wrapper like Launch4j, Exe4j, JSmooth, Jar2Exe. https://github.com/katjahahn/JWScan * __jynx2 2.0__ An expansion of the original Jynx LD_PRELOAD rootkit http://www.blackhatlibrary.net/Jynx2 * __kalibrate-rtl 11.aae11c8__ Fork of http://thre.at/kalibrate/ for use with rtl-sdr devices. https://github.com/steve-m/kalibrate-rtl * __katsnoop 0.1__ Utility that sniffs HTTP Basic Authentication information and prints the base64 decoded form. http://packetstormsecurity.com/files/52514/katsnoop.tbz2.html * __kautilya 0.5.0__ Pwnage with Human Interface Devices using Teensy++2.0 and Teensy 3.0 devices http://code.google.com/p/kautilya * __keimpx 0.2__ Tool to verify the usefulness of credentials across a network over SMB. http://code.google.com/p/keimpx/ * __khc 0.2__ A small tool designed to recover hashed known_hosts fiels back to their plain-text equivalents. http://packetstormsecurity.com/files/87003/Known-Host-Cracker.2.html * __killerbee 85__ Framework and tools for exploiting ZigBee and IEEE 802.15.4 networks. https://code.google.com/p/killerbee/ * __kippo 0.9__ A medium interaction SSH honeypot designed to log brute force attacks and most importantly, the entire shell interaction by the attacker. https://github.com/desaster/kippo * __kismet 2013_03_R1b 802.11__ layer2 wireless network detector, sniffer, and intrusion detection system http://www.kismetwireless.net/ * __kismet-earth 0.1__ Various scripts to convert kismet logs to kml file to be used in Google Earth. http:// * __kismet2earth 1.0__ A set of utilities that convert from Kismet logs to Google Earth .kml format http://code.google.com/p/kismet2earth/ * __klogger 1.0__ A keystroke logger for the NT-series of Windows. http://ntsecurity.nu/toolbox/klogger/ * __kolkata 3.0__ A web application fingerprinting engine written in Perl that combines cryptography with IDS evasion. http://www.blackhatlibrary.net/Kolkata * __kraken 32.368a837__ A project to encrypt A5/1 GSM signaling using a Time/Memory Tradeoff Attack. http://opensource.srlabs.de/projects/a51-decrypt * __laf 12.7a456b3__ Login Area Finder: scans host/s for login panels. https://github.com/takeshixx/laf * __lanmap2 124.4f8afed__ Passive network mapping tool http://github.com/rflynn/lanmap2 * __lans 1.0__ A Multithreaded asynchronous packet parsing/injecting arp spoofer. https://github.com/DanMcInerney/LANs.py * __latd 1.31__ A LAT terminal daemon for Linux and BSD. http://sourceforge.net/projects/linux-decnet/files/latd/1.31/ * __laudanum 1.0__ A collection of injectable files, designed to be used in a pentest when SQL injection flaws are found and are in multiple languages for different environments. http://laudanum.inguardians.com/# * __lbd 20130719__ Load Balancing detector http://ge.mine.nu/code/lbd * __lbmap 145.93e6b71__ Proof of concept scripts for advanced web application fingerprinting, presented at OWASP AppSecAsia 2012. https://github.com/wireghoul/lbmap * __ldapenum 0.1__ Enumerate domain controllers using LDAP. https://gobag.googlecode.com/svn-history/r2/trunk/ldap/ldapenum/ * __leo 4.11__ Literate programmer's editor, outliner, and project manager http://webpages.charter.net/edreamleo/front.html * __leroy-jenkins 0.r3.bdc3965__ A python tool that will allow remote execution of commands on a Jenkins server and its nodes. https://github.com/captainhooligan/Leroy-Jenkins * __levye 85.419e817__ A brute force tool which is support sshkey, vnckey, rdp, openvpn. https://github.com/galkan/levye * __lfi-autopwn 3.0__ A Perl script to try to gain code execution on a remote server via LFI http://www.blackhatlibrary.net/Lfi_autopwn.pl * __lfi-exploiter 1.1__ This perl script leverages /proc/self/environ to attempt getting code execution out of a local file inclusion vulnerability.. http://packetstormsecurity.com/files/124332/LFI-Exploiter.1.html * __lfi-fuzzploit 1.1__ A simple tool to help in the fuzzing for, finding, and exploiting of local file inclusion vulnerabilities in Linux-based PHP applications. http://packetstormsecurity.com/files/106912/LFI-Fuzzploit-Tool.1.html * __lfi-scanner 4.0__ This is a simple perl script that enumerates local file inclusion attempts when given a specific target. http://packetstormsecurity.com/files/102848/LFI-Scanner.0.html * __lfi-sploiter 1.0__ This tool helps you exploit LFI (Local File Inclusion) vulnerabilities. Post discovery, simply pass the affected URL and vulnerable parameter to this tool. You can also use this tool to scan a URL for LFI vulnerabilities. http://packetstormsecurity.com/files/96056/Simple-Local-File-Inclusion-Exploiter.0.html * __lfimap 1.4.8__ This script is used to take the highest beneficts of the local file include vulnerability in a webserver. https://code.google.com/p/lfimap/ * __lft 3.72__ A layer four traceroute implementing numerous other features. http://pwhois.org/lft/ * __libdisasm 0.23__ A disassembler library. http://bastard.sourceforge.net/libdisasm.html * __libpst 0.6.63__ Outlook .pst file converter http://www.five-ten-sg.com/libpst/ * __liffy 63.238ce6d__ A Local File Inclusion Exploitation tool. https://github.com/rotlogix/liffy * __linenum 18.b4c2541__ Scripted Local Linux Enumeration & Privilege Escalation Checks https://github.com/rebootuser/LinEnum * __linux-exploit-suggester 32.9db2f5a__ A Perl script that tries to suggest exploits based OS version number. https://github.com/PenturaLabs/Linux_Exploit_Suggester * __list-urls 0.1__ Extracts links from webpage http://www.whoppix.net * __littleblackbox 0.1.3__ Penetration testing tool, search in a collection of thousands of private SSL keys extracted from various embedded devices. http://code.google.com/p/littleblackbox/wiki/FAQ * __lodowep 1.2.1__ Lodowep is a tool for analyzing password strength of accounts on a Lotus Domino webserver system. http://www.cqure.net/wp/lodowep/ * __logkeys 0.1.1a__ Simple keylogger supporting also USB keyboards. http://logkeys.googlecode.com/ * __loki 0.2.7___ Python based framework implementing many packet generation and attack modules for Layer 2 and 3 protocols http://c0decafe.de/loki.html * __lorcon 2.0.0.20091101__ Generic library for injecting 802.11 frames http://802.11ninja.net/ * __lotophagi 0.1__ a relatively compact Perl script designed to scan remote hosts for default (or common) Lotus NSF and BOX databases. http://packetstormsecurity.com/files/55250/lotophagi.rar.html * __lsrtunnel 0.2__ lsrtunnel spoofs connections using source routed packets. http://www.synacklabs.net/projects/lsrtunnel/ * __luksipc 0.01__ A tool to convert unencrypted block devices to encrypted LUKS devices in-place. http://www.johannes-bauer.com/linux/luksipc * __lynis 1.6.4__ An auditing tool for Unix (specialists). http://www.rootkit.nl/projects/lynis.html * __mac-robber 1.02__ A digital investigation tool that collects data from allocated files in a mounted file system. http://www.sleuthkit.org/mac-robber/download.php * __macchanger 1.6.0__ A small utility to change your NIC's MAC address http://ftp.gnu.org/gnu/macchanger * __maclookup 0.3__ Lookup MAC addresses in the IEEE MA-L/OUI public listing. https://github.com/paraxor/maclookup * __magicrescue 1.1.9__ Find and recover deleted files on block devices http://freshmeat.net/projects/magicrescue/ * __magictree 1.3__ A penetration tester productivity tool designed to allow easy and straightforward data consolidation, querying, external command execution and report generation http://www.gremwell.com * __make-pdf 0.1.5__ This tool will embed javascript inside a PDF document. http://blog.didierstevens.com/programs/pdf-tools/ * __makepasswd 1.10_9__ Generates true random passwords with the emphasis on security over pronounceability (Debian version) http://packages.qa.debian.org/m/makepasswd.html * __malheur 0.5.4__ A tool for the automatic analyze of malware behavior. http://www.mlsec.org/malheur/ * __maligno 1.2__ An open source penetration testing tool written in python, that serves Metasploit payloads. It generates shellcode with msfvenom and transmits it over HTTP or HTTPS. http://www.encripto.no/tools/ * __malmon 0.3__ Hosting exploit/backdoor detection daemon. It's written in python, and uses inotify (pyinotify) to monitor file system activity. It checks files smaller then some size, compares their md5sum and hex signatures against DBs with known exploits/backdoor. http://sourceforge.net/projects/malmon/ * __maltego 3.5.3__ An open source intelligence and forensics application, enabling to easily gather information about DNS, domains, IP addresses, websites, persons, etc. http://www.paterva.com/web5 * __maltrieve 148.4ad4045__ Originated as a fork of mwcrawler. It retrieves malware directly from the sources as listed at a number of sites. https://github.com/technoskald/maltrieve * __malware-check-tool 1.2__ Python script that detects malicious files via checking md5 hashes from an offline set or via the virustotal site. It has http proxy support and an update feature. http://packetstormsecurity.com/files/93518/Malware-Check-Tool.2.html * __malwareanalyser 3.3__ A freeware tool to perform static and dynamic analysis on malware. http://malwareanalyser.blogspot.de/2011/10/malware-analyser.html * __malwaredetect 0.1__ Submits a file's SHA1 sum to VirusTotal to determine whether it is a known piece of malware http://www.virustotal.com * __malwasm 0.2__ Offline debugger for malware's reverse engineering. https://code.google.com/p/malwasm/ marc4dasm 6.f11860f This python-based tool is a disassembler for the Atmel MARC4 (a 4 bit Harvard micro). https://github.com/ApertureLabsLtd/marc4dasm * __maskprocessor 0.71__ A High-Performance word generator with a per-position configurable charset. http://hashcat.net/wiki/doku.php?id=maskprocessor * __masscan 391.a60cc70__ TCP port scanner, spews SYN packets asynchronously, scanning entire Internet in under 5 minutes. https://github.com/robertdavidgraham/masscan * __mat 0.5__ Metadata Anonymisation Toolkit composed of a GUI application, a CLI application and a library. https://mat.boum.org/ * __matahari 0.1.30__ A reverse HTTP shell to execute commands on remote machines behind firewalls. http://matahari.sourceforge.net * __mausezahn 0.40__ A free fast traffic generator written in C which allows you to send nearly every possible and impossible packet. http://www.perihel.at/sec/mz/ * __mbenum 1.5.0__ Queries the master browser for whatever information it has registered. http://www.cqure.net/wp/mbenum/ * __mboxgrep 0.7.9__ Mboxgrep is a small, non-interactive utility that scans mail folders for messages matching regular expressions. It does matching against basic and extended POSIX regular expressions, and reads and writes a variety of mailbox formats. http://mboxgrep.sourceforge.net * __md5deep 4.3__ Advanced checksum hashing tool http://md5deep.sourceforge.net * __mdbtools 0.7.1__ Utilities for viewing data and exporting schema from Microsoft Access Database files http://sourceforge.net/projects/mdbtools/ * __mdcrack 1.2__ MD4/MD5/NTLM1 hash cracker http://c3rb3r.openwall.net/mdcrack/ * __mdk3 6__ WLAN penetration tool http://homepages.tu-darmstadt.de/~p_larbig/wlan/ * __mdns-scan 0.5__ Scan mDNS/DNS-SD published services on the local network. * __medusa 2.1.1__ A speedy, massively parallel, modular, login brute-forcer for network. http://www.foofus.net/jmk/medusa/medusa.html * __melkor 1.0__ An ELF fuzzer that mutates the existing data in an ELF sample given to create orcs (malformed ELFs), however, it does not change values randomly (dumb fuzzing), instead, it fuzzes certain metadata with semi-valid values through the use of fuzzing rules (knowledge base). http://packetstormsecurity.com/files/127924/Melkor-ELF-Fuzzer.0.html * __memdump 1.01__ Dumps system memory to stdout, skipping over holes in memory maps. http://www.porcupine.org/forensics/tct.html * __memfetch 0.05b__ dumps any userspace process memory without affecting its execution http://lcamtuf.coredump.cx/ * __metacoretex 0.8.0__ MetaCoretex is an entirely JAVA vulnerability scanning framework for databases. http://metacoretex.sourceforge.net/ * __metagoofil 1.4b__ An information gathering tool designed for extracting metadata of public documents http://www.edge-security.com/metagoofil.php * __metasploit 29270.738fc78__ An open source platform that supports vulnerability research, exploit development and the creation of custom security tools representing the largest collection of quality-assured exploits. http://www.metasploit.com * __metoscan 05__ Tool for scanning the HTTP methods supported by a webserver. It works by testing a URL and checking the responses for the different requests. http://www.open-labs.org/ * __mfcuk 0.3.8__ MIFARE Classic Universal toolKit http://code.google.com/p/mfcuk/ * __mfoc 0.10.7__ Mifare Classic Offline Cracker http://code.google.com/p/mfoc/ * __mfsniffer 0.1__ A python script for capturing unencrypted TSO login credentials. http://packetstormsecurity.com/files/120802/MF-Sniffer-TN3270-Password-Grabber.html * __mibble 2.9.3__ Mibble is an open-source SNMP MIB parser (or SMI parser) written in Java. It can be used to read SNMP MIB files as well as simple ASN.1 files. http://www.mibble.org/ * __middler 1.0__ A Man in the Middle tool to demonstrate protocol middling attacks. http://code.google.com/p/middler/ * __minimysqlator 0.5__ A multi-platform application used to audit web sites in order to discover and exploit SQL injection vulnerabilities. http://www.scrt.ch/en/attack/downloads/mini-mysqlat0r * __miranda-upnp 1.3__ A Python-based Universal Plug-N-Play client application designed to discover, query and interact with UPNP devices http://code.google.com/p/miranda-upnp/ * __miredo 1.2.6__ Teredo client and server. http://www.remlab.net/miredo/ * __missidentify 1.0__ A program to find Win32 applications http://missidentify.sourceforge.net/ * __missionplanner 1.2.55__ A GroundControl Station for Ardupilot. https://code.google.com/p/ardupilot-mega/wiki/Mission * __mitmap 0.1__ Shell Script for launching a Fake AP with karma functionality and launches ettercap for packet capture and traffic manipulation. http://www.darkoperator.com/tools-and-scripts/ * __mitmer 22.b01c7fe__ A man-in-the-middle and phishing attack tool that steals the victim's credentials of some web services like Facebook. https://github.com/husam212/MITMer * __mitmf 169.83b4a93__ A Framework for Man-In-The-Middle attacks written in Python. https://github.com/byt3bl33d3r/MITMf * __mitmproxy 0.10.1__ SSL-capable man-in-the-middle HTTP proxy http://mitmproxy.org/ * __mkbrutus 1.0.2__ Password bruteforcer for MikroTik devices or boxes running RouterOS. http://mkbrutusproject.github.io/MKBRUTUS/ * __mobiusft 0.5.21__ An open-source forensic framework written in Python/GTK that manages cases and case items, providing an abstract interface for developing extensions. http://savannah.nongnu.org/projects/mobiusft * __modscan 0.1__ A new tool designed to map a SCADA MODBUS TCP based network. https://code.google.com/p/modscan/ * __moloch 0.9.2__ An open source large scale IPv4 full PCAP capturing, indexing and database system. https://github.com/aol/moloch * __monocle 1.0__ A local network host discovery tool. In passive mode, it will listen for ARP request and reply packets. In active mode, it will send ARP requests to the specific IP range. The results are a list of IP and MAC addresses present on the local network. http://packetstormsecurity.com/files/99823/Monocle-Host-Discovery-Tool.0.html * __morxbrute 1.01__ A customizable HTTP dictionary-based password cracking tool written in Perl http://www.morxploit.com/morxbrute/ * __morxcrack 1.2__ A cracking tool written in Perl to perform a dictionary-based attack on various hashing algorithm and CMS salted-passwords. http://www.morxploit.com/morxcrack/ * __mp3nema 0.4__ A tool aimed at analyzing and capturing data that is hidden between frames in an MP3 file or stream, otherwise noted as "out of band" data. http://packetstormsecurity.com/files/76432/MP3nema-Forensic-Analysis-Tool.html * __mptcp 1.9.0__ A tool for manipulation of raw packets that allows a large number of options. http://packetstormsecurity.com/files/119132/Mptcp-Packet-Manipulator.9.0.html * __mptcp-abuse 6.b0eeb27__ A collection of tools and resources to explore MPTCP on your network. Initially released at Black Hat USA 2014. https://github.com/Neohapsis/mptcp-abuse * __ms-sys 2.4.0__ A tool to write Win9x-.. master boot records (mbr) under linux - RTM! http://ms-sys.sourceforge.net/ * __mssqlscan 0.8.4__ A small multi-threaded tool that scans for Microsoft SQL Servers. http://www.cqure.net/wp/mssqlscan/ * __msvpwn 0.1.r23.g328921b__ Bypass Windows' authentication via binary patching. https://bitbucket.org/mrabault/msvpwn * __mtr 0.85__ Combines the functionality of traceroute and ping into one tool (CLI version) http://www.bitwizard.nl/mtr/ * __multiinjector 0.3__ Automatic SQL injection utility using a lsit of URI addresses to test parameter manipulation. http://chaptersinwebsecurity.blogspot.de/2008/11/multiinjector-v03-released.html * __multimac 1.0.3__ Multiple MACs on an adapter http://sourceforge.net/projects/multimac/ * __multitun 43.9804513__ Tunnel arbitrary traffic through an innocuous WebSocket. https://github.com/covertcodes/multitun * __mutator 51.164132d__ This project aims to be a wordlist mutator with hormones, which means that some mutations will be applied to the result of the ones that have been already done, resulting in something like: corporation -> C0rp0r4t10n_2012 https://bitbucket.org/alone/mutator/ * __mysql2sqlite 1.dd87f4__ Converts a mysqldump file into a Sqlite 3 compatible file https://gist.github.com/esperlu/943776 * __nacker 23.b67bb39__ A tool to circumvent 802.1x Network Access Control on a wired LAN. https://github.com/carmaa/nacker * __nbnspoof 1.0__ NBNSpoof - NetBIOS Name Service Spoofer http://www.mcgrewsecurity.com/tools/nbnspoof/ * __nbtenum 3.3__ A utility for Windows that can be used to enumerate NetBIOS information from one host or a range of hosts. http://reedarvin.thearvins.com/ * __nbtool 2.bf90c76__ Some tools for NetBIOS and DNS investigation, attacks, and communication. http://wiki.skullsecurity.org/Nbtool * __nbtscan 1.5.1__ NBTscan is a program for scanning IP networks for NetBIOS name information. http://www.inetcat.net/software/nbtscan.html * __ncpfs 2.2.6__ Allows you to mount volumes of NetWare servers under Linux. http://www.novell.com/ * __ncrack 0.4a__ A high-speed network authentication cracking tool http://nmap.org/ncrack/ * __nemesis 1.4__ command-line network packet crafting and injection utility http://nemesis.sourceforge.net/ * __netactview 0.6.2__ A graphical network connections viewer for Linux similar in functionality with Netstat http://netactview.sourceforge.net/index.html * __netbios-share-scanner 1.0__ This tool could be used to check windows workstations and servers if they have accessible shared resources. http://www.secpoint.com/netbios-share-scanner.html * __netcommander 1.3__ An easy-to-use arp spoofing tool. https://github.com/evilsocket/netcommander * __netcon 0.1__ A network connection establishment and management script. http://www.paramecium.org/~leendert/ * __netdiscover 0.3__ An active/passive address reconnaissance tool, mainly developed for those wireless networks without dhcp server, when you are wardriving. It can be also used on hub/switched networks. http://nixgeneration.com/~jaime/netdiscover/ * __netmap 0.1.3__ Can be used to make a graphical representation of the surounding network. http://netmap.sourceforge.net * __netmask 2.3.12__ Helps determine network masks http://packages.qa.debian.org/n/netmask.html * __netreconn 1.76__ A collection of network scan/recon tools that are relatively small compared to their larger cousins. http://packetstormsecurity.com/files/86076/NetReconn-Scanning-Tool-Collection.76.html * __netscan 1.0__ Tcp/Udp/Tor port scanner with: synpacket, connect TCP/UDP and socks5 (tor connection). http://packetstormsecurity.com/files/125569/Netscan-Port-Scanner.0.html * __netsed 1.2__ Small and handful utility design to alter the contents of packets forwarded thru network in real time. http://silicone.homelinux.org/projects/netsed/ * __netsniff-ng 0.5.8__ A high performance Linux network sniffer for packet inspection. http://netsniff-ng.org/ * __netzob 0.4.1__ An open source tool for reverse engineering, traffic generation and fuzzing of communication protocols. http://www.netzob.org/ * __nfcutils 0.3.2__ Provides a simple 'lsnfc' command that list tags which are in your NFC device field http://code.google.com/p/nfc-tools * __nfex 2.5__ A tool for extracting files from the network in real-time or post-capture from an offline tcpdump pcap savefile. It is based off of the code-base from the apparently defunct project tcpxtract. https://code.google.com/p/nfex/ * __nfspy 1.0__ A Python library for automating the falsification of NFS credentials when mounting an NFS share. https://github.com/bonsaiviking/NfSpy * __nfsshell 19980519__ Userland NFS command tool. http://www.paramecium.org/~leendert/ * __ngrep 1.45__ A grep-like utility that allows you to search for network packets on an interface. http://ngrep.sourceforge.net/ * __nield 0.5.1__ A tool to receive notifications from kernel through netlink socket, and generate logs related to interfaces, neighbor cache(ARP,NDP), IP address(IPv4,IPv6), routing, FIB rules, traffic control. http://nield.sourceforge.net/ * __nikto 2.1.5__ A web server scanner which performs comprehensive tests against web servers for multiple items http://www.cirt.net/nikto2 * __nimbostratus 54.c7c206f__ Tools for fingerprintinging and exploiting Amazon cloud infrastructures. https://github.com/andresriancho/nimbostratus * __nipper 0.11.7__ Network Infrastructure Parser https://www.titania-security.com/ * __nishang 0.4.0__ Using PowerShell for Penetration Testing. https://code.google.com/p/nishang/ * __nkiller2 2.0__ A TCP exhaustion/stressing tool. http://sock-raw.org/projects.html * __nmap 6.47__ Utility for network discovery and security auditing http://nmap.org/ * __nmbscan 1.2.6__ Tool to scan the shares of a SMB/NetBIOS network, using the NMB/SMB/NetBIOS protocols. http://nmbscan.gbarbier.org/ * __nomorexor 0.1__ Tool to help guess a files 256 byte XOR key by using frequency analysis https://github.com/hiddenillusion/NoMoreXOR * __notspikefile 0.1__ A Linux based file format fuzzing tool http://packetstormsecurity.com/files/39627/notSPIKEfile.tgz.html * __nsdtool 0.1__ A netgear switch discovery tool. It contains some extra features like bruteoforce and setting a new password. http://www.curesec.com/en/publications/tools.html * __nsec3walker 20101223__ Enumerates domain names using DNSSEC http://dnscurve.org/nsec3walker.html * __ntds-decode 0.1__ This application dumps LM and NTLM hashes from active accounts stored in an Active Directory database. http://packetstormsecurity.com/files/121543/NTDS-Hash-Decoder.b.html * __o-saft 513.6bcc35b__ A tool to show informations about SSL certificate and tests the SSL connection according given list of ciphers and various SSL configurations. https://www.owasp.org/index.php/O-Saft * __oat 1.3.1__ A toolkit that could be used to audit security within Oracle database servers. http://www.cqure.net/wp/test/ * __obexstress 0.1__ Script for testing remote OBEX service for some potential vulnerabilities. http://bluetooth-pentest.narod.ru/ * __obfsproxy 0.2.12__ A pluggable transport proxy written in Python. https://pypi.python.org/pypi/obfsproxy * __oclhashcat 1.30__ Worlds fastest WPA cracker with dictionary mutation engine. http://hashcat.net/oclhashcat/ * __ocs 0.2__ Compact mass scanner for Cisco routers with default telnet/enable passwords. http://packetstormsecurity.com/files/119462/OCS-Cisco-Scanner.2.html * __ohrwurm 0.1__ A small and simple RTP fuzzer. http://mazzoo.de/ * __ollydbg 201g__ A 32-bit assembler-level analysing debugger http://www.ollydbg.de * __onesixtyone 0.7__ An SNMP scanner that sends multiple SNMP requests to multiple IP addresses http://labs.portcullis.co.uk/application/onesixtyone/ * __onionshare 439.027d774__ Securely and anonymously share a file of any size. https://github.com/micahflee/onionshare/ * __openstego 0.6.1__ A tool implemented in Java for generic steganography, with support for password-based encryption of the data. http://www.openstego.info/ * __opensvp 64.56b2b8f__ A security tool implementing "attacks" to be able to the resistance of firewall to protocol level attack. https://github.com/regit/opensvp * __openvas-cli 1.3.1__ The OpenVAS Command-Line Interface http://www.openvas.org/ * __openvas-libraries 7.0.6__ The OpenVAS libraries http://www.openvas.org/ * __openvas-manager 5.0.7__ A layer between the OpenVAS Scanner and various client applications http://www.openvas.org/ * __openvas-scanner 4.0.5__ The OpenVAS scanning Daemon http://www.openvas.org/ * __ophcrack 3.6.0__ A free Windows password cracker based on rainbow tables http://ophcrack.sourceforge.net * __orakelcrackert 1.00__ This tool can crack passwords which are encrypted using Oracle's latest SHA1 based password protection algorithm. http://freeworld.thc.org/thc-orakelcrackert11g/ * __origami 1.2.7__ Aims at providing a scripting tool to generate and analyze malicious PDF files. http://code.google.com/p/origami-pdf * __oscanner 1.0.6__ An Oracle assessment framework developed in Java. http://www.cqure.net/wp/oscanner/ * __ostinato 0.5.1__ An open-source, cross-platform packet/traffic generator and analyzer with a friendly GUI. It aims to be "Wireshark in Reverse" and thus become complementary to Wireshark. http://code.google.com/p/ostinato/ * __osueta 65.90323e2__ A simple Python script to exploit the OpenSSH User Enumeration Timing Attack. https://github.com/c0r3dump3d/osueta * __owabf 1.3__ Outlook Web Access bruteforcer tool. http://netsec.rs/70/tools.html * __owasp-bywaf 26.e730d1b__ A web application penetration testing framework (WAPTF). https://github.com/depasonico/OWASP-ByWaf * __owtf 1016.fef357e__ The Offensive (Web) Testing Framework. https://www.owasp.org/index.php/OWASP_OWTF * __p0f 3.08b__ Purely passive TCP/IP traffic fingerprinting tool. http://lcamtuf.coredump.cx/p0f3/ * __pack 0.0.4__ Password Analysis and Cracking Kit http://thesprawl.org/projects/pack/ * __packerid 1.4__ Script which uses a PEiD database to identify which packer (if any) is being used by a binary. http://handlers.sans.org/jclausing/ * __packet-o-matic 351__ A real time packet processor. Reads the packet from an input module, match the packet using rules and connection tracking information and then send it to a target module. http://www.packet-o-matic.org/ * __packeth 1.7.2__ A Linux GUI packet generator tool for ethernet. http://packeth.sourceforge.net/ * __packit 1.0__ A network auditing tool. Its value is derived from its ability to customize, inject, monitor, and manipulate IP traffic. http://packit.sourceforge.net/ * __pacumen 1.92a0884__ Packet Acumen - Analyse encrypted network traffic and more (side-channel attacks). https://github.com/bniemczyk/pacumen * __padbuster 0.3.3__ Automated script for performing Padding Oracle attacks. http://www.gdssecurity.com/l/t.php * __paketto 1.10__ Advanced TCP/IP Toolkit. http://www.doxpara.com/paketto * __panoptic 178.73b2b4c__ A tool that automates the process of search and retrieval of content for common log and config files through LFI vulnerability. https://github.com/lightos/Panoptic * __paros 3.2.13__ Java-based HTTP/HTTPS proxy for assessing web app vulnerabilities. Supports editing/viewing HTTP messages on-the-fly, spiders, client certificates, proxy-chaining, intelligent scanning for XSS and SQLi, etc. http://www.parosproxy.org * __parsero 56.fc5f7ec__ A robots.txt audit tool. https://github.com/behindthefirewalls/Parsero * __pasco 20040505_1__ Examines the contents of Internet Explorer's cache files for forensic purposes http://www.jonesdykstra.com/ * __passcracking 20131214__ A little python script for sending hashes to passcracking.com and milw0rm http://github.com/jensp/passcracking * __passe-partout 0.1__ Tool to extract RSA and DSA private keys from any process linked with OpenSSL. The target memory is scanned to lookup specific OpenSSL patterns. http://www.hsc.fr/ressources/outils/passe-partout/index.html.en * __passivedns 1.1.3__ A network sniffer that logs all DNS server replies for use in a passive DNS setup. https://github.com/gamelinux/passivedns * __pastenum 0.4.1__ Search Pastebins for content, fork from nullthreat corelan pastenum2 http://github.com/shadowbq/pastenum * __patator 80.5a140c1__ A multi-purpose bruteforcer. https://github.com/lanjelot/patator * __pathod 0.11.1__ Crafted malice for tormenting HTTP clients and servers. http://pathod.net/ * __pblind 1.0__ Little utility to help exploiting blind sql injection vulnerabilities. http://www.edge-security.com/pblind.php * __pcapsipdump 0.2__ A tool for dumping SIP sessions (+RTP traffic, if available) to disk in a fashion similar to 'tcpdump -w' (format is exactly the same), but one file per sip session (even if there is thousands of concurrect SIP sessions). http://pcapsipdump.sourceforge.net/ * __pcredz 0.9__ A tool that extracts credit card numbers, NTLM(DCE-RPC, HTTP, SQL, LDAP, etc), Kerberos (AS-REQ Pre-Auth etype 23), HTTP Basic, SNMP, POP, SMTP, FTP, IMAP, and more from a pcap file or from a live interface. https://github.com/lgandx/PCredz * __pdf-parser 0.4.2__ Parses a PDF document to identify the fundamental elements used in the analyzed file http://blog.didierstevens.com/programs/pdf-tools/ * __pdfbook-analyzer 2__ Utility for facebook memory forensics. http://sourceforge.net/projects/pdfbook/ * __pdfcrack 0.12__ Password recovery tool for PDF-files. http://pdfcrack.sourceforge.net/ * __pdfid 0.1.2__ scan a file to look for certain PDF keywords http://blog.didierstevens.com/programs/pdf-tools/ * __pdfresurrect 0.12__ A tool aimed at analyzing PDF documents. http://packetstormsecurity.com/files/118459/PDFResurrect-PDF-Analyzer.12.html * __pdgmail 1.0__ A password dictionary attack tool that targets windows authentication via the SMB protocol http://www.jeffbryner.com/code/pdgmail * __peach 3.0.202__ A SmartFuzzer that is capable of performing both generation and mutation based fuzzing http://peachfuzzer.com/ * __peda 51.327db44__ Python Exploit Development Assistance for GDB. https://github.com/longld/peda * __peepdf 0.3__ A Python tool to explore PDF files in order to find out if the file can be harmful or not http://eternal-todo.com/tools/peepdf-pdf-analysis-tool * __pentbox 1.8__ A security suite that packs security and stability testing oriented tools for networks and systems. http://www.pentbox.net * __perl-image-exiftool 9.76__ Reader and rewriter of EXIF informations that supports raw files http://search.cpan.org/perldoc?exiftool * __perl-tftp 1.0b3__ TFTP - TFTP Client class for perl http://search.cpan.org/~gsm/TFTP/TFTP.pm * __pev 0.60__ Command line based tool for PE32/PE32+ file analysis http://pev.sourceforge.net/ * __pextractor 0.18b__ A forensics tool that can extract all files from an executable file created by a joiner or similar. http://packetstormsecurity.com/files/62977/PExtractor_v0.18b_binary_and_src.rar.html * __pgdbf 94.baa1d95__ Convert XBase / FoxPro databases to PostgreSQL https://github.com/kstrauser/pgdbf * __phoss 0.1.13__ Sniffer designed to find HTTP, FTP, LDAP, Telnet, IMAP4, VNC and POP3 logins. http://www.phenoelit.org/fr/tools.html * __php-mt-seed 3.2__ PHP mt_rand() seed cracker http://www.openwall.com/php_mt_seed/ * __php-rfi-payload-decoder 30.bd42caa__ Decode and analyze RFI payloads developed in PHP. https://github.com/bwall/PHP-RFI-Payload-Decoder * __php-vulnerability-hunter 1.4.0.20__ An whitebox fuzz testing tool capable of detected several classes of vulnerabilities in PHP web applications. https://phpvulnhunter.codeplex.com/ * __phpstress 5.f987a7e__ A PHP denial of service / stress test for Web Servers running PHP-FPM or PHP-CGI. https://github.com/nightlionsecurity/phpstress * __phrasendrescher 1.2.2__ A modular and multi processing pass phrase cracking tool http://www.leidecker.info/projects/phrasendrescher/ * __pipal 1.1__ A password analyser http://www.digininja.org/projects/pipal.php * __pirana 0.3.1__ Exploitation framework that tests the security of a email content filter. http://www.guay-leroux.com/projects.html * __plcscan 0.1__ This is a tool written in Python that will scan for PLC devices over s7comm or modbus protocols. http://packetstormsecurity.com/files/119726/PLC-Device-Scanner.html * __plecost 2__ Wordpress finger printer tool search and retrieve information about the plugins versions installed in Wordpress systems. http://code.google.com/p/plecost/ * __plown 13.ccf998c__ A security scanner for Plone CMS. https://github.com/unweb/plown * __pmcma 1.00__ Automated exploitation of invalid memory writes (being them the consequences of an overflow in a writable section, of a missing format string, integer overflow, variable misuse, or any other type of memory corruption). http://packetstormsecurity.com/files/104724/Post-Memory-Corruption-Memory-Analyzer.00.html * __pnscan 1.11__ A parallel network scanner that can be used to survey TCP network services. http://www.lysator.liu.se/~pen/pnscan/ * __pompem 69.b2569c4__ A python exploit tool finder. https://github.com/rfunix/Pompem * __portspoof 100.70b6bf2__ This program's primary goal is to enhance OS security through a set of new techniques. http://portspoof.org/ * __posttester 0.1__ A jar file that will send POST requests to servers in order to test for the hash collision vulnerability discussed at the Chaos Communication Congress in Berlin. http://packetstormsecurity.com/files/109010/MagicHash-Collision-Testing-Tool.html * __powerfuzzer 1_beta__ Powerfuzzer is a highly automated web fuzzer based on many other Open Source fuzzers available (incl. cfuzzer, fuzzled, fuzzer.pl, jbrofuzz, webscarab, wapiti, Socket Fuzzer). It can detect XSS, Injections (SQL, LDAP, commands, code, XPATH) and others. http://www.powerfuzzer.com * __powersploit 239.dc1a5e5__ A PowerShell Post-Exploitation Framework. https://github.com/mattifestation/PowerSploit * __praeda 37.093d1c0__ An automated data/information harvesting tool designed to gather critical information from various embedded devices. https://github.com/percx/Praeda * __prometheus 175.497b2ce__ A Firewall analyzer written in ruby https://github.com/averagesecurityguy/prometheus * __propecia 2__ A fast class scanner that scans for a specified open port with banner grabbing http://www.redlevel.org * __protos-sip 2__ SIP test suite. https://www.ee.oulu.fi/research/ouspg/PROTOS_Test-Suite_c07-sip * __proxychains-ng 4.8.1__ A hook preloader that allows to redirect TCP traffic of existing dynamically linked programs through one or more SOCKS or HTTP proxies https://github.com/rofl0r/proxychains * __proxycheck 0.1__ This is a simple proxy tool that checks for the HTTP CONNECT method and grabs verbose output from a webserver. http://packetstormsecurity.com/files/61864/proxycheck.pl.txt.html * __proxyp 2013__ Small multithreaded Perl script written to enumerate latency, port numbers, server names, & geolocations of proxy IP addresses. http://sourceforge.net/projects/proxyp/ * __proxyscan 0.3__ A security penetration testing tool to scan for hosts and ports through a Web proxy server. http://packetstormsecurity.com/files/69778/proxyScan.3.tgz.html * __proxytunnel 1.9.0__ a program that connects stdin and stdout to a server somewhere on the network, through a standard HTTPS proxy http://proxytunnel.sourceforge.net * __pscan 1.3__ A limited problem scanner for C source files http://deployingradius.com/pscan/ * __pshitt 21.85cde65__ A lightweight fake SSH server designed to collect authentication data sent by intruders. https://github.com/regit/pshitt * __pstoreview 1.0__ Lists the contents of the Protected Storage. http://www.ntsecurity.nu/toolbox/pstoreview/ * __ptunnel 0.72__ A tool for reliably tunneling TCP connections over ICMP echo request and reply packets http://www.cs.uit.no/~daniels/PingTunnel/#download * __pwd-hash 2.0__ A password hashing tool that use the crypt function to generate the hash of a string given on standard input. http://vladz.devzero.fr/pwd-hash.php * __pwdump 7.1__ Extracts the binary SAM and SYSTEM file from the filesystem and then the hashes. http://www.tarasco.org/security/pwdump_7/index.html * __pwnat 0.3__ A tool that allows any number of clients behind NATs to communicate with a server behind a separate NAT with *no* port forwarding and *no* DMZ setup on any routers in order to directly communicate with each other http://samy.pl/pwnat/ * __pwntools 2.1.3__ The CTF framework used by #Gallopsled in every CTF. https://github.com/Gallopsled/pwntools * __pyew 2.3.0__ A python tool to analyse malware. https://code.google.com/p/pyew/ * __pyfiscan 1015.072ce1e__ Free web-application vulnerability and version scanner. https://github.com/fgeek/pyfiscan * __pyinstaller 2.1__ A program that converts (packages) Python programs into stand-alone executables, under Windows, Linux, Mac OS X, Solaris and AIX. http://www.pyinstaller.org/ * __pyminifakedns 0.1__ Minimal DNS server written in Python; it always replies with a 127.0.0.1 A-record http://code.activestate.com/recipes/491264/ * __pyrasite 2.0__ Code injection and introspection of running Python processes. http://pyrasite.com/ * __pyrit 0.4.0__ WPA/WPA2-PSK attacking with gpu and cluster http://code.google.com/p/pyrit * __pytacle alpha2__ Automates the task of sniffing GSM frames http://packetstormsecurity.com/files/124299/pytacle-alpha2.tar.gz * __pytbull 2.0__ A python based flexible IDS/IPS testing framework shipped with more than 300 tests http://pytbull.sourceforge.net/ * __python-utidylib 0.2__ Python bindings for Tidy HTML parser/cleaner. http://utidylib.berlios.de * __python2-binaryornot 0.3.0__ Ultra-lightweight pure Python package to check if a file is binary or text. https://github.com/audreyr/binaryornot * __python2-yara 3.2.0__ A malware identification and classification tool. https://github.com/plusvic/yara * __quickrecon 0.3.2__ A python script for simple information gathering. It attempts to find subdomain names, perform zone transfers and gathers emails from Google and Bing. http://packetstormsecurity.com/files/104314/QuickRecon.3.2.html radamsa 0.3 General purpose data fuzzer. https://code.google.com/p/ouspg/wiki/Radamsa radare2 0.9.8 Open-source tools to disasm, debug, analyze and manipulate binary files. http://radare.org/ radiography 2 A forensic tool which grabs as much information as possible from a Windows system. http://www.security-projects.com/?RadioGraPhy rainbowcrack 1.2 Password cracker based on the faster time-memory trade-off. With MySQL and Cisco PIX Algorithm patches. http://project-rainbowcrack.com/ rarcrack 0.2 This program uses bruteforce algorithm to find correct password (rar, 7z, zip). http://rarcrack.sourceforge.net/ ratproxy 1.58 A passive web application security assessment tool http://code.google.com/p/ratproxy/ rawr 42.ff1bfa1 Rapid Assessment of Web Resources. A web enumerator. https://bitbucket.org/al14s/rawr/wiki/Home rcracki-mt 0.7.0 A tool to perform rainbow table attacks on password hashes. It is intended for indexed/perfected rainbow tables, mainly generated by the distributed project www.freerainbowtables.com http://rcracki.sourceforge.net/ rdesktop-brute 1.5.0 It connects to windows terminal servers - Bruteforce patch included. http://www.rdesktop.org/ reaver 1.4 Implements a brute force attack against wifi protected setup WPS registrar PINs in order to recover WPA/WPA2 passphrases http://code.google.com/p/reaver-wps rebind 0.3.4 DNS Rebinding Tool http://code.google.com/p/rebind/ recon-ng 885.f42ffbe A full-featured Web Reconnaissance framework written in Python. https://bitbucket.org/LaNMaSteR53/recon-ng recoverjpeg 2.2.2 Recover jpegs from damaged devices. http://www.rfc1149.net/devel/recoverjpeg recstudio 4.0_20130717 Cross platform interactive decompiler http://www.backerstreet.com/rec/rec.htm redfang 2.5 Finds non-discoverable Bluetooth devices by brute-forcing the last six bytes of the devices' Bluetooth addresses and calling read_remote_name(). http://packetstormsecurity.com/files/31864/redfang.2.5.tar.gz.html redirectpoison 1.1 A tool to poison a targeted issuer of SIP INVITE requests with 301 (i.e. Moved Permanently) redirection responses. http://www.hackingexposedvoip.com/ regeorg 26.22fb8a9 The successor to reDuh, pwn a bastion webserver and create SOCKS proxies through the DMZ. Pivot and pwn. https://github.com/sensepost/reGeorg reglookup 1.0.1 Command line utility for reading and querying Windows NT registries http://projects.sentinelchicken.org/reglookup relay-scanner 1.7 An SMTP relay scanner. http://www.cirt.dk replayproxy 1.1 Forensic tool to replay web-based attacks (and also general HTTP traffic) that were captured in a pcap file. https://code.google.com/p/replayproxy/ responder 117.6c7a5dd A LLMNR and NBT-NS poisoner, with built-in HTTP/SMB/MSSQL/FTP/LDAP rogue authentication server supporting NTLMv1/NTLMv2/LMv2, Extended Security NTLMSSP and Basic HTTP authentication. https://github.com/SpiderLabs/Responder/ rfcat 130515 RF ChipCon-based Attack Toolset http://code.google.com/p/rfcat rfdump 1.6 A back-end GPL tool to directly inter-operate with any RFID ISO-Reader to make the contents stored on RFID tags accessible http://www.rfdump.org rfidiot e302bb7 An open source python library for exploring RFID devices. http://rfidiot.org/ rfidtool 0.01 A opensource tool to read / write rfid tags http://www.bindshell.net/tools/rfidtool.html ridenum 39.ebbfaca A null session RID cycle attack for brute forcing domain controllers. https://github.com/trustedsec/ridenum rifiuti2 0.5.1 A rewrite of rifiuti, a great tool from Foundstone folks for analyzing Windows Recycle Bin INFO2 file. https://code.google.com/p/rifiuti2/ rinetd 0.62 internet redirection server http://www.boutell.com/rinetd ripdc 0.2 A script which maps domains related to an given ip address or domainname. http://nullsecurity.net/tools/scanner rkhunter 1.4.2 Checks machines for the presence of rootkits and other unwanted tools. http://rkhunter.sourceforge.net/ rlogin-scanner 0.2 Multithreaded rlogin scanner. Tested on Linux, OpenBSD and Solaris. http://wayreth.eu.org/old_page/ rootbrute 0.1 Local root account bruteforcer. http://www.packetstormsecurity.org/ ropeadope 1.1 A linux log cleaner. http://www.highhacksociety.com/ ropeme 1.0 ROPME is a set of python scripts to generate ROP gadgets and payload. http://www.vnsecurity.net/2010/08/ropeme-rop-exploit-made-easy/ ropgadget 5.3 Lets you search your gadgets on your binaries (ELF format) to facilitate your ROP exploitation. https://github.com/JonathanSalwan/ROPgadget ropper 91.212d5da It can show information about files in different file formats and you can find gadgets to build rop chains for different architectures. For disassembly ropper uses the awesome Capstone Framework. https://github.com/sashs/Ropper rpdscan 2.a71b0f3 Remmina Password Decoder and scanner. https://github.com/freakyclown/RPDscan rrs 1.70 A reverse (connecting) remote shell. Instead of listening for incoming connections it will connect out to a listener (rrs in listen mode). With tty support and more. http://www.cycom.se/dl/rrs rsakeyfind 1.0 A tool to find RSA key in RAM. http://citp.princeton.edu/memory/code/ rsmangler 1.4 rsmangler takes a wordlist and mangle it http://www.randomstorm.com/rsmangler-security-tool.php rtlsdr-scanner 856.a47ba2e A cross platform Python frequency scanning GUI for the OsmoSDR rtl-sdr library. https://github.com/EarToEarOak/RTLSDR-Scanner rtp-flood 1.0 RTP flooder http://www.hackingexposedvoip.com/ rtpbreak 1.3a Detects, reconstructs and analyzes any RTP session http://xenion.antifork.org/rtpbreak/ rubilyn 0.0.1 64bit Mac OS-X kernel rootkit that uses no hardcoded address to hook the BSD subsystem in all OS-X Lion & below. It uses a combination of syscall hooking and DKOM to hide activity on a host. http://nullsecurity.net/tools/backdoor.html ruby-msgpack 0.5.8 MessagePack, a binary-based efficient data interchange format. http://msgpack.org/ ruby-ronin 1.5.0 A Ruby platform for exploit development and security research. http://ronin-ruby.github.io/ ruby-ronin-support 0.5.1 A support library for Ronin. http://ronin-ruby.github.io/ ruby-uri-query_params 0.7.0 Access the query parameters of a URI, just like in PHP. http://github.com/postmodern/uri-query_params rww-attack 0.9.2 The Remote Web Workplace Attack tool will perform a dictionary attack against a live Microsoft Windows Small Business Server's 'Remote Web Workplace' portal. It currently supports both SBS 2003 and SBS 2008 and includes features to avoid account lock out. http://packetstormsecurity.com/files/79021/Remote-Web-Workplace-Attack-Tool.html safecopy 1.7 A disk data recovery tool to extract data from damaged media http://safecopy.sourceforge.net/ sakis3g 0.2.0e An all-in-one script for connecting with 3G http://www.sakis3g.org/ sambascan 0.5.0 Allows you to search an entire network or a number of hosts for SMB shares. It will also list the contents of all public shares that it finds. http://sourceforge.net/projects/sambascan2/ samdump2 3.0.0 Dump password hashes from a Windows NT/2k/XP installation http://sourceforge.net/projects/ophcrack/files/samdump2/ samydeluxe 2.2ed1bac Automatic samdump creation script. http://github.com/jensp/samydeluxe sandy 6.531ab16 An open-source Samsung phone encryption assessment framework https://github.com/donctl/sandy sasm 3.1.0 A simple crossplatform IDE for NASM, MASM, GAS and FASM assembly languages. https://github.com/Dman95/SASM sb0x 19.04f40fe A simple and Lightweight framework for Penetration testing. https://github.com/levi0x0/sb0x-project sbd 1.36 Netcat-clone, portable, offers strong encryption - features AES-CBC + HMAC-SHA1 encryption, program execution (-e), choosing source port, continuous reconnection with delay + more http://www2.packetstormsecurity.org/cgi-bin/search/search.cgi?searchvalue=sbd scalpel 2.0 A frugal, high performance file carver http://www.digitalforensicssolutions.com/Scalpel/ scanmem 0.13 A utility used to locate the address of a variable in an executing process. http://code.google.com/p/scanmem/ scanssh 2.1 Fast SSH server and open proxy scanner. http://www.monkey.org/~provos/scanssh/ scapy 2.2.0 A powerful interactive packet manipulation program written in Python http://www.secdev.org/projects/scapy/ schnappi-dhcp 0.1 schnappi can fuck network with no DHCP http://www.emanuelegentili.eu/ scout2 196.7cc58b4 Security auditing tool for AWS environments. http://isecpartners.github.io/Scout2/ scrapy 4419.c485a05 A fast high-level scraping and web crawling framework. http://www.scrapy.org/ scrounge-ntfs 0.9 Data recovery program for NTFS file systems http://memberwebs.com/stef/software/scrounge/ sctpscan 1.0 A network scanner for discovery and security http://www.p1sec.com/ seat 0.3 Next generation information digging application geared toward the needs of security professionals. It uses information stored in search engine databases, cache repositories, and other public resources to scan web sites for potential vulnerabilities. http://thesprawl.org/projects/search-engine-assessment-tool/ secscan 1.5 Web Apps Scanner and Much more utilities. http://code.google.com/p/secscan-py/ secure-delete 3.1 Secure file, disk, swap, memory erasure utilities. http://www.thc.org/ sees 67.cd741aa Increase the success rate of phishing attacks by sending emails to company users as if they are coming from the very same company's domain. https://github.com/galkan/sees/ sergio-proxy 0.2.1 A multi-threaded transparent HTTP proxy for manipulating web traffic https://github.com/darkoperator/dnsrecon sessionlist 1.0 Sniffer that intents to sniff HTTP packets and attempts to reconstruct interesting authentication data from websites that do not employ proper secure cookie auth. http://www.0xrage.com/ set 6.1.2 Social-engineer toolkit. Aimed at penetration testing around Social-Engineering https://www.trustedsec.com/downloads/social-engineer-toolkit sfuzz 0.7.0 A simple fuzzer. http://aconole.brad-x.com/programs/sfuzz.html shellcodecs 0.1 A collection of shellcode, loaders, sources, and generators provided with documentation designed to ease the exploitation and shellcode programming process. http://www.blackhatlibrary.net/Shellcodecs shellme 3.8c7919d Because sometimes you just need shellcode and opcodes quickly. This essentially just wraps some nasm/objdump calls into a neat script. https://github.com/hatRiot/shellme shellnoob 2.1 A toolkit that eases the writing and debugging of shellcode https://github.com/reyammer/shellnoob shortfuzzy 0.1 A web fuzzing script written in perl. http://packetstormsecurity.com/files/104872/Short-Fuzzy-Rat-Scanner.html sidguesser 1.0.5 Guesses sids/instances against an Oracle database according to a predefined dictionary file. http://www.cqure.net/wp/tools/database/sidguesser/ siege 3.0.8 An http regression testing and benchmarking utility http://www.joedog.org/JoeDog/Siege silk 3.9.0 A collection of traffic analysis tools developed by the CERT NetSA to facilitate security analysis of large networks. https://tools.netsa.cert.org/silk/ simple-ducky 1.1.1 A payload generator. https://code.google.com/p/simple-ducky-payload-generator simple-lan-scan 1.0 A simple python script that leverages scapy for discovering live hosts on a network. http://packetstormsecurity.com/files/97353/Simple-LAN-Scanner.0.html sinfp 1.22 A full operating system stack fingerprinting suite. http://www.networecon.com/tools/sinfp/ siparmyknife 11232011 A small command line tool for developers and administrators of Session Initiation Protocol (SIP) applications. http://packetstormsecurity.com/files/107301/sipArmyKnife_11232011.pl.txt sipcrack 0.2 A SIP protocol login cracker. http://www.remote-exploit.org/codes_sipcrack.html sipp 3.3 A free Open Source test tool / traffic generator for the SIP protocol. http://sipp.sourceforge.net/ sipsak 0.9.6 A small command line tool for developers and administrators of Session Initiation Protocol (SIP) applications. http://sipsak.org sipscan 0.1 A sip scanner. http://www.hackingvoip.com/sec_tools.html sipshock 6.1d636ab A scanner for SIP proxies vulnerable to Shellshock. https://github.com/zaf/sipshock sipvicious 0.2.8 Tools for auditing SIP devices http://blog.sipvicious.org skipfish 2.10b A fully automated, active web application security reconnaissance tool http://code.google.com/p/skipfish/ skyjack 7.5f7a25e Takes over Parrot drones, deauthenticating their true owner and taking over control, turning them into zombie drones under your own control. https://github.com/samyk/skyjack skype-dump 0.1 This is a tool that demonstrates dumping MD5 password hashes from the configuration file in Skype. http://packetstormsecurity.com/files/119155/Skype-Hash-Dumper.0.html skypefreak 30.14a81cb A Cross Platform Forensic Framework for Skype. http://osandamalith.github.io/SkypeFreak/ sleuthkit 4.1.3 File system and media management forensic analysis tools http://www.sleuthkit.org/sleuthkit slowhttptest 1.5 A highly configurable tool that simulates application layer denial of service attacks http://code.google.com/p/slowhttptest slowloris 0.7 A tool which is written in perl to test http-server vulnerabilites for connection exhaustion denial of service (DoS) attacks so you can enhance the security of your webserver. http://ha.ckers.org/slowloris/ smali 1.4.1 An assembler/disassembler for Android's dex format http://code.google.com/p/smali/ smartphone-pentest-framework 95.20918b2 Repository for the Smartphone Pentest Framework (SPF). https://github.com/georgiaw/Smartphone-Pentest-Framework smbbf 0.9.1 SMB password bruteforcer. http://packetstormsecurity.com/files/25381/smbbf.9.1.tar.gz.html smbexec 148.7827616 A rapid psexec style attack with samba tools. https://github.com/pentestgeek/smbexec smbrelay 3 SMB / HTTP to SMB replay attack toolkit. http://www.tarasco.org/security/smbrelay/ smtp-fuzz 1.0 Simple smtp fuzzer none smtp-user-enum 1.2 Username guessing tool primarily for use against the default Solaris SMTP service. Can use either EXPN, VRFY or RCPT TO. http://pentestmonkey.net/tools/user-enumeration/smtp-user-enum smtp-vrfy 1.0 An SMTP Protocol Hacker. smtpmap 0.8.234_BETA Tool to identify the running smtp software on a given host. http://www.projectiwear.org/~plasmahh/software.html smtpscan 0.5 An SMTP scanner http://packetstormsecurity.com/files/31102/smtpscan.5.tar.gz.html sn00p 0.8 A modular tool written in bourne shell and designed to chain and automate security tools and tests. http://www.nullsecurity.net/tools/automation.html sniffjoke 0.4.1 Injects packets in the transmission flow that are able to seriously disturb passive analysis like sniffing, interception and low level information theft. http://www.delirandom.net/sniffjoke/ snmp-fuzzer 0.1.1 SNMP fuzzer uses Protos test cases with an entirely new engine written in Perl. http://www.arhont.com/en/category/resources/tools-utilities/ snmpattack 1.8 SNMP scanner and attacking tool. http://www.c0decafe.de/ snmpcheck 1.8 A free open source utility to get information via SNMP protocols. http://www.nothink.org/perl/snmpcheck/ snmpenum 1.7 snmp enumerator http://www.filip.waeytens.easynet.be/ snmpscan 0.1 A free, multi-processes SNMP scanner http://www.nothink.org/perl/snmpscan/index.php snoopy-ng 93.e305420 A distributed, sensor, data collection, interception, analysis, and visualization framework. https://github.com/sensepost/snoopy-ng snort 2.9.6.1 A lightweight network intrusion detection system. http://www.snort.org snow 20130616 Steganography program for concealing messages in text files. http://darkside.com.au/snow/index.html snscan 1.05 A Windows based SNMP detection utility that can quickly and accurately identify SNMP enabled devices on a network. http://www.mcafee.com/uk/downloads/free-tools/snscan.aspx socat 1.7.2.4 Multipurpose relay http://www.dest-unreach.org/socat/ soot 2.5.0 A Java Bytecode Analysis and Transformation Framework. http://www.sable.mcgill.ca/soot spade 114 A general-purpose Internet utility package, with some extra features to help in tracing the source of spam and other forms of Internet harassment. http://www.hoobie.net/brutus/ sparty 0.1 An open source tool written in python to audit web applications using sharepoint and frontpage architecture. http://sparty.secniche.org/ spectools 2010_04_R1 Spectrum-Tools is a set of utilities for using the Wi-Spy USB spectrum analyzer hardware. Stable version. http://www.kismetwireless.net/spectools/ speedpwn 8.3dd2793 An active WPA/2 Bruteforcer, original created to prove weak standard key generation in different ISP labeled routers without a client is connected. https://gitorious.org/speedpwn/ spiderfoot 2.1.5 The Open Source Footprinting Tool http://spiderfoot.net/ spiderpig-pdffuzzer 0.1 A javascript pdf fuzzer https://code.google.com/p/spiderpig-pdffuzzer/ spiga 7240.3a804ac Configurable web resource scanner https://github.com/getdual/scripts-n-tools/blob/master/spiga.py spike 2.9 IMMUNITYsec's fuzzer creation kit in C http://www.immunitysec.com/resources-freesoftware.shtml spike-proxy 148 A Proxy for detecting vulnerabilities in web applications http://www.immunitysec.com/resources-freesoftware.shtml spiped 1.4.1 A utility for creating symmetrically encrypted and authenticated pipes between socket addresses. https://www.tarsnap.com/spiped.html spipscan 8340.db8ef4a SPIP (CMS) scanner for penetration testing purpose written in Python. https://github.com/PaulSec/SPIPScan splint 3.1.2 A tool for statically checking C programs for security vulnerabilities and coding mistakes http://www.splint.org/ sploitctl 1.1 Fetch, install and search exploit archives from exploit sites like exploit-db and packetstorm. https://github.com/BlackArch/sploitctl sploitego 153.d9568dc Maltego Penetration Testing Transforms. https://github.com/allfro/sploitego spooftooph 0.5.2 Designed to automate spoofing or cloning Bluetooth device Name, Class, and Address. Cloning this information effectively allows Bluetooth device to hide in plain sight http://www.hackfromacave.com/projects/spooftooph.html sps 4.2 A Linux packet crafting tool. Supports IPv4, IPv6 including extension headers, and tunneling IPv6 over IPv4. https://sites.google.com/site/simplepacketsender/ sqid 0.3 A SQL injection digger. http://sqid.rubyforge.org/ sqlbrute 1.0 Brute forces data out of databases using blind SQL injection. http://www.justinclarke.com/archives/2006/03/sqlbrute.html sqlmap 6445.20c272b An automatic SQL injection tool developed in Python. http://sqlmap.sourceforge.net sqlninja 0.2.6_r1 A tool targeted to exploit SQL Injection vulnerabilities on a web application that uses Microsoft SQL Server as its back-end http://sqlninja.sourceforge.net/ sqlpat 1.0.1 This tool should be used to audit the strength of Microsoft SQL Server passwords offline. http://www.cqure.net/wp/sqlpat/ sqlping 4 SQL Server scanning tool that also checks for weak passwords using wordlists. http://www.sqlsecurity.com/downloads sqlsus 0.7.2 An open source MySQL injection and takeover tool, written in perl http://sqlsus.sourceforge.net/ ssh-privkey-crack 0.3 A SSH private key cracker https://code.google.com/p/lusas/ sshatter 1.2 Password bruteforcer for SSH http://www.nth-dimension.org.uk/downloads.php?id=34 sshscan 7401.3bfd4ae A horizontal SSH scanner that scans large swaths of IPv4 space for a single SSH user and pass. https://github.com/getdual/scripts-n-tools/blob/master/sshscan.py sshtrix 0.0.2 A very fast multithreaded SSH login cracker http://nullsecurity.net/tools/cracker.html sshuttle 198.9ce2fa0 Transparent proxy server that works as a poor man's VPN. Forwards all TCP packets over ssh (and even DNS requests when using --dns option). Doesn't require admin privileges on the server side. https://github.com/apenwarr/sshuttle ssl-hostname-resolver 1 CN (Common Name) grabber on X.509 Certificates over HTTPS. http://packetstormsecurity.com/files/120634/Common-Name-Grabber-Script.html ssl-phuck3r 2.0 All in one script for Man-In-The-Middle attacks. https://github.com/zombiesam/ssl_phuck3r sslcat 1.0 SSLCat is a simple Unix utility that reads and writes data across an SSL enable network connection. http://www.bindshell.net/tools/sslcat sslcaudit 522.5b6be3e Utility to perform security audits of SSL/TLS clients. https://github.com/grwl/sslcaudit ssldump 0.9b3 an SSLv3/TLS network protocol analyzer http://www.rtfm.com/ssldump/ sslh 1.16 SSL/SSH/OpenVPN/XMPP/tinc port multiplexer http://www.rutschle.net/tech/sslh.shtml sslmap 0.2.0 A lightweight TLS/SSL cipher suite scanner. http://thesprawl.org/projects/latest/ sslnuke 5.c5faeaa Transparent proxy that decrypts SSL traffic and prints out IRC messages. https://github.com/jtripper/sslnuke sslscan 239.1328b49 Tests SSL/TLS enabled services to discover supported cipher suites. https://github.com/DinoTools/sslscan sslsniff 0.8 A tool to MITM all SSL connections on a LAN and dynamically generate certs for the domains that are being accessed on the fly http://www.thoughtcrime.org/software/sslsniff/ sslsplit 0.4.9 A tool for man-in-the-middle attacks against SSL/TLS encrypted network connections. http://www.roe.ch/SSLsplit sslstrip 0.9 Transparently hijack http traffic on a network, watch for https links and redirects, then map those links. http://www.thoughtcrime.org/software/sslstrip sslyze 0.10 Python tool for analyzing the configuration of SSL servers and for identifying misconfigurations. https://github.com/nabla-c0d3/sslyze/ stackflow 2.2af525d Universal stack-based buffer overfow exploitation tool. https://github.com/d4rkcat/stackflow starttls-mitm 7.b257756 A mitm proxy that will transparently proxy and dump both plaintext and TLS traffic. https://github.com/ipopov/starttls-mitm statsprocessor 0.10 A high-performance word-generator based on per-position Markov-attack. http://hashcat.net/wiki/doku.php?id=statsprocessor steghide 0.5.1 Embeds a message in a file by replacing some of the least significant bits http://steghide.sourceforge.net stompy 0.0.4 an advanced utility to test the quality of WWW session identifiers and other tokens that are meant to be unpredictable. http://lcamtuf.coredump.cx/ storm-ring 0.1 This simple tool is useful to test a PABX with "allow guest" parameter set to "yes" (in this scenario an anonymous caller could place a call). http://packetstormsecurity.com/files/115852/Storm-Ringing-PABX-Test-Tool.html stunnel 5.06 A program that allows you to encrypt arbitrary TCP connections inside SSL http://www.stunnel.org subdomainer 1.2 A tool designed for obtaining subdomain names from public sources. http://www.edge-security.com/subdomainer.php subterfuge 5.0 Automated Man-in-the-Middle Attack Framework http://kinozoa.com sucrack 1.2.3 A multi-threaded Linux/UNIX tool for brute-force cracking local user accounts via su http://labs.portcullis.co.uk/application/sucrack sulley 1.0.cb5e62c A pure-python fully automated and unattended fuzzing framework. https://github.com/OpenRCE/sulley/ superscan 4 Powerful TCP port scanner, pinger, resolver. http://www.foundstone.com/us/resources/proddesc/superscan.htm suricata 2.0.3 An Open Source Next Generation Intrusion Detection and Prevention Engine. http://openinfosecfoundation.org/index.php/download-suricata svn-extractor 28.3af00fb A simple script to extract all web resources by means of .SVN folder exposed over network. https://github.com/anantshri/svn-extractor swaks 20130209.0 Swiss Army Knife SMTP; Command line SMTP testing, including TLS and AUTH http://jetmore.org/john/code/swaks/ swfintruder 0.9.1 First tool for testing security in Flash movies. A runtime analyzer for SWF external movies. It helps to find flaws in Flash. http://code.google.com/p/swfintruder/ synflood 0.1 A very simply script to illustrate DoS SYN Flooding attack. http://thesprawl.org/projects/syn-flooder/ synner 1.1 A custom eth->ip->tcp packet generator (spoofer) for testing firewalls and dos attacks. http://packetstormsecurity.com/files/69802/synner.c.html synscan 5.02 fast asynchronous half-open TCP portscanner http://www.digit-labs.org/files/tools/synscan/ sysdig 1314.45921f5 Open source system-level exploration and troubleshooting tool. http://www.sysdig.org/ sysinternals-suite 1.2 Sysinternals tools suite. http://sysinternals.com/ t50 5.4.1 Experimental Multi-protocol Packet Injector Tool http://t50.sourceforge.net/ taof 0.3.2 Taof is a GUI cross-platform Python generic network protocol fuzzer. http://taof.sf.net tbear 1.5 Transient Bluetooth Environment Auditor includes an ncurses-based Bluetooth scanner (a bit similar to kismet), a Bluetooth DoS tool, and a Bluetooth hidden device locator. http://freshmeat.net/projects/t-bear tcgetkey 0.1 A set of tools that deal with acquiring physical memory dumps via FireWire and then scan the memory dump to locate TrueCrypt keys and finally decrypt the encrypted TrueCrypt container using the keys. http://packetstormsecurity.com/files/119146/tcgetkey.1.html tcpcontrol-fuzzer 0.1 2^6 TCP control bit fuzzer (no ECN or CWR). https://www.ee.oulu.fi/research/ouspg/tcpcontrol-fuzzer tcpdump 4.6.2 A tool for network monitoring and data acquisition http://www.tcpdump.org tcpextract 1.1 Extracts files from captured TCP sessions. Support live streams and pcap files. https://pypi.python.org/pypi/tcpextract/1.1 tcpflow 1.4.4 Captures data transmitted as part of TCP connections then stores the data conveniently http://afflib.org/software/tcpflow tcpick 0.2.1 TCP stream sniffer and connection tracker http://tcpick.sourceforge.net/ tcpjunk 2.9.03 A general tcp protocols testing and hacking utility http://code.google.com/p/tcpjunk tcpreplay 4.0.5 Gives the ability to replay previously captured traffic in a libpcap format http://tcpreplay.appneta.com tcptraceroute 1.5beta7 A traceroute implementation using TCP packets. http://michael.toren.net/code/tcptraceroute/ tcpwatch 1.3.1 A utility written in Python that lets you monitor forwarded TCP connections or HTTP proxy connections. http://hathawaymix.org/Software/TCPWatch tcpxtract 1.0.1 A tool for extracting files from network traffic. http://tcpxtract.sourceforge.net teardown 1.0 Command line tool to send a BYE request to tear down a call. http://www.hackingexposedvoip.com/ tekdefense-automater 52.6d0bd5a IP URL and MD5 OSINT Analysis https://github.com/1aN0rmus/TekDefense-Automater termineter 0.1.0 Smart meter testing framework https://code.google.com/p/termineter/ tftp-bruteforce 0.1 TFTP-bruteforcer is a fast TFTP filename bruteforcer written in perl. http://www.hackingexposedcisco.com/ tftp-fuzz 1337 Master TFTP fuzzing script as part of the ftools series of fuzzers http://nullsecurity.net/tools/fuzzer.html tftp-proxy 0.1 This tool accepts connection on tftp and reloads requested content from an upstream tftp server. Meanwhile modifications to the content can be done by pluggable modules. So this one's nice if your mitm with some embedded devices. http://www.c0decafe.de/ thc-ipv6 2.5 A complete tool set to attack the inherent protocol weaknesses of IPv6 and ICMP6, and includes an easy to use packet factory library. http://thc.org/thc-ipv6/ thc-keyfinder 1.0 Finds crypto keys, encrypted data and compressed data in files by analyzing the entropy of parts of the file. https://www.thc.org/releases.php thc-pptp-bruter 0.1.4 A brute force program that works against pptp vpn endpoints (tcp port 1723). http://www.thc.org thc-smartbrute 1.0 This tool finds undocumented and secret commands implemented in a smartcard. https://www.thc.org/thc-smartbrute/ thc-ssl-dos 1.4 A tool to verify the performance of SSL. To be used in your authorized and legitimate area ONLY. You need to accept this to make use of it, no use for bad intentions, you have been warned! http://www.thc.org/thc-ssl-dos/ theharvester 2.2a Python tool for gathering e-mail accounts and subdomain names from different public sources (search engines, pgp key servers) http://www.edge-security.com/theHarvester.php themole 0.3 Automatic SQL injection exploitation tool. http://sourceforge.net/projects/themole/ tiger 3.2.3 A security scanner, that checks computer for known problems. Can also use tripwire, aide and chkrootkit. http://www.nongnu.org/tiger/ tilt 90.2bc2ef2 An easy and simple tool implemented in Python for ip reconnaissance, with reverse ip lookup. https://github.com/AeonDave/tilt timegen 0.4 This program generates a *.wav file to "send" an own time signal to DCF77 compatible devices. http://bastianborn.de/radio-clock-hack/ tinc 1.0.24 VPN (Virtual Private Network) daemon http://www.tinc-vpn.org/ tinyproxy 1.8.3 A light-weight HTTP proxy daemon for POSIX operating systems. https://banu.com/tinyproxy/ tlsenum 75.6618285 A command line tool to enumerate TLS cipher-suites supported by a server. https://github.com/Ayrx/tlsenum tlspretense 0.6.2 SSL/TLS client testing framework https://github.com/iSECPartners/tlspretense tlssled 1.3 A Linux shell script whose purpose is to evaluate the security of a target SSL/TLS (HTTPS) web server implementation. http://blog.taddong.com/2011/05/tlssled-v10.html tnscmd 1.3 a lame tool to prod the oracle tnslsnr process (1521/tcp) http://www.jammed.com/~jwa/hacks/security/tnscmd/ topera 19.3e230fd An IPv6 security analysis toolkit, with the particularity that their attacks can't be detected by Snort. https://github.com/toperaproject/topera tor 0.2.5.10 Anonymizing overlay network. http://www.torproject.org/ tor-autocircuit 0.2 Tor Autocircuit was developed to give users a finer control over Tor circuit creation. The tool exposes the functionality of TorCtl library which allows its users to control circuit length, speed, geolocation, and other parameters. http://www.thesprawl.org/projects/tor-autocircuit/ tor-browser-en 4.0.2 Tor Browser Bundle: Anonymous browsing using firefox and tor https://www.torproject.org/projects/torbrowser.html.en torshammer 1.0 A slow POST Denial of Service testing tool written in Python. http://sourceforge.net/projects/torshammer/ torsocks 2.0.0 Wrapper to safely torify applications http://code.google.com/p/torsocks tpcat latest TPCAT is based upon pcapdiff by the EFF. TPCAT will analyze two packet captures (taken on each side of the firewall as an example) and report any packets that were seen on the source capture but didn’t make it to the dest. http://sourceforge.net/projects/tpcat/ traceroute 2.0.21 Tracks the route taken by packets over an IP network http://traceroute.sourceforge.net/ trid 2.11 An utility designed to identify file types from their binary signatures http://mark0.net/soft-trid-e.html trinity 3728.985a087 A Linux System call fuzzer. http://codemonkey.org.uk/projects/trinity/ trixd00r 0.0.1 An advanced and invisible userland backdoor based on TCP/IP for UNIX systems http://nullsecurity.net/tools/backdoor.html truecrack 35 Password cracking for truecrypt(c) volumes. http://code.google.com/p/truecrack/ truecrypt 7.1a Free open-source cross-platform disk encryption software http://www.truecrypt.org/ tsh 0.6 An open-source UNIX backdoor that compiles on all variants, has full pty support, and uses strong crypto for communication. http://packetstormsecurity.com/search/?q=tsh tsh-sctp 2.850a2da An open-source UNIX backdoor. https://github.com/infodox/tsh-sctp tuxcut 5.0 Netcut-like program for Linux written in PyQt http://bitbucket.org/a_atalla/tuxcut/ twofi 2.0 Twitter Words of Interest. http://www.digininja.org/projects/twofi.php u3-pwn 2.0 A tool designed to automate injecting executables to Sandisk smart usb devices with default U3 software install http://www.nullsecurity.net/tools/backdoor.html *__uatester 1.06__ User Agent String Tester http://code.google.com/p/ua-tester/ *__ubertooth 2012.10.R1__ A 2.4 GHz wireless development board suitable for Bluetooth experimentation. Open source hardware and software. Tools only http://sourceforge.net/projects/ubertooth/ *__ubitack 0.3__ Tool, which automates some of the tasks you might need on a (wireless) penetration test or while you are on the go. https://code.google.com/p/ubitack/ *__udis86 1.7.2__ A minimalistic disassembler library http://udis86.sourceforge.net/ *__udptunnel 19__ Tunnels TCP over UDP packets. http://code.google.com/p/udptunnel/ *__uefi-firmware-parser 103.9d4d220__ Parse BIOS/Intel ME/UEFI firmware related structures: Volumes, FileSystems, Files, etc https://github.com/theopolis/uefi-firmware-parser *__ufo-wardriving 4__ Allows you to test the security of wireless networks by detecting their passwords based on the router model http://www.ufo-wardriving.com/ *__ufonet 9.5484a90__ A tool designed to launch DDoS attacks against a target, using 'Open Redirect' vectors on third party web applications, like botnet. https://github.com/epsylon/ufonet *__umap 25.3ad8121__ The USB host security assessment tool. https://github.com/nccgroup/umap *__umit 1.0__ A powerful nmap frontend. http://www.umitproject.org/ *__unhide 20130526__ A forensic tool to find processes hidden by rootkits, LKMs or by other techniques. http://sourceforge.net/projects/unhide/ *__unicorn 9.a18cb5d__ A simple tool for using a PowerShell downgrade attack and inject shellcode straight into memory. https://github.com/trustedsec/unicorn *__unicornscan 0.4.7__ A new information gathering and correlation engine. http://www.unicornscan.org/ *__uniofuzz 1337__ The universal fuzzing tool for browsers, web services, files, programs and network services/ports http://nullsecurity.net/tools/fuzzer.html *__uniscan 6.2__ A simple Remote File Include, Local File Include and Remote Command Execution vulnerability scanner. http://sourceforge.net/projects/uniscan/ *__unix-privesc-check 1.4__ Tries to find misconfigurations that could allow local unprivilged users to escalate privileges to other users or to access local apps (e.g. databases) http://pentestmonkey.net/tools/audit/unix-privesc-check *__unsecure 1.2__ Bruteforces network login masks. http://www.sniperx.net/ *__upnpscan 0.4__ Scans the LAN or a given address range for UPnP capable devices. http://www.cqure.net/wp/upnpscan/ *__upx 3.91__ Ultimate executable compressor. http://upx.sourceforge.net/ *__urlcrazy 0.5__ Generate and test domain typos and variations to detect and perform typo squatting, URL hijacking, phishing, and corporate espionage. http://www.morningstarsecurity.com/research/urlcrazy *__urldigger 02c__ A python tool to extract URL addresses from different HOT sources and/or detect SPAM and malicious code https://code.google.com/p/urldigger/ *__username-anarchy 0.2__ Tools for generating usernames when penetration testing http://www.morningstarsecurity.com/research/username-anarchy *__usernamer 7.813139d__ Pentest Tool to generate usernames/logins based on supplied names. https://github.com/jseidl/usernamer *__uw-loveimap 0.1__ Multi threaded imap bounce scanner. http://uberwall.org/bin/download/45/UWloveimap.tgz *__uw-offish 0.1__ Clear-text protocol simulator. http://uberwall.org/bin/download/42/UW_offish.1.tar.gz *__uw-udpscan 0.1__ Multi threaded udp scanner. http://uberwall.org/bin/download/44/UWudpscan.tar.gz *__uw-zone 0.1__ Multi threaded, randomized IP zoner. http://uberwall.org/bin/download/43/UWzone.tgz *__v3n0m 77.cdaf14e__ Popular linux version of Balthazar/NovaCygni's 'v3n0m' scanner. Searches 18k+ dorks over 13 search engines. https://github.com/v3n0m-Scanner/V3n0M-Scanner * __valgrind 3.10.1__ A tool to help find memory-management problems in programs http://valgrind.org/ * __vanguard 0.1__ A comprehensive web penetration testing tool written in Perl thatidentifies vulnerabilities in web applications. http://packetstormsecurity.com/files/110603/Vanguard-Pentesting-Scanner.html * __vbrute 1.11dda8b__ Virtual hosts brute forcer. https://github.com/nccgroup/vbrute * __vega 1.0__ An open source platform to test the security of web applications https://github.com/subgraph/Vega/wiki * __veil 276.f6dc4ff__ A tool designed to generate metasploit payloads that bypass common anti-virus solutions. https://github.com/veil-evasion/Veil * __vfeed 36.a0fdf06__ Open Source Cross Linked and Aggregated Local Vulnerability Database main repository. http://www.toolswatch.org/vfeed * __vidalia 0.2.21__ Controller GUI for Tor https://www.torproject.org/vidalia * __videosnarf 0.63__ A new security assessment tool for pcap analysis http://ucsniff.sourceforge.net/videosnarf.html * __vinetto 0.07beta__ A forensics tool to examine Thumbs.db files http://vinetto.sourceforge.net * __viper 501.5f6a19a__ A Binary analysis framework. https://github.com/botherder/viper * __viproy-voipkit 2.0__ VoIP Pen-Test Kit for Metasploit Framework http://viproy.com/ * __vivisect 20140803__ A Python based static analysis and reverse engineering framework, Vdb is a Python based research/reversing focused debugger and programatic debugging API by invisigoth of kenshoto http://visi.kenshoto.com/ * __vnak 1.cf0fda7__ Aim is to be the one tool a user needs to attack multiple VoIP protocols. https://www.isecpartners.com/vnak.html * __vnc-bypauth 0.0.1__ Multi-threaded bypass authentication scanner for VNC servers <= 4.1.1. http://pentester.fr/resources/tools/techno/VNC/VNC_bypauth/ * __vncrack 1.21__ What it looks like: crack VNC. http://phenoelit-us.org/vncrack * __voiper 0.07__ A VoIP security testing toolkit incorporating several VoIP fuzzers and auxilliary tools to assist the auditor. http://voiper.sourceforge.net/ * __voiphopper 2.04__ A security validation tool that tests to see if a PC can mimic the behavior of an IP Phone. It rapidly automates a VLAN Hop into the Voice VLAN. http://voiphopper.sourceforge.net/ * __voipong 2.0__ A utility which detects all Voice Over IP calls on a pipeline, and for those which are G711 encoded, dumps actual conversation to seperate wave files. http://www.enderunix.org/voipong/ * __volatility 2.4.1__ A memory forensics toolkit. https://www.volatilesystems.com/default/volatility * __vstt 0.5.0__ VSTT is a multi-protocol tunneling tool. It accepts input by TCP stream sockets and FIFOs, and can send data via TCP, POP3, and ICMP tunneling. http://www.wendzel.de/dr.org/files/Projects/vstt/ * __vulscan 2.0__ A module which enhances nmap to a vulnerability scanner http://www.computec.ch/projekte/vulscan/ * __w3af 1.6__ Web Application Attack and Audit Framework. http://w3af.sourceforge.net/ * __waffit 30__ A set of security tools to identify and fingerprint Web Application Firewall/WAF products protecting a website http://code.google.com/p/waffit/ * __wafp 0.01_26c3__ An easy to use Web Application Finger Printing tool written in ruby using sqlite3 databases for storing the fingerprints. http://packetstormsecurity.com/files/84468/Web-Application-Finger-Printer.01-26c3.html * __wapiti 2.3.0__ A vulnerability scanner for web applications. It currently search vulnerabilities like XSS, SQL and XPath injections, file inclusions, command execution, LDAP injections, CRLF injections... http://wapiti.sourceforge.net/ * __wavemon 0.7.6__ Ncurses-based monitoring application for wireless network devices http://eden-feed.erg.abdn.ac.uk/wavemon/ * __web-soul 2__ A plugin based scanner for attacking and data mining web sites written in Perl. http://packetstormsecurity.com/files/122064/Web-Soul-Scanner.html * __webacoo 0.2.3__ Web Backdoor Cookie Script-Kit. https://bechtsoudis.com/webacoo/ * __webenum 0.1__ Tool to enumerate http responses using dynamically generated queries and more. Useful for penetration tests against web servers. http://code.google.com/p/webenum/ * __webhandler 0.8.5__ A handler for PHP system functions & also an alternative 'netcat' handler. https://github.com/lnxg33k/webhandler * __webpwn3r 35.3fb27bb__ A python based Web Applications Security Scanner. https://github.com/zigoo0/webpwn3r * __webrute 3.3__ Web server directory brute forcer. https://github.com/BlackArch/webrute * __webscarab 20120422.001828__ Framework for analysing applications that communicate using the HTTP and HTTPS protocols http://www.owasp.org/index.php/Category:OWASP_WebScarab_Project * __webshag 1.10__ A multi-threaded, multi-platform web server audit tool. http://www.scrt.ch/en/attack/downloads/webshag * __webshells 6.690ebd9__ Web Backdoors. https://github.com/BlackArch/webshells * __webslayer 5__ A tool designed for brute forcing Web Applications https://code.google.com/p/webslayer/ * __websockify__ 0.6.0 WebSocket to TCP proxy/bridge. http://github.com/kanaka/websockify * __webspa 0.7__ A web knocking tool, sending a single HTTP/S to run O/S commands. http://sourceforge.net/projects/webspa/ * __websploit 3.0.0__ An Open Source Project For, Social Engineering Works, Scan, Crawler & Analysis Web, Automatic Exploiter, Support Network Attacks http://code.google.com/p/websploit/ * __weevely 1.1__ Stealth tiny web shell http://epinna.github.io/Weevely/ * __wepbuster 1.0_beta_0.7__ script for automating aircrack-ng http://code.google.com/p/wepbuster/ * __wfuzz 24.1c6ecd8__ Utility to bruteforce web applications to find their not linked resources. https://github.com/xmendez/wfuzz * __whatweb 0.4.7__ Next generation web scanner that identifies what websites are running. http://www.morningstarsecurity.com/research/whatweb * __wi-feye 1.0__ An automated wireless penetration testing tool written in python, its designed to simplify common attacks that can be performed on wifi networks so that they can be executed quickly and easily. http://wi-feye.za1d.com/download.php * __wifi-honey 1.0__ A management tool for wifi honeypots http://www.digininja.org/projects/wifi_honey.php * __wifi-monitor 0.r22.71340a3__ Prints the IPs on your local network that're sending the most packets https://github.com/DanMcInerney/wifi-monitor * __wificurse 0.3.9__ WiFi jamming tool. https://github.com/oblique/wificurse * __wifijammer 43.4a0fe56__ A python script to continuosly jam all wifi clients within range. https://github.com/DanMcInerney/wifijammer * __wifiphisher 17.09cf393__ Fast automated phishing attacks against WPA networks. https://github.com/sophron/wifiphisher * __wifitap 2b16088__ WiFi injection tool through tun/tap device. https://github.com/GDSSecurity/wifitap * __wifite 2.28fc5cd__ A tool to attack multiple WEP and WPA encrypted networks at the same time. http://code.google.com/p/wifite/ * __wig 291.14f19bd__ WebApp Information Gatherer. https://github.com/jekyc/wig * __wikigen 8.348aa99__ A script to generate wordlists out of wikipedia pages. https://github.com/zombiesam/wikigen * __winexe 1.00__ Remotely execute commands on Windows NT/2000/XP/2003 systems. http://sourceforge.net/projects/winexe/ * __winfo 2.0__ Uses null sessions to remotely try to retrieve lists of and information about user accounts, workstation/interdomain/server trust accounts, shares (also hidden), sessions, logged in users, and password/lockout policy, from Windows NT/2000/XP. http://www.ntsecurity.nu/toolbox/winfo/ * __wireless-ids 24.b132071__ Ability to detect suspicious activity such as (WEP/WPA/WPS) attack by sniffing the air for wireless packets. https://github.com/SYWorks/wireless-ids * __wireshark-cli 1.12.2__ a free network protocol analyzer for Unix/Linux and Windows - CLI version http://www.wireshark.org/ * __wireshark-gtk 1.12.2__ a free network protocol analyzer for Unix/Linux and Windows - GTK frontend http://www.wireshark.org/ * __wirouter-keyrec 1.1.2__ A powerful and platform independent software to recover the default WPA passphrases of the supported router models (Telecom Italia Alice AGPF, Fastweb Pirelli, Fastweb Tesley, Eircom Netopia, Pirelli TeleTu/Tele 2). http://www.salvatorefresta.net/tools/ * __witchxtool 1.1__ A perl script that consists of a port scanner, LFI scanner, MD5 bruteforcer, dork SQL injection scanner, fresh proxy scanner, and a dork LFI scanner. http://packetstormsecurity.com/files/97465/Witchxtool-Port-LFI-SQL-Scanner-And-MD5-Bruteforcing-Tool.1.html * __wlan2eth 1.3__ re-writes 802.11 captures into standard Ethernet frames. http://www.willhackforsushi.com/?page_id=79 * __wmat 0.1__ Automatic tool for testing webmail accounts http://netsec.rs/70/tools.html * __wnmap 0.1__ A shell script written with the purpose to automate and chain scans via nmap. You can run nmap with a custom mode written by user and create directories for every mode with the xml/nmap files inside. http://nullsecurity.net/tools/automation.html * __wol-e 2.0__ A suite of tools for the Wake on LAN feature of network attached computers http://code.google.com/p/wol-e/ * __wordpot 37.e42eeda__ A Wordpress Honeypot. https://github.com/gbrindisi/wordpot * __wpbf 7.11b6ac1__ Multithreaded WordPress brute forcer. https://github.com/dejanlevaja/wpbf * __wpscan 1803.88808db__ A vulnerability scanner which checks the security of WordPress installations using a black box approach. http://wpscan.org * __ws-attacker 1.3__ A modular framework for web services penetration testing. http://ws-attacker.sourceforge.net/ * __wsfuzzer 1.9.5__ A Python tool written to automate pentesting of web services. https://www.owasp.org/index.php/Category:OWASP_WSFuzzer_ProjectSOAP * __wyd 0.2__ Gets keywords from personal files. IT security/forensic tool. http://www.remote-exploit.org/?page_id=418 * __x-scan 3.3__ A general network vulnerabilities scanner for scanning network vulnerabilities for specific IP address scope or stand-alone computer by multi-threading method, plug-ins are supportable. http://www.xfocus.org/ * __xcavator 5.bd9e2d8__ Man-In-The-Middle and phishing attack tool that steals the victim's credentials of some web services like Facebook. https://github.com/nccgroup/xcavator * __xf86-video-qxl-git r541.cbe70e9__ Xorg X11 qxl video driver. http://www.spice-space.org/ * __xorbruteforcer 0.1__ Script that implements a XOR bruteforcing of a given file, although a specific key can be used too. http://eternal-todo.com/category/bruteforce * __xorsearch 1.11.1__ Program to search for a given string in an XOR, ROL or ROT encoded binary file. http://blog.didierstevens.com/programs/xorsearch/ * __xortool 0.96__ A tool to analyze multi-byte xor cipher. https://github.com/hellman/xortool/ * __xplico 33.0f6d8bc__ Internet Traffic Decoder. Network Forensic Analysis Tool (NFAT). http://www.xplico.org/ * __xprobe2 0.3__ An active OS fingerprinting tool. http://sourceforge.net/apps/mediawiki/xprobe/index.php?title=Main_Page * __xspy 1.0c__ A utility for monitoring keypresses on remote X servers http://www.freshports.org/security/xspy/ * __xsser 1.6__ A penetration testing tool for detecting and exploiting XSS vulnerabilites. http://xsser.sourceforge.net/ * __xssless 35.9eee648__ An automated XSS payload generator written in python. https://github.com/mandatoryprogrammer/xssless * __xsss 0.40b__ A brute force cross site scripting scanner. http://www.sven.de/xsss/ * __xssscan 8340.db8ef4a__ Command line tool for detection of XSS attacks in URLs. Based on ModSecurity rules from OWASP CRS. https://github.com/gwroblew/detectXSSlib * __xsssniper 0.9__ An automatic XSS discovery tool https://github.com/gbrindisi/xsssniper * __xssya 13.15ebdfe__ A Cross Site Scripting Scanner & Vulnerability Confirmation. https://github.com/yehia-mamdouh/XSSYA * __yara 3.2.0__ A malware identification and classification tool. https://plusvic.github.io/yara/ * __ycrawler 0.1__ A web crawler that is useful for grabbing all user supplied input related to a given website and will save the output. It has proxy and log file support. http://packetstormsecurity.com/files/98546 # Awesome Hacking Tools ___________________________________________________________________________________________________________ * __0trace__ 1.5 A hop enumeration tool http://jon.oberheide.org/0trace/ * __3proxy__ 0.7.1.1 Tiny free proxy server. http://3proxy.ru/ * __3proxy-win32__ 0.7.1.1 Tiny free proxy server. http://3proxy.ru/ * __42zip 42__ Recursive Zip archive bomb. http://blog.fefe.de/?ts=b6cea88d * __acccheck__ 0.2.1 A password dictionary attack tool that targets windows authentication via the SMB protocol. http://labs.portcullis.co.uk/tools/acccheck/ * __ace 1.10__ Automated Corporate Enumerator. A simple yet powerful VoIP Corporate Directory enumeration tool that mimics the behavior of an IP Phone in order to download the name and extension entries that a given phone can display on its screen interface http://ucsniff.sourceforge.net/ace.html * __admid-pack 0.1__ ADM DNS spoofing tools - Uses a variety of active and passive methods to spoof DNS packets. Very powerful. http://packetstormsecurity.com/files/10080/ADMid-pkg.tgz.html * __adminpagefinder 0.1__ This python script looks for a large amount of possible administrative interfaces on a given site. http://packetstormsecurity.com/files/112855/Admin-Page-Finder-Script.html * __admsnmp 0.1__ ADM SNMP audit scanner. * __aesfix 1.0.1__ A tool to find AES key in RAM http://citp.princeton.edu/memory/code/ * __aeskeyfind 1.0__ A tool to find AES key in RAM http://citp.princeton.edu/memory/code/ * __aespipe 2.4c__ Reads data from stdin and outputs encrypted or decrypted results to stdout. http://loop-aes.sourceforge.net/aespipe/ * __afflib 3.7.3__ An extensible open format for the storage of disk images and related forensic information. http://www.afflib.org * __afpfs-ng 0.8.1__ A client for the Apple Filing Protocol (AFP) http://alexthepuffin.googlepages.com/ * __against 0.2__ A very fast ssh attacking script which includes a multithreaded port scanning module (tcp connect) for discovering possible targets and a multithreaded brute-forcing module which attacks parallel all discovered hosts or given ip addresses from a list. http://nullsecurity.net/tools/cracker.html * __aiengine 339.58dfb85__ A packet inspection engine with capabilities of learning without any human intervention. https://bitbucket.org/camp0/aiengine/ * __aimage 3.2.5__ A program to create aff-images. http://www.afflib.org * __air 2.0.0__ A GUI front-end to dd/dc3dd designed for easily creating forensic images. http://air-imager.sourceforge.net/ * __airflood 0.1__ A modification of aireplay that allows for a DOS in in the AP. This program fills the table of clients of the AP with random MACs doing impossible new connections. http://packetstormsecurity.com/files/51127/airflood.1.tar.gz.html * __airgraph-ng 2371__ Graphing tool for the aircrack suite http://www.aircrack-ng.org * __airoscript 45.0a122ee__ A script to simplify the use of aircrack-ng tools. http://midnightresearch.com/projects/wicrawl/ * __airpwn 1.4__ A tool for generic packet injection on an 802.11 network. http://airpwn.sourceforge.net * __allthevhosts 1.0__ A vhost discovery tool that scrapes various web applications http://labs.portcullis.co.uk/tools/finding-all-the-vhosts/ * __american-fuzzy-lop 0.89b__ A practical, instrumentation-driven fuzzer for binary formats. https://code.google.com/p/american-fuzzy-lop/ * __androguard 1.9__ Reverse engineering, Malware and goodware analysis of Android applications and more. https://code.google.com/p/androguard/ * __androick 5.35048d7__ A python tool to help in forensics analysis on android. https://github.com/Flo354/Androick * __android-apktool 1.5.2__ A tool for reengineering Android apk files. http://forum.xda-developers.com/showthread.php?t=1755243 * __android-ndk r9c__ Android C/C++ developer kit. http://developer.android.com/sdk/ndk/index.html * __android-sdk-platform-tools r19__ Platform-Tools for Google Android SDK (adb and fastboot) http://developer.android.com/sdk/index.html * __android-sdk r22.3__ Google Android SDK http://developer.android.com/sdk/index.html * __android-udev-rules 8340.db8ef4a__ Android udev rules. https://github.com/bbqlinux/android-udev-rules * __androidsniffer 0.1__ A perl script that lets you search for 3rd party passwords, dump the call log, dump contacts, dump wireless configuration, and more. http://packetstormsecurity.com/files/97464/Andr01d-Magic-Dumper.1.html * __anontwi 1.0__ A free software python client designed to navigate anonymously on social networks. It supports Identi.ca and Twitter.com. http://anontwi.sourceforge.net/ * __aphopper 0.3__ AP Hopper is a program that automatically hops between access points of different wireless networks. http://aphopper.sourceforge.net/ * __apnbf 0.1__ A small python script designed for enumerating valid APNs (Access Point Name) on a GTP-C speaking device. http://www.c0decafe.de/ * __arachni 1.0.6__ A feature-full, modular, high-performance Ruby framework aimed towards helping penetration testers and administrators evaluate the security of web applications. https://www.arachni-scanner.com * __arduino 1.0.5__ Arduino SDK (includes patched avrdude and librxtx) http://arduino.cc/en/Main/Software * __argus 3.0.8__ Network monitoring tool with flow control. http://qosient.com/argus/ * __argus-clients 3.0.8__ Network monitoring client for Argus. http://qosient.com/argus/ * __armitage 141120__ A graphical cyber attack management tool for Metasploit. http://www.fastandeasyhacking.com/ * __arp-scan 1.9__ A tool that uses ARP to discover and fingerprint IP hosts on the local network http://www.nta-monitor.com/tools/arp-scan/ * __arpalert 2.0.12__ Monitor ARP changes in ethernet networks http://www.arpalert.org/ * __arpantispoofer 1.0.1.32__ A utility to detect and resist BIDIRECTIONAL ARP spoofing. It can anti-spoof for not only the local host, but also other hosts in the same subnet. It is also a handy helper for gateways which don't work well with ARP. http://arpantispoofer.sourceforge.net/ * __arpoison 0.6__ The UNIX arp cache update utility http://www.arpoison.net * __arpon 2.7__ A portable handler daemon that make ARP protocol secure in order to avoid the Man In The Middle (MITM) attack through ARP Spoofing, ARP Cache Poisoning or ARP Poison Routing (APR) attacks. http://arpon.sourceforge.net/ * __arpwner 26.f300fdf__ GUI-based python tool for arp posioning and dns poisoning attacks. https://github.com/ntrippar/ARPwner * __artillery 1.0.2__ A combination of a honeypot, file-system monitoring, system hardening, and overall health of a server to create a comprehensive way to secure a system https://www.trustedsec.com/downloads/artillery/ * __asleap 2.2__ Actively recover LEAP/PPTP passwords. http://www.willhackforsushi.com/Asleap.html * __asp-audit 2BETA__ An ASP fingerprinting tool and vulnerability scanner. http://seclists.org/basics/2006/Sep/128 * __athena-ssl-scanner 0.5.2__ a SSL cipher scanner that checks all cipher codes. It can identify about 150 different ciphers. http://packetstormsecurity.com/files/93062/Athena-SSL-Cipher-Scanner.html * __atstaketools 0.1__ This is an archive of various @Stake tools that help perform vulnerability scanning and analysis, information gathering, password auditing, and forensics. http://packetstormsecurity.com/files/50718/AtStakeTools.zip.html * __auto-xor-decryptor 3.6a1f8f7__ Automatic XOR decryptor tool. http://www.blog.mrg-effitas.com/publishing-of-mrg-effitas-automatic-xor-decryptor-tool/ * __autopsy 2.24__ A GUI for The Sleuth Kit. http://www.sleuthkit.org/autopsy * __azazel 10.401e3aa__ A userland rootkit based off of the original LD_PRELOAD technique from Jynx rootkit. https://github.com/chokepoint/azazel * __b2sum 20140114__ BLAKE2 file hash sum check. Computes the BLAKE2 (BLAKE2b or -s, -bp, -sp) cryptographic hash of a given file. https://blake2.net/ * __backcookie 44.cbf5b8b__ Small backdoor using cookie. https://github.com/mrjopino/backcookie * __backdoor-factory 98.89d87b2__ Patch win32/64 binaries with shellcode. https://github.com/secretsquirrel/the-backdoor-factory * __backfuzz 36.8e54ed6__ A network protocol fuzzing toolkit. https://github.com/localh0t/backfuzz * __balbuzard 65.546c5dcf629c__ A package of malware analysis tools in python to extract patterns of interest from suspicious files (IP addresses, domain names, known file headers, interesting strings, etc). https://bitbucket.org/decalage/balbuzard/ * __bamf-framework 35.30d2b4b__ A modular framework designed to be a platform to launch attacks against botnets. https://github.com/bwall/BAMF * __basedomainname 0.1__ Tool that can extract TLD (Top Level Domain), domain extensions (Second Level Domain + TLD), domain name, and hostname from fully qualified domain names. http://www.morningstarsecurity.com/research * __batman-adv 2013.4.0__ batman kernel module, (included upstream since .38) http://www.open-mesh.net/ * __bbqsql 1.2__ SQL injection exploitation tool. https://github.com/neohapsis/bbqsql * __bdfproxy 38.43e83e4__ Patch Binaries via MITM: BackdoorFactory + mitmProxy https://github.com/secretsquirrel/BDFProxy * __bed 0.5__ Collection of scripts to test for buffer overflows, format string vulnerabilities. http://www.aldeid.com/wiki/Bed * __beef 0.4.5.0.181.g80a9f8e__ The Browser Exploitation Framework that focuses on the web browser http://beefproject.com/ * __beholder 0.8.9__ A wireless intrusion detection tool that looks for anomalies in a wifi environment. http://www.beholderwireless.org/ * __beleth 36.0963699__ A Multi-threaded Dictionary based SSH cracker. https://github.com/chokepoint/Beleth * __bfbtester 2.0.1__ Performs checks of single and multiple argument command line overflows and environment variable overflows http://sourceforge.net/projects/bfbtester/ * __bgp-md5crack 0.1__ RFC2385 password cracker http://www.c0decafe.de/ * __bing-ip2hosts 0.4__ Enumerates all hostnames which Bing has indexed for a specific IP address. http://www.morningstarsecurity.com/research/bing-ip2hosts * __bing-lfi-rfi 0.1__ This is a python script for searching Bing for sites that may have local and remote file inclusion vulnerabilities. http://packetstormsecurity.com/files/121590/Bing-LFI-RFI-Scanner.html * __binwalk 2.0.1__ A tool for searching a given binary image for embedded files. http://binwalk.org * __binwally 3.ca092a7__ Binary and Directory tree comparison tool using the Fuzzy Hashing concept (ssdeep). https://github.com/bmaia/binwally * __bios_memimage 1.2__ A tool to dump RAM contents to disk (aka cold boot attack). http://citp.princeton.edu/memory/code/ * __birp 60.1d7c49f__ A tool that will assist in the security assessment of mainframe applications served over TN3270. https://github.com/sensepost/birp * __bittwist 2.0__ A simple yet powerful libpcap-based Ethernet packet generator. It is designed to complement tcpdump, which by itself has done a great job at capturing network traffic. http://bittwist.sourceforge.net/ * __bkhive 1.1.1__ Program for dumping the syskey bootkey from a Windows NT/2K/XP system hive. http://sourceforge.net/projects/ophcrack * __blackarch-menus 0.2__ BlackArch specific XDG-compliant menu http://www.blackarch.org/ * __blackhash 0.2__ Creates a filter from system hashes http://16s.us/blackhash/ * __bletchley 0.0.1__ A collection of practical application cryptanalysis tools. https://code.google.com/p/bletchley/ * __blindelephant 7__ A web application fingerprinter. Attempts to discover the version of a (known) web application by comparing static files at known locations http://blindelephant.sourceforge.net/ * __blindsql 1.0__ Set of bash scripts for blind SQL injection attacks http://www.enye-sec.org/programas.html * __bluebox-ng 66.4a73bb4__ A GPL VoIP/UC vulnerability scanner. https://github.com/jesusprubio/bluebox-ng * __bluebugger 0.1__ An implementation of the bluebug technique which was discovered by Martin Herfurt. http://packetstormsecurity.com/files/54024/bluebugger.1.tar.gz.html * __bluelog 1.1.1__ A Bluetooth scanner and sniffer written to do a single task, log devices that are in discoverable mode. http://www.digifail.com/software/bluelog.shtml * __bluepot 0.1__ A Bluetooth Honeypot written in Java, it runs on Linux https://code.google.com/p/bluepot/ * __blueprint 0.1_3__ A perl tool to identify Bluetooth devices. http://trifinite.org/trifinite_stuff_blueprinting.html * __blueranger 1.0__ A simple Bash script which uses Link Quality to locate Bluetooth device radios. http://www.hackfromacave.com/projects/blueranger.html * __bluesnarfer 0.1__ A bluetooth attacking tool http://www.alighieri.org/project.html * __bmap-tools 3.2__ Tool for copying largely sparse files using information from a block map file. http://git.infradead.org/users/dedekind/bmap-tools.git * __bob-the-butcher 0.7.1__ A distributed password cracker package. http://btb.banquise.net/ * __bokken 376.caaa65c431a8__ GUI for radare2 and pyew. http://inguma.eu/projects/bokken/ * __bowcaster 0.1__ This framework, implemented in Python, is intended to aid those developing exploits by providing useful set of tools and modules, such as payloads, encoders, connect-back servers, etc. Currently the framework is focused on the MIPS CPU architecture, but the design is intended to be modular enough to support arbitrary architectures. https://github.com/zcutlip/bowcaster * __braa 0.82__ A mass snmp scanner http://s-tech.elsat.net.pl/braa/ * __braces 0.4__ A Bluetooth Tracking Utility. http://braces.shmoo.com/ * __browser-fuzzer__ 3 Browser Fuzzer 3 http://www.krakowlabs.com/dev.html * __brutessh 0.5__ A simple sshd password bruteforcer using a wordlist, it's very fast for internal networks. It's multithreads. http://www.edge-security.com/edge-soft.php * __brutus 2__ One of the fastest, most flexible remote password crackers you can get your hands on. http://www.hoobie.net/brutus/ * __bsdiff 4.3__ bsdiff and bspatch are tools for building and applying patches to binary files. http://www.daemonology.net/bsdiff/ * __bsqlbf 2.7__ Blind SQL Injection Brute Forcer. http://code.google.com/p/bsqlbf-v2/ * __bss 0.8__ Bluetooth stack smasher / fuzzer http://www.secuobs.com/news/15022006-bss_0_8.shtml * __bt_audit 0.1.1__ Bluetooth audit http://www.betaversion.net/btdsd/download/ * __btcrack 1.1__ The world's first Bluetooth Pass phrase (PIN) bruteforce tool. Bruteforces the Passkey and the Link key from captured Pairing exchanges. http://www.nruns.com/_en/security_tools_btcrack.php * __btscanner 2.1__ Bluetooth device scanner. http://www.pentest.co.uk * __bulk-extractor 1.5.5__ Bulk Email and URL extraction tool. https://github.com/simsong/bulk_extractor * __bully 19.ba33677__ A wifi-protected-setup (WPS) brute force attack tool. http://code.google.com/p/bully/ * __bunny 0.93__ A closed loop, high-performance, general purpose protocol-blind fuzzer for C programs. http://code.google.com/p/bunny-the-fuzzer/ * __burpsuite 1.6__ An integrated platform for attacking web applications (free edition). http://portswigger.net/burp/ * __buttinsky 138.1a2a1b2__ Provide an open source framework for automated botnet monitoring. https://github.com/buttinsky/buttinsky * __bvi 1.4.0beta__ A display-oriented editor for binary files operate like "vi" editor. http://bvi.sourceforge.net/ * __cadaver 0.23.3__ Command-line WebDAV client for Unix http://www.webdav.org/cadaver * __canari 1.1__ A transform framework for maltego http://www.canariproject.com/ * __cansina 93.abc6577__ A python-based Web Content Discovery Tool. https://github.com/deibit/cansina * __capstone 3.0__ A lightweight multi-platform, multi-architecture disassembly framework. http://www.capstone-engine.org/index.html * __carwhisperer 0.2__ Intends to sensibilise manufacturers of carkits and other Bluetooth appliances without display and keyboard for the possible security threat evolving from the use of standard passkeys. http://trifinite.org/trifinite_stuff_carwhisperer.html * __casefile 1.0.1__ The little brother to Maltego without transforms, but combines graph and link analysis to examine links between manually added data to mind map your information http://www.paterva.com/web6/products/casefile.php * __cdpsnarf 0.1.6__ Cisco discovery protocol sniffer. https://github.com/Zapotek/cdpsnarf * __cecster 5.15544cb__ A tool to perform security testing against the HDMI CEC (Consumer Electronics Control) and HEC (HDMI Ethernet Channel) protocols https://github.com/nccgroup/CECster * __centry 72.6de2868__ Cold boot & DMA protection https://github.com/0xPoly/Centry * __cewl 4.3__ A custom word list generator http://www.digininja.org/projects/cewl.php * __cflow 1.4__ A C program flow analyzer. http://www.gnu.org/software/cflow/ * __chaosmap 1.3__ An information gathering tool and dns / whois / web server scanner http://freecode.com/projects/chaosmap * __chaosreader 0.94__ A freeware tool to trace tcp, udp etc. sessions and fetch application data from snoop or tcpdump logs. http://chaosreader.sourceforge.net/ * __chapcrack 17.ae2827f__ A tool for parsing and decrypting MS-CHAPv2 network handshakes. https://github.com/moxie0/chapcrack * __check-weak-dh-ssh 0.1__ Debian OpenSSL weak client Diffie-Hellman Exchange checker. http://packetstormsecurity.com/files/66683/check_weak_dh_ssh.pl.bz2.html * __checkiban 0.2__ Checks the validity of an International Bank Account Number (IBAN). http://kernel.embedromix.ro/us/ * __checkpwd 1.23__ Oracle Password Checker (Cracker) http://www.red-database-security.com/software/checkpwd.html * __checksec 1.5__ The checksec.sh script is designed to test what standard Linux OS and PaX security features are being used. http://www.trapkit.de/tools/checksec.html * __chiron 0.7__ An all-in-one IPv6 Penetration Testing Framework. http://www.secfu.net/tools-scripts/ * __chkrootkit 0.50__ Checks for rootkits on a system http://www.chkrootkit.org/ * __chntpw 140201__ Offline NT Password Editor - reset passwords in a Windows NT SAM user database file http://pogostick.net/~pnh/ntpasswd/ * __chownat 0.08b__ Allows two peers behind two separate NATs with no port forwarding and no DMZ setup on their routers to directly communicate with each other http://samy.pl/chownat/ * __chrome-decode 0.1__ Chrome web browser decoder tool that demonstrates recovering passwords. http://packetstormsecurity.com/files/119153/Chrome-Web-Browser-Decoder.html * __chromefreak 22.336e323__ A Cross-Platform Forensic Framework for Google Chrome http://osandamalith.github.io/ChromeFreak/ * __cidr2range 0.9__ Script for listing the IP addresses contained in a CIDR netblock http://www.cpan.org/authors/id/R/RA/RAYNERLUC * __ntruder 0.2.0__ An automatic pentesting tool to bypass captchas. http://cintruder.sourceforge.net/ * __ciphertest 14.7f49ea7__ A better SSL cipher checker using gnutls. https://github.com/OpenSecurityResearch/ciphertest * __cirt-fuzzer 1.0__ A simple TCP/UDP protocol fuzzer. http://www.cirt.dk/ * __cisco-auditing-tool 1__ Perl script which scans cisco routers for common vulnerabilities. Checks for default passwords, easily guessable community names, and the IOS history bug. Includes support for plugins and scanning multiple hosts. http://www.scrypt.net * __cisco-global-exploiter 1.3__ A perl script that targets multiple vulnerabilities in the Cisco Internetwork Operating System (IOS) and Catalyst products. http://www.blackangels.it * __cisco-ocs 0.2__ Cisco Router Default Password Scanner. http://www.question-defense.com/2013/01/11/ocs-version-2-release-ocs-cisco-router-default-password-scanner * __cisco-router-config 1.1__ copy-router-config and merge-router-config to copy and merge Cisco Routers Configuration * __cisco-scanner 0.2__ Multithreaded Cisco HTTP vulnerability scanner. Tested on Linux, OpenBSD and Solaris. http://wayreth.eu.org/old_page/ * __cisco-torch 0.4b__ Cisco Torch mass scanning, fingerprinting, and exploitation tool. http://www.arhont.com * __cisco5crack 2.c4b228c__ Crypt and decrypt the cisco enable 5 passwords. https://github.com/madrisan/cisco7crack * __cisco7crack 2.f1c21dd__ Crypt and decrypt the cisco enable 7 passwords. https://github.com/madrisan/cisco7crack * __ciscos 1.3__ Scans class A, B, and C networks for cisco routers which have telnet open and have not changed the default password from cisco. * __climber 23.f614304__ Check UNIX/Linux systems for privilege escalation. https://github.com/raffaele-forte/climber * __clusterd 129.0f04a49__ Automates the fingerprinting, reconnaissance, and exploitation phases of an application server attack. https://github.com/hatRiot/clusterd * __cmospwd 5.0__ Decrypts password stored in CMOS used to access BIOS setup. http://www.cgsecurity.org/wiki/CmosPwd * __cms-explorer 1.0__ Designed to reveal the specific modules, plugins, components and themes that various cms driven websites are running http://code.google.com/p/cms-explorer * __cms-few 0.1__ Joomla, Mambo, PHP-Nuke, and XOOPS CMS SQL injection vulnerability scanning tool written in Python. http://packetstormsecurity.com/files/64722/cms_few.py.txt.html * __codetective 37.f94d9e8__ A tool to determine the crypto/encoding algorithm used according to traces of its representation. https://www.digitalloft.org/init/plugin_wiki/page/codetective * __complemento 0.7.6__ A collection of tools for pentester: LetDown is a powerful tcp flooder ReverseRaider is a domain scanner that use wordlist scanning or reverse resolution scanning Httsquash is an http server scanner, banner grabber and data retriever http://complemento.sourceforge.net * __conpot 0.3.1__ ICS honeypot with the goal to collect intelligence about the motives and methods of adversaries targeting industrial control systems url="http://conpot.org" * __conscan 1.1__ A blackbox vulnerability scanner for the Concre5 CMS. http://nullsecurity.net/tools/scanner.html * __cookie-cadger 1.07__ An auditing tool for Wi-Fi or wired Ethernet connections. https://cookiecadger.com/ * __cowpatty 4.6__ Wireless WPA/WPA2 PSK handshake cracking utility http://www.wirelessdefence.org/Contents/Files/ * __cpfinder 0.1__ This is a simple script that looks for administrative web interfaces. http://packetstormsecurity.com/files/118851/Control-Panel-Finder-Script.html * __cppcheck 1.67__ A tool for static C/C++ code analysis http://cppcheck.wiki.sourceforge.net/ * __cpptest 1.1.2__ A portable and powerful, yet simple, unit testing framework for handling automated tests in C++. http://cpptest.sourceforge.net/ * __crackhor 2.ae7d83f__ A Password cracking utility. https://github.com/CoalfireLabs/crackHOR * __crackle 39.3e93196__ Crack and decrypt BLE encryption https://github.com/mikeryan/crackle/ * __crackserver 31.c268a80__ An XMLRPC server for password cracking. https://github.com/averagesecurityguy/crack * __create-ap 112.1c89b44__ This script creates a NATed or Bridged WiFi Access Point. https://github.com/oblique/create_ap * __creddump 0.3__ A python tool to extract various credentials and secrets from Windows registry hives. https://code.google.com/p/creddump/ * __creds 8340.db8ef4a__ Harvest FTP/POP/IMAP/HTTP/IRC credentials along with interesting data from each of the protocols. https://github.com/DanMcInerney/creds.py * __creepy 137.9f60449__ A geolocation information gatherer. Offers geolocation information gathering through social networking platforms. http://github.com/ilektrojohn/creepy.git * __crunch 3.6__ A wordlist generator for all combinations/permutations of a given character set. http://sourceforge.net/projects/crunch-wordlist/ * __cryptcat 1.2.1__ A lightweight version of netcat with integrated transport encryption capabilities. http://sourceforge.net/projects/cryptcat * __crypthook__ 17.0728cd1 TCP/UDP symmetric encryption tunnel wrapper. https://github.com/chokepoint/CryptHook * __cryptonark 0.4.9__ SSL security checker. http://blog.techstacks.com/cryptonark.html * __csrftester 1.0__ The OWASP CSRFTester Project attempts to give developers the ability to test their applications for CSRF flaws. http://www.owasp.org/index.php/Category:OWASP_CSRFTester_Project * __ctunnel 0.6__ Tunnel and/or proxy TCP or UDP connections via a cryptographic tunnel. http://nardcore.org/ctunnel * __cuckoo 1.1.1__ A malware analysis system. http://cuckoosandbox.org/ * __cupp 3.0__ Common User Password Profiler http://www.remote-exploit.org/?page_id=418 * __cutycapt 10__ A Qt and WebKit based command-line utility that captures WebKit's rendering of a web page. http://cutycapt.sourceforge.net/ * __cvechecker 3.5__ The goal of cvechecker is to report about possible vulnerabilities on your system, by scanning the installed software and matching the results with the CVE database. http://cvechecker.sourceforge.net/ * __cymothoa 1__ A stealth backdooring tool, that inject backdoor's shellcode into an existing process. http://cymothoa.sourceforge.net/ * __darkbing 0.1__ A tool written in python that leverages bing for mining data on systems that may be susceptible to SQL injection. http://packetstormsecurity.com/files/111510/darkBing-SQL-Scanner.1.html * __darkd0rk3r 1.0__ Python script that performs dork searching and searches for local file inclusion and SQL injection errors. http://packetstormsecurity.com/files/117403/Dark-D0rk3r.0.html * __darkjumper 5.8__ This tool will try to find every website that host at the same server at your target http://sourceforge.net/projects/darkjumper/ * __darkmysqli 1.6__ Multi-Purpose MySQL Injection Tool https://github.com/BlackArch/darkmysqli * __darkstat 3.0.718__ Network statistics gatherer (packet sniffer) http://dmr.ath.cx/net/darkstat/ * __davoset 1.2.3__ A tool for using Abuse of Functionality and XML External Entities vulnerabilities on some websites to attack other websites. http://websecurity.com.ua/davoset/ * __davtest 1.0__ Tests WebDAV enabled servers by uploading test executable files, and then (optionally) uploading files which allow for command execution or other actions directly on the target http://code.google.com/p/davtest/ * __dbd 1.50__ A Netcat-clone, designed to be portable and offer strong encryption. It runs on Unix-like operating systems and on Microsoft Win32. https://github.com/gitdurandal/dbd * __dbpwaudit 0.8__ A Java tool that allows you to perform online audits of password quality for several database engines http://www.cqure.net/wp/dbpwaudit/ * __dc3dd 7.1.614__ A patched version of dd that includes a number of features useful for computer forensics http://sourceforge.net/projects/dc3dd * __dcfldd 1.3.4.1__ DCFL (DoD Computer Forensics Lab) dd replacement with hashing http://dcfldd.sourceforge.net/ * __ddrescue 1.19__ GNU data recovery tool http://www.gnu.org/software/ddrescue/ddrescue.html * __deblaze 0.3__ A remote method enumeration tool for flex servers http://deblaze-tool.appspot.com/ * __delldrac 0.1a__ DellDRAC and Dell Chassis Discovery and Brute Forcer. https://www.trustedsec.com/september/owning-dell-drac-awesome-hack/ * __depant 0.3a__ Check network for services with default passwords. http://midnightresearch.com/projects/depant/ * __device-pharmer__ 35.c1d449e Opens 1K+ IPs or Shodan search results and attempts to login. https://github.com/DanMcInerney/device-pharmer * __dex2jar 0.0.9.13__ A tool for converting Android's .dex format to Java's .class format http://code.google.com/p/dex2jar * __dff-scanner 1.1__ Tool for finding path of predictable resource locations. http://netsec.rs/70/tools.html * __dhcdrop 0.5__ Remove illegal dhcp servers with IP-pool underflow. Stable version http://www.netpatch.ru/dhcdrop.html * __dhcpig 69.cc4109a__ Enumerates hosts, subdomains, and emails from a given domain using google https://github.com/kamorin/DHCPig * __dinouml 0.9.5__ A network simulation tool, based on UML (User Mode Linux) that can simulate big Linux networks on a single PC http://kernel.embedromix.ro/us/ * __dirb 2.04__ A web content scanner, brute forceing for hidden files http://dirb.sourceforge.net/ * __dirbuster 1.0_RC1__ An application designed to brute force directories and files names on web/application servers http://www.owasp.org/index.php/Category:OWASP_DirBuster_Project * __directorytraversalscan 1.0.1.0__ Detect directory traversal vulnerabilities in HTTP servers and web applications. http://sourceforge.net/projects/httpdirscan/ * __dirs3arch 119.6a3b68a__ HTTP(S) directory/file brute forcer. https://github.com/maurosoria/dirs3arch * __dirscanner 0.1__ This is a python script that scans webservers looking for administrative directories, php shells, and more. http://packetstormsecurity.com/files/117773/Directory-Scanner-Tool.html * __dislocker 0.3__ A tool to exploit the hash length extension attack in various hashing algorithms. With FUSE capabilities built in. http://www.hsc.fr/ressources/outils/dislocker/ * __dissector 1__ This code dissects the internal data structures in ELF files. It supports x86 and x86_64 archs and runs under Linux. http://packetstormsecurity.com/files/125972/Coloured-ELF-File-Dissector.html * __dissy 10__ A graphical frontend to the objdump disassembler for compiler-generated code. http://dissy.googlecode.com/ * __dizzy 0.8.2__ A Python based fuzzing framework with many features. http://www.c0decafe.de/ * __dmitry 1.3a__ Deepmagic Information Gathering Tool. Gathers information about hosts. It is able to gather possible subdomains, email addresses, and uptime information and run tcp port scans, whois lookups, and more. http://www.mor-pah.net/ * __dnmap 0.6__ The distributed nmap framework http://sourceforge.net/projects/dnmap/ * __dns-spoof 12.3918a10__ Yet another DNS spoof utility. https://github.com/maurotfilho/dns-spoof * __dns2geoip 0.1__ A simple python script that brute forces DNS and subsequently geolocates the found subdomains. http://packetstormsecurity.com/files/118036/DNS-GeoIP.html * __dns2tcp 0.5.2__ A tool for relaying TCP connections over DNS. http://www.hsc.fr/ressources/outils/dns2tcp/index.html.en * __dnsa 0.5__ DNSA is a dns security swiss army knife http://packetfactory.openwall.net/projects/dnsa/index.html * __dnsbf 0.2__ search for available domain names in an IP range http://code.google.com/p/dnsbf * __dnsbrute 2.b1dc84a__ Multi-theaded DNS bruteforcing, average speed 80 lookups/second with 40 threads. https://github.com/d4rkcat/dnsbrute * __dnschef 0.3__ A highly configurable DNS proxy for pentesters. http://thesprawl.org/projects/dnschef/ * __dnsdrdos 0.1__ Proof of concept code for distributed DNS reflection DoS http://nullsecurity.net/tools/dos.html * __dnsenum 1.2.4.1__ Script that enumerates DNS information from a domain, attempts zone transfers, performs a brute force dictionary style attack, and then performs reverse look-ups on the results. http://www2.packetstormsecurity.org/cgi-bin/search/search.cgi?searchvalue=dnsenum * __dnsgoblin 0.1__ Nasty creature constantly searching for DNS servers. It uses standard dns querys and waits for the replies http://nullsecurity.net/tools/scanner.html * __dnsmap 0.30__ Passive DNS network mapper http://dnsmap.googlecode.com * __dnspredict 0.0.2__ DNS prediction http://johnny.ihackstuff.com * __dnsrecon 0.8.8__ Python script for enumeration of hosts, subdomains and emails from a given domain using google. https://github.com/darkoperator/dnsrecon * __dnsspider 0.5__ A very fast multithreaded bruteforcer of subdomains that leverages a wordlist and/or character permutation. http://nullsecurity.net/tools/scanner.html * __dnstracer 1.9__ Determines where a given DNS server gets its information from, and follows the chain of DNS servers http://www.mavetju.org/unix/dnstracer.php * __dnsutils 9.9.2.P2__ DNS utilities: dig host nslookup http://www.isc.org/software/bind/ * __dnswalk 2.0.2__ A DNS debugger http://sourceforge.net/projects/dnswalk/ * __domain-analyzer 0.8.1__ Finds all the security information for a given domain name. http://sourceforge.net/projects/domainanalyzer/ * __doona 118.ff1e17b__ A fork of the Bruteforce Exploit Detector Tool (BED). https://github.com/wireghoul/doona * __dotdotpwn 3.0__ The Transversal Directory Fuzzer http://dotdotpwn.blogspot.com * __dpeparser beta002__ Default password enumeration project http://www.toolswatch.org/dpe/ * __dpscan 0.1__ Drupal Vulnerabilty Scanner. https://github.com/insaneisnotfree/Blue-Sky-Information-Security * __dradis 2.9.0__ An open source framework to enable effective information sharing. http://dradisframework.org/ * __driftnet 0.1.6__ Listens to network traffic and picks out images from TCP streams it observes. http://www.ex-parrot.com/~chris/driftnet/ * ___dripper v1.r1.gc9bb0c9__ A fast, asynchronous DNS scanner; it can be used for enumerating subdomains and enumerating boxes via reverse DNS. http://www.blackhatlibrary.net/Dripper * __dscanner 709.f00026f__ Swiss-army knife for D source code. https://github.com/Hackerpilot/Dscanner * __dsd 84.60807e0__ Digital Speech Decoder https://github.com/szechyjs/dsd * __dsniff 2.4b1__ Collection of tools for network auditing and penetration testing http://www.monkey.org/~dugsong/dsniff/ * __dumb0 19.1493e74__ A simple tool to dump users in popular forums and CMS. https://github.com/0verl0ad/Dumb0 * __dump1090 386.bff92c4__ A simple Mode S decoder for RTLSDR devices. https://github.com/MalcolmRobb/dump1090 * __dumpacl 0.0__ Dumps NTs ACLs and audit settings. http://www.systemtools.com/cgi-bin/download.pl?DumpAcl * __dumpzilla 03152013__ A forensic tool for firefox. http://www.dumpzilla.org/ * __eapmd5pass 1.4__ An implementation of an offline dictionary attack against the EAP-MD5 protocol http://www.willhackforsushi.com/?page_id=67 * __easy-creds 3.9 A__ bash script that leverages ettercap and other tools to obtain credentials. https://github.com/brav0hax/easy-creds * __easyfuzzer 3.6__ A flexible fuzzer, not only for web, has a CSV output for efficient output analysis (platform independant). http://www.mh-sec.de/downloads.html.en * __eazy 0.1__ This is a small python tool that scans websites to look for PHP shells, backups, admin panels, and more. http://packetstormsecurity.com/files/117572/EAZY-Web-Scanner.html * __edb 0.9.20__ A QT4-based binary mode debugger with the goal of having usability on par with OllyDbg. http://www.codef00.com/projects.php#Debugger * __eindeutig 20050628_1__ Examine the contents of Outlook Express DBX email repository files (forensic purposes) http://www.jonesdykstra.com/ * __elettra 1.0__ Encryption utility by Julia Identity http://www.winstonsmith.info/julia/elettra/ * __elettra-gui 1.0__ Gui for the elettra crypto application. http://www.winstonsmith.info/julia/elettra/ * __elite-proxy-finder 42.b92f75a__ Finds public elite anonymity proxies and concurrently tests them. https://github.com/DanMcInerney/elite-proxy-finder * __enabler 1__ attempts to find the enable password on a cisco system via brute force. http://packetstormsecurity.org/cisco/enabler.c * __encodeshellcode 0.1b__ This is an encoding tool for 32-bit x86 shellcode that assists a researcher when dealing with character filter or byte restrictions in a buffer overflow vulnerability or some kind of IDS/IPS/AV blocking your code. http://packetstormsecurity.com/files/119904/Encode-Shellcode.1b.html * __ent 1.0__ Pseudorandom number sequence test. http://www.fourmilab.ch/random * __enum-shares 7.97cba5a__ Tool that enumerates shared folders across the network and under a custom user account. https://github.com/dejanlevaja/enum_shares * __enum4linux 0.8.9__ A tool for enumerating information from Windows and Samba systems. http://labs.portcullis.co.uk/application/enum4linux/ * __enumiax 1.0__ IAX enumerator http://sourceforge.net/projects/enumiax/ * __enyelkm 1.2__ Rootkit for Linux x86 kernels v2.6. http://www.enye-sec.org/programas.html * __epicwebhoneypot 2.0a__ Tool which aims to lure attackers using various types of web vulnerability scanners by tricking them into believing that they have found a vulnerability on a host. http://sourceforge.net/projects/epicwebhoneypot/ * __erase-registrations 1.0__ IAX flooder http://www.hackingexposedvoip.com/ * __etherape 0.9.13__ A graphical network monitor for various OSI layers and protocols http://etherape.sourceforge.net/ * __ettercap 0.8.1__ A network sniffer/interceptor/logger for ethernet LANs - console http://ettercap.github.com/ettercap/ * __evilgrade 2.0.0__ Modular framework that takes advantage of poor upgrade implementations by injecting fake updates http://www.infobyte.com.ar/developments.html * __evilmaid 1.01__ TrueCrypt loader backdoor to sniff volume password http://theinvisiblethings.blogspot.com * __exiv2 0.24__ Exif and Iptc metadata manipulation library and tools http://exiv2.org * __exploit-db 1.6__ The Exploit Database (EDB) – an ultimate archive of exploits and vulnerable software - A collection of hacks http://www.exploit-db.com * __extracthosts 14.ec8b89c__ Extracts hosts (IP/Hostnames) from files. https://github.com/bwall/ExtractHosts * __extundelete 0.2.4__ Utility for recovering deleted files from ext2, ext3 or ext4 partitions by parsing the journal http://extundelete.sourceforge.net * __eyepwn 1.0__ Exploit for Eye-Fi Helper directory traversal vulnerability http://www.pentest.co.uk * __eyewitness 278.e72c21e__ Designed to take screenshots of websites, provide some server header info, and identify default credentials if possible. https://github.com/ChrisTruncer/EyeWitness * __facebot 23.57f6025__ A facebook profile and reconnaissance system. https://github.com/pun1sh3r/facebot * __facebrute 7.ece355b__ This script tries to guess passwords for a given facebook account using a list of passwords (dictionary). https://github.com/emerinohdz/FaceBrute * __fakeap 0.3.2__ Black Alchemy's Fake AP generates thousands of counterfeit 802.11b access points. Hide in plain sight amongst Fake AP's cacophony of beacon frames. http://www.blackalchemy.to/project/fakeap/ * __fakedns 17.87d4216__ A regular-expression based python MITM DNS server with correct DNS request passthrough and "Not Found" responses. https://github.com/Crypt0s/FakeDns * __fakemail 1.0__ Fake mail server that captures e-mails as files for acceptance testing. http://sourceforge.net/projects/fakemail/ * __fakenetbios 7.b83701e__ A family of tools designed to simulate Windows hosts (NetBIOS) on a LAN. https://github.com/mubix/FakeNetBIOS * __fang 1.2__ A multi service threaded MD5 cracker. https://github.com/evilsocket/fang * __fbht r12.a284878__ A Facebook Hacking Tool https://github.com/chinoogawa/fbht-linux * __fcrackzip 1.0__ Zip file password cracker http://oldhome.schmorp.de/marc/fcrackzip.html * __fern-wifi-cracker 219__ WEP, WPA wifi cracker for wireless penetration testing http://code.google.com/p/fern-wifi-cracker/ * __fernmelder 6.c6d4ebe__ Asynchronous mass DNS scanner. https://github.com/stealth/fernmelder * __fgscanner 11.893372c__ An advanced, opensource URL scanner. http://www.fantaghost.com/fgscanner * __fhttp 1.3__ This is a framework for HTTP related attacks. It is written in Perl with a GTK interface, has a proxy for debugging and manipulation, proxy chaining, evasion rules, and more. http://packetstormsecurity.com/files/104315/FHTTP-Attack-Tool.3.html * __fierce 0.9.9__ A DNS scanner http://ha.ckers.org/fierce/ * __fiked 0.0.5__ Fake IDE daemon http://www.roe.ch/FakeIKEd * __filibuster 161.37b7f9c__ A Egress filter mapping application with additional functionality. https://github.com/subinacls/Filibuster * __fimap 1.00__ A little tool for local and remote file inclusion auditing and exploitation http://code.google.com/p/fimap/ * __findmyhash 1.1.2__ Crack different types of hashes using free online services http://code.google.com/p/findmyhash/ * __firewalk 5.0__ An active reconnaissance network security tool http://packetfactory.openwall.net/projects/firewalk/ * __firmware-mod-kit 099__ Modify firmware images without recompiling! http://code.google.com/p/firmware-mod-kit * __firstexecution 6.a275793__ A Collection of different ways to execute code outside of the expected entry points. https://github.com/nccgroup/firstexecution * __fl0p 0.1__ A passive L7 flow fingerprinter that examines TCP/UDP/ICMP packet sequences, can peek into cryptographic tunnels, can tell human beings and robots apart, and performs a couple of other infosec-related tricks. http://lcamtuf.coredump.cx/ * __flare 0.6__ Flare processes an SWF and extracts all scripts from it. http://www.nowrap.de/flare.html * __flasm 1.62__ Disassembler tool for SWF bytecode http://www.nowrap.de/flasm.html * __flawfinder 1.31__ Searches through source code for potential security flaws. http://www.dwheeler.com/flawfinder * __flowinspect 94.01c8921__ A network traffic inspection tool. https://github.com/7h3rAm/flowinspect * __flunym0us 2.0__ A Vulnerability Scanner for Wordpress and Moodle. http://code.google.com/p/flunym0us/ * __foremost 1.5.7__ A console program to recover files based on their headers, footers, and internal data structures http://foremost.sourceforge.net/ * __fpdns 0.9.3__ Program that remotely determines DNS server versions http://code.google.com/p/fpdns/ * __fping 3.10__ A utility to ping multiple hosts at once http://www.fping.org/ * __fport 2.0__ Identify unknown open ports and their associated applications. http://www.foundstone.com/us/resources/proddesc/fport.htm * __fraud-bridge 10.775c563__ ICMP and DNS tunneling via IPv4 and IPv6. https://github.com/stealth/fraud-bridge * __freeipmi 1.4.5__ Sensor monitoring, system event monitoring, power control, and serial-over-LAN (SOL). http://www.gnu.org/software/freeipmi/ * __freeradius 3.0.4__ The premier open source RADIUS server http://www.freeradius.org/ * __frisbeelite 1.2__ A GUI-based USB device fuzzer. https://github.com/nccgroup/FrisbeeLite * __fs-nyarl 1.0__ A network takeover & forensic analysis tool - useful to advanced PenTest tasks & for fun and profit. http://www.fulgursecurity.com/en/content/fs-nyarl * __fsnoop 3.3__ A tool to monitor file operations on GNU/Linux systems by using the Inotify mechanism. Its primary purpose is to help detecting file race condition vulnerabilities and since version 3, to exploit them with loadable DSO modules (also called "payload modules" or "paymods"). http://vladz.devzero.fr/fsnoop.php * __fstealer 0.1__ Automates file system mirroring through remote file disclosur vulnerabilities on Linux machines. http://packetstormsecurity.com/files/106450/FStealer-Filesystem-Mirroring-Tool.html * __ftester 1.0__ A tool designed for testing firewall filtering policies and Intrusion Detection System (IDS) capabilities. http://www.inversepath.com/ftester.html * __ftp-fuzz 1337__ The master of all master fuzzing scripts specifically targeted towards FTP server sofware http://nullsecurity.net/tools/fuzzer.html * __ftp-scanner 0.2.5__ Multithreaded ftp scanner/brute forcer. Tested on Linux, OpenBSD and Solaris. http://wayreth.eu.org/old_page/ * __ftp-spider 1.0__ FTP investigation tool - Scans ftp server for the following: reveal entire directory tree structures, detect anonymous access, detect directories with write permissions, find user specified data within repository. http://packetstormsecurity.com/files/35120/ftp-spider.pl.html * __ftpmap 0.4__ scans remote FTP servers to identify what software and what versions they are running. http://wcoserver.googlecode.com/files/ * __fusil 1.4__ Fusil the fuzzer is a Python library used to write fuzzing programs. It helps to start process with a prepared environment (limit memory, environment variables, redirect stdout, etc.), start network client or server, and create mangled files http://bitbucket.org/haypo/fusil/wiki/Home * __fuzzap 14.f13932c__ A python script for obfuscating wireless networks. https://github.com/lostincynicism/FuzzAP * __fuzzball2 0.7__ A little fuzzer for TCP and IP options. It sends a bunch of more or less bogus packets to the host of your choice. http://nologin.org/ * __fuzzdb 1.09__ Attack and Discovery Pattern Database for Application Fuzz Testing https://code.google.com/p/fuzzdb/ * __fuzzdiff 1.0__ A simple tool designed to help out with crash analysis during fuzz testing. It selectively 'un-fuzzes' portions of a fuzzed file that is known to cause a crash, re-launches the targeted application, and sees if it still crashes. http://vsecurity.com/resources/tool * __fuzztalk 1.0.0.0__ An XML driven fuzz testing framework that emphasizes easy extensibility and reusability. https://code.google.com/p/fuzztalk * __g72x++ 1__ Decoder for the g72x++ codec. http://www.ps-auxw.de/ * __galleta 20040505_1__ Examine the contents of the IE's cookie files for forensic purposes http://www.jonesdykstra.com/ * __gdb 7.8.1__ The GNU Debugger http://www.gnu.org/software/gdb/ * __genlist 0.1__ Generates lists of IP addresses. * __geoedge 0.2__ This little tools is designed to get geolocalization information of a host, it get the information from two sources (maxmind and geoiptool). * __geoip 1.6.2__ Non-DNS IP-to-country resolver C library & utils http://www.maxmind.com/app/c * __geoipgen 0.4__ GeoIPgen is a country to IP addresses generator. http://code.google.com/p/geoipgen/ * __getsids 0.0.1__ Getsids tries to enumerate Oracle Sids by sending the services command to the Oracle TNS listener. Like doing ‘lsnrctl service’. http://www.cqure.net/wp/getsids/ * __gggooglescan 0.4__ A Google scraper which performs automated searches and returns results of search queries in the form of URLs or hostnames. http://www.morningstarsecurity.com/research/gggooglescan * __ghettotooth 1.0__ Ghettodriving for bluetooth http://www.oldskoolphreak.com/tfiles/ghettotooth.txt * __ghost-phisher 1.62__ GUI suite for phishing and penetration attacks http://code.google.com/p/ghost-phisher * __ghost-py 0.1b3__ Webkit based webclient (relies on PyQT). http://jeanphix.github.com/Ghost.py/ * __giskismet 20110805__ A program to visually represent the Kismet data in a flexible manner. http://www.giskismet.org * __gnuradio 3.7.5.1__ General purpose DSP and SDR toolkit. With drivers for usrp and fcd. http://gnuradio.org * __gnutls2 2.12.23__ A library which provides a secure layer over a reliable transport layer (Version 2) http://gnutls.org/ * __goldeneye 16.7a38fe9__ A HTTP DoS test tool. Attack Vector exploited: HTTP Keep Alive + NoCache. https://github.com/jseidl/GoldenEye * __golismero 2.0__ Opensource web security testing framework. https://github.com/golismero/golismero * __goodork 2.2__ A python script designed to allow you to leverage the power of google dorking straight from the comfort of your command line. http://goo-dork.blogspot.com/ * __goofile 1.5__ Command line filetype search https://code.google.com/p/goofile/ * __goog-mail 1.0__ Enumerate domain emails from google. http://www.darkc0de.com/others/goog-mail.py * __googlesub 1.2__ A python script to find domains by using google dorks. https://github.com/zombiesam/googlesub * __gooscan 1.0.9__ A tool that automates queries against Google search appliances, but with a twist. http://johnny.ihackstuff.com/downloads/task,doc_details&Itemid=/gid,28/ * __gqrx 2.3.1__ Interactive SDR receiver waterfall for many devices. http://gqrx.dk/ * __grabber 0.1__ A web application scanner. Basically it detects some kind of vulnerabilities in your website. http://rgaucher.info/beta/grabber/ * __grepforrfi 0.1__ Simple script for parsing web logs for RFIs and Webshells v1.2 http://www.irongeek.com/downloads/grepforrfi.txt * __grokevt 0.5.0__ A collection of scripts built for reading Windows® NT/2K/XP/2K eventlog files. http://code.google.com/p/grokevt/ * __gtalk-decode 0.1__ Google Talk decoder tool that demonstrates recovering passwords from accounts. http://packetstormsecurity.com/files/119154/Google-Talk-Decoder.html * __gtp-scan 0.7__ A small python script that scans for GTP (GPRS tunneling protocol) speaking hosts. http://www.c0decafe.de/ * __guymager 0.7.4__ A forensic imager for media acquisition. http://guymager.sourceforge.net/ * __gwcheck 0.1__ A simple program that checks if a host in an ethernet network is a gateway to Internet. http://packetstormsecurity.com/files/62047/gwcheck.c.html * __gwtenum 7.f27a5aa__ Enumeration of GWT-RCP method calls. http://www.gdssecurity.com/l/t/d.php?k=GwtEnum * __hackersh 0.2.0__ A shell for with Pythonect-like syntax, including wrappers for commonly used security tools http://www.hackersh.org/ * __halberd 0.2.4__ Halberd discovers HTTP load balancers. It is useful for web application security auditing and for load balancer configuration testing. http://halberd.superadditive.com/ * __halcyon 0.1__ A repository crawler that runs checksums for static files found within a given git repository. http://www.blackhatlibrary.net/Halcyon * __hamster 2.0.0__ Tool for HTTP session sidejacking. http://hamster.erratasec.com/ * __handle 0.0__ An small application designed to analyze your system searching for global objects related to running proccess and display information for every found object, like tokens, semaphores, ports, files,.. http://www.tarasco.org/security/handle/index.html * __hasere 1.0__ Discover the vhosts using google and bing. https://github.com/galkan/hasere * __hash-identifier 1.1__ Identifies the different types of hashes used to encrypt data, especially passwords http://code.google.com/p/hash-identifier * __hashcat 0.47__ A multithreaded cross platform hash cracker. http://hashcat.net/hashcat/ * ___hashcat-utils 1.0__ Utilites for Hashcat http://hashcat.net/wiki/doku.php?id=hashcat_utils * __hasher 32.e9d1394__ A tool that allows you to quickly hash plaintext strings, or compare hashed values with a plaintext locally. https://github.com/ChrisTruncer/Hasher * __hashid 2.6.0__ Software to identify the different types of hashes used to encrypt data https://github.com/psypanda/hashID * __hashpump 34.0b3c286__ A tool to exploit the hash length extension attack in various hashing algorithms. https://github.com/bwall/HashPump * __hashtag 0.41__ A python script written to parse and identify password hashes. https://github.com/SmeegeSec/HashTag * __haystack 1035.ac2ffa4__ A Python framework for finding C structures from process memory - heap analysis - Memory structures forensics. https://github.com/trolldbois/python-haystack * __hbad 1.0__ This tool allows you to test clients on the heartbleed bug. http://www.curesec.com/ * __hcraft 1.0.0__ HTTP Vuln Request Crafter http://sourceforge.net/projects/hcraft/ * __hdcp-genkey 18.e8d342d__ Generate HDCP source and sink keys from the leaked master key. https://github.com/rjw57/hdcp-genkey * __hdmi-sniff 5.f7fbc0e__ HDMI DDC (I2C) inspection tool. It is designed to demonstrate just how easy it is to recover HDCP crypto keys from HDMI devices. https://github.com/ApertureLabsLtd/hdmi-sniff * __heartbleed-honeypot 0.1__ Script that listens on TCP port 443 and responds with completely bogus SSL heartbeat responses, unless it detects the start of a byte pattern similar to that used in Jared Stafford's http://packetstormsecurity.com/files/126068/hb_honeypot.pl.txt * __hex2bin 1.0.7__ Converts Motorola and Intel hex files to binary. http://hex2bin.sourceforge.net/ * __hexinject 1.5__ A very versatile packet injector and sniffer that provides a command-line framework for raw network access. http://hexinject.sourceforge.net * __hexorbase 6__ A database application designed for administering and auditing multiple database servers simultaneously from a centralized location. It is capable of performing SQL queries and bruteforce attacks against common database servers (MySQL, SQLite, Microsoft SQL Server, Oracle, PostgreSQL). https://code.google.com/p/hexorbase/ * __hharp 1beta__ This tool can perform man-in-the-middle and switch flooding attacks. It has 4 major functions, 3 of which attempt to man-in-the-middle one or more computers on a network with a passive method or flood type method. http://packetstormsecurity.com/files/81368/Hackers-Hideaway-ARP-Attack-Tool.html * __hidattack 0.1__ HID Attack (attacking HID host implementations) http://mulliner.org/bluetooth/hidattack.php * __honeyd 1.6.7__ A small daemon that creates virtual hosts on a network. https://github.com/DataSoft/Honeyd/ * __honssh 47.0de60ec__ A high-interaction Honey Pot solution designed to log all SSH communications between a client and server. https://code.google.com/p/honssh/ * __hookanalyser 3.0__ A hook tool which can be potentially helpful in reversing applications and analyzing malware. It can hook to an API in a process and search for a pattern in memory or dump the buffer. http://hookanalyser.blogspot.de/ * __host-extract 9__ Ruby script tries to extract all IP/Host patterns in page response of a given URL and JavaScript/CSS files of that URL. https://code.google.com/p/host-extract/ * __hostbox-ssh 0.1.1__ A ssh password/account scanner. http://stridsmanit.wordpress.com/2012/12/02/brute-forcing-passwords-with-hostbox-ssh-1-1/ * __hotpatch 0.2__ Hot patches executables on Linux using .so file injection http://www.selectiveintellect.com/hotpatch.html * __hotspotter 0.4___ Hotspotter passively monitors the network for probe request frames to identify the preferred networks of Windows XP clients, and will compare it to a supplied list of common hotspot network names. http://www.remote-exploit.org/?page_id=418 * __hpfeeds__ 138.249b2f7 Honeynet Project generic authenticated datafeed protocol. https://github.com/rep/hpfeeds * __hping 3.0.0__ A command-line oriented TCP/IP packet assembler/analyzer. http://www.hping.org * __hqlmap 35.081395e__ A tool to exploit HQL Injections. https://github.com/PaulSec/HQLmap * __htexploit 0.77__ A Python script that exploits a weakness in the way that .htaccess files can be configured to protect a web directory with an authentication process http://www.mkit.com.ar/labs/htexploit/ * __htrosbif 134.9dc3f86__ Active HTTP server fingerprinting and recon tool. https://github.com/lkarsten/htrosbif * __htshells 760b5e9__ Self contained web shells and other attacks via .htaccess files. https://github.com/wireghoul/htshells * __http-enum 0.3__ A tool to enumerate the enabled HTTP methods supported on a webserver. https://www.thexero.co.uk/tools/http-enum/ * __http-fuzz 0.1__ A simple http fuzzer. none * __http-put 1.0__ Simple http put perl script * __http-traceroute 0.5__ This is a python script that uses the Max-Forwards header in HTTP and SIP to perform a traceroute-like scanning functionality. http://packetstormsecurity.com/files/107167/Traceroute-Like-HTTP-Scanner.html * __httpbog 1.0.0.0__ A slow HTTP denial-of-service tool that works similarly to other attacks, but rather than leveraging request headers or POST data Bog consumes sockets by slowly reading responses. http://sourceforge.net/projects/httpbog/ * __httpforge 11.02.01__ A set of shell tools that let you manipulate, send, receive, and analyze HTTP messages. These tools can be used to test, discover, and assert the security of Web servers, apps, and sites. An accompanying Python library is available for extensions. http://packetstormsecurity.com/files/98109/HTTPForge.02.01.html * __httping 2.3.4__ A 'ping'-like tool for http-requests. http://www.vanheusden.com/httping/ * __httprint 301__ A web server fingerprinting tool. http://www.net-square.com/httprint.html * __httprint-win32__ 301 A web server fingerprinting tool (Windows binaries). http://net-square.com/httprint * __httpry 0.1.8__ A specialized packet sniffer designed for displaying and logging HTTP traffic. http://dumpsterventures.com/jason/httpry/ * __httpsniff 0.4__ Tool to sniff HTTP responses from TCP/IP based networks and save contained files locally for later review. http://www.sump.org/projects/httpsniff/ * __httpsscanner 1.2__ A tool to test the strength of a SSL web server. https://code.google.com/p/libre-tools/ * __httptunnel 3.3__ Creates a bidirectional virtual data connection tunnelled in HTTP requests http://www.nocrew.org/software/httptunnel * __hulk 11.a9b9ad4__ A webserver DoS tool (Http Unbearable Load King) ported to Go with some additional features. https://github.com/grafov/hulk * __hwk 0.4__ Collection of packet crafting and wireless network flooding tools http://www.nullsecurity.net/ * __hydra 8.1__ A very fast network logon cracker which support many different services. http://www.thc.org/thc-hydra/ * __hyenae 0.36_1__ flexible platform independent packet generator http://sourceforge.net/projects/hyenae/ * __hyperion 1.1__ A runtime encrypter for 32-bit portable executables. http://nullsecurity.net/tools/binary.html * __iaxflood 0.1__ IAX flooder. http://www.hackingexposedvoip.com/ * __iaxscan 0.02__ A Python based scanner for detecting live IAX/2 hosts and then enumerating (by bruteforce) users on those hosts. http://code.google.com/p/iaxscan/ * __ibrute 12.3a6a11e__ An AppleID password bruteforce tool. It uses Find My Iphone service API, where bruteforce protection was not implemented. https://github.com/hackappcom/ibrute/ * __icmpquery 1.0__ Send and receive ICMP queries for address mask and current time. http://www.angio.net/security/ * __icmptx 0.01__ IP over ICMP http://thomer.com/icmptx/ * __iheartxor 0.01__ iheartxor is a tool for bruteforcing encoded strings within a boundary defined by a regular expression. It will bruteforce the key value range of 0x1 through 0x255. http://hooked-on-mnemonics.blogspot.com.es/p/iheartxor.html * __ike-scan 1.9__ A tool that uses IKE protocol to discover, fingerprint and test IPSec VPN servers http://www.nta-monitor.com/tools/ike-scan/ * __ikecrack 1.00__ An IKE/IPSec crack tool designed to perform Pre-Shared-Key analysis of RFC compliant aggressive mode authentication http://sourceforge.net/projects/ikecrack/ * __ikeprobe 0.1__ Determine vulnerabilities in the PSK implementation of the VPN server. http://www.ernw.de/download/ikeprobe.zip * __ikeprober 1.12__ Tool crafting IKE initiator packets and allowing many options to be manually set. Useful to find overflows, error conditions and identifiyng vendors http://ikecrack.sourceforge.net/ * __ilty 1.0__ An interception phone system for VoIP network. http://chdir.org/~nico/ilty/ * __imagejs 48.1faf262__ Small tool to package javascript into a valid image file. https://github.com/jklmnn/imagejs * __inception 416.2e7b723__ A FireWire physical memory manipulation and hacking tool exploiting IEEE 1394 SBP DMA. http://www.breaknenter.org/projects/inception/ * __indxparse 150.1b50750__ A Tool suite for inspecting NTFS artifacts. http://www.williballenthin.com/forensics/mft/indxparse/ * __inetsim 1.2.5__ A software suite for simulating common internet services in a lab environment, e.g. for analyzing the network behaviour of unknown malware samples. http://www.inetsim.org * __infip 0.1__ A python script that checks output from netstat against RBLs from Spamhaus. http://packetstormsecurity.com/files/104927/infIP.1-Blacklist-Checker.html * __inguma 0.1.1__ A free penetration testing and vulnerability discovery toolkit entirely written in python. Framework includes modules to discover hosts, gather information about, fuzz targets, brute force usernames and passwords, exploits, and a disassembler. http://inguma.sourceforge.net * __intercepter-ng 0.9.8__ A next generation sniffer including a lot of features: capturing passwords/hashes, sniffing chat messages, performing man-in-the-middle attacks, etc. http://intercepter.nerf.ru/#down * __interrogate 0.0.4__ A proof-of-concept tool for identification of cryptographic keys in binary material (regardless of target operating system), first and foremost for memory dump analysis and forensic usage. https://github.com/carmaa/interrogate * __intersect 2.5__ Post-exploitation framework https://github.com/ohdae/Intersect.5 * __intrace 1.5__ Traceroute-like application piggybacking on existing TCP connections http://intrace.googlecode.com * __inundator 0.5__ An ids evasion tool, used to anonymously inundate intrusion detection logs with false positives in order to obfuscate a real attack. http://inundator.sourceforge.net/ * __inviteflood 2.0__ Flood a device with INVITE requests https://launchpad.net/~wagungs/+archive/kali-linux/+build/4386635 * __iodine 0.7.0__ Tunnel IPv4 data through a DNS server http://code.kryo.se/iodine * __iosforensic 1.0__ iOS forensic tool https://www.owasp.org/index.php/Projects/OWASP_iOSForensic https://github.com/Flo354/iOSForensic * __ip-https-tools 5.b22e2b3__ Tools for the IP over HTTPS (IP-HTTPS) Tunneling Protocol. https://github.com/takeshixx/ip-https-tools * __ipaudit 1.0BETA2__ IPAudit monitors network activity on a network. http://ipaudit.sourceforge.net * __ipba2 032013__ IOS Backup Analyzer http://www.ipbackupanalyzer.com/ * __ipdecap 69.f3a08f6__ Can decapsulate traffic encapsulated within GRE, IPIP, 6in4, ESP (ipsec) protocols, and can also remove IEEE 802.1Q (virtual lan) header. http://www.loicp.eu/ipdecap#dependances * __iphoneanalyzer 2.1.0__ Allows you to forensically examine or recover date from in iOS device. http://www.crypticbit.com/zen/products/iphoneanalyzer * __ipscan 3.3.2__ Angry IP scanner is a very fast IP address and port scanner. http://www.angryziber.com/ * __iputils 20121221__ Network monitoring tools, including ping http://www.skbuff.net/iputils/ * __ipv6toolkit 2.0beta__ SI6 Networks' IPv6 Toolkit http://www.si6networks.com/tools/ipv6toolkit/ * __ircsnapshot 93.9ba3c6c__ Tool to gather information from IRC servers. https://github.com/bwall/ircsnapshot * __irpas 0.10__ Internetwork Routing Protocol Attack Suite. http://phenoelit-us.org/irpas * __isr-form 1.0__ Simple html parsing tool that extracts all form related information and generates reports of the data. Allows for quick analyzing of data. http://www.infobyte.com.ar/ * __jad 1.5.8e__ Java decompiler http://www.varaneckas.com/jad * __javasnoop 1.1__ A tool that lets you intercept methods, alter data and otherwise hack Java applications running on your computer https://code.google.com/p/javasnoop/ * __jboss-autopwn 1.3bc2d29__ A JBoss script for obtaining remote shell access. https://github.com/SpiderLabs/jboss-autopwn * __jbrofuzz 2.5__ Web application protocol fuzzer that emerged from the needs of penetration testing. http://sourceforge.net/projects/jbrofuzz/ * __jbrute 0.99__ Open Source Security tool to audit hashed passwords. http://sourceforge.net/projects/jbrute/ * __jd-gui 0.3.5__ A standalone graphical utility that displays Java source codes of .class files http://java.decompiler.free.fr/?q=jdgui * __jhead 2.97__ EXIF JPEG info parser and thumbnail remover http://www.sentex.net/~mwandel/jhead/ * __jigsaw 1.3__ A simple ruby script for enumerating information about a company's employees. It is useful for Social Engineering or Email Phishing. https://github.com/pentestgeek/jigsaw * __jnetmap 0.5.3__ A network monitor of sorts http://www.rakudave.ch/jnetmap/?file=introduction * __john 1.7.9__ John The Ripper - A fast password cracker (jumbo included) http://www.openwall.com/john/ * __johnny 20120424__ GUI for John the Ripper. http://openwall.info/wiki/john/johnny * __jomplug 0.1__ This php script fingerprints a given Joomla system and then uses Packet Storm's archive to check for bugs related to the installed components. http://packetstormsecurity.com/files/121390/Janissaries-Joomla-Fingerprint-Tool.html * __joomlascan 1.2__ Joomla scanner scans for known vulnerable remote file inclusion paths and files. http://packetstormsecurity.com/files/62126/joomlascan.2.py.txt.html * __joomscan 2012.03.10__ Detects file inclusion, sql injection, command execution vulnerabilities of a target Joomla! web site. http://joomscan.sourceforge.net/ * __js-beautify 1.4.2__ This little beautifier will reformat and reindent bookmarklets, ugly JavaScript, unpack scripts packed by Dean Edward?s popular packer, as well as deobfuscate scripts processed by javascriptobfuscator.com. https://github.com/einars/js-beautify * __jsql__ 0.5 A lightweight application used to find database information from a distant server. https://code.google.com/p/jsql-injection/ * __junkie 1338.baa4524__ A modular packet sniffer and analyzer. https://github.com/securactive/junkie * __jwscan 6.b0306f0__ Scanner for Jar to EXE wrapper like Launch4j, Exe4j, JSmooth, Jar2Exe. https://github.com/katjahahn/JWScan * __jynx2 2.0__ An expansion of the original Jynx LD_PRELOAD rootkit http://www.blackhatlibrary.net/Jynx2 * __kalibrate-rtl 11.aae11c8__ Fork of http://thre.at/kalibrate/ for use with rtl-sdr devices. https://github.com/steve-m/kalibrate-rtl * __katsnoop 0.1__ Utility that sniffs HTTP Basic Authentication information and prints the base64 decoded form. http://packetstormsecurity.com/files/52514/katsnoop.tbz2.html * __kautilya 0.5.0__ Pwnage with Human Interface Devices using Teensy++2.0 and Teensy 3.0 devices http://code.google.com/p/kautilya * __keimpx 0.2__ Tool to verify the usefulness of credentials across a network over SMB. http://code.google.com/p/keimpx/ * __khc 0.2__ A small tool designed to recover hashed known_hosts fiels back to their plain-text equivalents. http://packetstormsecurity.com/files/87003/Known-Host-Cracker.2.html * __killerbee 85__ Framework and tools for exploiting ZigBee and IEEE 802.15.4 networks. https://code.google.com/p/killerbee/ * __kippo 0.9__ A medium interaction SSH honeypot designed to log brute force attacks and most importantly, the entire shell interaction by the attacker. https://github.com/desaster/kippo * __kismet 2013_03_R1b 802.11__ layer2 wireless network detector, sniffer, and intrusion detection system http://www.kismetwireless.net/ * __kismet-earth 0.1__ Various scripts to convert kismet logs to kml file to be used in Google Earth. http:// * __kismet2earth 1.0__ A set of utilities that convert from Kismet logs to Google Earth .kml format http://code.google.com/p/kismet2earth/ * __klogger 1.0__ A keystroke logger for the NT-series of Windows. http://ntsecurity.nu/toolbox/klogger/ * __kolkata 3.0__ A web application fingerprinting engine written in Perl that combines cryptography with IDS evasion. http://www.blackhatlibrary.net/Kolkata * __kraken 32.368a837__ A project to encrypt A5/1 GSM signaling using a Time/Memory Tradeoff Attack. http://opensource.srlabs.de/projects/a51-decrypt * __laf 12.7a456b3__ Login Area Finder: scans host/s for login panels. https://github.com/takeshixx/laf * __lanmap2 124.4f8afed__ Passive network mapping tool http://github.com/rflynn/lanmap2 * __lans 1.0__ A Multithreaded asynchronous packet parsing/injecting arp spoofer. https://github.com/DanMcInerney/LANs.py * __latd 1.31__ A LAT terminal daemon for Linux and BSD. http://sourceforge.net/projects/linux-decnet/files/latd/1.31/ * __laudanum 1.0__ A collection of injectable files, designed to be used in a pentest when SQL injection flaws are found and are in multiple languages for different environments. http://laudanum.inguardians.com/# * __lbd 20130719__ Load Balancing detector http://ge.mine.nu/code/lbd * __lbmap 145.93e6b71__ Proof of concept scripts for advanced web application fingerprinting, presented at OWASP AppSecAsia 2012. https://github.com/wireghoul/lbmap * __ldapenum 0.1__ Enumerate domain controllers using LDAP. https://gobag.googlecode.com/svn-history/r2/trunk/ldap/ldapenum/ * __leo 4.11__ Literate programmer's editor, outliner, and project manager http://webpages.charter.net/edreamleo/front.html * __leroy-jenkins 0.r3.bdc3965__ A python tool that will allow remote execution of commands on a Jenkins server and its nodes. https://github.com/captainhooligan/Leroy-Jenkins * __levye 85.419e817__ A brute force tool which is support sshkey, vnckey, rdp, openvpn. https://github.com/galkan/levye * __lfi-autopwn 3.0__ A Perl script to try to gain code execution on a remote server via LFI http://www.blackhatlibrary.net/Lfi_autopwn.pl * __lfi-exploiter 1.1__ This perl script leverages /proc/self/environ to attempt getting code execution out of a local file inclusion vulnerability.. http://packetstormsecurity.com/files/124332/LFI-Exploiter.1.html * __lfi-fuzzploit 1.1__ A simple tool to help in the fuzzing for, finding, and exploiting of local file inclusion vulnerabilities in Linux-based PHP applications. http://packetstormsecurity.com/files/106912/LFI-Fuzzploit-Tool.1.html * __lfi-scanner 4.0__ This is a simple perl script that enumerates local file inclusion attempts when given a specific target. http://packetstormsecurity.com/files/102848/LFI-Scanner.0.html * __lfi-sploiter 1.0__ This tool helps you exploit LFI (Local File Inclusion) vulnerabilities. Post discovery, simply pass the affected URL and vulnerable parameter to this tool. You can also use this tool to scan a URL for LFI vulnerabilities. http://packetstormsecurity.com/files/96056/Simple-Local-File-Inclusion-Exploiter.0.html * __lfimap 1.4.8__ This script is used to take the highest beneficts of the local file include vulnerability in a webserver. https://code.google.com/p/lfimap/ * __lft 3.72__ A layer four traceroute implementing numerous other features. http://pwhois.org/lft/ * __libdisasm 0.23__ A disassembler library. http://bastard.sourceforge.net/libdisasm.html * __libpst 0.6.63__ Outlook .pst file converter http://www.five-ten-sg.com/libpst/ * __liffy 63.238ce6d__ A Local File Inclusion Exploitation tool. https://github.com/rotlogix/liffy * __linenum 18.b4c2541__ Scripted Local Linux Enumeration & Privilege Escalation Checks https://github.com/rebootuser/LinEnum * __linux-exploit-suggester 32.9db2f5a__ A Perl script that tries to suggest exploits based OS version number. https://github.com/PenturaLabs/Linux_Exploit_Suggester * __list-urls 0.1__ Extracts links from webpage http://www.whoppix.net * __littleblackbox 0.1.3__ Penetration testing tool, search in a collection of thousands of private SSL keys extracted from various embedded devices. http://code.google.com/p/littleblackbox/wiki/FAQ * __lodowep 1.2.1__ Lodowep is a tool for analyzing password strength of accounts on a Lotus Domino webserver system. http://www.cqure.net/wp/lodowep/ * __logkeys 0.1.1a__ Simple keylogger supporting also USB keyboards. http://logkeys.googlecode.com/ * __loki 0.2.7___ Python based framework implementing many packet generation and attack modules for Layer 2 and 3 protocols http://c0decafe.de/loki.html * __lorcon 2.0.0.20091101__ Generic library for injecting 802.11 frames http://802.11ninja.net/ * __lotophagi 0.1__ a relatively compact Perl script designed to scan remote hosts for default (or common) Lotus NSF and BOX databases. http://packetstormsecurity.com/files/55250/lotophagi.rar.html * __lsrtunnel 0.2__ lsrtunnel spoofs connections using source routed packets. http://www.synacklabs.net/projects/lsrtunnel/ * __luksipc 0.01__ A tool to convert unencrypted block devices to encrypted LUKS devices in-place. http://www.johannes-bauer.com/linux/luksipc * __lynis 1.6.4__ An auditing tool for Unix (specialists). http://www.rootkit.nl/projects/lynis.html * __mac-robber 1.02__ A digital investigation tool that collects data from allocated files in a mounted file system. http://www.sleuthkit.org/mac-robber/download.php * __macchanger 1.6.0__ A small utility to change your NIC's MAC address http://ftp.gnu.org/gnu/macchanger * __maclookup 0.3__ Lookup MAC addresses in the IEEE MA-L/OUI public listing. https://github.com/paraxor/maclookup * __magicrescue 1.1.9__ Find and recover deleted files on block devices http://freshmeat.net/projects/magicrescue/ * __magictree 1.3__ A penetration tester productivity tool designed to allow easy and straightforward data consolidation, querying, external command execution and report generation http://www.gremwell.com * __make-pdf 0.1.5__ This tool will embed javascript inside a PDF document. http://blog.didierstevens.com/programs/pdf-tools/ * __makepasswd 1.10_9__ Generates true random passwords with the emphasis on security over pronounceability (Debian version) http://packages.qa.debian.org/m/makepasswd.html * __malheur 0.5.4__ A tool for the automatic analyze of malware behavior. http://www.mlsec.org/malheur/ * __maligno 1.2__ An open source penetration testing tool written in python, that serves Metasploit payloads. It generates shellcode with msfvenom and transmits it over HTTP or HTTPS. http://www.encripto.no/tools/ * __malmon 0.3__ Hosting exploit/backdoor detection daemon. It's written in python, and uses inotify (pyinotify) to monitor file system activity. It checks files smaller then some size, compares their md5sum and hex signatures against DBs with known exploits/backdoor. http://sourceforge.net/projects/malmon/ * __maltego 3.5.3__ An open source intelligence and forensics application, enabling to easily gather information about DNS, domains, IP addresses, websites, persons, etc. http://www.paterva.com/web5 * __maltrieve 148.4ad4045__ Originated as a fork of mwcrawler. It retrieves malware directly from the sources as listed at a number of sites. https://github.com/technoskald/maltrieve * __malware-check-tool 1.2__ Python script that detects malicious files via checking md5 hashes from an offline set or via the virustotal site. It has http proxy support and an update feature. http://packetstormsecurity.com/files/93518/Malware-Check-Tool.2.html * __malwareanalyser 3.3__ A freeware tool to perform static and dynamic analysis on malware. http://malwareanalyser.blogspot.de/2011/10/malware-analyser.html * __malwaredetect 0.1__ Submits a file's SHA1 sum to VirusTotal to determine whether it is a known piece of malware http://www.virustotal.com * __malwasm 0.2__ Offline debugger for malware's reverse engineering. https://code.google.com/p/malwasm/ marc4dasm 6.f11860f This python-based tool is a disassembler for the Atmel MARC4 (a 4 bit Harvard micro). https://github.com/ApertureLabsLtd/marc4dasm * __maskprocessor 0.71__ A High-Performance word generator with a per-position configurable charset. http://hashcat.net/wiki/doku.php?id=maskprocessor * __masscan 391.a60cc70__ TCP port scanner, spews SYN packets asynchronously, scanning entire Internet in under 5 minutes. https://github.com/robertdavidgraham/masscan * __mat 0.5__ Metadata Anonymisation Toolkit composed of a GUI application, a CLI application and a library. https://mat.boum.org/ * __matahari 0.1.30__ A reverse HTTP shell to execute commands on remote machines behind firewalls. http://matahari.sourceforge.net * __mausezahn 0.40__ A free fast traffic generator written in C which allows you to send nearly every possible and impossible packet. http://www.perihel.at/sec/mz/ * __mbenum 1.5.0__ Queries the master browser for whatever information it has registered. http://www.cqure.net/wp/mbenum/ * __mboxgrep 0.7.9__ Mboxgrep is a small, non-interactive utility that scans mail folders for messages matching regular expressions. It does matching against basic and extended POSIX regular expressions, and reads and writes a variety of mailbox formats. http://mboxgrep.sourceforge.net * __md5deep 4.3__ Advanced checksum hashing tool http://md5deep.sourceforge.net * __mdbtools 0.7.1__ Utilities for viewing data and exporting schema from Microsoft Access Database files http://sourceforge.net/projects/mdbtools/ * __mdcrack 1.2__ MD4/MD5/NTLM1 hash cracker http://c3rb3r.openwall.net/mdcrack/ * __mdk3 6__ WLAN penetration tool http://homepages.tu-darmstadt.de/~p_larbig/wlan/ * __mdns-scan 0.5__ Scan mDNS/DNS-SD published services on the local network. * __medusa 2.1.1__ A speedy, massively parallel, modular, login brute-forcer for network. http://www.foofus.net/jmk/medusa/medusa.html * __melkor 1.0__ An ELF fuzzer that mutates the existing data in an ELF sample given to create orcs (malformed ELFs), however, it does not change values randomly (dumb fuzzing), instead, it fuzzes certain metadata with semi-valid values through the use of fuzzing rules (knowledge base). http://packetstormsecurity.com/files/127924/Melkor-ELF-Fuzzer.0.html * __memdump 1.01__ Dumps system memory to stdout, skipping over holes in memory maps. http://www.porcupine.org/forensics/tct.html * __memfetch 0.05b__ dumps any userspace process memory without affecting its execution http://lcamtuf.coredump.cx/ * __metacoretex 0.8.0__ MetaCoretex is an entirely JAVA vulnerability scanning framework for databases. http://metacoretex.sourceforge.net/ * __metagoofil 1.4b__ An information gathering tool designed for extracting metadata of public documents http://www.edge-security.com/metagoofil.php * __metasploit 29270.738fc78__ An open source platform that supports vulnerability research, exploit development and the creation of custom security tools representing the largest collection of quality-assured exploits. http://www.metasploit.com * __metoscan 05__ Tool for scanning the HTTP methods supported by a webserver. It works by testing a URL and checking the responses for the different requests. http://www.open-labs.org/ * __mfcuk 0.3.8__ MIFARE Classic Universal toolKit http://code.google.com/p/mfcuk/ * __mfoc 0.10.7__ Mifare Classic Offline Cracker http://code.google.com/p/mfoc/ * __mfsniffer 0.1__ A python script for capturing unencrypted TSO login credentials. http://packetstormsecurity.com/files/120802/MF-Sniffer-TN3270-Password-Grabber.html * __mibble 2.9.3__ Mibble is an open-source SNMP MIB parser (or SMI parser) written in Java. It can be used to read SNMP MIB files as well as simple ASN.1 files. http://www.mibble.org/ * __middler 1.0__ A Man in the Middle tool to demonstrate protocol middling attacks. http://code.google.com/p/middler/ * __minimysqlator 0.5__ A multi-platform application used to audit web sites in order to discover and exploit SQL injection vulnerabilities. http://www.scrt.ch/en/attack/downloads/mini-mysqlat0r * __miranda-upnp 1.3__ A Python-based Universal Plug-N-Play client application designed to discover, query and interact with UPNP devices http://code.google.com/p/miranda-upnp/ * __miredo 1.2.6__ Teredo client and server. http://www.remlab.net/miredo/ * __missidentify 1.0__ A program to find Win32 applications http://missidentify.sourceforge.net/ * __missionplanner 1.2.55__ A GroundControl Station for Ardupilot. https://code.google.com/p/ardupilot-mega/wiki/Mission * __mitmap 0.1__ Shell Script for launching a Fake AP with karma functionality and launches ettercap for packet capture and traffic manipulation. http://www.darkoperator.com/tools-and-scripts/ * __mitmer 22.b01c7fe__ A man-in-the-middle and phishing attack tool that steals the victim's credentials of some web services like Facebook. https://github.com/husam212/MITMer * __mitmf 169.83b4a93__ A Framework for Man-In-The-Middle attacks written in Python. https://github.com/byt3bl33d3r/MITMf * __mitmproxy 0.10.1__ SSL-capable man-in-the-middle HTTP proxy http://mitmproxy.org/ * __mkbrutus 1.0.2__ Password bruteforcer for MikroTik devices or boxes running RouterOS. http://mkbrutusproject.github.io/MKBRUTUS/ * __mobiusft 0.5.21__ An open-source forensic framework written in Python/GTK that manages cases and case items, providing an abstract interface for developing extensions. http://savannah.nongnu.org/projects/mobiusft * __modscan 0.1__ A new tool designed to map a SCADA MODBUS TCP based network. https://code.google.com/p/modscan/ * __moloch 0.9.2__ An open source large scale IPv4 full PCAP capturing, indexing and database system. https://github.com/aol/moloch * __monocle 1.0__ A local network host discovery tool. In passive mode, it will listen for ARP request and reply packets. In active mode, it will send ARP requests to the specific IP range. The results are a list of IP and MAC addresses present on the local network. http://packetstormsecurity.com/files/99823/Monocle-Host-Discovery-Tool.0.html * __morxbrute 1.01__ A customizable HTTP dictionary-based password cracking tool written in Perl http://www.morxploit.com/morxbrute/ * __morxcrack 1.2__ A cracking tool written in Perl to perform a dictionary-based attack on various hashing algorithm and CMS salted-passwords. http://www.morxploit.com/morxcrack/ * __mp3nema 0.4__ A tool aimed at analyzing and capturing data that is hidden between frames in an MP3 file or stream, otherwise noted as "out of band" data. http://packetstormsecurity.com/files/76432/MP3nema-Forensic-Analysis-Tool.html * __mptcp 1.9.0__ A tool for manipulation of raw packets that allows a large number of options. http://packetstormsecurity.com/files/119132/Mptcp-Packet-Manipulator.9.0.html * __mptcp-abuse 6.b0eeb27__ A collection of tools and resources to explore MPTCP on your network. Initially released at Black Hat USA 2014. https://github.com/Neohapsis/mptcp-abuse * __ms-sys 2.4.0__ A tool to write Win9x-.. master boot records (mbr) under linux - RTM! http://ms-sys.sourceforge.net/ * __mssqlscan 0.8.4__ A small multi-threaded tool that scans for Microsoft SQL Servers. http://www.cqure.net/wp/mssqlscan/ * __msvpwn 0.1.r23.g328921b__ Bypass Windows' authentication via binary patching. https://bitbucket.org/mrabault/msvpwn * __mtr 0.85__ Combines the functionality of traceroute and ping into one tool (CLI version) http://www.bitwizard.nl/mtr/ * __multiinjector 0.3__ Automatic SQL injection utility using a lsit of URI addresses to test parameter manipulation. http://chaptersinwebsecurity.blogspot.de/2008/11/multiinjector-v03-released.html * __multimac 1.0.3__ Multiple MACs on an adapter http://sourceforge.net/projects/multimac/ * __multitun 43.9804513__ Tunnel arbitrary traffic through an innocuous WebSocket. https://github.com/covertcodes/multitun * __mutator 51.164132d__ This project aims to be a wordlist mutator with hormones, which means that some mutations will be applied to the result of the ones that have been already done, resulting in something like: corporation -> C0rp0r4t10n_2012 https://bitbucket.org/alone/mutator/ * __mysql2sqlite 1.dd87f4__ Converts a mysqldump file into a Sqlite 3 compatible file https://gist.github.com/esperlu/943776 * __nacker 23.b67bb39__ A tool to circumvent 802.1x Network Access Control on a wired LAN. https://github.com/carmaa/nacker * __nbnspoof 1.0__ NBNSpoof - NetBIOS Name Service Spoofer http://www.mcgrewsecurity.com/tools/nbnspoof/ * __nbtenum 3.3__ A utility for Windows that can be used to enumerate NetBIOS information from one host or a range of hosts. http://reedarvin.thearvins.com/ * __nbtool 2.bf90c76__ Some tools for NetBIOS and DNS investigation, attacks, and communication. http://wiki.skullsecurity.org/Nbtool * __nbtscan 1.5.1__ NBTscan is a program for scanning IP networks for NetBIOS name information. http://www.inetcat.net/software/nbtscan.html * __ncpfs 2.2.6__ Allows you to mount volumes of NetWare servers under Linux. http://www.novell.com/ * __ncrack 0.4a__ A high-speed network authentication cracking tool http://nmap.org/ncrack/ * __nemesis 1.4__ command-line network packet crafting and injection utility http://nemesis.sourceforge.net/ * __netactview 0.6.2__ A graphical network connections viewer for Linux similar in functionality with Netstat http://netactview.sourceforge.net/index.html * __netbios-share-scanner 1.0__ This tool could be used to check windows workstations and servers if they have accessible shared resources. http://www.secpoint.com/netbios-share-scanner.html * __netcommander 1.3__ An easy-to-use arp spoofing tool. https://github.com/evilsocket/netcommander * __netcon 0.1__ A network connection establishment and management script. http://www.paramecium.org/~leendert/ * __netdiscover 0.3__ An active/passive address reconnaissance tool, mainly developed for those wireless networks without dhcp server, when you are wardriving. It can be also used on hub/switched networks. http://nixgeneration.com/~jaime/netdiscover/ * __netmap 0.1.3__ Can be used to make a graphical representation of the surounding network. http://netmap.sourceforge.net * __netmask 2.3.12__ Helps determine network masks http://packages.qa.debian.org/n/netmask.html * __netreconn 1.76__ A collection of network scan/recon tools that are relatively small compared to their larger cousins. http://packetstormsecurity.com/files/86076/NetReconn-Scanning-Tool-Collection.76.html * __netscan 1.0__ Tcp/Udp/Tor port scanner with: synpacket, connect TCP/UDP and socks5 (tor connection). http://packetstormsecurity.com/files/125569/Netscan-Port-Scanner.0.html * __netsed 1.2__ Small and handful utility design to alter the contents of packets forwarded thru network in real time. http://silicone.homelinux.org/projects/netsed/ * __netsniff-ng 0.5.8__ A high performance Linux network sniffer for packet inspection. http://netsniff-ng.org/ * __netzob 0.4.1__ An open source tool for reverse engineering, traffic generation and fuzzing of communication protocols. http://www.netzob.org/ * __nfcutils 0.3.2__ Provides a simple 'lsnfc' command that list tags which are in your NFC device field http://code.google.com/p/nfc-tools * __nfex 2.5__ A tool for extracting files from the network in real-time or post-capture from an offline tcpdump pcap savefile. It is based off of the code-base from the apparently defunct project tcpxtract. https://code.google.com/p/nfex/ * __nfspy 1.0__ A Python library for automating the falsification of NFS credentials when mounting an NFS share. https://github.com/bonsaiviking/NfSpy * __nfsshell 19980519__ Userland NFS command tool. http://www.paramecium.org/~leendert/ * __ngrep 1.45__ A grep-like utility that allows you to search for network packets on an interface. http://ngrep.sourceforge.net/ * __nield 0.5.1__ A tool to receive notifications from kernel through netlink socket, and generate logs related to interfaces, neighbor cache(ARP,NDP), IP address(IPv4,IPv6), routing, FIB rules, traffic control. http://nield.sourceforge.net/ * __nikto 2.1.5__ A web server scanner which performs comprehensive tests against web servers for multiple items http://www.cirt.net/nikto2 * __nimbostratus 54.c7c206f__ Tools for fingerprintinging and exploiting Amazon cloud infrastructures. https://github.com/andresriancho/nimbostratus * __nipper 0.11.7__ Network Infrastructure Parser https://www.titania-security.com/ * __nishang 0.4.0__ Using PowerShell for Penetration Testing. https://code.google.com/p/nishang/ * __nkiller2 2.0__ A TCP exhaustion/stressing tool. http://sock-raw.org/projects.html * __nmap 6.47__ Utility for network discovery and security auditing http://nmap.org/ * __nmbscan 1.2.6__ Tool to scan the shares of a SMB/NetBIOS network, using the NMB/SMB/NetBIOS protocols. http://nmbscan.gbarbier.org/ * __nomorexor 0.1__ Tool to help guess a files 256 byte XOR key by using frequency analysis https://github.com/hiddenillusion/NoMoreXOR * __notspikefile 0.1__ A Linux based file format fuzzing tool http://packetstormsecurity.com/files/39627/notSPIKEfile.tgz.html * __nsdtool 0.1__ A netgear switch discovery tool. It contains some extra features like bruteoforce and setting a new password. http://www.curesec.com/en/publications/tools.html * __nsec3walker 20101223__ Enumerates domain names using DNSSEC http://dnscurve.org/nsec3walker.html * __ntds-decode 0.1__ This application dumps LM and NTLM hashes from active accounts stored in an Active Directory database. http://packetstormsecurity.com/files/121543/NTDS-Hash-Decoder.b.html * __o-saft 513.6bcc35b__ A tool to show informations about SSL certificate and tests the SSL connection according given list of ciphers and various SSL configurations. https://www.owasp.org/index.php/O-Saft * __oat 1.3.1__ A toolkit that could be used to audit security within Oracle database servers. http://www.cqure.net/wp/test/ * __obexstress 0.1__ Script for testing remote OBEX service for some potential vulnerabilities. http://bluetooth-pentest.narod.ru/ * __obfsproxy 0.2.12__ A pluggable transport proxy written in Python. https://pypi.python.org/pypi/obfsproxy * __oclhashcat 1.30__ Worlds fastest WPA cracker with dictionary mutation engine. http://hashcat.net/oclhashcat/ * __ocs 0.2__ Compact mass scanner for Cisco routers with default telnet/enable passwords. http://packetstormsecurity.com/files/119462/OCS-Cisco-Scanner.2.html * __ohrwurm 0.1__ A small and simple RTP fuzzer. http://mazzoo.de/ * __ollydbg 201g__ A 32-bit assembler-level analysing debugger http://www.ollydbg.de * __onesixtyone 0.7__ An SNMP scanner that sends multiple SNMP requests to multiple IP addresses http://labs.portcullis.co.uk/application/onesixtyone/ * __onionshare 439.027d774__ Securely and anonymously share a file of any size. https://github.com/micahflee/onionshare/ * __openstego 0.6.1__ A tool implemented in Java for generic steganography, with support for password-based encryption of the data. http://www.openstego.info/ * __opensvp 64.56b2b8f__ A security tool implementing "attacks" to be able to the resistance of firewall to protocol level attack. https://github.com/regit/opensvp * __openvas-cli 1.3.1__ The OpenVAS Command-Line Interface http://www.openvas.org/ * __openvas-libraries 7.0.6__ The OpenVAS libraries http://www.openvas.org/ * __openvas-manager 5.0.7__ A layer between the OpenVAS Scanner and various client applications http://www.openvas.org/ * __openvas-scanner 4.0.5__ The OpenVAS scanning Daemon http://www.openvas.org/ * __ophcrack 3.6.0__ A free Windows password cracker based on rainbow tables http://ophcrack.sourceforge.net * __orakelcrackert 1.00__ This tool can crack passwords which are encrypted using Oracle's latest SHA1 based password protection algorithm. http://freeworld.thc.org/thc-orakelcrackert11g/ * __origami 1.2.7__ Aims at providing a scripting tool to generate and analyze malicious PDF files. http://code.google.com/p/origami-pdf * __oscanner 1.0.6__ An Oracle assessment framework developed in Java. http://www.cqure.net/wp/oscanner/ * __ostinato 0.5.1__ An open-source, cross-platform packet/traffic generator and analyzer with a friendly GUI. It aims to be "Wireshark in Reverse" and thus become complementary to Wireshark. http://code.google.com/p/ostinato/ * __osueta 65.90323e2__ A simple Python script to exploit the OpenSSH User Enumeration Timing Attack. https://github.com/c0r3dump3d/osueta * __owabf 1.3__ Outlook Web Access bruteforcer tool. http://netsec.rs/70/tools.html * __owasp-bywaf 26.e730d1b__ A web application penetration testing framework (WAPTF). https://github.com/depasonico/OWASP-ByWaf * __owtf 1016.fef357e__ The Offensive (Web) Testing Framework. https://www.owasp.org/index.php/OWASP_OWTF * __p0f 3.08b__ Purely passive TCP/IP traffic fingerprinting tool. http://lcamtuf.coredump.cx/p0f3/ * __pack 0.0.4__ Password Analysis and Cracking Kit http://thesprawl.org/projects/pack/ * __packerid 1.4__ Script which uses a PEiD database to identify which packer (if any) is being used by a binary. http://handlers.sans.org/jclausing/ * __packet-o-matic 351__ A real time packet processor. Reads the packet from an input module, match the packet using rules and connection tracking information and then send it to a target module. http://www.packet-o-matic.org/ * __packeth 1.7.2__ A Linux GUI packet generator tool for ethernet. http://packeth.sourceforge.net/ * __packit 1.0__ A network auditing tool. Its value is derived from its ability to customize, inject, monitor, and manipulate IP traffic. http://packit.sourceforge.net/ * __pacumen 1.92a0884__ Packet Acumen - Analyse encrypted network traffic and more (side-channel attacks). https://github.com/bniemczyk/pacumen * __padbuster 0.3.3__ Automated script for performing Padding Oracle attacks. http://www.gdssecurity.com/l/t.php * __paketto 1.10__ Advanced TCP/IP Toolkit. http://www.doxpara.com/paketto * __panoptic 178.73b2b4c__ A tool that automates the process of search and retrieval of content for common log and config files through LFI vulnerability. https://github.com/lightos/Panoptic * __paros 3.2.13__ Java-based HTTP/HTTPS proxy for assessing web app vulnerabilities. Supports editing/viewing HTTP messages on-the-fly, spiders, client certificates, proxy-chaining, intelligent scanning for XSS and SQLi, etc. http://www.parosproxy.org * __parsero 56.fc5f7ec__ A robots.txt audit tool. https://github.com/behindthefirewalls/Parsero * __pasco 20040505_1__ Examines the contents of Internet Explorer's cache files for forensic purposes http://www.jonesdykstra.com/ * __passcracking 20131214__ A little python script for sending hashes to passcracking.com and milw0rm http://github.com/jensp/passcracking * __passe-partout 0.1__ Tool to extract RSA and DSA private keys from any process linked with OpenSSL. The target memory is scanned to lookup specific OpenSSL patterns. http://www.hsc.fr/ressources/outils/passe-partout/index.html.en * __passivedns 1.1.3__ A network sniffer that logs all DNS server replies for use in a passive DNS setup. https://github.com/gamelinux/passivedns * __pastenum 0.4.1__ Search Pastebins for content, fork from nullthreat corelan pastenum2 http://github.com/shadowbq/pastenum * __patator 80.5a140c1__ A multi-purpose bruteforcer. https://github.com/lanjelot/patator * __pathod 0.11.1__ Crafted malice for tormenting HTTP clients and servers. http://pathod.net/ * __pblind 1.0__ Little utility to help exploiting blind sql injection vulnerabilities. http://www.edge-security.com/pblind.php * __pcapsipdump 0.2__ A tool for dumping SIP sessions (+RTP traffic, if available) to disk in a fashion similar to 'tcpdump -w' (format is exactly the same), but one file per sip session (even if there is thousands of concurrect SIP sessions). http://pcapsipdump.sourceforge.net/ * __pcredz 0.9__ A tool that extracts credit card numbers, NTLM(DCE-RPC, HTTP, SQL, LDAP, etc), Kerberos (AS-REQ Pre-Auth etype 23), HTTP Basic, SNMP, POP, SMTP, FTP, IMAP, and more from a pcap file or from a live interface. https://github.com/lgandx/PCredz * __pdf-parser 0.4.2__ Parses a PDF document to identify the fundamental elements used in the analyzed file http://blog.didierstevens.com/programs/pdf-tools/ * __pdfbook-analyzer 2__ Utility for facebook memory forensics. http://sourceforge.net/projects/pdfbook/ * __pdfcrack 0.12__ Password recovery tool for PDF-files. http://pdfcrack.sourceforge.net/ * __pdfid 0.1.2__ scan a file to look for certain PDF keywords http://blog.didierstevens.com/programs/pdf-tools/ * __pdfresurrect 0.12__ A tool aimed at analyzing PDF documents. http://packetstormsecurity.com/files/118459/PDFResurrect-PDF-Analyzer.12.html * __pdgmail 1.0__ A password dictionary attack tool that targets windows authentication via the SMB protocol http://www.jeffbryner.com/code/pdgmail * __peach 3.0.202__ A SmartFuzzer that is capable of performing both generation and mutation based fuzzing http://peachfuzzer.com/ * __peda 51.327db44__ Python Exploit Development Assistance for GDB. https://github.com/longld/peda * __peepdf 0.3__ A Python tool to explore PDF files in order to find out if the file can be harmful or not http://eternal-todo.com/tools/peepdf-pdf-analysis-tool * __pentbox 1.8__ A security suite that packs security and stability testing oriented tools for networks and systems. http://www.pentbox.net * __perl-image-exiftool 9.76__ Reader and rewriter of EXIF informations that supports raw files http://search.cpan.org/perldoc?exiftool * __perl-tftp 1.0b3__ TFTP - TFTP Client class for perl http://search.cpan.org/~gsm/TFTP/TFTP.pm * __pev 0.60__ Command line based tool for PE32/PE32+ file analysis http://pev.sourceforge.net/ * __pextractor 0.18b__ A forensics tool that can extract all files from an executable file created by a joiner or similar. http://packetstormsecurity.com/files/62977/PExtractor_v0.18b_binary_and_src.rar.html * __pgdbf 94.baa1d95__ Convert XBase / FoxPro databases to PostgreSQL https://github.com/kstrauser/pgdbf * __phoss 0.1.13__ Sniffer designed to find HTTP, FTP, LDAP, Telnet, IMAP4, VNC and POP3 logins. http://www.phenoelit.org/fr/tools.html * __php-mt-seed 3.2__ PHP mt_rand() seed cracker http://www.openwall.com/php_mt_seed/ * __php-rfi-payload-decoder 30.bd42caa__ Decode and analyze RFI payloads developed in PHP. https://github.com/bwall/PHP-RFI-Payload-Decoder * __php-vulnerability-hunter 1.4.0.20__ An whitebox fuzz testing tool capable of detected several classes of vulnerabilities in PHP web applications. https://phpvulnhunter.codeplex.com/ * __phpstress 5.f987a7e__ A PHP denial of service / stress test for Web Servers running PHP-FPM or PHP-CGI. https://github.com/nightlionsecurity/phpstress * __phrasendrescher 1.2.2__ A modular and multi processing pass phrase cracking tool http://www.leidecker.info/projects/phrasendrescher/ * __pipal 1.1__ A password analyser http://www.digininja.org/projects/pipal.php * __pirana 0.3.1__ Exploitation framework that tests the security of a email content filter. http://www.guay-leroux.com/projects.html * __plcscan 0.1__ This is a tool written in Python that will scan for PLC devices over s7comm or modbus protocols. http://packetstormsecurity.com/files/119726/PLC-Device-Scanner.html * __plecost 2__ Wordpress finger printer tool search and retrieve information about the plugins versions installed in Wordpress systems. http://code.google.com/p/plecost/ * __plown 13.ccf998c__ A security scanner for Plone CMS. https://github.com/unweb/plown * __pmcma 1.00__ Automated exploitation of invalid memory writes (being them the consequences of an overflow in a writable section, of a missing format string, integer overflow, variable misuse, or any other type of memory corruption). http://packetstormsecurity.com/files/104724/Post-Memory-Corruption-Memory-Analyzer.00.html * __pnscan 1.11__ A parallel network scanner that can be used to survey TCP network services. http://www.lysator.liu.se/~pen/pnscan/ * __pompem 69.b2569c4__ A python exploit tool finder. https://github.com/rfunix/Pompem * __portspoof 100.70b6bf2__ This program's primary goal is to enhance OS security through a set of new techniques. http://portspoof.org/ * __posttester 0.1__ A jar file that will send POST requests to servers in order to test for the hash collision vulnerability discussed at the Chaos Communication Congress in Berlin. http://packetstormsecurity.com/files/109010/MagicHash-Collision-Testing-Tool.html * __powerfuzzer 1_beta__ Powerfuzzer is a highly automated web fuzzer based on many other Open Source fuzzers available (incl. cfuzzer, fuzzled, fuzzer.pl, jbrofuzz, webscarab, wapiti, Socket Fuzzer). It can detect XSS, Injections (SQL, LDAP, commands, code, XPATH) and others. http://www.powerfuzzer.com * __powersploit 239.dc1a5e5__ A PowerShell Post-Exploitation Framework. https://github.com/mattifestation/PowerSploit * __praeda 37.093d1c0__ An automated data/information harvesting tool designed to gather critical information from various embedded devices. https://github.com/percx/Praeda * __prometheus 175.497b2ce__ A Firewall analyzer written in ruby https://github.com/averagesecurityguy/prometheus * __propecia 2__ A fast class scanner that scans for a specified open port with banner grabbing http://www.redlevel.org * __protos-sip 2__ SIP test suite. https://www.ee.oulu.fi/research/ouspg/PROTOS_Test-Suite_c07-sip * __proxychains-ng 4.8.1__ A hook preloader that allows to redirect TCP traffic of existing dynamically linked programs through one or more SOCKS or HTTP proxies https://github.com/rofl0r/proxychains * __proxycheck 0.1__ This is a simple proxy tool that checks for the HTTP CONNECT method and grabs verbose output from a webserver. http://packetstormsecurity.com/files/61864/proxycheck.pl.txt.html * __proxyp 2013__ Small multithreaded Perl script written to enumerate latency, port numbers, server names, & geolocations of proxy IP addresses. http://sourceforge.net/projects/proxyp/ * __proxyscan 0.3__ A security penetration testing tool to scan for hosts and ports through a Web proxy server. http://packetstormsecurity.com/files/69778/proxyScan.3.tgz.html * __proxytunnel 1.9.0__ a program that connects stdin and stdout to a server somewhere on the network, through a standard HTTPS proxy http://proxytunnel.sourceforge.net * __pscan 1.3__ A limited problem scanner for C source files http://deployingradius.com/pscan/ * __pshitt 21.85cde65__ A lightweight fake SSH server designed to collect authentication data sent by intruders. https://github.com/regit/pshitt * __pstoreview 1.0__ Lists the contents of the Protected Storage. http://www.ntsecurity.nu/toolbox/pstoreview/ * __ptunnel 0.72__ A tool for reliably tunneling TCP connections over ICMP echo request and reply packets http://www.cs.uit.no/~daniels/PingTunnel/#download * __pwd-hash 2.0__ A password hashing tool that use the crypt function to generate the hash of a string given on standard input. http://vladz.devzero.fr/pwd-hash.php * __pwdump 7.1__ Extracts the binary SAM and SYSTEM file from the filesystem and then the hashes. http://www.tarasco.org/security/pwdump_7/index.html * __pwnat 0.3__ A tool that allows any number of clients behind NATs to communicate with a server behind a separate NAT with *no* port forwarding and *no* DMZ setup on any routers in order to directly communicate with each other http://samy.pl/pwnat/ * __pwntools 2.1.3__ The CTF framework used by #Gallopsled in every CTF. https://github.com/Gallopsled/pwntools * __pyew 2.3.0__ A python tool to analyse malware. https://code.google.com/p/pyew/ * __pyfiscan 1015.072ce1e__ Free web-application vulnerability and version scanner. https://github.com/fgeek/pyfiscan * __pyinstaller 2.1__ A program that converts (packages) Python programs into stand-alone executables, under Windows, Linux, Mac OS X, Solaris and AIX. http://www.pyinstaller.org/ * __pyminifakedns 0.1__ Minimal DNS server written in Python; it always replies with a 127.0.0.1 A-record http://code.activestate.com/recipes/491264/ * __pyrasite 2.0__ Code injection and introspection of running Python processes. http://pyrasite.com/ * __pyrit 0.4.0__ WPA/WPA2-PSK attacking with gpu and cluster http://code.google.com/p/pyrit * __pytacle alpha2__ Automates the task of sniffing GSM frames http://packetstormsecurity.com/files/124299/pytacle-alpha2.tar.gz * __pytbull 2.0__ A python based flexible IDS/IPS testing framework shipped with more than 300 tests http://pytbull.sourceforge.net/ * __python-utidylib 0.2__ Python bindings for Tidy HTML parser/cleaner. http://utidylib.berlios.de * __python2-binaryornot 0.3.0__ Ultra-lightweight pure Python package to check if a file is binary or text. https://github.com/audreyr/binaryornot * __python2-yara 3.2.0__ A malware identification and classification tool. https://github.com/plusvic/yara * __quickrecon 0.3.2__ A python script for simple information gathering. It attempts to find subdomain names, perform zone transfers and gathers emails from Google and Bing. http://packetstormsecurity.com/files/104314/QuickRecon.3.2.html radamsa 0.3 General purpose data fuzzer. https://code.google.com/p/ouspg/wiki/Radamsa radare2 0.9.8 Open-source tools to disasm, debug, analyze and manipulate binary files. http://radare.org/ radiography 2 A forensic tool which grabs as much information as possible from a Windows system. http://www.security-projects.com/?RadioGraPhy rainbowcrack 1.2 Password cracker based on the faster time-memory trade-off. With MySQL and Cisco PIX Algorithm patches. http://project-rainbowcrack.com/ rarcrack 0.2 This program uses bruteforce algorithm to find correct password (rar, 7z, zip). http://rarcrack.sourceforge.net/ ratproxy 1.58 A passive web application security assessment tool http://code.google.com/p/ratproxy/ rawr 42.ff1bfa1 Rapid Assessment of Web Resources. A web enumerator. https://bitbucket.org/al14s/rawr/wiki/Home rcracki-mt 0.7.0 A tool to perform rainbow table attacks on password hashes. It is intended for indexed/perfected rainbow tables, mainly generated by the distributed project www.freerainbowtables.com http://rcracki.sourceforge.net/ rdesktop-brute 1.5.0 It connects to windows terminal servers - Bruteforce patch included. http://www.rdesktop.org/ reaver 1.4 Implements a brute force attack against wifi protected setup WPS registrar PINs in order to recover WPA/WPA2 passphrases http://code.google.com/p/reaver-wps rebind 0.3.4 DNS Rebinding Tool http://code.google.com/p/rebind/ recon-ng 885.f42ffbe A full-featured Web Reconnaissance framework written in Python. https://bitbucket.org/LaNMaSteR53/recon-ng recoverjpeg 2.2.2 Recover jpegs from damaged devices. http://www.rfc1149.net/devel/recoverjpeg recstudio 4.0_20130717 Cross platform interactive decompiler http://www.backerstreet.com/rec/rec.htm redfang 2.5 Finds non-discoverable Bluetooth devices by brute-forcing the last six bytes of the devices' Bluetooth addresses and calling read_remote_name(). http://packetstormsecurity.com/files/31864/redfang.2.5.tar.gz.html redirectpoison 1.1 A tool to poison a targeted issuer of SIP INVITE requests with 301 (i.e. Moved Permanently) redirection responses. http://www.hackingexposedvoip.com/ regeorg 26.22fb8a9 The successor to reDuh, pwn a bastion webserver and create SOCKS proxies through the DMZ. Pivot and pwn. https://github.com/sensepost/reGeorg reglookup 1.0.1 Command line utility for reading and querying Windows NT registries http://projects.sentinelchicken.org/reglookup relay-scanner 1.7 An SMTP relay scanner. http://www.cirt.dk replayproxy 1.1 Forensic tool to replay web-based attacks (and also general HTTP traffic) that were captured in a pcap file. https://code.google.com/p/replayproxy/ responder 117.6c7a5dd A LLMNR and NBT-NS poisoner, with built-in HTTP/SMB/MSSQL/FTP/LDAP rogue authentication server supporting NTLMv1/NTLMv2/LMv2, Extended Security NTLMSSP and Basic HTTP authentication. https://github.com/SpiderLabs/Responder/ rfcat 130515 RF ChipCon-based Attack Toolset http://code.google.com/p/rfcat rfdump 1.6 A back-end GPL tool to directly inter-operate with any RFID ISO-Reader to make the contents stored on RFID tags accessible http://www.rfdump.org rfidiot e302bb7 An open source python library for exploring RFID devices. http://rfidiot.org/ rfidtool 0.01 A opensource tool to read / write rfid tags http://www.bindshell.net/tools/rfidtool.html ridenum 39.ebbfaca A null session RID cycle attack for brute forcing domain controllers. https://github.com/trustedsec/ridenum rifiuti2 0.5.1 A rewrite of rifiuti, a great tool from Foundstone folks for analyzing Windows Recycle Bin INFO2 file. https://code.google.com/p/rifiuti2/ rinetd 0.62 internet redirection server http://www.boutell.com/rinetd ripdc 0.2 A script which maps domains related to an given ip address or domainname. http://nullsecurity.net/tools/scanner rkhunter 1.4.2 Checks machines for the presence of rootkits and other unwanted tools. http://rkhunter.sourceforge.net/ rlogin-scanner 0.2 Multithreaded rlogin scanner. Tested on Linux, OpenBSD and Solaris. http://wayreth.eu.org/old_page/ rootbrute 0.1 Local root account bruteforcer. http://www.packetstormsecurity.org/ ropeadope 1.1 A linux log cleaner. http://www.highhacksociety.com/ ropeme 1.0 ROPME is a set of python scripts to generate ROP gadgets and payload. http://www.vnsecurity.net/2010/08/ropeme-rop-exploit-made-easy/ ropgadget 5.3 Lets you search your gadgets on your binaries (ELF format) to facilitate your ROP exploitation. https://github.com/JonathanSalwan/ROPgadget ropper 91.212d5da It can show information about files in different file formats and you can find gadgets to build rop chains for different architectures. For disassembly ropper uses the awesome Capstone Framework. https://github.com/sashs/Ropper rpdscan 2.a71b0f3 Remmina Password Decoder and scanner. https://github.com/freakyclown/RPDscan rrs 1.70 A reverse (connecting) remote shell. Instead of listening for incoming connections it will connect out to a listener (rrs in listen mode). With tty support and more. http://www.cycom.se/dl/rrs rsakeyfind 1.0 A tool to find RSA key in RAM. http://citp.princeton.edu/memory/code/ rsmangler 1.4 rsmangler takes a wordlist and mangle it http://www.randomstorm.com/rsmangler-security-tool.php rtlsdr-scanner 856.a47ba2e A cross platform Python frequency scanning GUI for the OsmoSDR rtl-sdr library. https://github.com/EarToEarOak/RTLSDR-Scanner rtp-flood 1.0 RTP flooder http://www.hackingexposedvoip.com/ rtpbreak 1.3a Detects, reconstructs and analyzes any RTP session http://xenion.antifork.org/rtpbreak/ rubilyn 0.0.1 64bit Mac OS-X kernel rootkit that uses no hardcoded address to hook the BSD subsystem in all OS-X Lion & below. It uses a combination of syscall hooking and DKOM to hide activity on a host. http://nullsecurity.net/tools/backdoor.html ruby-msgpack 0.5.8 MessagePack, a binary-based efficient data interchange format. http://msgpack.org/ ruby-ronin 1.5.0 A Ruby platform for exploit development and security research. http://ronin-ruby.github.io/ ruby-ronin-support 0.5.1 A support library for Ronin. http://ronin-ruby.github.io/ ruby-uri-query_params 0.7.0 Access the query parameters of a URI, just like in PHP. http://github.com/postmodern/uri-query_params rww-attack 0.9.2 The Remote Web Workplace Attack tool will perform a dictionary attack against a live Microsoft Windows Small Business Server's 'Remote Web Workplace' portal. It currently supports both SBS 2003 and SBS 2008 and includes features to avoid account lock out. http://packetstormsecurity.com/files/79021/Remote-Web-Workplace-Attack-Tool.html safecopy 1.7 A disk data recovery tool to extract data from damaged media http://safecopy.sourceforge.net/ sakis3g 0.2.0e An all-in-one script for connecting with 3G http://www.sakis3g.org/ sambascan 0.5.0 Allows you to search an entire network or a number of hosts for SMB shares. It will also list the contents of all public shares that it finds. http://sourceforge.net/projects/sambascan2/ samdump2 3.0.0 Dump password hashes from a Windows NT/2k/XP installation http://sourceforge.net/projects/ophcrack/files/samdump2/ samydeluxe 2.2ed1bac Automatic samdump creation script. http://github.com/jensp/samydeluxe sandy 6.531ab16 An open-source Samsung phone encryption assessment framework https://github.com/donctl/sandy sasm 3.1.0 A simple crossplatform IDE for NASM, MASM, GAS and FASM assembly languages. https://github.com/Dman95/SASM sb0x 19.04f40fe A simple and Lightweight framework for Penetration testing. https://github.com/levi0x0/sb0x-project sbd 1.36 Netcat-clone, portable, offers strong encryption - features AES-CBC + HMAC-SHA1 encryption, program execution (-e), choosing source port, continuous reconnection with delay + more http://www2.packetstormsecurity.org/cgi-bin/search/search.cgi?searchvalue=sbd scalpel 2.0 A frugal, high performance file carver http://www.digitalforensicssolutions.com/Scalpel/ scanmem 0.13 A utility used to locate the address of a variable in an executing process. http://code.google.com/p/scanmem/ scanssh 2.1 Fast SSH server and open proxy scanner. http://www.monkey.org/~provos/scanssh/ scapy 2.2.0 A powerful interactive packet manipulation program written in Python http://www.secdev.org/projects/scapy/ schnappi-dhcp 0.1 schnappi can fuck network with no DHCP http://www.emanuelegentili.eu/ scout2 196.7cc58b4 Security auditing tool for AWS environments. http://isecpartners.github.io/Scout2/ scrapy 4419.c485a05 A fast high-level scraping and web crawling framework. http://www.scrapy.org/ scrounge-ntfs 0.9 Data recovery program for NTFS file systems http://memberwebs.com/stef/software/scrounge/ sctpscan 1.0 A network scanner for discovery and security http://www.p1sec.com/ seat 0.3 Next generation information digging application geared toward the needs of security professionals. It uses information stored in search engine databases, cache repositories, and other public resources to scan web sites for potential vulnerabilities. http://thesprawl.org/projects/search-engine-assessment-tool/ secscan 1.5 Web Apps Scanner and Much more utilities. http://code.google.com/p/secscan-py/ secure-delete 3.1 Secure file, disk, swap, memory erasure utilities. http://www.thc.org/ sees 67.cd741aa Increase the success rate of phishing attacks by sending emails to company users as if they are coming from the very same company's domain. https://github.com/galkan/sees/ sergio-proxy 0.2.1 A multi-threaded transparent HTTP proxy for manipulating web traffic https://github.com/darkoperator/dnsrecon sessionlist 1.0 Sniffer that intents to sniff HTTP packets and attempts to reconstruct interesting authentication data from websites that do not employ proper secure cookie auth. http://www.0xrage.com/ set 6.1.2 Social-engineer toolkit. Aimed at penetration testing around Social-Engineering https://www.trustedsec.com/downloads/social-engineer-toolkit sfuzz 0.7.0 A simple fuzzer. http://aconole.brad-x.com/programs/sfuzz.html shellcodecs 0.1 A collection of shellcode, loaders, sources, and generators provided with documentation designed to ease the exploitation and shellcode programming process. http://www.blackhatlibrary.net/Shellcodecs shellme 3.8c7919d Because sometimes you just need shellcode and opcodes quickly. This essentially just wraps some nasm/objdump calls into a neat script. https://github.com/hatRiot/shellme shellnoob 2.1 A toolkit that eases the writing and debugging of shellcode https://github.com/reyammer/shellnoob shortfuzzy 0.1 A web fuzzing script written in perl. http://packetstormsecurity.com/files/104872/Short-Fuzzy-Rat-Scanner.html sidguesser 1.0.5 Guesses sids/instances against an Oracle database according to a predefined dictionary file. http://www.cqure.net/wp/tools/database/sidguesser/ siege 3.0.8 An http regression testing and benchmarking utility http://www.joedog.org/JoeDog/Siege silk 3.9.0 A collection of traffic analysis tools developed by the CERT NetSA to facilitate security analysis of large networks. https://tools.netsa.cert.org/silk/ simple-ducky 1.1.1 A payload generator. https://code.google.com/p/simple-ducky-payload-generator simple-lan-scan 1.0 A simple python script that leverages scapy for discovering live hosts on a network. http://packetstormsecurity.com/files/97353/Simple-LAN-Scanner.0.html sinfp 1.22 A full operating system stack fingerprinting suite. http://www.networecon.com/tools/sinfp/ siparmyknife 11232011 A small command line tool for developers and administrators of Session Initiation Protocol (SIP) applications. http://packetstormsecurity.com/files/107301/sipArmyKnife_11232011.pl.txt sipcrack 0.2 A SIP protocol login cracker. http://www.remote-exploit.org/codes_sipcrack.html sipp 3.3 A free Open Source test tool / traffic generator for the SIP protocol. http://sipp.sourceforge.net/ sipsak 0.9.6 A small command line tool for developers and administrators of Session Initiation Protocol (SIP) applications. http://sipsak.org sipscan 0.1 A sip scanner. http://www.hackingvoip.com/sec_tools.html sipshock 6.1d636ab A scanner for SIP proxies vulnerable to Shellshock. https://github.com/zaf/sipshock sipvicious 0.2.8 Tools for auditing SIP devices http://blog.sipvicious.org skipfish 2.10b A fully automated, active web application security reconnaissance tool http://code.google.com/p/skipfish/ skyjack 7.5f7a25e Takes over Parrot drones, deauthenticating their true owner and taking over control, turning them into zombie drones under your own control. https://github.com/samyk/skyjack skype-dump 0.1 This is a tool that demonstrates dumping MD5 password hashes from the configuration file in Skype. http://packetstormsecurity.com/files/119155/Skype-Hash-Dumper.0.html skypefreak 30.14a81cb A Cross Platform Forensic Framework for Skype. http://osandamalith.github.io/SkypeFreak/ sleuthkit 4.1.3 File system and media management forensic analysis tools http://www.sleuthkit.org/sleuthkit slowhttptest 1.5 A highly configurable tool that simulates application layer denial of service attacks http://code.google.com/p/slowhttptest slowloris 0.7 A tool which is written in perl to test http-server vulnerabilites for connection exhaustion denial of service (DoS) attacks so you can enhance the security of your webserver. http://ha.ckers.org/slowloris/ smali 1.4.1 An assembler/disassembler for Android's dex format http://code.google.com/p/smali/ smartphone-pentest-framework 95.20918b2 Repository for the Smartphone Pentest Framework (SPF). https://github.com/georgiaw/Smartphone-Pentest-Framework smbbf 0.9.1 SMB password bruteforcer. http://packetstormsecurity.com/files/25381/smbbf.9.1.tar.gz.html smbexec 148.7827616 A rapid psexec style attack with samba tools. https://github.com/pentestgeek/smbexec smbrelay 3 SMB / HTTP to SMB replay attack toolkit. http://www.tarasco.org/security/smbrelay/ smtp-fuzz 1.0 Simple smtp fuzzer none smtp-user-enum 1.2 Username guessing tool primarily for use against the default Solaris SMTP service. Can use either EXPN, VRFY or RCPT TO. http://pentestmonkey.net/tools/user-enumeration/smtp-user-enum smtp-vrfy 1.0 An SMTP Protocol Hacker. smtpmap 0.8.234_BETA Tool to identify the running smtp software on a given host. http://www.projectiwear.org/~plasmahh/software.html smtpscan 0.5 An SMTP scanner http://packetstormsecurity.com/files/31102/smtpscan.5.tar.gz.html sn00p 0.8 A modular tool written in bourne shell and designed to chain and automate security tools and tests. http://www.nullsecurity.net/tools/automation.html sniffjoke 0.4.1 Injects packets in the transmission flow that are able to seriously disturb passive analysis like sniffing, interception and low level information theft. http://www.delirandom.net/sniffjoke/ snmp-fuzzer 0.1.1 SNMP fuzzer uses Protos test cases with an entirely new engine written in Perl. http://www.arhont.com/en/category/resources/tools-utilities/ snmpattack 1.8 SNMP scanner and attacking tool. http://www.c0decafe.de/ snmpcheck 1.8 A free open source utility to get information via SNMP protocols. http://www.nothink.org/perl/snmpcheck/ snmpenum 1.7 snmp enumerator http://www.filip.waeytens.easynet.be/ snmpscan 0.1 A free, multi-processes SNMP scanner http://www.nothink.org/perl/snmpscan/index.php snoopy-ng 93.e305420 A distributed, sensor, data collection, interception, analysis, and visualization framework. https://github.com/sensepost/snoopy-ng snort 2.9.6.1 A lightweight network intrusion detection system. http://www.snort.org snow 20130616 Steganography program for concealing messages in text files. http://darkside.com.au/snow/index.html snscan 1.05 A Windows based SNMP detection utility that can quickly and accurately identify SNMP enabled devices on a network. http://www.mcafee.com/uk/downloads/free-tools/snscan.aspx socat 1.7.2.4 Multipurpose relay http://www.dest-unreach.org/socat/ soot 2.5.0 A Java Bytecode Analysis and Transformation Framework. http://www.sable.mcgill.ca/soot spade 114 A general-purpose Internet utility package, with some extra features to help in tracing the source of spam and other forms of Internet harassment. http://www.hoobie.net/brutus/ sparty 0.1 An open source tool written in python to audit web applications using sharepoint and frontpage architecture. http://sparty.secniche.org/ spectools 2010_04_R1 Spectrum-Tools is a set of utilities for using the Wi-Spy USB spectrum analyzer hardware. Stable version. http://www.kismetwireless.net/spectools/ speedpwn 8.3dd2793 An active WPA/2 Bruteforcer, original created to prove weak standard key generation in different ISP labeled routers without a client is connected. https://gitorious.org/speedpwn/ spiderfoot 2.1.5 The Open Source Footprinting Tool http://spiderfoot.net/ spiderpig-pdffuzzer 0.1 A javascript pdf fuzzer https://code.google.com/p/spiderpig-pdffuzzer/ spiga 7240.3a804ac Configurable web resource scanner https://github.com/getdual/scripts-n-tools/blob/master/spiga.py spike 2.9 IMMUNITYsec's fuzzer creation kit in C http://www.immunitysec.com/resources-freesoftware.shtml spike-proxy 148 A Proxy for detecting vulnerabilities in web applications http://www.immunitysec.com/resources-freesoftware.shtml spiped 1.4.1 A utility for creating symmetrically encrypted and authenticated pipes between socket addresses. https://www.tarsnap.com/spiped.html spipscan 8340.db8ef4a SPIP (CMS) scanner for penetration testing purpose written in Python. https://github.com/PaulSec/SPIPScan splint 3.1.2 A tool for statically checking C programs for security vulnerabilities and coding mistakes http://www.splint.org/ sploitctl 1.1 Fetch, install and search exploit archives from exploit sites like exploit-db and packetstorm. https://github.com/BlackArch/sploitctl sploitego 153.d9568dc Maltego Penetration Testing Transforms. https://github.com/allfro/sploitego spooftooph 0.5.2 Designed to automate spoofing or cloning Bluetooth device Name, Class, and Address. Cloning this information effectively allows Bluetooth device to hide in plain sight http://www.hackfromacave.com/projects/spooftooph.html sps 4.2 A Linux packet crafting tool. Supports IPv4, IPv6 including extension headers, and tunneling IPv6 over IPv4. https://sites.google.com/site/simplepacketsender/ sqid 0.3 A SQL injection digger. http://sqid.rubyforge.org/ sqlbrute 1.0 Brute forces data out of databases using blind SQL injection. http://www.justinclarke.com/archives/2006/03/sqlbrute.html sqlmap 6445.20c272b An automatic SQL injection tool developed in Python. http://sqlmap.sourceforge.net sqlninja 0.2.6_r1 A tool targeted to exploit SQL Injection vulnerabilities on a web application that uses Microsoft SQL Server as its back-end http://sqlninja.sourceforge.net/ sqlpat 1.0.1 This tool should be used to audit the strength of Microsoft SQL Server passwords offline. http://www.cqure.net/wp/sqlpat/ sqlping 4 SQL Server scanning tool that also checks for weak passwords using wordlists. http://www.sqlsecurity.com/downloads sqlsus 0.7.2 An open source MySQL injection and takeover tool, written in perl http://sqlsus.sourceforge.net/ ssh-privkey-crack 0.3 A SSH private key cracker https://code.google.com/p/lusas/ sshatter 1.2 Password bruteforcer for SSH http://www.nth-dimension.org.uk/downloads.php?id=34 sshscan 7401.3bfd4ae A horizontal SSH scanner that scans large swaths of IPv4 space for a single SSH user and pass. https://github.com/getdual/scripts-n-tools/blob/master/sshscan.py sshtrix 0.0.2 A very fast multithreaded SSH login cracker http://nullsecurity.net/tools/cracker.html sshuttle 198.9ce2fa0 Transparent proxy server that works as a poor man's VPN. Forwards all TCP packets over ssh (and even DNS requests when using --dns option). Doesn't require admin privileges on the server side. https://github.com/apenwarr/sshuttle ssl-hostname-resolver 1 CN (Common Name) grabber on X.509 Certificates over HTTPS. http://packetstormsecurity.com/files/120634/Common-Name-Grabber-Script.html ssl-phuck3r 2.0 All in one script for Man-In-The-Middle attacks. https://github.com/zombiesam/ssl_phuck3r sslcat 1.0 SSLCat is a simple Unix utility that reads and writes data across an SSL enable network connection. http://www.bindshell.net/tools/sslcat sslcaudit 522.5b6be3e Utility to perform security audits of SSL/TLS clients. https://github.com/grwl/sslcaudit ssldump 0.9b3 an SSLv3/TLS network protocol analyzer http://www.rtfm.com/ssldump/ sslh 1.16 SSL/SSH/OpenVPN/XMPP/tinc port multiplexer http://www.rutschle.net/tech/sslh.shtml sslmap 0.2.0 A lightweight TLS/SSL cipher suite scanner. http://thesprawl.org/projects/latest/ sslnuke 5.c5faeaa Transparent proxy that decrypts SSL traffic and prints out IRC messages. https://github.com/jtripper/sslnuke sslscan 239.1328b49 Tests SSL/TLS enabled services to discover supported cipher suites. https://github.com/DinoTools/sslscan sslsniff 0.8 A tool to MITM all SSL connections on a LAN and dynamically generate certs for the domains that are being accessed on the fly http://www.thoughtcrime.org/software/sslsniff/ sslsplit 0.4.9 A tool for man-in-the-middle attacks against SSL/TLS encrypted network connections. http://www.roe.ch/SSLsplit sslstrip 0.9 Transparently hijack http traffic on a network, watch for https links and redirects, then map those links. http://www.thoughtcrime.org/software/sslstrip sslyze 0.10 Python tool for analyzing the configuration of SSL servers and for identifying misconfigurations. https://github.com/nabla-c0d3/sslyze/ stackflow 2.2af525d Universal stack-based buffer overfow exploitation tool. https://github.com/d4rkcat/stackflow starttls-mitm 7.b257756 A mitm proxy that will transparently proxy and dump both plaintext and TLS traffic. https://github.com/ipopov/starttls-mitm statsprocessor 0.10 A high-performance word-generator based on per-position Markov-attack. http://hashcat.net/wiki/doku.php?id=statsprocessor steghide 0.5.1 Embeds a message in a file by replacing some of the least significant bits http://steghide.sourceforge.net stompy 0.0.4 an advanced utility to test the quality of WWW session identifiers and other tokens that are meant to be unpredictable. http://lcamtuf.coredump.cx/ storm-ring 0.1 This simple tool is useful to test a PABX with "allow guest" parameter set to "yes" (in this scenario an anonymous caller could place a call). http://packetstormsecurity.com/files/115852/Storm-Ringing-PABX-Test-Tool.html stunnel 5.06 A program that allows you to encrypt arbitrary TCP connections inside SSL http://www.stunnel.org subdomainer 1.2 A tool designed for obtaining subdomain names from public sources. http://www.edge-security.com/subdomainer.php subterfuge 5.0 Automated Man-in-the-Middle Attack Framework http://kinozoa.com sucrack 1.2.3 A multi-threaded Linux/UNIX tool for brute-force cracking local user accounts via su http://labs.portcullis.co.uk/application/sucrack sulley 1.0.cb5e62c A pure-python fully automated and unattended fuzzing framework. https://github.com/OpenRCE/sulley/ superscan 4 Powerful TCP port scanner, pinger, resolver. http://www.foundstone.com/us/resources/proddesc/superscan.htm suricata 2.0.3 An Open Source Next Generation Intrusion Detection and Prevention Engine. http://openinfosecfoundation.org/index.php/download-suricata svn-extractor 28.3af00fb A simple script to extract all web resources by means of .SVN folder exposed over network. https://github.com/anantshri/svn-extractor swaks 20130209.0 Swiss Army Knife SMTP; Command line SMTP testing, including TLS and AUTH http://jetmore.org/john/code/swaks/ swfintruder 0.9.1 First tool for testing security in Flash movies. A runtime analyzer for SWF external movies. It helps to find flaws in Flash. http://code.google.com/p/swfintruder/ synflood 0.1 A very simply script to illustrate DoS SYN Flooding attack. http://thesprawl.org/projects/syn-flooder/ synner 1.1 A custom eth->ip->tcp packet generator (spoofer) for testing firewalls and dos attacks. http://packetstormsecurity.com/files/69802/synner.c.html synscan 5.02 fast asynchronous half-open TCP portscanner http://www.digit-labs.org/files/tools/synscan/ sysdig 1314.45921f5 Open source system-level exploration and troubleshooting tool. http://www.sysdig.org/ sysinternals-suite 1.2 Sysinternals tools suite. http://sysinternals.com/ t50 5.4.1 Experimental Multi-protocol Packet Injector Tool http://t50.sourceforge.net/ taof 0.3.2 Taof is a GUI cross-platform Python generic network protocol fuzzer. http://taof.sf.net tbear 1.5 Transient Bluetooth Environment Auditor includes an ncurses-based Bluetooth scanner (a bit similar to kismet), a Bluetooth DoS tool, and a Bluetooth hidden device locator. http://freshmeat.net/projects/t-bear tcgetkey 0.1 A set of tools that deal with acquiring physical memory dumps via FireWire and then scan the memory dump to locate TrueCrypt keys and finally decrypt the encrypted TrueCrypt container using the keys. http://packetstormsecurity.com/files/119146/tcgetkey.1.html tcpcontrol-fuzzer 0.1 2^6 TCP control bit fuzzer (no ECN or CWR). https://www.ee.oulu.fi/research/ouspg/tcpcontrol-fuzzer tcpdump 4.6.2 A tool for network monitoring and data acquisition http://www.tcpdump.org tcpextract 1.1 Extracts files from captured TCP sessions. Support live streams and pcap files. https://pypi.python.org/pypi/tcpextract/1.1 tcpflow 1.4.4 Captures data transmitted as part of TCP connections then stores the data conveniently http://afflib.org/software/tcpflow tcpick 0.2.1 TCP stream sniffer and connection tracker http://tcpick.sourceforge.net/ tcpjunk 2.9.03 A general tcp protocols testing and hacking utility http://code.google.com/p/tcpjunk tcpreplay 4.0.5 Gives the ability to replay previously captured traffic in a libpcap format http://tcpreplay.appneta.com tcptraceroute 1.5beta7 A traceroute implementation using TCP packets. http://michael.toren.net/code/tcptraceroute/ tcpwatch 1.3.1 A utility written in Python that lets you monitor forwarded TCP connections or HTTP proxy connections. http://hathawaymix.org/Software/TCPWatch tcpxtract 1.0.1 A tool for extracting files from network traffic. http://tcpxtract.sourceforge.net teardown 1.0 Command line tool to send a BYE request to tear down a call. http://www.hackingexposedvoip.com/ tekdefense-automater 52.6d0bd5a IP URL and MD5 OSINT Analysis https://github.com/1aN0rmus/TekDefense-Automater termineter 0.1.0 Smart meter testing framework https://code.google.com/p/termineter/ tftp-bruteforce 0.1 TFTP-bruteforcer is a fast TFTP filename bruteforcer written in perl. http://www.hackingexposedcisco.com/ tftp-fuzz 1337 Master TFTP fuzzing script as part of the ftools series of fuzzers http://nullsecurity.net/tools/fuzzer.html tftp-proxy 0.1 This tool accepts connection on tftp and reloads requested content from an upstream tftp server. Meanwhile modifications to the content can be done by pluggable modules. So this one's nice if your mitm with some embedded devices. http://www.c0decafe.de/ thc-ipv6 2.5 A complete tool set to attack the inherent protocol weaknesses of IPv6 and ICMP6, and includes an easy to use packet factory library. http://thc.org/thc-ipv6/ thc-keyfinder 1.0 Finds crypto keys, encrypted data and compressed data in files by analyzing the entropy of parts of the file. https://www.thc.org/releases.php thc-pptp-bruter 0.1.4 A brute force program that works against pptp vpn endpoints (tcp port 1723). http://www.thc.org thc-smartbrute 1.0 This tool finds undocumented and secret commands implemented in a smartcard. https://www.thc.org/thc-smartbrute/ thc-ssl-dos 1.4 A tool to verify the performance of SSL. To be used in your authorized and legitimate area ONLY. You need to accept this to make use of it, no use for bad intentions, you have been warned! http://www.thc.org/thc-ssl-dos/ theharvester 2.2a Python tool for gathering e-mail accounts and subdomain names from different public sources (search engines, pgp key servers) http://www.edge-security.com/theHarvester.php themole 0.3 Automatic SQL injection exploitation tool. http://sourceforge.net/projects/themole/ tiger 3.2.3 A security scanner, that checks computer for known problems. Can also use tripwire, aide and chkrootkit. http://www.nongnu.org/tiger/ tilt 90.2bc2ef2 An easy and simple tool implemented in Python for ip reconnaissance, with reverse ip lookup. https://github.com/AeonDave/tilt timegen 0.4 This program generates a *.wav file to "send" an own time signal to DCF77 compatible devices. http://bastianborn.de/radio-clock-hack/ tinc 1.0.24 VPN (Virtual Private Network) daemon http://www.tinc-vpn.org/ tinyproxy 1.8.3 A light-weight HTTP proxy daemon for POSIX operating systems. https://banu.com/tinyproxy/ tlsenum 75.6618285 A command line tool to enumerate TLS cipher-suites supported by a server. https://github.com/Ayrx/tlsenum tlspretense 0.6.2 SSL/TLS client testing framework https://github.com/iSECPartners/tlspretense tlssled 1.3 A Linux shell script whose purpose is to evaluate the security of a target SSL/TLS (HTTPS) web server implementation. http://blog.taddong.com/2011/05/tlssled-v10.html tnscmd 1.3 a lame tool to prod the oracle tnslsnr process (1521/tcp) http://www.jammed.com/~jwa/hacks/security/tnscmd/ topera 19.3e230fd An IPv6 security analysis toolkit, with the particularity that their attacks can't be detected by Snort. https://github.com/toperaproject/topera tor 0.2.5.10 Anonymizing overlay network. http://www.torproject.org/ tor-autocircuit 0.2 Tor Autocircuit was developed to give users a finer control over Tor circuit creation. The tool exposes the functionality of TorCtl library which allows its users to control circuit length, speed, geolocation, and other parameters. http://www.thesprawl.org/projects/tor-autocircuit/ tor-browser-en 4.0.2 Tor Browser Bundle: Anonymous browsing using firefox and tor https://www.torproject.org/projects/torbrowser.html.en torshammer 1.0 A slow POST Denial of Service testing tool written in Python. http://sourceforge.net/projects/torshammer/ torsocks 2.0.0 Wrapper to safely torify applications http://code.google.com/p/torsocks tpcat latest TPCAT is based upon pcapdiff by the EFF. TPCAT will analyze two packet captures (taken on each side of the firewall as an example) and report any packets that were seen on the source capture but didn’t make it to the dest. http://sourceforge.net/projects/tpcat/ traceroute 2.0.21 Tracks the route taken by packets over an IP network http://traceroute.sourceforge.net/ trid 2.11 An utility designed to identify file types from their binary signatures http://mark0.net/soft-trid-e.html trinity 3728.985a087 A Linux System call fuzzer. http://codemonkey.org.uk/projects/trinity/ trixd00r 0.0.1 An advanced and invisible userland backdoor based on TCP/IP for UNIX systems http://nullsecurity.net/tools/backdoor.html truecrack 35 Password cracking for truecrypt(c) volumes. http://code.google.com/p/truecrack/ truecrypt 7.1a Free open-source cross-platform disk encryption software http://www.truecrypt.org/ tsh 0.6 An open-source UNIX backdoor that compiles on all variants, has full pty support, and uses strong crypto for communication. http://packetstormsecurity.com/search/?q=tsh tsh-sctp 2.850a2da An open-source UNIX backdoor. https://github.com/infodox/tsh-sctp tuxcut 5.0 Netcut-like program for Linux written in PyQt http://bitbucket.org/a_atalla/tuxcut/ twofi 2.0 Twitter Words of Interest. http://www.digininja.org/projects/twofi.php u3-pwn 2.0 A tool designed to automate injecting executables to Sandisk smart usb devices with default U3 software install http://www.nullsecurity.net/tools/backdoor.html *__uatester 1.06__ User Agent String Tester http://code.google.com/p/ua-tester/ *__ubertooth 2012.10.R1__ A 2.4 GHz wireless development board suitable for Bluetooth experimentation. Open source hardware and software. Tools only http://sourceforge.net/projects/ubertooth/ *__ubitack 0.3__ Tool, which automates some of the tasks you might need on a (wireless) penetration test or while you are on the go. https://code.google.com/p/ubitack/ *__udis86 1.7.2__ A minimalistic disassembler library http://udis86.sourceforge.net/ *__udptunnel 19__ Tunnels TCP over UDP packets. http://code.google.com/p/udptunnel/ *__uefi-firmware-parser 103.9d4d220__ Parse BIOS/Intel ME/UEFI firmware related structures: Volumes, FileSystems, Files, etc https://github.com/theopolis/uefi-firmware-parser *__ufo-wardriving 4__ Allows you to test the security of wireless networks by detecting their passwords based on the router model http://www.ufo-wardriving.com/ *__ufonet 9.5484a90__ A tool designed to launch DDoS attacks against a target, using 'Open Redirect' vectors on third party web applications, like botnet. https://github.com/epsylon/ufonet *__umap 25.3ad8121__ The USB host security assessment tool. https://github.com/nccgroup/umap *__umit 1.0__ A powerful nmap frontend. http://www.umitproject.org/ *__unhide 20130526__ A forensic tool to find processes hidden by rootkits, LKMs or by other techniques. http://sourceforge.net/projects/unhide/ *__unicorn 9.a18cb5d__ A simple tool for using a PowerShell downgrade attack and inject shellcode straight into memory. https://github.com/trustedsec/unicorn *__unicornscan 0.4.7__ A new information gathering and correlation engine. http://www.unicornscan.org/ *__uniofuzz 1337__ The universal fuzzing tool for browsers, web services, files, programs and network services/ports http://nullsecurity.net/tools/fuzzer.html *__uniscan 6.2__ A simple Remote File Include, Local File Include and Remote Command Execution vulnerability scanner. http://sourceforge.net/projects/uniscan/ *__unix-privesc-check 1.4__ Tries to find misconfigurations that could allow local unprivilged users to escalate privileges to other users or to access local apps (e.g. databases) http://pentestmonkey.net/tools/audit/unix-privesc-check *__unsecure 1.2__ Bruteforces network login masks. http://www.sniperx.net/ *__upnpscan 0.4__ Scans the LAN or a given address range for UPnP capable devices. http://www.cqure.net/wp/upnpscan/ *__upx 3.91__ Ultimate executable compressor. http://upx.sourceforge.net/ *__urlcrazy 0.5__ Generate and test domain typos and variations to detect and perform typo squatting, URL hijacking, phishing, and corporate espionage. http://www.morningstarsecurity.com/research/urlcrazy *__urldigger 02c__ A python tool to extract URL addresses from different HOT sources and/or detect SPAM and malicious code https://code.google.com/p/urldigger/ *__username-anarchy 0.2__ Tools for generating usernames when penetration testing http://www.morningstarsecurity.com/research/username-anarchy *__usernamer 7.813139d__ Pentest Tool to generate usernames/logins based on supplied names. https://github.com/jseidl/usernamer *__uw-loveimap 0.1__ Multi threaded imap bounce scanner. http://uberwall.org/bin/download/45/UWloveimap.tgz *__uw-offish 0.1__ Clear-text protocol simulator. http://uberwall.org/bin/download/42/UW_offish.1.tar.gz *__uw-udpscan 0.1__ Multi threaded udp scanner. http://uberwall.org/bin/download/44/UWudpscan.tar.gz *__uw-zone 0.1__ Multi threaded, randomized IP zoner. http://uberwall.org/bin/download/43/UWzone.tgz *__v3n0m 77.cdaf14e__ Popular linux version of Balthazar/NovaCygni's 'v3n0m' scanner. Searches 18k+ dorks over 13 search engines. https://github.com/v3n0m-Scanner/V3n0M-Scanner * __valgrind 3.10.1__ A tool to help find memory-management problems in programs http://valgrind.org/ * __vanguard 0.1__ A comprehensive web penetration testing tool written in Perl thatidentifies vulnerabilities in web applications. http://packetstormsecurity.com/files/110603/Vanguard-Pentesting-Scanner.html * __vbrute 1.11dda8b__ Virtual hosts brute forcer. https://github.com/nccgroup/vbrute * __vega 1.0__ An open source platform to test the security of web applications https://github.com/subgraph/Vega/wiki * __veil 276.f6dc4ff__ A tool designed to generate metasploit payloads that bypass common anti-virus solutions. https://github.com/veil-evasion/Veil * __vfeed 36.a0fdf06__ Open Source Cross Linked and Aggregated Local Vulnerability Database main repository. http://www.toolswatch.org/vfeed * __vidalia 0.2.21__ Controller GUI for Tor https://www.torproject.org/vidalia * __videosnarf 0.63__ A new security assessment tool for pcap analysis http://ucsniff.sourceforge.net/videosnarf.html * __vinetto 0.07beta__ A forensics tool to examine Thumbs.db files http://vinetto.sourceforge.net * __viper 501.5f6a19a__ A Binary analysis framework. https://github.com/botherder/viper * __viproy-voipkit 2.0__ VoIP Pen-Test Kit for Metasploit Framework http://viproy.com/ * __vivisect 20140803__ A Python based static analysis and reverse engineering framework, Vdb is a Python based research/reversing focused debugger and programatic debugging API by invisigoth of kenshoto http://visi.kenshoto.com/ * __vnak 1.cf0fda7__ Aim is to be the one tool a user needs to attack multiple VoIP protocols. https://www.isecpartners.com/vnak.html * __vnc-bypauth 0.0.1__ Multi-threaded bypass authentication scanner for VNC servers <= 4.1.1. http://pentester.fr/resources/tools/techno/VNC/VNC_bypauth/ * __vncrack 1.21__ What it looks like: crack VNC. http://phenoelit-us.org/vncrack * __voiper 0.07__ A VoIP security testing toolkit incorporating several VoIP fuzzers and auxilliary tools to assist the auditor. http://voiper.sourceforge.net/ * __voiphopper 2.04__ A security validation tool that tests to see if a PC can mimic the behavior of an IP Phone. It rapidly automates a VLAN Hop into the Voice VLAN. http://voiphopper.sourceforge.net/ * __voipong 2.0__ A utility which detects all Voice Over IP calls on a pipeline, and for those which are G711 encoded, dumps actual conversation to seperate wave files. http://www.enderunix.org/voipong/ * __volatility 2.4.1__ A memory forensics toolkit. https://www.volatilesystems.com/default/volatility * __vstt 0.5.0__ VSTT is a multi-protocol tunneling tool. It accepts input by TCP stream sockets and FIFOs, and can send data via TCP, POP3, and ICMP tunneling. http://www.wendzel.de/dr.org/files/Projects/vstt/ * __vulscan 2.0__ A module which enhances nmap to a vulnerability scanner http://www.computec.ch/projekte/vulscan/ * __w3af 1.6__ Web Application Attack and Audit Framework. http://w3af.sourceforge.net/ * __waffit 30__ A set of security tools to identify and fingerprint Web Application Firewall/WAF products protecting a website http://code.google.com/p/waffit/ * __wafp 0.01_26c3__ An easy to use Web Application Finger Printing tool written in ruby using sqlite3 databases for storing the fingerprints. http://packetstormsecurity.com/files/84468/Web-Application-Finger-Printer.01-26c3.html * __wapiti 2.3.0__ A vulnerability scanner for web applications. It currently search vulnerabilities like XSS, SQL and XPath injections, file inclusions, command execution, LDAP injections, CRLF injections... http://wapiti.sourceforge.net/ * __wavemon 0.7.6__ Ncurses-based monitoring application for wireless network devices http://eden-feed.erg.abdn.ac.uk/wavemon/ * __web-soul 2__ A plugin based scanner for attacking and data mining web sites written in Perl. http://packetstormsecurity.com/files/122064/Web-Soul-Scanner.html * __webacoo 0.2.3__ Web Backdoor Cookie Script-Kit. https://bechtsoudis.com/webacoo/ * __webenum 0.1__ Tool to enumerate http responses using dynamically generated queries and more. Useful for penetration tests against web servers. http://code.google.com/p/webenum/ * __webhandler 0.8.5__ A handler for PHP system functions & also an alternative 'netcat' handler. https://github.com/lnxg33k/webhandler * __webpwn3r 35.3fb27bb__ A python based Web Applications Security Scanner. https://github.com/zigoo0/webpwn3r * __webrute 3.3__ Web server directory brute forcer. https://github.com/BlackArch/webrute * __webscarab 20120422.001828__ Framework for analysing applications that communicate using the HTTP and HTTPS protocols http://www.owasp.org/index.php/Category:OWASP_WebScarab_Project * __webshag 1.10__ A multi-threaded, multi-platform web server audit tool. http://www.scrt.ch/en/attack/downloads/webshag * __webshells 6.690ebd9__ Web Backdoors. https://github.com/BlackArch/webshells * __webslayer 5__ A tool designed for brute forcing Web Applications https://code.google.com/p/webslayer/ * __websockify__ 0.6.0 WebSocket to TCP proxy/bridge. http://github.com/kanaka/websockify * __webspa 0.7__ A web knocking tool, sending a single HTTP/S to run O/S commands. http://sourceforge.net/projects/webspa/ * __websploit 3.0.0__ An Open Source Project For, Social Engineering Works, Scan, Crawler & Analysis Web, Automatic Exploiter, Support Network Attacks http://code.google.com/p/websploit/ * __weevely 1.1__ Stealth tiny web shell http://epinna.github.io/Weevely/ * __wepbuster 1.0_beta_0.7__ script for automating aircrack-ng http://code.google.com/p/wepbuster/ * __wfuzz 24.1c6ecd8__ Utility to bruteforce web applications to find their not linked resources. https://github.com/xmendez/wfuzz * __whatweb 0.4.7__ Next generation web scanner that identifies what websites are running. http://www.morningstarsecurity.com/research/whatweb * __wi-feye 1.0__ An automated wireless penetration testing tool written in python, its designed to simplify common attacks that can be performed on wifi networks so that they can be executed quickly and easily. http://wi-feye.za1d.com/download.php * __wifi-honey 1.0__ A management tool for wifi honeypots http://www.digininja.org/projects/wifi_honey.php * __wifi-monitor 0.r22.71340a3__ Prints the IPs on your local network that're sending the most packets https://github.com/DanMcInerney/wifi-monitor * __wificurse 0.3.9__ WiFi jamming tool. https://github.com/oblique/wificurse * __wifijammer 43.4a0fe56__ A python script to continuosly jam all wifi clients within range. https://github.com/DanMcInerney/wifijammer * __wifiphisher 17.09cf393__ Fast automated phishing attacks against WPA networks. https://github.com/sophron/wifiphisher * __wifitap 2b16088__ WiFi injection tool through tun/tap device. https://github.com/GDSSecurity/wifitap * __wifite 2.28fc5cd__ A tool to attack multiple WEP and WPA encrypted networks at the same time. http://code.google.com/p/wifite/ * __wig 291.14f19bd__ WebApp Information Gatherer. https://github.com/jekyc/wig * __wikigen 8.348aa99__ A script to generate wordlists out of wikipedia pages. https://github.com/zombiesam/wikigen * __winexe 1.00__ Remotely execute commands on Windows NT/2000/XP/2003 systems. http://sourceforge.net/projects/winexe/ * __winfo 2.0__ Uses null sessions to remotely try to retrieve lists of and information about user accounts, workstation/interdomain/server trust accounts, shares (also hidden), sessions, logged in users, and password/lockout policy, from Windows NT/2000/XP. http://www.ntsecurity.nu/toolbox/winfo/ * __wireless-ids 24.b132071__ Ability to detect suspicious activity such as (WEP/WPA/WPS) attack by sniffing the air for wireless packets. https://github.com/SYWorks/wireless-ids * __wireshark-cli 1.12.2__ a free network protocol analyzer for Unix/Linux and Windows - CLI version http://www.wireshark.org/ * __wireshark-gtk 1.12.2__ a free network protocol analyzer for Unix/Linux and Windows - GTK frontend http://www.wireshark.org/ * __wirouter-keyrec 1.1.2__ A powerful and platform independent software to recover the default WPA passphrases of the supported router models (Telecom Italia Alice AGPF, Fastweb Pirelli, Fastweb Tesley, Eircom Netopia, Pirelli TeleTu/Tele 2). http://www.salvatorefresta.net/tools/ * __witchxtool 1.1__ A perl script that consists of a port scanner, LFI scanner, MD5 bruteforcer, dork SQL injection scanner, fresh proxy scanner, and a dork LFI scanner. http://packetstormsecurity.com/files/97465/Witchxtool-Port-LFI-SQL-Scanner-And-MD5-Bruteforcing-Tool.1.html * __wlan2eth 1.3__ re-writes 802.11 captures into standard Ethernet frames. http://www.willhackforsushi.com/?page_id=79 * __wmat 0.1__ Automatic tool for testing webmail accounts http://netsec.rs/70/tools.html * __wnmap 0.1__ A shell script written with the purpose to automate and chain scans via nmap. You can run nmap with a custom mode written by user and create directories for every mode with the xml/nmap files inside. http://nullsecurity.net/tools/automation.html * __wol-e 2.0__ A suite of tools for the Wake on LAN feature of network attached computers http://code.google.com/p/wol-e/ * __wordpot 37.e42eeda__ A Wordpress Honeypot. https://github.com/gbrindisi/wordpot * __wpbf 7.11b6ac1__ Multithreaded WordPress brute forcer. https://github.com/dejanlevaja/wpbf * __wpscan 1803.88808db__ A vulnerability scanner which checks the security of WordPress installations using a black box approach. http://wpscan.org * __ws-attacker 1.3__ A modular framework for web services penetration testing. http://ws-attacker.sourceforge.net/ * __wsfuzzer 1.9.5__ A Python tool written to automate pentesting of web services. https://www.owasp.org/index.php/Category:OWASP_WSFuzzer_ProjectSOAP * __wyd 0.2__ Gets keywords from personal files. IT security/forensic tool. http://www.remote-exploit.org/?page_id=418 * __x-scan 3.3__ A general network vulnerabilities scanner for scanning network vulnerabilities for specific IP address scope or stand-alone computer by multi-threading method, plug-ins are supportable. http://www.xfocus.org/ * __xcavator 5.bd9e2d8__ Man-In-The-Middle and phishing attack tool that steals the victim's credentials of some web services like Facebook. https://github.com/nccgroup/xcavator * __xf86-video-qxl-git r541.cbe70e9__ Xorg X11 qxl video driver. http://www.spice-space.org/ * __xorbruteforcer 0.1__ Script that implements a XOR bruteforcing of a given file, although a specific key can be used too. http://eternal-todo.com/category/bruteforce * __xorsearch 1.11.1__ Program to search for a given string in an XOR, ROL or ROT encoded binary file. http://blog.didierstevens.com/programs/xorsearch/ * __xortool 0.96__ A tool to analyze multi-byte xor cipher. https://github.com/hellman/xortool/ * __xplico 33.0f6d8bc__ Internet Traffic Decoder. Network Forensic Analysis Tool (NFAT). http://www.xplico.org/ * __xprobe2 0.3__ An active OS fingerprinting tool. http://sourceforge.net/apps/mediawiki/xprobe/index.php?title=Main_Page * __xspy 1.0c__ A utility for monitoring keypresses on remote X servers http://www.freshports.org/security/xspy/ * __xsser 1.6__ A penetration testing tool for detecting and exploiting XSS vulnerabilites. http://xsser.sourceforge.net/ * __xssless 35.9eee648__ An automated XSS payload generator written in python. https://github.com/mandatoryprogrammer/xssless * __xsss 0.40b__ A brute force cross site scripting scanner. http://www.sven.de/xsss/ * __xssscan 8340.db8ef4a__ Command line tool for detection of XSS attacks in URLs. Based on ModSecurity rules from OWASP CRS. https://github.com/gwroblew/detectXSSlib * __xsssniper 0.9__ An automatic XSS discovery tool https://github.com/gbrindisi/xsssniper * __xssya 13.15ebdfe__ A Cross Site Scripting Scanner & Vulnerability Confirmation. https://github.com/yehia-mamdouh/XSSYA * __yara 3.2.0__ A malware identification and classification tool. https://plusvic.github.io/yara/ * __ycrawler 0.1__ A web crawler that is useful for grabbing all user supplied input related to a given website and will save the output. It has proxy and log file support. http://packetstormsecurity.com/files/98546/yCrawler-Web-Crawling-Utility.html * __yersinia 0.7.1__ A network tool designed to take advantage of some weakness in different network protocols http://www.yersinia.net/ * __yinjector 0.1__ A MySQL injection penetration tool. It has multiple features, proxy support, and multiple exploitation methods. http://packetstormsecurity.com/files/98359/yInjector-MySQL-Injection-Tool.html * __zackattack 5.1f96c14__ A new tool set to do NTLM Authentication relaying unlike any other tool currently out there. https://github.com/urbanesec/ZackAttack/ * __zaproxy 2.3.1__ A local intercepting proxy with integrated penetration testing tool for finding vulnerabilities in web applications. http://code.google.com/p/zaproxy/ * __zarp 0.1.5__ A network attack tool centered around the exploitation of local networks. https://defense.ballastsecurity.net/wiki/index.php/Zarp * __zerowine 0.0.2__ Malware Analysis Tool - research project to dynamically analyze the behavior of malware http://zerowine.sf.net/ * __zmap 1.2.1__ Fast network scanner designed for Internet-wide network surveys. https://zmap.io/ * __zulu 0.1__ A light weight 802.11 wireless frame generation tool to enable fast and easy debugging and probing of 802.11 networks. http://sourceforge.net/projects/zulu-wireless/ * __zykeys 0.1__ Demonstrates how default wireless settings are derived on some models of ZyXEL routers. http://packetstormsecurity.com/files/119156/Zykeys-Wireless-Tool.html * __zzuf 0.13__ Transparent application input fuzzer. http://sam.zoy.org/zzuf/ /yCrawler-Web-Crawling-Utility.html * __yersinia 0.7.1__ A network tool designed to take advantage of some weakness in different network protocols http://www.yersinia.net/ * __yinjector 0.1__ A MySQL injection penetration tool. It has multiple features, proxy support, and multiple exploitation methods. http://packetstormsecurity.com/files/98359/yInjector-MySQL-Injection-Tool.html * __zackattack 5.1f96c14__ A new tool set to do NTLM Authentication relaying unlike any other tool currently out there. https://github.com/urbanesec/ZackAttack/ * __zaproxy 2.3.1__ A local intercepting proxy with integrated penetration testing tool for finding vulnerabilities in web applications. http://code.google.com/p/zaproxy/ * __zarp 0.1.5__ A network attack tool centered around the exploitation of local networks. https://defense.ballastsecurity.net/wiki/index.php/Zarp * __zerowine 0.0.2__ Malware Analysis Tool - research project to dynamically analyze the behavior of malware http://zerowine.sf.net/ * __zmap 1.2.1__ Fast network scanner designed for Internet-wide network surveys. https://zmap.io/ * __zulu 0.1__ A light weight 802.11 wireless frame generation tool to enable fast and easy debugging and probing of 802.11 networks. http://sourceforge.net/projects/zulu-wireless/ * __zykeys 0.1__ Demonstrates how default wireless settings are derived on some models of ZyXEL routers. http://packetstormsecurity.com/files/119156/Zykeys-Wireless-Tool.html * __zzuf 0.13__ Transparent application input fuzzer. http://sam.zoy.org/zzuf/ Source: https://github.com/m4ll0k/Awesome-Hacking-Tools

Salut, Un curs introductiv despre Machine Learning, predat de Andrew Ng: https://www.coursera.org/learn/machine-learning Can I take this course for free? You can access all videos, readings, and discussions, free of charge. You can also submit assignments and earn a grade for free. If you want to earn a Course Certificate, you can subscribe or apply for financial aid. About Andrew Ng: Andrew was a professor at Stanford University Department of Computer Science. He taught students and undertook research related to data mining and machine learning. From 2011 to 2012, he worked at Google, where he founded and led the Google Brain Deep Learning Project. In 2012, he co-foundedCoursera to offer free online courses for everyone. In 2014, he joinedBaidu as Chief Scientist, and carried out research related to big data and A.I. In March 2017, he announced his resignation from Baidu. - https://en.wikipedia.org/wiki/Andrew_Ng About this course: Machine learning is the science of getting computers to act without being explicitly programmed. In the past decade, machine learning has given us self-driving cars, practical speech recognition, effective web search, and a vastly improved understanding of the human genome. Machine learning is so pervasive today that you probably use it dozens of times a day without knowing it. Many researchers also think it is the best way to make progress towards human-level AI. In this class, you will learn about the most effective machine learning techniques, and gain practice implementing them and getting them to work for yourself. More importantly, you'll learn about not only the theoretical underpinnings of learning, but also gain the practical know-how needed to quickly and powerfully apply these techniques to new problems. Finally, you'll learn about some of Silicon Valley's best practices in innovation as it pertains to machine learning and AI. This course provides a broad introduction to machine learning, datamining, and statistical pattern recognition. Topics include: (i) Supervised learning (parametric/non-parametric algorithms, support vector machines, kernels, neural networks). (ii) Unsupervised learning (clustering, dimensionality reduction, recommender systems, deep learning). (iii) Best practices in machine learning (bias/variance theory; innovation process in machine learning and AI). The course will also draw from numerous case studies and applications, so that you'll also learn how to apply learning algorithms to building smart robots (perception, control), text understanding (web search, anti-spam), computer vision, medical informatics, audio, database mining, and other areas.

Filelist rip-off... Rusine.

Pffft. Vii tu aici cu apostroafele tale - Havij4life!

Tragi cu pusca la capitolul creativitate. Nu sunteti in stare sa ganditi pentru voi insiva, ati ajuns sa copiati FL-ul din scoarta in scoarta - maimute. Muie!

https://github.com/CoreSecurity/impacket Am folosit recent smbserver.py din Impacket ca sa urc un Meterpreter pe un Windows. Functioneaza aseamator cu SimpleHTTPServer din Python.

Prostul daca nu-i fudul, nu-i prost destul...

Ai cont de bărbat/România peste 6 luni vechime ?

Metasploit Low Level View Saad Talaat (saadtalaat@gmail.com) @Sa3dtalaat Abstract: for the past decade (almost) Metasploit have been number one pentesting tool. A lot of plug-ins have been developed specially for it. However, the key-point of this paper is to discuss metasploit framework as a code injector and payload encoder. Another key-point of this paper is malware different forms and how to avoid anti-viruses which have been a pain for pentesters lately. And how exactly anti-malware software work. Download: https://www.exploit-db.com/docs/18532.pdf

Am eu un cont din august anu trecut daca esti interesat .

Sakurity Racer This 128 LOC extension works pretty much as a "Make Money" button if used properly. LEGAL: Use at your own risk and only with your own projects. Do not use it against anyone else. Load this unpacked extension into your Chrome. We didn't upload it to the Chrome Store because for best results you need to run your own racer.js server anyway. See the circle on the right? It's the sniffer button. Once you click it, for next 3 seconds all requests (except ignored ones like OPTIONS) will be blocked and sent to specified default_server location where racer.js is running. Racer.js will get exact same request you were about to make along with all credentials and cookies and will repeat it to the victim in parallel (5 by default). That can trigger a race condition. No luck? Do it a few times because most race conditions are hard to reproduce. For basic tests you can run racer.js on your localhost and that will be used by default. For real pentest run it on a server as close to the victim as possible and change default_server inside sniffer.js. Best functionality to pentest: financial transfers, vouchers, discount codes, trade/withdraw functions and other actions that you're supposed to do limited amount of times. It doesn't cover all scenarios such as timed race conditions or when you need to run few different requests to achieve the result. Sursa: https://github.com/sakurity/racer

nu stiu dar mi se sparea aiurea sa aplic pentru un permis sa beau o bere

Scanner AI-Bolit is perhaps the most effective tool for webmasters and website administrators to find viruses, malicious code and hacker's scripts. Features: Detects any kind of malware and viruses in scripts and templates Reveals public vulnerabilities in CMS (Wordpress, Joomla, Drupal, and others) Heuristic analysis and patented way to find malware Actual antivirus database Suitable for any kind of websites Runs under Unix, Windows, Mac OS X Recommended by professional webmasters and Hosting Providers Download: AI-Bolit for Windows: aibolit-for-windows-en.zip AI-Bolit (General version — for hosting, Mac OS X or Unix OS): ai-bolit-en.zip Source: https://revisium.com/aibo/

aici si iti trebuie doar imeiul succes!

*SPUN* Esti pe un forum, pot vorbi ca ultimul idiot pe aici, nu inseamna ca in realitate fac la fel. Nu e vorba de a alege, ci vorba de "Da, voi trimite banii". In fine, daca atut te duce mintea...spor

poate incerci un kickstarter ...

Hater

Salut, va anuntam ca trackerul de torrente romanesc xtremefile.eu este acum deschis catre public, inregistrarile sunt deschise fara necesitatea unei invitatii, grabeste-te profita de aceasta ocazie si Inregistreaza-te xtremefile.eu ofera ultimele noutati in materie de Filme, Jocuri, Muzica, Software si E-book's, echipa noastra de uploaderi este mereu pregatita sa-ti ofere in cel mai scurt timp posibil filmele si serialele tale preferate. Cererile de torrente sunt completate in mod eficient si rapid, pentru a multumi toti utilizatorii acestei comunitati. Site: http://xtremefile.eu Inregistreaza-te: http://xtremefile.eu/signup.php Forum: http://xtremefile.eu/forum