Exemple de code pour s'authentifier avec OAuth 2.0 et obtenir un jeton d'accès. Les paramètres côté serveur d'authentification ne sont pas décrits cette fois.
(1) Obtenez l'ID client et la clé secrète émis à l'avance côté serveur d'authentification ② Demande au point de terminaison d'authentification (accès URL) ③ Authentifier (saisir l'ID utilisateur et le mot de passe) ④ Une requête arrive sur la page de rappel par redirection ⑤ Si l'authentification réussit, vous pouvez obtenir le code d'autorisation à partir des paramètres de requête, etc. ⑥ Envoyez le code d'autorisation, l'ID client et la clé secrète au point de terminaison du jeton (POST, etc.) ⑦ Obtenez un jeton d'accès (et un jeton d'actualisation) ⑧ Après cela, dès que vous lancez l'API, vous pouvez obtenir un jeton d'identification et un SSO librement
J'ai vérifié en utilisant OpenAM pour le serveur d'authentification (je ne toucherai pas aux paramètres ici). Le côté client a utilisé le client oauth de Google. De plus, j'utilise spark-framework pour l'essayer facilement.
pom.xml
<dependency>
<groupId>com.sparkjava</groupId>
<artifactId>spark-core</artifactId>
<version>2.7.1</version>
</dependency>
<dependency>
<groupId>com.google.oauth-client</groupId>
<artifactId>google-oauth-client</artifactId>
<version>1.23.0</version>
</dependency>
<dependency>
<groupId>com.google.http-client</groupId>
<artifactId>google-http-client-jackson2</artifactId>
<version>1.23.0</version>
</dependency>
MyOAuthServiceProviderSample.java
import java.util.Arrays;
import spark.Request;
import spark.Response;
import spark.Route;
import static spark.Spark.*;
import com.google.api.client.auth.oauth2.AuthorizationCodeRequestUrl;
import com.google.api.client.auth.oauth2.AuthorizationCodeTokenRequest;
import com.google.api.client.auth.oauth2.TokenResponse;
import com.google.api.client.http.GenericUrl;
import com.google.api.client.http.javanet.NetHttpTransport;
import com.google.api.client.json.jackson2.JacksonFactory;
import java.io.IOException;
/**
* OAuth2.Authentifiez-vous avec 0 et obtenez un jeton d'accès
* @author owl
*/
public class MyOAuthServiceProviderSample {
public static void main(String[] args) {
/**
*① Demande d'authentification
*/
get("/auth", new Route() {
@Override
public Object handle(Request req, Response resp) throws Exception {
/**
*Spécifiez le point de terminaison d'authentification et l'ID client
*Cette fois, nous utiliserons le serveur d'authentification construit avec OpenAM
*/
AuthorizationCodeRequestUrl codeUrl = new AuthorizationCodeRequestUrl("http://www1.openamexam.co.jp:18080/openam/oauth2/authorize?", "oauth_client_key");
codeUrl.setScopes(Arrays.asList("openid profile email")); //Spécifiez les informations que vous souhaitez obtenir
codeUrl.setResponseTypes(Arrays.asList("code")); //Obtenez un code d'autorisation
codeUrl.setRedirectUri("http://localhost:4567/callback"); //Spécifiez CallBackUrl
codeUrl.setState("this_is_test_state_code"); //Spécifiez le code d'état, pour les mesures CSRF
codeUrl.set("nonce", "this_is_one_time_phrase"); //Spécifiez nonce, pour les contre-mesures d'attaque de relecture
codeUrl.set("access_type", "offline"); //Demander un jeton d'actualisation
codeUrl.set("realm", "/api"); //Spécifiez le royaume
resp.redirect(codeUrl.build()); //Passer au point de terminaison d'authentification
return null;
}
});
/**
*② Acquisition de jeton d'accès
* --Une fois authentifié par le point de terminaison d'authentification, une redirection vous rappellera.
*/
get("/callback", new Route() {
@Override
public Object handle(Request req, Response resp) throws Exception {
/**
*Demander un jeton d'accès à partir du code d'autorisation
*Cette zone dépend également des paramètres du serveur d'authentification. Cette fois, il est défini de manière à pouvoir être obtenu avec QueryString.
*/
String allowCode = req.queryParams("code"); //Obtenir le code d'autorisation
//Obtenir le code d'état
//Ici, vous devez vérifier si la valeur est la même que lors de la demande (cette fois omise)
String stateCode = req.queryParams("state");
/**
*Faire une demande d'acquisition de jeton d'accès avec le code d'autorisation
*Cette zone dépend également des paramètres du serveur d'authentification. Cette fois, envoyez la clé secrète par la méthode POST
*/
AuthorizationCodeTokenRequest tokenUrl = new AuthorizationCodeTokenRequest(
new NetHttpTransport(),
new JacksonFactory(),
new GenericUrl("http://www1.openamexam.co.jp:18080/openam/oauth2/access_token?realm=/api"),
allowCode
);
tokenUrl.setGrantType("authorization_code");
tokenUrl.setRedirectUri("http://localhost:4567/callback"); //Si vous ne spécifiez pas à nouveau votre propre URL, une erreur se produira
tokenUrl.set("client_id", "oauth_client_key"); //Définir l'ID client
tokenUrl.set("client_secret", "oauth_secret_key"); //Définir l'ID secret
TokenResponse tr = null;
String accessToken = null;
String refreshToken = null;
try {
tr = tokenUrl.execute();
accessToken = tr.getAccessToken();
refreshToken = tr.getRefreshToken() == null ? "null" : tr.getRefreshToken();
//Il est également possible de le faire SSO si vous obtenez idToken, analysez-le, faites confiance aux informations et connectez-vous à votre propre service
String idToken = (String)tr.get("id_token");
} catch (IOException e) {
e.printStackTrace();
} finally {
tr = null;
}
return "AccessToken = " + accessToken
+ "<br>RefreshToken = " + refreshToken;
}
});
}
}
Recommended Posts