#

# All rights reserved.

# This component and the accompanying materials are made available

# under the terms of the License "Eclipse Public License v1.0"

# which accompanies this distribution, and is available

# at the URL "http://www.eclipse.org/legal/epl-v10.html".

#

# Initial Contributors:

# Nokia Corporation - initial contribution.

#

# Contributors:

#

# Description: 

# Basic ASN.1 encoding library

# Some parts of this program requrie OpenSSL which may be freely downloaded

# from www.openssl.org

#

use strict;

use Digest::HMAC_MD5;

use Digest::HMAC_SHA1;

use Getopt::Long;

# 0 = off

# 1 = log parsing

# 2 = log parsing + encoding

# 3 = really verbose stuff

my $DEBUG=0;

# Turn on validation checks that attempt to only generate

# valid DER encodings.

my $VALIDATE=0;

my $OID_PKCS = "1.2.840.113549.1";

my $OID_PKCS7 ="${OID_PKCS}.7";

my $OID_PKCS9 = "${OID_PKCS}.9";

my $OID_PKCS9_CERTTYPES = "${OID_PKCS9}.22"; 

my $OID_PKCS12 = "${OID_PKCS}.12";

my $OID_PKCS12_BAGTYPES = "${OID_PKCS12}.10.1";

my $OID_PKCS12_PBEIDS = "${OID_PKCS12}.1";

my %OIDS = 

	(

	 "MD5"  => "1.2.840.113549.2.5",

	 "SHA1" => "1.3.14.3.2.26",

	 "X509CRL" => "1.3.6.1.4.1.3627.4",

	 "PKCS7_DATA" => "${OID_PKCS7}.1",

	 "PKCS7_SIGNEDDATA" => "${OID_PKCS7}.2",

	 "PKCS7_ENVELOPEDDATA" => "${OID_PKCS7}.3",

	 "PKCS7_SIGNEDANDENVELOPEDDATA" => "${OID_PKCS7}.4",

	 "PKCS7_DIGESTEDDATA" => "${OID_PKCS7}.5",

	 "PKCS7_ENCRYPTEDDATA" => "${OID_PKCS7}.6",	

	 "PKCS9_CERTTYPES_PKCS12_X509" => "${OID_PKCS9_CERTTYPES}.1",

	 "PKCS9_FRIENDLY_NAME" => "${OID_PKCS9}.20",

	 "PKCS9_LOCAL_KEYID" => "${OID_PKCS9}.21",

	 "PKCS12_BAGTYPES_KEYBAG" => "${OID_PKCS12_BAGTYPES}.1",

	 "PKCS12_BAGTYPES_PKCS8SHROUDEDKEYBAG" => "${OID_PKCS12_BAGTYPES}.2",

	 "PKCS12_BAGTYPES_CERTBAG" => "${OID_PKCS12_BAGTYPES}.3",

	 "PKCS12_BAGTYPES_CRLBAG" => "${OID_PKCS12_BAGTYPES}.4",

	 "PKCS12_BAGTYPES_SECRETBAG" => "${OID_PKCS12_BAGTYPES}.5",

	 "PKCS12_BAGTYPES_SAFECONTENTSBAG" => "${OID_PKCS12_BAGTYPES}.6",

	 "PKCS12_PBEIDS_SHAAND128BITRC4" => "${OID_PKCS12_PBEIDS}.1",

	 "PKCS12_PBEIDS_SHAAND40BITRC4" => "${OID_PKCS12_PBEIDS}.2",

	 "PKCS12_PBEIDS_SHAAND3KEYTRIPLEDESCBC" => "${OID_PKCS12_PBEIDS}.3",

	 "PKCS12_PBEIDS_SHAAND2KEYTRIPLEDESCBC" => "${OID_PKCS12_PBEIDS}.4",

	 "PKCS12_PBEIDS_SHAAND128BITRC2CBC" => "${OID_PKCS12_PBEIDS}.5", 

	 "PKCS12_PBEIDS_SHAAND40BITRC2CBC" => "${OID_PKCS12_PBEIDS}.6",

	 # Symbian dev cert extensions

	 "SYMBIAN_DEVICE_ID_LIST" => "1.2.826.0.1.1796587.1.1.1.1",

	 "SYMBIAN_SID_LIST" => "1.2.826.0.1.1796587.1.1.1.4",

	 "SYMBIAN_VID_LIST" => "1.2.826.0.1.1796587.1.1.1.5",

	 "SYMBIAN_CAPABILITIES" => "1.2.826.0.1.1796587.1.1.1.6"

);

