WIF es sencillo, úsalo #3-3

En nuestra anterior entrada vimos como modificar el manejador de tokens de nuestro STS, de forma, que podíamos cambiar el sistema de autenticación de usarios dentro de este. De hecho, modificamos el STS generado por defecto con FedUtil introduciendo un UsernameSecurityTokenHandler personalizado. A lo largo de esta entrada, veremos algunos elementos particulares de nuestra configuración que no han sido tenidos en cuenta pero que también es importante entenderlos.

IssuerNameRegistry

Si leemos la documentación del SDK de WIF podemos ver a esta pieza como la responsable de rechazar los tokens de emisores inválidos, STS en los que no confiamos. Por defecto, las plantillas del asistente establecen un IssuerNameRegistry por defecto conocido como ConfigurationBasedIssuerNameRegistry que hace el mapeo y rechazo de los emisores en función del thumbprint del token ( certificado ) presentado. Como también se comenta en la documentación, este elemento debe de ser reemplazado en producción, creando un IssuerNameRegistry customizado

The <?XML:NAMESPACE PREFIX = [default] http://ddue.schemas.microsoft.com/authoring/2003/5 NS = «http://ddue.schemas.microsoft.com/authoring/2003/5» />IssuerNameRegistry class provides a name service that returns the issuer name of a given token. WIF provides a ConfigurationBasedIssuerNameRegistry to demonstrate an easy way to get started, but it is recommended that developers write a custom implementation that derives from the IssuerNameRegistry class.

Crear un nuevo issuer name registry es “tan sencillo o complicado” como crear una subclase de IssuerNameRegistry y sobreescribir el método GetIssuerName.

    <span class="kwrd">public</span> <span class="kwrd">class</span> CustomIssuerNameRegistry
        :IssuerNameRegistry
    {
        <span class="kwrd">public</span> <span class="kwrd">override</span> <span class="kwrd">string</span> GetIssuerName(System.IdentityModel.Tokens.SecurityToken securityToken)
        {
           
        }
    }

public class CustomIssuerNameRegistry

:IssuerNameRegistry

