WCF LiveID Authentication einer Windows 8 Store App

Home » Cloud » WCF LiveID Authentication einer Windows 8 Store App – Teil 4

WCF LiveID Authentication einer Windows 8 Store App – Teil 4

25. Januar 2013

div class=“articleAbstract“>In diesem Teil der Artikelserie wird für den WCF Service eine Authentifizierung durch Windows Live implementiert.

Überblick zur Artikelserie

Teil 1 gibt eine Übersicht über die eingesetzten Technologien und Portale
Teil 2 beschäftigt sich mit der Erzeugung und Konfiguration der Windows 8 Store App mit Live Anmeldung
Teil 3 erzeugt den WCF Service und sichert diesen über SSL ab
Teil 4 autorisiert den angemeldeten Live-Benutzer an den WCF Services
Teil 5 hosted den Service in Windows Azure

Teil 4 – Autorisierung des WCF Services mit LiveID

Ausgangsituation ist die Solution aus Teil 3 der Artikelserie. Diese besteht aus einer Windows Store App Anwendung, die sich bei Windows Live authentifizieren kann. Diese Clientanwendung ruft einen mit SSL transportgesicherten WCF Service auf.
In Teil 4 wird der WCF Service um eine Autorisierung erweitert. Diese prüft, ob der Benutzer sich mit einer gültigen LiveID angemeldet hat. Damit wird sichergestellt, dass die durch Live gelieferte UserID nicht manipuliert ist und der Benutzer somit eindeutig und sicher identifiziert werden kann.

Durchgeführt wird die Autorisierung mit dem AuthenticationToken der Live-Anmeldung aus Teil 2. Dieses Token ist ein Json Web Token (JWT), das unter anderem UserID und Claims des Benutzers enthält. Das JWT ist bei der Live-Anmeldung mit dem „Geheimen Clientschlüssel“ signiert worden. Den geheimen Clientschlüssel hat Live bei der Konfiguration der Anwendung angelegt (siehe Teil 2 – „Live ID Login“) und kann über das Managementportal https://manage.dev.live.com durch den Entwickler abgefragt werden.
Die Servicekommunikation steht nun vor der Aufgabe das JWT an den Service zu übertragen. Ein probates Mittel besteht darin, die Service-Security von Transport-Security auf TransportWithMessageCredential-Security umzustellen. Dies bedeutet, dass auf dem SSL verschlüsselten Kanal in der Nachricht eine User-Passwort Kombination übergeben wird.
Als Service-User wird die UserID des JWT genutzt. WCF nutzt wiederum den Namen und setzt diesen in der .NET-Umgebung als Name der PrimaryIdentity ein.

Autorisierung des WCF Services

Wie zuvor beschrieben wird das Binding auf TransportWithMessageCredential geändert:
Änderung des Bindings in der web.config

<binding name="SayHelloServiceBinding">      
  <security mode="TransportWithMessageCredential">      
    <transport/>      
    <message clientCredentialType="UserName"/>      
  </security>      
</binding>

Durch die Konfiguration wird ausgesagt, dass im Nachrichteninhalt zusätzlich eine UserName und Passwort Kombination übertragen wird. Diese Informationen werden bei Empfang der Nachricht auf der Service-Seite überprüft, bevor der eigentliche Service aufgerufen wird. Die Service-Schnittstelle ändert sich somit nicht.
User und Passwort müssen auf Server-Seite überprüft werden. Netterweise findet sich in den LiveSDKSamples https://github.com/liveservices/LiveSDK ein Parser für das Format. Als Input nutzt der Parser das WebToken sowie den „geheimen Schlüssel“ zum Validieren der Signatur.
Der Service wird um die Klasse JsonWebToken erweitert:

Neue Klasse JsonWebToken.cs

