PeerUnsafeNativeCryptMethods.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / WCF / WCF / 3.5.30729.1 / untmp / Orcas / SP / ndp / cdf / src / WCF / ServiceModel / System / ServiceModel / Channels / PeerUnsafeNativeCryptMethods.cs / 1 / PeerUnsafeNativeCryptMethods.cs
                        

                        
                            //------------------------------------------------------------ 
// Copyright (c) Microsoft Corporation.  All rights reserved.
//-----------------------------------------------------------
namespace System.ServiceModel.Channels
{ 
    using System;
    using System.ComponentModel; 
    using System.Diagnostics; 
    using System.Runtime.InteropServices;
    using System.Runtime.ConstrainedExecution; 
    using System.Security;
    using System.Security.Cryptography;
    using System.Security.Cryptography.X509Certificates;
    using System.ServiceModel.Channels; 
    using System.Text;
 
 
    [StructLayout(LayoutKind.Sequential)]
    internal struct SystemTime 
    {
        public short wYear;
        public short wMonth;
        public short wDayOfWeek; 
        public short wDay;
        public short wHour; 
        public short wMinute; 
        public short wSecond;
        public short wMilliseconds; 

        public SystemTime(DateTime date)
        {
            wYear = (short)date.Year; 
            wMonth = (short)date.Month;
            wDayOfWeek = (short)date.DayOfWeek; 
            wDay = (short)date.Day; 
            wHour = (short)date.Hour;
            wMinute = (short)date.Minute; 
            wSecond = (short)date.Second;
            wMilliseconds = (short)date.Millisecond;
        }
    } 

    [SuppressUnmanagedCodeSecurity] 
    class CertificateHandle : SafeHandle 
    {
#region PInvoke declarations 
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        [DllImport("Crypt32.dll", CallingConvention=CallingConvention.StdCall)]
        private extern static bool CertFreeCertificateContext(IntPtr pCertContext);
 
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        [DllImport("Crypt32.dll", CallingConvention = CallingConvention.StdCall, SetLastError=true)] 
        private extern static bool CertDeleteCertificateFromStore(IntPtr pCertContext); 

#endregion 
        protected bool delete = false;
        protected CertificateHandle() : base(IntPtr.Zero, true)
        {
            return; 
        }
 
        public override bool IsInvalid 
        {
            get { return handle == IntPtr.Zero; } 
        }

        protected override bool ReleaseHandle()
        { 
            if(delete)
                return CertDeleteCertificateFromStore(handle); 
            else 
                return CertFreeCertificateContext(handle);
        } 
    }

    [SuppressUnmanagedCodeSecurity]
    sealed class StoreCertificateHandle : CertificateHandle 
    {
        private StoreCertificateHandle() : base(){ base.delete = true;} 
    } 

    [SuppressUnmanagedCodeSecurity] 
    sealed class CertificateStoreHandle : SafeHandle
    {
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        [DllImport("Crypt32.dll", CallingConvention = CallingConvention.StdCall)] 
        private static extern bool CertCloseStore(IntPtr hCertStore, int dwFlags);
 
        private CertificateStoreHandle() : base(IntPtr.Zero, true) 
        {
        	return; 
        }	

        public override bool IsInvalid
        { 
            get { return handle == IntPtr.Zero; }
        } 
 
        protected override bool ReleaseHandle()
        { 
            return CertCloseStore(handle, 0);
        }
    }
 
    [SuppressUnmanagedCodeSecurity]
    sealed class KeyContainerHandle : SafeHandle 
    { 
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        [DllImport("Advapi32.dll", CallingConvention = CallingConvention.StdCall)] 
        private static extern bool CryptReleaseContext(IntPtr hProv, int dwFlags);

        private KeyContainerHandle() : base(IntPtr.Zero, true)
        { 
        	return;
        } 
 
        public override bool IsInvalid
        { 
        	get { return handle == IntPtr.Zero; }
        }

        protected override bool ReleaseHandle() 
        {
        	return CryptReleaseContext(handle, 0); 
        } 
    }
 
    sealed class KeyHandle : SafeHandle
    {
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        [DllImport("Advapi32.dll", CallingConvention = CallingConvention.StdCall)] 
        private static extern bool CryptDestroyKey(IntPtr hKey);
 
