Neues in der Kategorie Kryptographie

Gesalzene Hashes werden oft zur sicheren Speicherung von Passwörtern verwendet. Nun gut - das Verfahren ist zu mindestens sicherer als die Verwendung ungesalzener Hashes.

Crypt::SaltedHash von Sascha Kiefer bzw. Gerda Shank ist eine einfach zu bedienende Bibliothek zum Erzeugen und Validieren gesalzener Hashes.

Beispiel: Salted Passwort Hash erzeugen

Das folgende Beispiel erzeugt einen gesalzenen Hash für ein Klartextpasswort:

#!/usr/bin/perl
use strict;
use warnings;

use Crypt::SaltedHash;

my $csh = Crypt::SaltedHash->new( algorithm => 'SHA-1' );

my $cleartext = 'secret';

$csh->add( $cleartext );

my $salted = $csh->generate;

print "Salted: $salted\n";

Das Programm erzeugt folgende Ausgabe:

Salted: {SSHA}9GnzDgL3ChgeupyOkQtSrN/0/v8sGBf3 

Beispiel: Salted Passwort Hash validieren

Die Methode validate kann einen vorgegebenen gesalzenen Hash validieren:

#!/usr/bin/perl
use strict;
use warnings;

use Crypt::SaltedHash;

my $csh = Crypt::SaltedHash->new( algorithm => 'SHA-1' );

my $cleartext = 'secret';

my $salted = '{SSHA}9GnzDgL3ChgeupyOkQtSrN/0/v8sGBf3';

my $valid = Crypt::SaltedHash->validate( $salted, $cleartext );

if ($valid) {
    print "OK\n";
} else {
    print "Not OK\n";
}

Crypt::SaltedHash kann natürlich auch die gesalzenen Hashes, die mit anderen Programmen, z.B. slappasswd, dem OpenLDAP Passwort Tool, erzeugt wurden, validieren.

Für das folgende Beispiel habe ich das Klartextpasswort 123456 ein paar Mal durch slappasswd laufen lassen, um die gesalzenen Hashes zu erzeugen.

#!/usr/bin/perl
use strict;
use warnings;

use Crypt::SaltedHash;

my $csh = Crypt::SaltedHash->new( algorithm => 'SHA-1' );

#$ slappasswd -s 123456

my @salted = qw!
  {SSHA}jppWV0DCxDJeOtaSS434nv5WewNYZSCS
  {SSHA}ilJ95JAFKS4TgDbjRkcYrBMBRp+4mmCE
  {SSHA}vrPil747oBHVgriDBbE+04XAs6BhXis0
  {SSHA}ew3Xf1C9vK+H0kNeJ12Gc1M4fpbT41+x
  {SSHA}9bRacd1WzrrUTiav7QBkMrxHtKTbjhpi
  {SSHA}4m91OtOLhIfL+xDlfO/L5YdYaABKF60U
  {SSHA}b+8sUhnuy6gnmlpf5BD58pww8NiQDZ3S
  {SSHA}SeN6Yubt+pFOfTYDPPQ8JVp7MSfBkr1l
  {SSHA}oSX0fmh8wNPGaJgEGQHY28RMiawsmraB
  {SSHA}K4+dl7hft3VY7gfjPOdz8OOyXflbxA1f
  {SSHA}7X/z6qeaDP6NpKQM3PYUQrERTTTj+VPD
  !;

my $cleartext = '123456';

foreach my $salted (@salted) {

    my $valid = Crypt::SaltedHash->validate( $salted, $cleartext );
    if ($valid) {
        print "OK ($salted)\n";
    } else {
        print "Not OK ($salted)\n";
    }
}

Das Programm erzeugt folgende Ausgabe:

OK ({SSHA}jppWV0DCxDJeOtaSS434nv5WewNYZSCS)
OK ({SSHA}ilJ95JAFKS4TgDbjRkcYrBMBRp+4mmCE)
OK ({SSHA}vrPil747oBHVgriDBbE+04XAs6BhXis0)
OK ({SSHA}ew3Xf1C9vK+H0kNeJ12Gc1M4fpbT41+x)
OK ({SSHA}9bRacd1WzrrUTiav7QBkMrxHtKTbjhpi)
OK ({SSHA}4m91OtOLhIfL+xDlfO/L5YdYaABKF60U)
OK ({SSHA}b+8sUhnuy6gnmlpf5BD58pww8NiQDZ3S)
OK ({SSHA}SeN6Yubt+pFOfTYDPPQ8JVp7MSfBkr1l)
OK ({SSHA}oSX0fmh8wNPGaJgEGQHY28RMiawsmraB)
OK ({SSHA}K4+dl7hft3VY7gfjPOdz8OOyXflbxA1f)
OK ({SSHA}7X/z6qeaDP6NpKQM3PYUQrERTTTj+VPD)

Sicherheitshinweis

Das Salt wird zusammen mit dem Hash (dem gehashten Passwort) in einem String gespeichert und kann, z.B. über die Methoden salt_bin oder salt_hex, jederzeit ausgelesen werden.

Gesalzene Hashes erschweren einen Wörterbuchangriff auf Passwörter, macht diesen aber nicht unmöglich.

Siehe auch

• Crypt::SaltedHash
• Salt (Kryptologie)
• Passwords, Hashing, and Salt
• Avoiding Password Breaches 101: Salt Your Hash
• Salted Password Hashing - Doing it Right
• slappasswd(8) - Linux man page
• Kunterbuntes Schlüsselraten - Von Wörterbüchern und Regenbögen
• Cracker-Bremse - Passwörter unknackbar speichern