my $DER_BOOLEAN_TAG="01";

my $DER_INTEGER_TAG="02";

my $DER_BITSTRING_TAG="03";

my $DER_OCTETSTRING_TAG="04";

my $DER_NULL_TAG="05";

my $DER_OID_TAG="06";

my $DER_ENUMERATED_TAG="0A";

my $DER_SEQUENCE_TAG="10";

my $DER_SET_TAG="11";

my $DER_UTF8STRING_TAG="0C";

my $DER_PRINTABLESTRING_TAG="13";

my $DER_IA5STRING_TAG="16";

my $DER_UTCTIME_TAG="17";

my $DER_BMPSTRING_TAG="1E";

my $UNIVERSAL_CLASS="UNIVERSAL";

my $APPLICATION_CLASS="APPLICATION";

my $CONTEXT_SPECIFIC_CLASS="CONTEXT-SPECIFIC";

my $PRIVATE_CLASS="PRIVATE";

my %PARSE = 

	(

	 "BOOL" => \&parseBoolean,

	 "BOOLEAN" => \&parseBoolean,

	 "BIGINTEGER" => \&parseBigInteger,

	 "BITSTRING" => \&parseBitString,

	 "BITSTRING_WRAPPER" => \&parseBitStringWrapper,

	 "BMPSTRING" => \&parseBmpString,

	 "BMPSTRING_FILE" => \&parseBmpStringFile,

	 "ENUMERATED" => \&parseEnumerated,

	 "IA5STRING" => \&parseIA5String,

	 "IA5STRING_FILE" => \&parseIA5StringFile,

	 "INCLUDE" => \&parseInclude,

	 "INCLUDE_BINARY_FILE" => \&parseIncludeBinaryFile,

	 "INTEGER" => \&parseInteger,

	 "INT" => \&parseInteger,

	 "IMPLICIT" => \&parseImplicit,

	 "ENCRYPT" => \&parseEncrypt,

	 "EXPLICIT" => \&parseExplicit,

	 "HASH" => \&parseHash,

	 "HMAC" => \&parseHmac,

	 "NULL" => \&parseNull,

	 "OCTETSTRING" => \&parseOctetString,

	 "OUTPUT_BINARY_FILE" => \&parseOutputFile,

	 "OID" => \&parseOid,

	 "PRINTABLESTRING" => \&parsePrintableString,

	 "PRINTABLESTRING_FILE" => \&parsePrintableStringFile,

	 "RAW" => \&parseRaw,

	 "SEQUENCE" => \&parseSequence,

	 "SEQ" => \&parseSequence,

	 "SET" => \&parseSet,

	 "SHELL" => \&parseShell,

	 "SIGN" => \&parseSign,

	 "UTCTIME" => \&parseUtcTime,

	 "UTF8STRING" => \&parseUtf8String,

	 "UTF8STRING_FILE" => \&parseUtf8StringFile,

	 );

my $TABS = "";

&main;

exit(0);

sub main() {

	my $hex;

	my $out;

	my $in;	

	my @lines;

	GetOptions('debug=i' => \$DEBUG,

			   'hex' => \$hex, 

			   'in=s' => \$in,

			   'out=s' => \$out);

	if (! defined $in) {

		$in = $ARGV[0];

	}

	if (! defined $out) {

		$out = $ARGV[1];

	}

	if (defined $in) {

		@lines = readFile($in);

	}

	else {

		die "No input file specified.\n";

	}

	if (defined $out) {

		open OUT, ">$out" || die "Cannot open output file $out";

	}

	else {

		*OUT = *STDOUT;

	}

	my $oc = 0;

	my $asnHex = parseScript(\@lines, \$oc);

	$asnHex = tidyHex($asnHex);

	if ((!defined $hex) && (defined $out)) {

		binmode(OUT);

		print OUT toBin($asnHex);

	}

	elsif (defined $out) {

		print OUT $asnHex;

	}

	else {

		print $asnHex;

	}

	close OUT;

}

sub tidyHex($) {

	my ($input) = @_;	

	$input =~ s/:+/:/g;

	$input =~ s/(^:|:$)//g;

	return uc($input);

}

sub toBin($) {

	my ($asnHex) = @_;

	$asnHex =~ s/[\s:]//g;

	$asnHex = uc($asnHex);

	my $len = length($asnHex);

	if ($len % 2 != 0) {

		die "toBin: hex string contains an odd number ($len) of octets.\n$asnHex\n";

	}

	my $binary;

	$binary .= pack("H${len}", $asnHex);

#	for (my $i = 0; $i < length($asnHex); $i+=2) {

#		$binary .= pack('C', substr($asnHex, $i, 2));

#	}

	return $binary;

}

