Projekt

Allgemein

Profil

« Zurück | Weiter » 

Revision eb8ba476

Von Sven Schöling vor mehr als 12 Jahren hinzugefügt

  • ID eb8ba4764dff48ed8e67a00c48d02c9e7c6e5de5
  • Vorgänger 1085fceb
  • Nachfolger da4d7cff

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.

Unterschiede anzeigen:

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