Hey SD'ers,

Ik lees op diverse websites dat een md5 en sha1 hash tegenwoordig niet meer veilig is. Maar ik krijg geen uitleg gevonden waarom niet.

Kunnen 'hackers' in de database kijken? Als je een hash helemaal zou veranderen, dan is het wel veilig?

Groeten,
Bart Roelofs

Wat de meest veilige manier is om voor je wachtwoord in je sha2 string een random string te zetten die ze alleen kunnen zien als je in de server kan komen, dus niet alleen bij de database.

PHP Code:

  $securePassword = hash('sha256', "RAND0mStrinNGak19aknsa" . $password); 


Ik had zelf een improvisatie gemaakt. Maar weet niet of het veilig is:

Gebruiker geeft bij aanmelden wachtwoord op
wachtwoord wordt omgezet in sha1 hash
ik verwijder 5 characters (bijv. 1, 5, a, c en f)
Zet de record in de database

Gebruiker wil aanmelden
ik zet wachtwoord in een hash
verwijder weer de 5 characters
en vergelijk met de database

Geen idee of het werkt, en of het veilig is. Graag advies.

Groeten,
Bart

Kan inderdaad, maar dat is moeilijk doen, en niet 100% veilig. Mijn manier is simpel en veilig..

Even zodat ik het snap. Jij doet dus het volgende.

Gebruiker voert wachtwoord in
Jij plakt er gekke tekens achter
Je zet het om in een hash

Als gebruiker inlogt
Je plakt zelfde tekens achter wachtwoord
Je zet het om naar een hash

Correct?

Groeten,
Bart
Aanvullend bericht:
Ik ben eruit.

Bedankt,

Groeten,
Bart

Helemaal correct Bart :)

voor de cut&pasters:

private function makeHash($password) {
$salt = bin2hex(mcrypt_create_iv(32, MCRYPT_DEV_URANDOM));
$hash = hash("sha256", $salt . $password);
return $salt . $hash;
}
private function validateHash($password, $dbHash) {
$salt = substr($dbHash, 0, 64);
$valid = substr($dbHash, 64, 64);
$test = hash("sha256", $salt . $password);
return $test === $valid;
}
Aanvullend bericht:
En indien je de gegevens wilt encrypten/decrypten:

private function encrypt($str) {
$block = mcrypt_get_block_size('des', 'ecb');
$pad = $block - (strlen($str) % $block);
$str .= str_repeat(chr($pad), $pad);
$ret = base64_encode(mcrypt_encrypt(MCRYPT_DES, "8keypass", $str, MCRYPT_MODE_ECB));
return $ret;
}

private function decrypt($str) {
$str = mcrypt_decrypt(MCRYPT_DES, "8keypass", base64_decode($str), MCRYPT_MODE_ECB);
$block = mcrypt_get_block_size('des', 'ecb');
$pad = ord($str[($len = strlen($str)) - 1]);
return substr($str, 0, strlen($str) - $pad);
}

Dat '8keypass' is een encryptie key van 8 tekens die je ergens erg veilig (buiten je document root) moest bewaren.

Waarom eigenlijk niet meteen sha512 doen ipv 256?

Origineel gepost door Mark Puts

Waarom eigenlijk niet meteen sha512 doen ipv 256?

256 is ook al veel en kost de helft van de ruimte om op te slaan. Verder geen reden waarom het niet zou kunnen.

PHP raadt je aan crypt() te gebruiken met het blowfish algoritme. Dit algoritme doet er relatief lang over om een hash te maken van je wachtwoord, waardoor het brute-forcen (te) lang duurt. Zeker wanneer je dit combineert met een sterke salt heb je een sterke beveiliging.

Het is zelfs aan te raden je salt te genereren aan de hand van de invoer van de gebruiker. Iedere gebruiker heeft op die manier een uniek wachtwoord + unieke salt. Door deze methode voorkom je dat je salt uitlekt en je beveiliging in elkaar stort. Immers, wanneer een salt bekend is dan hoeft men niet meer alles te bruteforcen, maar kan men "pre-salt"+randomkarakters+"end-salt" gaan bruteforcen.

Kort door de bocht: Wanner het wachtwoord van de gebruiker "a" is, en daar "b" als pre-salt en "c" als end-salt bij hoort, dan is het wachtwoord wat je gaat hashen "bac". Heeft geen gebruiker "g" als wachtwoord, dan zou "h" pre-salt zijn en "i" end-salt. Het wachtwoord wat je dan gaat hashen is "hgi". Je salt verandert, dus zul je de hele string moeten bruteforcen.

Wellicht verstandig om in het genereren van je salt ook het blowfish-algoritme te gebruiken (of een ander algoritme wat "lang" duurt). Mocht dan je algoritme uitlekken, dan zorg je er nog voor dat het zo resource-intensief is dat het brute-forcen lang, lang duurt.