mirror of
https://github.com/friendica/friendica
synced 2024-11-11 07:02:53 +00:00
291 lines
8.2 KiB
PHP
291 lines
8.2 KiB
PHP
<?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(strtr(base64_encode($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";
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|