{

public override string GetIssuerName(System.IdentityModel.Tokens.SecurityToken securityToken)

{

}

Si el valor devuelto por este método es nulo, entonces el sistema interpreta que este issuer no es admitido y por lo tanto no es posible aceptar tokens del mismo. Lógicamente, este trabajo requeriría en la realidad de disponer de un almacen configurable de issuers y propiedades de los mismos que pudiéramos configurar y administrar. Este trabajo, no lo haremos en este post ( igual en futuros …), solamente incluiremos una posible implementación “tonta” que devuelve el nombre del STS utilizado en los ejemplos.

    <span class="kwrd">public</span> <span class="kwrd">class</span> CustomIssuerNameRegistry
        :IssuerNameRegistry
    {
        <span class="kwrd">public</span> <span class="kwrd">override</span> <span class="kwrd">string</span> GetIssuerName(System.IdentityModel.Tokens.SecurityToken securityToken)
        {
            <span class="kwrd">if</span> (securityToken == <span class="kwrd">null</span>)
                <span class="kwrd">throw</span> <span class="kwrd">new</span> ArgumentNullException(<span class="str">"securityToken"</span>);

            X509SecurityToken x509Token = securityToken <span class="kwrd">as</span> X509SecurityToken;
            <span class="kwrd">if</span> (x509Token != <span class="kwrd">null</span>)
            {
                <span class="kwrd">return</span> <span class="str">"http://localhost:2325/CRMService_STS/Service.svc"</span>;
            }
            <span class="kwrd">else</span>
                <span class="kwrd">return</span> <span class="kwrd">null</span>;
        }
    }

public class CustomIssuerNameRegistry

:IssuerNameRegistry

{

public override string GetIssuerName(System.IdentityModel.Tokens.SecurityToken securityToken)

{

if (securityToken == null)

throw new ArgumentNullException("securityToken");

X509SecurityToken x509Token = securityToken as X509SecurityToken;

if (x509Token != null)

{

return "http://localhost:2325/CRMService_STS/Service.svc";

}

else

return null;

}

AudienceUri

Si revisamos la configuración de nuestro RP veremos como la sección microsoft.identitymodel incluye dentro de ella un elemento llamado AudienceUris. Este elemento nos permite establecer una colección de elementos validos a los que se les aplica un toquen. Es decir, cuando un token es emitido este se establece o aplica para alguien, el RP que lo ha solicitado. Este token incluye una propiedad AppliesTo gracias a la cual podremos validar que el mismo se aplica al RP que tenemos. Por ello esta colección por defecto ya contiene la dirección del RP con el que estemos. Lógicamente, si esta información no es igual que la que trae el token se nos producirá una excepción de seguridad.

&lt;microsoft.identityModel&gt;
    &lt;service name=<span class="str">"CRMService.CRMManager"</span>  &gt;
      &lt;audienceUris&gt;
        &lt;add <span class="kwrd">value</span>=<span class="str">"http://localhost/CRMService"</span> /&gt;
      &lt;/audienceUris&gt;

<microsoft.identityModel>

</audienceUris>

Federation Metadata

Otro de los elementos importantes cuando estamos trabajando con nuestros RP y STS es la información de metadata. Si recuerda de las primeras entradas, el asistente de WIF, FedUtil nos genera un nuevo STS y crea en el proyecto de este un archivo llamado FederationMetadata.xml. Este archivo, firmado por defecto con el asistente utilizando un certificado llamado STSCert nos permite exponer toda la información del STS, incluyendo en esta por ejemplo la información de los claims que este conoce y que puede enviar en los tokens de autenticación. Se podría decir que estos documentos son a la seguridad como el WSDL a los servicios. Como se imaginará, mantener estos documentos actualizados es una tarea vital, sobre todo si estos son nuestro contrato de relación con los RP. Por defecto, este trabajo no lo tenemos disponible de una forma sencilla, es decir, cuando creamos un STS el asistente nos genera el archivo de metadata y las entradas necesarios en el web.config para dejarlo accesible, sin embargo, si añadimos nuevas claims a nuestros tokens o bien cambiamos alguna configuración este archivo no se actualiza y por lo tanto podría darnos problemas. Lógicamente, como está firmado, trabajar a mano con este documento no es posible como se imaginará.

Para nuestra tarera de automatizar la generación dinámica de este archivo de metadata tenemos varias opciones, opciones que puede ver en este post. En realidad, cualquiera de las dos opciones es buena, la primera, la habitual de Vittorio Bertocci es la de disponer de un servicio WCF REST que genere esta metadata al vuelo, algo parecido al código siguiente. Tenga en cuenta que este código es “codigo demo” y por lo tanto no valdría directamente para producción ya que fija direcciones del STS, del login pasivo, del certificado a usar y hasta de las claims a emitir, no obstante, es una buena base para empezar a adaptar en caso de querer disponer de este sistema.

    <span class="kwrd">public</span> <span class="kwrd">class</span> FederationMetadata : IFederationMetadata
    {

        System.Xml.Linq.XElement IFederationMetadata.FederationMetadata()
        {
            <span class="rem">// hostname </span>
            <span class="kwrd">string</span> host = WebOperationContext.Current.IncomingRequest.Headers[<span class="str">"Host"</span>];
            EndpointAddress realm = <span class="kwrd">new</span> EndpointAddress(String.Format(<span class="str">"https://{0}"</span>, host));
            EndpointAddress passiveEndpoint = <span class="kwrd">new</span> EndpointAddress(String.Format(<span class="str">"https://{0}/Sts.aspx"</span>, host));
            <span class="rem">// metadata document</span>
            EntityDescriptor entity = <span class="kwrd">new</span> EntityDescriptor(<span class="kwrd">new</span> EntityId(realm.Uri.AbsoluteUri));
            SecurityTokenServiceDescriptor sts = <span class="kwrd">new</span> SecurityTokenServiceDescriptor();
            entity.RoleDescriptors.Add(sts);
            <span class="rem">// signing key </span>
            var signingCredentials = <span class="kwrd">new</span> X509SigningCredentials(CertificateUtil.GetCertificate(
                                                                StoreName.My, StoreLocation.LocalMachine,
                                                               <span class="str">"CN=STSTestCert"</span>));

            KeyDescriptor signingKey = <span class="kwrd">new</span> KeyDescriptor(signingCredentials.SigningKeyIdentifier);
            signingKey.Use = KeyType.Signing;
            sts.Keys.Add(signingKey);

            <span class="rem">// claim types </span>
            sts.ClaimTypesOffered.Add(<span class="kwrd">new</span> DisplayClaim(ClaimTypes.Email, <span class="str">"email address"</span>, <span class="str">"The subject’s email address."</span>));
            <span class="rem">// passive federation endpoint </span>
            sts.PassiveRequestorEndpoints.Add(passiveEndpoint);
            <span class="rem">// supported protocols </span>
            sts.ProtocolsSupported.Add(<span class="kwrd">new</span> Uri(WSFederationConstants.Namespace));
            <span class="rem">// add passive STS endpoint</span>
            sts.SecurityTokenServiceEndpoints.Add(passiveEndpoint);
            <span class="rem">// metadata signing</span>
            entity.SigningCredentials = signingCredentials;
            <span class="rem">// serialize</span>
            MetadataSerializer serializer = <span class="kwrd">new</span> MetadataSerializer();
            MemoryStream stream = <span class="kwrd">new</span> MemoryStream();
            serializer.WriteMetadata(stream, entity);
            stream.Flush(); 
            stream.Seek(0, SeekOrigin.Begin);
            XmlReader xmlReader = XmlTextReader.Create(stream);
            <span class="kwrd">return</span> XElement.Load(xmlReader);
        }

public class FederationMetadata : IFederationMetadata

{

System.Xml.Linq.XElement IFederationMetadata.FederationMetadata()

{

// hostname

string host = WebOperationContext.Current.IncomingRequest.Headers["Host"];

EndpointAddress realm = new EndpointAddress(String.Format("https://{0}", host));

EndpointAddress passiveEndpoint = new EndpointAddress(String.Format("https://{0}/Sts.aspx", host));

// metadata document

EntityDescriptor entity = new EntityDescriptor(new EntityId(realm.Uri.AbsoluteUri));

SecurityTokenServiceDescriptor sts = new SecurityTokenServiceDescriptor();

entity.RoleDescriptors.Add(sts);

// signing key

var signingCredentials = new X509SigningCredentials(CertificateUtil.GetCertificate(

StoreName.My, StoreLocation.LocalMachine,

"CN=STSTestCert"));

KeyDescriptor signingKey = new KeyDescriptor(signingCredentials.SigningKeyIdentifier);

signingKey.Use = KeyType.Signing;

sts.Keys.Add(signingKey);

// claim types

sts.ClaimTypesOffered.Add(new DisplayClaim(ClaimTypes.Email, "email address", "The subject’s email address."));

// passive federation endpoint

sts.PassiveRequestorEndpoints.Add(passiveEndpoint);

// supported protocols

sts.ProtocolsSupported.Add(new Uri(WSFederationConstants.Namespace));

// add passive STS endpoint

sts.SecurityTokenServiceEndpoints.Add(passiveEndpoint);

// metadata signing

entity.SigningCredentials = signingCredentials;

// serialize

MetadataSerializer serializer = new MetadataSerializer();

MemoryStream stream = new MemoryStream();

serializer.WriteMetadata(stream, entity);

stream.Flush();

stream.Seek(0, SeekOrigin.Begin);

XmlReader xmlReader = XmlTextReader.Create(stream);

return XElement.Load(xmlReader);

}

&nbsp;

Una alternativa a la creación de un servicio WCF REST es la de crear un IHttpHandler que responda a una dirección, generalmente a algo como 2007-07/FederationMetadata.xml que genere, con un código similar al anterior, la información de metadata.

Con esto acabamos esta corta entrada, en capítulos siguientes veremos algunos elementos más avanzados como REALM,ActAs etc.. para despues pasar a elementos pasivos como ASP.NET y ASP.NET MVC….. hasta la siguiente

Saludos

Unai

Deja un comentario Cancelar respuesta