        private KeyHandle() : base(IntPtr.Zero, true) 
        {
        	return; 
        }

        public override bool IsInvalid
        { 
            get { return handle == IntPtr.Zero; }
        } 
 
        protected override bool ReleaseHandle()
        { 
            return CryptDestroyKey(handle);
        }
    }
 
    sealed class CryptoApiBlob : IDisposable
    { 
        private int cbData = 0; 
        private CriticalAllocHandle data;
 
        public CryptoApiBlob()
        {
        }
 
        public CryptoApiBlob(byte[] bytes)
        { 
            DiagnosticUtility.DebugAssert(bytes != null, "Cannot set null data"); 
            AllocateBlob(bytes.Length);
            Marshal.Copy(bytes, 0, (IntPtr)data, bytes.Length); 
            cbData = bytes.Length;
            return;
        }
 
        public int DataSize
        { 
            get 
            {
                DiagnosticUtility.DebugAssert(cbData >= 0, "Size must be greater than or equal to zero");	 
                return cbData;
            }
        }
 
        public void AllocateBlob(int size)
        { 
            data = CriticalAllocHandle.FromSize(size); 
            cbData = size;
        } 

        [StructLayout(LayoutKind.Sequential)]
        public class InteropHelper
        { 
            public int size;
            public IntPtr data; 
            public InteropHelper(int size, IntPtr data) 
            {
                this.size = size; 
                this.data = data;
            }
        }
        public InteropHelper GetMemoryForPinning() 
        {
            return new InteropHelper(cbData, (IntPtr)data); 
        } 

        public byte[] GetBytes() 
        {
            if(cbData == 0)
                return null;
 
            byte[] bytes = DiagnosticUtility.Utility.AllocateByteArray(cbData);
 	    Marshal.Copy((IntPtr)data, bytes, 0, cbData); 
            return bytes; 
        }
 
        private void Dispose(bool disposing)
        {

            if(disposing) 
                GC.SuppressFinalize(this);
 
            return; 
        }
 
        public void Dispose()
        {
            Dispose(true);
            return; 
        }
 
    } 

    sealed class CertificateName 
    {
#region PInvoke Declarations
        [DllImport("Crypt32.dll", CallingConvention=CallingConvention.StdCall, CharSet=CharSet.Auto, SetLastError=true)]
        private extern static bool CertStrToName(CertEncodingType dwCertEncodingType, 
                                                    [MarshalAs(UnmanagedType.LPTStr)]string pszX500,
                                                    StringType dwStrType, 
                                                    IntPtr pvReserved, 
                                                    [In, Out]byte[] pbEncoded,
                                                    [In, Out]ref int pcbEncoded, 
                                                    [MarshalAs(UnmanagedType.LPTStr)]ref StringBuilder ppszError);


        [Flags] 
        private enum CertEncodingType : int
        { 
        	X509AsnEncoding			= 0x00000001, 
        	PKCS7AsnEncoding		= 0x00010000
        } 

        [Flags]
        private enum StringType : int
        { 
            SimpleNameString = 1,
            OIDNameString = 2, 
            X500NameString= 3, 

            CommaFlag = 0x04000000, 
            SemicolonFlag = 0x40000000,
            CRLFFlag = 0x08000000,
            NoPlusFlag = 0x20000000,
            NoQuotingFlag = 0x10000000, 
            ReverseFlag = 0x02000000,
            DisableIE4UTF8Flag = 0x00010000, 
            EnableT61UnicodeFlag = 0x00020000, 
            EnableUTF8UnicodeFlag = 0x00040000
        } 
#endregion

        private string dn = null;
 
        public CertificateName(string dn)
        { 
            DiagnosticUtility.DebugAssert(!String.IsNullOrEmpty(dn), "Empty subject name for certificate!"); 
            this.dn = dn;
        } 

        public string DistinguishedName
        {
            get {return dn; } 
        }
 
        public CryptoApiBlob GetCryptoApiBlob() 
        {
            byte[] encodedName = GetEncodedName(); 
            return new CryptoApiBlob(encodedName);
        }

