aboutsummaryrefslogtreecommitdiffstats
path: root/library/asn1.php
diff options
context:
space:
mode:
Diffstat (limited to 'library/asn1.php')
-rw-r--r--library/asn1.php303
1 files changed, 303 insertions, 0 deletions
diff --git a/library/asn1.php b/library/asn1.php
new file mode 100644
index 000000000..5b1ad3b8f
--- /dev/null
+++ b/library/asn1.php
@@ -0,0 +1,303 @@
+<?php
+
+// ASN.1 parsing library
+// Attribution: http://www.krisbailey.com
+// license: unknown
+// modified: Mike Macgrivin mike@macgirvin.com 6-oct-2010 to support Salmon auto-discovery
+// from openssl public keys
+
+
+class ASN_BASE {
+ public $asnData = null;
+ private $cursor = 0;
+ private $parent = null;
+
+ public static $ASN_MARKERS = array(
+ 'ASN_UNIVERSAL' => 0x00,
+ 'ASN_APPLICATION' => 0x40,
+ 'ASN_CONTEXT' => 0x80,
+ 'ASN_PRIVATE' => 0xC0,
+
+ 'ASN_PRIMITIVE' => 0x00,
+ 'ASN_CONSTRUCTOR' => 0x20,
+
+ 'ASN_LONG_LEN' => 0x80,
+ 'ASN_EXTENSION_ID' => 0x1F,
+ 'ASN_BIT' => 0x80,
+ );
+
+ public static $ASN_TYPES = array(
+ 1 => 'ASN_BOOLEAN',
+ 2 => 'ASN_INTEGER',
+ 3 => 'ASN_BIT_STR',
+ 4 => 'ASN_OCTET_STR',
+ 5 => 'ASN_NULL',
+ 6 => 'ASN_OBJECT_ID',
+ 9 => 'ASN_REAL',
+ 10 => 'ASN_ENUMERATED',
+ 13 => 'ASN_RELATIVE_OID',
+ 48 => 'ASN_SEQUENCE',
+ 49 => 'ASN_SET',
+ 19 => 'ASN_PRINT_STR',
+ 22 => 'ASN_IA5_STR',
+ 23 => 'ASN_UTC_TIME',
+ 24 => 'ASN_GENERAL_TIME',
+ );
+
+ function __construct($v = false)
+ {
+ if (false !== $v) {
+ $this->asnData = $v;
+ if (is_array($this->asnData)) {
+ foreach ($this->asnData as $key => $value) {
+ if (is_object($value)) {
+ $this->asnData[$key]->setParent($this);
+ }
+ }
+ } else {
+ if (is_object($this->asnData)) {
+ $this->asnData->setParent($this);
+ }
+ }
+ }
+ }
+
+ public function setParent($parent)
+ {
+ if (false !== $parent) {
+ $this->parent = $parent;
+ }
+ }
+
+ /**
+ * This function will take the markers and types arrays and
+ * dynamically generate classes that extend this class for each one,
+ * and also define constants for them.
+ */
+ public static function generateSubclasses()
+ {
+ define('ASN_BASE', 0);
+ foreach (self::$ASN_MARKERS as $name => $bit)
+ self::makeSubclass($name, $bit);
+ foreach (self::$ASN_TYPES as $bit => $name)
+ self::makeSubclass($name, $bit);
+ }
+
+ /**
+ * Helper function for generateSubclasses()
+ */
+ public static function makeSubclass($name, $bit)
+ {
+ define($name, $bit);
+ eval("class ".$name." extends ASN_BASE {}");
+ }
+
+ /**
+ * This function reset's the internal cursor used for value iteration.
+ */
+ public function reset()
+ {
+ $this->cursor = 0;
+ }
+
+ /**
+ * This function catches calls to get the value for the type, typeName, value, values, and data
+ * from the object. For type calls we just return the class name or the value of the constant that
+ * is named the same as the class.
+ */
+ public function __get($name)
+ {
+ if ('type' == $name) {
+ // int flag of the data type
+ return constant(get_class($this));
+ } elseif ('typeName' == $name) {
+ // name of the data type
+ return get_class($this);
+ } elseif ('value' == $name) {
+ // will always return one value and can be iterated over with:
+ // while ($v = $obj->value) { ...
+ // because $this->asnData["invalid key"] will return false
+ return is_array($this->asnData) ? $this->asnData[$this->cursor++] : $this->asnData;
+ } elseif ('values' == $name) {
+ // will always return an array
+ return is_array($this->asnData) ? $this->asnData : array($this->asnData);
+ } elseif ('data' == $name) {
+ // will always return the raw data
+ return $this->asnData;
+ }
+ }
+
+ /**
+ * Parse an ASN.1 binary string.
+ *
+ * This function takes a binary ASN.1 string and parses it into it's respective
+ * pieces and returns it. It can optionally stop at any depth.
+ *
+ * @param string $string The binary ASN.1 String
+ * @param int $level The current parsing depth level
+ * @param int $maxLevel The max parsing depth level
+ * @return ASN_BASE The array representation of the ASN.1 data contained in $string
+ */
+ public static function parseASNString($string=false, $level=1, $maxLevels=false){
+ if (!class_exists('ASN_UNIVERSAL'))
+ self::generateSubclasses();
+ if ($level>$maxLevels && $maxLevels)
+ return array(new ASN_BASE($string));
+ $parsed = array();
+ $endLength = strlen($string);
+ $bigLength = $length = $type = $dtype = $p = 0;
+ while ($p<$endLength){
+ $type = ord($string[$p++]);
+ $dtype = ($type & 192) >> 6;
+ if ($type==0){ // if we are type 0, just continue
+ } else {
+ $length = ord($string[$p++]);
+ if (($length & ASN_LONG_LEN)==ASN_LONG_LEN){
+ $tempLength = 0;
+ for ($x=0; $x<($length & (ASN_LONG_LEN-1)); $x++){
+ $tempLength = ord($string[$p++]) + ($tempLength * 256);
+ }
+ $length = $tempLength;
+ }
+ $data = substr($string, $p, $length);
+ $parsed[] = self::parseASNData($type, $data, $level, $maxLevels);
+ $p = $p + $length;
+ }
+ }
+ return $parsed;
+ }
+
+ /**
+ * Parse an ASN.1 field value.
+ *
+ * This function takes a binary ASN.1 value and parses it according to it's specified type
+ *
+ * @param int $type The type of data being provided
+ * @param string $data The raw binary data string
+ * @param int $level The current parsing depth
+ * @param int $maxLevels The max parsing depth
+ * @return mixed The data that was parsed from the raw binary data string
+ */
+ public static function parseASNData($type, $data, $level, $maxLevels){
+ $type = $type%50; // strip out context
+ switch ($type){
+ default:
+ return new ASN_BASE($data);
+ case ASN_BOOLEAN:
+ return new ASN_BOOLEAN((bool)$data);
+ case ASN_INTEGER:
+ return new ASN_INTEGER(accum($data));
+// return new ASN_INTEGER(ord($data));
+ case ASN_BIT_STR:
+ return new ASN_BIT_STR(self::parseASNString($data, $level+1, $maxLevels));
+ case ASN_OCTET_STR:
+ return new ASN_OCTET_STR($data);
+ case ASN_NULL:
+ return new ASN_NULL(null);
+ case ASN_REAL:
+ return new ASN_REAL($data);
+ case ASN_ENUMERATED:
+ return new ASN_ENUMERATED(self::parseASNString($data, $level+1, $maxLevels));
+ case ASN_RELATIVE_OID: // I don't really know how this works and don't have an example :-)
+ // so, lets just return it ...
+ return new ASN_RELATIVE_OID($data);
+ case ASN_SEQUENCE:
+ return new ASN_SEQUENCE(self::parseASNString($data, $level+1, $maxLevels));
+ case ASN_SET:
+ return new ASN_SET(self::parseASNString($data, $level+1, $maxLevels));
+ case ASN_PRINT_STR:
+ return new ASN_PRINT_STR($data);
+ case ASN_IA5_STR:
+ return new ASN_IA5_STR($data);
+ case ASN_UTC_TIME:
+ return new ASN_UTC_TIME($data);
+ case ASN_GENERAL_TIME:
+ return new ASN_GENERAL_TIME($data);
+ case ASN_OBJECT_ID:
+ return new ASN_OBJECT_ID(self::parseOID($data));
+ }
+ }
+
+ /**
+ * Parse an ASN.1 OID value.
+ *
+ * This takes the raw binary string that represents an OID value and parses it into its
+ * dot notation form. example - 1.2.840.113549.1.1.5
+ * look up OID's here: http://www.oid-info.com/
+ * (the multi-byte OID section can be done in a more efficient way, I will fix it later)
+ *
+ * @param string $data The raw binary data string
+ * @return string The OID contained in $data
+ */
+ public static function parseOID($string){
+ $ret = floor(ord($string[0])/40).".";
+ $ret .= (ord($string[0]) % 40);
+ $build = array();
+ $cs = 0;
+
+ for ($i=1; $i<strlen($string); $i++){
+ $v = ord($string[$i]);
+ if ($v>127){
+ $build[] = ord($string[$i])-ASN_BIT;
+ } elseif ($build){
+ // do the build here for multibyte values
+ $build[] = ord($string[$i])-ASN_BIT;
+ // you know, it seems there should be a better way to do this...
+ $build = array_reverse($build);
+ $num = 0;
+ for ($x=0; $x<count($build); $x++){
+ $mult = $x==0?1:pow(256, $x);
+ if ($x+1==count($build)){
+ $value = ((($build[$x] & (ASN_BIT-1)) >> $x)) * $mult;
+ } else {
+ $value = ((($build[$x] & (ASN_BIT-1)) >> $x) ^ ($build[$x+1] << (7 - $x) & 255)) * $mult;
+ }
+ $num += $value;
+ }
+ $ret .= ".".$num;
+ $build = array(); // start over
+ } else {
+ $ret .= ".".$v;
+ $build = array();
+ }
+ }
+ return $ret;
+ }
+
+ public static function printASN($x, $indent=''){
+ if (is_object($x)) {
+ echo $indent.$x->typeName."\n";
+ if (ASN_NULL == $x->type) return;
+ if (is_array($x->data)) {
+ while ($d = $x->value) {
+ echo self::printASN($d, $indent.'. ');
+ }
+ $x->reset();
+ } else {
+ echo self::printASN($x->data, $indent.'. ');
+ }
+ } elseif (is_array($x)) {
+ foreach ($x as $d) {
+ echo self::printASN($d, $indent);
+ }
+ } else {
+ if (preg_match('/[^[:print:]]/', $x)) // if we have non-printable characters that would
+ $x = base64_encode($x); // mess up the console, then print the base64 of them...
+ echo $indent.$x."\n";
+ }
+ }
+
+
+}
+
+
+function accum($s) {
+ $len = strlen($s);
+ $result = '';
+ for ($i=0; $i < $len; $i++) {
+ $cur = substr($s,$i,1);
+ $result .= bin2hex($cur);
+ }
+ return $result;
+}
+
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-20 13:47:50 +0000