Free ct scan with pe protocols software for linux

TAHI Test Suite provides a mechanism for validating an IPv6 implementation against a standardized test for conformance to the IPv6 specification, extensions and directly related protocols.
Enhancements:
- Ported FreeBSD-4.x
- Dont support FreeBSD 2.x
- pa can decode MIP6 packets
- All interoperability test tools is included.

Ethics Search Protocol in short ESP is an XML-based protocol for search engines that is designed to allow people to express specific ethical requirements when performing searches.
Consumers seldom get the chance to communicate ethical requirements because the proper communication channel does not exist. This project has the goal to offer an open source specification and implementation for that missing communication channel.
Enhancements:
- Changes were made to Category, OrganizationSearchParameters, SearchProfile, and Community.
- PolicyReference complements PolicyStatement.
- EvaluationScheme complements VotingScheme.
- The Envelope type was removed.
- The documentation was improved.

The Port Scan Attack Detector (psad) is a collection of three system daemons that are designed to work with the Linux Netfilter firewalling code to detect port scans and other suspect traffic.
Port Scan Attack Detector project features a set of highly configurable danger thresholds (with sensible defaults), verbose alert messages, email alerting, DShield reporting, and automatic blocking of offending IP addresses.
Psad incorporates many of the packet signatures included in Snort to detect various kinds of suspicious scans, and implements the same passive OS fingerprinting algorithm used by p0f.
Enhancements:
- A --gnuplot mode was added so that psad can output data that is suitable for plotting with gnuplot.
- The ability to negate match conditions on fields specified with the --CSV-fields argument was added.
- The Storable-2.16 module was added along with the --use-store-file argument so that in --gnuplot mode the Gnuplot data can be stored on disk and retrieved quickly.
- --analysis-fields was added so the iptables log messages that are parsed in -A mode can be restricted to those that meet certain criteria.

IANA /etc Files installs /etc/services and /etc/protocols using data from the Internet Assigned Numbers Authority. Included are snapshots of the data from the IANA, scripts to transform that data into the needed formats, and scripts to fetch the latest data.
Installation
The installation process is flexible and friendly to unattended installation even though, due to its simplicity, it does not use Autoconf.
For basic installation run:
make
su
make install
This creates /etc/services and /etc/protocols without using internet access.
To install in a different location, use something like:
make PREFIX=/mnt/tmp install
This would create /mnt/tmp/etc/services and /mnt/tmp/etc/protocols.
For unusual installations, "make PREFIX=/foo ETC_DIR=bar install" will create /foo/bar/services and /foo/bar/protocols.
Enhancements:
- This release contains updated data from the IANA, improvements to the test function, and support for generating stripped files.
- It is the second of a series of planned changes intended to meet the needs of distributions.

Generic Protocol Framework aims to allow users to rapidly prototype different emerging communications protocols. Implementations can be easily "dropped in" and tested independant of a finished product. Testing on both the end product, and the protocol itself can be easily accomplished. The tool aims to provide the developer and end user with a robust solution which can track the size of messages, how rapidly they will be generated, and how many of each type can be seen.
Why the GPF:
There are many similar tools available. The problem with many of these tools is that they are 1) closed source, 2) not easily adaptable to a specific implementation (they use custom languages), 3) expensive. The advantages of the GPF are its open source nature, the ease of which it can be adapted, and the cost: free!
Basic Flow:
Modification of the GPF is fairly simple. Tool-opts.h contains the basic options that will be applied to the packet while it is being built. To transmit a packet, the system calls the tx_message() function, and passes the message ID as well as the option block. This is then passed to the custom function: tx_message_custom() in tx.c. From the message id, the system selects an appropriate tx_* function (to be implemented by the user) and passes an unsigned char **, where the buffer will be written, and the option block. In turn, that function will make heavy use of the add_buf_tu*() functions, which will allow the user to add a tubyte8, tuint16, or tuint32 number to the buffer.
In daemonize mode, the basic options are set, and the system then listens for incomming packets. When a packet arrives, the system calls basic_parse() on the packet. This function then calls basic_parse_custom(), found in parse.c. In turn, this can call any appropriate parsing helpers, including the get_tu*() functions, which allow the user to retrieve a tubyte8, tuint16, or tuint32 from the buffer. CAVEAT: if the first two bytes of the buffer are zerod, it will be treated as an END message. However, recovery is available. In the basic_parse_custom() message, you can set the end_signal_caught variable of the option_block to 0. In this case, it will not stop the daemon from running.
Enhancements:
- Currently, TCP support is somewhat experimental.
- Testing for that portion will be ongoing.
- No clear examples are provided.
- The examples/ directory contains the precursors to a MIP example.

Samba Scanner / Mount / Umount is a tool to Scan Samba share from Host.

Samba Scanner / Mount / Umount can found and mount remote share in local folder. Umount Share and Device from System.

C::Scan::Constants Perl module contains slurp constants from specified C header (.h) files.

SYNOPSIS

## Intended for use in your modules Makefile.PL file, to
## add DWIMery to use of C constants within your module.

use C::Scan::Constants;

my @hdr_files = (
"/path/to/first_header.h",
"/path/to/second_header.h",
);

## Slurp a list of constant information from C headers
my @constants = extract_constants_from( @hdr_files );

## Create the C, XS, and pure-Perl machinery needed to
## provide automagical access to C constants at runtime.
write_constants_module( "Your::Module", @constants );

This module provides an alternative to using the h2ph command to generate Perl header (.ph) files that are then subsequently required by your module code. When you need access to C numeric and enumerated type constants, especially in a dynamic source tree environment, there are times when youd like something a little more automagical and closely tailored to what you actually need. Now you have it, in this module.

C::Scan::Constants was born out of a recognition that ModPerl::CScan and ExtUtils::Constant provide a wealth of capabilities in the area of C code parsing and autogenerated XS access to C constants, but that the actual mechanisms for harnessing them to do those things were really rather opaque. This module should help take (most of) the mystery out of those activities.