        private byte[] GetEncodedName() 
        {
            int encodingSize = 0; 
            StringBuilder errorString = null; 

            CertStrToName(CertEncodingType.X509AsnEncoding | CertEncodingType.PKCS7AsnEncoding, 
                            DistinguishedName,
                            StringType.OIDNameString | StringType.ReverseFlag,
                            IntPtr.Zero,
                            null, 
                            ref encodingSize,
                            ref errorString); 
 
            byte[] encodedBytes = new byte[encodingSize];
            bool ok = CertStrToName(CertEncodingType.X509AsnEncoding | CertEncodingType.PKCS7AsnEncoding, 
                                        DistinguishedName,
                                        StringType.OIDNameString | StringType.ReverseFlag,
                                        IntPtr.Zero,
                                        encodedBytes, 
                                        ref encodingSize,
                                        ref errorString); 
 
            if(!ok)
            { 
            	PeerExceptionHelper.ThrowInvalidOperation_PeerCertGenFailure(PeerExceptionHelper.GetLastException());
            }

            return encodedBytes; 
        }
    } 
 

    sealed partial class SelfSignedCertificate : IDisposable 
    {
#region PInvoke declarations
[DllImport("Crypt32.dll", CallingConvention = CallingConvention.StdCall, SetLastError = true)]
    private extern static CertificateHandle CertCreateSelfSignCertificate( 
                                                KeyContainerHandle hProv,
                                                CryptoApiBlob.InteropHelper pSubjectIssuerBlob, 
                                                SelfSignFlags dwFlags, 
                                                IntPtr pKeyProvInfo,
                                                IntPtr pSignatureAlgorithm, 
                                                [In] ref SystemTime pStartTime,
                                                [In] ref SystemTime pEndTime,
                                                IntPtr pExtensions);
 
    [DllImport("Crypt32.dll", CallingConvention = CallingConvention.StdCall, SetLastError = true)]
    private extern static CertificateStoreHandle CertOpenStore( 
                                                IntPtr lpszStoreProvider, 
                                                int dwMsgAndCertEncodingType,
                                                IntPtr hCryptProv, 
                                                int dwFlags,
                                                IntPtr pvPara);

    [DllImport("Crypt32.dll", CallingConvention = CallingConvention.StdCall, SetLastError = true)] 
    private extern static bool CertAddCertificateContextToStore(
                                                CertificateStoreHandle hCertStore, 
                                                CertificateHandle pCertContext, 
                                                AddDisposition dwAddDisposition,
                                                [Out]out StoreCertificateHandle ppStoreContext); 

    [DllImport("Advapi32.dll", CallingConvention = CallingConvention.StdCall, SetLastError = true)]
    private extern static bool CryptAcquireContext(
                                                [Out]out KeyContainerHandle	phProv, 
                                                string pszContainer,
                                                string pszProvider, 
                                                ProviderType dwProvType, 
                                                ContextFlags dwFlags);
 
    [DllImport("Advapi32.dll", CallingConvention = CallingConvention.StdCall, SetLastError = true)]
    private extern static bool CryptGenKey(
                                                KeyContainerHandle hProv,
                                                AlgorithmType algId, 
                                                KeyFlags dwFlags,
                                                [Out]out KeyHandle phKey); 
 
    [DllImport("Crypt32.dll", CallingConvention = CallingConvention.StdCall, SetLastError = true, CharSet=CharSet.Unicode)]
    private extern static bool PFXExportCertStoreEx( 
                                                CertificateStoreHandle hStore,
                                                IntPtr pPFX,
                                                //IntPtr szPassword,
                                                string password, 
                                                IntPtr pvReserved,
                                                PfxExportFlags dwFlags); 
 
    [DllImport("Crypt32.dll", CallingConvention = CallingConvention.StdCall, SetLastError = true)]
    private extern static bool CertSetCertificateContextProperty( 
                                                CertificateHandle context,
                                                int propId,
                                                int flags,
                                                KeyHandle pv); 

    [Flags] 
    private enum SelfSignFlags : int 
    {
        None= 0, 
        NoSign = 1,
        NoKeyInfo = 2,
    }
 
    private enum AddDisposition : int
    { 
        New = 1, 
        UseExisting = 2,
        ReplaceExisting = 3, 
        Always = 4,
        ReplaceExistingInheritProperties	= 5
    }
 