namespace WcfService      
{      
    // Reference: http://tools.ietf.org/search/draft-jones-json-web-token-00      
    //      
    // JWT is made up of 3 parts: Envelope, Claims, Signature.      
    // - Envelope - specifies the token type and signature algorithm used to produce       
    //       signature segment. This is in JSON format      
    // - Claims - specifies claims made by the token. This is in JSON format      
    // - Signature - Cryptographic signature use to maintain data integrity.      
    //       
    // To produce a JWT token:      
    // 1. Create Envelope segment in JSON format      
    // 2. Create Claims segment in JSON format      
    // 3. Create signature      
    // 4. Base64url encode each part and append together separated by "."       
    using System;      
    using System.Collections.Generic;      
    using System.IO;      
    using System.Runtime.Serialization;      
    using System.Runtime.Serialization.Json;      
    using System.Security.Cryptography;      
    using System.Text;      
        
    public class JsonWebToken      
    {      
        #region Helper Classes      
        [DataContract]      
        public class JsonWebTokenClaims      
        {      
            [DataMember(Name = "exp")]      
            private int expUnixTime      
            {      
                get;      
                set;      
            }      
            private DateTime? expiration = null;      
            public DateTime Expiration      
            {      
                get      
                {      
                    if (this.expiration == null)      
                    {      
                        this.expiration = new DateTime(1970, 1, 1, 0, 0, 0).AddSeconds(this.expUnixTime);      
                    }      
                    return (DateTime)this.expiration;      
                }      
            }      
        
            [DataMember(Name = "iss")]      
            public string Issuer      
            {      
                get;      
                private set;      
            }      
        
            [DataMember(Name = "aud")]      
            public string Audience      
            {      
                get;      
                private set;      
            }      
        
            [DataMember(Name = "uid")]      
            public string UserId      
            {      
                get;      
                private set;      
            }      
        
            [DataMember(Name = "ver")]      
            public int Version      
            {      
                get;      
                private set;      
            }      
        
            [DataMember(Name = "urn:microsoft:appuri")]      
            public string ClientIdentifier      
            {      
                get;      
                private set;      
            }      
        
            [DataMember(Name = "urn:microsoft:appid")]      
            public string AppId      
            {      
                get;      
                private set;      
            }      
        }      
        
        [DataContract]      
        public class JsonWebTokenEnvelope      
        {      
            [DataMember(Name = "typ")]      
            public string Type      
            {      
                get;      
                private set;      
            }      
        
            [DataMember(Name = "alg")]      
            public string Algorithm      
            {      
                get;      
                private set;      
            }      
        
            [DataMember(Name = "kid")]      
            public int KeyId      
            {      
                get;      
                private set;      
            }      
        }      
        #endregion      
        
        #region Properties      
        private static readonly DataContractJsonSerializer ClaimsJsonSerializer = new DataContractJsonSerializer(typeof(JsonWebTokenClaims));      
        private static readonly DataContractJsonSerializer EnvelopeJsonSerializer = new DataContractJsonSerializer(typeof(JsonWebTokenEnvelope));      
        private static readonly UTF8Encoding UTF8Encoder = new UTF8Encoding(true, true);      
        private static readonly SHA256Managed SHA256Provider = new SHA256Managed();      
        private string claimsTokenSegment;      
        
        public JsonWebTokenClaims Claims      
        {      
            get;      
            private set;      
        }      
        
        private string envelopeTokenSegment;      
        
        public JsonWebTokenEnvelope Envelope      
        {      
            get;      
            private set;      
        }      
        
        public string Signature      
        {      
            get;      
            private set;      
        }      
        
        public bool IsExpired      
        {      
            get      
            {      
                return this.Claims.Expiration < DateTime.Now;      
            }      
        }      
        #endregion      
        
