DigestTraceRecordHelper.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 / IdentityModel / System / IdentityModel / Diagnostics / DigestTraceRecordHelper.cs / 1 / DigestTraceRecordHelper.cs

                            //------------------------------------------------------------ 
// Copyright (c) Microsoft Corporation.  All rights reserved.
//-----------------------------------------------------------

namespace System.IdentityModel.Diagnostics 
{
    using System; 
    using System.Diagnostics; 
    using System.IO;
    using System.Globalization; 
    using System.Security.Cryptography;
    using System.Text;
    using System.Xml;
    using System.ServiceModel.Diagnostics; 

    internal class DigestTraceRecord : TraceRecord 
    { 
        MemoryStream _logStream;
        HashAlgorithm _hash; 
        string _traceName;

        const string Empty = "Empty";
 
        const string CanonicalElementString = "CanonicalElementString";
        const string CanonicalElementStringLength = "CanonicalElementStringLength"; 
 
        const string CanonicalOctets = "CanonicalOctets";
        const string CanonicalOctetsLength = "CanonicalOctetsLength"; 

        const string CanonicalOctetsHash = "CanonicalOctetsHash";
        const string CanonicalOctetsHashLength = "CanonicalOctetsHashLength";
 
        const string Key = "Key";
        const string Length = "Length"; 
        const string FirstByte = "FirstByte"; 
        const string LastByte = "LastByte";
 
        internal DigestTraceRecord(string traceName, MemoryStream logStream, HashAlgorithm hash)
        {
            if (String.IsNullOrEmpty(traceName))
                _traceName = Empty; 
            else
                _traceName = traceName; 
 
            _logStream = logStream;
            _hash = hash; 
        }

        internal override string EventId
        { 
            get
            { 
                return TraceRecord.EventIdBase + _traceName + TraceRecord.NamespaceSuffix; 
            }
        } 

        internal override void WriteTo(XmlWriter writer)
        {
 
            base.WriteTo(writer);
 
            // 
            // canonical element string
            // 
            byte[] contentBuffer = _logStream.GetBuffer();
            string contentAsString = System.Text.Encoding.UTF8.GetString(contentBuffer, 0, (int)_logStream.Length);

 
            writer.WriteElementString(CanonicalElementStringLength, contentAsString.Length.ToString(CultureInfo.InvariantCulture));
            writer.WriteComment(CanonicalElementString + ":" + contentAsString); 
 
            //
            // canonical element base64 format 
            //
            writer.WriteElementString(CanonicalOctetsLength, contentBuffer.Length.ToString(CultureInfo.InvariantCulture));
            writer.WriteElementString(CanonicalOctets, Convert.ToBase64String(contentBuffer));
 
            //
            // Hash 
            // 
            writer.WriteElementString(CanonicalOctetsHashLength, _hash.Hash.Length.ToString(CultureInfo.InvariantCulture));
            writer.WriteElementString(CanonicalOctetsHash, Convert.ToBase64String(_hash.Hash)); 

            //
            // Key: this will only be printed out for the symmetric key case
            // 
            if (_hash is KeyedHashAlgorithm)
            { 
                KeyedHashAlgorithm keyedHash = _hash as KeyedHashAlgorithm; 
                byte[] key = keyedHash.Key;
 
                writer.WriteStartElement(Key); // start the key element

                writer.WriteElementString(Length, key.Length.ToString(CultureInfo.InvariantCulture)); // key length
                writer.WriteElementString(FirstByte, key[0].ToString(CultureInfo.InvariantCulture)); // first byte of the key 
                writer.WriteElementString(LastByte, key[key.Length - 1].ToString(CultureInfo.InvariantCulture)); // last byte of the key
 
                writer.WriteEndElement();  // close the key element 
            }
        } 
    }

    internal static class DigestTraceRecordHelper
    { 
        const string DigestTrace = "DigestTrace";
        static bool _shouldTraceDigest = false; 
        static bool _initialized = false; 

        internal static bool ShouldTraceDigest 
        {
            get
            {
                if (!_initialized) 
                    InitializeShouldTraceDigest();
 
                return _shouldTraceDigest; 
            }
        } 

        static void InitializeShouldTraceDigest()
        {
            // 
            // Log the digest only if
            // 1.Users ask for verbose AND 
            // 2.Users are fine with logging Pii ( private identity information ) - todo 
            //
            if (DiagnosticUtility.DiagnosticTrace != null && 
                DiagnosticUtility.DiagnosticTrace.TraceSource != null &&
                DiagnosticUtility.DiagnosticTrace.TraceSource.ShouldLogPii &&
                DiagnosticUtility.ShouldTraceVerbose)
            { 
                _shouldTraceDigest = true;
            } 
 
            _initialized = true;
        } 

        internal static void TraceDigest(MemoryStream logStream, HashAlgorithm hash)
        {
            if (DigestTraceRecordHelper.ShouldTraceDigest) 
            {
                TraceUtility.TraceEvent(TraceEventType.Verbose, TraceCode.IdentityModel, new DigestTraceRecord(DigestTrace, logStream, hash), null, null); 
            } 
        }
    } 
}

// 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