    [Flags]
    private enum PfxExportFlags : int 
    { 
        ReportNoPrivateKey = 0x00000001,
        ReportNotAbleToExportPrivateKey = 0x00000002, 
        ExportPrivateKeys = 0x00000004
    }

    private enum ProviderType : int 
    {
        RsaFull = 1, 
        RsaSignature = 2, 
        Dss = 3,
        Fortezza = 4, 
        MsExchange = 5,
        Ssl = 6,
        RsaSecureChannel = 12,		/* SSS_WARNINGS_OFF */
        DssDiffieHellman = 13, 
        EcDsaSignature = 14,
        EcNraSignature = 15, 
        EcDsaFull = 16, 
        EcNraFull = 17,
        DiffieHellmanSecureChannel = 18, 
        SpyrusLynks = 20,
        RandomNumberGenerator = 21,
        IntelSec = 22,
        ReplaceOwf = 23, 
        RsaAes= 24
    }					/* SSS_WARNINGS_ON */ 
 
    [Flags]
    private enum ContextFlags : uint 
    {
        VerifyContext= 0xF0000000,
        NewKeySet= 0x00000008,
        DeleteKeySet= 0x00000010, 
        MachineKeySet= 0x00000020,
        Silent= 0x00000040 
    } 

    private enum AlgorithmType : int 
    {
        KeyExchange= 1,
        Signature = 2
    } 

    private enum KeyFlags : int 
    { 
        Exportable= 0x00000001,
        UserProtected= 0x00000002, 
        CreateSalt= 0x00000004,
        UpdateKey= 0x00000008,
        NoSalt= 0x00000010,
        PreGenerate= 0x00000040, 
        Online= 0x00000080,
        Sf= 0x00000100, 
        CreateIv= 0x00000200, 
        KeyExchangeKey= 0x00000400,
        DataKey= 0x00000800, 
        Volatile= 0x00001000,
        SgcKey= 0x00002000,
        Archivable= 0x00004000,
        Exportable2k= 0x08000001, 
    }
 
    const int CERT_KEY_SPEC_PROP_ID = 1; 
    const int CERT_KEY_PROV_INFO_PROP_ID = 2;
 
#endregion

        [Serializable]
        [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)] 
        public class CRYPT_KEY_PROV_INFO
        { 
            public string container; 
            public string provName;
            public int providerType; 
            public int flags;
            public int paramsCount;
            public IntPtr param;
            public int keySpec; 
        }
 
        [Serializable] 
        [StructLayout(LayoutKind.Sequential)]
        public struct CRYPT_OBJID_BLOB 
        {
            public int count;
            public IntPtr parameters;
        } 

        [Serializable] 
        [StructLayout(LayoutKind.Sequential)] 
        public class CRYPT_ALGORITHM_IDENTIFIER
        { 
            public CRYPT_ALGORITHM_IDENTIFIER(string id)
            {
                this.pszObjId = id;
            } 
            public string pszObjId;
            public CRYPT_OBJID_BLOB Parameters; 
        } 

        [Serializable] 
        [StructLayout(LayoutKind.Sequential)]
        public class Sha1AlgorithmId : CRYPT_ALGORITHM_IDENTIFIER
        {
            const string AlgId = "1.2.840.113549.1.1.5"; 
            public Sha1AlgorithmId():base(AlgId){}
        } 
 
        CriticalAllocHandle GetProviderInfo()
        { 
            CRYPT_KEY_PROV_INFO provInfo = new CRYPT_KEY_PROV_INFO();
            provInfo.container = this.keyContainerName;
            provInfo.providerType = (int)ProviderType.RsaSecureChannel;
            provInfo.paramsCount = 0; 
            provInfo.keySpec = (int)AlgorithmType.KeyExchange;
            return CriticalAllocHandleBlob.FromBlob(provInfo); 
        } 

        static CriticalAllocHandle GetSha1AlgorithmId() 
        {
            Sha1AlgorithmId sha1Id = new Sha1AlgorithmId();
            return CriticalAllocHandleBlob.FromBlob(sha1Id);
        } 
    }
} 
 


// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK