\s*/$1/imsg;
open my $fh, '>', $target or die "can't clobber $target: $!\n";
print $fh $text;
close $fh;
foreach my $tempfile (@Tempfiles) {
unlink $tempfile;
}
}
foreach my $target (keys %COPY) {
my $source = $COPY{$target};
copy($source, $target);
}
CGI-Application-Plugin-LinkIntegrity-0.06/misc/prove_prereqs.pl 0100644 0001752 0000144 00000004772 10432775231 024056 0 ustar michael users #!/usr/bin/perl
=pod
This script allows you to run the test suite, simulating the absense of
a particular set of Perl modules, even if they are installed on your
system.
To run the test suite multiple times in a row, each tie multiple times
(each with a different selection of absent modules), run:
$ perl misc/prove_prereqs.pl t/*.t
To add a new set of absent modules, make a subdir under t/prereq_scenarios, and
add a dummy perl module for every module you want to skip. This file
should be empty. For instance if you wanted to simulate the absense of
XML::Complicated and Config::Obscure, you would do the following:
$ mkdir t/prereq_scenarios/skip_xc+co
$ mkdir t/prereq_scenarios/skip_xc+co/XML
$ touch t/prereq_scenarios/skip_xc+co/XML/Complicated.pm
$ mkdir t/prereq_scenarios/skip_xc+co/Config
$ touch t/prereq_scenarios/skip_xc+co/Config/Obscure.pm
Finally, add this directory to the @Scenarios array below.
=cut
my @Scenarios = qw(
t/prereq_scenarios/cgi-3.10
t/prereq_scenarios/cgi-3.11
t/prereq_scenarios/cgi-3.20
);
###################################################################
use strict;
use File::Find;
unless (@ARGV) {
die "Usage: $0 [args to prove]\n";
}
my %Skip_Modules;
my $errors;
foreach my $prereq_scenarios_dir (@Scenarios) {
if (!-d $prereq_scenarios_dir) {
$errors = 1;
warn "Skip lib dir does not exist: $prereq_scenarios_dir\n";
next;
}
my @modules;
find(sub {
return unless -f;
my $dir = "$File::Find::dir/$_";
$dir =~ s/^\Q$prereq_scenarios_dir\E//;
$dir =~ s/\.pm$//;
$dir =~ s{^/}{};
$dir =~ s{/}{::}g;
push @modules, $dir;
}, $prereq_scenarios_dir);
$Skip_Modules{$prereq_scenarios_dir} = \@modules;
}
die "Terminating." if $errors;
foreach my $prereq_scenarios_dir (@Scenarios) {
my $modules = join ', ', sort @{ $Skip_Modules{$prereq_scenarios_dir} };
$modules ||= 'none';
print "\n##############################################################\n";
print "Running tests. Old (or absent) modules in this scenario:\n";
print "$modules\n";
my @prove_command = ('prove', '-Ilib', "-I$prereq_scenarios_dir", @ARGV);
system(@prove_command) && do {
die <link_integrity_config(
secret => 'some secret string known only to you and me',
);
}
sub account_info {
my $self = shift;
my $account_id = get_user_account_id();
my $template = $self->load_tmpl('account.html');
$template->param(
'balance' => $self->link("/account.cgi?rm=balance&acct_id=$account_id");
'transfer' => $self->link("/account.cgi?rm=transfer&acct_id=$account_id");
'withdrawal' => $self->link("/account.cgi?rm=withdrawl&acct_id=$account_id");
);
}
In your template:
Welcome to The Faceless Banking Corp.
Actions:
">Show Balance
">Make a Transfer
">Get Cash
This will send the following HTML to the browser:
Welcome to The Faceless Banking Corp.
Actions:
Show Balance
Make a Transfer
Get Cash
The URLs created are now tamper-resistent. If the user changes "acct_id"
from 73 to 74, the "_checksum" will not match, and the system will treat
it as an intrusion attempt.
Calling link and self_link directly from the template
If you use "Template::Toolkit|Template" or
"HTML::Template::Plugin::Dot", you can pass the "CGI::Application" $self
object into the template and call "link" and "self_link" directly from
the template. In your app:
$template->param(
'app' => $self,
'name' => 'gordon',
'email' => 'gordon@example.com',
);
And in your template you can use
# Template::Toolkit syntax
...
# HTML::Template::Plugin::Dot syntax
">...
# Petal syntax
...
Note that in the parameters of the call to << link >>, items enclosed in
quotes are treated as literal parameters and barewords are treated as
template params. So 'email' is the literal string, and "email" is the
template paramter named email (in this case 'gordon@example.com').
DESCRIPTION
"CGI::Application::Plugin::LinkIntegrity" lets you create
tamper-resistent links within your CGI::Application project. When you
create an URL with "link", a "_checksum" is added to the URL:
my $link = $self->link("/account.cgi?rm=balance&acct_id=73");
print $link; # /account.cgi?rm=balance&acct_id=73&_checksum=1d7c4b82d075785de04fa6b98b572691
The checksum is a (cryptographic) hash of the URL, plus a secret string
known only to the server.
If the user attempts to change part of the URL (e.g. a query string
parameter, or the PATH_INFO), then the checksum will not match. The run
mode will be changed to "link_tampered", and the "invalid_checksum" hook
will be called.
You can define the "link_tampered" run mode yourself, or you can use the
default "link_tampered" run mode built into
CGI::Application::Plugin::LinkIntegrity.
You can disable link checking during development by passing a true value
to the "disable" parameter of "$self->link_integrity_config".
METHODS
link_integrity_config
Configure the CGI::Application::Plugin::LinkIntegrity. Usually, it makes
sense to configure this in the "setup" method of your application's base
class:
use CGI::Application::Plugin::LinkIntegrity;
use base 'CGI::Application';
package My::Project;
sub setup {
my $self = shift;
$self->run_modes(['bad_user_no_biscuit']);
$self->link_integrity_config(
secret => 'some secret string known only to you and me',
link_tampered_run_mode => 'bad_user_no_biscuit',
digest_module => 'Digest::MD5',
disable => 1,
);
}
Or you can pull in this configuration info from a config file. For
instance, with using CGI::Application::Config::Context:
use CGI::Application::Plugin::LinkIntegrity;
use CGI::Application::Plugin::Config::Context;
use base 'CGI::Application';
package My::Project;
sub setup {
my $self = shift;
$self->conf->init(
file => 'app.conf',
driver => 'ConfigGeneral',
);
my $config = $self->conf->context;
$self->link_integrity_config(
$config->{'LinkIntegrity'},
additional_data => sub {
my $self = shift;
return $self->session->id;
},
);
my $link_tampered_rm = $config->{'LinkIntegrity'}{'link_tampered_run_mode'} || 'link_tampered';
$self->run_modes([$link_tampered_rm]);
}
Then in your configuration file:
secret = some REALLY secret string
link_tampered_run_mode = bad_user_no_biscuit
hash_algorithm = SHA1
disable = 1
This strategy allows you to enable and disable link checking on the fly
by changing the value of "disable" in the config file.
The following configuration parameters are available:
secret
A string known only to your application. At a commandline, you can
generate a secret string with md5:
$ perl -MDigest::MD5 -le"print Digest::MD5::md5_hex($$, time, rand(42));"
Or you can use Data::UUID:
$ perl -MData::UUID -le"$ug = new Data::UUID; $uuid = $ug->create; print $ug->to_string($uuid)"
If someone knows your secret string, then they can generate their
own checksums on arbitrary data that will always pass the integrity
check in your application. That's a Bad Thing, so don't let other
people know your secret string, and don't use the default secret
string if you can help it.
additional_data
You can pass constant additional data to the checksum generator for
every link.
$self->link_integrity_config(
secret => 'really secret',
additional_data => 'some other secret data',
}
For instance, to stop one user from following a second user's link,
you can add a user-specific component to the session, such as the
user's session id:
$self->link_integrity_config(
secret => 'really secret',
additional_data => sub {
my $self = shift;
return $self->session->id;
}
}
You can pass a string instead of a subroutine. But in the case of
the user's session, a subroutine is useful so that you get the value
of the user's session at the time when the checksum is generated,
not at the time when the link integrity system is configured.
checksum_param
The name of the checksum parameter, which is added to the query
string and contains the cryptographic checksum of link. By default,
this parameter is named "_checksum".
link_tampered_run_mode
The run mode to go to when it has been detected that the user has
tampered with the link. The default is "link_tampered".
See "The link_tampered Run Mode", below.
digest_module
Which digest module to use to create the checksum. Typically, this
will be either "Digest::MD5" or "Digest::SHA1". However any module
supported by "Digest::HMAC" will work.
The default "digest_module" is "Digest::MD5".
checksum_generator
If you want to provide a custom subroutine to make your own
checksums, you can define your own subroutine do it via the
"make_checksum" param. Here's an example of one that uses
Digest::SHA2:
$self->link_integrity_config(
checksum_generator => sub {
my ($url, $secret) = @_;
require Digest::SHA2;
my $ctx = Digest::SHA2->new();
$ctx->add($url . $secret);
return $ctx->hexdigest;
},
);
disable
You can disable link checking entirely by setting "disable" to a
true value. This can be useful when you are developing or debugging
the application and you want the ability to tweak URL params without
getting busted.
link
Create a link, and add a checksum to it.
You can add parameters to the link directly in the URL:
my $link = $self->link('/cgi-bin/app.cgi?var=value&var2=value2');
Or you can add them as a hash of parameters after the URL:
my $link = $self->link(
'/cgi-bin/app.cgi',
'param1' => 'value',
'param2' => 'value2',
);
self_link
Make a link to the current application, with optional parameters, and
add a checksum to the URL.
my $link = $self->self_link(
'param1' => 'value1',
'param2' => 'value2',
);
"self_link" preserves the value of the current application's
"PATH_INFO". For instance if the current URL is:
/cgi-bin/app.cgi/some/path?foo=bar # PATH_INFO is 'some/path'
Calling:
$self->self_link('bar' => 'baz');
Will produce the URL:
/cgi-bin/app.cgi/some/path?bar=baz
If you want to remove the "PATH_INFO" value or replace it with a new
value, use path_link.
path_link
Calling "path_link" is the same as calling "self_link", except the
current value of "PATH_INFO" can be replaced.
my $link = $self->path_link(
'/new/path',
'param1' => 'value1',
'param2' => 'value2',
);
For instance if the current URL is:
/cgi-bin/app.cgi/some/path?foo=bar # PATH_INFO is 'some/path'
Calling:
$self->path_link('/new/path');
Will produce the URL:
/cgi-bin/app.cgi/new/path?foo=bar
If you want to remove "PATH_INFO" entirely, call one of the following:
$self->path_link;
$self->path_link(undef, 'param1' => 'val1', 'param2 => 'val2' ...);
$self->path_link('', 'param1' => 'val1', 'param2 => 'val2' ...);
If you want to keep the existing "PATH_INFO" that was passed to the
current application, use self_link instead.
RUN MODES
The link_tampered Run Mode
Your application is redirected to this run mode when it has been
detected that the user has tampered with the link. You can change the
name of this run mode by changing the value of the
"link_tampered_runmode" param to "link_integrity_config".
CGI::Application::Plugin::LinkIntegrity provides a default
"link_tampered" run mode, which just displays a page with some stern
warning text.
You can define your own as follows:
sub link_tampered {
my $self = shift;
my $template = $self->load_template('stern_talking_to');
return $template->output;
}
HOOKS
When a link is followed that doesn't match the checksum, the
"invalid_checksum" hook is called. You can add a callback to this hook
to do some cleanup such as deleting the user's session. For instance:
sub setup {
my $self = shift;
$self->add_callback('invalid_checksum' => \&bad_user);
}
sub bad_user {
my $self = shift;
# The user has been messing with the URLs, possibly trying to
# break into the system. We don't tolerate this behaviour.
# So we delete the user's session:
$self->session->delete;
}
AUTHOR
Michael Graham, ""
ACKNOWLEDGEMENTS
This module was based on the checksum feature originally built into
Richard Dice's CGI::Application::Framework.
BUGS
Please report any bugs or feature requests to
"bug-cgi-application-plugin-linkintegrity@rt.cpan.org", or through the
web interface at . I will be notified, and then
you'll automatically be notified of progress on your bug as I make
changes.
COPYRIGHT & LICENSE
Copyright 2005 Michael Graham, All Rights Reserved.
This program is free software; you can redistribute it and/or modify it
under the same terms as Perl itself.
CGI-Application-Plugin-LinkIntegrity-0.06/Changes 0100644 0001752 0000144 00000005370 10432775231 021160 0 ustar michael users Revision history for CGI-Application-Plugin-LinkIntegrity
0.06 May 18, 2006
- the entry point code added so many months ago had a bug in it:
When there is a blank query string, CGI.pm adds an empty 'keywords'
key to the query paremeters. This meant that 'GET' requests
without parameters would fail.
0.05 October 3, 2005
- now install 'invalid_checksum' hook at class load time
0.04 October 3, 2005
- made the module actually useful! In order to generate a valid
link, you need to load the module. However you can't load the
module if the application was invoked with an invalid URL.
Catch-22. So now there's an entry point: if the invoking URL
contained no parameters, then it is considered to be valid.
- changed setup of hooks to happen at config time instead of
import time. Hopefully this makes it possible to use '@ISA'
instead of 'use base':
# Typical usage
use base 'CGI::Application';
use CGI::Application::Plugin::LinkIntegrity;
# This also works
use CGI::Application;
our @ISA = qw(CGI::Application);
use CGI::Application::Plugin::LinkIntegrity;
- made CGI version 2.37 or greater a prerequisite (for url_param)
0.03 August 21, 2005
- NOTE: This release is not compatible with previous versions.
- API radically rewritten to make it possible to protect links
directly from within templates (Thanks to Michael Peter and
Mark Stosberg for the feedback and ideas)
- the following methods have changed:
Old Syntax New Syntax
========== ==========
->make_link($url, { 'p1' => 'v1'}) ->link($url, 'p1' => 'v1')
->make_self_link($url, ->self_link($url, 'p1' => 'v1')
keep_path_info => 1,
params => { 'p1' => 'v1'})
->make_self_link($url, ->path_link('', 'p1' => 'v1')
keep_path_info => 0,
params => { 'p1' => 'v1'})
->make_self_link($url, ->path_link('/new/path', 'p1' => 'v1')
path_info => '/new/path'
params => { 'p1' => 'v1'}
)
- added documentation illustrating how to call link, make_link,
etc. directly from templates
0.02 ????
- added 'additional_data' feature
0.01 ????
- First development version released for comments and feedback
CGI-Application-Plugin-LinkIntegrity-0.06/Build.PL 0100644 0001752 0000144 00000001502 10432775231 021152 0 ustar michael users use strict;
use warnings;
use Module::Build;
my $builder = Module::Build->new(
module_name => 'CGI::Application::Plugin::LinkIntegrity',
license => 'perl',
dist_author => 'Michael Graham ',
dist_version_from => 'lib/CGI/Application/Plugin/LinkIntegrity.pm',
requires => {
'Test::More' => 0,
'CGI::Application' => 4.0, # need hooks
'URI' => 0,
'URI::Escape' => 0, # included in URI
'URI::QueryParam' => 0, # included in URI
'Digest::HMAC' => 0,
'Digest::MD5' => 0,
'CGI' => 2.37,
},
add_to_cleanup => [ 'CGI-Application-Plugin-LinkIntegrity-*' ],
create_makefile_pl => 'traditional',
);
$builder->create_build_script();
CGI-Application-Plugin-LinkIntegrity-0.06/MANIFEST.SKIP 0100644 0001752 0000144 00000000204 10432775231 021552 0 ustar michael users ^_build
^Build$
^blib
~$
\.cvsignore$
\.bak$
CVS
^cover_db
^readme.txt$
^changes.txt$
^[^/]*\.html$
\.gz$
\.tar$
^t/prereq_scenarios CGI-Application-Plugin-LinkIntegrity-0.06/Makefile.PL 0100644 0001752 0000144 00000001366 10432775231 021640 0 ustar michael users # Note: this file was auto-generated by Module::Build::Compat version 0.03
use ExtUtils::MakeMaker;
WriteMakefile
(
'PL_FILES' => {},
'INSTALLDIRS' => 'site',
'NAME' => 'CGI::Application::Plugin::LinkIntegrity',
'VERSION_FROM' => 'lib/CGI/Application/Plugin/LinkIntegrity.pm',
'PREREQ_PM' => {
'Test::More' => 0,
'Digest::HMAC' => 0,
'CGI::Application' => '4',
'URI' => 0,
'URI::Escape' => 0,
'Digest::MD5' => 0,
'URI::QueryParam' => 0,
'CGI' => '2.37'
}
)
;
CGI-Application-Plugin-LinkIntegrity-0.06/META.yml 0100644 0001752 0000144 00000000770 10432775231 021135 0 ustar michael users ---
name: CGI-Application-Plugin-LinkIntegrity
version: 0.06
author:
- Michael Graham
abstract: Make tamper-resisistent links in CGI::Application
license: perl
requires:
CGI: 2.37
CGI::Application: 4
Digest::HMAC: 0
Digest::MD5: 0
Test::More: 0
URI: 0
URI::Escape: 0
URI::QueryParam: 0
provides:
CGI::Application::Plugin::LinkIntegrity:
file: lib/CGI/Application/Plugin/LinkIntegrity.pm
version: 0.06
generated_by: Module::Build version 0.2611
CGI-Application-Plugin-LinkIntegrity-0.06/MANIFEST 0100644 0001752 0000144 00000000625 10432775231 021014 0 ustar michael users Build.PL
Changes
lib/CGI/Application/Plugin/LinkIntegrity.pm
Makefile.PL
MANIFEST This list of files
MANIFEST.SKIP
META.yml
misc/dist
misc/makedocs.pl
misc/module-starter-opts.txt
misc/prove_prereqs.pl
misc/style.css
README
t/00.load.t
t/01-link.t
t/02-self_link.t
t/03-path_info_link.t
t/04-hmac.t
t/05-tampering.t
t/06-built_in_link_tampered_rm.t
t/07-invalid_checksum_hook.t
t/pod-coverage.t
t/pod.t