<?php

/****
 *                                                                             
 *                                                                             
 *    WARNING: THIS LIBRARY IS BROKEN. DO NOT USE IT!                          
 *                                                                              
 *    This library is used in some AVM Fritz!Box devices to calculate the      
 *    login response hash. This is a PHP translation of Paul Johnston's         
 *    BROKEN MD5 JavaScript library.                                           
 *                                                                             
 *    Translation by Philipp C. Heckel, Distributed under the BSD License      
 *    http://www.philippheckel.com/    
 *
 *    Original blog post:
 *      http://blog.philippheckel.com/2012/12/07/script-refresh-the-fritzmediaserver-dlna-index-of-the-fritzbox-6360-cable/
 *                                                                              
 *                                                                              
 ****/

/*
* A JavaScript implementation of the RSA Data Security, Inc. MD5 Message
* Digest Algorithm, $as defined in RFC 1321.
* Version 2.1 Copyright ($c) Paul Johnston 1999 - 2002.
* Other contributors: Greg Holt, $andrew Kepert, Ydnar, Lostinet
* Distributed under the BSD License
* See http://pajhome.org.uk/crypt/md5 for more info.
*/
/*
* Configurable variables. You may need to tweak these to be compatible with
* the server-side, $but the defaults work in most cases.
*/
$hexcase = 0; /* hex output format. 0 - lowercase; 1 - uppercase */
$b64pad = ""; /* base-64 pad character. "=" for strict RFC compliance */
/* $chrsz = 8; */ /* bits per input character. 8 - ASCII; 16 - Unicode */
$chrsz = 16; /* bits per input character. 8 - ASCII; 16 - Unicode */
/*
* These are the functions you'll usually want to call
* They take string arguments and return either hex or base-64 encoded strings
*/
function BROKEN_hex_md5($s){ return binl2hex(core_md5(str2binl($s), strlen($s) * $GLOBALS['chrsz']));}
function BROKEN_b64_md5($s){ return binl2b64(core_md5(str2binl($s), strlen($s) * $GLOBALS['chrsz']));}
function BROKEN_str_md5($s){ return binl2str(core_md5(str2binl($s), strlen($s) * $GLOBALS['chrsz']));}
function BROKEN_hex_hmac_md5($key, $data) { return binl2hex(core_hmac_md5($key, $data)); }
function BROKEN_b64_hmac_md5($key, $data) { return binl2b64(core_hmac_md5($key, $data)); }
function BROKEN_str_hmac_md5($key, $data) { return binl2str(core_hmac_md5($key, $data)); }
/*
* Perform a simple self-test to see if the VM is working
*/
function md5_vm_test()
{
return hex_md5("abc") == "900150983cd24fb0d6963f7d28e17f72";
}
/*
* Calculate the MD5 of an array of little-endian words, $and a bit length
*/
function core_md5($x, $len)
{
/* append padding */
$x[$len >> 5] |= 0x80 << (($len) % 32);
$x[((zeroFill($len + 64, 9)) << 4) + 14] = $len;
$a = 1732584193;
$b = -271733879;
$c = -1732584194;
$d = 271733878;
for($i = 0; $i < count($x); $i += 16)
{
$olda = $a;
$oldb = $b;
$oldc = $c;
$oldd = $d;
$a = md5_ff($a, $b, $c, $d, get_idx($x,$i+ 0), 7 , -680876936);
$d = md5_ff($d, $a, $b, $c, get_idx($x,$i+ 1), 12, -389564586);
$c = md5_ff($c, $d, $a, $b, get_idx($x,$i+ 2), 17, 606105819);
$b = md5_ff($b, $c, $d, $a, get_idx($x,$i+ 3), 22, -1044525330);
$a = md5_ff($a, $b, $c, $d, get_idx($x,$i+ 4), 7 , -176418897);
$d = md5_ff($d, $a, $b, $c, get_idx($x,$i+ 5), 12, 1200080426);
$c = md5_ff($c, $d, $a, $b, get_idx($x,$i+ 6), 17, -1473231341);
$b = md5_ff($b, $c, $d, $a, get_idx($x,$i+ 7), 22, -45705983);
$a = md5_ff($a, $b, $c, $d, get_idx($x,$i+ 8), 7 , 1770035416);
$d = md5_ff($d, $a, $b, $c, get_idx($x,$i+ 9), 12, -1958414417);
$c = md5_ff($c, $d, $a, $b, get_idx($x,$i+10), 17, -42063);
$b = md5_ff($b, $c, $d, $a, get_idx($x,$i+11), 22, -1990404162);
$a = md5_ff($a, $b, $c, $d, get_idx($x,$i+12), 7 , 1804603682);
$d = md5_ff($d, $a, $b, $c, get_idx($x,$i+13), 12, -40341101);
$c = md5_ff($c, $d, $a, $b, get_idx($x,$i+14), 17, -1502002290);
$b = md5_ff($b, $c, $d, $a, get_idx($x,$i+15), 22, 1236535329);
$a = md5_gg($a, $b, $c, $d, get_idx($x,$i+ 1), 5 , -165796510);
$d = md5_gg($d, $a, $b, $c, get_idx($x,$i+ 6), 9 , -1069501632);
$c = md5_gg($c, $d, $a, $b, get_idx($x,$i+11), 14, 643717713);
$b = md5_gg($b, $c, $d, $a, get_idx($x,$i+ 0), 20, -373897302);
$a = md5_gg($a, $b, $c, $d, get_idx($x,$i+ 5), 5 , -701558691);
$d = md5_gg($d, $a, $b, $c, get_idx($x,$i+10), 9 , 38016083);
$c = md5_gg($c, $d, $a, $b, get_idx($x,$i+15), 14, -660478335);
$b = md5_gg($b, $c, $d, $a, get_idx($x,$i+ 4), 20, -405537848);
$a = md5_gg($a, $b, $c, $d, get_idx($x,$i+ 9), 5 , 568446438);
$d = md5_gg($d, $a, $b, $c, get_idx($x,$i+14), 9 , -1019803690);
$c = md5_gg($c, $d, $a, $b, get_idx($x,$i+ 3), 14, -187363961);
$b = md5_gg($b, $c, $d, $a, get_idx($x,$i+ 8), 20, 1163531501);
$a = md5_gg($a, $b, $c, $d, get_idx($x,$i+13), 5 , -1444681467);
$d = md5_gg($d, $a, $b, $c, get_idx($x,$i+ 2), 9 , -51403784);
$c = md5_gg($c, $d, $a, $b, get_idx($x,$i+ 7), 14, 1735328473);
$b = md5_gg($b, $c, $d, $a, get_idx($x,$i+12), 20, -1926607734);
$a = md5_hh($a, $b, $c, $d, get_idx($x,$i+ 5), 4 , -378558);
$d = md5_hh($d, $a, $b, $c, get_idx($x,$i+ 8), 11, -2022574463);
$c = md5_hh($c, $d, $a, $b, get_idx($x,$i+11), 16, 1839030562);
$b = md5_hh($b, $c, $d, $a, get_idx($x,$i+14), 23, -35309556);
$a = md5_hh($a, $b, $c, $d, get_idx($x,$i+ 1), 4 , -1530992060);
$d = md5_hh($d, $a, $b, $c, get_idx($x,$i+ 4), 11, 1272893353);
$c = md5_hh($c, $d, $a, $b, get_idx($x,$i+ 7), 16, -155497632);
$b = md5_hh($b, $c, $d, $a, get_idx($x,$i+10), 23, -1094730640);
$a = md5_hh($a, $b, $c, $d, get_idx($x,$i+13), 4 , 681279174);
$d = md5_hh($d, $a, $b, $c, get_idx($x,$i+ 0), 11, -358537222);
$c = md5_hh($c, $d, $a, $b, get_idx($x,$i+ 3), 16, -722521979);
$b = md5_hh($b, $c, $d, $a, get_idx($x,$i+ 6), 23, 76029189);
$a = md5_hh($a, $b, $c, $d, get_idx($x,$i+ 9), 4 , -640364487);
$d = md5_hh($d, $a, $b, $c, get_idx($x,$i+12), 11, -421815835);
$c = md5_hh($c, $d, $a, $b, get_idx($x,$i+15), 16, 530742520);
$b = md5_hh($b, $c, $d, $a, get_idx($x,$i+ 2), 23, -995338651);
$a = md5_ii($a, $b, $c, $d, get_idx($x,$i+ 0), 6 , -198630844);
$d = md5_ii($d, $a, $b, $c, get_idx($x,$i+ 7), 10, 1126891415);
$c = md5_ii($c, $d, $a, $b, get_idx($x,$i+14), 15, -1416354905);
$b = md5_ii($b, $c, $d, $a, get_idx($x,$i+ 5), 21, -57434055);
$a = md5_ii($a, $b, $c, $d, get_idx($x,$i+12), 6 , 1700485571);
$d = md5_ii($d, $a, $b, $c, get_idx($x,$i+ 3), 10, -1894986606);
$c = md5_ii($c, $d, $a, $b, get_idx($x,$i+10), 15, -1051523);
$b = md5_ii($b, $c, $d, $a, get_idx($x,$i+ 1), 21, -2054922799);
$a = md5_ii($a, $b, $c, $d, get_idx($x,$i+ 8), 6 , 1873313359);
$d = md5_ii($d, $a, $b, $c, get_idx($x,$i+15), 10, -30611744);
$c = md5_ii($c, $d, $a, $b, get_idx($x,$i+ 6), 15, -1560198380);
$b = md5_ii($b, $c, $d, $a, get_idx($x,$i+13), 21, 1309151649);
$a = md5_ii($a, $b, $c, $d, get_idx($x,$i+ 4), 6 , -145523070);
$d = md5_ii($d, $a, $b, $c, get_idx($x,$i+11), 10, -1120210379);
$c = md5_ii($c, $d, $a, $b, get_idx($x,$i+ 2), 15, 718787259);
$b = md5_ii($b, $c, $d, $a, get_idx($x,$i+ 9), 21, -343485551);
$a = safe_add($a, $olda);
$b = safe_add($b, $oldb);
$c = safe_add($c, $oldc);
$d = safe_add($d, $oldd);
}
return array($a, $b, $c, $d);
}
/*
* These functions implement the four basic operations the algorithm uses.
*/
function md5_cmn($q, $a, $b, $x, $s, $t)
{
return safe_add(bit_rol(safe_add(safe_add($a, $q), safe_add($x, $t)), $s),$b);
}
function md5_ff($a, $b, $c, $d, $x, $s, $t)
{
return md5_cmn(($b & $c) | ((~$b) & $d), $a, $b, $x, $s, $t);
}
function md5_gg($a, $b, $c, $d, $x, $s, $t)
{
return md5_cmn(($b & $d) | ($c & (~$d)), $a, $b, $x, $s, $t);
}
function md5_hh($a, $b, $c, $d, $x, $s, $t)
{
return md5_cmn($b ^ $c ^ $d, $a, $b, $x, $s, $t);
}
function md5_ii($a, $b, $c, $d, $x, $s, $t)
{
return md5_cmn($c ^ ($b | (~$d)), $a, $b, $x, $s, $t);
}
/*
* Calculate the HMAC-MD5, of a key and some data
*/
function core_hmac_md5($key, $data)
{
$bkey = str2binl($key);
if(count($bkey) > 16) $bkey = core_md5($bkey, strlen($key) * $GLOBALS['chrsz']);
$ipad = array(/*16*/); $opad = array(/*16*/);
for($i = 0; $i < 16; $i++)
{
$ipad[$i] = $bkey[$i] ^ 0x36363636;
$opad[$i] = $bkey[$i] ^ 0x5C5C5C5C;
}
$hash = core_md5(array_merge($ipad, str2binl($data)), 512 + strlen($data) * $GLOBALS['chrsz']);
return core_md5(array_merge($opad, $hash), 512 + 128);
}
/*
* Add integers, wrapping at 2^32. This uses 16-bit operations internally
* to work around bugs in some JS interpreters.
*/
function safe_add($x, $y)
{
$lsw = ($x & 0xFFFF) + ($y & 0xFFFF);
$msw = ($x >> 16) + ($y >> 16) + ($lsw >> 16);
return ($msw << 16) | ($lsw & 0xFFFF);
}
/*
* Bitwise rotate a 32-bit number to the left.
*/
function bit_rol($num, $cnt)
{
return ($num << $cnt) | (zeroFill($num, 32 - $cnt));
}
/*
* Convert a string to an array of little-endian words
* If $GLOBALS['chrsz'] is ASCII, $characters >255 have their hi-byte silently ignored.
*/
function str2binl($str)
{
$bin = array();
$mask = (1 << $GLOBALS['chrsz']) - 1;
for($i = 0; $i < strlen($str) * $GLOBALS['chrsz']; $i += $GLOBALS['chrsz']) {
if (!isset($bin[$i>>5])) { $bin[$i>>5] = 0; } // PHILIPP: Addition to avoid PHP notices
$bin[$i>>5] |= (ord($str[$i / $GLOBALS['chrsz']]) & $mask) << ($i%32); 
}
return $bin;
}
/*
* Convert an array of little-endian words to a string
*/
function binl2str($bin)
{
$str = "";
$mask = (1 << $GLOBALS['chrsz']) - 1;
for($i = 0; $i < strlen($bin) * 32; $i += $GLOBALS['chrsz'])
$str .=	 uniord((zeroFill($bin[$i>>5], $i % 32)) & $mask); 
return $str;
}
/*
* Convert an array of little-endian words to a hex string.
*/
function binl2hex($binarray)
{
$hex_tab = $GLOBALS['hexcase'] ? "0123456789ABCDEF" : "0123456789abcdef";
$str = "";
for($i = 0; $i < count($binarray) * 4; $i++)
{
$str .= $hex_tab[($binarray[$i>>2] >> (($i%4)*8+4)) & 0xF] . 
$hex_tab[($binarray[$i>>2] >> (($i%4)*8 )) & 0xF]; 
}
return $str;
}
/*
* Convert an array of little-endian words to a base-64 string
*/
function binl2b64($binarray)
{
$tab = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
$str = "";
for($i = 0; $i < count($binarray) * 4; $i += 3)
{
$triplet = ((($binarray[$i >> 2] >> 8 * ( $i %4)) & 0xFF) << 16)
| ((($binarray[$i+1 >> 2] >> 8 * (($i+1)%4)) & 0xFF) << 8 )
| (($binarray[$i+2 >> 2] >> 8 * (($i+2)%4)) & 0xFF);
for($j = 0; $j < 4; $j++)
{
if($i * 8 + $j * 6 > count($binarray) * 32) $str .= $GLOBALS['b64pad'];
else $str .= $tab{($triplet >> 6*(3-j)) & 0x3F};
}
}
return $str;
}