        #region Constructors      
        public JsonWebToken(string token, Dictionary<int, string> keyIdsKeys)      
        {      
            // Get the token segments & perform validation      
            string[] tokenSegments = this.SplitToken(token);      
        
            // Decode and deserialize the claims      
            this.claimsTokenSegment = tokenSegments[1];      
            this.Claims = this.GetClaimsFromTokenSegment(this.claimsTokenSegment);      
        
            // Decode and deserialize the envelope      
            this.envelopeTokenSegment = tokenSegments[0];      
            this.Envelope = this.GetEnvelopeFromTokenSegment(this.envelopeTokenSegment);      
        
            // Get the signature      
            this.Signature = tokenSegments[2];      
       
            // Ensure that the tokens KeyId exists in the secret keys list      
            if (!keyIdsKeys.ContainsKey(this.Envelope.KeyId))      
            {      
                throw new Exception(string.Format("Could not find key with id {0}", this.Envelope.KeyId));      
            }      
        
            // Validation      
            this.ValidateEnvelope(this.Envelope);      
            this.ValidateSignature(keyIdsKeys[this.Envelope.KeyId]);      
        }      
        
        private JsonWebToken()      
        {      
        }      
        
        #endregion      
        
        #region Parsing Methods      
        private JsonWebTokenClaims GetClaimsFromTokenSegment(string claimsTokenSegment)      
        {      
            byte[] claimsData = this.Base64UrlDecode(claimsTokenSegment);      
            using (MemoryStream memoryStream = new MemoryStream(claimsData))      
            {      
                return ClaimsJsonSerializer.ReadObject(memoryStream) as JsonWebTokenClaims;      
            }      
        }      
        
        private JsonWebTokenEnvelope GetEnvelopeFromTokenSegment(string envelopeTokenSegment)      
        {      
            byte[] envelopeData = this.Base64UrlDecode(envelopeTokenSegment);      
            using (MemoryStream memoryStream = new MemoryStream(envelopeData))      
            {      
                return EnvelopeJsonSerializer.ReadObject(memoryStream) as JsonWebTokenEnvelope;      
            }      
        }      
        
        private string[] SplitToken(string token)      
        {      
            // Expected token format: Envelope.Claims.Signature      
            if (string.IsNullOrEmpty(token))      
            {      
                throw new Exception("Token is empty or null.");      
            }      
        
            string[] segments = token.Split('.');      
            if (segments.Length != 3)      
            {      
                throw new Exception("Invalid token format. Expected Envelope.Claims.Signature");      
            }      
            if (string.IsNullOrEmpty(segments[0]))      
            {      
                throw new Exception("Invalid token format. Envelope must not be empty");      
            }      
            if (string.IsNullOrEmpty(segments[1]))      
            {      
                throw new Exception("Invalid token format. Claims must not be empty");      
            }      
            if (string.IsNullOrEmpty(segments[2]))      
            {      
                throw new Exception("Invalid token format. Signature must not be empty");      
            }      
            return segments;      
        }      
        #endregion      
        
        #region Validation Methods      
        private void ValidateEnvelope(JsonWebTokenEnvelope envelope)      
        {      
            if (envelope.Type != "JWT")      
            {      
                throw new Exception("Unsupported token type");      
            }      
            if (envelope.Algorithm != "HS256")      
            {      
                throw new Exception("Unsupported crypto algorithm");      
            }      
        }      
        
