IdentityModel/Selectors/CryptoHandle.cs

//-----------------------------------------------------------------------------
// Copyright (c) Microsoft Corporation.  All rights reserved.
//-----------------------------------------------------------------------------
//
// Presharp uses the c# pragma mechanism to supress its warnings.
// These are not recognised by the base compiler so we need to explictly
// disable the following warnings. See http://winweb/cse/Tools/PREsharp/userguide/default.asp
// for details.
//
#pragma warning disable 1634, 1691      // unknown message, unknown pragma

namespace System.IdentityModel.Selectors
{
    using System;
    using System.Runtime.InteropServices;
    using System.Threading;
    using System.Security;
    using System.Runtime.ConstrainedExecution;
    using System.Runtime.CompilerServices;
    using IDT = Microsoft.InfoCards.Diagnostics.InfoCardTrace;


    //
    // For common & resources
    //
    using Microsoft.InfoCards;

    //
    // Summary:
    //  Wraps and manages the lifetime of a native crypto handle passed back from the native InfoCard API.
    //
    internal abstract class CryptoHandle : IDisposable
    {
        bool m_isDisposed;
        InternalRefCountedHandle m_internalHandle;

        //
        // Summary:
        //  Creates a new CryptoHandle. ParamType has information as to what
        //  nativeParameters has to be marshaled into.
        //
        protected CryptoHandle(InternalRefCountedHandle nativeHandle, DateTime expiration, IntPtr nativeParameters, Type paramType)
        {
            m_internalHandle = nativeHandle;

            m_internalHandle.Initialize(expiration, Marshal.PtrToStructure(nativeParameters, paramType));
        }

        //
        // Summary:
        //  This constructor creates a new CryptoHandle instance with the same InternalRefCountedHandle and adds
        //  a ref count to that InternalRefCountedHandle.
        //
        protected CryptoHandle(InternalRefCountedHandle internalHandle)
        {
            m_internalHandle = internalHandle;
            m_internalHandle.AddRef();
        }

        public InternalRefCountedHandle InternalHandle
        {
            get
            {
                ThrowIfDisposed();
                return m_internalHandle;
            }
        }


        public DateTime Expiration
        {
            get
            {
                ThrowIfDisposed();
                return m_internalHandle.Expiration;
            }
        }

        public object Parameters
        {
            get
            {
                ThrowIfDisposed();
                return m_internalHandle.Parameters;
            }
        }

        //
        // Summary:
        //  Creates a new CryptoHandle with same InternalRefCountedCryptoHandle.
        //
        public CryptoHandle Duplicate()
        {
            ThrowIfDisposed();
            return OnDuplicate();
        }


        //
        // Summary:
        //  Allows subclasses to create a duplicate of their particular class.
        //
        protected abstract CryptoHandle OnDuplicate();

        protected void ThrowIfDisposed()
        {
            if (m_isDisposed)
            {
                throw IDT.ThrowHelperError(new ObjectDisposedException(SR.GetString(SR.ClientCryptoSessionDisposed)));
            }
        }

        public void Dispose()
        {
            if (m_isDisposed)
            {
                return;
            }

            m_internalHandle.Release();
            m_internalHandle = null;
            m_isDisposed = true;
        }

        //
        // Summary:
        //  Given a pointer to a native cryptosession this method creates the appropriate CryptoHandle type.
        //
        static internal CryptoHandle Create(InternalRefCountedHandle nativeHandle)
        {
            CryptoHandle handle = null;

            bool mustRelease = false;
            RuntimeHelpers.PrepareConstrainedRegions();
            try
            {
                nativeHandle.DangerousAddRef(ref mustRelease);
                RpcInfoCardCryptoHandle hCrypto =
                    (RpcInfoCardCryptoHandle)Marshal.PtrToStructure(nativeHandle.DangerousGetHandle(),
                                                                     typeof(RpcInfoCardCryptoHandle));
                DateTime expiration = DateTime.FromFileTimeUtc(hCrypto.expiration);

                switch (hCrypto.type)
                {
                    case RpcInfoCardCryptoHandle.HandleType.Asymmetric:
                        handle = new AsymmetricCryptoHandle(nativeHandle, expiration, hCrypto.cryptoParameters);
                        break;
                    case RpcInfoCardCryptoHandle.HandleType.Symmetric:
                        handle = new SymmetricCryptoHandle(nativeHandle, expiration, hCrypto.cryptoParameters);
                        break;
                    case RpcInfoCardCryptoHandle.HandleType.Transform:
                        handle = new TransformCryptoHandle(nativeHandle, expiration, hCrypto.cryptoParameters);
                        break;
                    case RpcInfoCardCryptoHandle.HandleType.Hash:
                        handle = new HashCryptoHandle(nativeHandle, expiration, hCrypto.cryptoParameters);
                        break;
                    default:
                        IDT.DebugAssert(false, "Invalid crypto operation type");
                        throw IDT.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.GeneralExceptionMessage)));
                }

                return handle;

            }
            finally
            {
                if (mustRelease)
                {
                    nativeHandle.DangerousRelease();
                }
            }
        }


    }

    //
    // Summary:
    //  This class manages the lifetime of a native crypto handle through ref counts.  Any number of CryptoHandles
    //  may refer to a single InternalRefCountedHandle, but once they are all disposed this object will dispose
    //  itself as well.
    //
    internal class InternalRefCountedHandle : SafeHandle
    {
        int m_refcount = 0;
        DateTime m_expiration;
        object m_parameters = null;

        [DllImport("infocardapi.dll",
                    EntryPoint = "CloseCryptoHandle",
                    CharSet = CharSet.Unicode,
                    CallingConvention = CallingConvention.StdCall,
                    ExactSpelling = true,
                    SetLastError = true)]
        [SuppressUnmanagedCodeSecurity]
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        private static extern bool CloseCryptoHandle([In] IntPtr hKey);

        private InternalRefCountedHandle()
            : base(IntPtr.Zero, true)
        {
            m_refcount = 1;

        }

        public void Initialize(DateTime expiration, object parameters)
        {
            m_expiration = expiration;
            m_parameters = parameters;
        }


        //
        // Summary:
        //  The deserialized parameters specific to a particular type of CryptoHandle.
        //
        public object Parameters
        {
            get
            {
                ThrowIfInvalid();
                return m_parameters;
            }
        }

        //
        // Summary:
        //  The expiration of this CryptoHandle
        //
        public DateTime Expiration
        {
            get
            {
                ThrowIfInvalid();
                return m_expiration;
            }
        }

        public void AddRef()
        {
            ThrowIfInvalid();
            Interlocked.Increment(ref m_refcount);
        }

        public void Release()
        {
            ThrowIfInvalid();
            int refcount = Interlocked.Decrement(ref m_refcount);
            if (0 == refcount)
            {
                Dispose();
            }
        }

        private void ThrowIfInvalid()
        {
            if (IsInvalid)
            {
                throw IDT.ThrowHelperError(new ObjectDisposedException("InternalRefCountedHandle"));
            }
        }
        public override bool IsInvalid
        {
            get
            {
                return (IntPtr.Zero == base.handle);
            }
        }


        protected override bool ReleaseHandle()
        {
#pragma warning suppress 56523
            return CloseCryptoHandle(base.handle);
        }

    }
}