web-dev-qa-db-fra.com

Comment créer un jeton d'authentification en utilisant Java

Sur mon service Java EE6, REST, je souhaite utiliser des jetons d'authentification pour la connexion à partir de périphériques mobiles. L'utilisateur enverra son nom d'utilisateur, son mot de passe et le serveur renverra un jeton, qui servira à autoriser l'utilisateur demandes pour un temps donné.

Puis-je simplement créer moi-même un jeton de cette manière?

String token = UUID.randomUUID().toString().toUpperCase() 
            + "|" + "userid" + "|"
            + cal.getTimeInMillis();

Ou bien existe-t-il un moyen plus standard de créer mes jetons? peut-être qu'il existe dans l'une des API 

javasecurityrestauthenticationtoken
20
Spring

Le schéma que vous proposez permet effectivement à un client d’avoir un accès illimité à votre service. Après une première connexion, les UID et «userid» seront mis à la disposition du client, ce qui peut simplement être combiné avec un horodatage toujours valide.

Si vous avez besoin d'un service avec 'login' et d'un jeton de session, pourquoi ne pas utiliser simplement une session HttpSession?

9
ireddick

Pour créer un jeton difficile à deviner en Java, utilisez Java.security.SecureRandom

Par exemple.

SecureRandom random = new SecureRandom();
byte bytes[] = new byte[20];
random.nextBytes(bytes);
String token = bytes.toString();

Plutôt que d'inclure le nom d'utilisateur dans le jeton, il serait préférable de mettre en cache un utilisateur: carte de jeton en mémoire ou dans une base de données .

14
Daniel de Zwaan
public class SecureTokenGenerator {
public static final String CHARACTERS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";

// 2048 bit keys should be secure until 2030 - https://web.archive.org/web/20170417095741/https://www.emc.com/emc-plus/rsa-labs/historical/twirl-and-rsa-key-size.htm
public static final int SECURE_TOKEN_LENGTH = 256;

private static final SecureRandom random = new SecureRandom();

private static final char[] symbols = CHARACTERS.toCharArray();

private static final char[] buf = new char[SECURE_TOKEN_LENGTH];

/**
 * Generate the next secure random token in the series.
 */
public static String nextToken() {
    for (int idx = 0; idx < buf.length; ++idx)
        buf[idx] = symbols[random.nextInt(symbols.length)];
    return new String(buf);
}

}

Pris et condensé de https://stackoverflow.com/a/41156/584947

1
anon58192932

REST est basé sur HTTP et encourage l'utilisation du protocole sous-jacent plutôt que de réinventer la roue. HTTP utilise des cookies pour prendre en charge les interactions avec état, telles que la mémorisation de l'authentification, et prend également en charge l'authentification par nom d'utilisateur et mot de passe.

De plus, Java EE prend en charge tout cela immédiatement. Voir le tutoriel

http://docs.Oracle.com/javaee/6/tutorial/doc/bncas.html

0
artbristol

Il existe un moyen de créer des jetons qui ne peut pas être compromis, mais qui peut également être utilisé pour l'authentification. 

Créez un jeton qui est combiné:

base64 (nom d'utilisateur + expiration + autres valeurs pour le client + 3des codées (nom d'utilisateur, expiration, source ip, identifiant du navigateur, autres valeurs pour le client))

Le client peut utiliser le jeton pour authentifier la demande, par exemple l'utilisation du jeton Web JSON (RFC 7515).

Côté serveur, les clés utilisées pour l’encodage 3des peuvent être pivotées dans le temps, en tant que jeton. Chaque demande contient un jeton d'authentification et chaque réponse contient le même jeton ou un nouveau avant l'expiration.

Dans ce cas, le jeton contient le nom d'utilisateur. Par conséquent, sur l'authentification de la demande, il suffit de vérifier si la partie codée 3des est valide ou non (idem Vous pouvez composer d'autres identifiants sous forme de jeton, tels que le navigateur, etc. jeton. (En fait, il n’existe pas de sécurité parfaite, cela ne peut que rendre plus difficile à craquer)

Les avantages de cette solution sont:

  • Chaque pièce est standard, mais pas le tout ensemble et l'attaquant doit connaître les détails de la mise en œuvre pour pouvoir attaquer. 
  • Le côté client peut utiliser des parties du jeton pour afficher des informations à partir du jeton, tandis que le jeton lui-même est sécurisé, car chaque partie non chiffrée est contenue dans une partie chiffrée. attaque.
  • Il n'y a pas besoin de réplication de session/sessions collantes pour la mise en cluster. Les clés 3des suffisent pour se répliquer entre les nœuds - il convient donc à la stratégie de backend sans état.

Les inconvénients sont

  • Plus difficile à mettre en œuvre côté serveur, car pour cette solution, il est nécessaire de mettre en œuvre l'algorithme de génération/validation de jeton côté serveur. Pour ce serveur, le filtre est recommandé.

  • Les clients doivent implémenter le magasin de jetons - il est recommandé de stocker le magasin de session du navigateur de cookies - plus facile de voler les cookies.

  • Il faut s’assurer que les clés 3des sont suffisamment sécurisées - il est recommandé d’utiliser la sécurité Java pour éviter toute compression.
0
Csákány Róbert