Code:
/ WCF / WCF / 3.5.30729.1 / untmp / Orcas / SP / ndp / cdf / src / WCF / ServiceModel / System / ServiceModel / Diagnostics / SecurityTraceRecordHelper.cs / 1 / SecurityTraceRecordHelper.cs
//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------
namespace System.ServiceModel.Diagnostics
{
using System;
using System.ServiceModel.Channels;
//using System.ServiceModel;
using System.ServiceModel.Dispatcher;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Runtime.Serialization;
using System.IdentityModel.Claims;
using System.IdentityModel.Policy;
using System.IdentityModel.Selectors;
using System.IdentityModel.Tokens;
using System.Security.Principal;
using System.ServiceModel.Security.Tokens;
using System.ServiceModel.Security;
using System.Text;
using System.Xml;
internal class SecurityTraceRecord : TraceRecord
{
String traceName;
internal SecurityTraceRecord(String traceName)
{
if (String.IsNullOrEmpty(traceName))
this.traceName = "Empty";
else
this.traceName = traceName;
}
internal override string EventId
{
get
{
return TraceRecord.EventIdBase + traceName + TraceRecord.NamespaceSuffix;
}
}
}
internal static class SecurityTraceRecordHelper
{
internal static void TraceRemovedCachedServiceToken(IssuanceTokenProviderBase provider, SecurityToken serviceToken)
where T : IssuanceTokenProviderState
{
if (DiagnosticUtility.ShouldTraceInformation)
{
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.IssuanceTokenProviderRemovedCachedToken, SR.GetString(SR.TraceCodeIssuanceTokenProviderRemovedCachedToken), new IssuanceProviderTraceRecord(provider, serviceToken));
}
}
internal static void TraceUsingCachedServiceToken(IssuanceTokenProviderBase provider, SecurityToken serviceToken, EndpointAddress target)
where T : IssuanceTokenProviderState
{
if (DiagnosticUtility.ShouldTraceInformation)
{
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.IssuanceTokenProviderUsingCachedToken, SR.GetString(SR.TraceCodeIssuanceTokenProviderUsingCachedToken), new IssuanceProviderTraceRecord(provider, serviceToken, target));
}
}
internal static void TraceBeginSecurityNegotiation(IssuanceTokenProviderBase provider, EndpointAddress target)
where T : IssuanceTokenProviderState
{
if (DiagnosticUtility.ShouldTraceInformation)
{
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.IssuanceTokenProviderBeginSecurityNegotiation, SR.GetString(SR.TraceCodeIssuanceTokenProviderBeginSecurityNegotiation), new IssuanceProviderTraceRecord(provider, target));
}
}
internal static void TraceEndSecurityNegotiation(IssuanceTokenProviderBase provider, SecurityToken serviceToken, EndpointAddress target)
where T : IssuanceTokenProviderState
{
if (DiagnosticUtility.ShouldTraceInformation)
{
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.IssuanceTokenProviderEndSecurityNegotiation, SR.GetString(SR.TraceCodeIssuanceTokenProviderEndSecurityNegotiation), new IssuanceProviderTraceRecord(provider, serviceToken, target));
}
}
internal static void TraceRedirectApplied(IssuanceTokenProviderBase provider, EndpointAddress newTarget, EndpointAddress oldTarget)
where T : IssuanceTokenProviderState
{
if (DiagnosticUtility.ShouldTraceInformation)
{
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.IssuanceTokenProviderRedirectApplied, SR.GetString(SR.TraceCodeIssuanceTokenProviderRedirectApplied), new IssuanceProviderTraceRecord(provider, newTarget, oldTarget));
}
}
internal static void TraceClientServiceTokenCacheFull(IssuanceTokenProviderBase provider, int cacheSize)
where T : IssuanceTokenProviderState
{
if (DiagnosticUtility.ShouldTraceInformation)
{
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.IssuanceTokenProviderServiceTokenCacheFull, SR.GetString(SR.TraceCodeIssuanceTokenProviderServiceTokenCacheFull), new IssuanceProviderTraceRecord(provider, cacheSize));
}
}
internal static void TraceClientSpnego(WindowsSspiNegotiation windowsNegotiation)
{
if (DiagnosticUtility.ShouldTraceInformation)
{
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SpnegoClientNegotiationCompleted, SR.GetString(SR.TraceCodeSpnegoClientNegotiationCompleted), new WindowsSspiNegotiationTraceRecord(windowsNegotiation, true));
}
}
internal static void TraceServiceSpnego(WindowsSspiNegotiation windowsNegotiation)
{
if (DiagnosticUtility.ShouldTraceInformation)
{
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SpnegoServiceNegotiationCompleted, SR.GetString(SR.TraceCodeSpnegoServiceNegotiationCompleted), new WindowsSspiNegotiationTraceRecord(windowsNegotiation, false));
}
}
internal static void TraceNegotiationTokenAuthenticatorAttached(NegotiationTokenAuthenticator authenticator, IChannelListener transportChannelListener)
where T : NegotiationTokenAuthenticatorState
{
if (DiagnosticUtility.ShouldTraceInformation)
{
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.NegotiationAuthenticatorAttached, SR.GetString(SR.TraceCodeNegotiationAuthenticatorAttached), new NegotiationAuthenticatorTraceRecord(authenticator, transportChannelListener));
}
}
internal static void TraceServiceSecurityNegotiationCompleted(NegotiationTokenAuthenticator authenticator, SecurityContextSecurityToken serviceToken)
where T : NegotiationTokenAuthenticatorState
{
if (DiagnosticUtility.ShouldTraceInformation)
{
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.ServiceSecurityNegotiationCompleted, SR.GetString(SR.TraceCodeServiceSecurityNegotiationCompleted),
new NegotiationAuthenticatorTraceRecord(authenticator, serviceToken));
}
}
internal static void TraceServiceSecurityNegotiationFailure(NegotiationTokenAuthenticator authenticator, Exception e)
where T : NegotiationTokenAuthenticatorState
{
if (DiagnosticUtility.ShouldTraceWarning)
{
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning, TraceCode.SecurityNegotiationProcessingFailure, SR.GetString(SR.TraceCodeSecurityNegotiationProcessingFailure), new NegotiationAuthenticatorTraceRecord(authenticator, e));
}
}
internal static void TraceSecurityContextTokenCacheFull(int capacity, int pruningAmount)
{
if (DiagnosticUtility.ShouldTraceInformation)
{
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecurityContextTokenCacheFull, SR.GetString(SR.TraceCodeSecurityContextTokenCacheFull),
new SecurityContextTokenCacheTraceRecord(capacity, pruningAmount));
}
}
internal static void TraceIdentityVerificationSuccess(EndpointIdentity identity, Claim claim, Type identityVerifier)
{
if (DiagnosticUtility.ShouldTraceInformation)
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecurityIdentityVerificationSuccess, SR.GetString(SR.TraceCodeSecurityIdentityVerificationSuccess), new IdentityVerificationSuccessTraceRecord(identity, claim, identityVerifier));
}
internal static void TraceIdentityVerificationFailure(EndpointIdentity identity, AuthorizationContext authContext, Type identityVerifier)
{
if (DiagnosticUtility.ShouldTraceInformation)
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecurityIdentityVerificationFailure, SR.GetString(SR.TraceCodeSecurityIdentityVerificationFailure), new IdentityVerificationFailureTraceRecord(identity, authContext, identityVerifier));
}
internal static void TraceIdentityDeterminationSuccess(EndpointAddress epr, EndpointIdentity identity, Type identityVerifier)
{
if (DiagnosticUtility.ShouldTraceInformation)
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecurityIdentityDeterminationSuccess, SR.GetString(SR.TraceCodeSecurityIdentityDeterminationSuccess), new IdentityDeterminationSuccessTraceRecord(epr, identity, identityVerifier));
}
internal static void TraceIdentityDeterminationFailure(EndpointAddress epr, Type identityVerifier)
{
if (DiagnosticUtility.ShouldTraceInformation)
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecurityIdentityDeterminationFailure, SR.GetString(SR.TraceCodeSecurityIdentityDeterminationFailure), new IdentityDeterminationFailureTraceRecord(epr, identityVerifier));
}
internal static void TraceIdentityHostNameNormalizationFailure(EndpointAddress epr, Type identityVerifier, Exception e)
{
if (DiagnosticUtility.ShouldTraceInformation)
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecurityIdentityHostNameNormalizationFailure, SR.GetString(SR.TraceCodeSecurityIdentityHostNameNormalizationFailure), new IdentityHostNameNormalizationFailureTraceRecord(epr, identityVerifier, e));
}
internal static void TraceExportChannelBindingEntry()
{
if (DiagnosticUtility.ShouldTraceInformation)
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.ExportSecurityChannelBindingEntry, SR.GetString(SR.TraceCodeExportSecurityChannelBindingEntry), null);
}
internal static void TraceExportChannelBindingExit()
{
if (DiagnosticUtility.ShouldTraceInformation)
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.ExportSecurityChannelBindingExit, SR.GetString(SR.TraceCodeExportSecurityChannelBindingExit));
}
internal static void TraceImportChannelBindingEntry()
{
if (DiagnosticUtility.ShouldTraceInformation)
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.ImportSecurityChannelBindingEntry, SR.GetString(SR.TraceCodeImportSecurityChannelBindingEntry), null);
}
internal static void TraceImportChannelBindingExit()
{
if (DiagnosticUtility.ShouldTraceInformation)
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.ImportSecurityChannelBindingExit, SR.GetString(SR.TraceCodeImportSecurityChannelBindingExit));
}
internal static void TraceTokenProviderOpened(SecurityTokenProvider provider)
{
if (DiagnosticUtility.ShouldTraceInformation)
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecurityTokenProviderOpened, SR.GetString(SR.TraceCodeSecurityTokenProviderOpened), new TokenProviderTraceRecord(provider));
}
internal static void TraceTokenProviderClosed(SecurityTokenProvider provider)
{
if (DiagnosticUtility.ShouldTraceInformation)
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecurityTokenProviderClosed, SR.GetString(SR.TraceCodeSecurityTokenProviderClosed), new TokenProviderTraceRecord(provider));
}
internal static void TraceTokenAuthenticatorOpened(SecurityTokenAuthenticator authenticator)
{
if (DiagnosticUtility.ShouldTraceVerbose)
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Verbose, TraceCode.SecurityTokenAuthenticatorOpened, SR.GetString(SR.TraceCodeSecurityTokenAuthenticatorOpened), new TokenAuthenticatorTraceRecord(authenticator));
}
internal static void TraceTokenAuthenticatorClosed(SecurityTokenAuthenticator authenticator)
{
if (DiagnosticUtility.ShouldTraceInformation)
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecurityTokenAuthenticatorClosed, SR.GetString(SR.TraceCodeSecurityTokenAuthenticatorClosed), new TokenAuthenticatorTraceRecord(authenticator));
}
internal static void TraceOutgoingMessageSecured(SecurityProtocol binding, Message message)
{
if (DiagnosticUtility.ShouldTraceInformation)
TraceUtility.TraceEvent(TraceEventType.Information, TraceCode.SecurityBindingOutgoingMessageSecured, new MessageSecurityTraceRecord(binding, message), null, null, message);
}
internal static void TraceIncomingMessageVerified(SecurityProtocol binding, Message message)
{
if (DiagnosticUtility.ShouldTraceInformation)
TraceUtility.TraceEvent(TraceEventType.Information, TraceCode.SecurityBindingIncomingMessageVerified, new MessageSecurityTraceRecord(binding, message), null, null, message);
}
internal static void TraceSecureOutgoingMessageFailure(SecurityProtocol binding, Message message)
{
if (DiagnosticUtility.ShouldTraceWarning)
TraceUtility.TraceEvent(TraceEventType.Warning, TraceCode.SecurityBindingSecureOutgoingMessageFailure, new MessageSecurityTraceRecord(binding, message), null, null, message);
}
internal static void TraceVerifyIncomingMessageFailure(SecurityProtocol binding, Message message)
{
if (DiagnosticUtility.ShouldTraceWarning)
TraceUtility.TraceEvent(TraceEventType.Warning, TraceCode.SecurityBindingVerifyIncomingMessageFailure, new MessageSecurityTraceRecord(binding, message), null, null,message );
}
internal static void TraceSpnToSidMappingFailure(string spn, Exception e)
{
if (DiagnosticUtility.ShouldTraceWarning)
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning, TraceCode.SecuritySpnToSidMappingFailure, SR.GetString(SR.TraceCodeSecuritySpnToSidMappingFailure), new SpnToSidMappingTraceRecord(spn, e));
}
internal static void TraceSessionRedirectApplied(EndpointAddress previousTarget, EndpointAddress newTarget, GenericXmlSecurityToken sessionToken)
{
if (DiagnosticUtility.ShouldTraceInformation)
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecuritySessionRedirectApplied, SR.GetString(SR.TraceCodeSecuritySessionRedirectApplied), new SessionRedirectAppliedTraceRecord(previousTarget, newTarget, sessionToken));
}
internal static void TraceCloseMessageSent(SecurityToken sessionToken, EndpointAddress remoteTarget)
{
if (DiagnosticUtility.ShouldTraceInformation)
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecurityClientSessionCloseSent, SR.GetString(SR.TraceCodeSecurityClientSessionCloseSent), new ClientSessionTraceRecord(sessionToken, null, remoteTarget));
}
internal static void TraceCloseResponseMessageSent(SecurityToken sessionToken, EndpointAddress remoteTarget)
{
if (DiagnosticUtility.ShouldTraceInformation)
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecurityClientSessionCloseResponseSent, SR.GetString(SR.TraceCodeSecurityClientSessionCloseResponseSent), new ClientSessionTraceRecord(sessionToken, null, remoteTarget));
}
internal static void TraceCloseMessageReceived(SecurityToken sessionToken, EndpointAddress remoteTarget)
{
if (DiagnosticUtility.ShouldTraceInformation)
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecurityClientSessionCloseMessageReceived, SR.GetString(SR.TraceCodeSecurityClientSessionCloseMessageReceived), new ClientSessionTraceRecord(sessionToken, null, remoteTarget));
}
internal static void TraceSessionKeyRenewalFault(SecurityToken sessionToken, EndpointAddress remoteTarget)
{
if (DiagnosticUtility.ShouldTraceWarning)
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning, TraceCode.SecuritySessionKeyRenewalFaultReceived, SR.GetString(SR.TraceCodeSecuritySessionKeyRenewalFaultReceived), new ClientSessionTraceRecord(sessionToken, null, remoteTarget));
}
internal static void TraceRemoteSessionAbortedFault(SecurityToken sessionToken, EndpointAddress remoteTarget)
{
if (DiagnosticUtility.ShouldTraceWarning)
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning, TraceCode.SecuritySessionAbortedFaultReceived, SR.GetString(SR.TraceCodeSecuritySessionAbortedFaultReceived), new ClientSessionTraceRecord(sessionToken, null, remoteTarget));
}
internal static void TraceCloseResponseReceived(SecurityToken sessionToken, EndpointAddress remoteTarget)
{
if (DiagnosticUtility.ShouldTraceInformation)
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecuritySessionClosedResponseReceived, SR.GetString(SR.TraceCodeSecuritySessionClosedResponseReceived), new ClientSessionTraceRecord(sessionToken, null, remoteTarget));
}
internal static void TracePreviousSessionKeyDiscarded(SecurityToken previousSessionToken, SecurityToken currentSessionToken, EndpointAddress remoteAddress)
{
if (DiagnosticUtility.ShouldTraceInformation)
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecurityClientSessionPreviousKeyDiscarded, SR.GetString(SR.TraceCodeSecurityClientSessionPreviousKeyDiscarded), new ClientSessionTraceRecord(currentSessionToken, previousSessionToken, remoteAddress));
}
internal static void TraceSessionKeyRenewed(SecurityToken newSessionToken, SecurityToken currentSessionToken, EndpointAddress remoteAddress)
{
if (DiagnosticUtility.ShouldTraceInformation)
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecurityClientSessionKeyRenewed, SR.GetString(SR.TraceCodeSecurityClientSessionKeyRenewed), new ClientSessionTraceRecord(newSessionToken, currentSessionToken, remoteAddress));
}
internal static void TracePendingSessionAdded(UniqueId sessionId, Uri listenAddress)
{
if (DiagnosticUtility.ShouldTraceInformation)
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecurityPendingServerSessionAdded, SR.GetString(SR.TraceCodeSecurityPendingServerSessionAdded), new ServerSessionTraceRecord(sessionId, listenAddress));
}
internal static void TracePendingSessionClosed(UniqueId sessionId, Uri listenAddress)
{
if (DiagnosticUtility.ShouldTraceWarning)
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning, TraceCode.SecurityPendingServerSessionClosed, SR.GetString(SR.TraceCodeSecurityPendingServerSessionClosed), new ServerSessionTraceRecord(sessionId, listenAddress));
}
internal static void TracePendingSessionActivated(UniqueId sessionId, Uri listenAddress)
{
if (DiagnosticUtility.ShouldTraceInformation)
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecurityPendingServerSessionActivated, SR.GetString(SR.TraceCodeSecurityPendingServerSessionActivated), new ServerSessionTraceRecord(sessionId, listenAddress));
}
internal static void TraceActiveSessionRemoved(UniqueId sessionId, Uri listenAddress)
{
if (DiagnosticUtility.ShouldTraceInformation)
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecurityActiveServerSessionRemoved, SR.GetString(SR.TraceCodeSecurityActiveServerSessionRemoved), new ServerSessionTraceRecord(sessionId, listenAddress));
}
internal static void TraceNewServerSessionKeyIssued(SecurityContextSecurityToken newToken, SecurityContextSecurityToken supportingToken, Uri listenAddress)
{
if (DiagnosticUtility.ShouldTraceInformation)
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecurityNewServerSessionKeyIssued, SR.GetString(SR.TraceCodeSecurityNewServerSessionKeyIssued), new ServerSessionTraceRecord(newToken, supportingToken, listenAddress));
}
internal static void TraceInactiveSessionFaulted(SecurityContextSecurityToken sessionToken, Uri listenAddress)
{
if (DiagnosticUtility.ShouldTraceWarning)
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning, TraceCode.SecurityInactiveSessionFaulted, SR.GetString(SR.TraceCodeSecurityInactiveSessionFaulted), new ServerSessionTraceRecord(sessionToken, (SecurityContextSecurityToken) null, listenAddress));
}
internal static void TraceServerSessionKeyUpdated(SecurityContextSecurityToken sessionToken, Uri listenAddress)
{
if (DiagnosticUtility.ShouldTraceInformation)
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecurityServerSessionKeyUpdated, SR.GetString(SR.TraceCodeSecurityServerSessionKeyUpdated), new ServerSessionTraceRecord(sessionToken, (SecurityContextSecurityToken)null, listenAddress));
}
internal static void TraceServerSessionCloseReceived(SecurityContextSecurityToken sessionToken, Uri listenAddress)
{
if (DiagnosticUtility.ShouldTraceInformation)
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecurityServerSessionCloseReceived, SR.GetString(SR.TraceCodeSecurityServerSessionCloseReceived), new ServerSessionTraceRecord(sessionToken, (SecurityContextSecurityToken)null, listenAddress));
}
internal static void TraceServerSessionCloseResponseReceived(SecurityContextSecurityToken sessionToken, Uri listenAddress)
{
if (DiagnosticUtility.ShouldTraceInformation)
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecurityServerSessionCloseResponseReceived, SR.GetString(SR.TraceCodeSecurityServerSessionCloseResponseReceived), new ServerSessionTraceRecord(sessionToken, (SecurityContextSecurityToken)null, listenAddress));
}
internal static void TraceSessionRenewalFaultSent(SecurityContextSecurityToken sessionToken, Uri listenAddress, Message message)
{
if (DiagnosticUtility.ShouldTraceWarning)
TraceUtility.TraceEvent(TraceEventType.Warning, TraceCode.SecurityServerSessionRenewalFaultSent, new ServerSessionTraceRecord(sessionToken, message, listenAddress), null, null, message);
}
internal static void TraceSessionAbortedFaultSent(SecurityContextSecurityToken sessionToken, Uri listenAddress)
{
if (DiagnosticUtility.ShouldTraceWarning)
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning, TraceCode.SecurityServerSessionAbortedFaultSent, SR.GetString(SR.TraceCodeSecurityServerSessionAbortedFaultSent), new ServerSessionTraceRecord(sessionToken, (SecurityContextSecurityToken)null, listenAddress));
}
internal static void TraceSessionClosedResponseSent(SecurityContextSecurityToken sessionToken, Uri listenAddress)
{
if (DiagnosticUtility.ShouldTraceInformation)
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecuritySessionCloseResponseSent, SR.GetString(SR.TraceCodeSecuritySessionCloseResponseSent), new ServerSessionTraceRecord(sessionToken, (SecurityContextSecurityToken)null, listenAddress));
}
internal static void TraceSessionClosedSent(SecurityContextSecurityToken sessionToken, Uri listenAddress)
{
if (DiagnosticUtility.ShouldTraceInformation)
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecuritySessionServerCloseSent, SR.GetString(SR.TraceCodeSecuritySessionServerCloseSent), new ServerSessionTraceRecord(sessionToken, (SecurityContextSecurityToken)null, listenAddress));
}
internal static void TraceRenewFaultSendFailure(SecurityContextSecurityToken sessionToken, Uri listenAddress, Exception e)
{
if (DiagnosticUtility.ShouldTraceWarning)
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning, TraceCode.SecuritySessionRenewFaultSendFailure, SR.GetString(SR.TraceCodeSecuritySessionRenewFaultSendFailure), new ServerSessionTraceRecord(sessionToken, listenAddress), e);
}
internal static void TraceSessionAbortedFaultSendFailure(SecurityContextSecurityToken sessionToken, Uri listenAddress, Exception e)
{
if (DiagnosticUtility.ShouldTraceWarning)
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning, TraceCode.SecuritySessionAbortedFaultSendFailure, SR.GetString(SR.TraceCodeSecuritySessionAbortedFaultSendFailure), new ServerSessionTraceRecord(sessionToken, listenAddress), e);
}
internal static void TraceSessionClosedResponseSendFailure(SecurityContextSecurityToken sessionToken, Uri listenAddress, Exception e)
{
if (DiagnosticUtility.ShouldTraceWarning)
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning, TraceCode.SecuritySessionClosedResponseSendFailure, SR.GetString(SR.TraceCodeSecuritySessionClosedResponseSendFailure), new ServerSessionTraceRecord(sessionToken, listenAddress), e);
}
internal static void TraceSessionCloseSendFailure(SecurityContextSecurityToken sessionToken, Uri listenAddress, Exception e)
{
if (DiagnosticUtility.ShouldTraceWarning)
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning, TraceCode.SecuritySessionServerCloseSendFailure, SR.GetString(SR.TraceCodeSecuritySessionServerCloseSendFailure), new ServerSessionTraceRecord(sessionToken, listenAddress), e);
}
internal static void TraceBeginSecuritySessionOperation(SecuritySessionOperation operation, EndpointAddress target, SecurityToken currentToken)
{
if (DiagnosticUtility.ShouldTraceInformation)
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecuritySessionRequestorStartOperation, SR.GetString(SR.TraceCodeSecuritySessionRequestorStartOperation), new SessionRequestorTraceRecord(operation, currentToken, (GenericXmlSecurityToken)null, target));
}
internal static void TraceSecuritySessionOperationSuccess(SecuritySessionOperation operation, EndpointAddress target, SecurityToken currentToken, SecurityToken issuedToken)
{
if (DiagnosticUtility.ShouldTraceInformation)
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecuritySessionRequestorOperationSuccess, SR.GetString(SR.TraceCodeSecuritySessionRequestorOperationSuccess), new SessionRequestorTraceRecord(operation, currentToken, issuedToken, target));
}
internal static void TraceSecuritySessionOperationFailure(SecuritySessionOperation operation, EndpointAddress target, SecurityToken currentToken, Exception e)
{
if (DiagnosticUtility.ShouldTraceWarning)
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning, TraceCode.SecuritySessionRequestorOperationFailure, SR.GetString(SR.TraceCodeSecuritySessionRequestorOperationFailure), new SessionRequestorTraceRecord(operation, currentToken, e, target));
}
internal static void TraceServerSessionOperationException(SecuritySessionOperation operation, Exception e, Uri listenAddress)
{
if (DiagnosticUtility.ShouldTraceWarning)
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning, TraceCode.SecuritySessionResponderOperationFailure, SR.GetString(SR.TraceCodeSecuritySessionResponderOperationFailure), new SessionResponderTraceRecord(operation, e, listenAddress));
}
internal static void TraceImpersonationSucceeded(DispatchOperationRuntime operation)
{
if (DiagnosticUtility.ShouldTraceInformation)
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecurityImpersonationSuccess, SR.GetString(SR.TraceCodeSecurityImpersonationSuccess), new ImpersonationTraceRecord(operation));
}
internal static void TraceImpersonationFailed(DispatchOperationRuntime operation, Exception e)
{
if (DiagnosticUtility.ShouldTraceWarning)
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning, TraceCode.SecurityImpersonationFailure, SR.GetString(SR.TraceCodeSecurityImpersonationFailure), new ImpersonationTraceRecord(operation), e);
}
static void WritePossibleGenericXmlToken(XmlWriter writer, string startElement, SecurityToken token)
{
if (writer == null)
return;
writer.WriteStartElement(startElement);
GenericXmlSecurityToken gxt = token as GenericXmlSecurityToken;
if (gxt != null)
{
WriteGenericXmlToken(writer, gxt);
}
else
{
if (token != null)
writer.WriteElementString("TokenType", token.GetType().ToString());
}
writer.WriteEndElement();
}
static void WriteGenericXmlToken(XmlWriter xml, SecurityToken sessiontoken)
{
if (xml == null || sessiontoken == null)
return;
xml.WriteElementString("SessionTokenType", sessiontoken.GetType().ToString());
xml.WriteElementString("ValidFrom", XmlConvert.ToString(sessiontoken.ValidFrom, XmlDateTimeSerializationMode.Utc));
xml.WriteElementString("ValidTo", XmlConvert.ToString(sessiontoken.ValidTo, XmlDateTimeSerializationMode.Utc));
GenericXmlSecurityToken token = sessiontoken as GenericXmlSecurityToken;
if (token != null)
{
if (token.InternalTokenReference != null)
{
xml.WriteElementString("InternalTokenReference", token.InternalTokenReference.ToString());
}
if (token.ExternalTokenReference != null)
{
xml.WriteElementString("ExternalTokenReference", token.ExternalTokenReference.ToString());
}
xml.WriteElementString("IssuedTokenElementName", token.TokenXml.LocalName);
xml.WriteElementString("IssuedTokenElementNamespace", token.TokenXml.NamespaceURI);
}
}
static void WriteSecurityContextToken(XmlWriter xml, SecurityContextSecurityToken token)
{
xml.WriteElementString("ContextId", token.ContextId.ToString());
if (token.KeyGeneration != null)
{
xml.WriteElementString("KeyGeneration", token.KeyGeneration.ToString());
}
}
static internal void WriteClaim(XmlWriter xml, Claim claim)
{
if (xml == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("xml");
if (claim != null)
{
xml.WriteStartElement("Claim");
if (null != DiagnosticUtility.DiagnosticTrace
&& null != DiagnosticUtility.DiagnosticTrace.TraceSource
&& DiagnosticUtility.DiagnosticTrace.TraceSource.ShouldLogPii)
{
//
// ClaimType
//
xml.WriteElementString("ClaimType", claim.ClaimType);
//
// Right
//
xml.WriteElementString("Right", claim.Right);
//
// Resource object type: most of time, it is a System.String
//
if (claim.Resource != null)
xml.WriteElementString("ResourceType", claim.Resource.GetType().ToString());
else
xml.WriteElementString("Resource", "null");
}
else
{
xml.WriteString(claim.GetType().AssemblyQualifiedName);
}
xml.WriteEndElement();
}
}
class SessionResponderTraceRecord : SecurityTraceRecord
{
SecuritySessionOperation operation;
Exception e;
Uri listenAddress;
public SessionResponderTraceRecord(SecuritySessionOperation operation, Exception e, Uri listenAddress)
: base("SecuritySession")
{
this.operation = operation;
this.e = e;
this.listenAddress = listenAddress;
}
internal override void WriteTo(System.Xml.XmlWriter xml)
{
if (xml == null)
return;
xml.WriteElementString("Operation", this.operation.ToString());
if (this.e != null)
{
xml.WriteElementString("Exception", e.ToString());
}
if (this.listenAddress != null)
xml.WriteElementString("ListenAddress", this.listenAddress.ToString());
}
}
class SessionRequestorTraceRecord : SecurityTraceRecord
{
SecuritySessionOperation operation;
SecurityToken currentToken;
SecurityToken issuedToken;
EndpointAddress target;
Exception e;
public SessionRequestorTraceRecord(SecuritySessionOperation operation, SecurityToken currentToken, SecurityToken issuedToken, EndpointAddress target)
: base("SecuritySession")
{
this.operation = operation;
this.currentToken = currentToken;
this.issuedToken = issuedToken;
this.target = target;
}
public SessionRequestorTraceRecord(SecuritySessionOperation operation, SecurityToken currentToken, Exception e, EndpointAddress target)
: base("SecuritySession")
{
this.operation = operation;
this.currentToken = currentToken;
this.e = e;
this.target = target;
}
internal override void WriteTo(System.Xml.XmlWriter xml)
{
if (xml == null)
return;
xml.WriteElementString("Operation", this.operation.ToString());
if (this.currentToken != null)
{
WritePossibleGenericXmlToken(xml, "SupportingToken", this.currentToken);
}
if (this.issuedToken != null)
{
WritePossibleGenericXmlToken(xml, "IssuedToken", this.issuedToken);
}
if (this.e != null)
{
xml.WriteElementString("Exception", e.ToString());
}
if (this.target != null)
{
xml.WriteElementString("RemoteAddress", this.target.ToString());
}
}
}
class ServerSessionTraceRecord : SecurityTraceRecord
{
SecurityContextSecurityToken currentSessionToken;
SecurityContextSecurityToken newSessionToken;
UniqueId sessionId;
Message message;
Uri listenAddress;
public ServerSessionTraceRecord(SecurityContextSecurityToken currentSessionToken, SecurityContextSecurityToken newSessionToken, Uri listenAddress)
: base("SecuritySession")
{
this.currentSessionToken = currentSessionToken;
this.newSessionToken = newSessionToken;
this.listenAddress = listenAddress;
}
public ServerSessionTraceRecord(SecurityContextSecurityToken currentSessionToken, Message message, Uri listenAddress)
: base("SecuritySession")
{
this.currentSessionToken = currentSessionToken;
this.message = message;
this.listenAddress = listenAddress;
}
public ServerSessionTraceRecord(SecurityContextSecurityToken currentSessionToken, Uri listenAddress)
: base("SecuritySession")
{
this.currentSessionToken = currentSessionToken;
this.listenAddress = listenAddress;
}
public ServerSessionTraceRecord(UniqueId sessionId, Uri listenAddress)
: base("SecuritySession")
{
this.sessionId = sessionId;
this.listenAddress = listenAddress;
}
internal override void WriteTo(System.Xml.XmlWriter xml)
{
if (xml == null)
return;
if (this.currentSessionToken != null)
{
xml.WriteStartElement("CurrentSessionToken");
WriteSecurityContextToken(xml, this.currentSessionToken);
xml.WriteEndElement();
}
if (this.newSessionToken != null)
{
xml.WriteStartElement("NewSessionToken");
WriteSecurityContextToken(xml, this.newSessionToken);
xml.WriteEndElement();
}
if (this.sessionId != null)
{
XmlHelper.WriteElementStringAsUniqueId(xml, "SessionId", this.sessionId);
}
if (this.message != null)
{
xml.WriteElementString("MessageAction", message.Headers.Action);
}
if (this.listenAddress != null)
{
xml.WriteElementString("ListenAddress", this.listenAddress.ToString());
}
}
}
class ClientSessionTraceRecord : SecurityTraceRecord
{
SecurityToken currentSessionToken;
SecurityToken previousSessionToken;
EndpointAddress remoteAddress;
public ClientSessionTraceRecord(SecurityToken currentSessionToken, SecurityToken previousSessionToken, EndpointAddress remoteAddress)
: base("SecuritySession")
{
this.currentSessionToken = currentSessionToken;
this.previousSessionToken = previousSessionToken;
this.remoteAddress = remoteAddress;
}
internal override void WriteTo(System.Xml.XmlWriter xml)
{
if (xml == null)
return;
if (this.remoteAddress != null)
xml.WriteElementString("RemoteAddress", remoteAddress.ToString());
if (this.currentSessionToken != null)
{
xml.WriteStartElement("CurrentSessionToken");
WriteGenericXmlToken(xml, this.currentSessionToken);
xml.WriteEndElement();
}
if (this.previousSessionToken != null)
{
xml.WriteStartElement("PreviousSessionToken");
WriteGenericXmlToken(xml, this.previousSessionToken);
xml.WriteEndElement();
}
}
}
class SessionRedirectAppliedTraceRecord : SecurityTraceRecord
{
EndpointAddress previousTarget;
EndpointAddress newTarget;
GenericXmlSecurityToken sessionToken;
public SessionRedirectAppliedTraceRecord(EndpointAddress previousTarget, EndpointAddress newTarget, GenericXmlSecurityToken sessionToken)
: base("SecuritySession")
{
this.previousTarget = previousTarget;
this.newTarget = newTarget;
this.sessionToken = sessionToken;
}
internal override void WriteTo(System.Xml.XmlWriter xml)
{
if (xml == null)
return;
if (this.previousTarget != null)
xml.WriteElementString("OriginalRemoteAddress", this.previousTarget.ToString());
if (this.newTarget != null)
xml.WriteElementString("NewRemoteAddress", this.newTarget.ToString());
if (this.sessionToken != null)
{
xml.WriteStartElement("SessionToken");
WriteGenericXmlToken(xml, this.sessionToken);
xml.WriteEndElement();
}
}
}
class SpnToSidMappingTraceRecord : SecurityTraceRecord
{
string spn;
Exception e;
public SpnToSidMappingTraceRecord(string spn, Exception e)
: base("SecurityIdentity")
{
this.spn = spn;
this.e = e;
}
internal override void WriteTo(System.Xml.XmlWriter xml)
{
if (xml == null)
return;
if (this.spn != null)
xml.WriteElementString("ServicePrincipalName", this.spn);
if (this.e != null)
xml.WriteElementString("Exception", this.e.ToString());
}
}
class MessageSecurityTraceRecord : SecurityTraceRecord
{
SecurityProtocol binding;
Message message;
public MessageSecurityTraceRecord(SecurityProtocol binding, Message message)
: base("SecurityProtocol")
{
this.binding = binding;
this.message = message;
}
internal override void WriteTo(System.Xml.XmlWriter xml)
{
if (xml == null)
return;
if (this.binding != null)
xml.WriteElementString("SecurityProtocol", this.binding.ToString());
if (this.message != null)
{
string action = this.message.Headers.Action;
Uri to = this.message.Headers.To;
EndpointAddress replyTo = this.message.Headers.ReplyTo;
UniqueId id = this.message.Headers.MessageId;
if (!String.IsNullOrEmpty(action))
{
xml.WriteElementString("Action", action);
}
if (to != null)
{
xml.WriteElementString("To", to.AbsoluteUri);
}
if (replyTo != null)
{
replyTo.WriteTo(this.message.Version.Addressing, xml);
}
if (id != null)
{
xml.WriteElementString("MessageId", id.ToString());
}
}
else
{
xml.WriteElementString("Message", "null");
}
}
}
class TokenProviderTraceRecord : SecurityTraceRecord
{
SecurityTokenProvider provider;
public TokenProviderTraceRecord(SecurityTokenProvider provider)
: base("SecurityTokenProvider")
{
this.provider = provider;
}
internal override void WriteTo(System.Xml.XmlWriter xml)
{
if (xml == null)
return;
if (this.provider != null)
xml.WriteElementString("SecurityTokenProvider", this.provider.ToString());
}
}
class TokenAuthenticatorTraceRecord : SecurityTraceRecord
{
SecurityTokenAuthenticator authenticator;
public TokenAuthenticatorTraceRecord(SecurityTokenAuthenticator authenticator)
: base("SecurityTokenAuthenticator")
{
this.authenticator = authenticator;
}
internal override void WriteTo(System.Xml.XmlWriter xml)
{
if (xml == null)
return;
if (this.authenticator != null)
xml.WriteElementString("SecurityTokenAuthenticator", this.authenticator.ToString());
}
}
class SecurityContextTokenCacheTraceRecord : SecurityTraceRecord
{
int capacity;
int pruningAmount;
public SecurityContextTokenCacheTraceRecord(int capacity, int pruningAmount)
: base("ServiceSecurityNegotiation")
{
this.capacity = capacity;
this.pruningAmount = pruningAmount;
}
internal override void WriteTo(System.Xml.XmlWriter xml)
{
if (xml == null)
return;
xml.WriteElementString("Capacity", this.capacity.ToString(NumberFormatInfo.InvariantInfo));
xml.WriteElementString("PruningAmount", this.pruningAmount.ToString(NumberFormatInfo.InvariantInfo));
}
}
class NegotiationAuthenticatorTraceRecord : SecurityTraceRecord
where T : NegotiationTokenAuthenticatorState
{
NegotiationTokenAuthenticator authenticator;
IChannelListener transportChannelListener;
SecurityContextSecurityToken serviceToken;
Exception e;
public NegotiationAuthenticatorTraceRecord(NegotiationTokenAuthenticator authenticator, IChannelListener transportChannelListener)
: base("NegotiationTokenAuthenticator")
{
this.authenticator = authenticator;
this.transportChannelListener = transportChannelListener;
}
public NegotiationAuthenticatorTraceRecord(NegotiationTokenAuthenticator authenticator, Exception e)
: base("NegotiationTokenAuthenticator")
{
this.authenticator = authenticator;
this.e = e;
}
public NegotiationAuthenticatorTraceRecord(NegotiationTokenAuthenticator authenticator, SecurityContextSecurityToken serviceToken)
: base("NegotiationTokenAuthenticator")
{
this.authenticator = authenticator;
this.serviceToken = serviceToken;
}
internal override void WriteTo(System.Xml.XmlWriter xml)
{
if (xml == null)
return;
if (this.authenticator != null)
xml.WriteElementString("NegotiationTokenAuthenticator", DiagnosticTrace.XmlEncode(this.authenticator.ToString()));
if (this.authenticator != null && this.authenticator.ListenUri != null)
xml.WriteElementString("AuthenticatorListenUri", this.authenticator.ListenUri.AbsoluteUri);
if (this.serviceToken != null)
{
xml.WriteStartElement("SecurityContextSecurityToken");
WriteSecurityContextToken(xml, this.serviceToken);
xml.WriteEndElement();
}
if (this.transportChannelListener != null)
{
xml.WriteElementString("TransportChannelListener", DiagnosticTrace.XmlEncode(this.transportChannelListener.ToString()));
if (this.transportChannelListener.Uri != null)
xml.WriteElementString("ListenUri", this.transportChannelListener.Uri.AbsoluteUri);
}
if (this.e != null)
{
xml.WriteElementString("Exception", DiagnosticTrace.XmlEncode(e.ToString()));
}
}
}
class IdentityVerificationSuccessTraceRecord : SecurityTraceRecord
{
EndpointIdentity identity;
Claim claim;
Type identityVerifier;
public IdentityVerificationSuccessTraceRecord(EndpointIdentity identity, Claim claim, Type identityVerifier)
: base("ServiceIdentityVerification")
{
this.identity = identity;
this.claim = claim;
this.identityVerifier = identityVerifier;
}
internal override void WriteTo(System.Xml.XmlWriter xml)
{
if (xml == null)
return;
XmlDictionaryWriter xmlWriter = XmlDictionaryWriter.CreateDictionaryWriter(xml);
if (this.identityVerifier != null)
xml.WriteElementString("IdentityVerifierType", this.identityVerifier.ToString());
if (this.identity != null)
this.identity.WriteTo(xmlWriter);
if (this.claim != null)
SecurityTraceRecordHelper.WriteClaim(xmlWriter, this.claim);
}
}
class IdentityVerificationFailureTraceRecord : SecurityTraceRecord
{
EndpointIdentity identity;
AuthorizationContext authContext;
Type identityVerifier;
public IdentityVerificationFailureTraceRecord(EndpointIdentity identity, AuthorizationContext authContext, Type identityVerifier)
: base("ServiceIdentityVerification")
{
this.identity = identity;
this.authContext = authContext;
this.identityVerifier = identityVerifier;
}
internal override void WriteTo(System.Xml.XmlWriter xml)
{
if (xml == null)
return;
XmlDictionaryWriter xmlWriter = XmlDictionaryWriter.CreateDictionaryWriter(xml);
if (this.identityVerifier != null)
xml.WriteElementString("IdentityVerifierType", this.identityVerifier.ToString());
if (this.identity != null)
this.identity.WriteTo(xmlWriter);
if (this.authContext != null)
{
for (int i = 0; i < this.authContext.ClaimSets.Count; ++i)
{
ClaimSet claimSet = this.authContext.ClaimSets[i];
if (this.authContext.ClaimSets[i] == null)
continue;
for (int j = 0; j < claimSet.Count; ++j)
{
Claim claim = claimSet[j];
if (claimSet[j] == null)
continue;
xml.WriteStartElement("Claim");
// currently ClaimType and Right cannot be null. Just being defensive
if (claim.ClaimType != null)
xml.WriteElementString("ClaimType", claim.ClaimType);
else
xml.WriteElementString("ClaimType","null");
if (claim.Right != null)
xml.WriteElementString("Right", claim.Right);
else
xml.WriteElementString("Right", "null");
if (claim.Resource != null)
xml.WriteElementString("ResourceType", claim.Resource.GetType().ToString());
else
xml.WriteElementString("Resource", "null");
xml.WriteEndElement();
}
}
}
}
}
class IdentityDeterminationSuccessTraceRecord : SecurityTraceRecord
{
EndpointIdentity identity;
EndpointAddress epr;
Type identityVerifier;
public IdentityDeterminationSuccessTraceRecord(EndpointAddress epr, EndpointIdentity identity, Type identityVerifier)
: base("ServiceIdentityDetermination")
{
this.identity = identity;
this.epr = epr;
this.identityVerifier = identityVerifier;
}
internal override void WriteTo(System.Xml.XmlWriter xml)
{
if (xml == null)
return;
if (this.identityVerifier != null)
xml.WriteElementString("IdentityVerifierType", this.identityVerifier.ToString());
if (this.identity != null)
this.identity.WriteTo(XmlDictionaryWriter.CreateDictionaryWriter(xml));
if (this.epr != null)
this.epr.WriteTo(AddressingVersion.WSAddressing10, xml);
}
}
class IdentityDeterminationFailureTraceRecord : SecurityTraceRecord
{
Type identityVerifier;
EndpointAddress epr;
public IdentityDeterminationFailureTraceRecord(EndpointAddress epr, Type identityVerifier)
: base("ServiceIdentityDetermination")
{
this.epr = epr;
this.identityVerifier = identityVerifier;
}
internal override void WriteTo(System.Xml.XmlWriter xml)
{
if (xml == null)
return;
if (this.identityVerifier != null)
xml.WriteElementString("IdentityVerifierType", this.identityVerifier.ToString());
if (this.epr != null)
this.epr.WriteTo(AddressingVersion.WSAddressing10, xml);
}
}
class IdentityHostNameNormalizationFailureTraceRecord : SecurityTraceRecord
{
Type identityVerifier;
Exception e;
EndpointAddress epr;
public IdentityHostNameNormalizationFailureTraceRecord(EndpointAddress epr, Type identityVerifier, Exception e)
: base("ServiceIdentityDetermination")
{
this.epr = epr;
this.identityVerifier = identityVerifier;
this.e = e;
}
internal override void WriteTo(System.Xml.XmlWriter xml)
{
if (xml == null)
return;
if (this.identityVerifier != null)
xml.WriteElementString("IdentityVerifierType", this.identityVerifier.ToString());
if (this.epr != null)
this.epr.WriteTo(AddressingVersion.WSAddressing10, xml);
if (e != null)
xml.WriteElementString("Exception", e.ToString());
}
}
class IssuanceProviderTraceRecord : SecurityTraceRecord
where T : IssuanceTokenProviderState
{
IssuanceTokenProviderBase provider;
EndpointAddress target;
EndpointAddress newTarget;
SecurityToken serviceToken;
int cacheSize;
public IssuanceProviderTraceRecord(IssuanceTokenProviderBase provider, SecurityToken serviceToken)
: this(provider, serviceToken, null)
{ }
public IssuanceProviderTraceRecord(IssuanceTokenProviderBase provider, EndpointAddress target)
: this(provider, (SecurityToken) null, target)
{ }
public IssuanceProviderTraceRecord(IssuanceTokenProviderBase provider, SecurityToken serviceToken, EndpointAddress target)
: base("ClientSecurityNegotiation")
{
this.provider = provider;
this.serviceToken = serviceToken;
this.target = target;
}
public IssuanceProviderTraceRecord(IssuanceTokenProviderBase provider, EndpointAddress newTarget, EndpointAddress oldTarget)
: base("ClientSecurityNegotiation")
{
this.provider = provider;
this.newTarget = newTarget;
this.target = oldTarget;
}
public IssuanceProviderTraceRecord(IssuanceTokenProviderBase provider, int cacheSize)
: base("ClientSecurityNegotiation")
{
this.provider = provider;
this.cacheSize = cacheSize;
}
internal override void WriteTo(System.Xml.XmlWriter xml)
{
if (xml == null)
return;
if (this.provider != null)
xml.WriteElementString("IssuanceTokenProvider", this.provider.ToString());
if (this.serviceToken != null)
WritePossibleGenericXmlToken(xml, "ServiceToken", this.serviceToken);
if (this.target != null)
{
xml.WriteStartElement("Target");
this.target.WriteTo(AddressingVersion.WSAddressing10, xml);
xml.WriteEndElement();
}
if (this.newTarget != null)
{
xml.WriteStartElement("PinnedTarget");
this.newTarget.WriteTo(AddressingVersion.WSAddressing10, xml);
xml.WriteEndElement();
}
if (this.cacheSize != 0)
{
xml.WriteElementString("CacheSize", this.cacheSize.ToString(NumberFormatInfo.InvariantInfo));
}
}
}
class WindowsSspiNegotiationTraceRecord : SecurityTraceRecord
{
WindowsSspiNegotiation windowsNegotiation;
bool isClient;
public WindowsSspiNegotiationTraceRecord(WindowsSspiNegotiation windowsNegotiation, bool isClient)
: base("SpnegoSecurityNegotiation")
{
this.windowsNegotiation = windowsNegotiation;
this.isClient = isClient;
}
internal override void WriteTo(System.Xml.XmlWriter xml)
{
if (xml == null)
return;
if (this.windowsNegotiation != null)
{
xml.WriteElementString("Protocol", this.windowsNegotiation.ProtocolName);
if (isClient)
{
xml.WriteElementString("ServicePrincipalName", this.windowsNegotiation.ServicePrincipalName);
xml.WriteElementString("MutualAuthentication", this.windowsNegotiation.IsMutualAuthFlag.ToString());
}
else
{
if (this.windowsNegotiation.IsIdentifyFlag)
{
xml.WriteElementString("ImpersonationLevel", "Identify");
}
else if (this.windowsNegotiation.IsDelegationFlag)
{
xml.WriteElementString("ImpersonationLevel", "Delegate");
}
else
{
xml.WriteElementString("ImpersonationLevel", "Impersonate");
}
}
}
}
}
class ImpersonationTraceRecord : SecurityTraceRecord
{
private DispatchOperationRuntime operation;
internal ImpersonationTraceRecord(DispatchOperationRuntime operation)
: base ("SecurityImpersonation")
{
this.operation = operation;
}
internal override void WriteTo(System.Xml.XmlWriter xml)
{
if (xml == null)
{
// We are inside tracing. Don't throw an exception here just
// return.
return;
}
if (this.operation != null)
{
xml.WriteElementString("OperationAction", this.operation.Action);
xml.WriteElementString("OperationName", this.operation.Name);
}
}
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- ValueQuery.cs
- FontCacheUtil.cs
- HttpRuntime.cs
- LogFlushAsyncResult.cs
- MemberExpressionHelper.cs
- ProvidersHelper.cs
- versioninfo.cs
- SaveLedgerEntryRequest.cs
- sqlser.cs
- TextBoxAutomationPeer.cs
- ObjectSelectorEditor.cs
- DocumentXmlWriter.cs
- ReflectPropertyDescriptor.cs
- UpdatePanelTriggerCollection.cs
- ComplexPropertyEntry.cs
- HtmlToClrEventProxy.cs
- XPathScanner.cs
- TableCellCollection.cs
- TemplateInstanceAttribute.cs
- NotSupportedException.cs
- AssemblyAttributesGoHere.cs
- DataControlCommands.cs
- SqlDataSourceConfigureSortForm.cs
- ShapingWorkspace.cs
- FileNotFoundException.cs
- OracleTimeSpan.cs
- SelectionList.cs
- BindingManagerDataErrorEventArgs.cs
- MSG.cs
- EntityDataSourceViewSchema.cs
- DataFormats.cs
- ToolStripContentPanelDesigner.cs
- DataGridHeaderBorder.cs
- ContainerAction.cs
- CustomErrorsSection.cs
- DynamicActivityTypeDescriptor.cs
- TypeReference.cs
- SqlConnectionHelper.cs
- Translator.cs
- SqlClientPermission.cs
- GeneratedContractType.cs
- DateTimeUtil.cs
- KeyEventArgs.cs
- IdlingCommunicationPool.cs
- RoleManagerSection.cs
- DesignerDataSchemaClass.cs
- DmlSqlGenerator.cs
- WebZone.cs
- CodeMemberProperty.cs
- TimelineGroup.cs
- ScrollEvent.cs
- EmissiveMaterial.cs
- LedgerEntry.cs
- DispatcherTimer.cs
- SolidColorBrush.cs
- ChtmlTextWriter.cs
- RemoteWebConfigurationHostStream.cs
- XmlReflectionMember.cs
- ThousandthOfEmRealPoints.cs
- ElementMarkupObject.cs
- MethodExpr.cs
- NativeMethods.cs
- PathFigureCollection.cs
- EarlyBoundInfo.cs
- SQLCharsStorage.cs
- MatrixTransform.cs
- PenContext.cs
- TableChangeProcessor.cs
- safesecurityhelperavalon.cs
- ValueTypeFixupInfo.cs
- MemoryStream.cs
- RightsManagementInformation.cs
- GlyphInfoList.cs
- TypeUnloadedException.cs
- WsatConfiguration.cs
- HttpModuleAction.cs
- SizeF.cs
- TypeConverterAttribute.cs
- StrokeCollection2.cs
- XmlSchemaObject.cs
- HttpStreamXmlDictionaryWriter.cs
- PtsContext.cs
- SmiGettersStream.cs
- IISMapPath.cs
- CookielessHelper.cs
- ServiceNameElement.cs
- TextDataBindingHandler.cs
- ModelChangedEventArgsImpl.cs
- SqlDependency.cs
- Utils.cs
- CharacterShapingProperties.cs
- CompressionTracing.cs
- _ConnectionGroup.cs
- XmlChildNodes.cs
- OleDbCommand.cs
- NativeMethods.cs
- DbProviderServices.cs
- HtmlInputButton.cs
- GridViewEditEventArgs.cs
- unitconverter.cs