include/heimdal/deslib.php

   1 <?php
   2 /*
   3  * deslib.php,v 1.0 2006/08/25 21:00:00
   4  *
   5  * Copyright 2006 Alejandro Escanero Blanco <aescanero@chaosdimension.org>
   6  *
   7  * See the enclosed file COPYING for license information (GPL).  If you
   8  * did not receive this file, see http://www.fsf.org/copyleft/gpl.html.
   9  */
  10
  11
  12 define(DEBUG,false);
  13 define(HDB_KU_MKEY,0x484442);
  14
  15 class Des{
  16
  17         var $in;
  18         var $out;
  19         var $key;
  20         var $schedule1;
  21         var $schedule2;
  22         var $schedule3;
  23
  24         function add1($a,$b,$len){
  25                 $carry=0;
  26                 for ($i=$len-1;$i>=0;$i--){
  27                         $x=$a[$i]+$b[$i]+$carry;
  28                         if($x > 0xff) $carry=1;else $carry=0;
  29                         $a[$i] = $x & 0xff;
  30                 }
  31                 for($i = $len - 1; $carry!=0 && $i!=0; $i--){
  32                         $x = $a[$i] + $carry;
  33                         if($x > 0xff) $carry=1;else $carry=0;
  34                         $a[$i] = $x & 0xff;
  35                 }
  36                 return ($a);
  37         }
  38
  39         function _krb5_n_fold($str,$size){ //str=passREALMname
  40                 $len=strlen($str);
  41                 if($size>$len) $maxlen=2*$size;
  42                 else $maxlen=2*$len;
  43                 $l=0;
  44                 $key=array($size);
  45                 $tmp=array($maxlen);
  46                 $tmpi=0;
  47                 for ($i=0;$i<$maxlen;$i++) $tmp[$i]=0;
  48                 for ($i=0;$i<$size;$i++) $key[$i]=0;
  49                 $buf=$str;
  50                 do{
  51                         for ($i=0; $i<$len;$i++) $tmp[$tmpi+$l+$i]=ord(substr($buf,$i,1));
  52                         $l+=$len;
  53                         $buf=$this->srr13($buf,strlen($buf)*8);
  54                         while($l>=$size){
  55                                 $key=$this->add1($key,$tmp,$size);
  56                                 $l-=$size;
  57                                 if($l==0) break;
  58                                 for ($i=0;$i<$l;$i++) $tmp[$i]=$tmp[$i+$size];
  59                         }
  60                 }while ($l!=0);
  61 /*              $stringh="";
  62                 for($i=0;$i<$size;$i++) $stringh.=sprintf("%02x",$key[$i]);
  63                 print "EKEY: ".$stringh."\n";*/
  64                 $skey="";
  65                 for($i=0;$i<$size;$i++) $skey.=chr($key[$i]);
  66                 return($skey);
  67         }
  68
  69         function srr13($sbuf,$len){
  70
  71                 $buf=array(strlen($sbuf));
  72                 for($i=0;$i<strlen($sbuf);$i++) $buf[$i]=ord(substr($sbuf,$i,1));
  73                 $bytes = floor(($len + 7) / 8);
  74                 $tmp=array($bytes);
  75                 for($i=0;$i<$bytes;$i++) $tmp[$i]=0;
  76
  77                 $bits = 13 % $len;
  78                 $lbit = $len % 8;
  79                 for($i=0;$i<$bytes;$i++) $tmp[$i]=$buf[$i];
  80                 if($lbit!=0){
  81                         $tmp[$bytes - 1] &= (0xff << (8 - $lbit));
  82                         for($i = $lbit; $i < 8; $i += $len)
  83                         $tmp[$bytes - 1] |= $buf[0] >> $i;
  84                 }
  85                 for($i = 0; $i < $bytes; $i++) {
  86                 $bb = 8 * $i - $bits;
  87                 while($bb < 0)
  88                         $bb += $len;
  89                 $b1 = floor($bb / 8);
  90                 $s1 = $bb % 8;
  91
  92                 if($bb + 8 > $bytes * 8)
  93                         $s2 = ($len + 8 - $s1) % 8;
  94                 else
  95                         $s2 = 8 - $s1;
  96                 $b2 = ($b1 + 1) % $bytes;
  97                 $buf[$i] = (($tmp[$b1]) << $s1) | (($tmp[$b2]) >> $s2);
  98                 }
  99                 $slen=strlen($sbuf);
 100                 $sbuf="";
 101                 for($i=0;$i<$slen;$i++) $sbuf.=chr($buf[$i]);
 102                 return($sbuf);
 103
 104         }
 105
 106         function load($achar,$aint){            //Array=char(8), Array=int32(2)
 107                 $aint[0] =  $achar[0] << 24;
 108                 $aint[0] |= $achar[1] << 16;
 109                 $aint[0] |= $achar[2] << 8;
 110                 $aint[0] |= $achar[3] << 0;
 111                 $aint[1] =  $achar[4] << 24;
 112                 $aint[1] |= $achar[5] << 16;
 113                 $aint[1] |= $achar[6] << 8;
 114                 $aint[1] |= $achar[7] << 0;
 115         }
 116
 117         function store($aint,$achar){           //Array=int32(2),Array=char(8)
 118                 $achar[0] = ($aint[0] >> 24) & 0xff;
 119                 $achar[1] = ($aint[0] >> 16) & 0xff;
 120                 $achar[2] = ($aint[0] >>  8) & 0xff;
 121                 $achar[3] = ($aint[0] >>  0) & 0xff;
 122                 $achar[4] = ($aint[1] >> 24) & 0xff;
 123                 $achar[5] = ($aint[1] >> 16) & 0xff;
 124                 $achar[6] = ($aint[1] >>  8) & 0xff;
 125                 $achar[7] = ($aint[1] >>  0) & 0xff;
 126         }
 127
 128         function IP($v){                //v=Array int(2)
 129                 $work=0;
 130                 $work = (($v[0] >> 4) ^ $v[1]) & 0x0f0f0f0f;
 131                 $v[1] ^= $work;
 132                 $v[0] ^= ($work << 4);
 133                 $work = (($v[0] >> 16) ^ $v[1]) & 0x0000ffff;
 134                 $v[1] ^= $work;
 135                 $v[0] ^= ($work << 16);
 136                 $work = (($v[1] >> 2) ^ $v[0]) & 0x33333333;
 137                 $v[0] ^= $work;
 138                 $v[1] ^= ($work << 2);
 139                 $work = (($v[1] >> 8) ^ $v[0]) & 0x00ff00ff;
 140                 $v[0] ^= $work;
 141                 $v[1] ^= ($work << 8);
 142                 $v[1] = (($v[1] << 1) | (($v[1] >> 31) & 1)) & 0xffffffff;
 143                 $work = ($v[0] ^ $v[1]) & 0xaaaaaaaa;
 144                 $v[0] ^= $work;
 145                 $v[1] ^= $work;
 146                 $v[0] = (($v[0] << 1) | (($v[0] >> 31) & 1)) & 0xffffffff;
 147         }
 148
 149         function FP($v){                //v=Array int(2)
 150
 151                 $work=0;
 152
 153                 $v[0] = ($v[0] << 31) | (($v[0] >> 1) & 0x7fffffff);
 154                 $work = ($v[1] ^ $v[0]) & 0xaaaaaaaa;
 155                 $v[1] ^= $work;
 156                 $v[0] ^= $work;
 157                 $v[1] = ($v[1] << 31) | (($v[1] >> 1) & 0x7fffffff);
 158                 $work = (($v[1] >> 8) ^ $v[0]) & 0x00ff00ff;
 159                 $v[0] ^= $work;
 160                 $v[1] ^= ($work << 8);
 161                 $work = (($v[1] >> 2) ^ $v[0]) & 0x33333333;
 162                 $v[0] ^= $work;
 163                 $v[1] ^= ($work << 2);
 164                 $work = (($v[0] >> 16) ^ $v[1]) & 0x0000ffff;
 165                 $v[1] ^= $work;
 166                 $v[0] ^= ($work << 16);
 167                 $work = (($v[0] >> 4) ^ $v[1]) & 0x0f0f0f0f;
 168                 $v[1] ^= $work;
 169                 $v[0] ^= ($work << 4);
 170         }
 171
 172         function desx($aint,$ks,$comp){
 173                 $SP = array(
 174                         array(
 175                                 0x01010400, 0x00000000, 0x00010000, 0x01010404,
 176                                 0x01010004, 0x00010404, 0x00000004, 0x00010000,
 177                                 0x00000400, 0x01010400, 0x01010404, 0x00000400,
 178                                 0x01000404, 0x01010004, 0x01000000, 0x00000004,
 179                                 0x00000404, 0x01000400, 0x01000400, 0x00010400,
 180                                 0x00010400, 0x01010000, 0x01010000, 0x01000404,
 181                                 0x00010004, 0x01000004, 0x01000004, 0x00010004,
 182                                 0x00000000, 0x00000404, 0x00010404, 0x01000000,
 183                                 0x00010000, 0x01010404, 0x00000004, 0x01010000,
 184                                 0x01010400, 0x01000000, 0x01000000, 0x00000400,
 185                                 0x01010004, 0x00010000, 0x00010400, 0x01000004,
 186                                 0x00000400, 0x00000004, 0x01000404, 0x00010404,
 187                                 0x01010404, 0x00010004, 0x01010000, 0x01000404,
 188                                 0x01000004, 0x00000404, 0x00010404, 0x01010400,
 189                                 0x00000404, 0x01000400, 0x01000400, 0x00000000,
 190                                 0x00010004, 0x00010400, 0x00000000, 0x01010004
 191                         ),
 192                         array(
 193                                 0x80108020, 0x80008000, 0x00008000, 0x00108020,
 194                                 0x00100000, 0x00000020, 0x80100020, 0x80008020,
 195                                 0x80000020, 0x80108020, 0x80108000, 0x80000000,
 196                                 0x80008000, 0x00100000, 0x00000020, 0x80100020,
 197                                 0x00108000, 0x00100020, 0x80008020, 0x00000000,
 198                                 0x80000000, 0x00008000, 0x00108020, 0x80100000,
 199                                 0x00100020, 0x80000020, 0x00000000, 0x00108000,
 200                                 0x00008020, 0x80108000, 0x80100000, 0x00008020,
 201                                 0x00000000, 0x00108020, 0x80100020, 0x00100000,
 202                                 0x80008020, 0x80100000, 0x80108000, 0x00008000,
 203                                 0x80100000, 0x80008000, 0x00000020, 0x80108020,
 204                                 0x00108020, 0x00000020, 0x00008000, 0x80000000,
 205                                 0x00008020, 0x80108000, 0x00100000, 0x80000020,
 206                                 0x00100020, 0x80008020, 0x80000020, 0x00100020,
 207                                 0x00108000, 0x00000000, 0x80008000, 0x00008020,
 208                                 0x80000000, 0x80100020, 0x80108020, 0x00108000
 209                         ),
 210                         array(
 211                                 0x00000208, 0x08020200, 0x00000000, 0x08020008,
 212                                 0x08000200, 0x00000000, 0x00020208, 0x08000200,
 213                                 0x00020008, 0x08000008, 0x08000008, 0x00020000,
 214                                 0x08020208, 0x00020008, 0x08020000, 0x00000208,
 215                                 0x08000000, 0x00000008, 0x08020200, 0x00000200,
 216                                 0x00020200, 0x08020000, 0x08020008, 0x00020208,
 217                                 0x08000208, 0x00020200, 0x00020000, 0x08000208,
 218                                 0x00000008, 0x08020208, 0x00000200, 0x08000000,
 219                                 0x08020200, 0x08000000, 0x00020008, 0x00000208,
 220                                 0x00020000, 0x08020200, 0x08000200, 0x00000000,
 221                                 0x00000200, 0x00020008, 0x08020208, 0x08000200,
 222                                 0x08000008, 0x00000200, 0x00000000, 0x08020008,
 223                                 0x08000208, 0x00020000, 0x08000000, 0x08020208,
 224                                 0x00000008, 0x00020208, 0x00020200, 0x08000008,
 225                                 0x08020000, 0x08000208, 0x00000208, 0x08020000,
 226                                 0x00020208, 0x00000008, 0x08020008, 0x00020200
 227                         ),
 228                         array(
 229                                 0x00802001, 0x00002081, 0x00002081, 0x00000080,
 230                                 0x00802080, 0x00800081, 0x00800001, 0x00002001,
 231                                 0x00000000, 0x00802000, 0x00802000, 0x00802081,
 232                                 0x00000081, 0x00000000, 0x00800080, 0x00800001,
 233                                 0x00000001, 0x00002000, 0x00800000, 0x00802001,
 234                                 0x00000080, 0x00800000, 0x00002001, 0x00002080,
 235                                 0x00800081, 0x00000001, 0x00002080, 0x00800080,
 236                                 0x00002000, 0x00802080, 0x00802081, 0x00000081,
 237                                 0x00800080, 0x00800001, 0x00802000, 0x00802081,
 238                                 0x00000081, 0x00000000, 0x00000000, 0x00802000,
 239                                 0x00002080, 0x00800080, 0x00800081, 0x00000001,
 240                                 0x00802001, 0x00002081, 0x00002081, 0x00000080,
 241                                 0x00802081, 0x00000081, 0x00000001, 0x00002000,
 242                                 0x00800001, 0x00002001, 0x00802080, 0x00800081,
 243                                 0x00002001, 0x00002080, 0x00800000, 0x00802001,
 244                                 0x00000080, 0x00800000, 0x00002000, 0x00802080
 245                         ),
 246                         array(
 247                                 0x00000100, 0x02080100, 0x02080000, 0x42000100,
 248                                 0x00080000, 0x00000100, 0x40000000, 0x02080000,
 249                                 0x40080100, 0x00080000, 0x02000100, 0x40080100,
 250                                 0x42000100, 0x42080000, 0x00080100, 0x40000000,
 251                                 0x02000000, 0x40080000, 0x40080000, 0x00000000,
 252                                 0x40000100, 0x42080100, 0x42080100, 0x02000100,
 253                                 0x42080000, 0x40000100, 0x00000000, 0x42000000,
 254                                 0x02080100, 0x02000000, 0x42000000, 0x00080100,
 255                                 0x00080000, 0x42000100, 0x00000100, 0x02000000,
 256                                 0x40000000, 0x02080000, 0x42000100, 0x40080100,
 257                                 0x02000100, 0x40000000, 0x42080000, 0x02080100,
 258                                 0x40080100, 0x00000100, 0x02000000, 0x42080000,
 259                                 0x42080100, 0x00080100, 0x42000000, 0x42080100,
 260                                 0x02080000, 0x00000000, 0x40080000, 0x42000000,
 261                                 0x00080100, 0x02000100, 0x40000100, 0x00080000,
 262                                 0x00000000, 0x40080000, 0x02080100, 0x40000100
 263                         ),
 264                         array(
 265                                 0x20000010, 0x20400000, 0x00004000, 0x20404010,
 266                                 0x20400000, 0x00000010, 0x20404010, 0x00400000,
 267                                 0x20004000, 0x00404010, 0x00400000, 0x20000010,
 268                                 0x00400010, 0x20004000, 0x20000000, 0x00004010,
 269                                 0x00000000, 0x00400010, 0x20004010, 0x00004000,
 270                                 0x00404000, 0x20004010, 0x00000010, 0x20400010,
 271                                 0x20400010, 0x00000000, 0x00404010, 0x20404000,
 272                                 0x00004010, 0x00404000, 0x20404000, 0x20000000,
 273                                 0x20004000, 0x00000010, 0x20400010, 0x00404000,
 274                                 0x20404010, 0x00400000, 0x00004010, 0x20000010,
 275                                 0x00400000, 0x20004000, 0x20000000, 0x00004010,
 276                                 0x20000010, 0x20404010, 0x00404000, 0x20400000,
 277                                 0x00404010, 0x20404000, 0x00000000, 0x20400010,
 278                                 0x00000010, 0x00004000, 0x20400000, 0x00404010,
 279                                 0x00004000, 0x00400010, 0x20004010, 0x00000000,
 280                                 0x20404000, 0x20000000, 0x00400010, 0x20004010
 281                         ),
 282                         array(
 283                                 0x00200000, 0x04200002, 0x04000802, 0x00000000,
 284                                 0x00000800, 0x04000802, 0x00200802, 0x04200800,
 285                                 0x04200802, 0x00200000, 0x00000000, 0x04000002,
 286                                 0x00000002, 0x04000000, 0x04200002, 0x00000802,
 287                                 0x04000800, 0x00200802, 0x00200002, 0x04000800,
 288                                 0x04000002, 0x04200000, 0x04200800, 0x00200002,
 289                                 0x04200000, 0x00000800, 0x00000802, 0x04200802,
 290                                 0x00200800, 0x00000002, 0x04000000, 0x00200800,
 291                                 0x04000000, 0x00200800, 0x00200000, 0x04000802,
 292                                 0x04000802, 0x04200002, 0x04200002, 0x00000002,
 293                                 0x00200002, 0x04000000, 0x04000800, 0x00200000,
 294                                 0x04200800, 0x00000802, 0x00200802, 0x04200800,
 295                                 0x00000802, 0x04000002, 0x04200802, 0x04200000,
 296                                 0x00200800, 0x00000000, 0x00000002, 0x04200802,
 297                                 0x00000000, 0x00200802, 0x04200000, 0x00000800,
 298                                 0x04000002, 0x04000800, 0x00000800, 0x00200002
 299                         ),
 300                         array(
 301                                 0x10001040, 0x00001000, 0x00040000, 0x10041040,
 302                                 0x10000000, 0x10001040, 0x00000040, 0x10000000,
 303                                 0x00040040, 0x10040000, 0x10041040, 0x00041000,
 304                                 0x10041000, 0x00041040, 0x00001000, 0x00000040,
 305                                 0x10040000, 0x10000040, 0x10001000, 0x00001040,
 306                                 0x00041000, 0x00040040, 0x10040040, 0x10041000,
 307                                 0x00001040, 0x00000000, 0x00000000, 0x10040040,
 308                                 0x10000040, 0x10001000, 0x00041040, 0x00040000,
 309                                 0x00041040, 0x00040000, 0x10041000, 0x00001000,
 310                                 0x00000040, 0x10040040, 0x00001000, 0x00041040,
 311                                 0x10001000, 0x00000040, 0x10000040, 0x10040000,
 312                                 0x10040040, 0x10000000, 0x00040000, 0x10001040,
 313                                 0x00000000, 0x10041040, 0x00040040, 0x10000040,
 314                                 0x10040000, 0x10001000, 0x10001040, 0x00000000,
 315                                 0x10041040, 0x00041000, 0x00041000, 0x00001040,
 316                                 0x00001040, 0x00040040, 0x10000000, 0x10041000
 317                         )
 318                 );
 319
 320                 $left = $aint[0];
 321                 $right = $aint[1];
 322                 $fval=0;
 323                 $work=0;
 324
 325                 if ($comp) {
 326                         $keyix=0;
 327                         $keys = $ks[$keyix];
 328
 329                         for( $i = 0; $i < 8; $i++ ) {
 330                                 $work  = ($right << 28) | (($right >> 4) & 0x0fffffff);
 331                                 $work ^= $ks[$keyix];$keyix++;
 332
 333                                 $fval  = $SP[6][ $work     & 0x3f];
 334                                 $fval |= $SP[4][($work >>  8) & 0x3f];
 335                                 $fval |= $SP[2][($work >> 16) & 0x3f];
 336                                 $fval |= $SP[0][($work >> 24) & 0x3f];
 337
 338                                 $work  = $right ^ $ks[$keyix];$keyix++;
 339                                 $fval |= $SP[7][ $work     & 0x3f];
 340                                 $fval |= $SP[5][($work >>  8) & 0x3f];
 341                                 $fval |= $SP[3][($work >> 16) & 0x3f];
 342                                 $fval |= $SP[1][($work >> 24) & 0x3f];
 343
 344                                 $left ^= $fval;
 345                                 $work  = ($left << 28) | (($left >> 4) & 0x0fffffff);
 346                                 $work ^= $ks[$keyix];$keyix++;
 347                                 $fval  = $SP[6][ $work     & 0x3f];
 348                                 $fval |= $SP[4][($work >>  8) & 0x3f];
 349                                 $fval |= $SP[2][($work >> 16) & 0x3f];
 350                                 $fval |= $SP[0][($work >> 24) & 0x3f];
 351                                 $work  = $left ^ $ks[$keyix];$keyix++;
 352                                 $fval |= $SP[7][ $work     & 0x3f];
 353                                 $fval |= $SP[5][($work >>  8) & 0x3f];
 354                                 $fval |= $SP[3][($work >> 16) & 0x3f];
 355                                 $fval |= $SP[1][($work >> 24) & 0x3f];
 356                                 $right ^= $fval;
 357                         }
 358                 } else {
 359                         $keyix=30;
 360                         $keys = $ks[$keyix];
 361
 362                         for( $i = 0; $i < 8; $i++ ) {
 363                                 $work  = ($right << 28) | (($right >> 4) & 0x0fffffff);
 364                                 $work ^= $ks[$keyix];$keyix++;
 365                                 $fval  = $SP[6][ $work     & 0x3f];
 366                                 $fval |= $SP[4][($work >>  8) & 0x3f];
 367                                 $fval |= $SP[2][($work >> 16) & 0x3f];
 368                                 $fval |= $SP[0][($work >> 24) & 0x3f];
 369                                 $work  = $right ^ $ks[$keyix];$keyix++;
 370                                 $fval |= $SP[7][ $work     & 0x3f];
 371                                 $fval |= $SP[5][($work >>  8) & 0x3f];
 372                                 $fval |= $SP[3][($work >> 16) & 0x3f];
 373                                 $fval |= $SP[1][($work >> 24) & 0x3f];
 374                                 $left ^= $fval;
 375                                 $work  = ($left << 28) | (($left >> 4) & 0x0fffffff);
 376                                 $keyix -= 4;
 377                                 $work ^= $ks[$keyix];$keyix++;
 378                                 $fval  = $SP[6][ $work     & 0x3f];
 379                                 $fval |= $SP[4][($work >>  8) & 0x3f];
 380                                 $fval |= $SP[2][($work >> 16) & 0x3f];
 381                                 $fval |= $SP[0][($work >> 24) & 0x3f];
 382                                 $work  = $left ^ $ks[$keyix];$keyix++;
 383                                 $fval |= $SP[7][ $work     & 0x3f];
 384                                 $fval |= $SP[5][($work >>  8) & 0x3f];
 385                                 $fval |= $SP[3][($work >> 16) & 0x3f];
 386                                 $fval |= $SP[1][($work >> 24) & 0x3f];
 387                                 $right ^= $fval;
 388                                 $keyix -= 4;
 389                         }
 390                 }
 391                 $aint[0] = $right;
 392                 $aint[1] = $left;
 393         }
 394
 395
 396         function _des3_encrypt($aint,$ks1,$ks2,$ks3,$comp){
 397                 $this->IP(&$aint);
 398                 if($comp){
 399                         $this->desx(&$aint,&$ks1,true);
 400                         $this->desx(&$aint,&$ks2,false);
 401                         $this->desx(&$aint,&$ks3,true);
 402                 }else{
 403                         $this->desx(&$aint,&$ks1,false);
 404                         $this->desx(&$aint,&$ks2,true);
 405                         $this->desx(&$aint,&$ks3,false);
 406                 }
 407                 $this->FP(&$aint);
 408         }
 409
 410         function DES_ede3_cbc_encrypt($chain,$comp,$ks1,$ks2,$ks3,$ixlen){
 411
 412                 $n_fold_key=$ch_input;
 413                 $size=$ixlen;
 414
 415                 $ivec=array(8);
 416                 for ($i=0;$i<8;$i++) $ivec[$i]=chr(0);
 417                 $uiv=array(2);$uiv[0]=0;$uiv[1]=0;
 418                 $this->load($ivec,&$uiv);
 419 //              $stringh="";
 420 //                              for($i=0;$i<$ixlen;$i++) $stringh.=sprintf("%02x",$chain[$i]);
 421 //                              print "PREINPUT:  $ixlen ".$stringh."\n";
 422
 423                 $ix=0;
 424                 $input=array(8); for($i=0;$i<8;$i++) $input[$i]=$chain[$i+$ix];
 425
 426                 $output=&$input;
 427                 $u=array(2);$u[0]=0;$u[1]=0;
 428                 if($comp){
 429                         while($ixlen>=8){
 430                                 $this->load($input,&$u);
 431                                 $u[0] ^=$uiv[0];
 432                                 $u[1] ^=$uiv[1];
 433                                 $this->_des3_encrypt(&$u,$ks1,$ks2,$ks3, true);
 434                                 $uiv[0]=$u[0];$uiv[1]=$u[1];
 435                                 $this->store($u,&$output);
 436
 437                                 $ixlen-=8;
 438                                 for($i=0;$i<8;$i++) $chain[$i+$ix]=$output[$i];
 439                                 $ix+=8;
 440                                 for($i=0;$i<8;$i++) $input[$i]=$chain[$i+$ix];
 441                         }
 442                         if($ixlen>0){
 443                                 $tmp=array(8);
 444                                 for($i=0;$i<$ixlen;$i++) $input[$i]=$chain[$i+$ix];
 445                                 for($i=$ixlen;$i<8;$i++) $input[$i]=0;
 446                                 $this->load($input,&$u);
 447                                 $u[0] ^= $uiv[0]; $u[1] ^= $uiv[1];
 448                                 $this->_des3_encrypt(&$u,$ks1,$ks2,$ks3, true);
 449                                 $this->store($u, &$output);
 450                                 for($i=0;$i<8;$i++) $chain[$i+$ix]=$output[$i];
 451                         }
 452                 }else{
 453                 }
 454                 $this->store($uiv, &$iv);
 455                 $uiv[0] = 0; $u[0] = 0; $uiv[1] = 0; $u[1] = 0;
 456 //              $stringh="";
 457 //              for($i=0;$i<$size;$i++) $stringh.=sprintf("%02x",$chain[$i]);
 458 //              print "CHAIN:  $ixlen ".$stringh."\n";
 459                  return($chain);
 460         }
 461
 462         function get(){
 463                 $stringh="";
 464                 for($i=0;$i<strlen($this->out);$i++) $stringh.=sprintf("%02x",ord(substr($this->out,$i,1)));
 465                 return($stringh);
 466         }
 467
 468         function des_make_key_sched($key){
 469
 470                 $PC1_CL = array(
 471                         0x00000000, 0x00000010, 0x00001000, 0x00001010,
 472                         0x00100000, 0x00100010, 0x00101000, 0x00101010
 473                 );
 474
 475                 $PC1_DL = array(
 476                         0x00000000, 0x00100000, 0x00001000, 0x00101000,
 477                         0x00000010, 0x00100010, 0x00001010, 0x00101010,
 478                         0x00000001, 0x00100001, 0x00001001, 0x00101001,
 479                         0x00000011, 0x00100011, 0x00001011, 0x00101011
 480                 );
 481
 482                 $PC1_CR = array(
 483                         0x00000000, 0x00000001, 0x00000100, 0x00000101,
 484                         0x00010000, 0x00010001, 0x00010100, 0x00010101,
 485                         0x01000000, 0x01000001, 0x01000100, 0x01000101,
 486                         0x01010000, 0x01010001, 0x01010100, 0x01010101
 487                 );
 488
 489                 $PC1_DR = array(
 490                         0x00000000, 0x01000000, 0x00010000, 0x01010000,
 491                         0x00000100, 0x01000100, 0x00010100, 0x01010100
 492                 );
 493
 494                 $PC2_C = array(
 495                         array(
 496                         0x00000000, 0x00004000, 0x00040000, 0x00044000,
 497                         0x00000100, 0x00004100, 0x00040100, 0x00044100,
 498                         0x00020000, 0x00024000, 0x00060000, 0x00064000,
 499                         0x00020100, 0x00024100, 0x00060100, 0x00064100,
 500                         0x00000001, 0x00004001, 0x00040001, 0x00044001,
 501                         0x00000101, 0x00004101, 0x00040101, 0x00044101,
 502                         0x00020001, 0x00024001, 0x00060001, 0x00064001,
 503                         0x00020101, 0x00024101, 0x00060101, 0x00064101,
 504                         0x00080000, 0x00084000, 0x000c0000, 0x000c4000,
 505                         0x00080100, 0x00084100, 0x000c0100, 0x000c4100,
 506                         0x000a0000, 0x000a4000, 0x000e0000, 0x000e4000,
 507                         0x000a0100, 0x000a4100, 0x000e0100, 0x000e4100,
 508                         0x00080001, 0x00084001, 0x000c0001, 0x000c4001,
 509                         0x00080101, 0x00084101, 0x000c0101, 0x000c4101,
 510                         0x000a0001, 0x000a4001, 0x000e0001, 0x000e4001,
 511                         0x000a0101, 0x000a4101, 0x000e0101, 0x000e4101
 512                         ),
 513                         array(
 514                         0x00000000, 0x00000002, 0x00000200, 0x00000202,
 515                         0x00200000, 0x00200002, 0x00200200, 0x00200202,
 516                         0x00001000, 0x00001002, 0x00001200, 0x00001202,
 517                         0x00201000, 0x00201002, 0x00201200, 0x00201202,
 518                         0x00000040, 0x00000042, 0x00000240, 0x00000242,
 519                         0x00200040, 0x00200042, 0x00200240, 0x00200242,
 520                         0x00001040, 0x00001042, 0x00001240, 0x00001242,
 521                         0x00201040, 0x00201042, 0x00201240, 0x00201242,
 522                         0x00000010, 0x00000012, 0x00000210, 0x00000212,
 523                         0x00200010, 0x00200012, 0x00200210, 0x00200212,
 524                         0x00001010, 0x00001012, 0x00001210, 0x00001212,
 525                         0x00201010, 0x00201012, 0x00201210, 0x00201212,
 526                         0x00000050, 0x00000052, 0x00000250, 0x00000252,
 527                         0x00200050, 0x00200052, 0x00200250, 0x00200252,
 528                         0x00001050, 0x00001052, 0x00001250, 0x00001252,
 529                         0x00201050, 0x00201052, 0x00201250, 0x00201252
 530                         ),
 531                         array(
 532                         0x00000000, 0x00000004, 0x00000400, 0x00000404,
 533                         0x00400000, 0x00400004, 0x00400400, 0x00400404,
 534                         0x00000020, 0x00000024, 0x00000420, 0x00000424,
 535                         0x00400020, 0x00400024, 0x00400420, 0x00400424,
 536                         0x00008000, 0x00008004, 0x00008400, 0x00008404,
 537                         0x00408000, 0x00408004, 0x00408400, 0x00408404,
 538                         0x00008020, 0x00008024, 0x00008420, 0x00008424,
 539                         0x00408020, 0x00408024, 0x00408420, 0x00408424,
 540                         0x00800000, 0x00800004, 0x00800400, 0x00800404,
 541                         0x00c00000, 0x00c00004, 0x00c00400, 0x00c00404,
 542                         0x00800020, 0x00800024, 0x00800420, 0x00800424,
 543                         0x00c00020, 0x00c00024, 0x00c00420, 0x00c00424,
 544                         0x00808000, 0x00808004, 0x00808400, 0x00808404,
 545                         0x00c08000, 0x00c08004, 0x00c08400, 0x00c08404,
 546                         0x00808020, 0x00808024, 0x00808420, 0x00808424,
 547                         0x00c08020, 0x00c08024, 0x00c08420, 0x00c08424
 548                         ),
 549                         array(
 550                             0x00000000, 0x00010000, 0x00000008, 0x00010008,
 551                                 0x00000080, 0x00010080, 0x00000088, 0x00010088,
 552                                 0x00100000, 0x00110000, 0x00100008, 0x00110008,
 553                                 0x00100080, 0x00110080, 0x00100088, 0x00110088,
 554                                 0x00000800, 0x00010800, 0x00000808, 0x00010808,
 555                                 0x00000880, 0x00010880, 0x00000888, 0x00010888,
 556                                 0x00100800, 0x00110800, 0x00100808, 0x00110808,
 557                                 0x00100880, 0x00110880, 0x00100888, 0x00110888,
 558                                 0x00002000, 0x00012000, 0x00002008, 0x00012008,
 559                                 0x00002080, 0x00012080, 0x00002088, 0x00012088,
 560                                 0x00102000, 0x00112000, 0x00102008, 0x00112008,
 561                                 0x00102080, 0x00112080, 0x00102088, 0x00112088,
 562                                 0x00002800, 0x00012800, 0x00002808, 0x00012808,
 563                                 0x00002880, 0x00012880, 0x00002888, 0x00012888,
 564                                 0x00102800, 0x00112800, 0x00102808, 0x00112808,
 565                                 0x00102880, 0x00112880, 0x00102888, 0x00112888
 566                         )
 567                 );
 568
 569                 $PC2_D = array(
 570                         array(
 571                                 0x00000000, 0x00000080, 0x00002000, 0x00002080,
 572                                 0x00000001, 0x00000081, 0x00002001, 0x00002081,
 573                                 0x00200000, 0x00200080, 0x00202000, 0x00202080,
 574                                 0x00200001, 0x00200081, 0x00202001, 0x00202081,
 575                                 0x00020000, 0x00020080, 0x00022000, 0x00022080,
 576                                 0x00020001, 0x00020081, 0x00022001, 0x00022081,
 577                                 0x00220000, 0x00220080, 0x00222000, 0x00222080,
 578                                 0x00220001, 0x00220081, 0x00222001, 0x00222081,
 579                                 0x00000002, 0x00000082, 0x00002002, 0x00002082,
 580                                 0x00000003, 0x00000083, 0x00002003, 0x00002083,
 581                                 0x00200002, 0x00200082, 0x00202002, 0x00202082,
 582                                 0x00200003, 0x00200083, 0x00202003, 0x00202083,
 583                                 0x00020002, 0x00020082, 0x00022002, 0x00022082,
 584                                 0x00020003, 0x00020083, 0x00022003, 0x00022083,
 585                                 0x00220002, 0x00220082, 0x00222002, 0x00222082,
 586                                 0x00220003, 0x00220083, 0x00222003, 0x00222083
 587                         ),
 588                         array(
 589                                 0x00000000, 0x00000010, 0x00800000, 0x00800010,
 590                                 0x00010000, 0x00010010, 0x00810000, 0x00810010,
 591                                 0x00000200, 0x00000210, 0x00800200, 0x00800210,
 592                                 0x00010200, 0x00010210, 0x00810200, 0x00810210,
 593                                 0x00100000, 0x00100010, 0x00900000, 0x00900010,
 594                                 0x00110000, 0x00110010, 0x00910000, 0x00910010,
 595                                 0x00100200, 0x00100210, 0x00900200, 0x00900210,
 596                                 0x00110200, 0x00110210, 0x00910200, 0x00910210,
 597                                 0x00000004, 0x00000014, 0x00800004, 0x00800014,
 598                                 0x00010004, 0x00010014, 0x00810004, 0x00810014,
 599                                 0x00000204, 0x00000214, 0x00800204, 0x00800214,
 600                                 0x00010204, 0x00010214, 0x00810204, 0x00810214,
 601                                 0x00100004, 0x00100014, 0x00900004, 0x00900014,
 602                                 0x00110004, 0x00110014, 0x00910004, 0x00910014,
 603                                 0x00100204, 0x00100214, 0x00900204, 0x00900214,
 604                                 0x00110204, 0x00110214, 0x00910204, 0x00910214
 605                         ),
 606                         array(
 607                                 0x00000000, 0x00000400, 0x00001000, 0x00001400,
 608                                 0x00080000, 0x00080400, 0x00081000, 0x00081400,
 609                                 0x00000020, 0x00000420, 0x00001020, 0x00001420,
 610                                 0x00080020, 0x00080420, 0x00081020, 0x00081420,
 611                                 0x00004000, 0x00004400, 0x00005000, 0x00005400,
 612                                 0x00084000, 0x00084400, 0x00085000, 0x00085400,
 613                                 0x00004020, 0x00004420, 0x00005020, 0x00005420,
 614                                 0x00084020, 0x00084420, 0x00085020, 0x00085420,
 615                                 0x00000800, 0x00000c00, 0x00001800, 0x00001c00,
 616                                 0x00080800, 0x00080c00, 0x00081800, 0x00081c00,
 617                                 0x00000820, 0x00000c20, 0x00001820, 0x00001c20,
 618                                 0x00080820, 0x00080c20, 0x00081820, 0x00081c20,
 619                                 0x00004800, 0x00004c00, 0x00005800, 0x00005c00,
 620                                 0x00084800, 0x00084c00, 0x00085800, 0x00085c00,
 621                                 0x00004820, 0x00004c20, 0x00005820, 0x00005c20,
 622                                 0x00084820, 0x00084c20, 0x00085820, 0x00085c20
 623                         ),
 624                         array(
 625                                 0x00000000, 0x00000100, 0x00040000, 0x00040100,
 626                                 0x00000040, 0x00000140, 0x00040040, 0x00040140,
 627                                 0x00400000, 0x00400100, 0x00440000, 0x00440100,
 628                                 0x00400040, 0x00400140, 0x00440040, 0x00440140,
 629                                 0x00008000, 0x00008100, 0x00048000, 0x00048100,
 630                                 0x00008040, 0x00008140, 0x00048040, 0x00048140,
 631                                 0x00408000, 0x00408100, 0x00448000, 0x00448100,
 632                                 0x00408040, 0x00408140, 0x00448040, 0x00448140,
 633                                 0x00000008, 0x00000108, 0x00040008, 0x00040108,
 634                                 0x00000048, 0x00000148, 0x00040048, 0x00040148,
 635                                 0x00400008, 0x00400108, 0x00440008, 0x00440108,
 636                                 0x00400048, 0x00400148, 0x00440048, 0x00440148,
 637                                 0x00008008, 0x00008108, 0x00048008, 0x00048108,
 638                                 0x00008048, 0x00008148, 0x00048048, 0x00048148,
 639                                 0x00408008, 0x00408108, 0x00448008, 0x00448108,
 640                                 0x00408048, 0x00408148, 0x00448048, 0x00448148
 641                         )
 642                 );
 643
 644                         $tmp=0;
 645                         $kix=0;
 646
 647                         $tmp = ($key[$kix++]) <<24;
 648                         $tmp |=($key[$kix++]) <<16;
 649                         $tmp |=($key[$kix++]) <<8;
 650                         $tmp |=($key[$kix++]);
 651
 652
 653                         $c =  $PC1_CL[($tmp >> 29) & 0x7]
 654                         | ($PC1_CL[($tmp >> 21) & 0x7] << 1)
 655                         | ($PC1_CL[($tmp >> 13) & 0x7] << 2)
 656                         | ($PC1_CL[($tmp >>  5) & 0x7] << 3);
 657                         $d =  $PC1_DL[($tmp >> 25) & 0xf]
 658                         | ($PC1_DL[($tmp >> 17) & 0xf] << 1)
 659                         | ($PC1_DL[($tmp >>  9) & 0xf] << 2)
 660                         | ($PC1_DL[($tmp >>  1) & 0xf] << 3);
 661
 662
 663                         $tmp = ($key[$kix++]) <<24;
 664                         $tmp |=($key[$kix++]) <<16;
 665                         $tmp |=($key[$kix++]) <<8;
 666                         $tmp |=($key[$kix++]);
 667
 668                         $c |= $PC1_CR[($tmp >> 28) & 0xf]
 669                         | ($PC1_CR[($tmp >> 20) & 0xf] << 1)
 670                         | ($PC1_CR[($tmp >> 12) & 0xf] << 2)
 671                         | ($PC1_CR[($tmp >>  4) & 0xf] << 3);
 672                         $d |= $PC1_DR[($tmp >> 25) & 0x7]
 673                         | ($PC1_DR[($tmp >> 17) & 0x7] << 1)
 674                         | ($PC1_DR[($tmp >>  9) & 0x7] << 2)
 675                         | ($PC1_DR[($tmp >>  1) & 0x7] << 3);
 676
 677                         define(TWO_BIT_SHIFTS,0x7efc);
 678                         $two_bit_shifts = TWO_BIT_SHIFTS;
 679                         $lix=0;
 680                         for ($i = 16; $i > 0; $i--) {
 681
 682                                 if ($two_bit_shifts & 0x1) {
 683                                         $c = (($c << 2) & 0xffffffc) | ($c >> 26);
 684                                         $d = (($d << 2) & 0xffffffc) | ($d >> 26);
 685                                 } else {
 686                                         $c = (($c << 1) & 0xffffffe) | ($c >> 27);
 687                                         $d = (($d << 1) & 0xffffffe) | ($d >> 27);
 688                                 }
 689                                 $two_bit_shifts >>= 1;
 690                                 $ltmp = $PC2_C[0][(($c >> 22) & 0x3f)]
 691                                         | $PC2_C[1][(($c >> 15) & 0xf) | (($c >> 16) & 0x30)]
 692                                         | $PC2_C[2][(($c >>  8) & 0x3) | (($c >>  9) & 0x3c)]
 693                                         | $PC2_C[3][(($c >> 2 ) & 0x20) | (($c >> 1) & 0x18) | ($c & 0x7)];
 694                                 $rtmp = $PC2_D[0][(($d >> 22) & 0x3f)]
 695                                         | $PC2_D[1][(($d >> 14) & 0xf) | (($d >> 15) & 0x30)]
 696                                         | $PC2_D[2][(($d >>  7) & 0x3f)]
 697                                         | $PC2_D[3][(($d      ) & 0x3) | (($d >>  1) & 0x3c)];
 698
 699                                 $sch[$lix]  =  ($ltmp & 0x00fc0000) << 6;
 700                                 $sch[$lix] |=    ($ltmp & 0x00000fc0) << 10;
 701                                 $sch[$lix] |=    ($rtmp & 0x00fc0000) >> 10;
 702                                 $sch[$lix] |= ($rtmp & 0x00000fc0) >> 6;
 703                                 $lix++;
 704
 705                                 $sch[$lix]  =    ($ltmp & 0x0003f000) << 12;
 706                                 $sch[$lix] |=    ($ltmp & 0x0000003f) << 16;
 707                                 $sch[$lix] |=    ($rtmp & 0x0003f000) >> 4;
 708                                 $sch[$lix] |= ($rtmp & 0x0000003f);
 709                                 $lix++;
 710                         }
 711
 712                 return($sch);
 713         }
 714
 715         function DES_set_odd_parity($in){
 716
 717                 $odd_parity=array(
 718                         1,  1,  2,  2,  4,  4,  7,  7,  8,  8, 11, 11, 13, 13, 14, 14,
 719                         16, 16, 19, 19, 21, 21, 22, 22, 25, 25, 26, 26, 28, 28, 31, 31,
 720                         32, 32, 35, 35, 37, 37, 38, 38, 41, 41, 42, 42, 44, 44, 47, 47,
 721                         49, 49, 50, 50, 52, 52, 55, 55, 56, 56, 59, 59, 61, 61, 62, 62,
 722                         64, 64, 67, 67, 69, 69, 70, 70, 73, 73, 74, 74, 76, 76, 79, 79,
 723                         81, 81, 82, 82, 84, 84, 87, 87, 88, 88, 91, 91, 93, 93, 94, 94,
 724                         97, 97, 98, 98,100,100,103,103,104,104,107,107,109,109,110,110,
 725                         112,112,115,115,117,117,118,118,121,121,122,122,124,124,127,127,
 726                         128,128,131,131,133,133,134,134,137,137,138,138,140,140,143,143,
 727                         145,145,146,146,148,148,151,151,152,152,155,155,157,157,158,158,
 728                         161,161,162,162,164,164,167,167,168,168,171,171,173,173,174,174,
 729                         176,176,179,179,181,181,182,182,185,185,186,186,188,188,191,191,
 730                         193,193,194,194,196,196,199,199,200,200,203,203,205,205,206,206,
 731                         208,208,211,211,213,213,214,214,217,217,218,218,220,220,223,223,
 732                         224,224,227,227,229,229,230,230,233,233,234,234,236,236,239,239,
 733                         241,241,242,242,244,244,247,247,248,248,251,251,253,253,254,254,
 734                 );
 735
 736                         for($j=0;$j<8;$j++){
 737                                 $in[$j]=$odd_parity[$in[$j]];
 738                         }
 739                 return $in;
 740         }
 741
 742         function DES3_set_odd_parity($in){
 743
 744                 $odd_parity=array(
 745                         1,  1,  2,  2,  4,  4,  7,  7,  8,  8, 11, 11, 13, 13, 14, 14,
 746                         16, 16, 19, 19, 21, 21, 22, 22, 25, 25, 26, 26, 28, 28, 31, 31,
 747                         32, 32, 35, 35, 37, 37, 38, 38, 41, 41, 42, 42, 44, 44, 47, 47,
 748                         49, 49, 50, 50, 52, 52, 55, 55, 56, 56, 59, 59, 61, 61, 62, 62,
 749                         64, 64, 67, 67, 69, 69, 70, 70, 73, 73, 74, 74, 76, 76, 79, 79,
 750                         81, 81, 82, 82, 84, 84, 87, 87, 88, 88, 91, 91, 93, 93, 94, 94,
 751                         97, 97, 98, 98,100,100,103,103,104,104,107,107,109,109,110,110,
 752                         112,112,115,115,117,117,118,118,121,121,122,122,124,124,127,127,
 753                         128,128,131,131,133,133,134,134,137,137,138,138,140,140,143,143,
 754                         145,145,146,146,148,148,151,151,152,152,155,155,157,157,158,158,
 755                         161,161,162,162,164,164,167,167,168,168,171,171,173,173,174,174,
 756                         176,176,179,179,181,181,182,182,185,185,186,186,188,188,191,191,
 757                         193,193,194,194,196,196,199,199,200,200,203,203,205,205,206,206,
 758                         208,208,211,211,213,213,214,214,217,217,218,218,220,220,223,223,
 759                         224,224,227,227,229,229,230,230,233,233,234,234,236,236,239,239,
 760                         241,241,242,242,244,244,247,247,248,248,251,251,253,253,254,254,
 761                 );
 762                 for($i=0;$i<3;$i++){
 763                         for($j=0;$j<8;$j++){
 764                                 $in[($i*8)+$j]=$odd_parity[$in[($i*8)+$j]];
 765                         }
 766                 }
 767                 return $in;
 768         }
 769
 770         function des_is_weak_key($in){
 771
 772                 $weak_keys=array(
 773                 /* weak keys */
 774                 array(0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01),
 775                 array(0xFE,0xFE,0xFE,0xFE,0xFE,0xFE,0xFE,0xFE),
 776                 array(0x1F,0x1F,0x1F,0x1F,0x0E,0x0E,0x0E,0x0E),
 777                 array(0xE0,0xE0,0xE0,0xE0,0xF1,0xF1,0xF1,0xF1),
 778                 /* semi-weak keys */
 779                 array(0x01,0xFE,0x01,0xFE,0x01,0xFE,0x01,0xFE),
 780                 array(0xFE,0x01,0xFE,0x01,0xFE,0x01,0xFE,0x01),
 781                 array(0x1F,0xE0,0x1F,0xE0,0x0E,0xF1,0x0E,0xF1),
 782                 array(0xE0,0x1F,0xE0,0x1F,0xF1,0x0E,0xF1,0x0E),
 783                 array(0x01,0xE0,0x01,0xE0,0x01,0xF1,0x01,0xF1),
 784                 array(0xE0,0x01,0xE0,0x01,0xF1,0x01,0xF1,0x01),
 785                 array(0x1F,0xFE,0x1F,0xFE,0x0E,0xFE,0x0E,0xFE),
 786                 array(0xFE,0x1F,0xFE,0x1F,0xFE,0x0E,0xFE,0x0E),
 787                 array(0x01,0x1F,0x01,0x1F,0x01,0x0E,0x01,0x0E),
 788                 array(0x1F,0x01,0x1F,0x01,0x0E,0x01,0x0E,0x01),
 789                 array(0xE0,0xFE,0xE0,0xFE,0xF1,0xFE,0xF1,0xFE),
 790                 array(0xFE,0xE0,0xFE,0xE0,0xFE,0xF1,0xFE,0xF1));
 791
 792                 for ($i=0; $i<16; $i++){
 793                         if(count(array_diff($in,$weak_keys[$i]))==0) return(true);;
 794                 }
 795                 return(false);
 796         }
 797
 798         function Des3StringToKey($pass,$realm,$username){
 799                 $n_fold_key=$this->_krb5_n_fold($pass.$realm.$username,24);
 800 //              $stringh="";
 801 //              for($i=0;$i<strlen($n_fold_key);$i++) $stringh.=sprintf("%02x",ord(substr($n_fold_key,$i,1)));
 802 //              print "IKEY: ".$stringh."\n";
 803                 $chain=array(24); for($i=0;$i<24;$i++) $chain[$i]=ord(substr($n_fold_key,$i,1));
 804                 $ix=0;
 805                 $key1=array(8); for($i=0;$i<8;$i++) $key1[$i]=$chain[$i];
 806                 $key2=array(8); for($i=0;$i<8;$i++) $key2[$i]=$chain[$i+8];
 807                 $key3=array(8); for($i=0;$i<8;$i++) $key3[$i]=$chain[$i+16];
 808                 $ks1=$this->des_make_key_sched($key1);
 809                 $ks2=$this->des_make_key_sched($key2);
 810                 $ks3=$this->des_make_key_sched($key3);
 811
 812                 $this->out=$this->DES_ede3_cbc_encrypt($chain,true,$ks1,$ks2,$ks3,24);
 813                 $keys=array(3);
 814                 $this->out=$this->DES3_set_odd_parity($this->out);
 815                 for($i = 0;$i < 3; $i++){
 816                         $keys[$i]=array(8);
 817                         for($j = 0;$j < 8; $j++) $keys[$i][$j]=$this->out[($i*8)+$j];
 818                         if($this->DES_is_weak_key($keys[$i])){
 819                                 $keys[$i][7]^=0xf0;
 820                                 $this->out[($i*8)+7]=$keys[$i][7];
 821                         }
 822                 }
 823 //              $stringh="";
 824 //              for($i=0;$i<24;$i++) $stringh.=sprintf("%02x",$this->out[$i]);
 825 //              print "OUT KEY: ".$stringh."\n";
 826         }
 827
 828         function des_cbc_cksum($key,$data,$sch){
 829                 $pos=0;
 830                 $u=array(0,0);
 831                 $uiv=array(0,0);
 832                 $this->load($key,&$uiv);
 833                 $len=count($data);
 834                 $input=array(8);for($i=0;$i<8;$i++) $input[$i]=$data[$i];
 835                 $ix=0;
 836                         while ($len >=8) {
 837                                 $this->load($input,&$u);
 838                                 $u[0] ^= $uiv[0]; $u[1] ^= $uiv[1];
 839                                 $this->IP(&$u);
 840                                 $this->desx(&$u, $sch, true);
 841                                 $this->FP(&$u);
 842                                 $uiv[0] = $u[0]; $uiv[1] = $u[1];
 843                                 $len -= 8;
 844                                 for($i=0;$i<8;$i++) $data[$i+$ix]=$input[$i];
 845                                 $ix+=8;$input=array(8);for($i=0;$i<8;$i++) $input[$i]=$data[$i+$ix];
 846                         }
 847                         if($len>0){
 848                                 $input=array(8);
 849                                 for($i=0;$i<$len;$i++) $input[$i]=$data[$i+$ix];
 850                                 for($i=$len;$i<8;$i++) $input[$i]=0;
 851                                 $this->load($input,&$u);
 852                                 $u[0] ^= $uiv[0]; $u[1] ^= $uiv[1];
 853                                 $this->IP(&$u);
 854                                 $this->desx(&$u, $sch, true);
 855                                 $this->FP(&$u);
 856                         }
 857                 $this->store($u,&$key);
 858                 return($key);
 859         }
 860
 861         function DesStringToKey($pass,$realm,$username){
 862                 $data=$pass.$realm.$username;
 863                 $len=strlen($data);
 864                 $reverse = 0;
 865                 $ix=0;
 866                 $key=array(8); for($i=0;$i<8;$i++) $key[$i]=0;
 867                 $tmp=array($len);for($i=0;$i<$len;$i++) $tmp[$i]=ord(substr($data,$i,1));
 868                 $swap=array( 0x0, 0x8, 0x4, 0xc, 0x2, 0xa, 0x6, 0xe,
 869                              0x1, 0x9, 0x5, 0xd, 0x3, 0xb, 0x7, 0xf );
 870                 for ($i = 0; $i < $len; $i++) {
 871                         if ($reverse==0){
 872                                 $key[$ix]^=($tmp[$i] << 1);
 873                                 $ix++;
 874                         }else{
 875                                 $ix--;
 876                                 $key[$ix]^=($swap[$tmp[$i] & 0xf] <<4)| $swap[(($tmp[$i] & 0xf0) >> 4) &0x0f];
 877                         }
 878                         if(($i % 8) == 7){
 879                                 if($reverse==0) $reverse=1;else $reverse=0;
 880                         }
 881                 }
 882                 $key=$this->DES_set_odd_parity($key);
 883                 if($this->DES_is_weak_key($key)){
 884                         $key[7]^=0xf0;
 885                 }
 886                 $sch=$this->des_make_key_sched($key);
 887                 $key=$this->des_cbc_cksum($key,$tmp,$sch);
 888                 $key=$this->DES_set_odd_parity($key);
 889                 if($this->DES_is_weak_key($key)){
 890                         $key[7]^=0xf0;
 891                 }
 892                 $this->out=$key;
 893         }
 894
 895         function DES3_random_to_key($data){
 896                 $key=array(24); for ($i=0;$i<24;$i++) $key[$i]=0;
 897
 898                 for($i=0;$i<3;++$i){
 899                         for ($j=0;$j<7;++$j){
 900                                 $key[(8*$i)+$j]=$data[7*$i+$j];
 901                         }
 902
 903                         $foo = 0;
 904                         for ($j = 6; $j >= 0; --$j) {
 905                                 $foo |= $data[7 *$i +$j] & 1;
 906                                 $foo <<= 1;
 907                         }
 908                         $key[(8*$i)+7]=$foo;
 909                 }
 910                 $keys=array(3);
 911                 $out=$key;
 912                 $out=$this->DES3_set_odd_parity($out);
 913                 for($i = 0;$i < 3; $i++){
 914                         $keys[$i]=array(8);
 915                         for($j = 0;$j < 8; $j++) $keys[$i][$j]=$out[($i*8)+$j];
 916                         if($this->DES_is_weak_key($keys[$i])){
 917                                 $keys[$i][7]^=0xf0;
 918                                 $out[($i*8)+7]=$keys[$i][7];
 919                         }
 920                 }
 921                 return($out);
 922         }
 923
 924         function Des3StringToKeyDerived($pass,$realm,$username){
 925                 $n_fold_key=$this->_krb5_n_fold($pass.$realm.$username,21);
 926 //              $stringh="";
 927 //              for($i=0;$i<strlen($n_fold_key);$i++) $stringh.=sprintf("%02x",ord(substr($n_fold_key,$i,1)));
 928 //              print "IKEY: ".$stringh."\n";
 929                 $data=array(21); for($i=0;$i<strlen($n_fold_key);$i++) $data[$i]=ord(substr($n_fold_key,$i,1));
 930                 $this->out=$this->DES3_random_to_key($data);
 931                 $keys=array(3);
 932                 for($i = 0;$i < 3; $i++){
 933                         $keys[$i]=array(8);
 934                         for($j = 0;$j < 8; $j++) $keys[$i][$j]=$this->out[($i*8)+$j];
 935                 }
 936
 937                 $ks1=$this->des_make_key_sched($keys[0]);
 938                 $ks2=$this->des_make_key_sched($keys[1]);
 939                 $ks3=$this->des_make_key_sched($keys[2]);
 940
 941                 $derivekey=$this->derive_key("kerberos",$this->out,$ks1,$ks2,$ks3,24);
 942                 $this->out=$this->DES3_random_to_key($derivekey);
 943
 944         }
 945
 946
 947         function derive_key($constant, $data,$ks1,$ks2,$ks3,$ixlen){
 948                 $len=strlen($constant);
 949                 $n_fold_key=$this->_krb5_n_fold($constant,$len);
 950                 $lk=array(8); for($i=0;$i<8;$i++) $lk[$i]=ord(substr($n_fold_key,$i,1));
 951                 $keys=array(3);
 952                 $keys[0]=$lk;
 953
 954                 $keys[0]=$this->DES_ede3_cbc_encrypt($keys[0],true,$ks1,$ks2,$ks3,8);
 955                 $keys[1]=$this->DES_ede3_cbc_encrypt($keys[0],true,$ks1,$ks2,$ks3,8);
 956                 $keys[2]=$this->DES_ede3_cbc_encrypt($keys[1],true,$ks1,$ks2,$ks3,8);
 957
 958                 $out=array(24);
 959                 for ($i=0;$i<3;$i++){
 960                         for ($j=0;$j<8;$j++)
 961                                 $out[($i*8)+$j]=$keys[$i][$j];
 962                 }
 963                 return($out);
 964         }
 965
 966         function derive_key_integrity($masterkey){
 967                 $keys=array(3);
 968                 for($i = 0;$i < 3; $i++){
 969                         $keys[$i]=array(8);
 970                         for($j = 0;$j < 8; $j++) $keys[$i][$j]=$masterkey[($i*8)+$j];
 971                 }
 972
 973                 $ks1=$this->des_make_key_sched($keys[0]);
 974                 $ks2=$this->des_make_key_sched($keys[1]);
 975                 $ks3=$this->des_make_key_sched($keys[2]);
 976
 977                 $usage=$this->getIntegrityUsage();
 978
 979                 $n_fold_key=$this->_krb5_n_fold($usage,8);
 980                 $lk=array(8); for($i=0;$i<8;$i++) $lk[$i]=ord(substr($n_fold_key,$i,1));
 981
 982                 $keys=array(3);
 983                 $keys[0]=$lk;
 984
 985                 $keys[0]=$this->DES_ede3_cbc_encrypt($keys[0],true,$ks1,$ks2,$ks3,8);
 986                 $keys[1]=$this->DES_ede3_cbc_encrypt($keys[0],true,$ks1,$ks2,$ks3,8);
 987                 $keys[2]=$this->DES_ede3_cbc_encrypt($keys[1],true,$ks1,$ks2,$ks3,8);
 988
 989                 $out=array(24);
 990                 for ($i=0;$i<3;$i++){
 991                         for ($j=0;$j<8;$j++)
 992                                 $out[($i*8)+$j]=$keys[$i][$j];
 993                 }
 994
 995                 $out=$this->DES3_random_to_key($out);
 996 /*              $stringh="";
 997                 for($i=0;$i<24;$i++) $stringh.=sprintf("%02x",$out[$i]);
 998                 print "DKEY: ".$stringh."\n";*/
 999                 return($out);
1000         }
1001
1002         function derive_key_encrypt($masterkey){
1003                 $keys=array(3);
1004                 for($i = 0;$i < 3; $i++){
1005                         $keys[$i]=array(8);
1006                         for($j = 0;$j < 8; $j++) $keys[$i][$j]=$masterkey[($i*8)+$j];
1007                 }
1008
1009                 $ks1=$this->des_make_key_sched($keys[0]);
1010                 $ks2=$this->des_make_key_sched($keys[1]);
1011                 $ks3=$this->des_make_key_sched($keys[2]);
1012
1013                 $usage=$this->getEncryptionUsage();
1014
1015                 $n_fold_key=$this->_krb5_n_fold($usage,8);
1016                 $lk=array(8); for($i=0;$i<8;$i++) $lk[$i]=ord(substr($n_fold_key,$i,1));
1017
1018                 $keys=array(3);
1019                 $keys[0]=$lk;
1020
1021                 $keys[0]=$this->DES_ede3_cbc_encrypt($keys[0],true,$ks1,$ks2,$ks3,8);
1022                 $keys[1]=$this->DES_ede3_cbc_encrypt($keys[0],true,$ks1,$ks2,$ks3,8);
1023                 $keys[2]=$this->DES_ede3_cbc_encrypt($keys[1],true,$ks1,$ks2,$ks3,8);
1024
1025                 $out=array(24);
1026                 for ($i=0;$i<3;$i++){
1027                         for ($j=0;$j<8;$j++)
1028                                 $out[($i*8)+$j]=$keys[$i][$j];
1029                 }
1030
1031                 $out=$this->DES3_random_to_key($out);
1032 /*              $stringh="";
1033                 for($i=0;$i<24;$i++) $stringh.=sprintf("%02x",$out[$i]);
1034                 print "DKEY: ".$stringh."\n";*/
1035                 return($out);
1036         }
1037
1038         function krb5_generate_random_block($len=8){
1039                 $key=$this->DES_new_random_key();
1040                 $sched=$this->des_make_key_sched($key);
1041                 $counter=$this->DES_new_random_key();
1042                 $out=$counter;
1043                 $this->DES_ecb_encrypt(&$out,$sched);
1044         }
1045
1046         function DES_new_random_key($len=8){
1047                 $seed=array($len);
1048                 //inicializacion!!!!
1049                 do{
1050                         $seed=$this->DES_generate_random_block($len);
1051                         $this->DES_set_odd_parity(&$seed);
1052                 }while ($this->DES_is_weak_key($seed));
1053                 $sequence_seed=$this->des_make_key_sched($seed);
1054                 //DES_ecb_encrypt!!!!
1055                 do{
1056                         $this->DES_ecb_encrypt(&$seed,$sequence_seed);
1057                         $this->DES_set_odd_parity(&$seed);
1058                 }while ($this->DES_is_weak_key($seed));
1059                 return($seed);
1060         }
1061
1062         function DES_generate_random_block($len=8){
1063                 $res=array($len);
1064                 for ($i=0;$i<$len;$i++){
1065                         $res[$i]=mt_rand(0,255);
1066                 }
1067                 return($res);
1068         }
1069
1070         function DES_ecb_encrypt($key,$sch){
1071                 $u=array(0,0);
1072                 $this->load($key,&$u);
1073                 //DES_encrypt
1074                 $this->IP(&$u);
1075                 $this->desx(&$u, $sch, true);
1076                 $this->FP(&$u);
1077                 $this->store($u,&$key);
1078                 return($key);
1079         }
1080
1081         function ENCRYPTION_USAGE($u){
1082                 return(($u << 8) | 0xAA);
1083         }
1084
1085         function INTEGRITY_USAGE($u){
1086                 return(($u << 8) | 0x55);
1087         }
1088
1089         function getIntegrityUsage(){
1090                 $usage=$this->INTEGRITY_USAGE(HDB_KU_MKEY);
1091                 $ausage=array(5);
1092                 $ausage[4] = $usage & 0xff;
1093                 $usage= $usage >> 8;
1094                 $ausage[3] = $usage & 0xff;
1095                 $usage= $usage >> 8;
1096                 $ausage[2] = $usage & 0xff;
1097                 $usage= $usage >> 8;
1098                 $ausage[1] = $usage & 0xff;
1099                 $usage= $usage >> 8;
1100                 $ausage[0] = $usage & 0xff;
1101                 $str="";
1102                 for ($i=0;$i<5;$i++){
1103                         $str.=chr($ausage[$i]);
1104                 }
1105                 return($str);
1106         }
1107
1108         function getEncryptionUsage(){
1109                 $usage=$this->ENCRYPTION_USAGE(HDB_KU_MKEY);
1110                 $ausage=array(5);
1111                 $ausage[4] = $usage & 0xff;
1112                 $usage= $usage >> 8;
1113                 $ausage[3] = $usage & 0xff;
1114                 $usage= $usage >> 8;
1115                 $ausage[2] = $usage & 0xff;
1116                 $usage= $usage >> 8;
1117                 $ausage[1] = $usage & 0xff;
1118                 $usage= $usage >> 8;
1119                 $ausage[0] = $usage & 0xff;
1120                 $str="";
1121                 for ($i=0;$i<5;$i++){
1122                         $str.=chr($ausage[$i]);
1123                 }
1124                 return($str);
1125         }
1126
1127
1128 };
1129
1130
1131
1132 ?>