        private void ValidateSignature(string key)      
        {      
            // Derive signing key, Signing key = SHA256(secret + "JWTSig")      
            byte[] bytes = UTF8Encoder.GetBytes(key + "JWTSig");      
            byte[] signingKey = SHA256Provider.ComputeHash(bytes);      
        
            // To Validate:      
            //       
            // 1. Take the bytes of the UTF-8 representation of the JWT Claim      
            //  Segment and calculate an HMAC SHA-256 MAC on them using the      
            //  shared key.      
            //      
            // 2. Base64url encode the previously generated HMAC as defined in this      
            //  document.      
            //      
            // 3. If the JWT Crypto Segment and the previously calculated value      
            //  exactly match in a character by character, case sensitive      
            //  comparison, then one has confirmation that the key was used to      
            //  generate the HMAC on the JWT and that the contents of the JWT      
            //  Claim Segment have not be tampered with.      
            //      
            // 4. If the validation fails, the token MUST be rejected.      
        
            // UFT-8 representation of the JWT envelope.claim segment      
            byte[] input = UTF8Encoder.GetBytes(this.envelopeTokenSegment + "." + this.claimsTokenSegment);      
        
            // calculate an HMAC SHA-256 MAC      
            using (HMACSHA256 hashProvider = new HMACSHA256(signingKey))      
            {      
                byte[] myHashValue = hashProvider.ComputeHash(input);      
        
                // Base64 url encode the hash      
                string base64urlEncodedHash = this.Base64UrlEncode(myHashValue);      
       
                // Now compare the two has values      
                if (base64urlEncodedHash != this.Signature)      
                {      
                    throw new Exception("Signature does not match.");      
                }      
            }      
        }      
        #endregion      
       
        #region Base64 Encode / Decode Functions      
        // Reference: http://tools.ietf.org/search/draft-jones-json-web-token-00      
        public byte[] Base64UrlDecode(string encodedSegment)      
        {      
            string s = encodedSegment;      
            s = s.Replace('-', '+'); // 62nd char of encoding      
            s = s.Replace('_', '/'); // 63rd char of encoding      
            switch (s.Length % 4) // Pad with trailing '='s      
            {      
                case 0: break; // No pad chars in this case      
                case 2: s += "=="; break; // Two pad chars      
                case 3: s += "="; break; // One pad char      
                default: throw new System.Exception("Illegal base64url string");      
            }      
            return Convert.FromBase64String(s); // Standard base64 decoder      
        }      
       
        public string Base64UrlEncode(byte[] arg)      
        {      
            string s = Convert.ToBase64String(arg); // Standard base64 encoder      
            s = s.Split('=')[0]; // Remove any trailing '='s      
            s = s.Replace('+', '-'); // 62nd char of encoding      
            s = s.Replace('/', '_'); // 63rd char of encoding      
            return s;      
        }      
        #endregion      
    }      
}

Jetzt fehlt nur noch die Überprüfung des Tokens.
Zur Erinnerung: Das Token enthält Claims und wurde von Live unterschrieben. Diese Unterschrift kann mit dem “geheimen Client Schlüssel” bzw. “Client Secret” der Anwendung geprüft werden. Wie im Teil 2 beschrieben, wird im Management Portal von Live der Schlüssel angezeigt bzw. neu erzeugt.
Die Prüfung des Tokens wird in einem UserNamePasswordValidator realisiert, der in die WCF Konfiguration eingehängt wird. Somit wird das transportierte Token überprüft ohne die Methodensignatur zu ändern. Der Code nutzt Funktionen aus System.IdentityModel bzw. System.IdentityModel.Selectors, die als Referenz hinzugefügt werden.

Neue Klasse CustomUserNameValidator.cs

using System;      
using System.Collections.Generic;      
using System.IdentityModel.Selectors;      
using System.Linq;      
using System.ServiceModel;      
using System.Web;      
       
namespace WcfService      
{      
    public class CustomUserNameValidator : UserNamePasswordValidator      
    {      
        const string LiveSecretClientKey = "ClientSecret_AusDemLivePortal";      
        
