internal void Reset(SubjectIdentifierType type, object value)
{
switch (type)
{
case SubjectIdentifierType.Unknown:
case SubjectIdentifierType.NoSignature:
break;
case SubjectIdentifierType.IssuerAndSerialNumber:
if (value.GetType() != typeof(X509IssuerSerial))
{
throw new CryptographicException(SecurityResources.GetResourceString("Cryptography_Cms_Invalid_Subject_Identifier_Type_Value_Mismatch"), value.GetType().ToString());
}
break;
case SubjectIdentifierType.SubjectKeyIdentifier:
if (!PkcsUtils.CmsSupported())
{
throw new CryptographicException(SecurityResources.GetResourceString("Cryptography_Cms_Not_Supported"));
}
if (value.GetType() != typeof(string))
{
throw new CryptographicException(SecurityResources.GetResourceString("Cryptography_Cms_Invalid_Subject_Identifier_Type_Value_Mismatch"), value.GetType().ToString());
}
break;
default:
throw new CryptographicException(SecurityResources.GetResourceString("Cryptography_Cms_Invalid_Subject_Identifier_Type"), type.ToString());
}
this.m_type = type;
this.m_value = value;
}
//
// Private methods.
//
private void Reset(SubjectIdentifierType recipientIdentifierType, X509Certificate2 certificate)
{
if (certificate == null)
{
throw new ArgumentNullException("certificate");
}
switch (recipientIdentifierType)
{
case SubjectIdentifierType.Unknown:
recipientIdentifierType = SubjectIdentifierType.IssuerAndSerialNumber;
break;
case SubjectIdentifierType.IssuerAndSerialNumber:
break;
case SubjectIdentifierType.SubjectKeyIdentifier:
if (!PkcsUtils.CmsSupported())
{
throw new CryptographicException(SecurityResources.GetResourceString("Cryptography_Cms_Not_Supported"));
}
break;
default:
throw new CryptographicException(SecurityResources.GetResourceString("Cryptography_Cms_Invalid_Subject_Identifier_Type"), recipientIdentifierType.ToString());
}
m_recipientIdentifierType = recipientIdentifierType;
m_certificate = certificate;
}
internal unsafe RecipientInfoCollection(SafeCryptMsgHandle safeCryptMsgHandle)
{
bool cmsSupported = PkcsUtils.CmsSupported();
uint dwRecipients = 0;
uint cbCount = (uint)Marshal.SizeOf(typeof(uint));
// Use CMS if supported.
if (cmsSupported)
{
// CMS.
if (!CAPI.CAPISafe.CryptMsgGetParam(safeCryptMsgHandle,
CAPI.CMSG_CMS_RECIPIENT_COUNT_PARAM,
0,
new IntPtr(&dwRecipients),
new IntPtr(&cbCount)))
{
throw new CryptographicException(Marshal.GetLastWin32Error());
}
}
else
{
// PKCS7.
if (!CAPI.CAPISafe.CryptMsgGetParam(safeCryptMsgHandle,
CAPI.CMSG_RECIPIENT_COUNT_PARAM,
0,
new IntPtr(&dwRecipients),
new IntPtr(&cbCount)))
{
throw new CryptographicException(Marshal.GetLastWin32Error());
}
}
m_recipientInfos = new ArrayList();
for (uint index = 0; index < dwRecipients; index++)
{
if (cmsSupported)
{
uint cbCmsRecipientInfo;
SafeLocalAllocHandle pbCmsRecipientInfo;
PkcsUtils.GetParam(safeCryptMsgHandle, CAPI.CMSG_CMS_RECIPIENT_INFO_PARAM, index, out pbCmsRecipientInfo, out cbCmsRecipientInfo);
CAPI.CMSG_CMS_RECIPIENT_INFO cmsRecipientInfo = (CAPI.CMSG_CMS_RECIPIENT_INFO)Marshal.PtrToStructure(pbCmsRecipientInfo.DangerousGetHandle(), typeof(CAPI.CMSG_CMS_RECIPIENT_INFO));
switch (cmsRecipientInfo.dwRecipientChoice)
{
case CAPI.CMSG_KEY_TRANS_RECIPIENT:
CAPI.CMSG_KEY_TRANS_RECIPIENT_INFO keyTrans = (CAPI.CMSG_KEY_TRANS_RECIPIENT_INFO)Marshal.PtrToStructure(cmsRecipientInfo.pRecipientInfo, typeof(CAPI.CMSG_KEY_TRANS_RECIPIENT_INFO));
m_recipientInfos.Add(new KeyTransRecipientInfo(pbCmsRecipientInfo, keyTrans, index));
break;
case CAPI.CMSG_KEY_AGREE_RECIPIENT:
CAPI.CMSG_KEY_AGREE_RECIPIENT_INFO keyAgree = (CAPI.CMSG_KEY_AGREE_RECIPIENT_INFO)Marshal.PtrToStructure(cmsRecipientInfo.pRecipientInfo, typeof(CAPI.CMSG_KEY_AGREE_RECIPIENT_INFO));
switch (keyAgree.dwOriginatorChoice)
{
case CAPI.CMSG_KEY_AGREE_ORIGINATOR_CERT:
CAPI.CMSG_KEY_AGREE_CERT_ID_RECIPIENT_INFO certIdRecipient = (CAPI.CMSG_KEY_AGREE_CERT_ID_RECIPIENT_INFO)Marshal.PtrToStructure(cmsRecipientInfo.pRecipientInfo, typeof(CAPI.CMSG_KEY_AGREE_CERT_ID_RECIPIENT_INFO));
for (uint cRecipient = 0; cRecipient < certIdRecipient.cRecipientEncryptedKeys; cRecipient++)
{
m_recipientInfos.Add(new KeyAgreeRecipientInfo(pbCmsRecipientInfo, certIdRecipient, index, cRecipient));
}
break;
case CAPI.CMSG_KEY_AGREE_ORIGINATOR_PUBLIC_KEY:
CAPI.CMSG_KEY_AGREE_PUBLIC_KEY_RECIPIENT_INFO publicKeyRecipient = (CAPI.CMSG_KEY_AGREE_PUBLIC_KEY_RECIPIENT_INFO)Marshal.PtrToStructure(cmsRecipientInfo.pRecipientInfo, typeof(CAPI.CMSG_KEY_AGREE_PUBLIC_KEY_RECIPIENT_INFO));
for (uint cRecipient = 0; cRecipient < publicKeyRecipient.cRecipientEncryptedKeys; cRecipient++)
{
m_recipientInfos.Add(new KeyAgreeRecipientInfo(pbCmsRecipientInfo, publicKeyRecipient, index, cRecipient));
}
break;
default:
throw new CryptographicException(SecurityResources.GetResourceString("Cryptography_Cms_Invalid_Originator_Identifier_Choice"), keyAgree.dwOriginatorChoice.ToString(CultureInfo.CurrentCulture));
}
break;
default:
throw new CryptographicException(CAPI.E_NOTIMPL);
}
}
else
{
uint cbCertInfo;
SafeLocalAllocHandle pbCertInfo;
PkcsUtils.GetParam(safeCryptMsgHandle, CAPI.CMSG_RECIPIENT_INFO_PARAM, index, out pbCertInfo, out cbCertInfo);
CAPI.CERT_INFO certInfo = (CAPI.CERT_INFO)Marshal.PtrToStructure(pbCertInfo.DangerousGetHandle(), typeof(CAPI.CERT_INFO));
m_recipientInfos.Add(new KeyTransRecipientInfo(pbCertInfo, certInfo, index));
}
}
m_safeCryptMsgHandle = safeCryptMsgHandle;
}
private unsafe void RemoveCounterSignature(int parentIndex, int childIndex)
{
// Just make sure this is non-negative.
if (parentIndex < 0)
{
throw new ArgumentOutOfRangeException("parentIndex");
}
if (childIndex < 0)
{
throw new ArgumentOutOfRangeException("childIndex");
}
uint cbCmsgCmsSignerInfo = 0;
SafeLocalAllocHandle pbCmsgCmsSignerInfo = SafeLocalAllocHandle.InvalidHandle;
uint cbCmsgSignerInfo = 0;
SafeLocalAllocHandle pbCmsgSignerInfo = SafeLocalAllocHandle.InvalidHandle;
uint index = 0;
uint cAttr = 0;
IntPtr pAttr = IntPtr.Zero;
SafeCryptMsgHandle hMsg = m_signedCms.GetCryptMsgHandle();
if (PkcsUtils.CmsSupported())
{
PkcsUtils.GetParam(hMsg,
CAPI.CMSG_CMS_SIGNER_INFO_PARAM,
(uint)parentIndex,
out pbCmsgCmsSignerInfo,
out cbCmsgCmsSignerInfo);
CAPI.CMSG_CMS_SIGNER_INFO cmsgCmsSignerInfo = (CAPI.CMSG_CMS_SIGNER_INFO)Marshal.PtrToStructure(pbCmsgCmsSignerInfo.DangerousGetHandle(), typeof(CAPI.CMSG_CMS_SIGNER_INFO));
cAttr = cmsgCmsSignerInfo.UnauthAttrs.cAttr;
pAttr = new IntPtr((long)cmsgCmsSignerInfo.UnauthAttrs.rgAttr);
}
else
{
PkcsUtils.GetParam(hMsg,
CAPI.CMSG_SIGNER_INFO_PARAM,
(uint)parentIndex,
out pbCmsgSignerInfo,
out cbCmsgSignerInfo);
CAPI.CMSG_SIGNER_INFO cmsgSignerInfo = (CAPI.CMSG_SIGNER_INFO)Marshal.PtrToStructure(pbCmsgSignerInfo.DangerousGetHandle(), typeof(CAPI.CMSG_SIGNER_INFO));
cAttr = cmsgSignerInfo.UnauthAttrs.cAttr;
pAttr = new IntPtr((long)cmsgSignerInfo.UnauthAttrs.rgAttr);
}
// Find index for counter signature attribute.
// Note: It is not guaranteed that CAPI will keep all counter signatures
// in one single unauthenticated attribute. So we need to find the correct
// unauthenticated attribute containing this counter signer which is
// identified by index.
for (index = 0; index < cAttr; index++)
{
checked {
CAPI.CRYPT_ATTRIBUTE attr = (CAPI.CRYPT_ATTRIBUTE)Marshal.PtrToStructure(pAttr, typeof(CAPI.CRYPT_ATTRIBUTE));
if (String.Compare(attr.pszObjId, CAPI.szOID_RSA_counterSign, StringComparison.OrdinalIgnoreCase) == 0)
{
if (attr.cValue > 0)
{
// Is it in this attribute?
if (childIndex < (int)attr.cValue)
{
// Found the desired counter signature attribute. So, first remove the
// entire attribute, then remove just the counter signature from the
// retrieved attribute, and finally add back the modified attribute,
// if necessary.
CAPI.CMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR_PARA delPara = new CAPI.CMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR_PARA(Marshal.SizeOf(typeof(CAPI.CMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR_PARA)));
delPara.dwSignerIndex = (uint)parentIndex;
delPara.dwUnauthAttrIndex = index;
if (!CAPI.CryptMsgControl(hMsg,
0,
CAPI.CMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR,
new IntPtr(&delPara)))
{
throw new CryptographicException(Marshal.GetLastWin32Error());
}
// No need to add back if only one counter signature in this attribute.
if (attr.cValue > 1)
{
try {
// There were more than one counter signatures in this attribute, so
// need to add back a new counter signature attribute which includes
// the remaining counter signatures.
uint cbCounterSignatureValue = (uint)((attr.cValue - 1) * Marshal.SizeOf(typeof(CAPI.CRYPTOAPI_BLOB)));
SafeLocalAllocHandle pbCounterSignatureValue = CAPI.LocalAlloc(CAPI.LPTR, new IntPtr(cbCounterSignatureValue));
// Copy everything except the one being removed.
CAPI.CRYPTOAPI_BLOB *pOldValue = (CAPI.CRYPTOAPI_BLOB *)attr.rgValue;
CAPI.CRYPTOAPI_BLOB *pNewValue = (CAPI.CRYPTOAPI_BLOB *)pbCounterSignatureValue.DangerousGetHandle();
for (int i = 0; i < (int)attr.cValue; i++, pOldValue++, pNewValue++)
{
if (i != childIndex)
{
*pNewValue = *pOldValue;
}
}
// Encode the new counter signature attribute.
byte[] encodedNewAttribute;
CAPI.CRYPT_ATTRIBUTE newAttr = new CAPI.CRYPT_ATTRIBUTE();
newAttr.pszObjId = attr.pszObjId;
newAttr.cValue = attr.cValue - 1;
newAttr.rgValue = pbCounterSignatureValue.DangerousGetHandle();
SafeLocalAllocHandle pNewAttr = CAPI.LocalAlloc(CAPI.LPTR, new IntPtr(Marshal.SizeOf(typeof(CAPI.CRYPT_ATTRIBUTE))));
Marshal.StructureToPtr(newAttr, pNewAttr.DangerousGetHandle(), false);
try {
if (!CAPI.EncodeObject(new IntPtr(CAPI.PKCS_ATTRIBUTE),
pNewAttr.DangerousGetHandle(),
out encodedNewAttribute))
{
throw new CryptographicException(Marshal.GetLastWin32Error());
}
}
finally {
Marshal.DestroyStructure(pNewAttr.DangerousGetHandle(), typeof(CAPI.CRYPT_ATTRIBUTE));
pNewAttr.Dispose();
}
// Finally, add it back.
fixed(byte *pbData = &encodedNewAttribute[0])
{
CAPI.CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARA addPara = new CAPI.CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARA(Marshal.SizeOf(typeof(CAPI.CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARA)));
addPara.dwSignerIndex = (uint)parentIndex;
addPara.blob.cbData = (uint)encodedNewAttribute.Length;
addPara.blob.pbData = new IntPtr(pbData);
if (!CAPI.CryptMsgControl(hMsg,
0,
CAPI.CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR,
new IntPtr(&addPara)))
{
throw new CryptographicException(Marshal.GetLastWin32Error());
}
}
// Keep alive.
pbCounterSignatureValue.Dispose();
}
catch (CryptographicException) {
// Roll back.
byte[] encodedAttribute;
if (CAPI.EncodeObject(new IntPtr(CAPI.PKCS_ATTRIBUTE),
pAttr,
out encodedAttribute))
{
fixed(byte *pbData = &encodedAttribute[0])
{
CAPI.CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARA addPara = new CAPI.CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARA(Marshal.SizeOf(typeof(CAPI.CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARA)));
addPara.dwSignerIndex = (uint)parentIndex;
addPara.blob.cbData = (uint)encodedAttribute.Length;
addPara.blob.pbData = new IntPtr(pbData);
CAPI.CryptMsgControl(hMsg, 0, CAPI.CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR, new IntPtr(&addPara));
}
}
throw;
}
}
return;
}
childIndex -= (int)attr.cValue;
}
}
pAttr = new IntPtr((long)pAttr + (long)Marshal.SizeOf(typeof(CAPI.CRYPT_ATTRIBUTE)));
}
}
// Keep alive.
if (pbCmsgCmsSignerInfo != null && !pbCmsgCmsSignerInfo.IsInvalid)
{
pbCmsgCmsSignerInfo.Dispose();
}
if (pbCmsgSignerInfo != null && !pbCmsgSignerInfo.IsInvalid)
{
pbCmsgSignerInfo.Dispose();
}
throw new CryptographicException(CAPI.CRYPT_E_NO_SIGNER);
}
internal unsafe RecipientInfoCollection(System.Security.Cryptography.SafeCryptMsgHandle safeCryptMsgHandle)
{
bool flag = PkcsUtils.CmsSupported();
uint num = 0;
uint num2 = (uint)Marshal.SizeOf(typeof(uint));
if (flag)
{
if (!System.Security.Cryptography.CAPI.CAPISafe.CryptMsgGetParam(safeCryptMsgHandle, 0x21, 0, new IntPtr((void *)&num), new IntPtr((void *)&num2)))
{
throw new CryptographicException(Marshal.GetLastWin32Error());
}
}
else if (!System.Security.Cryptography.CAPI.CAPISafe.CryptMsgGetParam(safeCryptMsgHandle, 0x11, 0, new IntPtr((void *)&num), new IntPtr((void *)&num2)))
{
throw new CryptographicException(Marshal.GetLastWin32Error());
}
this.m_recipientInfos = new ArrayList();
for (uint i = 0; i < num; i++)
{
uint num4;
System.Security.Cryptography.SafeLocalAllocHandle handle;
System.Security.Cryptography.CAPI.CMSG_KEY_AGREE_PUBLIC_KEY_RECIPIENT_INFO cmsg_key_agree_public_key_recipient_info;
uint num7;
System.Security.Cryptography.SafeLocalAllocHandle handle2;
if (!flag)
{
goto Label_020B;
}
PkcsUtils.GetParam(safeCryptMsgHandle, 0x24, i, out handle, out num4);
System.Security.Cryptography.CAPI.CMSG_CMS_RECIPIENT_INFO cmsg_cms_recipient_info = (System.Security.Cryptography.CAPI.CMSG_CMS_RECIPIENT_INFO)Marshal.PtrToStructure(handle.DangerousGetHandle(), typeof(System.Security.Cryptography.CAPI.CMSG_CMS_RECIPIENT_INFO));
switch (cmsg_cms_recipient_info.dwRecipientChoice)
{
case 1:
{
System.Security.Cryptography.CAPI.CMSG_KEY_TRANS_RECIPIENT_INFO keyTrans = (System.Security.Cryptography.CAPI.CMSG_KEY_TRANS_RECIPIENT_INFO)Marshal.PtrToStructure(cmsg_cms_recipient_info.pRecipientInfo, typeof(System.Security.Cryptography.CAPI.CMSG_KEY_TRANS_RECIPIENT_INFO));
this.m_recipientInfos.Add(new KeyTransRecipientInfo(handle, keyTrans, i));
continue;
}
case 2:
{
System.Security.Cryptography.CAPI.CMSG_KEY_AGREE_RECIPIENT_INFO cmsg_key_agree_recipient_info = (System.Security.Cryptography.CAPI.CMSG_KEY_AGREE_RECIPIENT_INFO)Marshal.PtrToStructure(cmsg_cms_recipient_info.pRecipientInfo, typeof(System.Security.Cryptography.CAPI.CMSG_KEY_AGREE_RECIPIENT_INFO));
switch (cmsg_key_agree_recipient_info.dwOriginatorChoice)
{
case 2:
goto Label_0192;
}
throw new CryptographicException(SecurityResources.GetResourceString("Cryptography_Cms_Invalid_Originator_Identifier_Choice"), cmsg_key_agree_recipient_info.dwOriginatorChoice.ToString(CultureInfo.CurrentCulture));
}
default:
throw new CryptographicException(-2147483647);
}
System.Security.Cryptography.CAPI.CMSG_KEY_AGREE_CERT_ID_RECIPIENT_INFO certIdRecipient = (System.Security.Cryptography.CAPI.CMSG_KEY_AGREE_CERT_ID_RECIPIENT_INFO)Marshal.PtrToStructure(cmsg_cms_recipient_info.pRecipientInfo, typeof(System.Security.Cryptography.CAPI.CMSG_KEY_AGREE_CERT_ID_RECIPIENT_INFO));
for (uint j = 0; j < certIdRecipient.cRecipientEncryptedKeys; j++)
{
this.m_recipientInfos.Add(new KeyAgreeRecipientInfo(handle, certIdRecipient, i, j));
}
continue;
Label_0192:
cmsg_key_agree_public_key_recipient_info = (System.Security.Cryptography.CAPI.CMSG_KEY_AGREE_PUBLIC_KEY_RECIPIENT_INFO)Marshal.PtrToStructure(cmsg_cms_recipient_info.pRecipientInfo, typeof(System.Security.Cryptography.CAPI.CMSG_KEY_AGREE_PUBLIC_KEY_RECIPIENT_INFO));
for (uint k = 0; k < cmsg_key_agree_public_key_recipient_info.cRecipientEncryptedKeys; k++)
{
this.m_recipientInfos.Add(new KeyAgreeRecipientInfo(handle, cmsg_key_agree_public_key_recipient_info, i, k));
}
continue;
Label_020B:
PkcsUtils.GetParam(safeCryptMsgHandle, 0x13, i, out handle2, out num7);
System.Security.Cryptography.CAPI.CERT_INFO certInfo = (System.Security.Cryptography.CAPI.CERT_INFO)Marshal.PtrToStructure(handle2.DangerousGetHandle(), typeof(System.Security.Cryptography.CAPI.CERT_INFO));
this.m_recipientInfos.Add(new KeyTransRecipientInfo(handle2, certInfo, i));
}
this.m_safeCryptMsgHandle = safeCryptMsgHandle;
}
private unsafe void RemoveCounterSignature(int parentIndex, int childIndex)
{
if (parentIndex < 0)
{
throw new ArgumentOutOfRangeException("parentIndex");
}
if (childIndex < 0)
{
throw new ArgumentOutOfRangeException("childIndex");
}
uint cbData = 0;
System.Security.Cryptography.SafeLocalAllocHandle invalidHandle = System.Security.Cryptography.SafeLocalAllocHandle.InvalidHandle;
uint num2 = 0;
System.Security.Cryptography.SafeLocalAllocHandle pvData = System.Security.Cryptography.SafeLocalAllocHandle.InvalidHandle;
uint num3 = 0;
uint cAttr = 0;
IntPtr zero = IntPtr.Zero;
System.Security.Cryptography.SafeCryptMsgHandle cryptMsgHandle = this.m_signedCms.GetCryptMsgHandle();
if (PkcsUtils.CmsSupported())
{
PkcsUtils.GetParam(cryptMsgHandle, 0x27, (uint)parentIndex, out invalidHandle, out cbData);
System.Security.Cryptography.CAPI.CMSG_CMS_SIGNER_INFO cmsg_cms_signer_info = (System.Security.Cryptography.CAPI.CMSG_CMS_SIGNER_INFO)Marshal.PtrToStructure(invalidHandle.DangerousGetHandle(), typeof(System.Security.Cryptography.CAPI.CMSG_CMS_SIGNER_INFO));
cAttr = cmsg_cms_signer_info.UnauthAttrs.cAttr;
zero = new IntPtr((long)cmsg_cms_signer_info.UnauthAttrs.rgAttr);
}
else
{
PkcsUtils.GetParam(cryptMsgHandle, 6, (uint)parentIndex, out pvData, out num2);
System.Security.Cryptography.CAPI.CMSG_SIGNER_INFO cmsg_signer_info = (System.Security.Cryptography.CAPI.CMSG_SIGNER_INFO)Marshal.PtrToStructure(pvData.DangerousGetHandle(), typeof(System.Security.Cryptography.CAPI.CMSG_SIGNER_INFO));
cAttr = cmsg_signer_info.UnauthAttrs.cAttr;
zero = new IntPtr((long)cmsg_signer_info.UnauthAttrs.rgAttr);
}
for (num3 = 0; num3 < cAttr; num3++)
{
System.Security.Cryptography.CAPI.CRYPT_ATTRIBUTE crypt_attribute = (System.Security.Cryptography.CAPI.CRYPT_ATTRIBUTE)Marshal.PtrToStructure(zero, typeof(System.Security.Cryptography.CAPI.CRYPT_ATTRIBUTE));
if ((string.Compare(crypt_attribute.pszObjId, "1.2.840.113549.1.9.6", StringComparison.OrdinalIgnoreCase) == 0) && (crypt_attribute.cValue > 0))
{
if (childIndex < crypt_attribute.cValue)
{
System.Security.Cryptography.CAPI.CMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR_PARA cmsg_ctrl_del_signer_unauth_attr_para = new System.Security.Cryptography.CAPI.CMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR_PARA(Marshal.SizeOf(typeof(System.Security.Cryptography.CAPI.CMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR_PARA)))
{
dwSignerIndex = (uint)parentIndex,
dwUnauthAttrIndex = num3
};
if (!System.Security.Cryptography.CAPI.CryptMsgControl(cryptMsgHandle, 0, 9, new IntPtr((void *)&cmsg_ctrl_del_signer_unauth_attr_para)))
{
throw new CryptographicException(Marshal.GetLastWin32Error());
}
if (crypt_attribute.cValue > 1)
{
try
{
byte[] buffer;
uint num5 = (uint)((crypt_attribute.cValue - 1) * Marshal.SizeOf(typeof(System.Security.Cryptography.CAPI.CRYPTOAPI_BLOB)));
System.Security.Cryptography.SafeLocalAllocHandle handle4 = System.Security.Cryptography.CAPI.LocalAlloc(0x40, new IntPtr((long)num5));
System.Security.Cryptography.CAPI.CRYPTOAPI_BLOB *rgValue = (System.Security.Cryptography.CAPI.CRYPTOAPI_BLOB *)crypt_attribute.rgValue;
System.Security.Cryptography.CAPI.CRYPTOAPI_BLOB *handle = (System.Security.Cryptography.CAPI.CRYPTOAPI_BLOB *)handle4.DangerousGetHandle();
int num6 = 0;
while (num6 < crypt_attribute.cValue)
{
if (num6 != childIndex)
{
handle[0] = rgValue[0];
}
num6++;
rgValue++;
handle++;
}
System.Security.Cryptography.CAPI.CRYPT_ATTRIBUTE structure = new System.Security.Cryptography.CAPI.CRYPT_ATTRIBUTE {
pszObjId = crypt_attribute.pszObjId,
cValue = crypt_attribute.cValue - 1,
rgValue = handle4.DangerousGetHandle()
};
System.Security.Cryptography.SafeLocalAllocHandle handle5 = System.Security.Cryptography.CAPI.LocalAlloc(0x40, new IntPtr(Marshal.SizeOf(typeof(System.Security.Cryptography.CAPI.CRYPT_ATTRIBUTE))));
Marshal.StructureToPtr(structure, handle5.DangerousGetHandle(), false);
try
{
if (!System.Security.Cryptography.CAPI.EncodeObject(new IntPtr(0x16L), handle5.DangerousGetHandle(), out buffer))
{
throw new CryptographicException(Marshal.GetLastWin32Error());
}
}
finally
{
Marshal.DestroyStructure(handle5.DangerousGetHandle(), typeof(System.Security.Cryptography.CAPI.CRYPT_ATTRIBUTE));
handle5.Dispose();
}
fixed(byte *numRef = buffer)
{
System.Security.Cryptography.CAPI.CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARA cmsg_ctrl_add_signer_unauth_attr_para = new System.Security.Cryptography.CAPI.CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARA(Marshal.SizeOf(typeof(System.Security.Cryptography.CAPI.CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARA)))
{
dwSignerIndex = (uint)parentIndex
};
cmsg_ctrl_add_signer_unauth_attr_para.blob.cbData = (uint)buffer.Length;
cmsg_ctrl_add_signer_unauth_attr_para.blob.pbData = new IntPtr((void *)numRef);
if (!System.Security.Cryptography.CAPI.CryptMsgControl(cryptMsgHandle, 0, 8, new IntPtr((void *)&cmsg_ctrl_add_signer_unauth_attr_para)))
{
throw new CryptographicException(Marshal.GetLastWin32Error());
}
}
handle4.Dispose();
}
catch (CryptographicException)
{
byte[] buffer2;
if (System.Security.Cryptography.CAPI.EncodeObject(new IntPtr(0x16L), zero, out buffer2))
{
fixed(byte *numRef2 = buffer2)
{
System.Security.Cryptography.CAPI.CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARA cmsg_ctrl_add_signer_unauth_attr_para2 = new System.Security.Cryptography.CAPI.CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARA(Marshal.SizeOf(typeof(System.Security.Cryptography.CAPI.CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARA)))
{
dwSignerIndex = (uint)parentIndex
};
cmsg_ctrl_add_signer_unauth_attr_para2.blob.cbData = (uint)buffer2.Length;
cmsg_ctrl_add_signer_unauth_attr_para2.blob.pbData = new IntPtr((void *)numRef2);
System.Security.Cryptography.CAPI.CryptMsgControl(cryptMsgHandle, 0, 8, new IntPtr((void *)&cmsg_ctrl_add_signer_unauth_attr_para2));
}
}
throw;
}
}
return;
}
childIndex -= (int)crypt_attribute.cValue;
}
zero = new IntPtr(((long)zero) + Marshal.SizeOf(typeof(System.Security.Cryptography.CAPI.CRYPT_ATTRIBUTE)));
}
if ((invalidHandle != null) && !invalidHandle.IsInvalid)
{
invalidHandle.Dispose();
}
if ((pvData != null) && !pvData.IsInvalid)
{
pvData.Dispose();
}
throw new CryptographicException(-2146885618);
}