Open Source Projects
At Core Security Technologies, we develop information security solutions to help meet the real-world security needs of our customers. In the spirit of creating an open developer and user community, we are pleased to share with you, free of charge, several of the tools we have developed. We hope that these technologies will be helpful for you, as they are for the thousands of organizations worldwide that are already using them.
- Pcapy
Python extension module for network packet capture
- Impacket
Python classes for providing access to network packets
- InlineEgg
Python classes for easily writing exploit payloads
- MSyslog
A UNIX subsystem for secure centralization and storage of log files
- Uhooker
A tool to intercept and manipulate execution of programs
Pcapy
Pcapy is a Python extension module that interfaces with the libpcap packet capture library. Pcapy enables python scripts to capture packets on the network. Pcapy is highly effective when used in conjunction with a packet-handling package such as Impacket, which is a collection of Python classes for providing access to network packets.
Click here for more information and you will be taken to our
open source software site, which will open in another window.
----------------------------------------------------------
Impacket
Impacket is a collection of Python classes focused on providing access to network packets. Impacket allows Python developers to craft and decode network packets in a simple and consistent manner. It includes support for low-level protocols such as IP, UDP and TCP, as well as higher-level protocols such as NMB and SMB. Impacket is highly effective when used in conjunction with a packet capture utility or package such as Pcapy. Packets can be constructed from scratch, as well as parsed from raw data. Furthermore, the object oriented API makes it simple to work with deep protocol hierarchies.
Click here for more information and you will be taken to our
open source software site, which will open in another window.
----------------------------------------------------------
InlineEgg
InlineEgg is a Python module that provides the user with a toolbox of classes for writing small assembly programs. It's goal is to simplify to process of creating and maintaining small assembly programs, including but not limited to shellcode, the payload of an exploit program, often called the "egg".
Click here for more information and you will be taken to our
open source software site, which will open in another window.
----------------------------------------------------------
MSyslog
MSyslog is a logging subsystem for UNIX operating systems. It replaces the traditional UNIX logging daemon, syslogd, with an improved version that provides capabilities for log centralization, preservation of log integrity, and storage on a myriad of popular database engines. MSyslog, which stands for Modular Syslog, has a very flexible architecture that allows the administrator to configure it to receive log data from several input sources such as TCP and UDP network connections, UNIX named pipes and plain text files. Log data storage is available through multiple output options including plaintext files, MySQL and PostgreSQL database engines. Log relaying can be performed over TCP sessions or the traditional UDP-based syslog protocol. MSyslog also supports filters that perform cryptographic integrity checks and filtering by regular expressions. MSyslog runs on a variety of UNIX and Linux operating systems.
Click here for more information and you will be taken to our
open source software site, which will open in another window.
----------------------------------------------------------
Uhooker
The Universal Hooker is a tool to intercept execution of programs. It enables the user to intercept calls to API calls inside DLLs, and also arbitrary addresses within the executable file in memory.
Why is it 'Universal'? There are different ways of hooking functions in a program, for example, it can be done by setting software breakpoints (int 3h), hardware breakpoints (cpu regs), or overwriting the prologue of a function to jump to a 'stub', etc. All the methods mentioned required above, specially the latter, require the programmer of the code creating the hook to have certain knowledge of the function it is intercepting. If the code is written in a programming language like C/C++, the code will normally need to be recompiled for every function one wants to intercept, etc.
The Universal Hooker tries to create very simple abstractions that allow a user of the tool to write hooks for different API and non-API functions using an interpreted language (python), without the need to compile anything, and with the possibility of changing the code that gets executed whent the hooked function is called in run-time.
The Universal Hooker builds on the idea that the function handling the hook is the one with the knowledge about the parameters type of the function it is handling. The Universal Hooker only knows the number of parameters of the function, and obtains them from the stack (all DWORDS). The hook handler is the one that will interpret those DWORDS as the types received by the function.
The hook handlers are written in python, what eliminates the need for recompiling the handlers when a modification is required. And also, the hook handlers (executed by the server) are reloaded from disk every time a hook handler is called, this means that one can change the behavior of the hook handler without the need to recompile the code, or having to restart the application being analyzed.
Click here for more information and you will be taken to our
open source software site, which will open in another window.
