Free silica gel packets software for linux

deja-packet transmits raw packets through a specified interface.

Usage: ./deja-packet -pcap < libpcap capture file > < interface name >
or: ./deja-packet -raw < raw packet file > < interface name >

Note: you must be root to successfully transmit packets with deja-packet due to the Linux security restrictions with raw sockets.

In the [-p]cap mode, deja-packet transmits selected packets from a libpcap capture file (such as one created by Ethereal/Wireshark, or tcpdump). In the [-r]aw mode, deja-packet transmits the raw contents of a file as one whole packet.

The [-p]cap mode is interactive: the user will be continuously prompted to select which packet from the libpcap capture file to transmit, until the “q” character is encountered, where the program will quit.

Example pcap mode:

$ sudo ./deja-packet -p icmp_ping.pcap eth0
Select packet number (1 to 6) for transmission or q for quit: 1
Successfully transmitted packet!
Select packet number (1 to 6) for transmission or q for quit: 2
Successfully transmitted packet!
Select packet number (1 to 6) for transmission or q for quit: 5
Successfully transmitted packet!
Select packet number (1 to 6) for transmission or q for quit: 6
Successfully transmitted packet!
Select packet number (1 to 6) for transmission or q for quit: q
$

In the [-r]aw mode, deja-packet exits immediately after the attempted transmission is complete (allows deja-packet to be easily used with a script).

Example raw mode:

$ sudo ./deja-packet -r samplepacket eth0
Successfully transmitted packet!
$

icmp_ping.pcap is included as a sample libpcap capture file.

To compile deja-packet, simply use the command “make”.

deja-packet remains Linux-only because it requires PF_PACKET sockets.

This project is released under the GNU General Public License version 2.

packETH is a Linux GUI packet generator tool for ethernet. The project allows you to create and send any possible packet or sequence of packets on the ethernet.
Main features:
you can create and send any ethernet packet. Supported protocols:
- ethernet II, ethernet 802.3, 802.1q, QinQ
- ARP, IPv4, user defined network layer payload
- UDP, TCP, ICMP, IGMP, user defined transport layer payload
- RTP (payload with options to send sin wave of any frequency for G.711)
sending sequence of packets
- delay between packets, number of packets to send
- sending with max speed, approaching the teoretical boundary
- change parameters while sending (change IP & mac address, UDP payload, 2 user defined bytes, etc.)
saving configuration to a text file and load from it.
Enhancements:
- new features

SYNOPSIS

use NetPacket::IP;

$ip_obj = NetPacket::IP->decode($raw_pkt);
$ip_pkt = NetPacket::IP->encode($ip_obj);
$ip_data = NetPacket::IP::strip($raw_pkt);

NetPacket::IP provides a set of routines for assembling and disassembling packets using IP (Internet Protocol).

Methods

NetPacket::IP->decode([RAW PACKET])

Decode the raw packet data given and return an object containing instance data. This method will quite happily decode garbage input. It is the responsibility of the programmer to ensure valid packet data is passed to this method.

NetPacket::IP->encode()

Return an IP packet encoded with the instance data specified. This will infer the total length of the packet automatically from the payload lenth and also adjust the checksum.

Functions

NetPacket::IP::strip([RAW PACKET])

Return the encapsulated data (or payload) contained in the IP packet. This data is suitable to be used as input for other NetPacket::* modules.

This function is equivalent to creating an object using the decode() constructor and returning the data field of that object.

Instance data

The instance data for the NetPacket::IP object consists of the following fields.

ver

The IP version number of this packet.

hlen

The IP header length of this packet.

flags

The IP header flags for this packet.

foffset

The IP fragment offset for this packet.

tos

The type-of-service for this IP packet.

len

The length (including length of header) in bytes for this packet.

id

The identification (sequence) number for this IP packet.

ttl

The time-to-live value for this packet.

proto

The IP protocol number for this packet.

cksum

The IP checksum value for this packet.

src_ip

The source IP address for this packet in dotted-quad notation.

dest_ip

The destination IP address for this packet in dotted-quad notation.

options

Any IP options for this packet.

data

The encapsulated data (payload) for this IP packet.

NetPacket::TCP is a Perl module to assemble and disassemble TCP (Transmission Control Protocol) packets.

SYNOPSIS

use NetPacket::TCP;

$tcp_obj = NetPacket::TCP->decode($raw_pkt);
$tcp_pkt = NetPacket::TCP->encode($ip_pkt);
$tcp_data = NetPacket::TCP::strip($raw_pkt);

NetPacket::TCP provides a set of routines for assembling and disassembling packets using TCP (Transmission Control Protocol).

Methods

NetPacket::TCP->decode([RAW PACKET])

Decode the raw packet data given and return an object containing instance data. This method will quite happily decode garbage input. It is the responsibility of the programmer to ensure valid packet data is passed to this method.

NetPacket::TCP->encode($ip_obj)

Return a TCP packet encoded with the instance data specified. Needs parts of the ip header contained in $ip_obj in order to calculate the TCP checksum.

Functions

NetPacket::TCP::strip([RAW PACKET])

