Free tcp software for linux

TCPDB is a Web application to keep track of your TCP/IP addresses and hosts. TCPDB is suited for both small and large networks with many locations and subnets. Are supported up to one A Class or 16777216 addresses.

Logon as root.
Unpack the software into web directory.
Create the mysql database.
mysqladmin create tcpdb
mysql tcpdb < tcpdb.sql
Logon.
Goto your http://yourdomain.com/tcpdb
Username: admin
Password: admin

TCPWatch is a utility written in Python that lets you monitor forwarded TCP connections or HTTP proxy connections.
It displays the sessions in a window with a history of past connections. It is useful for developing and debugging protocol implementations and web services.
Enhancements:
- Made compatible with versions of tcl that have threads enabled.
- Log file numbers are now sequential.
- "user@host" is now accepted as a destination hostname (the user name is ignored).

TCPreen is a simple tool to monitor and analyze data transmitted between clients and servers through connection-oriented streams data such as a TCP sessions; it supports TCP over either IPv4 or IPv6. This tool focuses on the data stream (software/socket layer), not on the lower level transmission protocol as packet sniffers do.

TCPreen listens on a TCP port and wait for incoming connections to come in. Then, it forwards data sent by the connecting client to another server port (possibly on another computer) and forwards server responses back to the client.

TCPreen can display data on your console in real-time and/or save it to log files for later reference. Various display formats are available.

While it was originally meant to help developers reverse-engineer TCP-based protocols, it can also be very useful to debug network server or client software or for a system administrator to monitor a TCP service.

TCP Knocking provides a port knocking implementation.
Often a secure system needs a port open so that only authorized persons can access a particular service and also the service should not exposed to attackers and worms that may use vulnerabilities that exist in the listening server. Port knocking is designed to be used as a complementary service to the existing authentication mechanism. But one of the biggest problems with port knocking is manipulating the firewall with timeouts.
When the correct knock sequence is sent, the firewall is modified for couple of seconds. Having the firewall open automatically for a time period will make any system administrator uncomfortable. TCP knocking attempts to solve the problem by incorporating the knock into the TCP handshake. Tcp knocking is similar to port knocking, but instead sending UDP packets with secret ports, the TCP handshake packets must include secrete codes. It is at least as secure as port knocking and it can be made secure with more hardening.
Modified TCP handshake:
In normal TCP handshake, the client sends the syn packet and chooses a random initial sequence number. The server responds with a packet that has both syn and ack flags set, choosing a random
The modified TCP handshake uses the empty fields in the header. The server does not respond to connection requests without a special code generated along with the syn packet. The server also encrypts the ISN in the ack packet (2) and the final packet of the three-way handshake must have the correct acknowledgment for the servers ISN. The system is further protected from brute-force attacks by closing the connection if the first attempt for the third packet does not have the expected acknowledgment sequence.
Also, rather than use conventional encryption techniques like HMAC for verification, this system uses a file with random numbers as the key. This is because of the limited unused space available in the TCP/IP header which makes HMAC very weak. By using a shared file, the length of the key can be much greater than traditional systems and even though some parts of the key can be revealed by attacks, the server can protect itself from replay attacks.
The handshake:
1) Syn
The syn packet does not use the 32 bit acknowledgment field in the TCP header as it the the first packet to initiate the connection. Further the 16 bit IPID can be used to transmit information. In the current implementation only the 32 bit acknowledgment field is used. Currently the 32 bit ack is derived from a 64 KB file which contains random numbers. The ISN and the source IP address along with the random numbers are used to generate this value.
2) Syn/Ack
The ISN is encrypted using the random numbers from the 64 KB file using the destination IP address as well as a 16 bit random number used as IPID. I do not have code for this part yet.
3) Ack
The client decrypts the syn number from the encrypted syn, the key file, the 16 bit IPID and its own IP address and sends the ack packet. The server closes all connections from the client for couple of minutes if it sends a wrong ack value. Part of the security relies on the fact that the ISN generated by Linux 2.6 is fairly random.
Implementation:
I have implemented only the first part, which is the server expecting secret code along with the first syn packet from the client. Hence it is very possible to brute-force the server. Also the system is designed with the second phase in mind, which is the encrypted Initial Sequence Number in the ack packet and closing the connection if the correct ack is not sent on the first try. I do not have an implementation for that yet. The security will be increased greatly when the second phase is incorporated. Also the ability to detect brute-force attacks can be added to this system.
But the current system can be used for protecting the server from worms and random scanning. The use-case is similar to port knocking but it does not use the ugly system of opening the firewall for a couple of seconds. Vanilla port knocking is susceptible to brute-force attacks as well. Besides, inserting a kernel module to just ssh into your server will increase your mad sysadmin points.
Enhancements:
- TCP knocking with Phase 1 of the protocol was implemented.

libtcp++ is a C++ class library to facilitate the creation of TCP/IP clients and servers. libtcp++ has three classes, TcpClient, TcpServer and TcpIpRuleSet.

TcpServer has build it logging capability peer detection method, and IP-based access control in addition to regular server functionality.

TcpClient supports a user specified timeout on connect(), nice for port/host scanning, and other situations when you may be connecting to a dead host or a firewalled port.

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.

Libsocketcpp provides a easy-to-use C++ socket library class.
Dispite the name, the TCPSocket class can handle both UDP and TCP connections.
Unfortunatly right now, the class is simple. It does not do anything really fancy like non-blocking sockets, select which interfaces you want to use, etc...
What it does allow you to do is to set up a TCP or UDP server/client and send and receive blocks of data. Plain and simple
Enhancements:
- Fixed missing include inside tcpservertest test program.
- Should be able to compile on RH 7.0 now.

POE::Component::Proxy::TCP is a simplified TCP proxy.

SYNOPSIS

use POE qw(Component::Proxy::TCP);
POE::Component::Proxy::TCP->new
(Alias => "ProxyServerSessionAlias",
Port => $local_server_port,
OrigPort => $remote_server_port,
OrigAddress => $remote_server_host,
DataFromClient => &data_from_client_handler,
DataFromServer => &data_from_server_handler,
);


# gets called with data passed from server.
# called inside the per client connected session created by PoCo::Server::TCP
sub data_from_server_handler {
my $server_data = shift;
# show obtaining other session info esp per proxy session info
};

# gets called with data passed from remote client
#
sub data_from_client_handler {
my $server_data = shift;
};

# show obtaining other session info esp per proxy session info
# Reserved HEAP variables:

$heap->{self} = Proxy object / instance var hash
$heap->{self}->losta stuff add documentation
[do the per connection ones]
EXAMPLE ^
use warnings;
use strict;
use diagnostics;
use POE;
use POE::Filter::Stream;
use POE::Filter::Line;
use POE::Component::Proxy::TCP;
$|++;

POE::Component::Proxy::TCP->new
(Alias => "ProxyServerSessionAlias",
Port => 4000,
OrigPort => 5000,
OrigAddress => "localhost",
DataFromClient => sub {print "From client:", shift(), "n";},
DataFromServer => sub {print "From server:", shift(), "n";},
RemoteClientFilter => "POE::Filter::Stream",
RemoteServerOutputFilter => "POE::Filter::Stream",
RemoteServerInputFilter => "POE::Filter::Stream"
);

$poe_kernel->run();
exit 0;