mixen van de salt in wachtwoord aan de hand van wachtwoord

[pizzafried]

Vandaag heb ik eens nagedacht over het feit dat men bij hashen van het wachtwoord in combinatie met een, al dan niet random, salt deze voor of achter het gehashte wachtwoord plaatsen in de database. Op die manier zou in theorie de salt gevonden kunnen worden en zodoende toch het wachtwoord gevonden kunnen worden. Dit in het achterhoofd hebbende kwam ik tot het volgende idee: We gaan het wachtwoord hashen op de conventionele manier met een random salt. Vervolgens ga ik aan de hand van de numerieke ascii karakters en de som van eventuele numerieke karakters van het wachtwoord aan de slag om steeds een stukje van de salt in te voegen in het gehashte wachtwoord. In theorie zou je dan alleen de salt terug kunnen vinden aan de hand van het wachtwoord, heb je geen wachtwoord, dan is het gehashte wachtwoord dus in theorie eigenlijk onbruikbaar.

Ik heb ook al een prototype gebouwd. hash_password zal het wachtwoord hashen en mixen met de salt, compare_password gaat met het gegeven wachtwoord het proces omkeren en de salt er uitfilteren. Ik heb het getest, en de code werkt.

PHP:

<?php
function hash_password($password, $hash = null) {
    $salt = (is_null($hash)) ? sha1(md5(time().rand(0, 9999) + strlen($password))) : $hash;
    for ($i = 0; $i < 10000; $i++) $saltedPassword = sha1($password . $salt);
    $sumord = strlen($password);
    $sumnr = 1;
    while (true) {
        if (strlen($salt) <= 0) break;
        for ($i = 0; $i < strlen($password); $i++) {
            if (strlen($salt) <= 0) break;
            $ord = ord($password[$i]);
            $sumord += $ord;
            if (ctype_digit($password[$i])) $sumnr += $password[$i];
            $key = $sumnr * $sumord;
            $position = $key % 40;
            $group = ($sumord % 2) ? 3 : 2;
            if (strlen($salt) < $group) $group = strlen($salt);
            if ($key % 2) {
                $saltedPassword = substr($saltedPassword, 0, $position) . substr($salt, 0, $group) . substr($saltedPassword, $position);
                $salt = substr($salt, $group, strlen($salt));
            } else {
                $saltedPassword1 = substr($saltedPassword, 0, strlen($saltedPassword) - $position);
                $saltedPassword = $saltedPassword1 . substr($salt, strlen($salt) - $group, strlen($salt)) . substr($saltedPassword, strlen($saltedPassword1));
                $salt = substr($salt, 0, strlen($salt) - $group);
            }
        }
    }
    return $saltedPassword;
}

function compare_password($password, $saltedPassword) {
    $sumord = strlen($password);
    $sumnr = 1;
    $decoders = array();
    $salt = sha1("dummyhash");
    while (true) {
        if (strlen($salt) <= 0) break;
        for ($i = 0; $i < strlen($password); $i++) {
            if (strlen($salt) <= 0) break;
            $ord = ord($password[$i]);
            $sumord += $ord;
            if (ctype_digit($password[$i])) $sumnr += $password[$i];
            $key = $sumnr * $sumord;
            $position = $key % 40;
            $group = ($sumord % 2) ? 3 : 2;
            if (strlen($salt) < $group) $group = strlen($salt);
            $decoders[] = array("ord" => $ord, "sumord" => $sumord, "sumnr" => $sumnr, "group" => $group, "key" => $key);           
            $salt = substr($salt, $group, strlen($salt));   
        }
    }
    $decoders = array_reverse($decoders);
    $salt = "";
    $unsaltedPassword = $saltedPassword;
    foreach ($decoders as $decoder) {
        if (strlen($salt) >= 40) break;
        $position = $decoder['key'] % 40;
        if ($decoder['key'] % 2) {
            $salt = substr($unsaltedPassword, $position, $decoder['group']) . $salt;
            $unsaltedPassword = substr($unsaltedPassword, 0, $position) . substr($unsaltedPassword, $position + $decoder['group']);
        } else {
            $salt .= substr($unsaltedPassword, strlen($unsaltedPassword) - ($position + $decoder['group']), $decoder['group']);
            $unsaltedPassword = substr($unsaltedPassword, 0, strlen($unsaltedPassword) - ($position + $decoder['group'])) . substr($unsaltedPassword, (strlen($unsaltedPassword) - $position));
        }
    }
    return $saltedPassword == hash_password($password, $salt);
}
?>

