library/asn1.php

   1 <?php
   2
   3 // ASN.1 parsing library
   4 // Attribution: http://www.krisbailey.com
   5 // license: unknown
   6 // modified: Mike Macgrivin mike@macgirvin.com 6-oct-2010 to support Salmon auto-discovery
   7 // from openssl public keys
   8
   9
  10 class ASN_BASE {
  11         public $asnData = null;
  12         private $cursor = 0;
  13         private $parent = null;
  14
  15         public static $ASN_MARKERS = array(
  16                 'ASN_UNIVERSAL'         => 0x00,
  17                 'ASN_APPLICATION'       => 0x40,
  18                 'ASN_CONTEXT'           => 0x80,
  19                 'ASN_PRIVATE'           => 0xC0,
  20
  21                 'ASN_PRIMITIVE'         => 0x00,
  22                 'ASN_CONSTRUCTOR'       => 0x20,
  23
  24                 'ASN_LONG_LEN'          => 0x80,
  25                 'ASN_EXTENSION_ID'      => 0x1F,
  26                 'ASN_BIT'               => 0x80,
  27         );
  28
  29         public static $ASN_TYPES = array(
  30                 1       => 'ASN_BOOLEAN',
  31                 2       => 'ASN_INTEGER',
  32                 3       => 'ASN_BIT_STR',
  33                 4       => 'ASN_OCTET_STR',
  34                 5       => 'ASN_NULL',
  35                 6       => 'ASN_OBJECT_ID',
  36                 9       => 'ASN_REAL',
  37                 10      => 'ASN_ENUMERATED',
  38                 13      => 'ASN_RELATIVE_OID',
  39                 48      => 'ASN_SEQUENCE',
  40                 49      => 'ASN_SET',
  41                 19      => 'ASN_PRINT_STR',
  42                 22      => 'ASN_IA5_STR',
  43                 23      => 'ASN_UTC_TIME',
  44                 24      => 'ASN_GENERAL_TIME',
  45         );
  46
  47         function __construct($v = false)
  48         {
  49                 if (false !== $v) {
  50                         $this->asnData = $v;
  51                         if (is_array($this->asnData)) {
  52                                 foreach ($this->asnData as $key => $value) {
  53                                         if (is_object($value)) {
  54                                                 $this->asnData[$key]->setParent($this);
  55                                         }
  56                                 }
  57                         } else {
  58                                 if (is_object($this->asnData)) {
  59                                         $this->asnData->setParent($this);
  60                                 }
  61                         }
  62                 }
  63         }
  64
  65         public function setParent($parent)
  66         {
  67                 if (false !== $parent) {
  68                         $this->parent = $parent;
  69                 }
  70         }
  71
  72         /**
  73          * This function will take the markers and types arrays and
  74          * dynamically generate classes that extend this class for each one,
  75          * and also define constants for them.
  76          */
  77         public static function generateSubclasses()
  78         {
  79                 define('ASN_BASE', 0);
  80                 foreach (self::$ASN_MARKERS as $name => $bit)
  81                         self::makeSubclass($name, $bit);
  82                 foreach (self::$ASN_TYPES as $bit => $name)
  83                         self::makeSubclass($name, $bit);
  84         }
  85
  86         /**
  87          * Helper function for generateSubclasses()
  88          */
  89         public static function makeSubclass($name, $bit)
  90         {
  91                 define($name, $bit);
  92                 eval("class ".$name." extends ASN_BASE {}");
  93         }
  94
  95         /**
  96          * This function reset's the internal cursor used for value iteration.
  97          */
  98         public function reset()
  99         {
 100                 $this->cursor = 0;
 101         }
 102
 103         /**
 104          * This function catches calls to get the value for the type, typeName, value, values, and data
 105          * from the object.  For type calls we just return the class name or the value of the constant that
 106          * is named the same as the class.
 107          */
 108         public function __get($name)
 109         {
 110                 if ('type' == $name) {
 111                         // int flag of the data type
 112                         return constant(get_class($this));
 113                 } elseif ('typeName' == $name) {
 114                         // name of the data type
 115                         return get_class($this);
 116                 } elseif ('value' == $name) {
 117                         // will always return one value and can be iterated over with:
 118                         // while ($v = $obj->value) { ...
 119                         // because $this->asnData["invalid key"] will return false
 120                         return is_array($this->asnData) ? $this->asnData[$this->cursor++] : $this->asnData;
 121                 } elseif ('values' == $name) {
 122                         // will always return an array
 123                         return is_array($this->asnData) ? $this->asnData : array($this->asnData);
 124                 } elseif ('data' == $name) {
 125                         // will always return the raw data
 126                         return $this->asnData;
 127                 }
 128         }
 129
 130         /**
 131          * Parse an ASN.1 binary string.
 132          *
 133          * This function takes a binary ASN.1 string and parses it into it's respective
 134          * pieces and returns it.  It can optionally stop at any depth.
 135          *
 136          * @param       string  $string         The binary ASN.1 String
 137          * @param       int     $level          The current parsing depth level
 138          * @param       int     $maxLevel       The max parsing depth level
 139          * @return      ASN_BASE        The array representation of the ASN.1 data contained in $string
 140          */
 141         public static function parseASNString($string=false, $level=1, $maxLevels=false){
 142                 if (!class_exists('ASN_UNIVERSAL'))
 143                         self::generateSubclasses();
 144                 if ($level>$maxLevels && $maxLevels)
 145                         return array(new ASN_BASE($string));
 146                 $parsed = array();
 147                 $endLength = strlen($string);
 148                 $bigLength = $length = $type = $dtype = $p = 0;
 149                 while ($p<$endLength){
 150                         $type = ord($string[$p++]);
 151                         $dtype = ($type & 192) >> 6;
 152                         if ($type==0){ // if we are type 0, just continue
 153                         } else {
 154                                 $length = ord($string[$p++]);
 155                                 if (($length & ASN_LONG_LEN)==ASN_LONG_LEN){
 156                                         $tempLength = 0;
 157                                         for ($x=0; $x<($length & (ASN_LONG_LEN-1)); $x++){
 158                                                 $tempLength = ord($string[$p++]) + ($tempLength * 256);
 159                                         }
 160                                         $length = $tempLength;
 161                                 }
 162                                 $data = substr($string, $p, $length);
 163                                 $parsed[] = self::parseASNData($type, $data, $level, $maxLevels);
 164                                 $p = $p + $length;
 165                         }
 166                 }
 167                 return $parsed;
 168         }
 169
 170         /**
 171          * Parse an ASN.1 field value.
 172          *
 173          * This function takes a binary ASN.1 value and parses it according to it's specified type
 174          *
 175          * @param       int     $type           The type of data being provided
 176          * @param       string  $data           The raw binary data string
 177          * @param       int     $level          The current parsing depth
 178          * @param       int     $maxLevels      The max parsing depth
 179          * @return      mixed   The data that was parsed from the raw binary data string
 180          */
 181         public static function parseASNData($type, $data, $level, $maxLevels){
 182                 $type = $type%50; // strip out context
 183                 switch ($type){
 184                         default:
 185                                 return new ASN_BASE($data);
 186                         case ASN_BOOLEAN:
 187                                 return new ASN_BOOLEAN((bool)$data);
 188                         case ASN_INTEGER:
 189                                 return new ASN_INTEGER(strtr(base64_encode($data),'+/','-_'));
 190                         case ASN_BIT_STR:
 191                                 return new ASN_BIT_STR(self::parseASNString($data, $level+1, $maxLevels));
 192                         case ASN_OCTET_STR:
 193                                 return new ASN_OCTET_STR($data);
 194                         case ASN_NULL:
 195                                 return new ASN_NULL(null);
 196                         case ASN_REAL:
 197                                 return new ASN_REAL($data);
 198                         case ASN_ENUMERATED:
 199                                 return new ASN_ENUMERATED(self::parseASNString($data, $level+1, $maxLevels));
 200                         case ASN_RELATIVE_OID: // I don't really know how this works and don't have an example :-)
 201                                                 // so, lets just return it ...
 202                                 return new ASN_RELATIVE_OID($data);
 203                         case ASN_SEQUENCE:
 204                                 return new ASN_SEQUENCE(self::parseASNString($data, $level+1, $maxLevels));
 205                         case ASN_SET:
 206                                 return new ASN_SET(self::parseASNString($data, $level+1, $maxLevels));
 207                         case ASN_PRINT_STR:
 208                                 return new ASN_PRINT_STR($data);
 209                         case ASN_IA5_STR:
 210                                 return new ASN_IA5_STR($data);
 211                         case ASN_UTC_TIME:
 212                                 return new ASN_UTC_TIME($data);
 213                         case ASN_GENERAL_TIME:
 214                                 return new ASN_GENERAL_TIME($data);
 215                         case ASN_OBJECT_ID:
 216                                 return new ASN_OBJECT_ID(self::parseOID($data));
 217                 }
 218         }
 219
 220         /**
 221          * Parse an ASN.1 OID value.
 222          *
 223          * This takes the raw binary string that represents an OID value and parses it into its
 224          * dot notation form.  example - 1.2.840.113549.1.1.5
 225          * look up OID's here: http://www.oid-info.com/
 226          * (the multi-byte OID section can be done in a more efficient way, I will fix it later)
 227          *
 228          * @param       string  $data           The raw binary data string
 229          * @return      string  The OID contained in $data
 230          */
 231         public static function parseOID($string){
 232                 $ret = floor(ord($string[0])/40).".";
 233                 $ret .= (ord($string[0]) % 40);
 234                 $build = array();
 235                 $cs = 0;
 236
 237                 for ($i=1; $i<strlen($string); $i++){
 238                         $v = ord($string[$i]);
 239                         if ($v>127){
 240                                 $build[] = ord($string[$i])-ASN_BIT;
 241                         } elseif ($build){
 242                                 // do the build here for multibyte values
 243                                 $build[] = ord($string[$i])-ASN_BIT;
 244                                 // you know, it seems there should be a better way to do this...
 245                                 $build = array_reverse($build);
 246                                 $num = 0;
 247                                 for ($x=0; $x<count($build); $x++){
 248                                         $mult = $x==0?1:pow(256, $x);
 249                                         if ($x+1==count($build)){
 250                                                 $value = ((($build[$x] & (ASN_BIT-1)) >> $x)) * $mult;
 251                                         } else {
 252                                                 $value = ((($build[$x] & (ASN_BIT-1)) >> $x) ^ ($build[$x+1] << (7 - $x) & 255)) * $mult;
 253                                         }
 254                                         $num += $value;
 255                                 }
 256                                 $ret .= ".".$num;
 257                                 $build = array(); // start over
 258                         } else {
 259                                 $ret .= ".".$v;
 260                                 $build = array();
 261                         }
 262                 }
 263                 return $ret;
 264         }
 265
 266         public static function printASN($x, $indent=''){
 267                 if (is_object($x)) {
 268                         echo $indent.$x->typeName."\n";
 269                         if (ASN_NULL == $x->type) return;
 270                         if (is_array($x->data)) {
 271                                 while ($d = $x->value) {
 272                                         echo self::printASN($d, $indent.'.  ');
 273                                 }
 274                                 $x->reset();
 275                         } else {
 276                                 echo self::printASN($x->data, $indent.'.  ');
 277                         }
 278                 } elseif (is_array($x)) {
 279                         foreach ($x as $d) {
 280                                 echo self::printASN($d, $indent);
 281                         }
 282                 } else {
 283                         if (preg_match('/[^[:print:]]/', $x))   // if we have non-printable characters that would
 284                                 $x = base64_encode($x);         // mess up the console, then print the base64 of them...
 285                         echo $indent.$x."\n";
 286                 }
 287         }
 288
 289
 290 }
 291