Manuel d'utilisation d'Apache Shiro (2) Certification Shiro

Manuel d'utilisation d'Apache Shiro (2) Authentification Shiro

L'authentification est le processus de vérification de l'identité de l'utilisateur. Au cours du processus d'authentification, les utilisateurs doivent soumettre des informations sur l'entité (Principaux) et des informations d'identification (Credentials) pour vérifier si l'utilisateur est légitime. La combinaison « entité/identifiant » la plus courante est la combinaison « nom d'utilisateur/mot de passe ».

1. Processus d'authentification Shiro

1. Collecter les informations d'entité/informations d'identification

//Example using most common scenario of username/password pair:  
UsernamePasswordToken token = new UsernamePasswordToken(username, password);  
//”Remember Me” built-in:  
token.setRememberMe(true);

UsernamePasswordToken prend en charge les mécanismes d'authentification par nom d'utilisateur/mot de passe les plus courants. En même temps, puisqu'il implémente l'interface RememberMeAuthenticationToken, nous pouvons définir la fonction « se souvenir de moi » via le jeton.
Cependant, il existe une différence entre « mémorisé » et « authentifié » :
Les utilisateurs mémorisés ne sont que des utilisateurs non anonymes et vous pouvez obtenir des informations sur les utilisateurs via subject.getPrincipals(). Mais il ne s'agit pas d'un utilisateur entièrement authentifié. Lorsque vous accédez à des fonctions nécessitant des utilisateurs authentifiés, vous devez toujours soumettre à nouveau les informations d'authentification.
Vous pouvez vous référer au site Web d'Amazon pour cette différence. Le site Web mémorisera les utilisateurs connectés par défaut. Lorsque vous visiterez à nouveau le site Web, pour les fonctions de page non sensibles, les informations utilisateur mémorisées seront affichées sur la page. mais lorsque vous accédez aux informations de compte du site Web, vous devez toujours vous reconnecter.

2. Soumettre les informations d'entité/informations d'identification

Subject currentUser = SecurityUtils.getSubject();  
currentUser.login(token);

Après avoir collecté les informations d'entité/informations d'identification, nous pouvons obtenir l'utilisateur actuel via la classe d'outils SecurityUtils, puis soumettre l'authentification en appelant le méthode de connexion.

3. Traitement de l'authentification

try {  
    currentUser.login(token);  
} catch ( UnknownAccountException uae ) { ...  
} catch ( IncorrectCredentialsException ice ) { ...  
} catch ( LockedAccountException lae ) { ...  
} catch ( ExcessiveAttemptsException eae ) { ...  
} ... catch your own ...  
} catch ( AuthenticationException ae ) {  
    //unexpected error?  
}

Si la méthode de connexion est terminée sans générer d'informations d'exception, alors l'authentification de l'utilisateur est considérée comme réussie. Ensuite, appeler SecurityUtils.getSubject() n'importe où dans l'application peut obtenir l'instance d'utilisateur actuellement authentifiée. Utiliser subject.isAuthenticated() pour déterminer si l'utilisateur a été authentifié retournera true
Au contraire, si la méthode de connexion est. exécuté, si une exception est levée, l'authentification sera considérée comme ayant échoué. Shiro dispose d'un riche ensemble de classes d'exceptions distinctes pour décrire les raisons des échecs d'authentification, telles que des exemples de code.

2. Opération de déconnexion
L'opération de déconnexion peut supprimer vos informations de connexion en appelant subject.logout(), par exemple :

currentUser.logout(); //removes all identifying information and invalidates their session too.

Une fois l'opération de déconnexion terminée, la session les informations seront effacées et le sujet sera considéré comme un utilisateur anonyme.

3. Mécanisme de traitement interne de l'authentification
Ce qui précède est le processus de traitement de l'authentification Shiro dans l'application. Le mécanisme de traitement interne de l'authentification Shiro sera expliqué en détail ci-dessous.

