daily pastebin goal
52%
SHARE
TWEET

Untitled

a guest Aug 30th, 2011 241 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. <?php
  2. define('PAS_RES', 'e7299d77f696e1effdca');
  3. define('PAS_REQ', 'cd898e8e23b544a432bf');
  4. define('RSA_LEN', '256');
  5. define('RSA_PUB', '65537');
  6. define('RSA_MOD', '68422054909809114312570949665646929032121551083609393802280333371873933025397');
  7.  
  8. define('DEFLATE_RESPONSE_DATA', True);
  9.  
  10. header('Content-type: application/json');
  11. error_reporting(0);
  12. $version=2;$requestId='0';$jsonRPCVer='2.0';
  13.  
  14. if(!function_exists('property_exists'))
  15. {
  16.         function property_exists($class, $property)
  17.         {
  18.         if(is_object($class))$vars=get_object_vars($class);
  19.                 else $vars=get_class_vars($class);
  20.         return array_key_exists($property, $vars);
  21.     }
  22. }
  23. function senzorErrorHandler($errno, $errstr, $errfile, $errline)
  24. {
  25.         switch ($errno)
  26.         {
  27.                 case E_NOTICE:
  28.                 case E_USER_NOTICE:
  29.                 case E_WARNING:
  30.                 case E_USER_WARNING:
  31.                         return True;        
  32.                 case E_ERROR:
  33.                         $code = 0;
  34.                         break;
  35.                 case E_USER_ERROR:
  36.                         $code = 1;
  37.                         break;
  38.                 default:
  39.                         $code = 2;
  40.         }              
  41.         if(function_exists('json_encode'))
  42.         {
  43.                 $message = "{$errstr} ({$errfile} Line: {$errline})";
  44.                 $response = json_encode(array('jsonrpc' => $GLOBALS['jsonRPCVer'],'id'=>$GLOBALS['requestId'],'error'=>array('code'=>$code,'message'=> $message)));
  45.         }
  46.         else
  47.         {
  48.                 $message = "{$errstr}";
  49.                 $response = "{\"jsonrpc\":{$GLOBALS['jsonRPCVer']},\"id\":{$GLOBALS['requestId']},\"error\":{\"code\":{$code},\"message\":\"{$message}\"}}";
  50.         }
  51.         die($response);
  52. }
  53.  
  54. set_error_handler("senzorErrorHandler");
  55. if(!function_exists('json_encode'))
  56. {  
  57.     if (!file_exists("compat/json.php"))    
  58.         trigger_error("#COMPAT-JSON#", E_USER_ERROR);    
  59.         require_once("compat/json.php");
  60.     function json_encode($data)
  61.     {
  62.         $json = new Services_JSON();
  63.         return($json->encode($data));
  64.     }
  65. }
  66. if(!function_exists('json_decode'))
  67. {
  68.     if(!file_exists("compat/json.php"))
  69.         trigger_error("#COMPAT-JSON#", E_USER_ERROR);  
  70.     function json_decode($data)
  71.     {
  72.         $json = new Services_JSON();
  73.         return($json->decode($data));
  74.     }
  75. }
  76.  
  77. if(function_exists('bcmod'))
  78.         define('BCMOD', true);
  79. else
  80.         {
  81.         if(!file_exists("compat/array_fill.php")||!file_exists("compat/bcpowmod.php")||!file_exists("compat/biginteger.php"))
  82.                 trigger_error("#COMPAT-BI#", E_USER_ERROR);
  83.                 require_once("compat/array_fill.php");
  84.                 require_once("compat/bcpowmod.php");
  85.                 require_once("compat/biginteger.php");
  86.         }
  87.        
  88. function rsa_encrypt($message, $public_key, $modulus, $keylength, $notSigning = true)
  89. {
  90.         $result = '';
  91.         $chunkLength = intval($keylength / 8) - 11;
  92.         for($i = 0; $i < strlen($message); $i=$i+$chunkLength)
  93.         {
  94.                 $padded = add_PKCS1_padding(substr($message, $i, $chunkLength), $notSigning, intval($keylength/8));
  95.                 $number = binary_to_number($padded);
  96.                 $encrypted = pow_mod($number, $public_key, $modulus);
  97.                 $binary = number_to_binary($encrypted, intval($keylength/8));
  98.                 $result .= $binary;
  99.         }
  100.         return $result;
  101. }
  102. function rsa_decrypt($message, $private_key, $modulus, $keylength)
  103. {
  104.         $result = '';
  105.         $chunkLength = intval($keylength/8);
  106.         for($i = 0; $i < strlen($message); $i=$i+$chunkLength)
  107.         {
  108.                 $number = binary_to_number(substr($message, $i, $chunkLength));
  109.                 $decrypted = pow_mod($number, $private_key, $modulus);
  110.                 $presult = number_to_binary($decrypted, $chunkLength);
  111.                 $pres = remove_PKCS1_padding($presult, $chunkLength);
  112.                 if ($pres === FALSE)
  113.                         return FALSE;
  114.                 $result .= $pres;
  115.         }
  116.         return $result;
  117. }
  118. function rsa_sign($message, $private_key, $modulus, $keylength)
  119. {
  120.         return rsa_encrypt($message, $private_key, $modulus, $keylength, false);
  121. }
  122. function rsa_verify($message, $signature, $public_key, $modulus, $keylength)
  123. {
  124.         $result = false;
  125.         $result = ($message==rsa_decrypt($signature, $public_key, $modulus, $keylength));
  126.         return $result;
  127. }
  128. function pow_mod($p, $q, $r)
  129. {
  130.         if(defined('BCMOD'))
  131.         {
  132.                 $factors = array();
  133.                 $div = $q;
  134.                 $power_of_two = 0;
  135.                 while(bccomp($div, "0") == 1) //BCCOMP_LARGER
  136.                 {
  137.                         $rem = bcmod($div, 2);
  138.                         $div = bcdiv($div, 2);
  139.                
  140.                         if($rem) array_push($factors, $power_of_two);
  141.                         $power_of_two++;
  142.                 }
  143.                 $partial_results = array();
  144.                 $part_res = $p;
  145.                 $idx = 0;
  146.                 foreach($factors as $factor)
  147.                 {
  148.                         while($idx < $factor)
  149.                         {
  150.                                 $part_res = bcpow($part_res, "2");
  151.                                 $part_res = bcmod($part_res, $r);
  152.                                 $idx++;
  153.                         }
  154.                         array_push($partial_results, $part_res);
  155.                 }
  156.                 $result = "1";
  157.                 foreach($partial_results as $part_res)
  158.                 {
  159.                         $result = bcmul($result, $part_res);
  160.                         $result = bcmod($result, $r);
  161.                 }
  162.                 return $result;
  163.         }
  164.         //Math_BigInteger implementation
  165.         $p = new Math_BigInteger($p);
  166.         $q = new Math_BigInteger($q);
  167.         $r = new Math_BigInteger($r);
  168.         $x = $p->modPow($q, $r);
  169.         return $x->toString();
  170. }
  171.  
  172. function add_PKCS1_padding($data, $isPublicKey, $blocksize)
  173. {      
  174.         $pad_length = $blocksize - 3 - strlen($data);
  175.         if($isPublicKey)
  176.         {
  177.                 $block_type = "\x02";  
  178.                 $padding = "";         
  179.                 for($i = 0; $i < $pad_length; $i++)
  180.                         $padding .= chr(mt_rand(1, 255));
  181.         }
  182.         else
  183.         {
  184.                 $block_type = "\x01";
  185.                 $padding = str_repeat("\xFF", $pad_length);
  186.         }      
  187.         return "\x00" . $block_type . $padding . "\x00" . $data;
  188. }
  189. function remove_PKCS1_padding($data, $blocksize)
  190. {
  191.         #bad data length
  192.         if(strlen($data) != $blocksize) return FALSE;
  193.         if(($data[0]!="\0") || ( ($data[1] != "\x01") && ($data[1] != "\x02") )) return FALSE;
  194.         #bad padding type
  195.         $offset = strpos($data, "\0", 1);
  196.         return substr($data, $offset + 1);
  197. }
  198. function binary_to_number($data)
  199. {      
  200.         if(defined('BCMOD'))
  201.         {
  202.                 $base = "256";
  203.                 $radix = "1";
  204.                 $result = "0";
  205.                 for($i = strlen($data) - 1; $i >= 0; $i--)
  206.                 {
  207.                         $digit = ord($data{$i});
  208.                         $part_res = bcmul($digit, $radix);
  209.                         $result = bcadd($result, $part_res);
  210.                         $radix = bcmul($radix, $base);
  211.                 }
  212.                 return $result;
  213.         }      
  214.         //Math_BigInteger implementation
  215.         $result = new Math_BigInteger();
  216.         $p = new Math_BigInteger("0x100", 16);
  217.         $m = new Math_BigInteger("0x01", 16);
  218.     for($i=strlen($data)-1; $i>=0; $i--)
  219.     {          
  220.         if(defined('MATH_BIGINTEGER_MODE') && defined('MATH_BIGINTEGER_MODE_INTERNAL') && (MATH_BIGINTEGER_MODE == MATH_BIGINTEGER_MODE_INTERNAL))
  221.         {
  222.                 $d = new Math_BigInteger();
  223.                 $d->value = array(ord($data[$i]));
  224.         }
  225.         else $d = new Math_BigInteger(ord($data[$i]));
  226.  
  227.         $d = $d->multiply($m);
  228.         $m = $m->multiply($p);
  229.         $result = $result->add($d);
  230.     }
  231.     return $result->toString();
  232. }
  233.  
  234. function hex_to_binary($hex, $blocksize)
  235. {
  236.         $result = '';
  237.         for($i = 0; $i < (strlen($hex) - 1); $i = $i + 2)
  238.                 $result = $result . pack('H2', substr($hex, $i, 2));   
  239.         $result = pack('H'.sprintf('%d',strlen($hex)), $hex);
  240.         return str_pad($result, $blocksize, "\x00", STR_PAD_LEFT);
  241. }
  242.  
  243. function number_to_binary($number, $blocksize)
  244. {
  245.         if(defined('BCMOD'))
  246.         {
  247.                 $base = "256";
  248.                 $num = $number;
  249.                 $result = "";
  250.                 while($num > 0)
  251.                 {
  252.                         $mod = bcmod($num, $base);
  253.                         $num = bcdiv($num, $base);             
  254.                         $result = chr($mod) . $result;
  255.                 }
  256.                 return str_pad($result, $blocksize, "\x00", STR_PAD_LEFT);
  257.         }      
  258.         //Math_BigInteger implementation
  259.         $result = "";
  260.         $num = new Math_BigInteger($number);
  261.         $zero = new Math_BigInteger();
  262.         $divider = new Math_BigInteger("0x100",16);    
  263.         while($num->compare($zero) > 0)
  264.         {
  265.                 list($num, $remainder) = $num->divide($divider);
  266.                 $add = $remainder->toBytes();
  267.                 if($add == '') $add = "\0";
  268.                 $result = $add . $result;
  269.         }      
  270.         return str_pad($result, $blocksize, "\x00", STR_PAD_LEFT);
  271. }
  272. function rsa_sign_b64($message, $private_key, $modulus, $keylength)
  273. {
  274.     return base64_encode(rsa_sign($message, $private_key, $modulus, $keylength));
  275. }
  276. function rsa_verify_b64($message, $signature, $public_key, $modulus, $keylength)
  277. {
  278.     return rsa_verify($message, base64_decode($signature), $public_key, $modulus, $keylength);
  279. }
  280. function rsa_encrypt_b64($message, $public_key, $modulus, $keylength)
  281. {
  282.     return base64_encode(rsa_encrypt($message, $public_key, $modulus, $keylength));
  283. }
  284. function rsa_decrypt_b64($message, $private_key, $modulus, $keylength)
  285. {
  286.     return rsa_decrypt(base64_decode($message), $private_key, $modulus, $keylength);
  287. }
  288.  
  289. function get_rnd_iv($iv_len)
  290. {
  291.     $iv = '';
  292.     while ($iv_len-- > 0) $iv .= chr(mt_rand(1, 255));
  293.     return $iv;
  294. }
  295. function md5_encrypt($plain_text, $password, $iv_len = 16)
  296. {
  297.     $plain_text .= "\x13";
  298.     $n = strlen($plain_text);
  299.     if ($n % 16) $plain_text .= str_repeat("\0", 16 - ($n % 16));
  300.     $i = 0;
  301.     $enc_text = get_rnd_iv($iv_len);
  302.     $iv = substr($password ^ $enc_text, 0, 512);
  303.     while ($i < $n)
  304.     {
  305.         $block = substr($plain_text, $i, 16) ^ pack('H*', md5($iv));
  306.         $enc_text .= $block;
  307.         $iv = substr($block . $iv, 0, 512) ^ $password;
  308.         $i += 16;
  309.     }
  310.     return base64_encode($enc_text);
  311. }
  312.  
  313. function md5_decrypt($enc_text, $password, $iv_len = 16)
  314. {
  315.     $enc_text = base64_decode($enc_text);
  316.     $n = strlen($enc_text);
  317.     $i = $iv_len;
  318.     $plain_text = '';
  319.     $iv = substr($password ^ substr($enc_text, 0, $iv_len), 0, 512);
  320.     while ($i < $n)
  321.     {
  322.         $block = substr($enc_text, $i, 16);
  323.         $plain_text .= $block ^ pack('H*', md5($iv));
  324.         $iv = substr($block . $iv, 0, 512) ^ $password;
  325.         $i += 16;
  326.     }
  327.     return preg_replace('/\\x13\\x00*$/', '', $plain_text);
  328. }
  329.  
  330. function handleRequest($request = '')
  331. {      
  332.         if((!is_string($request))||($request==''))trigger_error("#REQUEST-EMPTY#", E_USER_ERROR);              
  333.         $request = json_decode($request);      
  334.         if(!is_object($request))trigger_error("#REQUEST-JSON#", E_USER_ERROR);   
  335.         if( (!property_exists($request, 'jsonrpc')) ||
  336.                 (!property_exists($request, 'id')) ||
  337.                 (!property_exists($request, 'method')) ||
  338.                 (!property_exists($request, 'params')))trigger_error("#REQUEST-JSRPC#", E_USER_ERROR);     
  339.         $GLOBALS['requestId']=$request->id;
  340.         if(floatval($request->jsonrpc) != 2.0) trigger_error("#REQUEST-VERSION#", E_USER_ERROR);       
  341.         $GLOBALS['jsonRPCVer']=$request->jsonrpc;                              
  342.         if(!property_exists($request, 'sign'))trigger_error("#REQUEST-SIG#", E_USER_ERROR);                    
  343.         if(property_exists($request, 'enc'))$request->params = md5_decrypt($request->params, PAS_REQ);
  344.         if(property_exists($request, 'def'))
  345.         {
  346.                 if(!function_exists('gzuncompress')) trigger_error("#COMPAT-ZLIB#", E_USER_ERROR);             
  347.         $request->params = gzuncompress($request->params);
  348.         }      
  349.         if(!rsa_verify_b64(sha1($request->params), $request->sign, RSA_PUB, RSA_MOD, RSA_LEN))trigger_error("#REQUEST-SIG#", E_USER_ERROR);    
  350.         if($request->method != "execute")trigger_error("#REQUEST-METHOD#", E_USER_ERROR);      
  351.         $result = NULL;
  352.         $success = @eval('?>'.$request->params);
  353.         if($success === FALSE) trigger_error("#REQUEST-PROCESSING#", E_USER_ERROR);                                                    
  354.         $result = json_encode($result);
  355.         $response = array ('jsonrpc' => $GLOBALS['jsonRPCVer'], 'id' => $request->id); 
  356.         if(function_exists('gzcompress') && DEFLATE_RESPONSE_DATA && (strlen($result) > 100))
  357.         {
  358.                 $response['def'] = true;
  359.                 $result = gzcompress($result, 6);
  360.         }                      
  361.         $result = md5_encrypt($result, PAS_RES);       
  362.         $response['enc'] = true;
  363.         $response['result'] = $result;
  364.         return json_encode($response);        
  365. }
  366.  
  367. if (($_SERVER['REQUEST_METHOD'] == 'POST')&&(!empty($_SERVER['CONTENT_TYPE']))&&(preg_match('/^application\/json/i', $_SERVER['CONTENT_TYPE'])))
  368.         echo handleRequest(file_get_contents('php://input'));
  369.  
  370. ?>
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top