Mereged updates from DokuWiki 38
[sudaraka-org:dokuwiki-mods.git] / inc / PassHash.class.php
1 <?php
2 /**
3  * Password Hashing Class
4  *
5  * This class implements various mechanisms used to hash passwords
6  *
7  * @author Andreas Gohr <andi@splitbrain.org>
8  * @license LGPL2
9  */
10 class PassHash {
11     /**
12      * Verifies a cleartext password against a crypted hash
13      *
14      * The method and salt used for the crypted hash is determined automatically,
15      * then the clear text password is crypted using the same method. If both hashs
16      * match true is is returned else false
17      *
18      * @author  Andreas Gohr <andi@splitbrain.org>
19      * @param $clear string Clear-Text password
20      * @param $hash  string Hash to compare against
21      * @return  bool
22      */
23     function verify_hash($clear, $hash) {
24         $method = '';
25         $salt   = '';
26         $magic  = '';
27
28         //determine the used method and salt
29         $len = strlen($hash);
30         if(preg_match('/^\$1\$([^\$]{0,8})\$/', $hash, $m)) {
31             $method = 'smd5';
32             $salt   = $m[1];
33             $magic  = '1';
34         } elseif(preg_match('/^\$apr1\$([^\$]{0,8})\$/', $hash, $m)) {
35             $method = 'apr1';
36             $salt   = $m[1];
37             $magic  = 'apr1';
38         } elseif(preg_match('/^\$P\$(.{31})$/', $hash, $m)) {
39             $method = 'pmd5';
40             $salt   = $m[1];
41             $magic  = 'P';
42         } elseif(preg_match('/^\$H\$(.{31})$/', $hash, $m)) {
43             $method = 'pmd5';
44             $salt   = $m[1];
45             $magic  = 'H';
46         } elseif(preg_match('/^sha1\$(.{5})\$/', $hash, $m)) {
47             $method = 'djangosha1';
48             $salt   = $m[1];
49         } elseif(preg_match('/^md5\$(.{5})\$/', $hash, $m)) {
50             $method = 'djangomd5';
51             $salt   = $m[1];
52         } elseif(preg_match('/^\$2a\$(.{2})\$/', $hash, $m)) {
53             $method = 'bcrypt';
54             $salt   = $hash;
55         } elseif(substr($hash, 0, 6) == '{SSHA}') {
56             $method = 'ssha';
57             $salt   = substr(base64_decode(substr($hash, 6)), 20);
58         } elseif(substr($hash, 0, 6) == '{SMD5}') {
59             $method = 'lsmd5';
60             $salt   = substr(base64_decode(substr($hash, 6)), 16);
61         } elseif($len == 32) {
62             $method = 'md5';
63         } elseif($len == 40) {
64             $method = 'sha1';
65         } elseif($len == 16) {
66             $method = 'mysql';
67         } elseif($len == 41 && $hash[0] == '*') {
68             $method = 'my411';
69         } elseif($len == 34) {
70             $method = 'kmd5';
71             $salt   = $hash;
72         } else {
73             $method = 'crypt';
74             $salt   = substr($hash, 0, 2);
75         }
76
77         //crypt and compare
78         $call = 'hash_'.$method;
79         if($this->$call($clear, $salt, $magic) === $hash) {
80             return true;
81         }
82         return false;
83     }
84
85     /**
86      * Create a random salt
87      *
88      * @param int $len The length of the salt
89      * @return string
90      */
91     public function gen_salt($len = 32) {
92         $salt  = '';
93         $chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
94         for($i = 0; $i < $len; $i++) {
95             $salt .= $chars[mt_rand(0, 61)];
96         }
97         return $salt;
98     }
99
100     /**
101      * Initialize the passed variable with a salt if needed.
102      *
103      * If $salt is not null, the value is kept, but the lenght restriction is
104      * applied.
105      *
106      * @param string &$salt The salt, pass null if you want one generated
107      * @param int    $len The length of the salt
108      */
109     public function init_salt(&$salt, $len = 32) {
110         if(is_null($salt)) $salt = $this->gen_salt($len);
111         if(strlen($salt) > $len) $salt = substr($salt, 0, $len);
112     }
113
114     // Password hashing methods follow below
115
116     /**
117      * Password hashing method 'smd5'
118      *
119      * Uses salted MD5 hashs. Salt is 8 bytes long.
120      *
121      * The same mechanism is used by Apache's 'apr1' method. This will
122      * fallback to a implementation in pure PHP if MD5 support is not
123      * available in crypt()
124      *
125      * @author Andreas Gohr <andi@splitbrain.org>
126      * @author <mikey_nich at hotmail dot com>
127      * @link   http://de.php.net/manual/en/function.crypt.php#73619
128      * @param string $clear The clear text to hash
129      * @param string $salt  The salt to use, null for random
130      * @return string Hashed password
131      */
132     public function hash_smd5($clear, $salt = null) {
133         $this->init_salt($salt, 8);
134
135         if(defined('CRYPT_MD5') && CRYPT_MD5 && $salt !== '') {
136             return crypt($clear, '$1$'.$salt.'$');
137         } else {
138             // Fall back to PHP-only implementation
139             return $this->hash_apr1($clear, $salt, '1');
140         }
141     }
142
143     /**
144      * Password hashing method 'lsmd5'
145      *
146      * Uses salted MD5 hashs. Salt is 8 bytes long.
147      *
148      * This is the format used by LDAP.
149      *
150      * @param string $clear The clear text to hash
151      * @param string $salt  The salt to use, null for random
152      * @return string Hashed password
153      */
154     public function hash_lsmd5($clear, $salt = null) {
155         $this->init_salt($salt, 8);
156         return "{SMD5}".base64_encode(md5($clear.$salt, true).$salt);
157     }
158
159     /**
160      * Password hashing method 'apr1'
161      *
162      * Uses salted MD5 hashs. Salt is 8 bytes long.
163      *
164      * This is basically the same as smd1 above, but as used by Apache.
165      *
166      * @author <mikey_nich at hotmail dot com>
167      * @link   http://de.php.net/manual/en/function.crypt.php#73619
168      * @param string $clear The clear text to hash
169      * @param string $salt  The salt to use, null for random
170      * @param string $magic The hash identifier (apr1 or 1)
171      * @return string Hashed password
172      */
173     public function hash_apr1($clear, $salt = null, $magic = 'apr1') {
174         $this->init_salt($salt, 8);
175
176         $len  = strlen($clear);
177         $text = $clear.'$'.$magic.'$'.$salt;
178         $bin  = pack("H32", md5($clear.$salt.$clear));
179         for($i = $len; $i > 0; $i -= 16) {
180             $text .= substr($bin, 0, min(16, $i));
181         }
182         for($i = $len; $i > 0; $i >>= 1) {
183             $text .= ($i & 1) ? chr(0) : $clear{0};
184         }
185         $bin = pack("H32", md5($text));
186         for($i = 0; $i < 1000; $i++) {
187             $new = ($i & 1) ? $clear : $bin;
188             if($i % 3) $new .= $salt;
189             if($i % 7) $new .= $clear;
190             $new .= ($i & 1) ? $bin : $clear;
191             $bin = pack("H32", md5($new));
192         }
193         $tmp = '';
194         for($i = 0; $i < 5; $i++) {
195             $k = $i + 6;
196             $j = $i + 12;
197             if($j == 16) $j = 5;
198             $tmp = $bin[$i].$bin[$k].$bin[$j].$tmp;
199         }
200         $tmp = chr(0).chr(0).$bin[11].$tmp;
201         $tmp = strtr(
202             strrev(substr(base64_encode($tmp), 2)),
203             "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
204             "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
205         );
206         return '$'.$magic.'$'.$salt.'$'.$tmp;
207     }
208
209     /**
210      * Password hashing method 'md5'
211      *
212      * Uses MD5 hashs.
213      *
214      * @param string $clear The clear text to hash
215      * @return string Hashed password
216      */
217     public function hash_md5($clear) {
218         return md5($clear);
219     }
220
221     /**
222      * Password hashing method 'sha1'
223      *
224      * Uses SHA1 hashs.
225      *
226      * @param string $clear The clear text to hash
227      * @return string Hashed password
228      */
229     public function hash_sha1($clear) {
230         return sha1($clear);
231     }
232
233     /**
234      * Password hashing method 'ssha' as used by LDAP
235      *
236      * Uses salted SHA1 hashs. Salt is 4 bytes long.
237      *
238      * @param string $clear The clear text to hash
239      * @param string $salt  The salt to use, null for random
240      * @return string Hashed password
241      */
242     public function hash_ssha($clear, $salt = null) {
243         $this->init_salt($salt, 4);
244         return '{SSHA}'.base64_encode(pack("H*", sha1($clear.$salt)).$salt);
245     }
246
247     /**
248      * Password hashing method 'crypt'
249      *
250      * Uses salted crypt hashs. Salt is 2 bytes long.
251      *
252      * @param string $clear The clear text to hash
253      * @param string $salt  The salt to use, null for random
254      * @return string Hashed password
255      */
256     public function hash_crypt($clear, $salt = null) {
257         $this->init_salt($salt, 2);
258         return crypt($clear, $salt);
259     }
260
261     /**
262      * Password hashing method 'mysql'
263      *
264      * This method was used by old MySQL systems
265      *
266      * @link http://www.php.net/mysql
267      * @author <soren at byu dot edu>
268      * @param string $clear The clear text to hash
269      * @return string Hashed password
270      */
271     public function hash_mysql($clear) {
272         $nr      = 0x50305735;
273         $nr2     = 0x12345671;
274         $add     = 7;
275         $charArr = preg_split("//", $clear);
276         foreach($charArr as $char) {
277             if(($char == '') || ($char == ' ') || ($char == '\t')) continue;
278             $charVal = ord($char);
279             $nr ^= ((($nr & 63) + $add) * $charVal) + ($nr << 8);
280             $nr2 += ($nr2 << 8) ^ $nr;
281             $add += $charVal;
282         }
283         return sprintf("%08x%08x", ($nr & 0x7fffffff), ($nr2 & 0x7fffffff));
284     }
285
286     /**
287      * Password hashing method 'my411'
288      *
289      * Uses SHA1 hashs. This method is used by MySQL 4.11 and above
290      *
291      * @param string $clear The clear text to hash
292      * @return string Hashed password
293      */
294     public function hash_my411($clear) {
295         return '*'.sha1(pack("H*", sha1($clear)));
296     }
297
298     /**
299      * Password hashing method 'kmd5'
300      *
301      * Uses salted MD5 hashs.
302      *
303      * Salt is 2 bytes long, but stored at position 16, so you need to pass at
304      * least 18 bytes. You can pass the crypted hash as salt.
305      *
306      * @param string $clear The clear text to hash
307      * @param string $salt  The salt to use, null for random
308      * @return string Hashed password
309      */
310     public function hash_kmd5($clear, $salt = null) {
311         $this->init_salt($salt);
312
313         $key   = substr($salt, 16, 2);
314         $hash1 = strtolower(md5($key.md5($clear)));
315         $hash2 = substr($hash1, 0, 16).$key.substr($hash1, 16);
316         return $hash2;
317     }
318
319     /**
320      * Password hashing method 'pmd5'
321      *
322      * Uses salted MD5 hashs. Salt is 1+8 bytes long, 1st byte is the
323      * iteration count when given, for null salts $compute is used.
324      *
325      * The actual iteration count is the given count squared, maximum is
326      * 30 (-> 1073741824). If a higher one is given, the function throws
327      * an exception.
328      *
329      * @link  http://www.openwall.com/phpass/
330      * @param string $clear The clear text to hash
331      * @param string $salt  The salt to use, null for random
332      * @param string $magic The hash identifier (P or H)
333      * @param int    $compute The iteration count for new passwords
334      * @throws Exception
335      * @return string Hashed password
336      */
337     public function hash_pmd5($clear, $salt = null, $magic = 'P', $compute = 8) {
338         $itoa64 = './0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
339         if(is_null($salt)) {
340             $this->init_salt($salt);
341             $salt = $itoa64[$compute].$salt; // prefix iteration count
342         }
343         $iterc = $salt[0]; // pos 0 of salt is iteration count
344         $iter  = strpos($itoa64, $iterc);
345
346         if($iter > 30) {
347             throw new Exception("Too high iteration count ($iter) in ".
348                                     __CLASS__.'::'.__FUNCTION__);
349         }
350
351         $iter = 1 << $iter;
352         $salt = substr($salt, 1, 8);
353
354         // iterate
355         $hash = md5($salt.$clear, true);
356         do {
357             $hash = md5($hash.$clear, true);
358         } while(--$iter);
359
360         // encode
361         $output = '';
362         $count  = 16;
363         $i      = 0;
364         do {
365             $value = ord($hash[$i++]);
366             $output .= $itoa64[$value & 0x3f];
367             if($i < $count)
368                 $value |= ord($hash[$i]) << 8;
369             $output .= $itoa64[($value >> 6) & 0x3f];
370             if($i++ >= $count)
371                 break;
372             if($i < $count)
373                 $value |= ord($hash[$i]) << 16;
374             $output .= $itoa64[($value >> 12) & 0x3f];
375             if($i++ >= $count)
376                 break;
377             $output .= $itoa64[($value >> 18) & 0x3f];
378         } while($i < $count);
379
380         return '$'.$magic.'$'.$iterc.$salt.$output;
381     }
382
383     /**
384      * Alias for hash_pmd5
385      */
386     public function hash_hmd5($clear, $salt = null, $magic = 'H', $compute = 8) {
387         return $this->hash_pmd5($clear, $salt, $magic, $compute);
388     }
389
390     /**
391      * Password hashing method 'djangosha1'
392      *
393      * Uses salted SHA1 hashs. Salt is 5 bytes long.
394      * This is used by the Django Python framework
395      *
396      * @link http://docs.djangoproject.com/en/dev/topics/auth/#passwords
397      * @param string $clear The clear text to hash
398      * @param string $salt  The salt to use, null for random
399      * @return string Hashed password
400      */
401     public function hash_djangosha1($clear, $salt = null) {
402         $this->init_salt($salt, 5);
403         return 'sha1$'.$salt.'$'.sha1($salt.$clear);
404     }
405
406     /**
407      * Password hashing method 'djangomd5'
408      *
409      * Uses salted MD5 hashs. Salt is 5 bytes long.
410      * This is used by the Django Python framework
411      *
412      * @link http://docs.djangoproject.com/en/dev/topics/auth/#passwords
413      * @param string $clear The clear text to hash
414      * @param string $salt  The salt to use, null for random
415      * @return string Hashed password
416      */
417     public function hash_djangomd5($clear, $salt = null) {
418         $this->init_salt($salt, 5);
419         return 'md5$'.$salt.'$'.md5($salt.$clear);
420     }
421
422     /**
423      * Passwordhashing method 'bcrypt'
424      *
425      * Uses a modified blowfish algorithm called eksblowfish
426      * This method works on PHP 5.3+ only and will throw an exception
427      * if the needed crypt support isn't available
428      *
429      * A full hash should be given as salt (starting with $a2$) or this
430      * will break. When no salt is given, the iteration count can be set
431      * through the $compute variable.
432      *
433      * @param string $clear The clear text to hash
434      * @param string $salt  The salt to use, null for random
435      * @param int    $compute The iteration count (between 4 and 31)
436      * @throws Exception
437      * @return string Hashed password
438      */
439     public function hash_bcrypt($clear, $salt = null, $compute = 8) {
440         if(!defined('CRYPT_BLOWFISH') || CRYPT_BLOWFISH != 1) {
441             throw new Exception('This PHP installation has no bcrypt support');
442         }
443
444         if(is_null($salt)) {
445             if($compute < 4 || $compute > 31) $compute = 8;
446             $salt = '$2a$'.str_pad($compute, 2, '0', STR_PAD_LEFT).'$'.
447                 $this->gen_salt(22);
448         }
449
450         return crypt($clear, $salt);
451     }
452
453 }