Mijn vraag aan jullie is: Heb ik nu iets gemaakt dat niet gaat werken of heb ik dubbel werk geleverd?

[Ventieldopje]

Op die manier zou in theorie de salt gevonden kunnen worden en zodoende toch het wachtwoord gevonden kunnen worden.

Ik denk het niet Het is wel een leuk concept wat je hebt bedacht maar of het veel toe zal voegen weet ik niet, het geeft wel wat extra belasting op je server.

[Herko_ter_Horst]

Heel verhaal om de salt te verbergen, terwijl de salt helemaal niet geheim gehouden hoeft te worden...

The salt does not need to be secret. Just by randomizing the hashes, lookup tables, reverse lookup tables, and rainbow tables become ineffective. An attacker won't know in advance what the salt will be, so they can't pre-compute a lookup table or rainbow table. If each user's password is hashed with a different salt, the reverse lookup table attack won't work either.

Geen hash-functies chainen, geen "al dan niet random" salt, maar een cryptografisch sterke random salt per gebruiker meenemen bij het hashen met een enkele goede hash-functie dus. Die salt kun je gewoon opslaan in de database. In PHP hash en check je dan bijv. op deze manier: http://crackstation.net/hashing-security.htm#phpsourcecode

[ Voor 24% gewijzigd door Herko_ter_Horst op 17-09-2012 15:35 ]

[pizzafried]

die theorieen ken ik en heb ik gelezen, maar het gaat bijvoorbeeld om attacks om iemand, één persoon, zwart te maken. Heeft die dan een zwak wachtwoord en de salt is bekend (door dat de salt zichtbaar aan de voorkant of aan de achterkant is geplakt) heb je zo alsnog even veel kans met vooraf berekende rainbow tabellen op basis van de salt het wachtwoord te vinden, iets wat je met een onbekende salt niet hebt. Persoonlijk denk ik dat daar het voordeel ligt in dit systeem. niet zo zeer in de wachtwoord dieven die alle wachtwoorden willen stelen en gebruiken om andere accounts lastig te vallen, die zo overigens ook buiten de boot vallen...overigens, zoals je kunt zien wordt hier overigens ook voor iedere user een random salt gegenereerd en het wachtwoord en salt 10.000 keer gehashed.

[Verwijderd]

Henze schreef op maandag 17 september 2012 @ 16:59:
Heeft die dan een zwak wachtwoord en de salt is bekend (door dat de salt zichtbaar aan de voorkant of aan de achterkant is geplakt) heb je zo alsnog even veel kans met vooraf berekende rainbow tabellen op basis van de salt het wachtwoord te vinden,

Voor elke bit dat de salt lang is, moet de rainbow table 2x zo groot worden om hetzelfde effect te hebben. Het gaat dan ook niet om het onmogelijk maken om rainbow tables te gebruiken, maar om het onpraktisch te maken.

Voor jouw hash functie is ook een rainbow table te maken.

[BtM909]

Er zijn ook meerdere topics geweest met info hoe je het beste om kan gaan met je wachtwoord, hashes, salts (en wel of geen pepper)

http://gathering.tweakers...rchtimeout%5D=30#hitstart

[pedorus]

Mooi stukje ingewikkelde code, maar helaas maakt het de boel vooral onveiliger. Voor sha1(md5(time().rand(0, 9999) + strlen($password))) is maar een beperkte hoeveelheid mogelijkheden, zeker als je de tijd weet, en daar kun je een tabelletje van maken. Vervolgens kun je mogelijke salts gaan matchen, en krijg je informatie over het wachtwoord!

Voor welk probleem is deze oplossing eigenlijk een oplossing? Wat zou hier beter aan zijn dan gewoon iets als bcrypt gebruiken?

Waarom trouwens dit onzinloopje?