        public override void Validate(string userName, string password)      
        {      
            try      
            {      
                if (String.IsNullOrEmpty(userName) || String.IsNullOrEmpty(password))      
                {      
                    throw new Exception("User or Password not set");      
                }      
                Dictionary<int, string> d = new Dictionary<int, string>();      
                d.Add(0, LiveSecretClientKey);      
        
                // Parse Token und validiere Signatur      
                JsonWebToken jwt = new JsonWebToken(password, d);      
        
                // Prüfe ob User mit der UserId im Token übereinstimmt      
                var jwtUserName = jwt.Claims.UserId;      
                if (jwtUserName != userName)      
                {      
                    throw new Exception("Manipulated Username");      
                }      
            }      
            catch (Exception e)      
            {      
                FaultException fe = new FaultException("Unknown Username or Incorrect Password 
" + e.ToString());      
                throw fe;      
            }      
        }      
    }      
}

Der geheime Client Schlüssel muss im CustomUserNameValidator eingetragen werden (siehe Zeile 12) damit dieser die Unterschrift prüfen kann.
Das Einhängen des Validators erfolgt in einer Behavior-Konfiguration des Services.

Konfiguration des CustomUserNameValidators in der web.config

<behavior>      
  <serviceBehaviors>      
    [...]      
    <serviceCredentials>      
      <userNameAuthentication       
        userNamePasswordValidationMode="Custom"      
        customUserNamePasswordValidatorType="WcfService.CustomUserNameValidator, WcfService" />      
    </serviceCredentials>                
  </behavior>      
</serviceBehaviors>

Zum Debuggen des Validators muss der Debugger an den IISExpress Attached werden.

Setzen der Service-Credentials im Client

Nun muss der Client beim Serviceaufruf User und Passwort der Service-Authentifizierung setzen. Ansonsten erhält man nachfolgende Fehlermeldung:
InvalidOperationException „The username is not provided. Specify username in ClientCredentials“
Im ersten Schritte wird die UserID aus dem JWT Token extrahiert werden. Die Extraktion erfolgt dabei mit dem gleichen Code wie im CustomUserNameValiditor, mit Ausnahme der Validierung. Zum einen muss auf der Client-Seit das Token nicht validiert werden, zum anderen stehen auch einige kryptografische Funktionen in WinRT nicht zur Verfügung, so dass der Code nur leicht modifiziert funktioniert.

Neu Klasse JsonWebTokenMin.cs

namespace ClientStoraApp      
{      
    // Reference: http://tools.ietf.org/search/draft-jones-json-web-token-00      
    //      
    // JWT is made up of 3 parts: Envelope, Claims, Signature.      
    // - Envelope - specifies the token type and signature algorithm used to produce       
    //       signature segment. This is in JSON format      
    // - Claims - specifies claims made by the token. This is in JSON format      
    // - Signature - Cryptographic signature use to maintain data integrity.      
    //       
    // To produce a JWT token:      
    // 1. Create Envelope segment in JSON format      
    // 2. Create Claims segment in JSON format      
    // 3. Create signature      
    // 4. Base64url encode each part and append together separated by "."       
        
    using System;      
    using System.Collections.Generic;      
    using System.IO;      
    using System.Runtime.Serialization;      
    using System.Runtime.Serialization.Json;      
    using System.Text;      
       
    public class JsonWebTokenMin      
    {      
        #region Helper Classes      
        [DataContract]      
        public class JsonWebTokenClaims      
        {      
            [DataMember(Name = "exp")]      
            private int expUnixTime      
            {      
                get;      
                set;      
            }      
            private DateTime? expiration = null;      
            public DateTime Expiration      
            {      
                get      
                {      
                    if (this.expiration == null)      
                    {      
                        this.expiration = new DateTime(1970, 1, 1, 0, 0, 0).AddSeconds(this.expUnixTime);      
                    }      
                    return (DateTime)this.expiration;      
                }      
            }      
        
            [DataMember(Name = "iss")]      
            public string Issuer      
            {      
                get;      
                private set;      
            }      
        
            [DataMember(Name = "aud")]      
            public string Audience      
            {      
                get;      
                private set;      
            }      
       
            [DataMember(Name = "uid")]      
            public string UserId      
            {      
                get;      
                private set;      
            }      
        
            [DataMember(Name = "ver")]      
            public int Version      
            {      
                get;      
                private set;      
            }      
        
            [DataMember(Name = "urn:microsoft:appuri")]      
            public string ClientIdentifier      
            {      
                get;      
                private set;      
            }      
       
