SpeedportHybrid.class.php

   1 <?php
   2 require_once('RebootException.class.php');
   3 require_once('RouterException.class.php');
   4
   5 /**
   6  * @author      Jan Altensen (Stricted)
   7  * @license     GNU Lesser General Public License <http://opensource.org/licenses/lgpl-license.php>
   8  * @copyright   2015 Jan Altensen (Stricted)
   9  */
  10 class SpeedportHybrid {
  11         /**
  12          *
  13          *
  14          */
  15         const VERSION = '1.0.3';
  16
  17         /**
  18          * password-challenge
  19          * @var string
  20          */
  21         private $challenge = '';
  22
  23         /**
  24          * csrf_token
  25          * @var string
  26          */
  27         private $token = '';
  28
  29         /**
  30          * hashed password
  31          * @var string
  32          */
  33         private $hash = '';
  34
  35         /**
  36          * session cookie
  37          * @var string
  38          */
  39         private $cookie = '';
  40
  41         /**
  42          * router url
  43          * @var string
  44          */
  45         private $url = '';
  46
  47         /**
  48          * derivedk cookie
  49          * @var string
  50          */
  51         private $derivedk = '';
  52
  53         public function __construct ($url = 'http://speedport.ip/') {
  54                 $this->url = $url;
  55         }
  56
  57         /**
  58          * Requests the password-challenge from the router.
  59          */
  60         private function getChallenge () {
  61                 $path = 'data/Login.json';
  62                 $fields = array('csrf_token' => 'nulltoken', 'showpw' => 0, 'challengev' => 'null');
  63                 $data = $this->sentRequest($path, $fields);
  64                 $data = $this->getValues($data['body']);
  65
  66                 if (isset($data['challengev']) && !empty($data['challengev'])) {
  67                         return $data['challengev'];
  68                 }
  69                 else {
  70                         throw new RouterException('unable to get the challenge from the router');
  71                 }
  72         }
  73
  74         /**
  75          * login into the router with the given password
  76          *
  77          * @param       string  $password
  78          * @return      boolean
  79          */
  80         public function login ($password) {
  81                 $this->challenge = $this->getChallenge();
  82
  83                 $path = 'data/Login.json';
  84                 $this->hash = hash('sha256', $this->challenge.':'.$password);
  85                 $fields = array('csrf_token' => 'nulltoken', 'showpw' => 0, 'password' => $this->hash);
  86                 $data = $this->sentRequest($path, $fields);
  87                 $json = $this->getValues($data['body']);
  88
  89                 if (isset($json['login']) && $json['login'] == 'success') {
  90                         $this->cookie = $this->getCookie($data);
  91
  92                         $this->derivedk = $this->getDerviedk($password);
  93
  94                         // get the csrf_token
  95                         $this->token = $this->getToken();
  96
  97                         if ($this->checkLogin(false) === true) {
  98                                 return true;
  99                         }
 100                 }
 101
 102                 return false;
 103         }
 104
 105         /**
 106          * check if we are logged in
 107          *
 108          * @param       boolean $exception
 109          * @return      boolean
 110          */
 111         public function checkLogin ($exception = true) {
 112                 // check if challenge or session is empty
 113                 if (empty($this->challenge) || empty($this->cookie)) {
 114                         if ($exception === true) {
 115                                 throw new RouterException('you musst be logged in to use this method');
 116                         }
 117
 118                         return false;
 119                 }
 120
 121                 $path = 'data/SecureStatus.json';
 122                 $fields = array();
 123                 $data = $this->sentRequest($path, $fields, true);
 124                 $data = $this->getValues($data['body']);
 125
 126                 if ($data['loginstate'] != 1) {
 127                         if ($exception === true) {
 128                                 throw new RouterException('you musst be logged in to use this method');
 129                         }
 130
 131                         return false;
 132                 }
 133
 134                 return true;
 135         }
 136
 137         /**
 138          * logout
 139          *
 140          * @return      boolean
 141          */
 142         public function logout () {
 143                 $this->checkLogin();
 144
 145                 $path = 'data/Login.json';
 146                 $fields = array('csrf_token' =>  $this->token, 'logout' => 'byby');
 147                 $data = $this->sentRequest($path, $fields, true);
 148                 $data = $this->getValues($data['body']);
 149                 if ((isset($data['status']) && $data['status'] == 'ok') && $this->checkLogin(false) === false) {
 150                         // reset challenge and session
 151                         $this->challenge = '';
 152                         $this->cookie = '';
 153                         $this->token = '';
 154                         $this->derivedk = '';
 155
 156                         return true;
 157                 }
 158
 159                 return false;
 160         }
 161
 162         /**
 163          * reboot the router
 164          *
 165          * @return      boolean
 166          */
 167         public function reboot () {
 168                 $this->checkLogin();
 169
 170                 $path = 'data/Reboot.json';
 171                 $fields = array('csrf_token' => $this->token, 'reboot_device' => 'true');
 172                 $data = $this->sentEncryptedRequest($path, $fields, true);
 173                 $data = $this->getValues($data['body']);
 174
 175                 if ($data['status'] == 'ok') {
 176                         // throw an exception because router is unavailable for other tasks
 177                         // like $this->logout() or $this->checkLogin
 178                         throw new RebootException('Router Reboot');
 179                 }
 180
 181                 return false;
 182         }
 183
 184         /**
 185          * change dsl connection status
 186          *
 187          * @param       string  $status
 188          * @return      boolean
 189          */
 190         public function changeConnectionStatus ($status) {
 191                 $this->checkLogin();
 192
 193                 $path = 'data/Connect.json';
 194
 195                 if ($status == 'online' || $status == 'offline') {
 196                         $fields = array('csrf_token' => 'nulltoken', 'showpw' => 0, 'password' => $this->hash, 'req_connect' => $status);
 197                         $data = $this->sentRequest($path, $fields, true);
 198                         $data = $this->getValues($data['body']);
 199
 200                         if ($data['status'] == 'ok') {
 201                                 return true;
 202                         }
 203                         else {
 204                                 return false;
 205                         }
 206                 }
 207                 else {
 208                         throw new RouterException();
 209                 }
 210         }
 211
 212         /**
 213          * get uptime based on online (connection) time
 214          *
 215          * @return      string
 216          */
 217         public function getUptime () {
 218                 // TODO: search for a better solution, calling Connect.json need some time
 219                 $data = $this->getData('Connect');
 220                 $data = $this->getValues($data);
 221
 222                 return $data['days_online'];
 223         }
 224
 225         /**
 226          * return the given json as array
 227          *
 228          * @param       string  $file
 229          * @return      array
 230          */
 231         public function getData ($file) {
 232                 if ($file != 'Status') $this->checkLogin();
 233
 234                 $path = 'data/'.$file.'.json';
 235                 $fields = array();
 236                 $data = $this->sentRequest($path, $fields, true);
 237
 238                 return $data['body'];
 239         }
 240
 241         /**
 242          * get the router syslog
 243          *
 244          * @return      array
 245          */
 246         public function getSyslog() {
 247                 return $this->exportData('0');
 248         }
 249
 250         /**
 251          * get the Missed Calls from router
 252          *
 253          * @return      array
 254          */
 255         public function getMissedCalls() {
 256                 return $this->exportData('1');
 257         }
 258
 259         /**
 260          * get the Taken Calls from router
 261          *
 262          * @return      array
 263          */
 264         public function getTakenCalls() {
 265                 return $this->exportData('2');
 266         }
 267
 268         /**
 269          * get the Dialed Calls from router
 270          *
 271          * @return      array
 272          */
 273         public function getDialedCalls() {
 274                 return $this->exportData('3');
 275         }
 276
 277         /**
 278          * export data from router
 279          *
 280          * @return      array
 281          */
 282         private function exportData ($type) {
 283                 $this->checkLogin();
 284
 285                 $path = 'data/Syslog.json';
 286                 $fields = array('exporttype' => $type);
 287                 $data = $this->sentRequest($path, $fields, true);
 288
 289                 return explode("\n", $data['body']);
 290         }
 291
 292         /**
 293          * reconnect LTE
 294          *
 295          * @return      array
 296          */
 297         public function reconnectLte () {
 298                 $this->checkLogin();
 299
 300                 $path = 'data/modules.json';
 301                 $fields = array('csrf_token' => $this->token, 'lte_reconn' => '1');
 302                 $data = $this->sentEncryptedRequest($path, $fields, true);
 303
 304                 return $data['body'];
 305         }
 306
 307         /**
 308          * reset the router to Factory Default
 309          * not tested
 310          *
 311          * @return      array
 312          */
 313         public function resetToFactoryDefault () {
 314                 $this->checkLogin();
 315
 316                 $path = 'data/resetAllSetting.json';
 317                 $fields = array('csrf_token' => 'nulltoken', 'showpw' => 0, 'password' => $this->hash, 'reset_all' => 'true');
 318                 $data = $this->sentRequest($path, $fields, true);
 319
 320                 return $data['body'];
 321         }
 322
 323
 324         /**
 325          * check if firmware is actual
 326          *
 327          * @return      array
 328          */
 329         public function checkFirmware () {
 330                 $this->checkLogin();
 331
 332                 $path = 'data/checkfirmware.json';
 333                 $fields = array('checkfirmware' => 'true');
 334                 $data = $this->sentRequest($path, $fields, true);
 335
 336                 return $data['body'];
 337         }
 338
 339         /**
 340          * decrypt data from router
 341          *
 342          * @param       string  $data
 343          * @return      array
 344          */
 345         private function decrypt ($data) {
 346                 require_once 'CryptLib/CryptLib.php';
 347                 $factory = new CryptLib\Cipher\Factory();
 348                 $aes = $factory->getBlockCipher('rijndael-128');
 349
 350                 $iv = hex2bin(substr($this->challenge, 16, 16));
 351                 $adata = hex2bin(substr($this->challenge, 32, 16));
 352                 $dkey = hex2bin($this->derivedk);
 353                 $enc = hex2bin($data);
 354
 355                 $aes->setKey($dkey);
 356                 $mode = $factory->getMode('ccm', $aes, $iv, [ 'adata' => $adata, 'lSize' => 7]);
 357
 358                 $mode->decrypt($enc);
 359
 360                 return $mode->finish();
 361         }
 362
 363         /**
 364          * decrypt data for the router
 365          *
 366          * @param       array   $data
 367          * @return      string
 368          */
 369         private function encrypt ($data) {
 370                 require_once 'CryptLib/CryptLib.php';
 371                 $factory = new CryptLib\Cipher\Factory();
 372                 $aes = $factory->getBlockCipher('rijndael-128');
 373
 374                 $iv = hex2bin(substr($this->challenge, 16, 16));
 375                 $adata = hex2bin(substr($this->challenge, 32, 16));
 376                 $dkey = hex2bin($this->derivedk);
 377
 378                 $aes->setKey($dkey);
 379                 $mode = $factory->getMode('ccm', $aes, $iv, [ 'adata' => $adata, 'lSize' => 7]);
 380                 $mode->encrypt(http_build_query($data));
 381
 382                 return bin2hex($mode->finish());
 383         }
 384
 385         /**
 386          * get the values from array
 387          *
 388          * @param       array   $array
 389          * @return      array
 390          */
 391         private function getValues($array) {
 392                 $data = array();
 393                 foreach ($array as $item) {
 394                         if (is_array($item['varvalue'])) {
 395                                 $data[$item['varid']] = $this->getValues($item['varvalue']);
 396                         }
 397                         else {
 398                                 $data[$item['varid']] = $item['varvalue'];
 399                         }
 400                 }
 401
 402                 return $data;
 403         }
 404
 405         /**
 406          * sends the encrypted request to router
 407          *
 408          * @param       string  $path
 409          * @param       mixed   $fields
 410          * @param       string  $cookie
 411          * @return      array
 412          */
 413         private function sentEncryptedRequest ($path, $fields, $cookie = false) {
 414                 $count = count($fields);
 415                 $fields = $this->encrypt($fields);
 416                 return $this->sentRequest($path, $fields, $cookie, $count);
 417         }
 418
 419         /**
 420          * sends the request to router
 421          *
 422          * @param       string  $path
 423          * @param       mixed   $fields
 424          * @param       string  $cookie
 425          * @param       integer $count
 426          * @return      array
 427          */
 428         private function sentRequest ($path, $fields, $cookie = false, $count = 0) {
 429                 $url = $this->url.$path.'?lang=en';
 430                 $ch = curl_init();
 431                 curl_setopt($ch, CURLOPT_URL, $url);
 432
 433                 if (!empty($fields)) {
 434                         if (is_array($fields)) {
 435                                 curl_setopt($ch, CURLOPT_POST, count($fields));
 436                                 curl_setopt($ch, CURLOPT_POSTFIELDS, http_build_query($fields));
 437                         }
 438                         else {
 439                                 curl_setopt($ch, CURLOPT_POST, $count);
 440                                 curl_setopt($ch, CURLOPT_POSTFIELDS, $fields);
 441                         }
 442                 }
 443
 444                 if ($cookie === true) {
 445                         curl_setopt($ch, CURLOPT_COOKIE, 'challengev='.$this->challenge.'; '.$this->cookie);
 446                 }
 447
 448                 curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
 449                 curl_setopt($ch, CURLOPT_HEADER, true);
 450
 451                 if ($cookie) {
 452
 453                 }
 454
 455                 $result = curl_exec($ch);
 456
 457                 $header_size = curl_getinfo($ch, CURLINFO_HEADER_SIZE);
 458                 $header = substr($result, 0, $header_size);
 459                 $body = substr($result, $header_size);
 460                 curl_close($ch);
 461
 462                 // check if response is empty
 463                 if (empty($body)) {
 464                         throw new RouterException('empty response');
 465                 }
 466
 467                 // check if body is encrypted (hex instead of json)
 468                 if (ctype_xdigit($body)) {
 469                         $body = $this->decrypt($body);
 470                 }
 471
 472                 // fix invalid json
 473                 $body = preg_replace("/(\r\n)|(\r)/", "\n", $body);
 474                 $body = preg_replace('/\'/i', '"', $body);
 475                 $body = preg_replace("/\[\s+\]/i", '[ {} ]', $body);
 476                 $body = preg_replace("/},\s+]/", "}\n]", $body);
 477
 478                 // decode json
 479                 if (strpos($url, '.json') !== false) {
 480                         $body = json_decode($body, true);
 481                 }
 482
 483                 return array('header' => $this->parse_headers($header), 'body' => $body);
 484         }
 485
 486         /**
 487          * get the csrf_token
 488          *
 489          * @return      string
 490          */
 491         private function getToken () {
 492                 $this->checkLogin();
 493
 494                 $path = 'html/content/overview/index.html';
 495                 $fields = array();
 496                 $data = $this->sentRequest($path, $fields, true);
 497
 498                 $a = explode('csrf_token = "', $data['body']);
 499                 $a = explode('";', $a[1]);
 500
 501                 if (isset($a[0]) && !empty($a[0])) {
 502                         return $a[0];
 503                 }
 504                 else {
 505                         throw new RouterException('unable to get csrf_token');
 506                 }
 507         }
 508
 509         /**
 510          * calculate the derivedk
 511          *
 512          * @param       string  $password
 513          * @return      string
 514          */
 515         private function getDerviedk ($password) {
 516                 $derivedk = '';
 517
 518                 // calculate derivedk
 519                 if (!function_exists('hash_pbkdf2')) {
 520                         require_once 'CryptLib/CryptLib.php';
 521                         $pbkdf2 = new CryptLib\Key\Derivation\PBKDF\PBKDF2(array('hash' => 'sha1'));
 522                         $derivedk = bin2hex($pbkdf2->derive(hash('sha256', $password), substr($this->challenge, 0, 16), 1000, 32));
 523                         $derivedk = substr($derivedk, 0, 32);
 524                 }
 525                 else {
 526                         $derivedk = hash_pbkdf2('sha1', hash('sha256', $password), substr($this->challenge, 0, 16), 1000, 32);
 527                 }
 528
 529                 if (empty($derivedk)) {
 530                         throw new RouterException('unable to calculate derivedk');
 531                 }
 532
 533                 return $derivedk;
 534         }
 535
 536         /**
 537          * get cookie from header data
 538          *
 539          * @param       array   $data
 540          * @return      string
 541          */
 542         private function getCookie ($data) {
 543                 $cookie = '';
 544                 if (isset($data['header']['Set-Cookie']) && !empty($data['header']['Set-Cookie'])) {
 545                         preg_match('/^.*(SessionID_R3=[a-z0-9]*).*/i', $data['header']['Set-Cookie'], $match);
 546                         if (isset($match[1]) && !empty($match[1])) {
 547                                 $cookie = $match[1];
 548                         }
 549                 }
 550
 551                 if (empty($cookie)) {
 552                         throw new RouterException('unable to get the session cookie from the router');
 553                 }
 554
 555                 return $cookie;
 556         }
 557
 558         /**
 559          * parse the curl return header into an array
 560          *
 561          * @param       string  $response
 562          * @return      array
 563          */
 564         private function parse_headers($response) {
 565                 $headers = array();
 566                 $header_text = substr($response, 0, strpos($response, "\r\n\r\n"));
 567
 568                 $header_text = explode("\r\n", $header_text);
 569                 foreach ($header_text as $i => $line) {
 570                         if ($i === 0) {
 571                                 $headers['http_code'] = $line;
 572                         }
 573                         else {
 574                                 list ($key, $value) = explode(': ', $line);
 575                                 $headers[$key] = $value;
 576                         }
 577                 }
 578
 579                 return $headers;
 580         }
 581 }