jellyfin/MediaBrowser.Server.Mono/Security/PKCS7.cs

1012 lines
27 KiB
C#
Raw Normal View History

2016-06-29 20:28:48 +00:00
//
// PKCS7.cs: PKCS #7 - Cryptographic Message Syntax Standard
// http://www.rsasecurity.com/rsalabs/pkcs/pkcs-7/index.html
//
// Authors:
// Sebastien Pouliot <sebastien@ximian.com>
// Daniel Granath <dgranath#gmail.com>
//
// (C) 2002, 2003 Motus Technologies Inc. (http://www.motus.com)
// Copyright (C) 2004-2005 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using System.Collections;
using System.Security.Cryptography;
2016-06-30 21:56:14 +00:00
namespace MediaBrowser.Server.Mono.Security {
2016-06-29 20:28:48 +00:00
2016-06-30 21:56:14 +00:00
public sealed class PKCS7 {
2016-06-29 20:28:48 +00:00
public class Oid {
// pkcs 1
public const string rsaEncryption = "1.2.840.113549.1.1.1";
// pkcs 7
public const string data = "1.2.840.113549.1.7.1";
public const string signedData = "1.2.840.113549.1.7.2";
public const string envelopedData = "1.2.840.113549.1.7.3";
public const string signedAndEnvelopedData = "1.2.840.113549.1.7.4";
public const string digestedData = "1.2.840.113549.1.7.5";
public const string encryptedData = "1.2.840.113549.1.7.6";
// pkcs 9
public const string contentType = "1.2.840.113549.1.9.3";
public const string messageDigest = "1.2.840.113549.1.9.4";
public const string signingTime = "1.2.840.113549.1.9.5";
public const string countersignature = "1.2.840.113549.1.9.6";
public Oid ()
{
}
}
private PKCS7 ()
{
}
static public ASN1 Attribute (string oid, ASN1 value)
{
ASN1 attr = new ASN1 (0x30);
attr.Add (ASN1Convert.FromOid (oid));
ASN1 aset = attr.Add (new ASN1 (0x31));
aset.Add (value);
return attr;
}
static public ASN1 AlgorithmIdentifier (string oid)
{
ASN1 ai = new ASN1 (0x30);
ai.Add (ASN1Convert.FromOid (oid));
ai.Add (new ASN1 (0x05)); // NULL
return ai;
}
static public ASN1 AlgorithmIdentifier (string oid, ASN1 parameters)
{
ASN1 ai = new ASN1 (0x30);
ai.Add (ASN1Convert.FromOid (oid));
ai.Add (parameters);
return ai;
}
/*
* IssuerAndSerialNumber ::= SEQUENCE {
* issuer Name,
* serialNumber CertificateSerialNumber
* }
*/
static public ASN1 IssuerAndSerialNumber (X509Certificate x509)
{
ASN1 issuer = null;
ASN1 serial = null;
ASN1 cert = new ASN1 (x509.RawData);
int tbs = 0;
bool flag = false;
while (tbs < cert[0].Count) {
ASN1 e = cert[0][tbs++];
if (e.Tag == 0x02)
serial = e;
else if (e.Tag == 0x30) {
if (flag) {
issuer = e;
break;
}
flag = true;
}
}
ASN1 iasn = new ASN1 (0x30);
iasn.Add (issuer);
iasn.Add (serial);
return iasn;
}
/*
* ContentInfo ::= SEQUENCE {
* contentType ContentType,
* content [0] EXPLICIT ANY DEFINED BY contentType OPTIONAL
* }
* ContentType ::= OBJECT IDENTIFIER
*/
public class ContentInfo {
private string contentType;
private ASN1 content;
public ContentInfo ()
{
content = new ASN1 (0xA0);
}
public ContentInfo (string oid) : this ()
{
contentType = oid;
}
public ContentInfo (byte[] data)
: this (new ASN1 (data)) {}
public ContentInfo (ASN1 asn1)
{
// SEQUENCE with 1 or 2 elements
if ((asn1.Tag != 0x30) || ((asn1.Count < 1) && (asn1.Count > 2)))
throw new ArgumentException ("Invalid ASN1");
if (asn1[0].Tag != 0x06)
throw new ArgumentException ("Invalid contentType");
contentType = ASN1Convert.ToOid (asn1[0]);
if (asn1.Count > 1) {
if (asn1[1].Tag != 0xA0)
throw new ArgumentException ("Invalid content");
content = asn1[1];
}
}
public ASN1 ASN1 {
get { return GetASN1(); }
}
public ASN1 Content {
get { return content; }
set { content = value; }
}
public string ContentType {
get { return contentType; }
set { contentType = value; }
}
internal ASN1 GetASN1 ()
{
// ContentInfo ::= SEQUENCE {
ASN1 contentInfo = new ASN1 (0x30);
// contentType ContentType, -> ContentType ::= OBJECT IDENTIFIER
contentInfo.Add (ASN1Convert.FromOid (contentType));
// content [0] EXPLICIT ANY DEFINED BY contentType OPTIONAL
if ((content != null) && (content.Count > 0))
contentInfo.Add (content);
return contentInfo;
}
public byte[] GetBytes ()
{
return GetASN1 ().GetBytes ();
}
}
/*
* EncryptedData ::= SEQUENCE {
* version INTEGER {edVer0(0)} (edVer0),
* encryptedContentInfo EncryptedContentInfo
* }
*/
public class EncryptedData {
private byte _version;
private ContentInfo _content;
private ContentInfo _encryptionAlgorithm;
private byte[] _encrypted;
public EncryptedData ()
{
_version = 0;
}
public EncryptedData (byte[] data)
: this (new ASN1 (data))
{
}
public EncryptedData (ASN1 asn1) : this ()
{
if ((asn1.Tag != 0x30) || (asn1.Count < 2))
throw new ArgumentException ("Invalid EncryptedData");
if (asn1 [0].Tag != 0x02)
throw new ArgumentException ("Invalid version");
_version = asn1 [0].Value [0];
ASN1 encryptedContentInfo = asn1 [1];
if (encryptedContentInfo.Tag != 0x30)
throw new ArgumentException ("missing EncryptedContentInfo");
ASN1 contentType = encryptedContentInfo [0];
if (contentType.Tag != 0x06)
throw new ArgumentException ("missing EncryptedContentInfo.ContentType");
_content = new ContentInfo (ASN1Convert.ToOid (contentType));
ASN1 contentEncryptionAlgorithm = encryptedContentInfo [1];
if (contentEncryptionAlgorithm.Tag != 0x30)
throw new ArgumentException ("missing EncryptedContentInfo.ContentEncryptionAlgorithmIdentifier");
_encryptionAlgorithm = new ContentInfo (ASN1Convert.ToOid (contentEncryptionAlgorithm [0]));
_encryptionAlgorithm.Content = contentEncryptionAlgorithm [1];
ASN1 encryptedContent = encryptedContentInfo [2];
if (encryptedContent.Tag != 0x80)
throw new ArgumentException ("missing EncryptedContentInfo.EncryptedContent");
_encrypted = encryptedContent.Value;
}
public ASN1 ASN1 {
get { return GetASN1(); }
}
public ContentInfo ContentInfo {
get { return _content; }
}
public ContentInfo EncryptionAlgorithm {
get { return _encryptionAlgorithm; }
}
public byte[] EncryptedContent {
get {
if (_encrypted == null)
return null;
return (byte[]) _encrypted.Clone ();
}
}
public byte Version {
get { return _version; }
set { _version = value; }
}
// methods
internal ASN1 GetASN1 ()
{
return null;
}
public byte[] GetBytes ()
{
return GetASN1 ().GetBytes ();
}
}
/*
* EnvelopedData ::= SEQUENCE {
* version Version,
* recipientInfos RecipientInfos,
* encryptedContentInfo EncryptedContentInfo
* }
*
* RecipientInfos ::= SET OF RecipientInfo
*
* EncryptedContentInfo ::= SEQUENCE {
* contentType ContentType,
* contentEncryptionAlgorithm ContentEncryptionAlgorithmIdentifier,
* encryptedContent [0] IMPLICIT EncryptedContent OPTIONAL
* }
*
* EncryptedContent ::= OCTET STRING
*
*/
public class EnvelopedData {
private byte _version;
private ContentInfo _content;
private ContentInfo _encryptionAlgorithm;
private ArrayList _recipientInfos;
private byte[] _encrypted;
public EnvelopedData ()
{
_version = 0;
_content = new ContentInfo ();
_encryptionAlgorithm = new ContentInfo ();
_recipientInfos = new ArrayList ();
}
public EnvelopedData (byte[] data)
: this (new ASN1 (data))
{
}
public EnvelopedData (ASN1 asn1) : this ()
{
if ((asn1[0].Tag != 0x30) || (asn1[0].Count < 3))
throw new ArgumentException ("Invalid EnvelopedData");
if (asn1[0][0].Tag != 0x02)
throw new ArgumentException ("Invalid version");
_version = asn1[0][0].Value[0];
// recipientInfos
ASN1 recipientInfos = asn1 [0][1];
if (recipientInfos.Tag != 0x31)
throw new ArgumentException ("missing RecipientInfos");
for (int i=0; i < recipientInfos.Count; i++) {
ASN1 recipientInfo = recipientInfos [i];
_recipientInfos.Add (new RecipientInfo (recipientInfo));
}
ASN1 encryptedContentInfo = asn1[0][2];
if (encryptedContentInfo.Tag != 0x30)
throw new ArgumentException ("missing EncryptedContentInfo");
ASN1 contentType = encryptedContentInfo [0];
if (contentType.Tag != 0x06)
throw new ArgumentException ("missing EncryptedContentInfo.ContentType");
_content = new ContentInfo (ASN1Convert.ToOid (contentType));
ASN1 contentEncryptionAlgorithm = encryptedContentInfo [1];
if (contentEncryptionAlgorithm.Tag != 0x30)
throw new ArgumentException ("missing EncryptedContentInfo.ContentEncryptionAlgorithmIdentifier");
_encryptionAlgorithm = new ContentInfo (ASN1Convert.ToOid (contentEncryptionAlgorithm [0]));
_encryptionAlgorithm.Content = contentEncryptionAlgorithm [1];
ASN1 encryptedContent = encryptedContentInfo [2];
if (encryptedContent.Tag != 0x80)
throw new ArgumentException ("missing EncryptedContentInfo.EncryptedContent");
_encrypted = encryptedContent.Value;
}
public ArrayList RecipientInfos {
get { return _recipientInfos; }
}
public ASN1 ASN1 {
get { return GetASN1(); }
}
public ContentInfo ContentInfo {
get { return _content; }
}
public ContentInfo EncryptionAlgorithm {
get { return _encryptionAlgorithm; }
}
public byte[] EncryptedContent {
get {
if (_encrypted == null)
return null;
return (byte[]) _encrypted.Clone ();
}
}
public byte Version {
get { return _version; }
set { _version = value; }
}
internal ASN1 GetASN1 ()
{
// SignedData ::= SEQUENCE {
ASN1 signedData = new ASN1 (0x30);
// version Version -> Version ::= INTEGER
/* byte[] ver = { _version };
signedData.Add (new ASN1 (0x02, ver));
// digestAlgorithms DigestAlgorithmIdentifiers -> DigestAlgorithmIdentifiers ::= SET OF DigestAlgorithmIdentifier
ASN1 digestAlgorithms = signedData.Add (new ASN1 (0x31));
if (hashAlgorithm != null) {
string hashOid = CryptoConfig.MapNameToOid (hashAlgorithm);
digestAlgorithms.Add (AlgorithmIdentifier (hashOid));
}
// contentInfo ContentInfo,
ASN1 ci = contentInfo.ASN1;
signedData.Add (ci);
if ((mda == null) && (hashAlgorithm != null)) {
// automatically add the messageDigest authenticated attribute
HashAlgorithm ha = HashAlgorithm.Create (hashAlgorithm);
byte[] idcHash = ha.ComputeHash (ci[1][0].Value);
ASN1 md = new ASN1 (0x30);
mda = Attribute (messageDigest, md.Add (new ASN1 (0x04, idcHash)));
signerInfo.AuthenticatedAttributes.Add (mda);
}
// certificates [0] IMPLICIT ExtendedCertificatesAndCertificates OPTIONAL,
if (certs.Count > 0) {
ASN1 a0 = signedData.Add (new ASN1 (0xA0));
foreach (X509Certificate x in certs)
a0.Add (new ASN1 (x.RawData));
}
// crls [1] IMPLICIT CertificateRevocationLists OPTIONAL,
if (crls.Count > 0) {
ASN1 a1 = signedData.Add (new ASN1 (0xA1));
foreach (byte[] crl in crls)
a1.Add (new ASN1 (crl));
}
// signerInfos SignerInfos -> SignerInfos ::= SET OF SignerInfo
ASN1 signerInfos = signedData.Add (new ASN1 (0x31));
if (signerInfo.Key != null)
signerInfos.Add (signerInfo.ASN1);*/
return signedData;
}
public byte[] GetBytes () {
return GetASN1 ().GetBytes ();
}
}
/* RecipientInfo ::= SEQUENCE {
* version Version,
* issuerAndSerialNumber IssuerAndSerialNumber,
* keyEncryptionAlgorithm KeyEncryptionAlgorithmIdentifier,
* encryptedKey EncryptedKey
* }
*
* KeyEncryptionAlgorithmIdentifier ::= AlgorithmIdentifier
*
* EncryptedKey ::= OCTET STRING
*/
public class RecipientInfo {
private int _version;
private string _oid;
private byte[] _key;
private byte[] _ski;
private string _issuer;
private byte[] _serial;
public RecipientInfo () {}
public RecipientInfo (ASN1 data)
{
if (data.Tag != 0x30)
throw new ArgumentException ("Invalid RecipientInfo");
ASN1 version = data [0];
if (version.Tag != 0x02)
throw new ArgumentException ("missing Version");
_version = version.Value [0];
// issuerAndSerialNumber IssuerAndSerialNumber
ASN1 subjectIdentifierType = data [1];
if ((subjectIdentifierType.Tag == 0x80) && (_version == 3)) {
_ski = subjectIdentifierType.Value;
}
else {
_issuer = X501.ToString (subjectIdentifierType [0]);
_serial = subjectIdentifierType [1].Value;
}
ASN1 keyEncryptionAlgorithm = data [2];
_oid = ASN1Convert.ToOid (keyEncryptionAlgorithm [0]);
ASN1 encryptedKey = data [3];
_key = encryptedKey.Value;
}
public string Oid {
get { return _oid; }
}
public byte[] Key {
get {
if (_key == null)
return null;
return (byte[]) _key.Clone ();
}
}
public byte[] SubjectKeyIdentifier {
get {
if (_ski == null)
return null;
return (byte[]) _ski.Clone ();
}
}
public string Issuer {
get { return _issuer; }
}
public byte[] Serial {
get {
if (_serial == null)
return null;
return (byte[]) _serial.Clone ();
}
}
public int Version {
get { return _version; }
}
}
/*
* SignedData ::= SEQUENCE {
* version Version,
* digestAlgorithms DigestAlgorithmIdentifiers,
* contentInfo ContentInfo,
* certificates [0] IMPLICIT ExtendedCertificatesAndCertificates OPTIONAL,
* crls [1] IMPLICIT CertificateRevocationLists OPTIONAL,
* signerInfos SignerInfos
* }
*/
public class SignedData {
private byte version;
private string hashAlgorithm;
private ContentInfo contentInfo;
private X509CertificateCollection certs;
private ArrayList crls;
private SignerInfo signerInfo;
private bool mda;
private bool signed;
public SignedData ()
{
version = 1;
contentInfo = new ContentInfo ();
certs = new X509CertificateCollection ();
crls = new ArrayList ();
signerInfo = new SignerInfo ();
mda = true;
signed = false;
}
public SignedData (byte[] data)
: this (new ASN1 (data))
{
}
public SignedData (ASN1 asn1)
{
if ((asn1[0].Tag != 0x30) || (asn1[0].Count < 4))
throw new ArgumentException ("Invalid SignedData");
if (asn1[0][0].Tag != 0x02)
throw new ArgumentException ("Invalid version");
version = asn1[0][0].Value[0];
contentInfo = new ContentInfo (asn1[0][2]);
int n = 3;
certs = new X509CertificateCollection ();
if (asn1[0][n].Tag == 0xA0) {
for (int i=0; i < asn1[0][n].Count; i++)
certs.Add (new X509Certificate (asn1[0][n][i].GetBytes ()));
n++;
}
crls = new ArrayList ();
if (asn1[0][n].Tag == 0xA1) {
for (int i=0; i < asn1[0][n].Count; i++)
crls.Add (asn1[0][n][i].GetBytes ());
n++;
}
if (asn1[0][n].Count > 0)
signerInfo = new SignerInfo (asn1[0][n]);
else
signerInfo = new SignerInfo ();
// Exchange hash algorithm Oid from SignerInfo
if (signerInfo.HashName != null) {
HashName = OidToName(signerInfo.HashName);
}
// Check if SignerInfo has authenticated attributes
mda = (signerInfo.AuthenticatedAttributes.Count > 0);
}
public ASN1 ASN1 {
get { return GetASN1(); }
}
public X509CertificateCollection Certificates {
get { return certs; }
}
public ContentInfo ContentInfo {
get { return contentInfo; }
}
public ArrayList Crls {
get { return crls; }
}
public string HashName {
get { return hashAlgorithm; }
// todo add validation
set {
hashAlgorithm = value;
signerInfo.HashName = value;
}
}
public SignerInfo SignerInfo {
get { return signerInfo; }
}
public byte Version {
get { return version; }
set { version = value; }
}
public bool UseAuthenticatedAttributes {
get { return mda; }
set { mda = value; }
}
public bool VerifySignature (AsymmetricAlgorithm aa)
{
if (aa == null) {
return false;
}
RSAPKCS1SignatureDeformatter r = new RSAPKCS1SignatureDeformatter (aa);
r.SetHashAlgorithm (hashAlgorithm);
HashAlgorithm ha = HashAlgorithm.Create (hashAlgorithm);
byte[] signature = signerInfo.Signature;
byte[] hash = null;
if (mda) {
ASN1 asn = new ASN1 (0x31);
foreach (ASN1 attr in signerInfo.AuthenticatedAttributes)
asn.Add (attr);
hash = ha.ComputeHash (asn.GetBytes ());
} else {
hash = ha.ComputeHash (contentInfo.Content[0].Value);
}
if (hash != null && signature != null) {
return r.VerifySignature (hash, signature);
}
return false;
}
internal string OidToName (string oid)
{
switch (oid) {
case "1.3.14.3.2.26" :
return "SHA1";
case "1.2.840.113549.2.2" :
return "MD2";
case "1.2.840.113549.2.5" :
return "MD5";
case "2.16.840.1.101.3.4.1" :
return "SHA256";
case "2.16.840.1.101.3.4.2" :
return "SHA384";
case "2.16.840.1.101.3.4.3" :
return "SHA512";
default :
break;
}
// Unknown Oid
return oid;
}
internal ASN1 GetASN1 ()
{
// SignedData ::= SEQUENCE {
ASN1 signedData = new ASN1 (0x30);
// version Version -> Version ::= INTEGER
byte[] ver = { version };
signedData.Add (new ASN1 (0x02, ver));
// digestAlgorithms DigestAlgorithmIdentifiers -> DigestAlgorithmIdentifiers ::= SET OF DigestAlgorithmIdentifier
ASN1 digestAlgorithms = signedData.Add (new ASN1 (0x31));
if (hashAlgorithm != null) {
string hashOid = CryptoConfig.MapNameToOID (hashAlgorithm);
digestAlgorithms.Add (AlgorithmIdentifier (hashOid));
}
// contentInfo ContentInfo,
ASN1 ci = contentInfo.ASN1;
signedData.Add (ci);
if (!signed && (hashAlgorithm != null)) {
if (mda) {
// Use authenticated attributes for signature
// Automatically add the contentType authenticated attribute
ASN1 ctattr = Attribute (Oid.contentType, ci[0]);
signerInfo.AuthenticatedAttributes.Add (ctattr);
// Automatically add the messageDigest authenticated attribute
HashAlgorithm ha = HashAlgorithm.Create (hashAlgorithm);
byte[] idcHash = ha.ComputeHash (ci[1][0].Value);
ASN1 md = new ASN1 (0x30);
ASN1 mdattr = Attribute (Oid.messageDigest, md.Add (new ASN1 (0x04, idcHash)));
signerInfo.AuthenticatedAttributes.Add (mdattr);
} else {
// Don't use authenticated attributes for signature -- signature is content
RSAPKCS1SignatureFormatter r = new RSAPKCS1SignatureFormatter (signerInfo.Key);
r.SetHashAlgorithm (hashAlgorithm);
HashAlgorithm ha = HashAlgorithm.Create (hashAlgorithm);
byte[] sig = ha.ComputeHash (ci[1][0].Value);
signerInfo.Signature = r.CreateSignature (sig);
}
signed = true;
}
// certificates [0] IMPLICIT ExtendedCertificatesAndCertificates OPTIONAL,
if (certs.Count > 0) {
ASN1 a0 = signedData.Add (new ASN1 (0xA0));
foreach (X509Certificate x in certs)
a0.Add (new ASN1 (x.RawData));
}
// crls [1] IMPLICIT CertificateRevocationLists OPTIONAL,
if (crls.Count > 0) {
ASN1 a1 = signedData.Add (new ASN1 (0xA1));
foreach (byte[] crl in crls)
a1.Add (new ASN1 (crl));
}
// signerInfos SignerInfos -> SignerInfos ::= SET OF SignerInfo
ASN1 signerInfos = signedData.Add (new ASN1 (0x31));
if (signerInfo.Key != null)
signerInfos.Add (signerInfo.ASN1);
return signedData;
}
public byte[] GetBytes ()
{
return GetASN1 ().GetBytes ();
}
}
/*
* SignerInfo ::= SEQUENCE {
* version Version,
* issuerAndSerialNumber IssuerAndSerialNumber,
* digestAlgorithm DigestAlgorithmIdentifier,
* authenticatedAttributes [0] IMPLICIT Attributes OPTIONAL,
* digestEncryptionAlgorithm DigestEncryptionAlgorithmIdentifier,
* encryptedDigest EncryptedDigest,
* unauthenticatedAttributes [1] IMPLICIT Attributes OPTIONAL
* }
*
* For version == 3 issuerAndSerialNumber may be replaced by ...
*/
public class SignerInfo {
private byte version;
private X509Certificate x509;
private string hashAlgorithm;
private AsymmetricAlgorithm key;
private ArrayList authenticatedAttributes;
private ArrayList unauthenticatedAttributes;
private byte[] signature;
private string issuer;
private byte[] serial;
private byte[] ski;
public SignerInfo ()
{
version = 1;
authenticatedAttributes = new ArrayList ();
unauthenticatedAttributes = new ArrayList ();
}
public SignerInfo (byte[] data)
: this (new ASN1 (data)) {}
// TODO: INCOMPLETE
public SignerInfo (ASN1 asn1) : this ()
{
if ((asn1[0].Tag != 0x30) || (asn1[0].Count < 5))
throw new ArgumentException ("Invalid SignedData");
// version Version
if (asn1[0][0].Tag != 0x02)
throw new ArgumentException ("Invalid version");
version = asn1[0][0].Value[0];
// issuerAndSerialNumber IssuerAndSerialNumber
ASN1 subjectIdentifierType = asn1 [0][1];
if ((subjectIdentifierType.Tag == 0x80) && (version == 3)) {
ski = subjectIdentifierType.Value;
}
else {
issuer = X501.ToString (subjectIdentifierType [0]);
serial = subjectIdentifierType [1].Value;
}
// digestAlgorithm DigestAlgorithmIdentifier
ASN1 digestAlgorithm = asn1 [0][2];
hashAlgorithm = ASN1Convert.ToOid (digestAlgorithm [0]);
// authenticatedAttributes [0] IMPLICIT Attributes OPTIONAL
int n = 3;
ASN1 authAttributes = asn1 [0][n];
if (authAttributes.Tag == 0xA0) {
n++;
for (int i=0; i < authAttributes.Count; i++)
authenticatedAttributes.Add (authAttributes [i]);
}
// digestEncryptionAlgorithm DigestEncryptionAlgorithmIdentifier
n++;
// ASN1 digestEncryptionAlgorithm = asn1 [0][n++];
// string digestEncryptionAlgorithmOid = ASN1Convert.ToOid (digestEncryptionAlgorithm [0]);
// encryptedDigest EncryptedDigest
ASN1 encryptedDigest = asn1 [0][n++];
if (encryptedDigest.Tag == 0x04)
signature = encryptedDigest.Value;
// unauthenticatedAttributes [1] IMPLICIT Attributes OPTIONAL
ASN1 unauthAttributes = asn1 [0][n];
if ((unauthAttributes != null) && (unauthAttributes.Tag == 0xA1)) {
for (int i=0; i < unauthAttributes.Count; i++)
unauthenticatedAttributes.Add (unauthAttributes [i]);
}
}
public string IssuerName {
get { return issuer; }
}
public byte[] SerialNumber {
get {
if (serial == null)
return null;
return (byte[]) serial.Clone ();
}
}
public byte[] SubjectKeyIdentifier {
get {
if (ski == null)
return null;
return (byte[]) ski.Clone ();
}
}
public ASN1 ASN1 {
get { return GetASN1(); }
}
public ArrayList AuthenticatedAttributes {
get { return authenticatedAttributes; }
}
public X509Certificate Certificate {
get { return x509; }
set { x509 = value; }
}
public string HashName {
get { return hashAlgorithm; }
set { hashAlgorithm = value; }
}
public AsymmetricAlgorithm Key {
get { return key; }
set { key = value; }
}
public byte[] Signature {
get {
if (signature == null)
return null;
return (byte[]) signature.Clone ();
}
set {
if (value != null) {
signature = (byte[]) value.Clone ();
}
}
}
public ArrayList UnauthenticatedAttributes {
get { return unauthenticatedAttributes; }
}
public byte Version {
get { return version; }
set { version = value; }
}
internal ASN1 GetASN1 ()
{
if ((key == null) || (hashAlgorithm == null))
return null;
byte[] ver = { version };
ASN1 signerInfo = new ASN1 (0x30);
// version Version -> Version ::= INTEGER
signerInfo.Add (new ASN1 (0x02, ver));
// issuerAndSerialNumber IssuerAndSerialNumber,
signerInfo.Add (PKCS7.IssuerAndSerialNumber (x509));
// digestAlgorithm DigestAlgorithmIdentifier,
string hashOid = CryptoConfig.MapNameToOID (hashAlgorithm);
signerInfo.Add (AlgorithmIdentifier (hashOid));
// authenticatedAttributes [0] IMPLICIT Attributes OPTIONAL,
ASN1 aa = null;
if (authenticatedAttributes.Count > 0) {
aa = signerInfo.Add (new ASN1 (0xA0));
authenticatedAttributes.Sort(new SortedSet ());
foreach (ASN1 attr in authenticatedAttributes)
aa.Add (attr);
}
// digestEncryptionAlgorithm DigestEncryptionAlgorithmIdentifier,
if (key is RSA) {
signerInfo.Add (AlgorithmIdentifier (PKCS7.Oid.rsaEncryption));
if (aa != null) {
// Calculate the signature here; otherwise it must be set from SignedData
RSAPKCS1SignatureFormatter r = new RSAPKCS1SignatureFormatter (key);
r.SetHashAlgorithm (hashAlgorithm);
byte[] tbs = aa.GetBytes ();
tbs [0] = 0x31; // not 0xA0 for signature
HashAlgorithm ha = HashAlgorithm.Create (hashAlgorithm);
byte[] tbsHash = ha.ComputeHash (tbs);
signature = r.CreateSignature (tbsHash);
}
}
else if (key is DSA) {
throw new NotImplementedException ("not yet");
}
else
throw new CryptographicException ("Unknown assymetric algorithm");
// encryptedDigest EncryptedDigest,
signerInfo.Add (new ASN1 (0x04, signature));
// unauthenticatedAttributes [1] IMPLICIT Attributes OPTIONAL
if (unauthenticatedAttributes.Count > 0) {
ASN1 ua = signerInfo.Add (new ASN1 (0xA1));
unauthenticatedAttributes.Sort(new SortedSet ());
foreach (ASN1 attr in unauthenticatedAttributes)
ua.Add (attr);
}
return signerInfo;
}
public byte[] GetBytes ()
{
return GetASN1 ().GetBytes ();
}
}
internal class SortedSet : IComparer {
public int Compare (object x, object y)
{
if (x == null)
return (y == null) ? 0 : -1;
else if (y == null)
return 1;
ASN1 xx = x as ASN1;
ASN1 yy = y as ASN1;
if ((xx == null) || (yy == null)) {
throw new ArgumentException (("Invalid objects."));
}
byte[] xb = xx.GetBytes ();
byte[] yb = yy.GetBytes ();
for (int i = 0; i < xb.Length; i++) {
if (i == yb.Length)
break;
if (xb[i] == yb[i])
continue;
return (xb[i] < yb[i]) ? -1 : 1;
}
// The arrays are equal up to the shortest of them.
if (xb.Length > yb.Length)
return 1;
else if (xb.Length < yb.Length)
return -1;
return 0;
}
}
}
}