            [DataMember(Name = "urn:microsoft:appid")]      
            public string AppId      
            {      
                get;      
                private set;      
            }      
        }      
       
        [DataContract]      
        public class JsonWebTokenEnvelope      
        {      
            [DataMember(Name = "typ")]      
            public string Type      
            {      
                get;      
                private set;      
            }      
        
            [DataMember(Name = "alg")]      
            public string Algorithm      
            {      
                get;      
                private set;      
            }      
        
            [DataMember(Name = "kid")]      
            public int KeyId      
            {      
                get;      
                private set;      
            }      
        }      
        #endregion      
        
        #region Properties      
        private static readonly DataContractJsonSerializer ClaimsJsonSerializer = new DataContractJsonSerializer(typeof(JsonWebTokenClaims));      
        private static readonly DataContractJsonSerializer EnvelopeJsonSerializer = new DataContractJsonSerializer(typeof(JsonWebTokenEnvelope));      
        private static readonly UTF8Encoding UTF8Encoder = new UTF8Encoding(true, true);      
        private string claimsTokenSegment;      
        
        public JsonWebTokenClaims Claims      
        {      
            get;      
            private set;      
        }      
        
        private string envelopeTokenSegment;      
        
        public JsonWebTokenEnvelope Envelope      
        {      
            get;      
            private set;      
        }      
       
        public string Signature      
        {      
            get;      
            private set;      
        }      
       
        public bool IsExpired      
        {      
            get      
            {      
                return this.Claims.Expiration < DateTime.Now;      
            }      
        }      
        #endregion      
        
        #region Constructors      
        public JsonWebTokenMin(string token)      
        {      
            // Get the token segments & perform validation      
            string[] tokenSegments = this.SplitToken(token);      
        
            // Decode and deserialize the claims      
            this.claimsTokenSegment = tokenSegments[1];      
            this.Claims = this.GetClaimsFromTokenSegment(this.claimsTokenSegment);      
        
            // Decode and deserialize the envelope      
            this.envelopeTokenSegment = tokenSegments[0];      
            this.Envelope = this.GetEnvelopeFromTokenSegment(this.envelopeTokenSegment);      
        
            // Get the signature      
            this.Signature = tokenSegments[2];      
        
            // Validation      
            this.ValidateEnvelope(this.Envelope);      
        }      
        
        private JsonWebTokenMin()      
        {      
        }      
        #endregion      
       
        #region Parsing Methods      
        
        private JsonWebTokenClaims GetClaimsFromTokenSegment(string claimsTokenSegment)      
        {      
            byte[] claimsData = this.Base64UrlDecode(claimsTokenSegment);      
            using (MemoryStream memoryStream = new MemoryStream(claimsData))      
            {      
                return ClaimsJsonSerializer.ReadObject(memoryStream) as JsonWebTokenClaims;      
            }      
        }      
        
        private JsonWebTokenEnvelope GetEnvelopeFromTokenSegment(string envelopeTokenSegment)      
        {      
            byte[] envelopeData = this.Base64UrlDecode(envelopeTokenSegment);      
            using (MemoryStream memoryStream = new MemoryStream(envelopeData))      
            {      
                return EnvelopeJsonSerializer.ReadObject(memoryStream) as JsonWebTokenEnvelope;      
            }      
        }      
        
        private string[] SplitToken(string token)      
        {      
            // Expected token format: Envelope.Claims.Signature      
            if (string.IsNullOrEmpty(token))      
            {      
                throw new Exception("Token is empty or null.");      
            }      
            string[] segments = token.Split('.');      
            if (segments.Length != 3)      
            {      
                throw new Exception("Invalid token format. Expected Envelope.Claims.Signature");      
            }      
            if (string.IsNullOrEmpty(segments[0]))      
            {      
                throw new Exception("Invalid token format. Envelope must not be empty");      
            }      
            if (string.IsNullOrEmpty(segments[1]))      
            {      
                throw new Exception("Invalid token format. Claims must not be empty");      
            }      
            if (string.IsNullOrEmpty(segments[2]))      
            {      
                throw new Exception("Invalid token format. Signature must not be empty");      
            }      
            return segments;      
        }      
        #endregion      
        
