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));
        }
Example #3
0
        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;
 }
Example #8
0
        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();
        }
Example #9
0
        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();
 }
Example #11
0
 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);
     }
 }
Example #12
0
 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);
 }
Example #13
0
        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()) {}