Return the encapsulated data (or payload) contained in the TCP packet. This data is suitable to be used as input for other NetPacket::* modules.

This function is equivalent to creating an object using the decode() constructor and returning the data field of that object.

Instance data

The instance data for the NetPacket::TCP object consists of the following fields.

src_port

The source TCP port for the packet.

dest_port

The destination TCP port for the packet.

seqnum

The TCP sequence number for this packet.

acknum

The TCP acknowledgement number for this packet.

hlen

The header length for this packet.

reserved

The 6-bit "reserved" space in the TCP header.

flags

Contains the urg, ack, psh, rst, syn, fin, ece and cwr flags for this packet.

winsize

The TCP window size for this packet.

cksum

The TCP checksum.

urg

The TCP urgent pointer.

options

Any TCP options for this packet in binary form.

data

The encapsulated data (payload) for this packet.

NetPacket::LLC is a Perl module to assemble and disassemble IEEE 802.3 LLC protocol packets.

SYNOPSIS

use NetPacket::LLC;
use NetPacket::SpanningTree;

$llc_data = NetPacket::Ethernet->strip($raw_packet);
$st_data = NetPacket::LLC->strip($llc_data);
$st_obj = NetPacket::SpanningTree->decode($st_data);

NetPacket::LLC provides a set of routines for assembling and disassembling packets using the IEEE standard LLC protocol layer.

Methods

NetPacket::LLC->decode([ST DATA])
Decode the LLC packet data and return an object containing instance data. This method will probably decode garbage input, but it wont mean much.

NetPacket::SpanningTree->encode($st_hash)

Encode the hash into a raw data stream that may be appended to ethernet packet data. This allows the user to create his/her own LLC protocol packet and subsequently send it out on the wire (though sending on the wire isnt a function of this module).

libpcapnav is a libpcap wrapper library that allows navigation to arbitrary locations in a tcpdump trace file between reads.
The API is intentionally much like that of the pcap library. You can navigate in trace files both in time and space: you can jump to a packet which is at appr. 2/3 of the trace, or you can jump as closely as possible to a packet with a given timestamp, and then read packets from there. In addition, the API provides convenience functions for manipulating timeval structures.
Like libpcap, this library handles things through an opaque handle struct. For trace file navigation and reading packets, this handle is enough. If you need to apply BPF filters or write packets to disk, you can access the familiar pcap handle that is used internally.
At the core of libpcapnav is the ability to resynchronize to the sequence of packets contained in a tcpdump trace file at arbitrary location of the file position indicator.
The algorithm is based on Vern Paxsons method from the the tcpslice tool, that basically works as follows: the point near which the file position indicator is to be synchronized with the packet sequence is undershot a little bit, as it is much easier to scan forwards to the desired location, once the packet sequence has been detected.
The file is scanned from that initial offset in single-byte steps, at each step assuming a libpcap packet header is present and sanity-checking the values read. Several checks analyze this potential header for sane timestamps, capture lengths etc. If the header appears valid, the next packet header is examined in a similar function, based upon the offset that the checked header provides.
If a sequence of three packets seems valid, the algorithm considers the file position pointer to be synchronized with the packet flow and scans as closely as possible to the desired location. If the synchronization point is supposed to be a packet with a given timestamp, some interpolation is done and the process repeated, until the packet closest to the desired timestamp has been found.x
Enhancements:
- This release introduces large file support and better build support on OS X.

NetPacket::ICMP is a Perl module to assemble and disassemble ICMP (Internet Control Message Protocol) packets.

SYNOPSIS

use NetPacket::ICMP;

$icmp_obj = NetPacket::ICMP->decode($raw_pkt);
$icmp_pkt = NetPacket::ICMP->encode();
$icmp_data = NetPacket::ICMP::strip($raw_pkt);

NetPacket::ICMP provides a set of routines for assembling and disassembling packets using ICMP (Internet Control Message Protocol).

Methods

NetPacket::ICMP->decode([RAW PACKET])
Decode the raw packet data given and return an object containing instance data. This method will quite happily decode garbage input. It is the responsibility of the programmer to ensure valid packet data is passed to this method.

NetPacket::ICMP->encode()
Return an ICMP packet encoded with the instance data specified.

Layer-7 Packet Classifier for Linux is a packet classifier for Netfilter that identifies packets based on application layer (OSI layer 7) data. This means that it is able to classify packets as HTTP, FTP, Gnucleus, Kazaa, etc., regardless of ports.
It complements existing matches that classify based on port numbers, packet length, TOS bits, and so on. Combined with Linux QoS, it allows for full layer 7 packet shaping.
Main features:
- Patches for Linux 2.4 and 2.6
- Support for TCP, UDP and ICMP over IPv4
- Uses Netfilters connection tracking of FTP, IRC, etc
- Examines data across multiple packets
- Number of packets examined tunable on the fly through /proc
- Number of bytes examined tunable at module load time
- Distinguishes between new connections (those still being tested) and old unidentified connections
- Gives access to both Netfilter and QoS (rate limiting) features
- With the Netfilter "helper" match, you can distinguish between parent and child connections (e.g. ftp command/data)