        #region Validation Methods      
        private void ValidateEnvelope(JsonWebTokenEnvelope envelope)      
        {      
            if (envelope.Type != "JWT")      
            {      
                throw new Exception("Unsupported token type");      
            }      
            if (envelope.Algorithm != "HS256")      
            {      
                throw new Exception("Unsupported crypto algorithm");      
            }      
        }      
        #endregion      
        
        #region Base64 Encode / Decode Functions      
        // Reference: http://tools.ietf.org/search/draft-jones-json-web-token-00      
        public byte[] Base64UrlDecode(string encodedSegment)      
        {      
            string s = encodedSegment;      
            s = s.Replace('-', '+'); // 62nd char of encoding      
            s = s.Replace('_', '/'); // 63rd char of encoding      
            switch (s.Length % 4) // Pad with trailing '='s      
            {      
                case 0: break; // No pad chars in this case      
                case 2: s += "=="; break; // Two pad chars      
                case 3: s += "="; break; // One pad char      
                default: throw new System.Exception("Illegal base64url string");      
            }      
            return Convert.FromBase64String(s); // Standard base64 decoder      
        }      
        
        public string Base64UrlEncode(byte[] arg)      
        {      
            string s = Convert.ToBase64String(arg); // Standard base64 encoder      
            s = s.Split('=')[0]; // Remove any trailing '='s      
            s = s.Replace('+', '-'); // 62nd char of encoding      
            s = s.Replace('/', '_'); // 63rd char of encoding      
            return s;      
        }      
        #endregion      
    }      
}

Als Service-Passwort wird das JWT Token direkt genutzt. Service-User und Service-Passwort können nun zum Service Aufruf (siehe Zeile 14-15) hinzugefügt werden.

Änderung des WCF Aufrufs MainPage.xaml.cs

private async void CallWCFButton_Click(object sender, RoutedEventArgs e)      
{      
    SayHelloServiceClient helloClient = new SayHelloServiceClient(      
        SayHelloServiceClient.EndpointConfiguration.SayHelloService);      
    // Endpunkt für IIS Express (Portnummer bitte anpassen)       
    // EndpointAddress ea = new EndpointAddress("https://localhost:44303/SayHelloService.svc");      
    // Alternativer Endpunkt für Azure (Rechnername und Portnummer bitte anpassen)      
    //EndpointAddress ea = new EndpointAddress("https://win8securewcf.cloudapp.net:443/SayHelloService.svc");      
    helloClient.Endpoint.Address = ea;      
       
    if (! String.IsNullOrEmpty(AuthToken))      
    {      
        JsonWebTokenMin jwt = new JsonWebTokenMin(AuthToken);      
        helloClient.ClientCredentials.UserName.UserName = jwt.Claims.UserId;      
        helloClient.ClientCredentials.UserName.Password = AuthToken;      
    }      
    WcfOutput = await helloClient.SayHelloAsync("lieber Benutzer");      
}

Wird nun der Client gestartet antwortet der Service korrekt. Mit einer kleinen Erweiterungen gibt der Service auch die UserId mit aus.

Änderung an SayHello.cs

public string SayHello(string input)      
{      
  ServiceSecurityContext ssc = OperationContext.Current.ServiceSecurityContext;      
  string userName = ssc.PrimaryIdentity.Name;      
  return String.Format("Hello {0}. Your JWT-UserID is '{1}' ", input, userName);      
}

Finale

Knackpunkt in diesem Teil war die Auswertung und Validierung des Json Web Tokens. Dieses wird durch den Client bereitgestellt und im ServiceHost durch den Validator geprüft.