Henze schreef op maandag 17 september 2012 @ 15:16:

PHP:

    for ($i = 0; $i < 10000; $i++) $saltedPassword = sha1($password . $salt);

[pizzafried]

Het is natuurlijk wel een prototype, een idee, ik zou natuurlijk iets andere hash methodes kunnen gebruiken zoals idd bcrypt...over de salt heb je gelijk, ik heb die inmiddels vervangen voor een wat meer random functie. Al kan je ook gewoon zelf een salt opgeven als je deze functie zou gebruiken.

PHP:

<?php
       substr(base64_encode(mt_rand(1,9999999999)),0,10);
?>

all heeft deze ook wat kanttekeningen, je zou deze meerdere keren kunnen genereren en dan een randomlengte nemen en deze resultaten samenvoegen waardoor je een salt krijgt met variabele lengte.

dat onzinloopje wordt trouwens overal op internet aangeraden, ik hoef het 1x te doen, iemand die de wachtwoorden wil kraken/raden veel vaker achter elkaar, waarbij dit het proces zou moeten vertragen en onpraktisch maken. in geval van bcrypt zou dat kunnen vervallen.

Het idee was dat dit rainbowtables vrijwel onmogelijk zou moeten maken, maar ik zie nu in dat dat ook hiermee niet mogelijk is. Wel zou dit, gezien ook gezegt is dat dit extra serverbelasting op zou leveren deze rainbowtables nog verder onpraktisch kunnen maken...

[pedorus]

mt_rand lijkt me sowieso een beperkt aantal mogelijke waardes produceren bij een bekende tijd, zeker als je het PID weet te achterhalen (waarschijnlijker vanwege uitlekken passworddatabase), zie http://stackoverflow.com/...ow-is-phps-mt-rand-seeded

Het onzinloopje doet in jouw geval vooralsnog niets extras, dan zul je toch de rechterkant variabel moeten hebben, dus zeg $saltedPassword = $password, en dan $saltedPassword aan de rechterkant. Maar het is inderdaad wel ongeveer het concept dat bcrypt gebruikt. Het voordeel van bcrypt ten opzichte van jouw methode is echter dat je bcrypt makkelijk kan versterken zonder de wachtwoorden te weten. Daarnaast is het een proven methode, je ziet al weer hoe makkelijk het is om een foutje te maken waardoor het juist onveiliger wordt als je zelf iets gaat verzinnen.

Wat bijvoorbeeld hier ook zou kunnen gebeuren, is dat te veel wachtwoorden gaan valideren doordat de salt vrijer gekozen kan worden uit de beschikbare data. Daarom lijkt het me handiger om een reeds bestaande, geverifieerde en veel geteste methode te gebruiken

[RobIII]

pedorus schreef op dinsdag 18 september 2012 @ 11:37:
Maar het is inderdaad wel ongeveer het concept dat bcrypt gebruikt.

Niet echt; bij bcrypt, pbkdf2 en consorten verandert de uiteindelijke hash wel elke iteratie. En dat doet 't bij TS niet. Of ik mis iets (of begrijp bcrypt/pbkdf2 verkeerd ).

[ Voor 37% gewijzigd door RobIII op 18-09-2012 11:51 ]

[pizzafried]

@Robill idd zie net dat die implementatie wel heel erg fout gaat. Idee was wel de hash bij iedere iteratie anders te laten overkomen, maar hier herhaal ik de operatie gewoon 10.000 keer , en dan begrijp ik het verhaal over het onzinloopje

PHP:

<?php
    $saltedPassword = sha1($salt.$password);
    for ($i = 0; $i < 10000; $i++) $saltedPassword = sha1($salt.$saltedPassword); 
?>

[RobIII]

Mja, either way: waarom 't wiel opnieuw (en vierkant) uitvinden? Gebruik gewoon beproefde methodes, dat is eigenlijk les #1 in security. Daar kun je het hele topic mee afdoen (zonder afbreuk te willen doen aan je intenties).

offtopic:
En mijn nick is RobIII, niet Robill; zie ook mijn ondertitel: "^ Romeinse 3 ja!"

[ Voor 42% gewijzigd door RobIII op 18-09-2012 12:11 ]