Free proxy avoidance software for linux

Proxy Detector is a PHP class that can detect HTTP requests via proxy. This class can detect if a visitor uses a proxy server by scanning the headers returned by the user client.
When the user uses a proxy server, most of the proxy servers alter the header. The header is returned to PHP in the array $_SERVER.
Enhancements:
- This is the first release of the class and implementation example.

proxyScan.pl is a Perl script for security penetration testing, to scan for hosts and ports through a Web proxy server.

Features include various HTTP methods such as GET, CONNECT, HEAD as well as host and port ranges.

IOC::Proxy::Interfaces is a IOC::Proxy subclasss to proxy objects with a given interface.

SYNOPSIS

use IOC::Proxy::Interfaces;

my $proxy_server = IOC::Proxy->new({
interface => AnInterface,
# ... add other config values here
});

$proxy_server->wrap($object);
# our $object is now proxied, but only the
# methods which are part of the interface
# will work, all others will throw exceptions

$object->method_in_interface(); # works as normal

$object->method_not_in_interface(); # will thrown an exception

This is a subclass of IOC::Proxy which allows for the partial proxing of an object. It will only proxy the methods of a given interface, all other methods will throw a IOC::MethodNotFound exception. This could be used to (in a very weird way) emulate the concept of upcasting in Java, it is also somewhat like the idea of using interfaces with Dynamic Proxies in Java as well (see the article link in "SEE ALSO").

This proxy can be useful if you need to have an object strictly conform to a particular interface in a particular situation. The interface class is also pushed onto the proxies @ISA so that it will respond to UNIVERSAL::isa($object, Interface) correctly. Keep in mind that there is no need for the object being proxied to have the interface in its @ISA prior to being proxied. The proxy is dynamic and only requires that the object conform to the interface when it is being wraped but the proxy object.

HTTP Proxy Client is the small set of libraries and scripts, which provides transparent access to Internet via HTTP proxy for programs, which uses TCP/IP for communication.
The list of programs includes: telnet, ftp, licq, cvs, smth else? Project implements dynamic library, that can be preloaded before program run.
The library substitutes some system calls (connect(), gethostbyaddr(), gethostbyname()), with calls, which makes TCP/IP connection through HTTP proxy. This allows client programs behind HTTP proxy work with Internet without limitations.
At the moment tested on i386 Linux, i386/sparc Solaris.
Enhancements:
- While using dotted address, applications will attempt to connect regardless DNS lookup result.

Japt-Proxy is a JAVA based Caching Proxy for Debians APT-System. Japt-Proxy is very reliable and lightning fast. Japt-Proxy is usually used in environments where several Debian systems have to be kept up-to-date without downloading the same files over and over again from the debian mirrors. Mostly these environments are data centers, Linux-powered companies, schools, public authorities and so on.
Often Japt-Proxy is used because of small sized internet connections but it is also useful to install complete debian systems over the net (read: over the proxy). Even with high volume internet connections Japt-Proxy can dramatically reduce the time to install or update Debian on many machines.
Why Java?
I know there are people out there thinking "Hey? Why Java?". There are a bunch of reasons why people asking those questions. I have a simple answer to all those questions. The answer is, that Java enabled me to easily develop the fastest and most reliable APT-Proxy. Java and the Apache Software Foundation provides such good libraries for this job, that it wasnt very hard to bring up this tool.
If you dont trust, test it - the installation takes less than five minutes!
Doesnt a general proxy server supersede an APT-Proxy?
No, it doesnt. Japt-Proxy knows the characteristics of a Debian archive and their files. It knows, for example, that .deb files wont change, because newer files would have a new name (the version is always part of the filename), hence it wont recheck if there is a newer version of this specific file.
Furthermore you can configure the Japt-Proxy to delete old versions of a package in its cache directory - a general proxy cache would simple delete files that havent been requested for some time.
So, a general caching proxy like Squid is a perfect tool for caching "normal" internet traffic. If you need a proxy for faster APT access - Japt-Proxy is the right tool for you.
Main features:
- Caching of all apt requests from Debian archives
- Multi-threaded architecture which increases the download speed enormously when several machines are requesting packages
- Builds up a partial mirror directory automatically, with exactly the same directory structure and filenames as the original mirror
- Automatic and configurable cache cleanup (purging packages in cache if newer versions exists)
- Makes sources.list configuration easier for multiple machines - if you change your internet backend server you only have to make the change once in Japt-Proxy, instead of on all Debian machines
- Works with multiple architectures
- Backend support for HTTP and FTP
- existing .debs can be copied into the Japt-Proxy cache directory (from a CD or DVD for example) and will be used by the Proxy automatically

Net::Proxy is a Perl framework for proxying network connections in many ways.

SYNOPSIS

use Net::Proxy;

# proxy connections from localhost:6789 to remotehost:9876
# using standard TCP connections
my $proxy = Net::Proxy->new(
{ in => { type => tcp, port => 6789 },
out => { type => tcp, host => remotehost, port => 9876 },
}
);

# register the proxy object
$proxy->register();

# and you can setup multiple proxies

# and now proxy connections indefinitely
Net::Proxy->mainloop();

A Net::Proxy object represents a proxy that accepts connections and then relays the data transfered between the source and the destination.

The goal of this module is to abstract the different methods used to connect from the proxy to the destination.
A proxy is a program that transfer data across a network boundary between a client and a server. Net::Proxy introduces the concept of "connectors" (implemented as Net::Proxy::Connector subclasses), which abstract the server part (connected to the client) and the client part (connected to the server) of the proxy.

This architecture makes it easy to implement specific techniques to cross a given network boundary, possibly by using a proxy on one side of the network fence, and a reverse-proxy on the other side of the fence.