private ASN1 SubjectPublicKeyInfo()
{
ASN1 aSN = new ASN1(48);
if (aa is RSA)
{
aSN.Add(PKCS7.AlgorithmIdentifier("1.2.840.113549.1.1.1"));
RSAParameters rSAParameters = (aa as RSA).ExportParameters(includePrivateParameters: false);
ASN1 aSN2 = new ASN1(48);
aSN2.Add(ASN1Convert.FromUnsignedBigInteger(rSAParameters.Modulus));
aSN2.Add(ASN1Convert.FromUnsignedBigInteger(rSAParameters.Exponent));
aSN.Add(new ASN1(UniqueIdentifier(aSN2.GetBytes())));
}
else
{
if (!(aa is DSA))
{
throw new NotSupportedException("Unknown Asymmetric Algorithm " + aa.ToString());
}
DSAParameters dSAParameters = (aa as DSA).ExportParameters(includePrivateParameters: false);
ASN1 aSN3 = new ASN1(48);
aSN3.Add(ASN1Convert.FromUnsignedBigInteger(dSAParameters.P));
aSN3.Add(ASN1Convert.FromUnsignedBigInteger(dSAParameters.Q));
aSN3.Add(ASN1Convert.FromUnsignedBigInteger(dSAParameters.G));
aSN.Add(PKCS7.AlgorithmIdentifier("1.2.840.10040.4.1", aSN3));
ASN1 aSN4 = aSN.Add(new ASN1(3));
aSN4.Add(ASN1Convert.FromUnsignedBigInteger(dSAParameters.Y));
}
return(aSN);
}
internal ASN1 GetASN1(byte encoding)
{
byte encode = encoding;
if (encode == 0xFF)
{
encode = SelectBestEncoding();
}
ASN1 asn1 = new ASN1(0x30);
asn1.Add(ASN1Convert.FromOid(oid));
switch (encode)
{
case 0x13:
// PRINTABLESTRING
asn1.Add(new ASN1(0x13, Encoding.ASCII.GetBytes(attrValue)));
break;
case 0x16:
// IA5STRING
asn1.Add(new ASN1(0x16, Encoding.ASCII.GetBytes(attrValue)));
break;
case 0x1E:
// BMPSTRING
asn1.Add(new ASN1(0x1E, Encoding.BigEndianUnicode.GetBytes(attrValue)));
break;
}
return(asn1);
}
public byte[] GetBytes()
{
ASN1 privateKeyAlgorithm = new ASN1(0x30);
privateKeyAlgorithm.Add(ASN1Convert.FromOid(_algorithm));
privateKeyAlgorithm.Add(new ASN1(0x05)); // ASN.1 NULL
ASN1 pki = new ASN1(0x30);
pki.Add(new ASN1(0x02, new byte [1] {
(byte)_version
}));
pki.Add(privateKeyAlgorithm);
pki.Add(new ASN1(0x04, _key));
if (_list.Count > 0)
{
ASN1 attributes = new ASN1(0xA0);
foreach (ASN1 attribute in _list)
{
attributes.Add(attribute);
}
pki.Add(attributes);
}
return(pki.GetBytes());
}
protected override void Decode()
{
this.cA = false;
this.pathLenConstraint = -1;
ASN1 asN1_1 = new ASN1(this.extnValue.Value);
if (asN1_1.Tag != (byte)48)
{
throw new ArgumentException("Invalid BasicConstraints extension");
}
int num1 = 0;
ASN1 asN1_2 = asN1_1;
int index1 = num1;
int num2 = index1 + 1;
ASN1 asn1 = asN1_2[index1];
if (asn1 != null && asn1.Tag == (byte)1)
{
this.cA = asn1.Value[0] == byte.MaxValue;
ASN1 asN1_3 = asN1_1;
int index2 = num2;
int num3 = index2 + 1;
asn1 = asN1_3[index2];
}
if (asn1 == null || asn1.Tag != (byte)2)
{
return;
}
this.pathLenConstraint = ASN1Convert.ToInt32(asn1);
}
private byte[] GetRandomNumber()
{
byte[] _randomNum;
ASN1 _randomTop = (ASN1)KeyInfo.Attributes[0];
if (_randomTop.Tag != 0x30 || _randomTop.Count < 2)
{
throw new ProxyException("invalid random number");
}
var _algorithm = ASN1Convert.ToOid(_randomTop[0]);
if (_algorithm == "1.2.410.200004.10.1.1.3")
{
ASN1 _randomSeq = _randomTop[1];
if (_randomSeq.Tag != 0x31 || _randomSeq.Count < 1)
{
throw new ProxyException("invalid random number");
}
byte[] _rmvZero = RemoveLeadingZero(_randomSeq[0].Value);
var _size = _rmvZero.Length;
_randomNum = new byte[_size];
Array.Copy(_rmvZero, 0, _randomNum, 0, _size);
}
else
{
throw new ProxyException("unknown random algorithm");
}
return(_randomNum);
}
// Class(60) {
// OID(spnego),
// Class(A0) {
// Class(30) {
// Class(A0) {
// Class(30) { OID,OID,OID} },
// Class(A2) { OctetStream } } } }
public byte [] ProcessSpnegoInitialContextTokenRequest()
{
Type1Message type1 = new Type1Message(NtlmVersion.Version3);
type1.Flags = unchecked ((NtlmFlags)0xE21882B7);
type1.Domain = "WORKGROUP"; // FIXME: remove it
ASN1 asn = new ASN1(0x60);
ASN1 asn2 = new ASN1(0xA0);
ASN1 asn21 = new ASN1(0x30);
ASN1 asn211 = new ASN1(0xA0);
ASN1 asn2111 = new ASN1(0x30);
asn211.Add(asn2111);
asn2111.Add(ASN1Convert.FromOid(Constants.OidNtlmSsp));
asn2111.Add(ASN1Convert.FromOid(Constants.OidKerberos5));
asn2111.Add(ASN1Convert.FromOid(Constants.OidMIT));
ASN1 asn212 = new ASN1(0xA2);
ASN1 asn2121 = new ASN1(0x4);
asn2121.Value = type1.GetBytes();
asn212.Add(asn2121);
asn21.Add(asn211);
asn21.Add(asn212);
asn2.Add(asn21);
asn.Add(ASN1Convert.FromOid(Constants.OidSpnego));
asn.Add(asn2);
return(asn.GetBytes());
}
protected override void Decode()
{
ASN1 asn = new ASN1(this.extnValue.Value);
if (asn.Tag != 48)
{
throw new ArgumentException("Invalid PrivateKeyUsagePeriod extension");
}
for (int i = 0; i < asn.Count; i++)
{
byte tag = asn[i].Tag;
if (tag != 128)
{
if (tag != 129)
{
throw new ArgumentException("Invalid PrivateKeyUsagePeriod extension");
}
this.notAfter = ASN1Convert.ToDateTime(asn[i]);
}
else
{
this.notBefore = ASN1Convert.ToDateTime(asn[i]);
}
}
}
protected override void Decode()
{
ASN1 sequence = new ASN1(extnValue.Value);
if (sequence.Tag != 0x30)
{
throw new ArgumentException("Invalid PrivateKeyUsagePeriod extension");
}
for (int i = 0; i < sequence.Count; i++)
{
switch (sequence [i].Tag)
{
case 0x80:
notBefore = ASN1Convert.ToDateTime(sequence [i]);
break;
case 0x81:
notAfter = ASN1Convert.ToDateTime(sequence [i]);
break;
default:
throw new ArgumentException("Invalid PrivateKeyUsagePeriod extension");
}
}
}
private ASN1 SubjectPublicKeyInfo()
{
ASN1 asn = new ASN1(48);
if (this.aa is RSA)
{
asn.Add(PKCS7.AlgorithmIdentifier("1.2.840.113549.1.1.1"));
RSAParameters rsaparameters = (this.aa as RSA).ExportParameters(false);
ASN1 asn2 = new ASN1(48);
asn2.Add(ASN1Convert.FromUnsignedBigInteger(rsaparameters.Modulus));
asn2.Add(ASN1Convert.FromUnsignedBigInteger(rsaparameters.Exponent));
asn.Add(new ASN1(this.UniqueIdentifier(asn2.GetBytes())));
}
else
{
if (!(this.aa is DSA))
{
throw new NotSupportedException("Unknown Asymmetric Algorithm " + this.aa.ToString());
}
DSAParameters dsaparameters = (this.aa as DSA).ExportParameters(false);
ASN1 asn3 = new ASN1(48);
asn3.Add(ASN1Convert.FromUnsignedBigInteger(dsaparameters.P));
asn3.Add(ASN1Convert.FromUnsignedBigInteger(dsaparameters.Q));
asn3.Add(ASN1Convert.FromUnsignedBigInteger(dsaparameters.G));
asn.Add(PKCS7.AlgorithmIdentifier("1.2.840.10040.4.1", asn3));
ASN1 asn4 = asn.Add(new ASN1(3));
asn4.Add(ASN1Convert.FromUnsignedBigInteger(dsaparameters.Y));
}
return(asn);
}
private byte[] Header(byte[] fileHash, string hashAlgorithm)
{
string oid = CryptoConfig.MapNameToOID(hashAlgorithm);
ASN1 aSN = new ASN1(48);
ASN1 aSN2 = aSN.Add(new ASN1(48));
aSN2.Add(ASN1Convert.FromOid("1.3.6.1.4.1.311.2.1.15"));
aSN2.Add(new ASN1(48, obsolete));
ASN1 aSN3 = aSN.Add(new ASN1(48));
aSN3.Add(AlgorithmIdentifier(oid));
aSN3.Add(new ASN1(4, fileHash));
pkcs7.HashName = hashAlgorithm;
pkcs7.Certificates.AddRange(certs);
pkcs7.ContentInfo.ContentType = "1.3.6.1.4.1.311.2.1.4";
pkcs7.ContentInfo.Content.Add(aSN);
pkcs7.SignerInfo.Certificate = certs[0];
pkcs7.SignerInfo.Key = rsa;
ASN1 aSN4 = null;
aSN4 = ((!(url == null)) ? Attribute("1.3.6.1.4.1.311.2.1.12", Opus(description, url.ToString())) : Attribute("1.3.6.1.4.1.311.2.1.12", Opus(description, null)));
pkcs7.SignerInfo.AuthenticatedAttributes.Add(aSN4);
pkcs7.GetASN1();
return(pkcs7.SignerInfo.Signature);
}
public X509Extension(ASN1 asn1)
{
if ((asn1.Tag != 0x30) || (asn1.Count < 2))
{
throw new ArgumentException(Locale.GetText("Invalid X.509 extension."));
}
if (asn1[0].Tag != 0x06)
{
throw new ArgumentException(Locale.GetText("Invalid X.509 extension."));
}
extnOid = ASN1Convert.ToOid(asn1[0]);
extnCritical = ((asn1[1].Tag == 0x01) && (asn1[1].Value[0] == 0xFF));
// last element is an octet string which may need to be decoded
extnValue = asn1 [asn1.Count - 1];
if ((extnValue.Tag == 0x04) && (extnValue.Length > 0) && (extnValue.Count == 0))
{
try {
ASN1 encapsulated = new ASN1(extnValue.Value);
extnValue.Value = null;
extnValue.Add(encapsulated);
}
catch {
// data isn't ASN.1
}
}
Decode();
}
public static ASN1 ToAsn1(RSA rsa)
{
EnsureNotNull(rsa, "rsa");
ASN1 asn = new ASN1(0x30);
ASN1 asnOid = new ASN1(0x30);
// {iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs-1(1) rsaEncryption(1)}
// http://www.oid-info.com/get/1.2.840.113549.1.1.1
asnOid.Add(ASN1Convert.FromOid("1.2.840.113549.1.1.1"));
asnOid.Add(new ASN1(0x05));
asn.Add(asnOid);
ASN1 asnBits = new ASN1(0x03, new byte[1]);
byte[] intermediate = ToAsn1Key(rsa).GetBytes();
byte[] key = new byte[intermediate.Length + 1];
intermediate.CopyTo(key, 1);
asnBits.Value = key;
asn.Add(asnBits);
return(asn);
}
public byte[] GetBytes()
{
if (this._algorithm == null)
{
throw new CryptographicException("No algorithm OID specified");
}
ASN1 asn1_1 = new ASN1((byte)48);
asn1_1.Add(ASN1Convert.FromOid(this._algorithm));
if (this._iterations > 0 || this._salt != null)
{
ASN1 asn1_2 = new ASN1((byte)4, this._salt);
ASN1 asn1_3 = ASN1Convert.FromInt32(this._iterations);
ASN1 asn1_4 = new ASN1((byte)48);
asn1_4.Add(asn1_2);
asn1_4.Add(asn1_3);
asn1_1.Add(asn1_4);
}
ASN1 asn1_5 = new ASN1((byte)4, this._data);
ASN1 asN1 = new ASN1((byte)48);
asN1.Add(asn1_1);
asN1.Add(asn1_5);
return(asN1.GetBytes());
}
public byte[] GetBytes()
{
ASN1 asn1_1 = new ASN1((byte)48);
asn1_1.Add(ASN1Convert.FromOid(this._algorithm));
asn1_1.Add(new ASN1((byte)5));
ASN1 asN1 = new ASN1((byte)48);
asN1.Add(new ASN1((byte)2, new byte[1]
{
(byte)this._version
}));
asN1.Add(asn1_1);
asN1.Add(new ASN1((byte)4, this._key));
if (this._list.Count > 0)
{
ASN1 asn1_2 = new ASN1((byte)160);
foreach (ASN1 asn1_3 in this._list)
{
asn1_2.Add(asn1_3);
}
asN1.Add(asn1_2);
}
return(asN1.GetBytes());
}
public byte[] GetBytes()
{
ASN1 aSN = new ASN1(48);
aSN.Add(ASN1Convert.FromOid(_algorithm));
aSN.Add(new ASN1(5));
ASN1 aSN2 = new ASN1(48);
aSN2.Add(new ASN1(2, new byte[1]
{
(byte)_version
}));
aSN2.Add(aSN);
aSN2.Add(new ASN1(4, _key));
if (_list.Count > 0)
{
ASN1 aSN3 = new ASN1(160);
foreach (ASN1 item in _list)
{
aSN3.Add(item);
}
aSN2.Add(aSN3);
}
return(aSN2.GetBytes());
}
protected override void Decode()
{
ASN1 asN1 = new ASN1(this.extnValue.Value);
if (asN1.Tag != (byte)48)
{
throw new ArgumentException("Invalid PrivateKeyUsagePeriod extension");
}
for (int index = 0; index < asN1.Count; ++index)
{
switch (asN1[index].Tag)
{
case 128:
this.notBefore = ASN1Convert.ToDateTime(asN1[index]);
break;
case 129:
this.notAfter = ASN1Convert.ToDateTime(asN1[index]);
break;
default:
throw new ArgumentException("Invalid PrivateKeyUsagePeriod extension");
}
}
}
public byte[] GetBytes()
{
if (_algorithm == null)
{
throw new CryptographicException("No algorithm OID specified");
}
ASN1 aSN = new ASN1(48);
aSN.Add(ASN1Convert.FromOid(_algorithm));
if (_iterations > 0 || _salt != null)
{
ASN1 asn = new ASN1(4, _salt);
ASN1 asn2 = ASN1Convert.FromInt32(_iterations);
ASN1 aSN2 = new ASN1(48);
aSN2.Add(asn);
aSN2.Add(asn2);
aSN.Add(aSN2);
}
ASN1 asn3 = new ASN1(4, _data);
ASN1 aSN3 = new ASN1(48);
aSN3.Add(aSN);
aSN3.Add(asn3);
return(aSN3.GetBytes());
}
public byte[] GetBytes()
{
ASN1 asn = new ASN1(48);
asn.Add(ASN1Convert.FromOid(this._algorithm));
asn.Add(new ASN1(5));
ASN1 asn2 = new ASN1(48);
asn2.Add(new ASN1(2, new byte[]
{
(byte)this._version
}));
asn2.Add(asn);
asn2.Add(new ASN1(4, this._key));
if (this._list.Count > 0)
{
ASN1 asn3 = new ASN1(160);
foreach (object obj in this._list)
{
ASN1 asn4 = (ASN1)obj;
asn3.Add(asn4);
}
asn2.Add(asn3);
}
return(asn2.GetBytes());
}
protected override void Decode()
{
// default values
cA = false;
pathLenConstraint = NoPathLengthConstraint;
ASN1 sequence = new ASN1(extnValue.Value);
if (sequence.Tag != 0x30)
{
throw new ArgumentException("Invalid BasicConstraints extension");
}
int n = 0;
ASN1 a = sequence [n++];
if ((a != null) && (a.Tag == 0x01))
{
cA = (a.Value [0] == 0xFF);
a = sequence [n++];
}
if ((a != null) && (a.Tag == 0x02))
{
pathLenConstraint = ASN1Convert.ToInt32(a);
}
}
public byte[] GetBytes()
{
if (this._algorithm == null)
{
throw new CryptographicException("No algorithm OID specified");
}
ASN1 asn = new ASN1(48);
asn.Add(ASN1Convert.FromOid(this._algorithm));
if (this._iterations > 0 || this._salt != null)
{
ASN1 asn2 = new ASN1(4, this._salt);
ASN1 asn3 = ASN1Convert.FromInt32(this._iterations);
ASN1 asn4 = new ASN1(48);
asn4.Add(asn2);
asn4.Add(asn3);
asn.Add(asn4);
}
ASN1 asn5 = new ASN1(4, this._data);
ASN1 asn6 = new ASN1(48);
asn6.Add(asn);
asn6.Add(asn5);
return(asn6.GetBytes());
}
public void FromString_EscapingNonAscii()
{
// adapted from rfc2253
ASN1 asn = X501.FromString(@"CN=Lu\C4\8Di\C4\87,O=Test,C=GB");
Assert.AreEqual(0x30, asn.Tag, "Tag");
Assert.AreEqual(3, asn.Count, "Count");
Assert.AreEqual(0x31, asn[0].Tag, "Tag-0");
Assert.AreEqual(1, asn[0].Count, "Count-0");
Assert.AreEqual("2.5.4.3", ASN1Convert.ToOid(asn[0][0][0]), "OID-0");
char[] value = Encoding.BigEndianUnicode.GetChars(asn[0][0][1].Value);
Assert.AreEqual(0x004C, value[0], "Value-0[0]");
Assert.AreEqual(0x0075, value[1], "Value-0[1]");
Assert.AreEqual(0x010D, value[2], "Value-0[2]");
Assert.AreEqual(0x0069, value[3], "Value-0[3]");
Assert.AreEqual(0x0107, value[4], "Value-0[4]");
Assert.AreEqual(0x31, asn[1].Tag, "Tag-1");
Assert.AreEqual(1, asn[1].Count, "Count-1");
Assert.AreEqual("2.5.4.10", ASN1Convert.ToOid(asn[1][0][0]), "OID-1");
Assert.AreEqual("Test", Encoding.ASCII.GetString(asn[1][0][1].Value), "Value-1");
Assert.AreEqual(0x31, asn[2].Tag, "Tag-2");
Assert.AreEqual(1, asn[2].Count, "Count-2");
Assert.AreEqual("2.5.4.6", ASN1Convert.ToOid(asn[2][0][0]), "OID-2");
Assert.AreEqual("GB", Encoding.ASCII.GetString(asn[2][0][1].Value), "Value-2");
}
// internal
internal AsnDecodeStatus Decode(byte[] extension)
{
if ((extension == null) || (extension.Length == 0))
{
return(AsnDecodeStatus.BadAsn);
}
if (extension [0] != 0x30)
{
return(AsnDecodeStatus.BadTag);
}
if (_enhKeyUsage == null)
{
_enhKeyUsage = new OidCollection();
}
try {
ASN1 ex = new ASN1(extension);
if (ex.Tag != 0x30)
{
throw new CryptographicException(Locale.GetText("Invalid ASN.1 Tag"));
}
for (int i = 0; i < ex.Count; i++)
{
_enhKeyUsage.Add(new Oid(ASN1Convert.ToOid(ex [i])));
}
}
catch {
return(AsnDecodeStatus.BadAsn);
}
return(AsnDecodeStatus.Ok);
}
internal ASN1 GetASN1(byte encoding)
{
byte b = encoding;
if (b == byte.MaxValue)
{
b = SelectBestEncoding();
}
ASN1 aSN = new ASN1(48);
aSN.Add(ASN1Convert.FromOid(oid));
switch (b)
{
case 19:
aSN.Add(new ASN1(19, Encoding.ASCII.GetBytes(attrValue)));
break;
case 22:
aSN.Add(new ASN1(22, Encoding.ASCII.GetBytes(attrValue)));
break;
case 30:
aSN.Add(new ASN1(30, Encoding.BigEndianUnicode.GetBytes(attrValue)));
break;
}
return(aSN);
}
public X509Extension(ASN1 asn1)
{
if (asn1.Tag != 48 || asn1.Count < 2)
{
throw new ArgumentException(Locale.GetText("Invalid X.509 extension."));
}
if (asn1[0].Tag != 6)
{
throw new ArgumentException(Locale.GetText("Invalid X.509 extension."));
}
extnOid = ASN1Convert.ToOid(asn1[0]);
extnCritical = (asn1[1].Tag == 1 && asn1[1].Value[0] == byte.MaxValue);
extnValue = asn1[asn1.Count - 1];
if (extnValue.Tag == 4 && extnValue.Length > 0 && extnValue.Count == 0)
{
try
{
ASN1 asn2 = new ASN1(extnValue.Value);
extnValue.Value = null;
extnValue.Add(asn2);
}
catch
{
}
}
Decode();
}
internal X509CrlEntry(ASN1 entry)
{
sn = entry[0].Value;
Array.Reverse(sn);
revocationDate = ASN1Convert.ToDateTime(entry[1]);
extensions = new X509ExtensionCollection(entry[2]);
}
internal ASN1 GetASN1(byte encoding)
{
byte b = encoding;
if (b == 255)
{
b = this.SelectBestEncoding();
}
ASN1 asn = new ASN1(48);
asn.Add(ASN1Convert.FromOid(this.oid));
byte b2 = b;
switch (b2)
{
case 19:
asn.Add(new ASN1(19, Encoding.ASCII.GetBytes(this.attrValue)));
break;
default:
if (b2 == 30)
{
asn.Add(new ASN1(30, Encoding.BigEndianUnicode.GetBytes(this.attrValue)));
}
break;
case 22:
asn.Add(new ASN1(22, Encoding.ASCII.GetBytes(this.attrValue)));
break;
}
return(asn);
}
public X509Extension(ASN1 asn1)
{
if (asn1.Tag != (byte)48 || asn1.Count < 2)
{
throw new ArgumentException(Locale.GetText("Invalid X.509 extension."));
}
if (asn1[0].Tag != (byte)6)
{
throw new ArgumentException(Locale.GetText("Invalid X.509 extension."));
}
this.extnOid = ASN1Convert.ToOid(asn1[0]);
this.extnCritical = asn1[1].Tag == (byte)1 && asn1[1].Value[0] == byte.MaxValue;
this.extnValue = asn1[asn1.Count - 1];
if (this.extnValue.Tag == (byte)4 && this.extnValue.Length > 0)
{
if (this.extnValue.Count == 0)
{
try
{
ASN1 asn1_1 = new ASN1(this.extnValue.Value);
this.extnValue.Value = (byte[])null;
this.extnValue.Add(asn1_1);
}
catch
{
}
}
}
this.Decode();
}
private byte[] Header(byte[] fileHash, string hashAlgorithm)
{
string oid = CryptoConfig.MapNameToOID(hashAlgorithm);
ASN1 asn = new ASN1(48);
ASN1 asn2 = asn.Add(new ASN1(48));
asn2.Add(ASN1Convert.FromOid("1.3.6.1.4.1.311.2.1.15"));
asn2.Add(new ASN1(48, AuthenticodeFormatter.obsolete));
ASN1 asn3 = asn.Add(new ASN1(48));
asn3.Add(this.AlgorithmIdentifier(oid));
asn3.Add(new ASN1(4, fileHash));
this.pkcs7.HashName = hashAlgorithm;
this.pkcs7.Certificates.AddRange(this.certs);
this.pkcs7.ContentInfo.ContentType = "1.3.6.1.4.1.311.2.1.4";
this.pkcs7.ContentInfo.Content.Add(asn);
this.pkcs7.SignerInfo.Certificate = this.certs[0];
this.pkcs7.SignerInfo.Key = this.rsa;
ASN1 value;
if (this.url == null)
{
value = this.Attribute("1.3.6.1.4.1.311.2.1.12", this.Opus(this.description, null));
}
else
{
value = this.Attribute("1.3.6.1.4.1.311.2.1.12", this.Opus(this.description, this.url.ToString()));
}
this.pkcs7.SignerInfo.AuthenticatedAttributes.Add(value);
this.pkcs7.GetASN1();
return(this.pkcs7.SignerInfo.Signature);
}
// Note: PKCS#8 doesn't define how to generate the key required for encryption
// so you're on your own. Just don't try to copy the big guys too much ;)
// Netscape: http://www.cs.auckland.ac.nz/~pgut001/pubs/netscape.txt
// Microsoft: http://www.cs.auckland.ac.nz/~pgut001/pubs/breakms.txt
public byte[] GetBytes()
{
if (_algorithm == null)
{
throw new CryptographicException("No algorithm OID specified");
}
ASN1 encryptionAlgorithm = new ASN1(0x30);
encryptionAlgorithm.Add(ASN1Convert.FromOid(_algorithm));
// parameters ANY DEFINED BY algorithm OPTIONAL
if ((_iterations > 0) || (_salt != null))
{
ASN1 salt = new ASN1(0x04, _salt);
ASN1 iterations = ASN1Convert.FromInt32(_iterations);
ASN1 parameters = new ASN1(0x30);
parameters.Add(salt);
parameters.Add(iterations);
encryptionAlgorithm.Add(parameters);
}
// encapsulates EncryptedData into an OCTET STRING
ASN1 encryptedData = new ASN1(0x04, _data);
ASN1 encryptedPrivateKeyInfo = new ASN1(0x30);
encryptedPrivateKeyInfo.Add(encryptionAlgorithm);
encryptedPrivateKeyInfo.Add(encryptedData);
return(encryptedPrivateKeyInfo.GetBytes());
}
///
/// SEQUENCE (a)
/// +- INTEGER (V) // Version - 0 (v1998)
/// +- SEQUENCE (b)
/// | +- OID (oid) // 1.2.840.113549.1.1.1
/// | +- Nil (c)
/// +- OCTETSTRING(PRVKY) (os) // Private Key Parameter
///
/// However, OCTETSTRING(PRVKY) wraps
/// SEQUENCE(
/// INTEGER(0) // Version - 0 (v1998)
/// INTEGER(N)
/// INTEGER(E)
/// INTEGER(D)
/// INTEGER(P)
/// INTEGER(Q)
/// INTEGER(DP)
/// INTEGER(DQ)
/// INTEGER(InvQ)
/// )
public static byte[] RSAKeyToASN1(RSAParameters PrivateKey)
{
ASN1 v = ASN1Convert.FromUnsignedBigInteger(new byte[] { 0 });
ASN1 b = PKCS7.AlgorithmIdentifier("1.2.840.113549.1.1.1");
ASN1 os = new ASN1(0x30);
os.Add(ASN1Convert.FromUnsignedBigInteger(new byte[] { 0 }));
os.Add(ASN1Convert.FromUnsignedBigInteger(PrivateKey.Modulus));
os.Add(ASN1Convert.FromUnsignedBigInteger(PrivateKey.Exponent));
os.Add(ASN1Convert.FromUnsignedBigInteger(PrivateKey.D));
os.Add(ASN1Convert.FromUnsignedBigInteger(PrivateKey.P));
os.Add(ASN1Convert.FromUnsignedBigInteger(PrivateKey.Q));
os.Add(ASN1Convert.FromUnsignedBigInteger(PrivateKey.DP));
os.Add(ASN1Convert.FromUnsignedBigInteger(PrivateKey.DQ));
os.Add(ASN1Convert.FromUnsignedBigInteger(PrivateKey.InverseQ));
ASN1 pem = new ASN1(0x30);
pem.Add(v);
pem.Add(b);
// Make this into an OCTET string
pem.Add(new ASN1(0x04, os.GetBytes()));
return(pem.GetBytes());
}