Code:
/ WCF / WCF / 3.5.30729.1 / untmp / Orcas / SP / ndp / cdf / src / WCF / infocard / Service / managed / Microsoft / InfoCards / RequestSecurityToken.cs / 2 / RequestSecurityToken.cs
namespace Microsoft.InfoCards { using System; using System.Collections; using System.Collections.Generic; using System.Collections.ObjectModel; using System.Diagnostics; using System.IO; using System.ServiceModel.Security; using System.ServiceModel; using System.ServiceModel.Channels; using System.Security.Cryptography; using System.Security.Cryptography.Xml; using System.Runtime.Serialization; using System.Globalization; using System.Xml; using System.IdentityModel.Tokens; using System.ServiceModel.Security.Tokens; using System.IdentityModel.Policy; using System.IdentityModel.Selectors; using IDT = Microsoft.InfoCards.Diagnostics.InfoCardTrace; using System.Text; internal class RequestSecurityTokenParameters { private AddressingVersion m_addressingVersion = null; private GetBrowserTokenParameters m_browserTokenParams = null; private InfoCardPolicy m_policy = null; private InfoCard m_card = null; private bool m_discloseOptionalClaims; private RSAKeyValue m_rsaKeyValue = null; private byte[] m_clientEntropyForSymmetric = null; private CultureInfo m_cultureInfo = null; private string m_context = null; private Dictionarym_disclosedClaims; private ProtocolProfile m_profile = null; public AddressingVersion Version { get { return m_addressingVersion; } } public GetBrowserTokenParameters BrowserTokenParams { get { return m_browserTokenParams; } } public InfoCardPolicy Policy { get { return m_policy; } } public InfoCard Card { get { return m_card; } } public bool DiscloseOptionalClaims { get { return m_discloseOptionalClaims; } } public RSAKeyValue RSAKey { get { return m_rsaKeyValue; } } public byte[] ClientEntropyForSymmetric { get { return m_clientEntropyForSymmetric; } } public CultureInfo Culture { get { return m_cultureInfo; } } public string Context { get { return m_context; } } public Dictionary DisclosedClaims { get { return m_disclosedClaims; } } public ProtocolProfile Profile { get { return m_profile; } } public RequestSecurityTokenParameters( AddressingVersion version, InfoCard card, InfoCardPolicy policy, bool discloseOptionalClaims, RSAKeyValue rsaKeyValue, Dictionary disclosedClaims, string context, byte[] clientEntropyForSymmetric, CultureInfo displayCulture ) { m_card = card; m_policy = policy; m_discloseOptionalClaims = discloseOptionalClaims; m_rsaKeyValue = rsaKeyValue; m_clientEntropyForSymmetric = clientEntropyForSymmetric; m_profile = policy.ProtocolVersionProfile; IDT.Assert( ( ( null == m_rsaKeyValue && null != m_clientEntropyForSymmetric ) || // symmetric ( null == m_rsaKeyValue && null == m_clientEntropyForSymmetric ) || // no proof key ( null != m_rsaKeyValue && null == m_clientEntropyForSymmetric ) ), // asymmetric "The three allowed cases are symmetric, noProofKey, asymmetric" ); m_disclosedClaims = disclosedClaims; m_addressingVersion = version; m_context = context; m_cultureInfo = displayCulture; } public RequestSecurityTokenParameters( AddressingVersion addressing, GetBrowserTokenParameters parameters, ProtocolProfile profile, InfoCardPolicy policy, bool discloseOptionalClaims ) { m_browserTokenParams = parameters; m_addressingVersion = addressing; m_policy = policy; m_discloseOptionalClaims = discloseOptionalClaims; m_context = Guid.NewGuid().ToString(); m_profile = profile; } } internal abstract class RequestSecurityToken : BodyWriter { protected RequestSecurityTokenParameters m_rstParams; protected RequestSecurityTokenSerializer m_serializer; protected XmlDictionaryWriter m_xmlWriter; // // Retrieves the protocol versions to use when serializing // protected ProtocolProfile ProtocolVersionProfile { get { return m_rstParams.Profile; } } protected InfoCardPolicy Policy { get { return m_rstParams.Policy; } } protected RequestSecurityTokenSerializer Serializer { get { return m_serializer; } set { m_serializer = value; } } protected XmlDictionaryWriter Writer { get { return m_xmlWriter; } set { m_xmlWriter = value; } } protected string WstPrefix { get { return ProtocolVersionProfile.WSTrust.DefaultPrefix; } } public RequestSecurityToken( RequestSecurityTokenParameters rstParams ) : base( false ) { m_rstParams = rstParams; } protected virtual void WriteRSTOpeningElement() { Writer.WriteStartElement( WstPrefix, ProtocolVersionProfile.WSTrust.RequestSecurityToken, ProtocolVersionProfile.WSTrust.Namespace ); Writer.WriteAttributeString( ProtocolVersionProfile.WSTrust.Context, null, m_rstParams.Context ); } protected virtual void WriteInfoCardReferenceElement() { if( m_rstParams.Card != null ) { Serializer.WriteInfoCardReferenceElement( m_rstParams.Card ); } } protected virtual void WriteKeyTypeElement() { IDT.TraceDebug( "IPSTSCLIENT: Writing key type {0} to RST", Policy.GetKeyTypeString() ); Serializer.WriteKeyTypeElement( Policy.GetKeyTypeString() ); } protected virtual void WriteKeySupportingElements() { // // write the (KeySize, Entropy) or (KeySize, UseKey) or nothing // in symmetric, asymmetric, and no proof key cases respectively. // if( SecurityKeyTypeInternal.SymmetricKey == Policy.KeyType ) { // // write the keySize - default is 256 (currently) if not specified // IDT.TraceDebug( "IPSTSCLIENT: Writing key size {0} to RST", Policy.GetIntelligentKeySize( false ) ); Serializer.WriteKeySizeElement( Policy.GetIntelligentKeySize( false ).ToString( CultureInfo.InvariantCulture ) ); IDT.Assert( null != m_rstParams.ClientEntropyForSymmetric, "Should not be null" ); // // Send entropy to IP/STS // BinarySecretSecurityToken bst = new BinarySecretSecurityToken( m_rstParams.ClientEntropyForSymmetric ); Serializer.WriteBinarySecretElement( bst ); // // Write encryptWith // if( !String.IsNullOrEmpty( Policy.OptionalRstParams.EncryptWith ) ) { Serializer.WriteEncryptWithElement( Policy.OptionalRstParams.EncryptWith ); } // // Write signWith // if( !String.IsNullOrEmpty( Policy.OptionalRstParams.SignWith ) ) { Serializer.WriteSignWithElement( Policy.OptionalRstParams.SignWith ); } } else if( SecurityKeyTypeInternal.AsymmetricKey == Policy.KeyType ) { // // The KeyWrapAlgorithm element is specific to WSTrust Oasis 2007 (1.3). It allows the RP to specify (to the STS) // the asymmetric algorithm to use for protecting the key that was used to encrypt the token. // if( XmlNames.WSSpecificationVersion.WSTrustOasis2007 == ProtocolVersionProfile.WSTrust.Version ) { // // Write KeyWrapAlgorithm // if( !String.IsNullOrEmpty( Policy.OptionalRstParams.KeyWrapAlgorithm ) ) { Serializer.WriteKeyWrapAlgorithmElement( Policy.OptionalRstParams.KeyWrapAlgorithm ); } } // // write the keySize - this should be 2048 // IDT.TraceDebug( "IPSTSCLIENT: Writing key size {0} to RST", Policy.GetIntelligentKeySize( false ) ); Serializer.WriteKeySizeElement( Policy.GetIntelligentKeySize( false ).ToString( CultureInfo.InvariantCulture ) ); // // write the UseKey element if Asymmetric keys are to be used // IDT.Assert( null != m_rstParams.RSAKey, "Should have been populated in asymmetric case" ); IDT.TraceDebug( "IPSTSCLIENT: Writing use key {0} to RST", m_rstParams.RSAKey.GetXml().InnerXml ); Serializer.WriteUseKeyElement( m_rstParams.RSAKey.GetXml() ); // // Write the encryptWith // if( !String.IsNullOrEmpty( Policy.OptionalRstParams.EncryptWith ) ) { Serializer.WriteEncryptWithElement( Policy.OptionalRstParams.EncryptWith ); } // // Write signWith // if( !String.IsNullOrEmpty( Policy.OptionalRstParams.SignWith ) ) { Serializer.WriteSignWithElement( Policy.OptionalRstParams.SignWith ); } } else { IDT.Assert( SecurityKeyTypeInternal.NoKey == Policy.KeyType, "Should be no proof key" ); } } protected virtual void WriteRequestTypeElement() { // // Write RequestType element. If none found in policy write the WSTrust version specific Issue action uri. // For browser case, we only support the Issue action. // if( !String.IsNullOrEmpty( Policy.RequestType ) ) { IDT.TraceDebug( "IPSTSCLIENT: Writing RequestType {0} to RST", Policy.RequestType ); Serializer.WriteRequestTypeElement( Policy.RequestType ); } else { IDT.TraceDebug( "IPSTSCLIENT: Writing RequestType {0} to RST", ProtocolVersionProfile.WSTrust.IssueRequestType ); Serializer.WriteRequestTypeElement( ProtocolVersionProfile.WSTrust.IssueRequestType ); } } protected virtual void WritePPIDElement() { // // Write the /ClientPseudonym/PPID element if PPID claim is present in card // PPID = base64 string version of hash( card key, recipient org id, card salt ) // if( ( null != m_rstParams.Card ) && ( m_rstParams.Card.GetClaims().ContainsKey( InfoCardConstants.PPIDClaimsUri ) ) ) { byte[] ppid = Utility.CreateHash( m_rstParams.Card.Key, Convert.FromBase64String( Policy.ImmediateTokenRecipient.GetOrganizationPPIDIdentifier() ), m_rstParams.Card.HashSalt ); Serializer.WritePPIDElement( ppid ); } } protected virtual void WriteEncryptionAlgorithmElement() { // // Write the EncryptionAlgorithm element // if( !string.IsNullOrEmpty( Policy.OptionalRstParams.EncryptionAlgorithm ) ) { IDT.TraceDebug( "IPSTSCLIENT: Writing encrypting algorithm {0} to RST", Policy.OptionalRstParams.EncryptionAlgorithm ); Serializer.WriteEncryptionAlgorithmElement( Policy.OptionalRstParams.EncryptionAlgorithm ); } } protected virtual void WriteClaimsElement() { Serializer.WriteClaimsElement( m_rstParams.DisclosedClaims, Policy.RequiredClaims, Policy.OptionalClaims ); } protected virtual void WriteDisplayTokenElement() { IDT.TraceDebug( "IPSTSCLIENT: Writing display token elemnet to RST" ); if( null != m_rstParams.Culture ) { Serializer.WriteDisplayTokenElement( m_rstParams.Culture ); } } protected virtual void WriteTokenTypeElement() { if( !String.IsNullOrEmpty( Policy.OptionalRstParams.TokenType ) ) { Serializer.WriteTokenTypeElement( Policy.OptionalRstParams.TokenType ); } } protected virtual void WritePassOnElements() { // // Write the pass on parameters from Recipient policy's RequestSecurityTokenTemplate. // Optional RST Parameters include: // // wst:TokenType // wst:SignatureAlgorithm // wst:EncryptionAlgorithm // wst:CanonicalizationAlgorithm // wst:SignWith // wst:EncryptWith // wst:KeyWrapAlgorithm // Policy.OptionalRstParams.WritePassOnElements( Writer, ProtocolVersionProfile ); } protected virtual void WriteUnprocessedPolicyElements() { // // Write all the other policy elements // if( ( null != Policy.UnprocessedPolicyElements ) && ( Policy.UnprocessedPolicyElements.Length > 0 ) ) { Serializer.WriteUnprocessedPolicyElements( Policy.UnprocessedPolicyElements ); } } protected abstract void WriteSecondaryParametersElement(); protected virtual void WriteEndElement() { // // Write closing element // Writer.WriteEndElement(); } protected abstract void WriteAppliesToElement(); protected virtual void InitializeWriters( XmlDictionaryWriter writer ) { Writer = writer; // // Initialize the serializer does the actual work of writing the RST elements. // This property will be used by all the write functions called below. // Serializer = new RequestSecurityTokenSerializer( writer, ProtocolVersionProfile ); } // // We are called back here when the rst is being serialized into the message body, and write the custom // element in as an rst customToken tag. // protected override void OnWriteBodyContents( XmlDictionaryWriter writer ) { // // Call the pure virtual version of the function so we can ensure the method has been implemented // by any derived instances. // CustomWriteBodyContents( writer ); } protected abstract void CustomWriteBodyContents( XmlDictionaryWriter writer ); } } // 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
- XmlDownloadManager.cs
- InstanceKeyView.cs
- CompModSwitches.cs
- ParseHttpDate.cs
- TimeStampChecker.cs
- DnsPermission.cs
- Utils.cs
- PartitionResolver.cs
- Point3DAnimationUsingKeyFrames.cs
- DataKey.cs
- TabRenderer.cs
- MatcherBuilder.cs
- UpdateCompiler.cs
- LayoutEngine.cs
- TextSegment.cs
- DynamicRenderer.cs
- DataGridViewRowCollection.cs
- ApplicationInfo.cs
- Package.cs
- StrokeNode.cs
- TreeNodeEventArgs.cs
- FixedTextBuilder.cs
- NumberEdit.cs
- StrokeCollectionConverter.cs
- Run.cs
- ValidatingCollection.cs
- InkCollectionBehavior.cs
- TextUtf8RawTextWriter.cs
- String.cs
- SqlClientWrapperSmiStreamChars.cs
- ColorAnimationUsingKeyFrames.cs
- PerfCounters.cs
- SHA512.cs
- TableHeaderCell.cs
- ObjectView.cs
- _FtpControlStream.cs
- XmlSchemaObjectTable.cs
- FixedDocumentSequencePaginator.cs
- WmlLabelAdapter.cs
- ItemAutomationPeer.cs
- TypeLoadException.cs
- Size.cs
- SmtpFailedRecipientsException.cs
- BindingsCollection.cs
- GrammarBuilder.cs
- VariantWrapper.cs
- EllipseGeometry.cs
- ImageCollectionEditor.cs
- Comparer.cs
- SystemDropShadowChrome.cs
- FactoryGenerator.cs
- XmlWrappingReader.cs
- XMLSyntaxException.cs
- PrinterResolution.cs
- UpWmlPageAdapter.cs
- SecurityElement.cs
- ConnectionPoint.cs
- NamespaceInfo.cs
- SocketElement.cs
- ContractNamespaceAttribute.cs
- ClassDataContract.cs
- IndicCharClassifier.cs
- ProfileService.cs
- RoleManagerModule.cs
- BamlTreeNode.cs
- XPathExpr.cs
- Speller.cs
- IsolatedStorageFile.cs
- FlowDocumentReader.cs
- HandlerBase.cs
- XmlSchemaDocumentation.cs
- Opcode.cs
- FileLogRecordHeader.cs
- DbProviderConfigurationHandler.cs
- KeyConverter.cs
- OleDbPermission.cs
- CodeEntryPointMethod.cs
- MimeMapping.cs
- LowerCaseStringConverter.cs
- DebugHandleTracker.cs
- SimpleWorkerRequest.cs
- InitializationEventAttribute.cs
- IPAddressCollection.cs
- FixedSOMPage.cs
- DataListCommandEventArgs.cs
- SamlAttribute.cs
- ScriptIgnoreAttribute.cs
- LoginView.cs
- ActivityCodeDomSerializer.cs
- Rules.cs
- StylusPointProperty.cs
- srgsitem.cs
- DataGridViewEditingControlShowingEventArgs.cs
- CTreeGenerator.cs
- NetworkAddressChange.cs
- TimeoutValidationAttribute.cs
- PropertyCondition.cs
- WebBrowserNavigatedEventHandler.cs
- PtsCache.cs
- DateTimeConverter2.cs