void encode()
{
List <Byte> rawData = new List <Byte>(IssuerName.RawData);
rawData.AddRange(Asn1Utils.Encode(AsnFormatter.StringToBinary(SerialNumber, EncodingType.HexRaw), 4));
RawData = rawData.ToArray();
}
void encode()
{
var rawData = new List <Byte>(IssuerName.RawData);
rawData.AddRange(Asn1Utils.Encode(AsnFormatter.StringToBinary(SerialNumber, EncodingType.HexRaw), (Byte)Asn1Type.INTEGER));
_rawData.AddRange(Asn1Utils.Encode(rawData.ToArray(), 48));
}
static IntPtr get_thumbptr(String thumbprint)
{
Byte[] thBytes = AsnFormatter.StringToBinary(thumbprint, EncodingType.HexAny);
IntPtr thumbPtr = Marshal.AllocHGlobal(thBytes.Length);
Marshal.Copy(thBytes, 0, thumbPtr, thBytes.Length);
return(thumbPtr);
}
void initializeFromKeyId(String keyId, Boolean critical)
{
Oid = _oid;
Critical = critical;
IncludedComponents = AuthorityKeyIdentifierFlags.KeyIdentifier;
Byte[] keyIdBytes = AsnFormatter.StringToBinary(keyId);
KeyIdentifier = AsnFormatter.BinaryToString(keyIdBytes, EncodingType.HexRaw, EncodingFormat.NOCRLF);
RawData = Asn1Utils.Encode(AsnFormatter.StringToBinary(keyId, EncodingType.Hex), 0x80);
RawData = Asn1Utils.Encode(RawData, 48);
}
void generateSerialNumber()
{
if (String.IsNullOrWhiteSpace(SerialNumber))
{
using (MD5 hasher = MD5.Create()) {
serialNumber = hasher.ComputeHash(Guid.NewGuid().ToByteArray());
}
}
else
{
serialNumber = AsnFormatter.StringToBinary(SerialNumber, EncodingType.Hex);
}
}
/// <summary>
/// Encodes current instance of CTL entry to ASN.1-encoded byte array.
/// </summary>
/// <returns>
/// ASN.1-encoded byte array.
/// </returns>
public Byte[] Encode()
{
Byte[] thumbBytes = AsnFormatter.StringToBinary(Thumbprint, EncodingType.HexRaw);
var retValue = new List <Byte>(Asn1Utils.Encode(thumbBytes, (Byte)Asn1Type.OCTET_STRING));
if (_attributes.Count == 0)
{
return(Asn1Utils.Encode(retValue.ToArray(), 48));
}
var asn = new Asn1Reader(Attributes.Encode());
retValue.AddRange(Asn1Utils.Encode(asn.GetPayload(), 49));
return(Asn1Utils.Encode(retValue.ToArray(), 48));
}
/// <summary>
/// Converts input string to a byte array. See <strong>Remarks</strong> for more details.
/// </summary>
/// <param name="anyString">
/// A string encoded in Base64, hex or binary text.
/// </param>
/// <exception cref="Win32Exception">If the input string cannot be recognized and/or decoded.</exception>
/// <exception cref="ArgumentNullException">Input string is null or empty.</exception>
/// <returns>Decoded bytes</returns>
/// <remarks>
/// This method is used to decode cryptographic messages formatted in various ways, such Base64 with or
/// without headers, hex string, with or without address and ASCII panels or pure binary text.
/// <para>This method attempts to decode string in the following order:</para>
/// <list type="bullet">
/// <item>CRYPT_STRING_HEXADDR</item>
/// <item>CRYPT_STRING_HEXASCIIADDR</item>
/// <item>CRYPT_STRING_HEX</item>
/// <item>CRYPT_STRING_HEXRAW</item>
/// <item>CRYPT_STRING_HEXASCII</item>
/// <item>CRYPT_STRING_BASE64HEADER</item>
/// <item>CRYPT_STRING_BASE64</item>
/// <item>CRYPT_STRING_BINARY</item>
/// </list>
/// </remarks>
public static Byte[] AnyToBinary(String anyString)
{
if (String.IsNullOrEmpty(anyString))
{
throw new ArgumentNullException(nameof(anyString));
}
try {
return(AsnFormatter.StringToBinary(anyString, EncodingType.HexAny));
} catch {
try {
return(AsnFormatter.StringToBinary(anyString, EncodingType.Base64Any));
} catch {
return(AsnFormatter.StringToBinary(anyString, EncodingType.Binary));
}
}
}
public static IEnumerable <Byte> AnyToBinary(String anyString)
{
try {
return(AsnFormatter.StringToBinary(anyString, EncodingType.HexAny));
} catch {
try {
return(AsnFormatter.StringToBinary(anyString, EncodingType.StringAny));
} catch {
try {
return(AsnFormatter.StringToBinary(anyString, EncodingType.Binary));
} catch {
Tools.MsgBox("Error", "The data is invalid");
return(null);
}
}
}
}
/// <summary>
/// Encodes current object to an ASN.1 format.
/// </summary>
/// <returns>ASN.1-encoded byte array that represents current object.</returns>
public Byte[] Encode()
{
var retValue = new List <Byte>();
switch (Type)
{
case SubjectIdentifierType.IssuerAndSerialNumber:
retValue.AddRange(((X509IssuerSerial)Value).RawData);
break;
case SubjectIdentifierType.SubjectKeyIdentifier:
retValue.AddRange(Asn1Utils.Encode(AsnFormatter.StringToBinary(Value.ToString(), EncodingType.HexRaw), 0x80));
break;
default:
throw new ArgumentException("Invalid CMS issuer identifier type.");
}
return(retValue.ToArray());
}
/// <summary>
/// Encodes revocation entry to a ASN.1-encoded byte array.
/// </summary>
/// <returns>ASN.1-encoded byte array</returns>
public Byte[] Encode()
{
if (String.IsNullOrEmpty(SerialNumber))
{
throw new UninitializedObjectException();
}
List <Byte> rawData = new List <Byte>(AsnFormatter.StringToBinary(SerialNumber, EncodingType.HexAny));
rawData = new List <Byte>(Asn1Utils.Encode(rawData.ToArray(), (Byte)Asn1Type.INTEGER));
rawData.AddRange(Asn1Utils.EncodeDateTime(RevocationDate));
if (ReasonCode != 0)
{
Byte[] reasonEnum = new Byte[] { 10, 1, (Byte)ReasonCode };
X509ExtensionCollection exts = new X509ExtensionCollection();
X509Extension CRlReasonCode = new X509Extension("2.5.29.21", reasonEnum, false);
exts.Add(CRlReasonCode);
rawData.AddRange(Crypt32Managed.EncodeX509Extensions(exts));
}
return(Asn1Utils.Encode(rawData.ToArray(), 48));
}
/// <summary>
/// Encodes current object to a DER-encoded byte array. Returned array is used to construct initial OCSP Request structure.
/// </summary>
/// <returns>Returns a DER-encoded byte array.</returns>
/// <value>System.Byte[]</value>
public Byte[] Encode()
{
if (!String.IsNullOrEmpty(SerialNumber))
{
if (issuerPublicKey != null)
{
initializeFromCertAndIssuer();
}
// algorithm identifier
var rawData = new List <Byte>(Asn1Utils.EncodeObjectIdentifier(hashAlgorithm));
rawData.AddRange(Asn1Utils.EncodeNull());
rawData = new List <Byte>(Asn1Utils.Encode(rawData.ToArray(), 48));
// IssuerNameId
rawData.AddRange(Asn1Utils.Encode(AsnFormatter.StringToBinary(IssuerNameId, EncodingType.HexRaw), 4));
// IssuerKeyId
rawData.AddRange(Asn1Utils.Encode(AsnFormatter.StringToBinary(IssuerKeyId, EncodingType.HexRaw), 4));
// SerialNumber
rawData.AddRange(Asn1Utils.Encode(serialNumber, 2));
IsReadOnly = true;
return(Asn1Utils.Encode(rawData.ToArray(), 48));
}
throw new UninitializedObjectException();
}
public static Byte[] EncodeHex(Byte tag, String hexString, Byte unusedBits)
{
Byte[] hexBytes = AsnFormatter.StringToBinary(hexString, EncodingType.Hex);
return(Asn1Utils.Encode(hexBytes, tag));
}
public static Byte[] HexToBinary(String hexString)
{
return(AsnFormatter.StringToBinary(hexString, EncodingType.Hex));
}