InfoCardKeyedHashAlgorithm.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / cdf / src / WCF / infocard / Client / System / IdentityModel / Selectors / InfoCardKeyedHashAlgorithm.cs / 1305376 / InfoCardKeyedHashAlgorithm.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.ComponentModel;
    using System.Runtime.InteropServices; 
    using System.Security.Cryptography; 
    using System.Runtime.ConstrainedExecution;
    using System.Runtime.CompilerServices; 
    using IDT=Microsoft.InfoCards.Diagnostics.InfoCardTrace;
    using DiagnosticUtility=Microsoft.InfoCards.Diagnostics.DiagnosticUtility;

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

 
    //
    // Summary:
    //  Remotes a KeyedHashAlgorithm from the InfoCard service.
    // 
    internal class InfoCardKeyedHashAlgorithm : KeyedHashAlgorithm
    { 
        HashCryptoHandle m_cryptoHandle; 
        RpcHashCryptoParameters m_param;
        byte[]  m_cachedBlock; 

        //
        // Summary:
        //  Creates a new InfoCardKeyedHashAlgorithm based on a SymmetricCryptoHandle. 
        //
        // Parameters: 
        //  cryptoHandle  - The handle to the symmetric key on which to base the keyed hash. 
        //
        public InfoCardKeyedHashAlgorithm( SymmetricCryptoHandle cryptoHandle ) 
        {
            InternalRefCountedHandle nativeHandle = null;

            try 
            {
                // 
                // Call native api to get a hashCryptoHandle. 
                //
                int status = CardSpaceSelector.GetShim().m_csShimGetKeyedHash( cryptoHandle.InternalHandle, out nativeHandle ); 

                if ( 0 != status )
                {
                    IDT.CloseInvalidOutSafeHandle(nativeHandle); 
                    ExceptionHelper.ThrowIfCardSpaceException( status );
                    throw IDT.ThrowHelperError( new Win32Exception( status ) ); 
                } 

                m_cryptoHandle = (HashCryptoHandle) CryptoHandle.Create( nativeHandle ); 

                m_param = (RpcHashCryptoParameters) m_cryptoHandle.Parameters;
            }
            catch 
            {
 
                if ( null != m_cryptoHandle ) 
                {
                    m_cryptoHandle.Dispose(); 
                }
                throw;
            }
 
        }
        #pragma warning disable 56503 // property gets should not throw. 
        public override byte[] Key 
        {
            get { throw IDT.ThrowHelperError( new NotImplementedException() ); } 
        }

        public override int HashSize
        { 
            get { return m_param.hashSize;}
        } 
 
        public override int InputBlockSize
        { 
            get { return m_param.transform.inputBlockSize;}
        }
        public override int OutputBlockSize
        { 
            get { return m_param.transform.outputBlockSize;}
        } 
        public override bool CanTransformMultipleBlocks 
        {
            get { return m_param.transform.canTransformMultipleBlocks;} 
        }

        public override bool CanReuseTransform
        { 
            get { return m_param.transform.canReuseTransform;}
        } 
        #pragma warning restore 56503 
        public override void Initialize()
        { 
        }

        //
        // Summary: 
        //  Implements the HashCore method of the KeyedHashAlgorithm class by calling the InfoCard native client.
        // 
        // Parameters: 
        //  array   - the bytes to hash.
        //  ibStart - the index in the array from which to begin hashing. 
        //  cbSize  - the number of bytes after the starting index to hash.
        //
        protected override void HashCore(byte[] array, int ibStart, int cbSize)
        { 
            //
            // will cache one block and call TransformBlock on the previous block. 
            // 
            if ( null != m_cachedBlock )
            { 

                HGlobalSafeHandle pInData = null;
                try
                { 
                    if ( 0 != m_cachedBlock.Length )
                    { 
                        pInData = HGlobalSafeHandle.Construct( m_cachedBlock.Length ); 
                        Marshal.Copy( m_cachedBlock, 0, pInData.DangerousGetHandle(), m_cachedBlock.Length );
                    } 

                    int status = CardSpaceSelector.GetShim().m_csShimHashCore( m_cryptoHandle.InternalHandle,
                                                         m_cachedBlock.Length,
                                                         null != pInData ? pInData: HGlobalSafeHandle.Construct() ); 

                    if ( 0 != status ) 
                    { 
                        ExceptionHelper.ThrowIfCardSpaceException( status );
                        throw IDT.ThrowHelperError( new Win32Exception( status ) ); 
                    }

                }
                finally 
                {
                    if( null != pInData ) 
                    { 
                        pInData.Dispose();
                    } 
                }

            }
 
            //
            // Cache the current block. 
            // 
            if ( null != m_cachedBlock )
            { 
                Array.Clear( m_cachedBlock, 0, m_cachedBlock.Length );
            }
            m_cachedBlock = DiagnosticUtility.Utility.AllocateByteArray(cbSize);
            Array.Copy(array, ibStart, m_cachedBlock, 0, cbSize); 

            return; 
        } 

        // 
        // Summary:
        //  Implements the HashFinal method of the KeyedHashAlgorithm class by calling the InfoCard native client.
        //
        protected override byte[] HashFinal() 
        {
            byte[] outData = null; 
            int    cbOutData = 0; 
            IDT.DebugAssert( null != m_cachedBlock, "null cached block" );
 
            HGlobalSafeHandle pInData = null;
            GlobalAllocSafeHandle pOutData = null;
            try
            { 
                if( null != m_cachedBlock )
                { 
 
                    if( 0 != m_cachedBlock.Length )
                    { 
                        pInData = HGlobalSafeHandle.Construct( m_cachedBlock.Length );
                        Marshal.Copy( m_cachedBlock, 0, pInData.DangerousGetHandle(), m_cachedBlock.Length );
                    }
 
                    int status = CardSpaceSelector.GetShim().m_csShimHashFinal( m_cryptoHandle.InternalHandle,
                                                         m_cachedBlock.Length, 
                                                         null != pInData ? pInData : HGlobalSafeHandle.Construct(), 
                                                         out cbOutData,
                                                         out pOutData ); 
                    if( 0 != status )
                    {
                        ExceptionHelper.ThrowIfCardSpaceException( status );
                        throw IDT.ThrowHelperError( new Win32Exception( status ) ); 
                    }
                    pOutData.Length = cbOutData; 
                    outData = DiagnosticUtility.Utility.AllocateByteArray( pOutData.Length ); 
                    using( pOutData )
                    { 
                        Marshal.Copy( pOutData.DangerousGetHandle(), outData, 0, pOutData.Length );
                    }
                }
            } 
            finally
            { 
                if ( null != pInData ) 
                {
                    pInData.Dispose(); 
                }
                Array.Clear( m_cachedBlock, 0, m_cachedBlock.Length );
                m_cachedBlock = null;
            } 

            return outData; 
        } 

        protected override void Dispose( bool disposing ) 
        {
            try
            {
                if ( null != m_cachedBlock ) 
                {
                    Array.Clear( m_cachedBlock, 0, m_cachedBlock.Length ); 
                } 
                m_cryptoHandle.Dispose();
            } 
            finally
            {
                base.Dispose( disposing );
            } 
        }
    } 
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
                        

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