App-HTTP_Proxy_IMP

 view release on metacpan or  search on metacpan

examples/DelayRequest.pm  view on Meta::CPAN

use Net::IMP;
use Net::IMP::HTTP;
use Net::IMP::Debug;
use Scalar::Util 'weaken';

sub RTYPES { ( IMP_PASS ) }

sub new_analyzer {
    my ($class,%args) = @_;
    my $self = $class->SUPER::new_analyzer(%args);
    $self->run_callback(
	# we don't need to look at response
	[ IMP_PASS,1,IMP_MAXOFFSET ],
    );
    return $self;
}

sub validate_cfg {
    my ($class,%cfg) = @_;
    delete $cfg{delay};
    return $class->SUPER::validate_cfg(%cfg);
}

sub data {
    my ($self,$dir,$data,$offset,$type) = @_;
    if ( $dir == 0                             # request
	&& $type == IMP_DATA_HTTPRQ_HEADER     # header
	&& $data =~m{\AGET ((http://[^/]+/)[^\s]*)}
    ) {
	if(0) {
	    my ($base,$path) = ($2,$1);

examples/ReplaceUA.pm  view on Meta::CPAN

use Net::IMP;
use Net::IMP::Debug;

my $UA = 'Mozilla/5.0 (Windows NT 5.1; rv:10.0.2) Gecko/20100101 Firefox/10.0.20';

sub RTYPES { ( IMP_PASS,IMP_REPLACE ) }

sub new_analyzer {
    my ($class,%args) = @_;
    my $self = $class->SUPER::new_analyzer(%args);
    $self->run_callback(
	# we don't need to look at response
	[ IMP_PASS,1,IMP_MAXOFFSET ],
    );
    return $self;
}

sub validate_cfg {
    my ($class,%cfg) = @_;
    delete $cfg{ua};
    return $class->SUPER::validate_cfg(%cfg);
}

sub request_hdr {
    my ($self,$hdr) = @_;
    my $len = length($hdr) or return;
    $hdr =~s{^User-Agent:\s*(.*\n( .*\n)*)}{}sg;
    my $ua = $self->{factory_args}{ua} || $UA;
    $hdr =~s{\n}{\nUser-Agent: $ua\r\n}img;
    #warn $hdr;
    $self->run_callback( 

lib/App/HTTP_Proxy_IMP/Conn.pm  view on Meta::CPAN

    'imp_factory', # App::HTTP_Proxy_IMP::IMP factory
    # per connection
    'spool',       # any data which cannot be processed yet?
    'pcapw',       # Net::PcapWriter object
    'intunnel',    # true if connections is inside intercepted SSL tunnel
    'relay',       # weak reference to managing relay
);

sub new {
    my ($class,$upper_flow,%args) = @_;
    my $self = $class->SUPER::new($upper_flow);
    %$self = ( %$self, %args ) if %args;
    if ( ref($class)) { # from factory
	$self->{pcapdir} ||= $class->{pcapdir};
	$self->{imp_factory} ||= $class->{imp_factory};
	$self->{mitm} ||= $class->{mitm};
	$self->{capath} ||= $class->{capath};
    }
    return $self;
}

sub DESTROY { 
    my $self = shift or return;
    $self->xdebug("connection done"); 
    $self->SUPER::DESTROY();
}

sub clone {
    my $self = shift;
    return $self->new_connection(
	$self->{meta},
	$self->{relay}
    );
}

sub new_connection {
    my ($self,$meta,$relay) = @_;
    my $obj = $self->SUPER::new_connection($meta);

    if ( my $pcapdir = $self->{pcapdir} ) {
	open( my $fh,'>', sprintf("%s/%d.%d.pcap",$pcapdir,$$,$obj->{connid}))
	    or die "cannot open pcap file: $!";
	$fh->autoflush;
	my $w = Net::PcapWriter->new($fh);
	my $c = $w->tcp_conn( 
	    $meta->{daddr}, $meta->{dport},
	    $meta->{saddr}, $meta->{sport} 
	);
	$obj->{pcapw} = [$c,$w],
    }

    weaken( $obj->{relay} = $relay );
    return $obj;
}

sub in {
    my $self = shift;
    return $self->SUPER::in(@_) if ! $self->{pcapw};
    my ($dir,$data,$eof,$time) = @_;
    if ( defined ( my $bytes = eval { $self->SUPER::in(@_) } )) {
	$self->{pcapw}[0]->write($dir,substr($data,0,$bytes));
	return $bytes;
    } else {
	# save final data
	$self->{pcapw}[0]->write($dir,$data);
	die $@ if $@;
	return;
    }
}

lib/App/HTTP_Proxy_IMP/IMP/CSRFprotect.pm  view on Meta::CPAN

sub RTYPES { return (
    IMP_REPLACE, # remove Cookie/Authorization header
    IMP_LOG,     # log if we removed something
    IMP_DENY,    # bad requests/responses
    IMP_PASS,
)}

sub new_analyzer {
    my ($class,%args) = @_;
    my $self = $class->SUPER::new_analyzer(%args);
    $self->run_callback(
	# we will not modify response, but need to look at the response
	# header to detect redirects. After the response header was seen
	# this will be upgraded to IMP_PASS
	[ IMP_PREPASS,1,IMP_MAXOFFSET]
    );
    return $self;
}

sub request_hdr {

lib/App/HTTP_Proxy_IMP/IMP/Example/changeTarget.pm  view on Meta::CPAN

use base 'Net::IMP::HTTP::Request';

use Net::IMP;
use Net::IMP::Debug;

my $target = 'www.spiegel.de';
sub RTYPES { ( IMP_PASS,IMP_REPLACE,IMP_DENY ) }

sub new_analyzer {
    my ($class,%args) = @_;
    my $self = $class->SUPER::new_analyzer(%args);
    $self->run_callback(
	# we don't need to look at response
	[ IMP_PASS,1,IMP_MAXOFFSET ],
    );
    return $self;
}


sub request_hdr {
    my ($self,$hdr) = @_;

lib/App/HTTP_Proxy_IMP/IMP/FakeResponse.pm  view on Meta::CPAN

use Net::IMP::Debug;
use Carp;
use Digest::MD5;

sub RTYPES { ( IMP_PASS,IMP_REPLACE,IMP_DENY,IMP_ACCTFIELD ) }

sub new_factory {
    my ($class,%args) = @_;
    my $dir = $args{root} or croak("no root directory given");
    -d $dir && -r _ && -x _ or croak("cannot use base dir $dir: $!");
    my $obj = $class->SUPER::new_factory(%args);
    $obj->{root} = $dir;
    return $obj;
}

sub validate_cfg {
    my ($class,%args) = @_;
    my $dir = delete $args{root};
    delete $args{ignore_parameters};
    my @err = $class->SUPER::validate_cfg(%args);
    if ( ! $dir ) {
	push @err, "no 'root' given";
    } elsif ( ! -d $dir || ! -r _ || ! -x _ ) {
	push @err, "cannot access root dir $dir";
    }
    return @err;
}

sub request_hdr {
    my ($self,$hdr) = @_;

t/02_leak.t  view on Meta::CPAN

}

{
    package DummyFilter;
    use base 'Net::IMP::HTTP::Request';
    use Net::IMP;
    sub RTYPES { (IMP_PASS) }
    sub new_analyzer {
	Devel::TrackObjects->show_tracked;
	my $self = shift;
	my $obj = $self->SUPER::new_analyzer(@_);
	$obj->run_callback(
	    [ IMP_PASS,0,IMP_MAXOFFSET ],
	    [ IMP_PASS,1,IMP_MAXOFFSET ],
	);
	return $obj;
    }

    sub request_hdr {}
    sub request_body {}
    sub response_hdr {}