// From: http://stackoverflow.com/questions/2642026/php-equivalent-javascript-shift-right-with-zero-fill-bitwise-operators
function zeroFill($a,$b) {
    if ($a >= 0) { 
        return bindec(decbin($a>>$b)); //simply right shift for positive number
    }

    $bin = decbin($a>>$b);

    $bin = substr($bin, $b); // zero fill on the left side

    $o = bindec($bin);
    return $o;
}

// Equals JavaScript String.fromCharCode()
// From: http://blog.stanislavstankov.com/2010/02/equal-function-string-fromcharcode-in-php/
function uniord($ch) {

    $n = ord($ch{0});

    if ($n < 128) {
        return $n; // no conversion required
    }

    if ($n < 192 || $n > 253) {
        return false; // bad first byte || out of range
    }

    $arr = array(1 => 192, // byte position => range from
                 2 => 224,
                 3 => 240,
                 4 => 248,
                 5 => 252,
                 );

    foreach ($arr as $key => $val) {
        if ($n >= $val) { // add byte to the 'char' array
            $char[] = ord($ch{$key}) - 128;
            $range  = $val;
        } else {
            break; // save some e-trees
        }
    }

    $retval = ($n - $range) * pow(64, sizeof($char));

    foreach ($char as $key => $val) {
        $pow = sizeof($char) - ($key + 1); // invert key
        $retval += $val * pow(64, $pow);   // dark magic
    }

    return $retval;
}

function get_idx($arr, $i) {
	return (isset($arr[$i])) ? $arr[$i] : 0;
}
?>