lib/base32.php

   1 <?php
   2 //
   3 // +----------------------------------------------------------------------+
   4 // | Base32 Library                                                     |
   5 // +----------------------------------------------------------------------+
   6 // | Copyright (c) 2001 The PHP Group                                     |
   7 // +----------------------------------------------------------------------+
   8 // | This source file is dual-licensed. It is available under the terms   |
   9 // | of the GNU GPL v2.0 and under the terms of the PHP license version   |
  10 // | 2.02,  available at through the world-wide-web at                    |
  11 // | available at through the world-wide-web at                           |
  12 // | http://www.php.net/license/2_02.txt.                                 |
  13 // +----------------------------------------------------------------------+
  14 // |  Minor fixes and additional functions by Allan Hansen.               |
  15 // |  Moodle porting work by Martin Langhoff                              |
  16 // +----------------------------------------------------------------------+
  17 // | base32.php - based on race.php  - RACE encode and decode strings.    |
  18 // +----------------------------------------------------------------------+
  19 // | Authors: Allan Hansen  <All@nHansen.dk>                              |
  20 // |          Arjan Wekking <a.wekking@synantics.nl>                      |
  21 // |          Martin Langhoff <martin@catalyst.net.nz>                    |
  22 // +----------------------------------------------------------------------+
  23 //
  24
  25 /**
  26  * Base32 encode a binary string
  27  *
  28  * @param    $inString   Binary string to base32 encode
  29  *
  30  * @return   $outString  Base32 encoded $inString
  31  *
  32  * @access   private
  33  *
  34  */
  35
  36 function base32_encode ($inString)
  37 {
  38     $outString = "";
  39     $compBits = "";
  40     $BASE32_TABLE = array(
  41                           '00000' => 0x61,
  42                           '00001' => 0x62,
  43                           '00010' => 0x63,
  44                           '00011' => 0x64,
  45                           '00100' => 0x65,
  46                           '00101' => 0x66,
  47                           '00110' => 0x67,
  48                           '00111' => 0x68,
  49                           '01000' => 0x69,
  50                           '01001' => 0x6a,
  51                           '01010' => 0x6b,
  52                           '01011' => 0x6c,
  53                           '01100' => 0x6d,
  54                           '01101' => 0x6e,
  55                           '01110' => 0x6f,
  56                           '01111' => 0x70,
  57                           '10000' => 0x71,
  58                           '10001' => 0x72,
  59                           '10010' => 0x73,
  60                           '10011' => 0x74,
  61                           '10100' => 0x75,
  62                           '10101' => 0x76,
  63                           '10110' => 0x77,
  64                           '10111' => 0x78,
  65                           '11000' => 0x79,
  66                           '11001' => 0x7a,
  67                           '11010' => 0x32,
  68                           '11011' => 0x33,
  69                           '11100' => 0x34,
  70                           '11101' => 0x35,
  71                           '11110' => 0x36,
  72                           '11111' => 0x37,
  73                           );
  74
  75     /* Turn the compressed string into a string that represents the bits as 0 and 1. */
  76     for ($i = 0; $i < strlen($inString); $i++) {
  77         $compBits .= str_pad(decbin(ord(substr($inString,$i,1))), 8, '0', STR_PAD_LEFT);
  78     }
  79
  80     /* Pad the value with enough 0's to make it a multiple of 5 */
  81     if((strlen($compBits) % 5) != 0) {
  82         $compBits = str_pad($compBits, strlen($compBits)+(5-(strlen($compBits)%5)), '0', STR_PAD_RIGHT);
  83     }
  84
  85     /* Create an array by chunking it every 5 chars */
  86     $fiveBitsArray = split("\n",rtrim(chunk_split($compBits, 5, "\n")));
  87
  88     /* Look-up each chunk and add it to $outstring */
  89     foreach($fiveBitsArray as $fiveBitsString) {
  90         $outString .= chr($BASE32_TABLE[$fiveBitsString]);
  91     }
  92
  93     return $outString;
  94 }
  95
  96
  97
  98 /**
  99  * Base32 decode to a binary string
 100  *
 101  * @param    $inString   String to base32 decode
 102  *
 103  * @return   $outString  Base32 decoded $inString
 104  *
 105  * @access   private
 106  *
 107  */
 108
 109 function Base32_decode($inString) {
 110     /* declaration */
 111     $inputCheck = null;
 112     $deCompBits = null;
 113
 114     $BASE32_TABLE = array(
 115                           0x61 => '00000',
 116                           0x62 => '00001',
 117                           0x63 => '00010',
 118                           0x64 => '00011',
 119                           0x65 => '00100',
 120                           0x66 => '00101',
 121                           0x67 => '00110',
 122                           0x68 => '00111',
 123                           0x69 => '01000',
 124                           0x6a => '01001',
 125                           0x6b => '01010',
 126                           0x6c => '01011',
 127                           0x6d => '01100',
 128                           0x6e => '01101',
 129                           0x6f => '01110',
 130                           0x70 => '01111',
 131                           0x71 => '10000',
 132                           0x72 => '10001',
 133                           0x73 => '10010',
 134                           0x74 => '10011',
 135                           0x75 => '10100',
 136                           0x76 => '10101',
 137                           0x77 => '10110',
 138                           0x78 => '10111',
 139                           0x79 => '11000',
 140                           0x7a => '11001',
 141                           0x32 => '11010',
 142                           0x33 => '11011',
 143                           0x34 => '11100',
 144                           0x35 => '11101',
 145                           0x36 => '11110',
 146                           0x37 => '11111',
 147                           );
 148
 149     /* Step 1 */
 150     $inputCheck = strlen($inString) % 8;
 151     if(($inputCheck == 1)||($inputCheck == 3)||($inputCheck == 6)) {
 152         trigger_error('input to Base32Decode was a bad mod length: '.$inputCheck);
 153         return false;
 154         //return $this->raiseError('input to Base32Decode was a bad mod length: '.$inputCheck, null,
 155         // PEAR_ERROR_DIE, null, null, 'Net_RACE_Error', false );
 156     }
 157
 158     /* $deCompBits is a string that represents the bits as 0 and 1.*/
 159     for ($i = 0; $i < strlen($inString); $i++) {
 160         $inChar = ord(substr($inString,$i,1));
 161         if(isset($BASE32_TABLE[$inChar])) {
 162             $deCompBits .= $BASE32_TABLE[$inChar];
 163         } else {
 164             trigger_error('input to Base32Decode had a bad character: '.$inChar);
 165             return false;
 166             //return $this->raiseError('input to Base32Decode had a bad character: '.$inChar, null,
 167             //    PEAR_ERROR_DIE, null, null, 'Net_RACE_Error', false );
 168         }
 169     }
 170
 171     /* Step 5 */
 172     $padding = strlen($deCompBits) % 8;
 173     $paddingContent = substr($deCompBits, (strlen($deCompBits) - $padding));
 174     if(substr_count($paddingContent, '1')>0) {
 175         trigger_error('found non-zero padding in Base32Decode');
 176         return false;
 177         //return $this->raiseError('found non-zero padding in Base32Decode', null,
 178         //    PEAR_ERROR_DIE, null, null, 'Net_RACE_Error', false );
 179     }
 180
 181     /* Break the decompressed string into octets for returning */
 182     $deArr = array();
 183     for($i = 0; $i < (int)(strlen($deCompBits) / 8); $i++) {
 184         $deArr[$i] = chr(bindec(substr($deCompBits, $i*8, 8)));
 185     }
 186
 187     $outString = join('',$deArr);
 188
 189     return $outString;
 190 }
 191
 192 ?>