internal static AsnEncodedDataCollection DecodeSequence(AsnEncodedData encodedData)
{
if (encodedData == null)
{
throw new ArgumentNullException(nameof(encodedData));
}
byte[] rawData = encodedData.RawData;
int position = 0;
if (ReadTag(rawData, ref position) != AsnTag.Sequence)
{
throw new InvalidOperationException();
}
int end = position + ReadLength(rawData, ref position);
var result = new AsnEncodedDataCollection();
while (position < end)
{
result.Add(new AsnEncodedData(ReadTriplet(rawData, ref position)));
}
return(result);
}
public bool Equals(CryptographicAttributeObject x, CryptographicAttributeObject y)
{
if (x.Oid.Value != y.Oid.Value)
{
return(false);
}
AsnEncodedDataCollection xv = x.Values;
AsnEncodedDataCollection yv = y.Values;
if (xv.Count != yv.Count)
{
return(false);
}
for (int i = 0; i < xv.Count; i++)
{
AsnEncodedData xa = xv[i];
AsnEncodedData ya = yv[i];
if (xa.Oid.Value != ya.Oid.Value)
{
return(false);
}
if (!xa.RawData.SequenceEqual(ya.RawData))
{
return(false);
}
}
return(true);
}
public static void CopyExceptions()
{
AsnEncodedData a0 = new AsnEncodedData("1.0", Array.Empty <byte>());
AsnEncodedData a1 = new AsnEncodedData("1.1", Array.Empty <byte>());
AsnEncodedData a2 = new AsnEncodedData("1.2", Array.Empty <byte>());
AsnEncodedDataCollection c = new AsnEncodedDataCollection();
c.Add(a0);
c.Add(a1);
c.Add(a2);
Assert.Throws <ArgumentNullException>(() => c.CopyTo(null, 0));
AsnEncodedData[] a = new AsnEncodedData[3];
Assert.Throws <ArgumentOutOfRangeException>(() => c.CopyTo(a, -1));
Assert.Throws <ArgumentOutOfRangeException>(() => c.CopyTo(a, 3));
AssertExtensions.Throws <ArgumentException>("destinationArray", null, () => c.CopyTo(a, 1));
if (PlatformDetection.IsNonZeroLowerBoundArraySupported)
{
// Array has non-zero lower bound
ICollection ic = c;
Array array = Array.CreateInstance(typeof(object), new int[] { 10 }, new int[] { 10 });
Assert.Throws <IndexOutOfRangeException>(() => ic.CopyTo(array, 0));
}
}
public static void Oneary()
{
AsnEncodedData a0 = new AsnEncodedData("1.0", Array.Empty <byte>());
AsnEncodedDataCollection c = new AsnEncodedDataCollection(a0);
AssertEquals(c, new AsnEncodedData[] { a0 });
}
private static void AssertEquals(AsnEncodedDataCollection c, IList <AsnEncodedData> expected)
{
Assert.Equal(expected.Count, c.Count);
for (int i = 0; i < c.Count; i++)
{
Assert.Equal(expected[i], c[i]);
}
int index = 0;
foreach (AsnEncodedData a in c)
{
Assert.Equal(expected[index++], a);
}
Assert.Equal(c.Count, index);
ValidateEnumerator(c.GetEnumerator(), expected);
ValidateEnumerator(((ICollection)c).GetEnumerator(), expected);
AsnEncodedData[] dumped = new AsnEncodedData[c.Count + 3];
c.CopyTo(dumped, 2);
Assert.Null(dumped[0]);
Assert.Null(dumped[1]);
Assert.Null(dumped[dumped.Length - 1]);
Assert.Equal <AsnEncodedData>(expected, dumped.Skip(2).Take(c.Count));
}
public static void RemoveNonExistent()
{
AsnEncodedDataCollection c = new AsnEncodedDataCollection();
AsnEncodedData a0 = new AsnEncodedData("1.0", Array.Empty <byte>());
c.Remove(a0); // You can "remove" items that aren't in the collection - this is defined as a NOP.
}
static void TestAdd()
{
asn = new AsnEncodedDataCollection() ;
try
{
asn.Add( null ) ;
Result = false ;
}
catch( ArgumentNullException )
{
Result = true ;
}
catch( Exception )
{
Result = false ;
}
//add normal case
AsnEncodedData data1 = new AsnEncodedData( oid , new byte[]{1,2,3} ) ;
AsnEncodedData data2 = new AsnEncodedData( oid , new byte[]{5,6,7} ) ;
asn = new AsnEncodedDataCollection(data1) ;
asn.Add( data2 ) ;
Result = asn.Count == 2 ;
//Add where OIDs don't match
data2 = new AsnEncodedData(badOid , new byte[]{1,2,3,4} ) ;
asn = GetCollection(data1) ;
try
{
asn.Add(data2) ;
Result = false ;
}
catch(CryptographicException)
{
Result = true ;
}
catch(Exception e)
{
Result = false ;
Console.WriteLine(e) ;
}
//add w/ a empty Oid
data2.Oid = new Oid() ;
asn = GetCollection(data1) ;
try
{
asn.Add(data2) ;
Result = false ;
}
catch(CryptographicException)
{
Result = true ;
}
catch(Exception e)
{
Result = false ;
Console.WriteLine(e) ;
}
}
internal static AsnEncodedDataCollection GetAsnEncodedDataCollection(System.Security.Cryptography.CAPI.CRYPT_ATTRIBUTE_TYPE_VALUE cryptAttribute)
{
AsnEncodedDataCollection datas = new AsnEncodedDataCollection();
datas.Add(new Pkcs9AttributeObject(new Oid(cryptAttribute.pszObjId), System.Security.Cryptography.CAPI.BlobToByteArray(cryptAttribute.Value)));
return(datas);
}
static AsnEncodedDataCollection GetCollection(AsnEncodedData data)
{
AsnEncodedDataCollection asn = new AsnEncodedDataCollection(data);
FieldInfo fi = asn.GetType().GetField("m_oid", BindingFlags.NonPublic | BindingFlags.Instance);
fi.SetValue(asn, oid);
return(asn);
}
public void ConstructorOidAsnEncodedDataCollectionNull()
{
Oid o = new Oid(defaultOid);
AsnEncodedDataCollection coll = null;
CryptographicAttributeObject ca = new CryptographicAttributeObject(o, coll);
Assert.AreEqual(defaultName, ca.Oid.FriendlyName, "Oid.FriendlyName");
Assert.AreEqual(defaultOid, ca.Oid.Value, "Oid.Value");
Assert.AreEqual(0, ca.Values.Count, "Values");
}
/// <summary>
/// Enumerate AsnEncodedDataCollection
/// </summary>
private static List <AsnEncodedData> ToList(this AsnEncodedDataCollection collection)
{
var values = new List <AsnEncodedData>();
foreach (var value in collection)
{
values.Add(value);
}
return(values);
}
public void ConstructorOidCollection()
{
Oid o = new Oid(defaultOid);
AsnEncodedDataCollection coll = new AsnEncodedDataCollection();
CryptographicAttributeObject ca = new CryptographicAttributeObject(o, coll);
Assert.AreEqual(defaultName, ca.Oid.FriendlyName, "Oid.FriendlyName");
Assert.AreEqual(defaultOid, ca.Oid.Value, "Oid.Value");
Assert.AreEqual(0, ca.Values.Count, "Values - 0");
coll.Add(new AsnEncodedData(new byte [0]));
Assert.AreEqual(1, ca.Values.Count, "Values - 1");
}
public static void CryptographicAttributeObjectMismatch()
{
Oid oid = new Oid(Oids.DocumentDescription);
Oid wrongOid = new Oid(Oids.DocumentName);
AsnEncodedDataCollection col = new AsnEncodedDataCollection();
col.Add(new AsnEncodedData(oid, new byte[3]));
object ignore;
Assert.Throws <InvalidOperationException>(() => ignore = new CryptographicAttributeObject(wrongOid, col));
}
/// <summary>
/// Allows encoding data that the production helper does not.
/// </summary>
private static CryptographicAttributeObject GetCommitmentTypeTestAttribute(params string[] oids)
{
var commitmentTypeIndication = new Oid(Oids.CommitmentTypeIndication);
var values = new AsnEncodedDataCollection();
foreach (var oid in oids)
{
var value = DerEncoder.ConstructSequence(DerEncoder.SegmentedEncodeOid(oid));
values.Add(new AsnEncodedData(commitmentTypeIndication, value));
}
return(new CryptographicAttributeObject(commitmentTypeIndication, values));
}
public static void IndexOutOfBounds()
{
AsnEncodedData a0 = new AsnEncodedData("1.0", Array.Empty <byte>());
AsnEncodedData a1 = new AsnEncodedData("1.1", Array.Empty <byte>());
AsnEncodedData a2 = new AsnEncodedData("1.2", Array.Empty <byte>());
AsnEncodedDataCollection c = new AsnEncodedDataCollection();
c.Add(a0);
c.Add(a1);
c.Add(a2);
Assert.Throws <ArgumentOutOfRangeException>(() => c[-1]);
Assert.Throws <ArgumentOutOfRangeException>(() => c[3]);
}
private static unsafe void AddCryptAttribute(CryptographicAttributeObjectCollection collection, CRYPT_ATTRIBUTE *pCryptAttribute)
{
string oidValue = pCryptAttribute->pszObjId.ToStringAnsi();
Oid oid = new Oid(oidValue);
AsnEncodedDataCollection attributeCollection = new AsnEncodedDataCollection();
for (int i = 0; i < pCryptAttribute->cValue; i++)
{
byte[] encodedAttribute = pCryptAttribute->rgValue[i].ToByteArray();
AsnEncodedData attributeObject = PkcsHelpers.CreateBestPkcs9AttributeObjectAvailable(oid, encodedAttribute);
attributeCollection.Add(attributeObject);
}
collection.Add(new CryptographicAttributeObject(oid, attributeCollection));
}
private static AsnEncodedData[] FlattenAndSort(this CryptographicAttributeObjectCollection col)
{
List <AsnEncodedData> attributes = new List <AsnEncodedData>();
foreach (CryptographicAttributeObject cao in col)
{
AsnEncodedDataCollection acol = cao.Values;
foreach (AsnEncodedData a in acol)
{
attributes.Add(a);
}
}
return(attributes.OrderBy(a => a.RawData.ByteArrayToHex()).ToArray());
}
public static void Add()
{
AsnEncodedData a0 = new AsnEncodedData("1.0", Array.Empty<byte>());
AsnEncodedData a1 = new AsnEncodedData("1.1", Array.Empty<byte>());
AsnEncodedData a2 = new AsnEncodedData("1.2", Array.Empty<byte>());
AsnEncodedDataCollection c = new AsnEncodedDataCollection();
int index;
index = c.Add(a0);
Assert.Equal(0, index);
index = c.Add(a1);
Assert.Equal(1, index);
index = c.Add(a2);
Assert.Equal(2, index);
AssertEquals(c, new AsnEncodedData[] { a0, a1, a2 });
}
static void TestRemove()
{
asn = new AsnEncodedDataCollection();
try
{
asn.Remove(null);
Result = false;
}
catch (ArgumentNullException)
{
Result = true;
}
catch (Exception)
{
Result = false;
}
}
static void TestRemove()
{
asn = new AsnEncodedDataCollection() ;
try
{
asn.Remove( null ) ;
Result = false ;
}
catch( ArgumentNullException )
{
Result = true ;
}
catch( Exception )
{
Result = false ;
}
}
private static unsafe void AddCryptAttribute(CryptographicAttributeObjectCollection collection, CRYPT_ATTRIBUTE *pCryptAttribute)
{
string oidValue = pCryptAttribute->pszObjId.ToStringAnsi();
Oid oid = new Oid(oidValue);
AsnEncodedDataCollection attributeCollection = new AsnEncodedDataCollection();
for (int i = 0; i < pCryptAttribute->cValue; i++)
{
// CreateBestPkcs9AttributeObjectAvailable is expected to create a copy of the data so that it has ownership
// of the underlying data.
ReadOnlySpan <byte> encodedAttribute = pCryptAttribute->rgValue[i].DangerousAsSpan();
AsnEncodedData attributeObject = PkcsHelpers.CreateBestPkcs9AttributeObjectAvailable(oid, encodedAttribute);
attributeCollection.Add(attributeObject);
}
collection.Add(new CryptographicAttributeObject(oid, attributeCollection));
}
public static void CopyExceptions()
{
AsnEncodedData a0 = new AsnEncodedData("1.0", Array.Empty <byte>());
AsnEncodedData a1 = new AsnEncodedData("1.1", Array.Empty <byte>());
AsnEncodedData a2 = new AsnEncodedData("1.2", Array.Empty <byte>());
AsnEncodedDataCollection c = new AsnEncodedDataCollection();
c.Add(a0);
c.Add(a1);
c.Add(a2);
Assert.Throws <ArgumentNullException>(() => c.CopyTo(null, 0));
AsnEncodedData[] a = new AsnEncodedData[3];
Assert.Throws <ArgumentOutOfRangeException>(() => c.CopyTo(a, -1));
Assert.Throws <ArgumentOutOfRangeException>(() => c.CopyTo(a, 3));
Assert.Throws <ArgumentException>(() => c.CopyTo(a, 1));
}
public static void Add()
{
AsnEncodedData a0 = new AsnEncodedData("1.0", Array.Empty <byte>());
AsnEncodedData a1 = new AsnEncodedData("1.1", Array.Empty <byte>());
AsnEncodedData a2 = new AsnEncodedData("1.2", Array.Empty <byte>());
AsnEncodedDataCollection c = new AsnEncodedDataCollection();
int index;
index = c.Add(a0);
Assert.Equal(0, index);
index = c.Add(a1);
Assert.Equal(1, index);
index = c.Add(a2);
Assert.Equal(2, index);
AssertEquals(c, new AsnEncodedData[] { a0, a1, a2 });
}
/// <summary>
/// Get the ANS.1 encoded data from the certificate.
/// </summary>
/// <param name="certificate">The certificate.</param>
/// <returns>The collection of ANS.1 encoded data.</returns>
public AsnEncodedDataCollection GetData(X509Certificate2 certificate)
{
// Create a new AsnEncodedDataCollection object.
AsnEncodedDataCollection asncoll = new AsnEncodedDataCollection();
// Display extensions information.
foreach (X509Extension extension in certificate.Extensions)
{
// Create an AsnEncodedData object using the extensions information.
AsnEncodedData asndata = new AsnEncodedData(extension.Oid, extension.RawData);
// Add the AsnEncodedData object to the AsnEncodedDataCollection object.
asncoll.Add(asndata);
}
// Return the ASN.1 encoded data.
return(asncoll);
}
internal unsafe CryptographicAttributeObjectCollection ReadAttributes(CRYPT_ATTRIBUTES attributes)
{
var collection = new CryptographicAttributeObjectCollection();
var attributeSize = Marshal.SizeOf <CRYPT_ATTRIBUTE>();
var blobSize = Marshal.SizeOf <CRYPTOAPI_BLOB>();
for (var i = 0; i < attributes.cAttr; i++)
{
var structure = Marshal.PtrToStructure <CRYPT_ATTRIBUTE>(attributes.rgAttr + (i * attributeSize));
var asnValues = new AsnEncodedDataCollection();
for (var j = 0; j < structure.cValue; j++)
{
var blob = Marshal.PtrToStructure <CRYPTOAPI_BLOB>(structure.rgValue + j * blobSize);
asnValues.Add(new AsnEncodedData(structure.pszObjId, ReadBlob(blob)));
}
collection.Add(new CryptographicAttributeObject(new Oid(structure.pszObjId), asnValues));
}
return(collection);
}
public CryptographicAttributeObject(Oid oid, AsnEncodedDataCollection?values)
{
_oid = new Oid(oid);
if (values == null)
{
Values = new AsnEncodedDataCollection();
}
else
{
foreach (AsnEncodedData asn in values)
{
if (!string.Equals(asn.Oid !.Value, oid.Value, StringComparison.Ordinal))
{
throw new InvalidOperationException(string.Format(Strings.InvalidOperation_WrongOidInAsnCollection, oid.Value, asn.Oid.Value));
}
}
Values = values;
}
}
internal static AsnEncodedDataCollection GetAsnEncodedDataCollection(System.Security.Cryptography.CAPI.CRYPT_ATTRIBUTE cryptAttribute)
{
AsnEncodedDataCollection datas = new AsnEncodedDataCollection();
Oid oid = new Oid(cryptAttribute.pszObjId);
string name = oid.Value;
for (uint i = 0; i < cryptAttribute.cValue; i++)
{
IntPtr pBlob = new IntPtr(((long)cryptAttribute.rgValue) + (i * Marshal.SizeOf(typeof(System.Security.Cryptography.CAPI.CRYPTOAPI_BLOB))));
Pkcs9AttributeObject asnEncodedData = new Pkcs9AttributeObject(oid, System.Security.Cryptography.CAPI.BlobToByteArray(pBlob));
Pkcs9AttributeObject obj3 = CryptoConfig.CreateFromName(name) as Pkcs9AttributeObject;
if (obj3 != null)
{
obj3.CopyFrom(asnEncodedData);
asnEncodedData = obj3;
}
datas.Add(asnEncodedData);
}
return(datas);
}
internal static AsnEncodedDataCollection GetAsnEncodedDataCollection(CAPI.CRYPT_ATTRIBUTE cryptAttribute)
{
AsnEncodedDataCollection encodedDataCollection = new AsnEncodedDataCollection();
Oid oid = new Oid(cryptAttribute.pszObjId);
string name = oid.Value;
for (uint index = 0U; index < cryptAttribute.cValue; ++index)
{
IntPtr pBlob = new IntPtr((long)cryptAttribute.rgValue + (long)index * (long)Marshal.SizeOf(typeof(CAPI.CRYPTOAPI_BLOB)));
Pkcs9AttributeObject pkcs9AttributeObject1 = new Pkcs9AttributeObject(oid, CAPI.BlobToByteArray(pBlob));
Pkcs9AttributeObject pkcs9AttributeObject2 = CryptoConfig.CreateFromName(name) as Pkcs9AttributeObject;
if (pkcs9AttributeObject2 != null)
{
pkcs9AttributeObject2.CopyFrom((AsnEncodedData)pkcs9AttributeObject1);
pkcs9AttributeObject1 = pkcs9AttributeObject2;
}
encodedDataCollection.Add((AsnEncodedData)pkcs9AttributeObject1);
}
return(encodedDataCollection);
}
public static void AddFold()
{
AsnEncodedData dd1 = new Pkcs9DocumentDescription("My Description 1");
AsnEncodedData dd2 = new Pkcs9DocumentDescription("My Description 2");
CryptographicAttributeObjectCollection c = new CryptographicAttributeObjectCollection();
int index;
index = c.Add(dd1);
Assert.Equal(0, index);
index = c.Add(dd2);
Assert.Equal(0, index);
AsnEncodedDataCollection expectedValues = new AsnEncodedDataCollection();
expectedValues.Add(dd1);
expectedValues.Add(dd2);
CryptographicAttributeObject expected = new CryptographicAttributeObject(dd1.Oid, expectedValues);
AssertEquals(c, new CryptographicAttributeObject[] { expected });
}
public void ConstructorOidNullCollection()
{
AsnEncodedDataCollection coll = new AsnEncodedDataCollection();
CryptographicAttributeObject ca = new CryptographicAttributeObject(null, coll);
}
static Oid badOid = new Oid( "1.3.14.3.2.27" ) ; //bogus OID
static void TestCopyTo()
{
asn = GetCollection( new AsnEncodedData( oid , new byte[]{1,2,3} ) );
AsnEncodedData[] array = new AsnEncodedData[asn.Count] ;
//straight up copy
asn.CopyTo( array , 0 ) ;
Result = array[0] != null ;
//ary is null
try
{
asn.CopyTo( null , 0 ) ;
Result = false ;
}
catch(ArgumentNullException)
{
Result = true ;
}
catch(Exception e)
{
Result = false ;
Console.WriteLine(e) ;
}
//index is too big/small
try
{
asn.CopyTo( array , -1 ) ;
Result = false ;
}
catch(ArgumentOutOfRangeException)
{
Result = true ;
}
catch(Exception e)
{
Result = false ;
Console.WriteLine(e) ;
}
try
{
asn.CopyTo( array , 10 ) ;
Result = false ;
}
catch(ArgumentOutOfRangeException)
{
Result = true ;
}
catch(Exception e)
{
Result = false ;
Console.WriteLine(e) ;
}
//count + length mistmatch
try
{
asn.CopyTo( array , 1 ) ;
Result = false ;
}
catch(ArgumentException)
{
Result = true ;
}
catch(Exception e)
{
Result = false ;
Console.WriteLine(e) ;
}
}
public static void CopyExceptions()
{
AsnEncodedData a0 = new AsnEncodedData("1.0", Array.Empty<byte>());
AsnEncodedData a1 = new AsnEncodedData("1.1", Array.Empty<byte>());
AsnEncodedData a2 = new AsnEncodedData("1.2", Array.Empty<byte>());
AsnEncodedDataCollection c = new AsnEncodedDataCollection();
c.Add(a0);
c.Add(a1);
c.Add(a2);
Assert.Throws<ArgumentNullException>(() => c.CopyTo(null, 0));
AsnEncodedData[] a = new AsnEncodedData[3];
Assert.Throws<ArgumentOutOfRangeException>(() => c.CopyTo(a, -1));
Assert.Throws<ArgumentOutOfRangeException>(() => c.CopyTo(a, 3));
Assert.Throws<ArgumentException>(() => c.CopyTo(a, 1));
}
static AsnEncodedDataCollection GetCollection(AsnEncodedData data)
{
AsnEncodedDataCollection asn = new AsnEncodedDataCollection(data) ;
FieldInfo fi = asn.GetType().GetField( "m_oid" , BindingFlags.NonPublic | BindingFlags.Instance ) ;
fi.SetValue( asn , oid ) ;
return asn ;
}
public static void RemoveNegative()
{
AsnEncodedDataCollection c = new AsnEncodedDataCollection();
Assert.Throws <ArgumentNullException>(() => c.Remove(null));
}
public static void CopyExceptions()
{
AsnEncodedData a0 = new AsnEncodedData("1.0", Array.Empty<byte>());
AsnEncodedData a1 = new AsnEncodedData("1.1", Array.Empty<byte>());
AsnEncodedData a2 = new AsnEncodedData("1.2", Array.Empty<byte>());
AsnEncodedDataCollection c = new AsnEncodedDataCollection();
c.Add(a0);
c.Add(a1);
c.Add(a2);
Assert.Throws<ArgumentNullException>(() => c.CopyTo(null, 0));
AsnEncodedData[] a = new AsnEncodedData[3];
Assert.Throws<ArgumentOutOfRangeException>(() => c.CopyTo(a, -1));
Assert.Throws<ArgumentOutOfRangeException>(() => c.CopyTo(a, 3));
Assert.Throws<ArgumentException>(() => c.CopyTo(a, 1));
// Array has non-zero lower bound
ICollection ic = c;
Array array = Array.CreateInstance(typeof(object), new int[] { 10 }, new int[] { 10 });
Assert.Throws<IndexOutOfRangeException>(() => ic.CopyTo(array, 0));
}
public static void RemoveNegative()
{
AsnEncodedDataCollection c = new AsnEncodedDataCollection();
Assert.Throws<ArgumentNullException>(() => c.Remove(null));
}
public static void Nullary()
{
AsnEncodedDataCollection c = new AsnEncodedDataCollection();
AssertEquals(c, Array.Empty<AsnEncodedData>());
}
public static void Nullary()
{
AsnEncodedDataCollection c = new AsnEncodedDataCollection();
AssertEquals(c, Array.Empty <AsnEncodedData>());
}
public CryptographicAttributeObject(Oid oid, AsnEncodedDataCollection values) {}
public static void RemoveNonExistent()
{
AsnEncodedDataCollection c = new AsnEncodedDataCollection();
AsnEncodedData a0 = new AsnEncodedData("1.0", Array.Empty<byte>());
c.Remove(a0); // You can "remove" items that aren't in the collection - this is defined as a NOP.
}
//
// This returns an allocated native memory block. Its lifetime (and that of any allocated subblocks it may point to) is that of "hb".
//
private static unsafe CMSG_ENVELOPED_ENCODE_INFO *CreateCmsEnvelopedEncodeInfo(CmsRecipientCollection recipients, AlgorithmIdentifier contentEncryptionAlgorithm, X509Certificate2Collection originatorCerts, CryptographicAttributeObjectCollection unprotectedAttributes, HeapBlockRetainer hb)
{
CMSG_ENVELOPED_ENCODE_INFO *pEnvelopedEncodeInfo = (CMSG_ENVELOPED_ENCODE_INFO *)(hb.Alloc(sizeof(CMSG_ENVELOPED_ENCODE_INFO)));
pEnvelopedEncodeInfo->cbSize = sizeof(CMSG_ENVELOPED_ENCODE_INFO);
pEnvelopedEncodeInfo->hCryptProv = IntPtr.Zero;
string algorithmOidValue = contentEncryptionAlgorithm.Oid.Value;
pEnvelopedEncodeInfo->ContentEncryptionAlgorithm.pszObjId = hb.AllocAsciiString(algorithmOidValue);
// Desktop compat: Though it seems like we could copy over the contents of contentEncryptionAlgorithm.Parameters, that property is for retrieving information from decoded Cms's only, and it
// massages the raw data so it wouldn't be usable here anyway. To hammer home that fact, the EncryptedCms constructer rather rudely forces contentEncryptionAlgorithm.Parameters to be the empty array.
pEnvelopedEncodeInfo->ContentEncryptionAlgorithm.Parameters.cbData = 0;
pEnvelopedEncodeInfo->ContentEncryptionAlgorithm.Parameters.pbData = IntPtr.Zero;
pEnvelopedEncodeInfo->pvEncryptionAuxInfo = GenerateEncryptionAuxInfoIfNeeded(contentEncryptionAlgorithm, hb);
int numRecipients = recipients.Count;
pEnvelopedEncodeInfo->cRecipients = numRecipients;
pEnvelopedEncodeInfo->rgpRecipients = IntPtr.Zero;
CMSG_RECIPIENT_ENCODE_INFO *rgCmsRecipients = (CMSG_RECIPIENT_ENCODE_INFO *)(hb.Alloc(numRecipients, sizeof(CMSG_RECIPIENT_ENCODE_INFO)));
for (int index = 0; index < numRecipients; index++)
{
rgCmsRecipients[index] = EncodeRecipientInfo(recipients[index], contentEncryptionAlgorithm, hb);
}
pEnvelopedEncodeInfo->rgCmsRecipients = rgCmsRecipients;
int numCertificates = originatorCerts.Count;
pEnvelopedEncodeInfo->cCertEncoded = numCertificates;
pEnvelopedEncodeInfo->rgCertEncoded = null;
if (numCertificates != 0)
{
DATA_BLOB *pCertEncoded = (DATA_BLOB *)(hb.Alloc(numCertificates, sizeof(DATA_BLOB)));
for (int i = 0; i < numCertificates; i++)
{
byte[] certEncoded = originatorCerts[i].Export(X509ContentType.Cert);
pCertEncoded[i].cbData = (uint)(certEncoded.Length);
pCertEncoded[i].pbData = hb.AllocBytes(certEncoded);
}
pEnvelopedEncodeInfo->rgCertEncoded = pCertEncoded;
}
pEnvelopedEncodeInfo->cCrlEncoded = 0;
pEnvelopedEncodeInfo->rgCrlEncoded = null;
pEnvelopedEncodeInfo->cAttrCertEncoded = 0;
pEnvelopedEncodeInfo->rgAttrCertEncoded = null;
int numUnprotectedAttributes = unprotectedAttributes.Count;
pEnvelopedEncodeInfo->cUnprotectedAttr = numUnprotectedAttributes;
pEnvelopedEncodeInfo->rgUnprotectedAttr = null;
if (numUnprotectedAttributes != 0)
{
CRYPT_ATTRIBUTE *pCryptAttribute = (CRYPT_ATTRIBUTE *)(hb.Alloc(numUnprotectedAttributes, sizeof(CRYPT_ATTRIBUTE)));
for (int i = 0; i < numUnprotectedAttributes; i++)
{
CryptographicAttributeObject attribute = unprotectedAttributes[i];
pCryptAttribute[i].pszObjId = hb.AllocAsciiString(attribute.Oid.Value);
AsnEncodedDataCollection values = attribute.Values;
int numValues = values.Count;
pCryptAttribute[i].cValue = numValues;
DATA_BLOB *pValues = (DATA_BLOB *)(hb.Alloc(numValues, sizeof(DATA_BLOB)));
for (int j = 0; j < numValues; j++)
{
byte[] rawData = values[j].RawData;
pValues[j].cbData = (uint)(rawData.Length);
pValues[j].pbData = hb.AllocBytes(rawData);
}
pCryptAttribute[i].rgValue = pValues;
}
pEnvelopedEncodeInfo->rgUnprotectedAttr = pCryptAttribute;
}
return(pEnvelopedEncodeInfo);
}
private static void AssertEquals(AsnEncodedDataCollection c, IList<AsnEncodedData> expected)
{
Assert.Equal(expected.Count, c.Count);
for (int i = 0; i < c.Count; i++)
{
Assert.Equal(expected[i], c[i]);
}
int index = 0;
foreach (AsnEncodedData a in c)
{
Assert.Equal(expected[index++], a);
}
Assert.Equal(c.Count, index);
ValidateEnumerator(c.GetEnumerator(), expected);
ValidateEnumerator(((ICollection)c).GetEnumerator(), expected);
AsnEncodedData[] dumped = new AsnEncodedData[c.Count + 3];
c.CopyTo(dumped, 2);
Assert.Equal(null, dumped[0]);
Assert.Equal(null, dumped[1]);
Assert.Equal(null, dumped[dumped.Length - 1]);
Assert.Equal<AsnEncodedData>(expected, dumped.Skip(2).Take(c.Count));
}
public static void Oneary()
{
AsnEncodedData a0 = new AsnEncodedData("1.0", Array.Empty<byte>());
AsnEncodedDataCollection c = new AsnEncodedDataCollection(a0);
AssertEquals(c, new AsnEncodedData[] { a0 });
}
public static void IndexOutOfBounds()
{
AsnEncodedData a0 = new AsnEncodedData("1.0", Array.Empty<byte>());
AsnEncodedData a1 = new AsnEncodedData("1.1", Array.Empty<byte>());
AsnEncodedData a2 = new AsnEncodedData("1.2", Array.Empty<byte>());
AsnEncodedDataCollection c = new AsnEncodedDataCollection();
c.Add(a0);
c.Add(a1);
c.Add(a2);
Assert.Throws<ArgumentOutOfRangeException>(() => c[-1]);
Assert.Throws<ArgumentOutOfRangeException>(() => c[3]);
}