Session::Token von Doug Hoyte bietet eine sichere, schnelle und wirklich einfach zu nutzende Schnittstelle um Session IDs, Zufallspasswörter, zufällige Identifier, Reset Codes für Passwörter und vieles mehr zu erzeugen.

Beispiele: Zufällige Session Token

Das folgende Beispiel erzeugt einen zufälligen String mit mindestens 128 Bit Entropie.

#!/usr/bin/perl
use strict;
use warnings;

use Session::Token;

my $token = Session::Token->new->get;

print "Token: $token\n";

Das Programm erzeugt folgende Ausgabe:

Token: 2sSNJqxSf2U3lP2by9fRfs

Die Mindestentropie des zufälligen Tokens lässt sich über den Parameter entropy einstellen:

#!/usr/bin/perl
use strict;
use warnings;

use Session::Token;

my $token = Session::Token->new(entropy => 256)->get;

print "Token: $token\n";

Das Programm erzeugt folgende Ausgabe:

Token: PA5M2r9XOMl7i8scMAaLo7KiBPFu2QH1jqP6huqId0N

Falls mehrere Tokens benötigt werden, bietet sich aus Effizienzgründen, die einmalige Erzeugung eines Generators an, der wiederholt zur Erzeugung zufälliger Token aufgerufen wird.

#!/usr/bin/perl
use strict;
use warnings;

use Session::Token;

my $generator = Session::Token->new;

my $token = $generator->get;

print "Token: $token\n";

Beispiele: Zufallspasswort

Die Länge des zufälligen Passworts kann über den Parameter length eingestellt werden.

#!/usr/bin/perl
use strict;
use warnings;

use Session::Token;

my $token = Session::Token->new( length => 8 )->get;

print "Token: $token\n";

Das Programm erzeugt folgende Ausgabe:

Token: zJPtFyyH

Wem das voreingestellte Alphabet nicht genügt, kann ein eigenes über den Parameter alphabet einstellen.

#!/usr/bin/perl
use strict;
use warnings;

use Session::Token;

my $token = Session::Token->new( length => 8, 
   alphabet => 'ABCDEFGHIJKLMNOPQRSTUVW1234567890!"§$%&/()=?' )->get;

print "Token: $token\n";

Das Programm erzeugt folgende Ausgabe:

Token: H/VJ)G/6

Siehe auch

• Session::Token - Secure, efficient, simple random session token generation
• Neil Bowers: CPAN modules for generating passwords
• ISAAC: a fast cryptographic random number generator
• The Session::Token github repo

Crypt::Cracklib von Dan Sully verhindert bzw. erschwert die Verwendung zu einfacher Passwörter.

Dazu führt Crypt::Cracklib eine Wörterbuch Attacke auf das Passwort durch und prüft auch die Verteilung der Zeichen, die Länge der Zeichenkette und die Groß- und Kleinschreibung.

Crypt::Cracklib sollte verwendet werden, wenn der Benutzer sein Passwort selbst festlegen kann.

Beispiel fascist_check

Die automatisch exportierte Funktion fascist_check() liefert folgende Zeichenketten, die Begründung für ein zu schwaches Passwort, zurück (in Klammern die deutsche Lokalisierung):

• it is based on a dictionary word (Es basiert auf einem Wörterbucheintrag)
• it is based on a (reversed) dictionary word (Es basiert auf einem (umgekehrten) Wörterbucheintrag)
• it is WAY too short! (Es ist VIEL zu kurz!)
• it is too short ((Es ist zu kurz)
• it does not contain enough DIFFERENT characters (Es enthält nicht genug unterschiedliche Zeichen)
• it is all whitespace
• it is too simplistic/systematic (Es ist zu einfach/systematisch)
• it looks like a National Insurance number (Es schaut nach Versicherungsnummer aus)

Falls das Password gut genug ist, wird ok zurück geliefert.

#!/usr/bin/perl
use strict;
use warnings;

use Crypt::Cracklib;

my @passwords = qw/123456 Schatzi abc
                   z6IvPlOx6H oWOYNZI$bP
                   geheym aaa2$ss iztahcS
		   FH153436A /;

foreach my $password (@passwords) {

    if ( fascist_check($password) eq 'ok' ) {
       print "Passwort $password ist OK.\n";
    }
    else {
        print "Ooops - Passwort $password: ",  fascist_check($password) , " !!!\n";
    }
}

Das Programm erzeugt folgende Ausgabe:

Ooops - Passwort 123456: Es ist zu einfach/systematisch !!!
Ooops - Passwort Schatzi: Es basiert auf einem Wörterbucheintrag !!!
Ooops - Passwort abc: Es ist VIEL zu kurz !!!
Passwort z6IvPlOx6H ist OK.
Passwort oWOYNZI$bP ist OK.
Ooops - Passwort geheym: Es basiert auf einem Wörterbucheintrag !!!
Ooops - Passwort aaa2$ss: Es enthält nicht genug unterschiedliche Zeichen !!!
Ooops - Passwort iztahcS: Es basiert auf einem (umgekehrten) Wörterbucheintrag !!!
Ooops - Passwort FH153436A: Es schaut nach Versicherungsnummer aus !!!

Siehe auch

• Crypt::Cracklib
• CrackLib
• Gawker-Einbruch: Beliebtestes Passwort ist 123456
• Das Passwort: Die einzige Konstante im Leben