ASP.Net MVC 5 Comment crypter des jetons JWT

Question

Je suis allé jeter quelques messages sur l'utilisation de JWT dans ASP.Net MVC, qui guide comment émettre et consommer des jetons Web signés JSON. Quelqu'un peut-il guider l'émission et la consommation de JWT crypté conformément aux spécifications JSON Web Encryption (JWE) au cas où nous aurions besoin de transmettre des données sensibles dans la charge utile JWT?

Answer 1

Comprendre JWT

JSON Token Web (JWT) est un moyen compact de sécurité URL de réclamations représentant à transférer entre deux parties. Les revendications dans un JWT sont codées en tant qu'objet JSON (JavaScript Object Notation) utilisé en tant que charge utile d'une structure JSON Web Signature (JWS) ou en tant que texte en clair d'une structure JSON Web Encryption (JWE), ce qui permet signé numériquement ou MACed et/ou crypté.

Qu'est-ce que JWT?
https://jwt.io/introduction/

Json Normes Jeton Web
https://tools.ietf.org/html/draft-ietf-oauth-json-web-token-25

Anatomie de JWT
https://scotch.io/tutorials/the-anatomy-of-a-json-web-token

Création JSON Token Web en JavaScript
https://www.jonathan-petitcolas.com/2014/11/27/creating-json-web-token-in-javascript.html

Maintenant, nous comprenons l'appel JWT et comment nous pouvons le servir du côté serveur. Ici j'ai la page HTML dans laquelle j'ai le bouton et également mis quelques paramètres personnalisés.

<script src="//cdnjs.cloudflare.com/ajax/libs/crypto-js/3.1.2/rollups/hmac-sha256.js"></script> 
    <script src="//cdnjs.cloudflare.com/ajax/libs/crypto-js/3.1.2/components/enc-base64-min.js"></script> 
    <script language="JavaScript" type="text/javascript" src="https://kjur.github.io/jsrsasign/jsrsasign-latest-all-min.js"></script> 

<script type="text/javascript"> 
    $(function() { 
     $("#btnJWTApi").click(function() { 
        // Defining our token parts 
        // You can use one of these, as alg 
        // HS256, HS386, HS512 
        // Always keep type as JWT 
        var header = { 
         "alg": "HS256", 
         "typ": "JWT" 
        }; 

        var tNow = KJUR.jws.IntDate.getNow(); 
        var tEnd = KJUR.jws.IntDate.getNow() + 60 * 5; 
        // dynamically pass these data using a function 
        var data = { 
         "appId": "yourAppId", 
         "iat": tNow, 
         // iat (issued at time) should be set to time when request has been generated 
         "exp": tEnd, 
         // exp (expiration) should not be more than 5 minutes from now, this is to prevent Replay Attacks 
         "method": "TestMethod", 
         "Q": "test", 
         "SecretKey": "MySecretKey" 
        }; 
        // Secret key is used for calculating and verifying the signature. 
        // The secret signing key MUST only be accessible by the issuer and the User, 
        // it should not be accessible outside of these two parties.     
        // Use the Secret you set during user registration from the Plugin 
        var secret = btoa('MySecret '); 

        function base64url(source) { 
         // Encode in classical base64 
         encodedSource = CryptoJS.enc.Base64.stringify(source); 
         // Remove padding equal characters 
         encodedSource = encodedSource.replace(/=+$/, ''); 
         // Replace characters according to base64url specifications 
         encodedSource = encodedSource.replace(/\+/g, '-'); 
         encodedSource = encodedSource.replace(/\//g, '_'); 
         return encodedSource; 
        } 

        var stringifiedHeader = CryptoJS.enc.Utf8.parse(JSON.stringify(header)); 
        var encodedHeader = base64url(stringifiedHeader); 

        var stringifiedData = CryptoJS.enc.Utf8.parse(JSON.stringify(data)); 
        var encodedData = base64url(stringifiedData); 

        var signature = encodedHeader + "." + encodedData; 
        signature = CryptoJS.HmacSHA256(signature, secret); 
        signature = base64url(signature); 

        var targetEle = $("#data"); 
        $.ajax(
         { 
          type: "POST", 
          url: "http://localhost:12345/api/v1/MyController/SecureMethod",   
          data: '{"token":"' + encodedHeader + "." + encodedData + "." + signature + '"}', 
          contentType: "application/json; charset=utf-8", 
          dataType: "json", 
          success: function (data) { 
           targetEle.html("<pre>" + JSON.stringify(data, null, '\t') + "</pre>"); 
          }, 
          error: function() { 
           alert('error'); 
          } 
         }); 
       });   
      }); 
    </script> 

Cet appel générera jeton crypté qui comprennent appId, secret et nos données de charge utile avec le nom de la méthode.

(créer ici une méthode commune, qui appellent d'abord, puis selon les données passant dans une autre méthode jeton sera appel)

Ceci appellera votre méthode SecureMethod au lieu de TestMethod directe. Et déchiffrez le jeton.

public string SecureMethod(dynamic tokenObject) 
{ 
    //save at a time of user registration. 
    string applicationID = appSecret get from database; 
    string secretKey = appSecret get from database; 
} 

var bytes = Encoding.UTF8.GetBytes(secretKey); 
        var secret = Convert.ToBase64String(bytes); 
        var jwtDecryption = JsonWebToken.DecodeToObject(token, secret, true, true); 
        var jsonObj = JObject.FromObject(jwtDecryption); 
        string appId = jsonObj["appId"].Value<string>(); 
if (appId.Equals(applicationID) 
{ 
     object restService = new MyController(); 
    var method = restService.GetType().GetMethod(jsonObj["method"].ToString(), BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); 
} 
if (method != null) 
{  
    var parameters = method.GetParameters().Select(p => Convert.ChangeType(jsonObj[p.Name].ToString(), p.ParameterType)).ToArray(); 
object response = method.Invoke(restService, parameters); //your actual method should 
return new JavaScriptSerializer().Serialize(response); 
} 

method.Invoke(restService, parameters); aura le nom et le paramètre méthode il va appeler votre méthode et passer des paramètres.

public IHttpActionResult TestMethod([FromBody]Response model) 
{ 
    // you will get parameters in a model 

    return Ok(); 
} 

Toute suggestion bienvenue!