Revision eb8ba476
Von Sven Schöling vor mehr als 12 Jahren hinzugefügt
| SL/Auth.pm | ||
|---|---|---|
| 23 | 23 |
|
| 24 | 24 |
use strict; |
| 25 | 25 |
|
| 26 |
use constant SESSION_KEY_ROOT_AUTH => 'session_auth_status_root'; |
|
| 27 |
use constant SESSION_KEY_USER_AUTH => 'session_auth_status_user'; |
|
| 28 |
|
|
| 26 | 29 |
sub new {
|
| 27 | 30 |
$main::lxdebug->enter_sub(); |
| 28 | 31 |
|
| ... | ... | |
| 146 | 149 |
|
| 147 | 150 |
my ($self, $password) = @_; |
| 148 | 151 |
|
| 149 |
$password = SL::Auth::Password->hash_if_unhashed(login => 'root', password => $password); |
|
| 152 |
my $session_root_auth = $self->get_session_value(SESSION_KEY_ROOT_AUTH); |
|
| 153 |
if (defined $session_root_auth && $session_root_auth == OK) {
|
|
| 154 |
$::lxdebug->leave_sub; |
|
| 155 |
return OK; |
|
| 156 |
} |
|
| 157 |
|
|
| 158 |
if (!defined $password) {
|
|
| 159 |
$::lxdebug->leave_sub; |
|
| 160 |
return ERR_PASSWORD; |
|
| 161 |
} |
|
| 162 |
|
|
| 163 |
$password = SL::Auth::Password->hash(login => 'root', password => $password); |
|
| 150 | 164 |
my $admin_password = SL::Auth::Password->hash_if_unhashed(login => 'root', password => $self->{admin_password}->());
|
| 151 | 165 |
|
| 152 |
$main::lxdebug->leave_sub(); |
|
| 166 |
my $result = $password eq $admin_password ? OK : ERR_PASSWORD; |
|
| 167 |
$self->set_session_value(SESSION_KEY_ROOT_AUTH ,=> $result); |
|
| 168 |
|
|
| 169 |
sleep 5 if $result != OK; |
|
| 153 | 170 |
|
| 154 |
return OK if $password eq $admin_password; |
|
| 155 |
sleep 5; |
|
| 156 |
return ERR_PASSWORD; |
|
| 171 |
$::lxdebug->leave_sub; |
|
| 172 |
return $result; |
|
| 157 | 173 |
} |
| 158 | 174 |
|
| 159 | 175 |
sub authenticate {
|
| ... | ... | |
| 161 | 177 |
|
| 162 | 178 |
my ($self, $login, $password) = @_; |
| 163 | 179 |
|
| 164 |
$main::lxdebug->leave_sub(); |
|
| 165 |
|
|
| 166 |
my $result = $login ? $self->{authenticator}->authenticate($login, $password) : ERR_USER;
|
|
| 167 |
return OK if $result eq OK; |
|
| 168 |
sleep 5; |
|
| 169 |
return $result; |
|
| 170 |
} |
|
| 171 |
|
|
| 172 |
sub store_credentials_in_session {
|
|
| 173 |
my ($self, %params) = @_; |
|
| 180 |
my $session_auth = $self->get_session_value(SESSION_KEY_USER_AUTH); |
|
| 181 |
if (defined $session_auth && $session_auth == OK) {
|
|
| 182 |
$::lxdebug->leave_sub; |
|
| 183 |
return OK; |
|
| 184 |
} |
|
| 174 | 185 |
|
| 175 |
if (!$self->{authenticator}->requires_cleartext_password) {
|
|
| 176 |
$params{password} = SL::Auth::Password->hash_if_unhashed(login => $params{login},
|
|
| 177 |
password => $params{password},
|
|
| 178 |
look_up_algorithm => 1, |
|
| 179 |
auth => $self); |
|
| 186 |
if (!defined $password) {
|
|
| 187 |
$::lxdebug->leave_sub; |
|
| 188 |
return ERR_PASSWORD; |
|
| 180 | 189 |
} |
| 181 | 190 |
|
| 182 |
$self->set_session_value(login => $params{login}, password => $params{password});
|
|
| 183 |
}
|
|
| 191 |
my $result = $login ? $self->{authenticator}->authenticate($login, $password) : ERR_USER;
|
|
| 192 |
$self->set_session_value(SESSION_KEY_USER_AUTH ,=> $result, login => $login);
|
|
| 184 | 193 |
|
| 185 |
sub store_root_credentials_in_session {
|
|
| 186 |
my ($self, $rpw) = @_; |
|
| 194 |
sleep 5 if $result != OK; |
|
| 187 | 195 |
|
| 188 |
$self->set_session_value(rpw => SL::Auth::Password->hash_if_unhashed(login => 'root', password => $rpw)); |
|
| 196 |
$::lxdebug->leave_sub; |
|
| 197 |
return $result; |
|
| 189 | 198 |
} |
| 190 | 199 |
|
| 191 | 200 |
sub get_stored_password {
|
| ... | ... | |
| 404 | 413 |
|
| 405 | 414 |
my $result = $self->{authenticator}->change_password($login, $new_password);
|
| 406 | 415 |
|
| 407 |
$self->store_credentials_in_session(login => $login, |
|
| 408 |
password => $new_password, |
|
| 409 |
look_up_algorithm => 1, |
|
| 410 |
auth => $self); |
|
| 411 |
|
|
| 412 | 416 |
$main::lxdebug->leave_sub(); |
| 413 | 417 |
|
| 414 | 418 |
return $result; |
Auch abrufbar als: Unified diff
Keine Passwörter mehr in Sessions speichern.
Der vorherige Mechanismus hat Passwörter in der Session hinterlegt, um bei
jedem Request überprüfen zu können, ob die Zugriffsrechte immernoch bestehen.
Gedacht war das vor allem für LDAP Authetifizierung, wo der Admin den Zugang
eines Benutzers speichern konnte und das System das sonst nicht mitbekommt.
Ein großes Problem was daraus entsteht ist, dass das Passwort auch akzeptiert
wird, wenn die gehashte Version übergeben wird, weil zur Überprüfungszeit nicht
mehr festgestellt werden kann, ob das gehashte Passwort aus der Session kommt
oder vom User.
Diese Änderung sorgt dafür, dass Passwörter weder im Klartext, noch crypted in
der Session gespeichert werden, sondern der Authetifizierungsstatus.
Eine Session bleibt jetzt eutentifiziert, auch wenn zwischendurch das Passwort
geändert wird. Lokal wird das später abgefangen werden, dass Sessions
invalidiert werden, wenn der Admin das Passwort ändert, im LDAP ist es garnicht
mehr der Fall. Auf der positiven Seite reduziert das den load auf dem LDAP
Server, weil nicht mehr für jeden Request ein Bind passieren muss.
Da die Passwörter nicht mehr verglichen werden müssen, werden gehashte
Passwörter jetzt nicht mehr akzeptiert. Jedes Passwort wird vor dem Vergleichen
unkonditional gehasht.
Die Backend Routinen erkennen jetzt wenn garkein Passwort übergeben wurde, und
triggern dafür den 5s Penalty nicht. Das macht das Aufrufen der Administration
das erste Mal wie erwartet schneller.