Comme indiqué ci-dessus, nous utilisons la partie authentification du diagramme d'architecture Shiro pour illustrer la séquence de traitement interne de l'authentification Shiro :
1 L'application construit une fin-. informations d'authentification de l'utilisateur Après l'instance AuthenticationToken, appelez la méthode Subject.login.
2. L'instance de Sbuject est généralement un objet instance de la classe (ou sous-classe) DelegatingSubject. Lorsque l'authentification démarre, l'instance securityManager définie par l'application est déléguée pour appeler la méthode securityManager.login(token).
3. Après avoir reçu les informations du jeton (jeton), SecurityManager confiera à une instance de l'authentificateur intégré (généralement une instance de la classe ModularRealmAuthenticator) d'appeler l'authentificateur.authenticate(token) définira un ou plusieurs domaines. les instances sont adaptées, ce qui fournit en fait un mécanisme d'authentification enfichable pour Shiro.
4. Si plusieurs domaines sont configurés dans l'application, ModularRealmAuthenticator effectuera le processus d'authentification multi-domaines selon la stratégie d'authentification configurée (stratégie d'authentification). Une fois Realm appelé, AuthenticationStrategy répondra à chaque résultat Realm.
Remarque : Si un seul Realm est configuré dans l'application, Realm sera appelé directement sans configurer la politique d'authentification.
5. Déterminez si chaque domaine prend en charge le jeton soumis. Si tel est le cas, Realm appellera getAuthenticationInfo(token) ; la méthode getAuthenticationInfo est le traitement d'authentification réel. Nous écrivons notre traitement d'authentification personnalisé en remplaçant la méthode doGetAuthenticationInfo de Realm.

4. Mécanisme de traitement utilisant plusieurs domaines :

1. Authentificateur
L'implémentation par défaut est ModularRealmAuthenticator, qui prend en charge à la fois un seul domaine et plusieurs domaines. Si un seul domaine est configuré, ModularRealmAuthenticator appellera directement le domaine pour traiter les informations d'authentification. Si plusieurs domaines sont configurés, il adaptera le domaine en fonction de la politique d'authentification et trouvera le domaine approprié pour exécuter les informations d'authentification.
Personnaliser la configuration de l'authentificateur :

[main]  
...  
authenticator = com.foo.bar.CustomAuthenticator  
securityManager.authenticator = $authenticator

2、AuthenticationStrategy（认证策略） 
当应用程序配置了多个Realm时，ModularRealmAuthenticator将根据认证策略来判断认证成功或是失败。 
例如，如果只有一个Realm验证成功，而其他Realm验证失败，那么这次认证是否成功呢？如果大多数的Realm验证成功了，认证是否就认为成功呢？或者，一个Realm验证成功后，是否还需要判断其他Realm的结果？认证策略就是根据应用程序的需要对这些问题作出决断。 
认证策略是一个无状态的组件，在认证过程中会经过4次的调用： 

在所有Realm被调用之前

在调用Realm的getAuthenticationInfo 方法之前

在调用Realm的getAuthenticationInfo 方法之后

在所有Realm被调用之后

认证策略的另外一项工作就是聚合所有Realm的结果信息封装至一个AuthenticationInfo实例中，并将此信息返回，以此作为Subject的身份信息。 
Shiro有3中认证策略的具体实现： 

AtLeastOneSuccessfulStrategy     只要有一个（或更多）的Realm验证成功，那么认证将被视为成功    

FirstSuccessfulStrategy     第一个Realm验证成功，整体认证将被视为成功，且后续Realm将被忽略    

AllSuccessfulStrategy     所有Realm成功，认证才视为成功    

ModularRealmAuthenticator 内置的认证策略默认实现是AtLeastOneSuccessfulStrategy 方式，因为这种方式也是被广泛使用的一种认证策略。当然，你也可以通过配置文件定义你需要的策略，如： 

[main]  
...  
authcStrategy = org.apache.shiro.authc.pam.FirstSuccessfulStrategy  
securityManager.authenticator.authenticationStrategy = $authcStrategy  
...

3、Realm的顺序 
由刚才提到的认证策略，可以看到Realm在ModularRealmAuthenticator 里面的顺序对认证是有影响的。 
ModularRealmAuthenticator 会读取配置在SecurityManager里的Realm。当执行认证是，它会遍历Realm集合，对所有支持提交的token的Realm调用getAuthenticationInfo 。 
因此，如果Realm的顺序对你使用的认证策略结果有影响，那么你应该在配置文件中明确定义Realm的顺序，如： 

blahRealm = com.company.blah.Realm  
...  
fooRealm = com.company.foo.Realm  
...  
barRealm = com.company.another.Realm  
  
securityManager.realms = $fooRealm, $barRealm, $blahRealm

以上就是Apache Shiro 使用手册（二）Shiro 认证的内容，更多相关内容请关注PHP中文网（m.sbmmt.com）！