internal SignerInfo(SignedCms signedCms, System.Security.Cryptography.SafeLocalAllocHandle pbCmsgSignerInfo)
{
this.m_signedCms = signedCms;
this.m_parentSignerInfo = null;
this.m_encodedSignerInfo = null;
this.m_pbCmsgSignerInfo = pbCmsgSignerInfo;
this.m_cmsgSignerInfo = (System.Security.Cryptography.CAPI.CMSG_SIGNER_INFO) Marshal.PtrToStructure(pbCmsgSignerInfo.DangerousGetHandle(), typeof(System.Security.Cryptography.CAPI.CMSG_SIGNER_INFO));
}
internal SignerInfo (SignedCms signedCms, SafeLocalAllocHandle pbCmsgSignerInfo) {
// Sanity check.
Debug.Assert(signedCms != null && pbCmsgSignerInfo != null && !pbCmsgSignerInfo.IsInvalid);
m_signedCms = signedCms;
m_parentSignerInfo = null;
m_encodedSignerInfo = null;
m_pbCmsgSignerInfo = pbCmsgSignerInfo;
m_cmsgSignerInfo = (CAPI.CMSG_SIGNER_INFO) Marshal.PtrToStructure(pbCmsgSignerInfo.DangerousGetHandle(), typeof(CAPI.CMSG_SIGNER_INFO));
}
internal RecipientInfo (RecipientInfoType recipientInfoType, RecipientSubType recipientSubType, SafeLocalAllocHandle pCmsgRecipientInfo, Object cmsgRecipientInfo, uint index) {
if (recipientInfoType < RecipientInfoType.Unknown || recipientInfoType > RecipientInfoType.KeyAgreement)
recipientInfoType = RecipientInfoType.Unknown;
if (recipientSubType < RecipientSubType.Unknown || recipientSubType > RecipientSubType.PublicKeyAgreement)
recipientSubType = RecipientSubType.Unknown;
m_recipentInfoType = recipientInfoType;
m_recipientSubType = recipientSubType;
m_pCmsgRecipientInfo = pCmsgRecipientInfo;
m_cmsgRecipientInfo = cmsgRecipientInfo;
m_index = index;
}
internal RecipientInfo(RecipientInfoType recipientInfoType, RecipientSubType recipientSubType, System.Security.Cryptography.SafeLocalAllocHandle pCmsgRecipientInfo, object cmsgRecipientInfo, uint index)
{
if ((recipientInfoType < RecipientInfoType.Unknown) || (recipientInfoType > RecipientInfoType.KeyAgreement))
{
recipientInfoType = RecipientInfoType.Unknown;
}
if ((recipientSubType < RecipientSubType.Unknown) || (recipientSubType > RecipientSubType.PublicKeyAgreement))
{
recipientSubType = RecipientSubType.Unknown;
}
this.m_recipentInfoType = recipientInfoType;
this.m_recipientSubType = recipientSubType;
this.m_pCmsgRecipientInfo = pCmsgRecipientInfo;
this.m_cmsgRecipientInfo = cmsgRecipientInfo;
this.m_index = index;
}
internal unsafe SignerInfo(SignedCms signedCms, SignerInfo parentSignerInfo, byte[] encodedSignerInfo)
{
uint cbDecodedValue = 0;
System.Security.Cryptography.SafeLocalAllocHandle invalidHandle = System.Security.Cryptography.SafeLocalAllocHandle.InvalidHandle;
fixed (byte* numRef = encodedSignerInfo)
{
if (!System.Security.Cryptography.CAPI.DecodeObject(new IntPtr(500L), new IntPtr((void*) numRef), (uint) encodedSignerInfo.Length, out invalidHandle, out cbDecodedValue))
{
throw new CryptographicException(Marshal.GetLastWin32Error());
}
}
this.m_signedCms = signedCms;
this.m_parentSignerInfo = parentSignerInfo;
this.m_encodedSignerInfo = (byte[]) encodedSignerInfo.Clone();
this.m_pbCmsgSignerInfo = invalidHandle;
this.m_cmsgSignerInfo = (System.Security.Cryptography.CAPI.CMSG_SIGNER_INFO) Marshal.PtrToStructure(invalidHandle.DangerousGetHandle(), typeof(System.Security.Cryptography.CAPI.CMSG_SIGNER_INFO));
}
internal unsafe SignerInfo (SignedCms signedCms, SignerInfo parentSignerInfo, byte[] encodedSignerInfo) {
// Sanity check.
Debug.Assert(signedCms != null && encodedSignerInfo != null && encodedSignerInfo.Length > 0);
uint cbCmsgSignerInfo = 0;
SafeLocalAllocHandle pbCmsgSignerInfo = SafeLocalAllocHandle.InvalidHandle;
fixed (byte * pEncodedSignerInfo = &encodedSignerInfo[0]) {
if (!CAPI.DecodeObject(new IntPtr(CAPI.PKCS7_SIGNER_INFO),
new IntPtr(pEncodedSignerInfo),
(uint) encodedSignerInfo.Length,
out pbCmsgSignerInfo,
out cbCmsgSignerInfo))
throw new CryptographicException(Marshal.GetLastWin32Error());
}
m_signedCms = signedCms;
m_parentSignerInfo = parentSignerInfo;
m_encodedSignerInfo = (byte[]) encodedSignerInfo.Clone();
m_pbCmsgSignerInfo = pbCmsgSignerInfo;
m_cmsgSignerInfo = (CAPI.CMSG_SIGNER_INFO) Marshal.PtrToStructure(pbCmsgSignerInfo.DangerousGetHandle(), typeof(CAPI.CMSG_SIGNER_INFO));
}
internal static unsafe bool DecodeObject(IntPtr pszStructType, IntPtr pbEncoded, uint cbEncoded, out SafeLocalAllocHandle decodedValue, out uint cbDecodedValue)
{
decodedValue = SafeLocalAllocHandle.InvalidHandle;
cbDecodedValue = 0;
uint num = 0;
SafeLocalAllocHandle invalidHandle = SafeLocalAllocHandle.InvalidHandle;
if (!CAPISafe.CryptDecodeObject(0x10001, pszStructType, pbEncoded, cbEncoded, 0, invalidHandle, new IntPtr((void*) &num)))
{
return false;
}
invalidHandle = LocalAlloc(0, new IntPtr((long) num));
if (!CAPISafe.CryptDecodeObject(0x10001, pszStructType, pbEncoded, cbEncoded, 0, invalidHandle, new IntPtr((void*) &num)))
{
return false;
}
decodedValue = invalidHandle;
cbDecodedValue = num;
return true;
}
private static byte[] ConstructDSSPubKeyCspBlob (SafeLocalAllocHandle decodedKeyValue,
SafeLocalAllocHandle decodedParameters) {
// The CAPI DSS public key representation consists of the following sequence:
// - PUBLICKEYSTRUC
// - DSSPUBKEY
// - rgbP[cbKey]
// - rgbQ[20]
// - rgbG[cbKey]
// - rgbY[cbKey]
// - DSSSEED
CAPI.CRYPTOAPI_BLOB pDssPubKey = (CAPI.CRYPTOAPI_BLOB) Marshal.PtrToStructure(decodedKeyValue.DangerousGetHandle(), typeof(CAPI.CRYPTOAPI_BLOB));
CAPI.CERT_DSS_PARAMETERS pDssParameters = (CAPI.CERT_DSS_PARAMETERS) Marshal.PtrToStructure(decodedParameters.DangerousGetHandle(), typeof(CAPI.CERT_DSS_PARAMETERS));
uint cbKey = pDssParameters.p.cbData;
if (cbKey == 0)
throw new CryptographicException(CAPI.NTE_BAD_PUBLIC_KEY);
const uint DSS_Q_LEN = 20;
uint cbKeyBlob = 8 /* sizeof(CAPI.BLOBHEADER) */ + 8 /* sizeof(CAPI.DSSPUBKEY) */ +
cbKey + DSS_Q_LEN + cbKey + cbKey + 24 /* sizeof(CAPI.DSSSEED) */;
MemoryStream keyBlob = new MemoryStream((int) cbKeyBlob);
BinaryWriter bw = new BinaryWriter(keyBlob);
// PUBLICKEYSTRUC
bw.Write(CAPI.PUBLICKEYBLOB); // pPubKeyStruc->bType = PUBLICKEYBLOB
bw.Write(CAPI.CUR_BLOB_VERSION); // pPubKeyStruc->bVersion = CUR_BLOB_VERSION
bw.Write((short) 0); // pPubKeyStruc->reserved = 0;
bw.Write(CAPI.CALG_DSS_SIGN); // pPubKeyStruc->aiKeyAlg = CALG_DSS_SIGN;
// DSSPUBKEY
bw.Write(CAPI.DSS_MAGIC); // pCspPubKey->magic = DSS_MAGIC; We are constructing a DSS1 Csp blob.
bw.Write(cbKey * 8); // pCspPubKey->bitlen = cbKey * 8;
// rgbP[cbKey]
byte[] p = new byte[pDssParameters.p.cbData];
Marshal.Copy(pDssParameters.p.pbData, p, 0, p.Length);
bw.Write(p);
// rgbQ[20]
uint cb = pDssParameters.q.cbData;
if (cb == 0 || cb > DSS_Q_LEN)
throw new CryptographicException(CAPI.NTE_BAD_PUBLIC_KEY);
byte[] q = new byte[pDssParameters.q.cbData];
Marshal.Copy(pDssParameters.q.pbData, q, 0, q.Length);
bw.Write(q);
if (DSS_Q_LEN > cb)
bw.Write(new byte[DSS_Q_LEN - cb]);
// rgbG[cbKey]
cb = pDssParameters.g.cbData;
if (cb == 0 || cb > cbKey)
throw new CryptographicException(CAPI.NTE_BAD_PUBLIC_KEY);
byte[] g = new byte[pDssParameters.g.cbData];
Marshal.Copy(pDssParameters.g.pbData, g, 0, g.Length);
bw.Write(g);
if (cbKey > cb)
bw.Write(new byte[cbKey - cb]);
// rgbY[cbKey]
cb = pDssPubKey.cbData;
if (cb == 0 || cb > cbKey)
throw new CryptographicException(CAPI.NTE_BAD_PUBLIC_KEY);
byte[] y = new byte[pDssPubKey.cbData];
Marshal.Copy(pDssPubKey.pbData, y, 0, y.Length);
bw.Write(y);
if (cbKey > cb)
bw.Write(new byte[cbKey - cb]);
// DSSSEED: set counter to 0xFFFFFFFF to indicate not available
bw.Write(0xFFFFFFFF);
bw.Write(new byte[20]);
return keyBlob.ToArray();
}
internal static unsafe void GetParam (SafeCryptMsgHandle safeCryptMsgHandle,
uint paramType,
uint index,
out SafeLocalAllocHandle pvData,
out uint cbData) {
cbData = 0;
pvData = SafeLocalAllocHandle.InvalidHandle;
fixed (uint * pcbData = &cbData) {
if (!CAPI.CAPISafe.CryptMsgGetParam(safeCryptMsgHandle,
paramType,
index,
pvData,
new IntPtr(pcbData)))
checkErr(Marshal.GetLastWin32Error());
if (cbData > 0) {
pvData = CAPI.LocalAlloc(CAPI.LPTR, new IntPtr(cbData));
if (!CAPI.CAPISafe.CryptMsgGetParam(safeCryptMsgHandle,
paramType,
index,
pvData,
new IntPtr(pcbData)))
checkErr(Marshal.GetLastWin32Error());
}
}
}
private static byte[] ConstructDSSPubKeyCspBlob(SafeLocalAllocHandle decodedKeyValue, SafeLocalAllocHandle decodedParameters)
{
CAPIBase.CRYPTOAPI_BLOB cryptoapi_blob = (CAPIBase.CRYPTOAPI_BLOB) Marshal.PtrToStructure(decodedKeyValue.DangerousGetHandle(), typeof(CAPIBase.CRYPTOAPI_BLOB));
CAPIBase.CERT_DSS_PARAMETERS cert_dss_parameters = (CAPIBase.CERT_DSS_PARAMETERS) Marshal.PtrToStructure(decodedParameters.DangerousGetHandle(), typeof(CAPIBase.CERT_DSS_PARAMETERS));
uint cbData = cert_dss_parameters.p.cbData;
if (cbData == 0)
{
throw new CryptographicException(-2146893803);
}
uint num2 = ((((0x10 + cbData) + 20) + cbData) + cbData) + 0x18;
MemoryStream output = new MemoryStream((int) num2);
BinaryWriter writer = new BinaryWriter(output);
writer.Write((byte) 6);
writer.Write((byte) 2);
writer.Write((short) 0);
writer.Write((uint) 0x2200);
writer.Write((uint) 0x31535344);
writer.Write((uint) (cbData * 8));
byte[] destination = new byte[cert_dss_parameters.p.cbData];
Marshal.Copy(cert_dss_parameters.p.pbData, destination, 0, destination.Length);
writer.Write(destination);
uint num3 = cert_dss_parameters.q.cbData;
if ((num3 == 0) || (num3 > 20))
{
throw new CryptographicException(-2146893803);
}
byte[] buffer2 = new byte[cert_dss_parameters.q.cbData];
Marshal.Copy(cert_dss_parameters.q.pbData, buffer2, 0, buffer2.Length);
writer.Write(buffer2);
if (20 > num3)
{
writer.Write(new byte[20 - num3]);
}
num3 = cert_dss_parameters.g.cbData;
if ((num3 == 0) || (num3 > cbData))
{
throw new CryptographicException(-2146893803);
}
byte[] buffer3 = new byte[cert_dss_parameters.g.cbData];
Marshal.Copy(cert_dss_parameters.g.pbData, buffer3, 0, buffer3.Length);
writer.Write(buffer3);
if (cbData > num3)
{
writer.Write(new byte[cbData - num3]);
}
num3 = cryptoapi_blob.cbData;
if ((num3 == 0) || (num3 > cbData))
{
throw new CryptographicException(-2146893803);
}
byte[] buffer4 = new byte[cryptoapi_blob.cbData];
Marshal.Copy(cryptoapi_blob.pbData, buffer4, 0, buffer4.Length);
writer.Write(buffer4);
if (cbData > num3)
{
writer.Write(new byte[cbData - num3]);
}
writer.Write(uint.MaxValue);
writer.Write(new byte[20]);
return output.ToArray();
}
internal KeyAgreeRecipientInfo (SafeLocalAllocHandle pRecipientInfo, CAPI.CMSG_KEY_AGREE_PUBLIC_KEY_RECIPIENT_INFO publicKeyRecipient, uint index, uint subIndex) : base(RecipientInfoType.KeyAgreement, RecipientSubType.PublicKeyAgreement, pRecipientInfo, publicKeyRecipient, index) {
checked {
IntPtr pEncryptedKeyInfo = Marshal.ReadIntPtr(new IntPtr((long) publicKeyRecipient.rgpRecipientEncryptedKeys + (long) (subIndex * Marshal.SizeOf(typeof(IntPtr)))));
CAPI.CMSG_RECIPIENT_ENCRYPTED_KEY_INFO encryptedKeyInfo = (CAPI.CMSG_RECIPIENT_ENCRYPTED_KEY_INFO) Marshal.PtrToStructure(pEncryptedKeyInfo, typeof(CAPI.CMSG_RECIPIENT_ENCRYPTED_KEY_INFO));
Reset(CAPI.CMSG_KEY_AGREE_ORIGINATOR_PUBLIC_KEY, publicKeyRecipient.dwVersion, encryptedKeyInfo, subIndex);
}
}
internal KeyTransRecipientInfo (SafeLocalAllocHandle pRecipientInfo, CAPI.CMSG_KEY_TRANS_RECIPIENT_INFO keyTrans, uint index) : base(RecipientInfoType.KeyTransport, RecipientSubType.CmsKeyTransport, pRecipientInfo, keyTrans, index) {
Reset((int) keyTrans.dwVersion);
}
internal unsafe KeyTransRecipientInfo (SafeLocalAllocHandle pRecipientInfo, CAPI.CERT_INFO certInfo, uint index) : base(RecipientInfoType.KeyTransport, RecipientSubType.Pkcs7KeyTransport, pRecipientInfo, certInfo, index) {
// If serial number is 0, then it is the special SKI encoding.
int version = 2;
byte * pb = (byte *) certInfo.SerialNumber.pbData;
for (int i = 0; i < certInfo.SerialNumber.cbData; i++) {
if (*pb++ != (byte) 0) {
version = 0;
break;
}
}
Reset(version);
}
internal CryptographicAttributeObjectCollection (SafeLocalAllocHandle pCryptAttributes) : this(pCryptAttributes.DangerousGetHandle()) {}
