@sswroom/sswr 1.6.3 → 1.6.5

package/cert.js

@@ -68,6 +68,11 @@ export const ContentDataType = {
 
 export class ASN1Data extends data.ParsedObject
 {
+	/**
+	 * @param {string} sourceName
+	 * @param {string} objType
+	 * @param {ArrayBuffer} buff
+	 */
 	constructor(sourceName, objType, buff)
 	{
 		super(sourceName, objType);
@@ -87,6 +92,12 @@ export class ASN1Data extends data.ParsedObject
 		return this.reader;
 	}
 
+	/**
+	 * @param {string[]} arr
+	 * @param {data.ByteReader} reader
+	 * @param {number} ofst
+	 * @param {number} len
+	 */
 	static appendInteger(arr, reader, ofst, len)
 	{
 		if (len == 1)
@@ -118,6 +129,11 @@ export class ASN1Data extends data.ParsedObject
 
 export class X509File extends ASN1Data
 {
+	/**
+	 * @param {any} sourceName
+	 * @param {any} objType
+	 * @param {any} buff
+	 */
 	constructor(sourceName, objType, buff)
 	{
 		super(sourceName, objType, buff);
@@ -133,11 +149,17 @@ export class X509File extends ASN1Data
 		return 0;
 	}
 
+	/**
+	 * @param {any} index
+	 */
 	getCertName(index)
 	{
 		return null;
 	}
 
+	/**
+	 * @param {any} index
+	 */
 	getNewCert(index)
 	{
 		return null;
@@ -148,11 +170,14 @@ export class X509File extends ASN1Data
 		return fileTypeGetName(this.getFileType())+": "+this.toShortName();
 	}
 
+	/**
+	 * @param {X509Key} key
+	 */
 	isSignatureKey(key)
 	{
 		let data = ASN1Util.pduGetItem(this.reader, 0, this.reader.getLength(), "1.1");
 		let signature = ASN1Util.pduGetItem(this.reader, 0, this.reader.getLength(), "1.3");
-		if (data == 0 || signature == 0 || signature.itemType != ASN1ItemType.BIT_STRING)
+		if (data == null || signature == null || signature.itemType != ASN1ItemType.BIT_STRING)
 		{
 			return false;
 		}
@@ -191,6 +216,12 @@ export class X509File extends ASN1Data
 			algType: algType};
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {string | null | undefined} path
+	 */
 	static isSigned(reader, startOfst, endOfst, path)
 	{
 		let cnt = ASN1Util.pduCountItem(reader, startOfst, endOfst, path);
@@ -209,6 +240,14 @@ export class X509File extends ASN1Data
 		return true;
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {string} path
+	 * @param {string[]} sb
+	 * @param {string | null} varName
+	 */
 	static appendSigned(reader, startOfst, endOfst, path, sb, varName)
 	{
 		let name;
@@ -240,6 +279,12 @@ export class X509File extends ASN1Data
 		}		
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {string | null | undefined} path
+	 */
 	static isTBSCertificate(reader, startOfst, endOfst, path)
 	{
 		let cnt = ASN1Util.pduCountItem(reader, startOfst, endOfst, path);
@@ -279,6 +324,14 @@ export class X509File extends ASN1Data
 		return true;
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {string} path
+	 * @param {string[]} sb
+	 * @param {string} varName
+	 */
 	static appendTBSCertificate(reader, startOfst, endOfst, path, sb, varName)
 	{
 		let name;
@@ -392,17 +445,37 @@ export class X509File extends ASN1Data
 		}
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {string} path
+	 */
 	static isCertificate(reader, startOfst, endOfst, path)
 	{
 		return X509File.isSigned(reader, startOfst, endOfst, path) && X509File.isTBSCertificate(reader, startOfst, endOfst, path+".1");
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {string} path
+	 * @param {any[]} sb
+	 * @param {string | null} varName
+	 */
 	static appendCertificate(reader, startOfst, endOfst, path, sb, varName)
 	{
 		X509File.appendTBSCertificate(reader, startOfst, endOfst, path+".1", sb, varName);
 		X509File.appendSigned(reader, startOfst, endOfst, path, sb, varName);
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {string | null | undefined} path
+	 */
 	static isTBSCertList(reader, startOfst, endOfst, path)
 	{
 		let cnt = ASN1Util.pduCountItem(reader, startOfst, endOfst, path);
@@ -443,6 +516,14 @@ export class X509File extends ASN1Data
 		return true;
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {string} path
+	 * @param {(string | number)[]} sb
+	 * @param {string} varName
+	 */
 	static appendTBSCertList(reader, startOfst, endOfst, path, sb, varName)
 	{
 		let dt;
@@ -577,46 +658,64 @@ export class X509File extends ASN1Data
 		}
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {string} path
+	 */
 	static isCertificateList(reader, startOfst, endOfst, path)
 	{
 		return X509File.isSigned(reader, startOfst, endOfst, path) && X509File.isTBSCertList(reader, startOfst, endOfst, path+".1");
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {string} path
+	 * @param {any[]} sb
+	 * @param {string} varName
+	 */
 	static appendCertificateList(reader, startOfst, endOfst, path, sb, varName)
 	{
 		X509File.appendTBSCertList(reader, startOfst, endOfst, path+".1", sb, varName);
 		X509File.appendSigned(reader, startOfst, endOfst, path, sb, varName);
 	}
 
-/*	static isPrivateKeyInfo(reader, startOfst, endOfst, path)
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {string | null | undefined} path
+	 */
+	static isPrivateKeyInfo(reader, startOfst, endOfst, path)
 	{
-		UOSInt cnt = ASN1Util.pduCountItem(pdu, pduEnd, path);
+		let cnt = ASN1Util.pduCountItem(reader, startOfst, endOfst, path);
 		if (cnt != 3 && cnt != 4)
 		{
 			return false;
 		}
-		Char sbuff[256];
-		Char *sptr;
-		sptr = Text.StrConcat(sbuff, path);
-		Text.StrConcat(sptr, ".1");
-		if (ASN1Util.pduGetItemType(pdu, pduEnd, sbuff) != ASN1ItemType.INTEGER)
+		let sbuff;
+		sbuff = path + ".1";
+		if (ASN1Util.pduGetItemType(reader, startOfst, endOfst, sbuff) != ASN1ItemType.INTEGER)
 		{
 			return false;
 		}
-		Text.StrConcat(sptr, ".2");
-		if (ASN1Util.pduGetItemType(pdu, pduEnd, sbuff) != ASN1ItemType.SEQUENCE)
+		sbuff = path + ".2";
+		if (ASN1Util.pduGetItemType(reader, startOfst, endOfst, sbuff) != ASN1ItemType.SEQUENCE)
 		{
 			return false;
 		}
-		Text.StrConcat(sptr, ".3");
-		if (ASN1Util.pduGetItemType(pdu, pduEnd, sbuff) != ASN1ItemType.OCTET_STRING)
+		sbuff = path + ".3";
+		if (ASN1Util.pduGetItemType(reader, startOfst, endOfst, sbuff) != ASN1ItemType.OCTET_STRING)
 		{
 			return false;
 		}
 		if (cnt == 4)
 		{
-			Text.StrConcat(sptr, ".4");
-			if (ASN1Util.pduGetItemType(pdu, pduEnd, sbuff) != ASN1ItemType.SET)
+			sbuff = path + ".4";
+			if (ASN1Util.pduGetItemType(reader, startOfst, endOfst, sbuff) != ASN1ItemType.SET)
 			{
 				return false;
 			}
@@ -624,49 +723,58 @@ export class X509File extends ASN1Data
 		return true;
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {string} path
+	 * @param {any[]} sb
+	 */
 	static appendPrivateKeyInfo(reader, startOfst, endOfst, path, sb)
 	{
-		Char sbuff[256];
-		Char *sptr;
-		const UInt8 *itemPDU;
-		UOSInt len;
-		Net.ASN1Util.ItemType itemType;
-		KeyType keyType = KeyType.Unknown;
-		sptr = Text.StrConcat(sbuff, path);
-		Text.StrConcat(sptr, ".1");
-		if ((itemPDU = ASN1Util.pduGetItem(pdu, pduEnd, sbuff, len, itemType)) != 0)
+		let sbuff;
+		let itemPDU;
+		let keyType = KeyType.Unknown;
+		sbuff = path + ".1";
+		if ((itemPDU = ASN1Util.pduGetItem(reader, startOfst, endOfst, sbuff)) != null)
 		{
-			if (itemType == ASN1ItemType.INTEGER)
+			if (itemPDU.itemType == ASN1ItemType.INTEGER)
 			{
-				sb.push("version = "));
-				AppendVersion(pdu, pduEnd, sbuff, sb);
-				sb.push("\r\n"));
+				sb.push("version = ");
+				X509File.appendVersion(reader, startOfst, endOfst, sbuff, sb);
+				sb.push("\r\n");
 			}
 		}
-		Text.StrConcat(sptr, ".2");
-		if ((itemPDU = ASN1Util.pduGetItem(pdu, pduEnd, sbuff, len, itemType)) != 0)
+		sbuff = path + ".2";
+		if ((itemPDU = ASN1Util.pduGetItem(reader, startOfst, endOfst, sbuff)) != null)
 		{
-			if (itemType == ASN1ItemType.SEQUENCE)
+			if (itemPDU.itemType == ASN1ItemType.SEQUENCE)
 			{
-				AppendAlgorithmIdentifier(itemPDU, itemPDU + len, sb, CSTR("privateKeyAlgorithm"), false, &keyType);
+				keyType = X509File.appendAlgorithmIdentifier(reader, itemPDU.dataOfst, itemPDU.endOfst, sb, "privateKeyAlgorithm", false);
 			}
 		}
-		Text.StrConcat(sptr, ".3");
-		if ((itemPDU = ASN1Util.pduGetItem(pdu, pduEnd, sbuff, len, itemType)) != 0)
+		sbuff = path + ".3";
+		if ((itemPDU = ASN1Util.pduGetItem(reader, startOfst, endOfst, sbuff)) != null)
 		{
-			if (itemType == ASN1ItemType.OCTET_STRING)
+			if (itemPDU.itemType == ASN1ItemType.OCTET_STRING)
 			{
-				sb.push("privateKey = "));
-				sb.push("\r\n"));
+				sb.push("privateKey = ");
+				sb.push("\r\n");
 				if (keyType != KeyType.Unknown)
 				{
-					Crypto.Cert.X509Key privkey(CSTR("PrivKey"), Data.ByteArrayR(itemPDU, len), keyType);
-					privkey.ToString(sb);
+					let privkey = new X509PrivKey("PrivKey", reader.getU8Arr(itemPDU.dataOfst, itemPDU.contLen));
+					sb.push(privkey.toString());
 				}
 			}
 		}
-	}*/
+	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {string | null | undefined} path
+	 */
 	static isCertificateRequestInfo(reader, startOfst, endOfst, path)
 	{
 		let cnt = ASN1Util.pduCountItem(reader, startOfst, endOfst, path);
@@ -694,6 +802,13 @@ export class X509File extends ASN1Data
 		return true;
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {string} path
+	 * @param {string[]} sb
+	 */
 	static appendCertificateRequestInfo(reader, startOfst, endOfst, path, sb)
 	{
 		let i = 1;
@@ -762,17 +877,36 @@ export class X509File extends ASN1Data
 		}
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {string} path
+	 */
 	static isCertificateRequest(reader, startOfst, endOfst, path)
 	{
 		return X509File.isSigned(reader, startOfst, endOfst, path) && X509File.isCertificateRequestInfo(reader, startOfst, endOfst, path+".1");
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {string} path
+	 * @param {any[]} sb
+	 */
 	static appendCertificateRequest(reader, startOfst, endOfst, path, sb)
 	{
 		X509File.appendCertificateRequestInfo(reader, startOfst, endOfst, path+".1", sb);
 		X509File.appendSigned(reader, startOfst, endOfst, path, sb, null);
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {string | null | undefined} path
+	 */
 	static isPublicKeyInfo(reader, startOfst, endOfst, path)
 	{
 		let cnt = ASN1Util.pduCountItem(reader, startOfst, endOfst, path);
@@ -791,6 +925,13 @@ export class X509File extends ASN1Data
 		return true;
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {string} path
+	 * @param {any[]} sb
+	 */
 	static appendPublicKeyInfo(reader, startOfst, endOfst, path, sb)
 	{
 		let buff = ASN1Util.pduGetItem(reader, startOfst, endOfst, path);
@@ -806,6 +947,12 @@ export class X509File extends ASN1Data
 		}
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {string | null | undefined} path
+	 */
 	static isContentInfo(reader, startOfst, endOfst, path)
 	{
 		if (ASN1Util.pduGetItemType(reader, startOfst, endOfst, path) != ASN1ItemType.SEQUENCE)
@@ -826,6 +973,15 @@ export class X509File extends ASN1Data
 		return true;
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {string} path
+	 * @param {any[]} sb
+	 * @param {string | null} varName
+	 * @param {number} dataType
+	 */
 	static appendContentInfo(reader, startOfst, endOfst, path, sb, varName, dataType)
 	{
 		let buff = ASN1Util.pduGetItem(reader, startOfst, endOfst, path);
@@ -884,6 +1040,12 @@ export class X509File extends ASN1Data
 		}
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {string | null | undefined} path
+	 */
 	static isPFX(reader, startOfst, endOfst, path)
 	{
 		if (ASN1Util.pduGetItemType(reader, startOfst, endOfst, path) != ASN1ItemType.SEQUENCE)
@@ -911,6 +1073,14 @@ export class X509File extends ASN1Data
 		return true;		
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {string} path
+	 * @param {any[]} sb
+	 * @param {string | null} varName
+	 */
 	static appendPFX(reader, startOfst, endOfst, path, sb, varName)
 	{
 		let buff = ASN1Util.pduGetItem(reader, startOfst, endOfst, path);
@@ -946,6 +1116,13 @@ export class X509File extends ASN1Data
 		}
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {string} path
+	 * @param {string[]} sb
+	 */
 	static appendVersion(reader, startOfst, endOfst, path, sb)
 	{
 		let itemPDU = ASN1Util.pduGetItem(reader, startOfst, endOfst, path);
@@ -969,6 +1146,14 @@ export class X509File extends ASN1Data
 		}
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {string[]} sb
+	 * @param {string} varName
+	 * @param {boolean} pubKey
+	 */
 	static appendAlgorithmIdentifier(reader, startOfst, endOfst, sb, varName, pubKey)
 	{
 		let itemPDU;
@@ -1071,6 +1256,13 @@ export class X509File extends ASN1Data
 		return keyType;
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {string[]} sb
+	 * @param {string} varName
+	 */
 	static appendValidity(reader, startOfst, endOfst, sb, varName)
 	{
 		let dt;
@@ -1095,6 +1287,13 @@ export class X509File extends ASN1Data
 		}
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {string[]} sb
+	 * @param {string} varName
+	 */
 	static appendSubjectPublicKeyInfo(reader, startOfst, endOfst, sb, varName)
 	{
 		let itemPDU;
@@ -1124,6 +1323,13 @@ export class X509File extends ASN1Data
 		}
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {any} sb
+	 * @param {string} varName
+	 */
 	static appendName(reader, startOfst, endOfst, sb, varName)
 	{
 		let itemPDU;
@@ -1142,6 +1348,13 @@ export class X509File extends ASN1Data
 		}
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {any} sb
+	 * @param {string} varName
+	 */
 	static appendRelativeDistinguishedName(reader, startOfst, endOfst, sb, varName)
 	{
 		let itemPDU;
@@ -1161,6 +1374,13 @@ export class X509File extends ASN1Data
 		}
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {string[]} sb
+	 * @param {string} varName
+	 */
 	static appendAttributeTypeAndDistinguishedValue(reader, startOfst, endOfst, sb, varName)
 	{
 		let typePDU = ASN1Util.pduGetItem(reader, startOfst, endOfst, "1");
@@ -1238,6 +1458,13 @@ export class X509File extends ASN1Data
 		}
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {any} sb
+	 * @param {string} varName
+	 */
 	static appendCRLExtensions(reader, startOfst, endOfst, sb, varName)
 	{
 		let itemPDU;
@@ -1256,6 +1483,13 @@ export class X509File extends ASN1Data
 		}
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {string[]} sb
+	 * @param {string} varName
+	 */
 	static appendCRLExtension(reader, startOfst, endOfst, sb, varName)
 	{
 		let extension;
@@ -1298,13 +1532,13 @@ export class X509File extends ASN1Data
 				let extOID = reader.getU8Arr(extension.dataOfst, extension.contLen);
 				if (ASN1Util.oidEqualsText(extOID, "1.3.6.1.5.5.7.1.1")) //id-pe-authorityInfoAccess
 				{
-					if ((itemPDU = ASN1Util.pduGetItem(itemPDU.dataOfst, itemPDU.endOfst, "1")) != null && itemPDU.itemType == ASN1ItemType.SEQUENCE)
+					if ((itemPDU = ASN1Util.pduGetItem(reader, itemPDU.dataOfst, itemPDU.endOfst, "1")) != null && itemPDU.itemType == ASN1ItemType.SEQUENCE)
 					{
 						let i = 1;
-						while ((subItemPDU = ASN1Util.pduGetItem(itemPDU.dataOfst, itemPDU.endOfst, i.toString())) != null && subItemPDU.itemType == ASN1ItemType.SEQUENCE)
+						while ((subItemPDU = ASN1Util.pduGetItem(reader, itemPDU.dataOfst, itemPDU.endOfst, i.toString())) != null && subItemPDU.itemType == ASN1ItemType.SEQUENCE)
 						{
 							let descPDU;
-							if ((descPDU = ASN1Util.pduGetItem(subItemPDU.dataOfst, subItemPDU.endOfst, "1")) != null && descPDU.itemType == ASN1ItemType.OID)
+							if ((descPDU = ASN1Util.pduGetItem(reader, subItemPDU.dataOfst, subItemPDU.endOfst, "1")) != null && descPDU.itemType == ASN1ItemType.OID)
 							{
 								sb.push(varName);
 								sb.push(".authorityInfoAccess[");
@@ -1338,13 +1572,13 @@ export class X509File extends ASN1Data
 				}
 				else if (ASN1Util.oidEqualsText(extOID, "2.5.29.15")) //id-ce-keyUsage
 				{
-					if ((subItemPDU = ASN1Util.pduGetItem(itemPDU.dataOfst, itemPDU.endOfst, "1")) != null && subItemPDU.itemType == ASN1ItemType.BIT_STRING)
+					if ((subItemPDU = ASN1Util.pduGetItem(reader, itemPDU.dataOfst, itemPDU.endOfst, "1")) != null && subItemPDU.itemType == ASN1ItemType.BIT_STRING)
 					{
 						sb.push(varName);
 						sb.push(".keyUsage =");
 						if (subItemPDU.contLen >= 2)
 						{
-							let v = reader.readUInt8(subitemPDU.dataOfst + 1);
+							let v = reader.readUInt8(subItemPDU.dataOfst + 1);
 							if (v & 0x80) sb.push(" digitalSignature");
 							if (v & 0x40) sb.push(" nonRepudiation");
 							if (v & 0x20) sb.push(" keyEncipherment");
@@ -1356,7 +1590,7 @@ export class X509File extends ASN1Data
 						}
 						if (subItemPDU.contLen >= 3)
 						{
-							let v = reader.readUInt8(subitemPDU.dataOfst + 2);
+							let v = reader.readUInt8(subItemPDU.dataOfst + 2);
 							if (v & 0x80) sb.push(" decipherOnly");
 						}
 						sb.push("\r\n");
@@ -1541,86 +1775,107 @@ export class X509File extends ASN1Data
 		}
 	}
 
-/*	static appendMSOSVersion(reader, startOfst, endOfst, sb, varName)
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {string[]} sb
+	 * @param {string} varName
+	 */
+	static appendMSOSVersion(reader, startOfst, endOfst, sb, varName)
 	{
-		Net.ASN1Util.ItemType itemType;
-		UOSInt itemLen;
-		const UInt8 *itemPDU = ASN1Util.pduGetItem(pdu, pduEnd, "1", itemLen, itemType);
-		if (itemType == Net.ASN1Util.ItemType.IT_IA5STRING)
+		let itemPDU = ASN1Util.pduGetItem(reader, startOfst, endOfst, "1");
+		if (itemPDU && itemPDU.itemType == ASN1ItemType.IA5STRING)
 		{
 			sb.push(varName);
-			sb.push(".version = "));
-			sb->AppendC(itemPDU, itemLen);
-			sb.push("\r\n"));
+			sb.push(".version = ");
+			sb.push(new TextDecoder().decode(reader.getU8Arr(itemPDU.dataOfst, itemPDU.contLen)));
+			sb.push("\r\n");
 		}
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {string[]} sb
+	 * @param {string} varName
+	 */
 	static appendMSRequestClientInfo(reader, startOfst, endOfst, sb, varName)
 	{
-		Net.ASN1Util.ItemType itemType;
-		UOSInt itemLen;
-		const UInt8 *itemPDU;
-		if ((itemPDU = ASN1Util.pduGetItem(pdu, pduEnd, "1", itemLen, itemType)) != 0 && itemType == Net.ASN1Util.ItemType.IT_SEQUENCE)
+		let itemPDU;
+		if ((itemPDU = ASN1Util.pduGetItem(reader, startOfst, endOfst, "1")) != null && itemPDU.itemType == ASN1ItemType.SEQUENCE)
 		{
-			UOSInt subitemLen;
-			const UInt8 *subitemPDU;
-			if ((subitemPDU = ASN1Util.pduGetItem(itemPDU, itemPDU + itemLen, "1", subitemLen, itemType)) != 0 && itemType == Net.ASN1Util.ItemType.IT_INTEGER)
+			let subitemPDU;
+			if ((subitemPDU = ASN1Util.pduGetItem(reader, itemPDU.dataOfst, itemPDU.endOfst, "1")) != null && subitemPDU.itemType == ASN1ItemType.INTEGER)
 			{
 				sb.push(varName);
-				sb.push(".unknown = "));
-				Net.ASN1Util.IntegerToString(subitemPDU, subitemLen, sb);
-				sb.push("\r\n"));
+				sb.push(".unknown = ");
+				sb.push(ASN1Util.integerToString(reader, subitemPDU.dataOfst, subitemPDU.contLen));
+				sb.push("\r\n");
 			}
-			if ((subitemPDU = ASN1Util.pduGetItem(itemPDU, itemPDU + itemLen, "2", subitemLen, itemType)) != 0 && itemType == Net.ASN1Util.ItemType.IT_UTF8STRING)
+			if ((subitemPDU = ASN1Util.pduGetItem(reader, itemPDU.dataOfst, itemPDU.endOfst, "2")) != null && subitemPDU.itemType == ASN1ItemType.UTF8STRING)
 			{
 				sb.push(varName);
-				sb.push(".machine = "));
-				sb->AppendC(subitemPDU, subitemLen);
-				sb.push("\r\n"));
+				sb.push(".machine = ");
+				sb.push(new TextDecoder().decode(reader.getU8Arr(subitemPDU.dataOfst, subitemPDU.contLen)));
+				sb.push("\r\n");
 			}
-			if ((subitemPDU = ASN1Util.pduGetItem(itemPDU, itemPDU + itemLen, "3", subitemLen, itemType)) != 0 && itemType == Net.ASN1Util.ItemType.IT_UTF8STRING)
+			if ((subitemPDU = ASN1Util.pduGetItem(reader, itemPDU.dataOfst, itemPDU.endOfst, "3")) != null && subitemPDU.itemType == ASN1ItemType.UTF8STRING)
 			{
 				sb.push(varName);
-				sb.push(".user = "));
-				sb->AppendC(subitemPDU, subitemLen);
-				sb.push("\r\n"));
+				sb.push(".user = ");
+				sb.push(new TextDecoder().decode(reader.getU8Arr(subitemPDU.dataOfst, subitemPDU.contLen)));
+				sb.push("\r\n");
 			}
-			if ((subitemPDU = ASN1Util.pduGetItem(itemPDU, itemPDU + itemLen, "4", subitemLen, itemType)) != 0 && itemType == Net.ASN1Util.ItemType.IT_UTF8STRING)
+			if ((subitemPDU = ASN1Util.pduGetItem(reader, itemPDU.dataOfst, itemPDU.endOfst, "4")) != null && subitemPDU.itemType == ASN1ItemType.UTF8STRING)
 			{
 				sb.push(varName);
-				sb.push(".software = "));
-				sb->AppendC(subitemPDU, subitemLen);
-				sb.push("\r\n"));
+				sb.push(".software = ");
+				sb.push(new TextDecoder().decode(reader.getU8Arr(subitemPDU.dataOfst, subitemPDU.contLen)));
+				sb.push("\r\n");
 			}
 		}
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {string[]} sb
+	 * @param {string} varName
+	 */
 	static appendMSEnrollmentCSPProvider(reader, startOfst, endOfst, sb, varName)
 	{
-		Net.ASN1Util.ItemType itemType;
-		UOSInt itemLen;
-		const UInt8 *itemPDU;
-		if ((itemPDU = ASN1Util.pduGetItem(pdu, pduEnd, "1", itemLen, itemType)) != 0 && itemType == Net.ASN1Util.ItemType.IT_SEQUENCE)
+		let itemPDU;
+		if ((itemPDU = ASN1Util.pduGetItem(reader, startOfst, endOfst, "1")) != null && itemPDU.itemType == ASN1ItemType.SEQUENCE)
 		{
-			UOSInt subitemLen;
-			const UInt8 *subitemPDU;
-			if ((subitemPDU = ASN1Util.pduGetItem(itemPDU, itemPDU + itemLen, "1", subitemLen, itemType)) != 0 && itemType == Net.ASN1Util.ItemType.IT_INTEGER)
+			let subitemPDU;
+			if ((subitemPDU = ASN1Util.pduGetItem(reader, itemPDU.dataOfst, itemPDU.endOfst, "1")) != null && subitemPDU.itemType == ASN1ItemType.INTEGER)
 			{
 				sb.push(varName);
-				sb.push(".unknown = "));
-				Net.ASN1Util.IntegerToString(subitemPDU, subitemLen, sb);
-				sb.push("\r\n"));
+				sb.push(".unknown = ");
+				sb.push(ASN1Util.integerToString(reader, subitemPDU.dataOfst, subitemPDU.contLen));
+				sb.push("\r\n");
 			}
-			if ((subitemPDU = ASN1Util.pduGetItem(itemPDU, itemPDU + itemLen, "2", subitemLen, itemType)) != 0 && itemType == Net.ASN1Util.ItemType.IT_BMPSTRING)
+			if ((subitemPDU = ASN1Util.pduGetItem(reader, itemPDU.dataOfst, itemPDU.endOfst, "2")) != null && subitemPDU.itemType == ASN1ItemType.BMPSTRING)
 			{
+				let enc = new text.UTF16BETextBinEnc();
 				sb.push(varName);
-				sb.push(".provider = "));
-				sb->AppendUTF16BE(subitemPDU, subitemLen >> 1);
-				sb.push("\r\n"));
+				sb.push(".provider = ");
+				sb.push(enc.encodeBin(reader.getU8Arr(subitemPDU.dataOfst, subitemPDU.contLen)));
+				sb.push("\r\n");
 			}
 		}
-	}*/
+	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {any} sb
+	 * @param {string} varName
+	 */
 	static appendGeneralNames(reader, startOfst, endOfst, sb, varName)
 	{
 		let itemPDU;
@@ -1637,6 +1892,14 @@ export class X509File extends ASN1Data
 		}
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {string} path
+	 * @param {string[]} sb
+	 * @param {string} varName
+	 */
 	static appendGeneralName(reader, startOfst, endOfst, path, sb, varName)
 	{
 		let subItemPDU;
@@ -1694,7 +1957,7 @@ export class X509File extends ASN1Data
 				{
 					sb.push(net.getIPv4Name(reader.readInt32(subItemPDU.dataOfst, false)));
 				}
-				else if (subItemLen == 16)
+				else if (subItemPDU.contLen == 16)
 				{
 /*					Net.SocketUtil.AddressInfo addr;
 					Net.SocketUtil.SetAddrInfoV6(addr, subItemPDU, 0);
@@ -1721,6 +1984,14 @@ export class X509File extends ASN1Data
 		return false;
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {string} path
+	 * @param {string[]} sb
+	 * @param {string} varName
+	 */
 	static appendDistributionPoint(reader, startOfst, endOfst, path, sb, varName)
 	{
 		let itemPDU;
@@ -1754,7 +2025,7 @@ export class X509File extends ASN1Data
 								if (v & 0x2) sb.push("certificateHold");
 								if (v & 0x1) sb.push("privilegeWithdrawn");
 							}
-							if (subItemLen >= 3)
+							if (subItemPDU.contLen >= 3)
 							{
 								let v = reader.readUInt8(subItemPDU.dataOfst + 2);
 								if (v & 0x80) sb.push("aACompromise");
@@ -1774,6 +2045,13 @@ export class X509File extends ASN1Data
 		return false;
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {any} sb
+	 * @param {string} varName
+	 */
 	static appendDistributionPointName(reader, startOfst, endOfst, sb, varName)
 	{
 		let i;
@@ -1795,6 +2073,14 @@ export class X509File extends ASN1Data
 		}
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {string} path
+	 * @param {string[]} sb
+	 * @param {any} varName
+	 */
 	static appendPolicyInformation(reader, startOfst, endOfst, path, sb, varName)
 	{
 		let itemPDU;
@@ -1838,7 +2124,7 @@ export class X509File extends ASN1Data
 							sb.push(reader.readUTF8(itemPDU.dataOfst, itemPDU.contLen));
 							sb.push("\r\n");
 						}
-						else if (itemType == ASN1ItemType.SEQUENCE)
+						else if (itemPDU.itemType == ASN1ItemType.SEQUENCE)
 						{
 							/////////////////////////////////// UserNotice
 						}
@@ -1850,6 +2136,13 @@ export class X509File extends ASN1Data
 		return false;
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {string[]} sb
+	 * @param {string} varName
+	 */
 	static appendPKCS7SignedData(reader, startOfst, endOfst, sb, varName)
 	{
 		let itemPDU = ASN1Util.pduGetItem(reader, startOfst, endOfst, "1");
@@ -1872,23 +2165,30 @@ export class X509File extends ASN1Data
 			}
 			let i = 4;
 			subItemPDU = ASN1Util.pduGetItem(reader, itemPDU.dataOfst, itemPDU.endOfst, "4");
-			if (subItemPDU != 0 && subItemPDU.itemType == ASN1ItemType.CONTEXT_SPECIFIC_0)
+			if (subItemPDU != null && subItemPDU.itemType == ASN1ItemType.CONTEXT_SPECIFIC_0)
 			{
 				X509File.appendCertificate(reader, subItemPDU.dataOfst, subItemPDU.endOfst, "1", sb, "signedData.certificates");
 				subItemPDU = ASN1Util.pduGetItem(reader, itemPDU.dataOfst, itemPDU.endOfst, (++i).toString());
 			}
-			if (subItemPDU != 0 && subItemPDU.itemType == ASN1ItemType.CONTEXT_SPECIFIC_1)
+			if (subItemPDU != null && subItemPDU.itemType == ASN1ItemType.CONTEXT_SPECIFIC_1)
 			{
 				//AppendCertificate(subItemPDU, subItemPDU + subItemLen, "1", sb, CSTR("signedData.crls"));
 				subItemPDU = ASN1Util.pduGetItem(reader, itemPDU.dataOfst, itemPDU.endOfst, (++i).toString());
 			}
-			if (subItemPDU != 0 && subItemPDU.itemType == ASN1ItemType.SET)
+			if (subItemPDU != null && subItemPDU.itemType == ASN1ItemType.SET)
 			{
 				X509File.appendPKCS7SignerInfos(reader, subItemPDU.dataOfst, subItemPDU.endOfst, sb, "signedData.signerInfos");
 			}
 		}
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {any} sb
+	 * @param {string} varName
+	 */
 	static appendPKCS7DigestAlgorithmIdentifiers(reader, startOfst, endOfst, sb, varName)
 	{
 		let itemPDU;
@@ -1906,6 +2206,13 @@ export class X509File extends ASN1Data
 		}
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {any} sb
+	 * @param {string} varName
+	 */
 	static appendPKCS7SignerInfos(reader, startOfst, endOfst, sb, varName)
 	{
 		let itemPDU;
@@ -1924,6 +2231,13 @@ export class X509File extends ASN1Data
 		}
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {string[]} sb
+	 * @param {string} varName
+	 */
 	static appendPKCS7SignerInfo(reader, startOfst, endOfst, sb, varName)
 	{
 		let i;
@@ -1971,6 +2285,13 @@ export class X509File extends ASN1Data
 		}
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {string[]} sb
+	 * @param {string} varName
+	 */
 	static appendIssuerAndSerialNumber(reader, startOfst, endOfst, sb, varName)
 	{
 		let itemPDU;
@@ -1987,6 +2308,13 @@ export class X509File extends ASN1Data
 		}
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {string[]} sb
+	 * @param {string} varName
+	 */
 	static appendPKCS7Attributes(reader, startOfst, endOfst, sb, varName)
 	{
 		let itemPDU;
@@ -2077,6 +2405,14 @@ export class X509File extends ASN1Data
 		}
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {string} path
+	 * @param {string[]} sb
+	 * @param {string} varName
+	 */
 	static appendMacData(reader, startOfst, endOfst, path, sb, varName)
 	{
 		let itemPDU;
@@ -2106,6 +2442,13 @@ export class X509File extends ASN1Data
 		return false;
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {string[]} sb
+	 * @param {string} varName
+	 */
 	static appendDigestInfo(reader, startOfst, endOfst, sb, varName)
 	{
 		let itemPDU;
@@ -2122,6 +2465,14 @@ export class X509File extends ASN1Data
 		}
 	}
 
+	/**
+	 * @param {any} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {any} sb
+	 * @param {string} varName
+	 * @param {any} dataType
+	 */
 	static appendData(reader, startOfst, endOfst, sb, varName, dataType)
 	{
 		switch (dataType)
@@ -2135,6 +2486,14 @@ export class X509File extends ASN1Data
 		}
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {string[]} sb
+	 * @param {string} varName
+	 * @param {any} dataType
+	 */
 	static appendEncryptedData(reader, startOfst, endOfst, sb, varName, dataType)
 	{
 		let itemPDU;
@@ -2170,6 +2529,13 @@ export class X509File extends ASN1Data
 		}
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {any} sb
+	 * @param {string} varName
+	 */
 	static appendAuthenticatedSafe(reader, startOfst, endOfst, sb, varName)
 	{
 		let itemPDU;
@@ -2187,10 +2553,18 @@ export class X509File extends ASN1Data
 		}
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {string[]} sb
+	 * @param {string} varName
+	 * @param {any} dataType
+	 */
 	static appendEncryptedContentInfo(reader, startOfst, endOfst, sb, varName, dataType)
 	{
 		let itemPDU;
-		if ((itemPDU = ASN1Util.pduGetItem(reader, startOfst, endOfst, "1")) != 0 && itemPDU.itemType == ASN1ItemType.OID)
+		if ((itemPDU = ASN1Util.pduGetItem(reader, startOfst, endOfst, "1")) != null && itemPDU.itemType == ASN1ItemType.OID)
 		{
 			sb.push(varName);
 			sb.push(".contentType = ");
@@ -2202,7 +2576,7 @@ export class X509File extends ASN1Data
 			}
 			sb.push("\r\n");
 		}
-		if ((itemPDU = ASN1Util.pduGetItem(reader, startOfst, endOfst, "2")) != 0 && itemPDU.itemType == ASN1ItemType.SEQUENCE)
+		if ((itemPDU = ASN1Util.pduGetItem(reader, startOfst, endOfst, "2")) != null && itemPDU.itemType == ASN1ItemType.SEQUENCE)
 		{
 			let name = "contentEncryptionAlgorithm";
 			if (varName)
@@ -2220,6 +2594,12 @@ export class X509File extends ASN1Data
 		}
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {string} oidText
+	 */
 	static nameGetByOID(reader, startOfst, endOfst, oidText)
 	{
 		if (!(reader instanceof data.ByteReader))
@@ -2260,11 +2640,21 @@ export class X509File extends ASN1Data
 		return null;
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 */
 	static nameGetCN(reader, startOfst, endOfst)
 	{
 		return X509File.nameGetByOID(reader, startOfst, endOfst, "2.5.4.3");
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 */
 	static namesGet(reader, startOfst, endOfst)
 	{
 		let names = {};
@@ -2281,7 +2671,7 @@ export class X509File extends ASN1Data
 	
 			if ((itemPDU = ASN1Util.pduGetItem(reader, startOfst, endOfst, i.toString()+".1")) != null)
 			{
-				if (itemType == ASN1ItemType.SEQUENCE)
+				if (itemPDU.itemType == ASN1ItemType.SEQUENCE)
 				{
 					oidPDU = ASN1Util.pduGetItem(reader, itemPDU.rawOfst + itemPDU.hdrLen, itemPDU.rawOfst + itemPDU.hdrLen + itemPDU.contLen, "1");
 					if (oidPDU != null && oidPDU.itemType == ASN1ItemType.OID)
@@ -2326,6 +2716,11 @@ export class X509File extends ASN1Data
 		return names;
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 */
 	static extensionsGet(reader, startOfst, endOfst)
 	{
 		let ext = {};
@@ -2358,6 +2753,9 @@ export class X509File extends ASN1Data
 							let oid = new Uint8Array(reader.getArrayBuffer(oidPDU.rawOfst + oidPDU.hdrLen, oidPDU.contLen));
 							if (ASN1Util.oidEqualsText(oid, "2.5.29.17")) //id-ce-subjectAltName
 							{
+								/**
+								 * @type {any[]}
+								 */
 								ext.subjectAltName = [];
 								let j = 0;
 								let k = ASN1Util.pduCountItem(reader, strPDU.rawOfst + strPDU.hdrLen, strPDU.rawOfst + strPDU.hdrLen + strPDU.contLen, "1");
@@ -2412,6 +2810,11 @@ export class X509File extends ASN1Data
 		return ext;
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 */
 	static extensionsGetCRLDistributionPoints(reader, startOfst, endOfst)
 	{
 		let ret = [];
@@ -2461,14 +2864,20 @@ export class X509File extends ASN1Data
 		return ret;
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {any[]} distPoints
+	 */
 	static distributionPointAdd(reader, startOfst, endOfst, distPoints)
 	{
 		let itemPDU;
 		if ((itemPDU = ASN1Util.pduGetItem(reader, startOfst, endOfst, "1")) != null && itemPDU.itemType == ASN1ItemType.CONTEXT_SPECIFIC_0)
 		{
-			if ((itemPDU = ASN1Util.pduGetItem(reader, itemPDU.rawOfst, itemPDU.hdrLen, itemPDU.rawOfst + itemPDU.hdrLen + itemPDU.contLen, "1")) != null && itemPDU.itemType == ASN1ItemType.CONTEXT_SPECIFIC_0)
+			if ((itemPDU = ASN1Util.pduGetItem(reader.getU8Arr(itemPDU.rawOfst), itemPDU.hdrLen, itemPDU.rawOfst + itemPDU.hdrLen + itemPDU.contLen, "1")) != null && itemPDU.itemType == ASN1ItemType.CONTEXT_SPECIFIC_0)
 			{
-				if ((itemPDU = ASN1Util.pduGetItem(reader, itemPDU.rawOfst, itemPDU.hdrLen, itemPDU.rawOfst + itemPDU.hdrLen + itemPDU.contLen, "1")) != null && itemPDU.itemType == ASN1ItemType.CHOICE_6)
+				if ((itemPDU = ASN1Util.pduGetItem(reader.getU8Arr(itemPDU.rawOfst), itemPDU.hdrLen, itemPDU.rawOfst + itemPDU.hdrLen + itemPDU.contLen, "1")) != null && itemPDU.itemType == ASN1ItemType.CHOICE_6)
 				{
 					distPoints.push(reader.readUTF8(itemPDU.rawOfst + itemPDU.hdrLen, itemPDU.contLen));
 					return true;
@@ -2478,6 +2887,11 @@ export class X509File extends ASN1Data
 		return false;
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 */
 	static publicKeyGetNew(reader, startOfst, endOfst)
 	{
 		let oidPDU = ASN1Util.pduGetItem(reader, startOfst, endOfst, "1.1");
@@ -2501,6 +2915,12 @@ export class X509File extends ASN1Data
 		return null;
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 * @param {number} keyType
+	 */
 	static keyGetLeng(reader, startOfst, endOfst, keyType)
 	{
 		let keyPDU;
@@ -2548,6 +2968,10 @@ export class X509File extends ASN1Data
 		}
 	}
 
+	/**
+	 * @param {ArrayBuffer | Iterable<number>} oid
+	 * @param {boolean} pubKey
+	 */
 	static keyTypeFromOID(oid, pubKey)
 	{
 		let arr = new Uint8Array(oid);
@@ -2569,6 +2993,11 @@ export class X509File extends ASN1Data
 		return KeyType.Unknown;
 	}
 
+	/**
+	 * @param {data.ByteReader} reader
+	 * @param {number} startOfst
+	 * @param {number} endOfst
+	 */
 	static algorithmIdentifierGet(reader, startOfst, endOfst)
 	{
 		let cnt = ASN1Util.pduCountItem(reader, startOfst, endOfst, null);
@@ -2627,6 +3056,10 @@ export class X509File extends ASN1Data
 
 export class X509Cert extends X509File
 {
+	/**
+	 * @param {string} sourceName
+	 * @param {ArrayBuffer} buff
+	 */
 	constructor(sourceName, buff)
 	{
 		super(sourceName, "application/x-pem-file", buff);
@@ -2698,6 +3131,9 @@ export class X509Cert extends X509File
 		return 1;
 	}
 
+	/**
+	 * @param {number} index
+	 */
 	getCertName(index)
 	{
 		if (index != 0)
@@ -2705,6 +3141,9 @@ export class X509Cert extends X509File
 		return this.getSubjectCN();
 	}
 
+	/**
+	 * @param {number} index
+	 */
 	getNewCert(index)
 	{
 		if (index != 0)
@@ -2903,7 +3342,7 @@ export class X509Cert extends X509File
 		{
 			return null;
 		}
-		if (pdu.itemType == ASN1Util.CONTEXT_SPECIFIC_0)
+		if (pdu.itemType == ASN1ItemType.CONTEXT_SPECIFIC_0)
 		{
 			pdu = ASN1Util.pduGetItem(this.reader, 0, this.reader.getLength(), "1.1.7");
 			if (pdu)
@@ -2972,6 +3411,9 @@ export class X509Cert extends X509File
 		return null;
 	}
 
+	/**
+	 * @param {string} domain
+	 */
 	domainValid(domain)
 	{
 		let valid = false;
@@ -3049,7 +3491,7 @@ export class X509Cert extends X509File
 			pdu = ASN1Util.pduGetItem(this.reader, 0, this.reader.getLength(), "1.1.8.1");
 			if (pdu)
 			{
-				return X509File.extensionsGetCRLDistributionPoints(reader, pdu.rawOfst + pdu.hdrLen, pdu.rawOfst + pdu.hdrLen + pdu.contLen);
+				return X509File.extensionsGetCRLDistributionPoints(this.reader, pdu.rawOfst + pdu.hdrLen, pdu.rawOfst + pdu.hdrLen + pdu.contLen);
 			}
 		}
 		else
@@ -3057,7 +3499,7 @@ export class X509Cert extends X509File
 			pdu = ASN1Util.pduGetItem(this.reader, 0, this.reader.getLength(), "1.1.7.1");
 			if (pdu)
 			{
-				return X509File.extensionsGetCRLDistributionPoints(reader, pdu.rawOfst + pdu.hdrLen, pdu.rawOfst + pdu.hdrLen + pdu.contLen);
+				return X509File.extensionsGetCRLDistributionPoints(this.reader, pdu.rawOfst + pdu.hdrLen, pdu.rawOfst + pdu.hdrLen + pdu.contLen);
 			}
 		}
 		return [];
@@ -3118,6 +3560,10 @@ export class X509Cert extends X509File
 
 export class X509CertReq extends X509File
 {
+	/**
+	 * @param {string} sourceName
+	 * @param {ArrayBuffer} buff
+	 */
 	constructor(sourceName, buff)
 	{
 		super(sourceName, "application/x-pem-file", buff);
@@ -3237,6 +3683,11 @@ export class X509CertReq extends X509File
 
 export class X509Key extends X509File
 {
+	/**
+	 * @param {string} sourceName
+	 * @param {ArrayBuffer} buff
+	 * @param {number} keyType
+	 */
 	constructor(sourceName, buff, keyType)
 	{
 		super(sourceName, "application/x-pem-file", buff);
@@ -3487,7 +3938,7 @@ export class X509Key extends X509File
 
 	getRSAPrivateExponent()
 	{
-		if (this.keyType != KeyType.RSA) return 0;
+		if (this.keyType != KeyType.RSA) return null;
 		let len = ASN1Util.pduGetItem(this.reader, 0, this.reader.getLength(), "1.4");
 		if (len)
 		{
@@ -3498,7 +3949,7 @@ export class X509Key extends X509File
 
 	getRSAPrime1()
 	{
-		if (this.keyType != KeyType.RSA) return 0;
+		if (this.keyType != KeyType.RSA) return null;
 		let len = ASN1Util.pduGetItem(this.reader, 0, this.reader.getLength(), "1.5");
 		if (len)
 		{
@@ -3509,7 +3960,7 @@ export class X509Key extends X509File
 
 	getRSAPrime2()
 	{
-		if (this.keyType != KeyType.RSA) return 0;
+		if (this.keyType != KeyType.RSA) return null;
 		let len = ASN1Util.pduGetItem(this.reader, 0, this.reader.getLength(), "1.6");
 		if (len)
 		{
@@ -3520,7 +3971,7 @@ export class X509Key extends X509File
 
 	getRSAExponent1()
 	{
-		if (this.keyType != KeyType.RSA) return 0;
+		if (this.keyType != KeyType.RSA) return null;
 		let len = ASN1Util.pduGetItem(this.reader, 0, this.reader.getLength(), "1.7");
 		if (len)
 		{
@@ -3531,7 +3982,7 @@ export class X509Key extends X509File
 
 	getRSAExponent2()
 	{
-		if (this.keyType != KeyType.RSA) return 0;
+		if (this.keyType != KeyType.RSA) return null;
 		let len = ASN1Util.pduGetItem(this.reader, 0, this.reader.getLength(), "1.8");
 		if (len)
 		{
@@ -3542,7 +3993,7 @@ export class X509Key extends X509File
 
 	getRSACoefficient()
 	{
-		if (this.keyType != KeyType.RSA) return 0;
+		if (this.keyType != KeyType.RSA) return null;
 		let len = ASN1Util.pduGetItem(this.reader, 0, this.reader.getLength(), "1.9");
 		if (len)
 		{
@@ -3578,7 +4029,7 @@ export class X509Key extends X509File
 			{
 				return this.reader.getArrayBuffer(itemPDU.rawOfst + itemPDU.hdrLen + 1, itemPDU.contLen - 1);
 			}
-			return 0;
+			return null;
 		}
 		else if (this.keyType == KeyType.ECDSA)
 		{
@@ -3590,7 +4041,7 @@ export class X509Key extends X509File
 				{
 					return this.reader.getArrayBuffer(itemPDU.rawOfst + itemPDU.hdrLen + 1, itemPDU.contLen - 1);
 				}
-				return 0;
+				return null;
 			}
 			itemPDU = ASN1Util.pduGetItem(this.reader, 0, this.reader.getLength(), "1.4");
 			if (itemPDU != null && itemPDU.itemType == ASN1ItemType.CONTEXT_SPECIFIC_1)
@@ -3600,13 +4051,13 @@ export class X509Key extends X509File
 				{
 					return this.reader.getArrayBuffer(itemPDU.rawOfst + itemPDU.hdrLen + 1, itemPDU.contLen - 1);
 				}
-				return 0;
+				return null;
 			}
-			return 0;
+			return null;
 		}
 		else
 		{
-			return 0;
+			return null;
 		}
 	}
 
@@ -3635,6 +4086,10 @@ export class X509Key extends X509File
 		return ECName.Unknown;		
 	}
 
+	/**
+	 * @param {ArrayBuffer} buff
+	 * @param {ArrayBuffer} paramOID
+	 */
 	static fromECPublicKey(buff, paramOID)
 	{
 		let pdu = new ASN1PDUBuilder();
@@ -3651,6 +4106,10 @@ export class X509Key extends X509File
 
 export class X509PrivKey extends X509File
 {
+	/**
+	 * @param {string} sourceName
+	 * @param {ArrayBuffer} buff
+	 */
 	constructor(sourceName, buff)
 	{
 		super(sourceName, "application/x-pem-file", buff);
@@ -3668,14 +4127,14 @@ export class X509PrivKey extends X509File
 		{
 			return "";
 		}
-		let keyType = X509File.keyTypeFromOID(reader.getArrayBuffer(oidPDU.dataOfst, oidPDU.contLen), false);
+		let keyType = X509File.keyTypeFromOID(this.reader.getArrayBuffer(oidPDU.dataOfst, oidPDU.contLen), false);
 		let keyPDU = ASN1Util.pduGetItem(this.reader, 0, this.reader.getLength(), "1.3");
 		if (keyPDU && keyPDU.itemType == ASN1ItemType.OCTET_STRING)
 		{
 			let sb = [];
 			sb.push(keyTypeGetName(keyType));
 			sb.push(' ');
-			sb.push(X509File.keyGetLeng(reader, keyPDU.dataOfst, keyPDU.endOfst, keyType));
+			sb.push(X509File.keyGetLeng(this.reader, keyPDU.dataOfst, keyPDU.endOfst, keyType));
 			sb.push(" bits");
 			return sb.join("");
 		}
@@ -3735,6 +4194,11 @@ export class X509PrivKey extends X509File
 		return null;
 	}
 
+	/**
+	 * @param {any} keyType
+	 * @param {string | ArrayBuffer} buff
+	 * @param {string | null} sourceName
+	 */
 	static createFromKeyBuff(keyType, buff, sourceName)
 	{
 		if (sourceName == null)
@@ -3754,6 +4218,9 @@ export class X509PrivKey extends X509File
 		return new X509PrivKey(sourceName, keyPDU.getArrayBuffer());
 	}
 
+	/**
+	 * @param {{ getKeyType: () => any; getECName: () => any; getECPrivate: () => any; getECPublic: () => any; sourceName: any; getASN1Buff: () => { (): any; new (): any; getArrayBuffer: { (): any; new (): any; }; }; }} key
+	 */
 	static createFromKey(key)
 	{
 		if (!(key instanceof X509Key))
@@ -3776,7 +4243,14 @@ export class X509PrivKey extends X509File
 			keyPDU.beginSequence();
 			keyPDU.appendInt32(1);
 			keyBuff = key.getECPrivate();
-			keyPDU.appendOctetString(keyBuff);
+			if (keyBuff)
+			{
+				keyPDU.appendOctetString(keyBuff);
+			}
+			else
+			{
+				keyPDU.appendOctetString(new Uint8Array().buffer);
+			}
 			keyBuff = key.getECPublic();
 			if (keyBuff)
 			{
@@ -3802,6 +4276,10 @@ export class X509PrivKey extends X509File
 
 export class X509PubKey extends X509File
 {
+	/**
+	 * @param {string} sourceName
+	 * @param {ArrayBuffer} buff
+	 */
 	constructor(sourceName, buff)
 	{
 		super(sourceName, "application/x-pem-file", buff);
@@ -3819,13 +4297,13 @@ export class X509PubKey extends X509File
 		{
 			return null;
 		}
-		let keyType = X509File.keyTypeFromOID(reader.getArrayBuffer(oidPDU.rawOfst + oidPDU.hdrLen, oidPDU.contLen), true);
+		let keyType = X509File.keyTypeFromOID(this.reader.getArrayBuffer(oidPDU.rawOfst + oidPDU.hdrLen, oidPDU.contLen), true);
 		let keyPDU = ASN1Util.pduGetItem(this.reader, 0, this.reader.getLength(), "1.2");
 		if (keyPDU && keyPDU.itemType == ASN1ItemType.OCTET_STRING)
 		{
 			let sb = [];
 			sb.push(keyTypeGetName(keyType)+" ");
-			sb.push(keyGetLeng(reader, keyPDU.rawOfst + keyPDU.hdrLen, keyPDU.rawOfst + keyPDU.hdrLen + keyPDU.contLen, keyType));
+			sb.push(X509File.keyGetLeng(this.reader, keyPDU.rawOfst + keyPDU.hdrLen, keyPDU.rawOfst + keyPDU.hdrLen + keyPDU.contLen, keyType));
 			sb.push(" bits");
 			return sb.join("");
 		}
@@ -3873,6 +4351,11 @@ export class X509PubKey extends X509File
 		return null;
 	}
 
+	/**
+	 * @param {number} keyType
+	 * @param {ArrayBuffer} buff
+	 * @param {any} sourceName
+	 */
 	static createFromKeyBuff(keyType, buff, sourceName)
 	{
 		let keyPDU = new ASN1PDUBuilder();
@@ -3894,14 +4377,21 @@ export class X509PubKey extends X509File
 		return new X509PubKey(sourceName, keyPDU.getArrayBuffer());
 	}
 
+	/**
+	 * @param {{ getKeyType: () => any; getASN1Buff: () => { (): any; new (): any; getArrayBuffer: { (): any; new (): any; }; }; sourceName: any; }} key
+	 */
 	static createFromKey(key)
 	{
-		return createFromKeyBuff(key.getKeyType(), key.getASN1Buff().getArrayBuffer(), key.sourceName);
+		return X509PubKey.createFromKeyBuff(key.getKeyType(), key.getASN1Buff().getArrayBuffer(), key.sourceName);
 	}
 }
 
 export class X509PKCS7 extends X509File
 {
+	/**
+	 * @param {string} sourceName
+	 * @param {ArrayBuffer} buff
+	 */
 	constructor(sourceName, buff)
 	{
 		super(sourceName, "application/x-pem-file", buff);
@@ -3926,6 +4416,9 @@ export class X509PKCS7 extends X509File
 		return ASN1Util.pduCountItem(this.reader, certListPDU.dataOfst, certListPDU.endOfst, null);
 	}
 
+	/**
+	 * @param {number} index
+	 */
 	getCertName(index)
 	{
 		let certListPDU = ASN1Util.pduGetItem(this.reader, 0, this.reader.getLength(), "1.2.1.4");
@@ -3950,6 +4443,9 @@ export class X509PKCS7 extends X509File
 		return null;
 	}
 
+	/**
+	 * @param {number} index
+	 */
 	getNewCert(index)
 	{
 		let certListPDU = ASN1Util.pduGetItem(this.reader, 0, this.reader.getLength(), "1.2.1.4");
@@ -3997,7 +4493,7 @@ export class X509PKCS7 extends X509File
 		{
 			return false;
 		}
-		return ASN1Util.oidEqualsText(reader.getU8Arr(itemPDU.dataOfst, itemPDU.contLen), "1.2.840.113549.1.7.2");	
+		return ASN1Util.oidEqualsText(this.reader.getU8Arr(itemPDU.dataOfst, itemPDU.contLen), "1.2.840.113549.1.7.2");	
 	}
 
 	getDigestType()
@@ -4053,6 +4549,10 @@ export class X509PKCS7 extends X509File
 
 export class X509PKCS12 extends X509File
 {
+	/**
+	 * @param {string} sourceName
+	 * @param {ArrayBuffer} buff
+	 */
 	constructor(sourceName, buff)
 	{
 		super(sourceName, "application/x-pem-file", buff);
@@ -4072,11 +4572,17 @@ export class X509PKCS12 extends X509File
 		return 0;
 	}
 
+	/**
+	 * @param {any} index
+	 */
 	getCertName(index)
 	{
 		return null;
 	}
 
+	/**
+	 * @param {any} index
+	 */
 	getNewCert(index)
 	{
 		return null;
@@ -4110,6 +4616,10 @@ export class X509PKCS12 extends X509File
 
 export class X509FileList extends X509File
 {
+	/**
+	 * @param {string} sourceName
+	 * @param {{ reader: { getArrayBuffer: () => any; }; }} cert
+	 */
 	constructor(sourceName, cert)
 	{
 		super(sourceName, "application/x-pem-file", cert.reader.getArrayBuffer());
@@ -4137,6 +4647,9 @@ export class X509FileList extends X509File
 		return ret;
 	}
 
+	/**
+	 * @param {number} index
+	 */
 	getCertName(index)
 	{
 		let i;
@@ -4155,6 +4668,9 @@ export class X509FileList extends X509File
 		return null;
 	}
 
+	/**
+	 * @param {number} index
+	 */
 	getNewCert(index)
 	{
 		let i;
@@ -4193,7 +4709,7 @@ export class X509FileList extends X509File
 		}
 		else
 		{
-			return this.fileList[0],isValid();
+			return this.fileList[0].isValid();
 		}		
 	}
 
@@ -4231,6 +4747,9 @@ export class X509FileList extends X509File
 		return this.fileList[0].createNames();
 	}
 
+	/**
+	 * @param {any} file
+	 */
 	addFile(file)
 	{
 		this.fileList.push(file);
@@ -4241,6 +4760,9 @@ export class X509FileList extends X509File
 		return this.fileList.length;
 	}
 
+	/**
+	 * @param {string | number} index
+	 */
 	getFile(index)
 	{
 		return this.fileList[index];
@@ -4249,7 +4771,7 @@ export class X509FileList extends X509File
 	setDefaultSourceName()
 	{
 		let file;
-		let j = INVALID_INDEX;
+		let j = -1;
 		let i = this.fileList.length;
 		while (i-- > 0)
 		{
@@ -4259,7 +4781,7 @@ export class X509FileList extends X509File
 				j = i;
 			}
 		}
-		if (j != INVALID_INDEX)
+		if (j != -1)
 		{
 			this.setSourceName(this.fileList[j].sourceName);
 		}
@@ -4268,6 +4790,10 @@ export class X509FileList extends X509File
 
 export class X509CRL extends X509File
 {
+	/**
+	 * @param {string} sourceName
+	 * @param {ArrayBuffer} buff
+	 */
 	constructor(sourceName, buff)
 	{
 		super(sourceName, "application/x-pem-file", buff);
@@ -4283,14 +4809,14 @@ export class X509CRL extends X509File
 		let tmpBuff = ASN1Util.pduGetItem(this.reader, 0, this.reader.getLength(), "1.1.3");
 		if (tmpBuff != null && tmpBuff.itemType == ASN1ItemType.SEQUENCE)
 		{
-			return X509File.nameGetCN(reader, tmpBuff.dataOfst, tmpBuff.endOfst);
+			return X509File.nameGetCN(this.reader, tmpBuff.dataOfst, tmpBuff.endOfst);
 		}
 		else
 		{
 			tmpBuff = ASN1Util.pduGetItem(this.reader, 0, this.reader.getLength(), "1.1.2");
 			if (tmpBuff != null && tmpBuff.itemType == ASN1ItemType.SEQUENCE)
 			{
-				return X509File.nameGetCN(reader, tmpBuff.dataOfst, tmpBuff.endOfst);
+				return X509File.nameGetCN(this.reader, tmpBuff.dataOfst, tmpBuff.endOfst);
 			}
 		}
 		return "";
@@ -4372,7 +4898,7 @@ export class X509CRL extends X509File
 	hasVersion()
 	{
 		let itemPDU;
-		if ((itemPDU = ASN1Util.pduGetItem(this.reader, 0, this.reader.getLength(), "1.1.1") != null) && itemPDU.itemType == ASN1ItemType.INTEGER)
+		if ((itemPDU = ASN1Util.pduGetItem(this.reader, 0, this.reader.getLength(), "1.1.1")) != null && itemPDU.itemType == ASN1ItemType.INTEGER)
 		{
 			return true;
 		}
@@ -4392,7 +4918,7 @@ export class X509CRL extends X509File
 		}
 		if (tmpBuff != null && tmpBuff.itemType == ASN1ItemType.SEQUENCE)
 		{
-			return X509File.nameGetCN(reader, tmpBuff.dataOfst, tmpBuff.endOfst);
+			return X509File.nameGetCN(this.reader, tmpBuff.dataOfst, tmpBuff.endOfst);
 		}
 		else
 		{
@@ -4413,7 +4939,7 @@ export class X509CRL extends X509File
 		}
 		if (itemPDU != null && (itemPDU.itemType == ASN1ItemType.UTCTIME || itemPDU.itemType == ASN1ItemType.GENERALIZEDTIME))
 		{
-			return ASN1Util.pduParseUTCTimeCont(reader, itemPDU.dataOfst, itemPDU.endOfst);
+			return ASN1Util.pduParseUTCTimeCont(this.reader, itemPDU.dataOfst, itemPDU.endOfst);
 		}
 		else
 		{
@@ -4434,7 +4960,7 @@ export class X509CRL extends X509File
 		}
 		if (itemPDU != null && (itemPDU.itemType == ASN1ItemType.UTCTIME || itemPDU.itemType == ASN1ItemType.GENERALIZEDTIME))
 		{
-			return ASN1Util.pduParseUTCTimeCont(reader, itemPDU.dataOfst, itemPDU.endOfst);
+			return ASN1Util.pduParseUTCTimeCont(this.reader, itemPDU.dataOfst, itemPDU.endOfst);
 		}
 		else
 		{
@@ -4442,6 +4968,9 @@ export class X509CRL extends X509File
 		}
 	}
 
+	/**
+	 * @param {{ getSerialNumber: () => any; }} cert
+	 */
 	isRevoked(cert)
 	{
 		let sn = cert.getSerialNumber();
@@ -4476,10 +5005,10 @@ export class X509CRL extends X509File
 		while (true)
 		{
 			let subitemPDU;
-			subitemPDU = ASN1Util.pduGetItem(reader, itemPDU.dataOfst, itemPDU.endOfst, (++i)+".1");
+			subitemPDU = ASN1Util.pduGetItem(this.reader, itemPDU.dataOfst, itemPDU.endOfst, (++i)+".1");
 			if (subitemPDU == null)
 				break;
-			if (subitemPDU.itemType == ASN1ItemType.INTEGER && data.arrayBufferEquals(reader.getArrayBuffer(subitemPDU.dataOfst, subitemPDU.contLen), sn))
+			if (subitemPDU.itemType == ASN1ItemType.INTEGER && data.arrayBufferEquals(this.reader.getArrayBuffer(subitemPDU.dataOfst, subitemPDU.contLen), sn))
 			{
 				return true;
 			}
@@ -4488,6 +5017,9 @@ export class X509CRL extends X509File
 	}
 }
 
+/**
+ * @param {string} algType
+ */
 export function algTypeGetHash(algType)
 {
 	switch (algType)
@@ -4516,6 +5048,9 @@ export function algTypeGetHash(algType)
 	}
 }
 
+/**
+ * @param {any} fileType
+ */
 export function fileTypeGetName(fileType)
 {
 	switch (fileType)
@@ -4543,6 +5078,9 @@ export function fileTypeGetName(fileType)
 	}
 }
 
+/**
+ * @param {number} keyType
+ */
 export function keyTypeGetName(keyType)
 {
 	switch (keyType)
@@ -4565,6 +5103,33 @@ export function keyTypeGetName(keyType)
 	}
 }
 
+/**
+ * @param {any} keyType
+ */
+export function keyTypeGetOID(keyType)
+{
+	switch (keyType)
+	{
+	case KeyType.RSA:
+		return "1.2.840.113549.1.1.1";
+	case KeyType.DSA:
+		return "1.2.840.10040.4.1";
+	case KeyType.ECDSA:
+		return "1.2.840.10045.2.1";
+	case KeyType.ED25519:
+		return "1.3.101.112";
+	case KeyType.ECPublic:
+		return "1.2.840.10045.2.1";
+	case KeyType.RSAPublic:
+	case KeyType.Unknown:
+	default:
+		return "1.2.840.113549.1.1.1";
+	}
+}
+
+/**
+ * @param {number} ecName
+ */
 export function ecNameGetName(ecName)
 {
 	switch (ecName)
@@ -4581,6 +5146,9 @@ export function ecNameGetName(ecName)
 	}
 }
 
+/**
+ * @param {number} ecName
+ */
 export function ecNameGetOID(ecName)
 {
 	switch (ecName)
@@ -4597,6 +5165,9 @@ export function ecNameGetOID(ecName)
 	}
 }
 
+/**
+ * @param {ArrayBuffer | Iterable<number>} buff
+ */
 export function ecNameFromOID(buff)
 {
 	let arr = new Uint8Array(buff);
@@ -4613,4 +5184,32 @@ export function ecNameFromOID(buff)
 		return ECName.secp521r1;
 	}
 	return ECName.Unknown;
-}
+}
+
+/**
+ * @param {Uint8Array | number[]} oid
+ */
+export function hashTypeFromOID(oid)
+{
+	if (ASN1Util.oidEqualsText(oid, "2.16.840.1.101.3.4.2.1"))
+	{
+		return hash.HashType.SHA256;
+	}
+	else if (ASN1Util.oidEqualsText(oid, "2.16.840.1.101.3.4.2.2"))
+	{
+		return hash.HashType.SHA384;
+	}
+	else if (ASN1Util.oidEqualsText(oid, "2.16.840.1.101.3.4.2.3"))
+	{
+		return hash.HashType.SHA512;
+	}
+	else if (ASN1Util.oidEqualsText(oid, "2.16.840.1.101.3.4.2.4"))
+	{
+		return hash.HashType.SHA224;
+	}
+	else if (ASN1Util.oidEqualsText(oid, "1.3.14.3.2.26"))
+	{
+		return hash.HashType.SHA1;
+	}
+	return hash.HashType.Unknown;
+}