sub parseScript($$;$) {

	my ($lines, $oc, $params) = @_;

	my $derHex = "";

	nest();

	substVars($lines, $params);

	while (my $line = shift @$lines) {

		chomp($line);

		# Remove leading spaces

		$line =~ s/^\s*//g;

		# skip comments 

		next if ($line =~ /^\/\//);

		if ($DEBUG == 3) {

			print "${TABS}:PARSE parseScript: $line\n";

		}

		my $argString;

		my $cmd;

		if ($line =~ /(\w+)\s*\{/ ) {

			# parse block commands e.g. large integer

			$cmd = uc($1);

			$line =~ s/.*\{//g;

			while (defined $line && !($line =~ /(^|[^\\]+)\}/) ) {

				$argString .= $line;

				$line = shift(@$lines);				

			}

			if (defined $line) {

				# append everything up to the closing curly bracket

				$line =~ s/(^|[^\\])\}.*/$1/g;

				$argString .= $line;

			}

		}	

		elsif ($line =~ /(\w+)\s*=*(.*)/) {

			# parse commands of the form key = value

			$cmd = uc($1);

			$argString = defined $2 ? $2 : "";			

		}

		if (defined $cmd) {

			if ($cmd =~ /^END/) {

				leaveNest();

				if ($DEBUG) {

					print "${TABS}:PARSE END\n";

				}

				return $derHex;

			}

			elsif (! defined $PARSE{$cmd}) {

				die "parseScript: Unknown command: $cmd\n";

			}

			else {

				if ($DEBUG) {

					print "${TABS}:PARSE CMD=$cmd";					

					if ($argString ne "") {print " ARG: $argString";}

					print "\n";

				}

				# Substitue variables in argString

				$derHex .= ":" . &{$PARSE{$cmd}}($argString, $oc, $lines);

			}

		}

	}

	leaveNest();

	return $derHex;

}

sub substVars($$) {

	my ($lines, $params) = @_;

	if (! defined $params) {

		@$params = ();

	}

	for (my $i = 0; $i < scalar(@$lines); $i++) {

		my $line = @$lines[$i];

		my $paramIndex = 1;

		# For each parameter search for the a use of $N where

		# N is the index of the parameter and replace $N with the

		# value of the parameter

		foreach (@$params) {

			$line =~ s/\$${paramIndex}(\D|$)/$_$1/g;	

			++$paramIndex;

		}

		# Remove any unused parameters

		$line =~ s/\$\d+//g;

		@$lines[$i] = $line;

	}

}

sub readFile($) {

	my ($fileName) = @_;

	my $inFile;

	if ($DEBUG) {

		print "readFile, $fileName\n";

	}

	open($inFile, $fileName) || die "readFile: cannot open $fileName\n";	

	my @lines = <$inFile>;

	close $inFile;

	return @lines;

}

sub parseBitString($$;$) {

	my ($argString, $oc, $lines) = @_;	

	return encodeBitString($argString, $oc);

}

sub parseBitStringWrapper($$;$) {

	my ($argString, $oc, $lines) = @_;	

	my $contents_oc = 0;

	my $contents = parseScript($lines, \$contents_oc);

	my $binary = toBin($contents);

	my $bitCount = $contents_oc * 8;

	my $bitStr = unpack("B${bitCount}", $binary);

	# remove trailing zeros - breaks signatures so disable for the moment

	# $bitStr =~ s/0*$//g;

	return encodeBitString($bitStr, $oc);

}

sub parseBmpString($$;$) {

	my ($argString, $oc, $lines) = @_;	

	my $bmpString_oc = 0;

	my $bmpString = asciiToBmpString($argString, \$bmpString_oc);

	return encodeBmpString($bmpString, $bmpString_oc, $oc);

}

sub parseBmpStringFile($$;$) {

	my ($binFName, $oc, $lines) = @_;

	$binFName =~ s/\s*//g;

	my $bmpString_oc = 0;

	my $bmpString = encodeBinaryFile($binFName, \$bmpString_oc);	

	return encodeBmpString($bmpString, $bmpString_oc, $oc);

}

sub parseBoolean($$;$) {

	my ($argString, $oc, $lines) = @_;

	$argString =~ s/\s//g;

	$argString = lc($argString);

	my $bool;

	if ($argString eq "t" || $argString eq "true" || $argString eq "1") {

		$bool = 1;

	}

	elsif ($argString eq "f" || $argString eq "false" || $argString eq "0") {

		$bool = 0;

	}

	else {

		die "parseBoolean: Invalid boolean value \'$argString\'";

	}

	return encodeBoolean($bool, $oc);

}

sub parseHash($$;$) {

	my ($argString, $oc, $lines) = @_;

	my ($algorithm) = getArgs($argString);

	if (! defined $algorithm) {

		die "parseHash: missing algortithm";

	}

	my $hashIn_oc = 0;

	my $hashIn = parseScript($lines, \$hashIn_oc);

	my $hashInFName = '_hashin.tmp';

	my $hashOutFName = '_hashout.tmp';

	# Create binary hash file

	my $hashInFh;

	open($hashInFh, ">$hashInFName") or die "Cannot create $hashInFName";

	binmode($hashInFh);

	print $hashInFh toBin($hashIn);

	close $hashInFh;

	my @command = ("cmd",

				   "/C \"openssl dgst -${algorithm} -binary $hashInFName > $hashOutFName\"");	

	if ($DEBUG == 1) {

		print "${TABS}:parseHash:" . join(" ", @command) . "\n";

	}

	if ((my $err = system(@command)) != 0) {

		die "parseHash: " . join(" ", @command) . "\nreturned error $err";

	}

	my $derHex = parseIncludeBinaryFile($hashOutFName, $oc);

	if (! $DEBUG) {

		unlink($hashInFName);

		unlink($hashOutFName);

	}

	return $derHex;

}

sub parseHmac($$;$) {

	my ($argString, $oc, $lines) = @_;

	my ($algorithm, $key) = getArgs($argString);

	if (! defined $algorithm) {

		die "parseHmac: missing algortithm";

	}

	$algorithm = uc($algorithm);

	if (! $algorithm =~ /MD5|SHA1/) {

		die "parseHmac: invalid algorithm $algorithm";

	}

	if (! defined $key) {

		die "parseHmac: missing key";

	}

	my $hmacIn_oc = 0;

	my $hmacIn = toBin(parseScript($lines, \$hmacIn_oc));

	my $hmac;

	my $binKey = toBin($key);

	if ($algorithm eq "SHA1") {

		$hmac = Digest::HMAC_SHA1->new($binKey);

	}

	else {

		$hmac = Digest::HMAC_MD5->new($binKey);

	}

	$hmac->add($hmacIn);

	my $digest = $hmac->digest;

	$$oc += length($digest);

	return toHex($digest);

}

sub parseIA5String($$;$) {

	my ($argString, $oc, $lines) = @_;	

	my $ia5String_oc = 0;

	my $ia5String = asciiToIA5String($argString, \$ia5String_oc);

	return encodeIA5String($ia5String, $ia5String_oc, $oc);

}

sub parseIA5StringFile($$;$) {

	my ($binFName, $oc, $lines) = @_;

	$binFName =~ s/\s*//g;

	my $ia5String_oc = 0;

	my $ia5String = encodeBinaryFile($binFName, \$ia5String_oc);	

	return encodeIA5String($ia5String, $ia5String_oc, $oc);

}

sub parseIncludeBinaryFile($$;$) {

	my ($binFName, $oc, $lines) = @_;

	$binFName =~ s/\s*//g;

	return encodeBinaryFile($binFName, $oc);

}

sub parseInclude($$$) {

	my ($argString, $oc, $lines) = @_;   

	my @args = getArgs($argString);

   	my $fileName = shift(@args);

	if (! (defined $fileName && $fileName ne "")) {

		die "parseInclude: Filename not specified\n";

	}

	my $derHex = "";

	my @lines = readFile($fileName);	

	$derHex = parseScript(\@lines, $oc, \@args);

	return $derHex;

}

sub parseInteger($$;$) {

	my ($argString, $oc, $lines) = @_;

	$argString =~ s/\s//g;

	return encodeInteger($argString, $oc);

}

sub parseBigInteger($$;$) {

	my ($argString, $oc, $lines) = @_;

	$argString =~ s/\s//g;

	return encodeBigInteger($argString, $oc);

}

sub parseEncrypt($$;$) {

	my ($argString, $oc, $lines) = @_;		

	my ($cipher, $key, $iv) = getArgs($argString);

	if (! defined $cipher) {

		die "parseEncrypt: missing cipher\n";