#!/usr/bin/perl
package Catalyst::Plugin::Session;
-use base qw/Class::Accessor::Fast/;
-use strict;
-use warnings;
-
-use NEXT;
+use Moose;
+with 'MooseX::Emulate::Class::Accessor::Fast';
+use MRO::Compat;
use Catalyst::Exception ();
use Digest ();
use overload ();
use Object::Signature ();
use Carp;
-our $VERSION = '0.20';
+use namespace::clean -except => 'meta';
+
+our $VERSION = '0.26';
my @session_data_accessors; # used in delete_session
-BEGIN {
- __PACKAGE__->mk_accessors(
+
+__PACKAGE__->mk_accessors(
"_session_delete_reason",
@session_data_accessors = qw/
_sessionid
_tried_loading_session_expires
_tried_loading_flash_data
/
- );
+);
+
+sub _session_plugin_config {
+ my $c = shift;
+ # FIXME - Start warning once all the state/store modules have also been updated.
+ #$c->log->warn("Deprecated 'session' config key used, please use the key 'Plugin::Session' instead")
+ # if exists $c->config->{session}
+ #$c->config->{'Plugin::Session'} ||= delete($c->config->{session}) || {};
+ $c->config->{'Plugin::Session'} ||= $c->config->{session} || {};
}
sub setup {
my $c = shift;
- $c->NEXT::setup(@_);
+ $c->maybe::next::method(@_);
$c->check_session_plugin_requirements;
$c->setup_session;
sub setup_session {
my $c = shift;
- my $cfg = ( $c->config->{session} ||= {} );
+ my $cfg = $c->_session_plugin_config;
%$cfg = (
expires => 7200,
verify_address => 0,
+ verify_user_agent => 0,
%$cfg,
);
- $c->NEXT::setup_session();
+ $c->maybe::next::method();
}
sub prepare_action {
my $c = shift;
- if ( $c->config->{session}{flash_to_stash}
+ $c->maybe::next::method(@_);
+
+ if ( $c->_session_plugin_config->{flash_to_stash}
and $c->sessionid
and my $flash_data = $c->flash )
{
@{ $c->stash }{ keys %$flash_data } = values %$flash_data;
}
-
- $c->NEXT::prepare_action(@_);
}
sub finalize_headers {
# fix cookie before we send headers
$c->_save_session_expires;
- return $c->NEXT::finalize_headers(@_);
+ return $c->maybe::next::method(@_);
}
-sub finalize {
+sub finalize_body {
my $c = shift;
- my $ret = $c->NEXT::finalize(@_);
- # then finish the rest
+ # We have to finalize our session *before* $c->engine->finalize_xxx is called,
+ # because we do not want to send the HTTP response before the session is stored/committed to
+ # the session database (or whatever Session::Store you use).
$c->finalize_session;
- return $ret;
+
+ return $c->maybe::next::method(@_);
}
sub finalize_session {
my $c = shift;
- $c->NEXT::finalize_session;
+ $c->maybe::next::method(@_);
$c->_save_session_id;
$c->_save_session;
delete $flash_data->{$key};
}
}
-
+
my $sid = $c->sessionid;
my $session_data = $c->_session;
$c->_session($session_data);
no warnings 'uninitialized'; # ne __address
- if ( $c->config->{session}{verify_address}
+ if ( $c->_session_plugin_config->{verify_address}
&& $session_data->{__address} ne $c->request->address )
{
$c->log->warn(
$c->delete_session("address mismatch");
return;
}
+ if ( $c->_session_plugin_config->{verify_user_agent}
+ && $session_data->{__user_agent} ne $c->request->user_agent )
+ {
+ $c->log->warn(
+ "Deleting session $sid due to user agent mismatch ("
+ . $session_data->{__user_agent} . " != "
+ . $c->request->user_agent . ")"
+ );
+ $c->delete_session("user agent mismatch");
+ return;
+ }
$c->log->debug(qq/Restored session "$sid"/) if $c->debug;
$c->_session_data_sig( Object::Signature::signature($session_data) ) if $session_data;
if ( my $flash_data = $c->_flash )
{
$c->_flash_key_hashes({ map { $_ => Object::Signature::signature( \$flash_data->{$_} ) } keys %$flash_data });
-
+
return $flash_data;
}
}
sub _clear_session_instance_data {
my $c = shift;
$c->$_(undef) for @session_data_accessors;
- $c->NEXT::_clear_session_instance_data; # allow other plugins to hook in on this
+ $c->maybe::next::method(@_); # allow other plugins to hook in on this
+}
+
+sub change_session_id {
+ my $c = shift;
+
+ my $sessiondata = $c->session;
+ my $oldsid = $c->sessionid;
+ my $newsid = $c->create_session_id;
+
+ if ($oldsid) {
+ $c->log->debug(qq/change_sessid: deleting session data from "$oldsid"/) if $c->debug;
+ $c->delete_session_data("${_}:${oldsid}") for qw/session expires flash/;
+ }
+
+ $c->log->debug(qq/change_sessid: storing session data to "$newsid"/) if $c->debug;
+ $c->store_session_data( "session:$newsid" => $sessiondata );
+
+ return $newsid;
}
sub delete_session {
sub calculate_initial_session_expires {
my $c = shift;
- return ( time() + $c->config->{session}{expires} );
+ return ( time() + $c->_session_plugin_config->{expires} );
}
sub calculate_extended_session_expires {
sub reset_session_expires {
my ( $c, $sid ) = @_;
-
+
my $exp = $c->calculate_initial_session_expires;
$c->_session_expires( $exp );
$c->_extended_session_expires( $exp );
sub sessionid {
my $c = shift;
-
+
return $c->_sessionid || $c->_load_sessionid;
}
(@{$href}{@keys}) = ((undef) x @keys);
}
-sub _flash_data {
+sub _flash_data {
my $c = shift;
$c->_flash || $c->_load_flash || do {
$c->create_session_id_if_needed;
sub clear_flash {
my $c = shift;
-
+
#$c->delete_session_data("flash:" . $c->sessionid); # should this be in here? or delayed till finalization?
$c->_flash_key_hashes({});
$c->_flash_keep_keys({});
__updated => $now,
(
- $c->config->{session}{verify_address}
- ? ( __address => $c->request->address )
+ $c->_session_plugin_config->{verify_address}
+ ? ( __address => $c->request->address||'' )
+ : ()
+ ),
+ (
+ $c->_session_plugin_config->{verify_user_agent}
+ ? ( __user_agent => $c->request->user_agent||'' )
: ()
),
}
sub create_session_id {
my $c = shift;
-
+
my $sid = $c->generate_session_id;
$c->log->debug(qq/Created session "$sid"/) if $c->debug;
my $c = shift;
(
- $c->NEXT::dump_these(),
+ $c->maybe::next::method(),
$c->sessionid
? ( [ "Session ID" => $c->sessionid ], [ Session => $c->session ], )
}
-sub get_session_id { shift->NEXT::get_session_id(@_) }
-sub set_session_id { shift->NEXT::set_session_id(@_) }
-sub delete_session_id { shift->NEXT::delete_session_id(@_) }
-sub extend_session_id { shift->NEXT::extend_session_id(@_) }
+sub get_session_id { shift->maybe::next::method(@_) }
+sub set_session_id { shift->maybe::next::method(@_) }
+sub delete_session_id { shift->maybe::next::method(@_) }
+sub extend_session_id { shift->maybe::next::method(@_) }
__PACKAGE__;
my ( $self, $c ) = @_;
if ( exists $c->flash->{beans} ) { # false
-
+
}
}
For example:
- __PACKAGE__->config->{session}{expires} = 1000000000000; # forever
+ __PACKAGE__->config('Plugin::Session' => { expires => 1000000000000 }); # forever
# later
Note that these values are not auto extended.
+=item change_session_id
+
+By calling this method you can force a session id change while keeping all
+session data. This method might come handy when you are paranoid about some
+advanced variations of session fixation attack.
+
+If you want to prevent this session fixation scenario:
+
+ 0) let us have WebApp with anonymous and authenticated parts
+ 1) a hacker goes to vulnerable WebApp and gets a real sessionid,
+ just by browsing anonymous part of WebApp
+ 2) the hacker inserts (somehow) this values into a cookie in victim's browser
+ 3) after the victim logs into WebApp the hacker can enter his/her session
+
+you should call change_session_id in your login controller like this:
+
+ if ($c->authenticate( { username => $user, password => $pass } )) {
+ # login OK
+ $c->change_session_id;
+ ...
+ } else {
+ # login FAILED
+ ...
+ }
+
=back
=head1 INTERNAL METHODS
=item setup_session
-This method populates C<< $c->config->{session} >> with the default values
+This method populates C<< $c->config('Plugin::Session') >> with the default values
listed in L</CONFIGURATION>.
=item prepare_action
This method is extended and will extend the expiry time before sending
the response.
-=item finalize
+=item finalize_body
-This method is extended and will call finalize_session after the other
-finalizes run. Here we persist the session data if a session exists.
+This method is extended and will call finalize_session before the other
+finalize_body methods run. Here we persist the session data if a session exists.
=item initialize_session_data
=head1 CONFIGURATION
- $c->config->{session} = {
+ $c->config('Plugin::Session' => {
expires => 1234,
- };
+ });
All configuation parameters are provided in a hash reference under the
-C<session> key in the configuration hash.
+C<Plugin::Session> key in the configuration hash.
=over 4
Defaults to false.
+=item verify_user_agent
+
+When true, C<<$c->request->user_agent>> will be checked at prepare time. If it
+is not the same as the user agent that initiated the session, the session is
+deleted.
+
+Defaults to false.
+
=item flash_to_stash
This option makes it easier to have actions behave the same whether they were
The value of C<< $c->request->address >> at the time the session was created.
This value is only populated if C<verify_address> is true in the configuration.
+=item __user_agent
+
+The value of C<< $c->request->user_agent >> at the time the session was created.
+This value is only populated if C<verify_user_agent> is true in the configuration.
+
=back
=head1 CAVEATS
Christian Hansen
-Yuval Kogman, C<nothingmuch@woobling.org> (current maintainer)
+Yuval Kogman, C<nothingmuch@woobling.org>
Sebastian Riedel
+Tomas Doran (t0m) C<bobtfish@bobtfish.net> (current maintainer)
+
+Sergio Salvi
+
+kmx C<kmx@volny.cz>
+
And countless other contributers from #catalyst. Thanks guys!
=head1 COPYRIGHT & LICENSE
projects / catagits/Catalyst-Plugin-Session.git / blobdiff