简单的Spring整合Shiro
<!-- SECURITY begin --><dependency> <groupId>org.apache.shiro</groupId> <artifactId>shiro-spring</artifactId> <version>${shiro.version}</version></dependency><dependency> <groupId>org.apache.shiro</groupId> <artifactId>shiro-ehcache</artifactId> <version>${shiro.version}</version></dependency><!-- SECURITY end --><!-- CACHE begin --><dependency> <groupId>net.sf.ehcache</groupId> <artifactId>ehcache-core</artifactId> <version>${ehcache.version}</version></dependency><!-- CACHE end --><dependency> <groupId>commons-codec</groupId> <artifactId>commons-codec</artifactId> <version>${commons-codec.version}</version></dependency>
?
?
二、加密方式这里对选择的加密方式为，用户的password使用salt并迭代N次的sha-1式加密
salt是一组随机定长的byte数字，一般用byte数组装载
本文中用salt加密1024次，salt数组长度为8
用到了加密和解密，过程中用到了commons-codec，由于比较麻烦，所以借用springside中的utils，内容如下
?
Digestsimport java.io.IOException;import java.io.InputStream;import java.security.GeneralSecurityException;import java.security.MessageDigest;import java.security.SecureRandom;import org.apache.commons.lang3.Validate;import com.gqshao.common.exception.Exceptions;public class Digests { private static final String SHA1 = "SHA-1"; private static final String MD5 = "MD5"; private static SecureRandom random = new SecureRandom(); /** * 对输入字符串进行sha1散列. */ public static byte[] sha1(byte[] input) { return digest(input, SHA1, null, 1); } public static byte[] sha1(byte[] input, byte[] salt) { return digest(input, SHA1, salt, 1); } public static byte[] sha1(byte[] input, byte[] salt, int iterations) { return digest(input, SHA1, salt, iterations); } /** * 对字符串进行散列, 支持md5与sha1算法. */ private static byte[] digest(byte[] input, String algorithm, byte[] salt, int iterations) { try { MessageDigest digest = MessageDigest.getInstance(algorithm); if (salt != null) { digest.update(salt); } byte[] result = digest.digest(input); for (int i = 1; i < iterations; i++) { digest.reset(); result = digest.digest(result); } return result; } catch (GeneralSecurityException e) { throw Exceptions.unchecked(e); } } /** * 生成随机的Byte[]作为salt. * * @param numBytes byte数组的大小 */ public static byte[] generateSalt(int numBytes) { Validate.isTrue(numBytes > 0, "numBytes argument must be a positive integer (1 or larger)", numBytes); byte[] bytes = new byte[numBytes]; random.nextBytes(bytes); return bytes; } /** * 对文件进行md5散列. */ public static byte[] md5(InputStream input) throws IOException { return digest(input, MD5); } /** * 对文件进行sha1散列. */ public static byte[] sha1(InputStream input) throws IOException { return digest(input, SHA1); } private static byte[] digest(InputStream input, String algorithm) throws IOException { try { MessageDigest messageDigest = MessageDigest.getInstance(algorithm); int bufferLength = 8 * 1024; byte[] buffer = new byte[bufferLength]; int read = input.read(buffer, 0, bufferLength); while (read > -1) { messageDigest.update(buffer, 0, read); read = input.read(buffer, 0, bufferLength); } return messageDigest.digest(); } catch (GeneralSecurityException e) { throw Exceptions.unchecked(e); } }}
?
?
?
Encodesimport java.io.UnsupportedEncodingException;import java.net.URLDecoder;import java.net.URLEncoder;import org.apache.commons.codec.DecoderException;import org.apache.commons.codec.binary.Base64;import org.apache.commons.codec.binary.Hex;import org.apache.commons.lang3.StringEscapeUtils;import com.gqshao.common.exception.Exceptions;public class Encodes { private static final String DEFAULT_URL_ENCODING = "UTF-8"; private static final char[] BASE62 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" .toCharArray(); /** * Hex编码. */ public static String encodeHex(byte[] input) { return Hex.encodeHexString(input); } /** * Hex解码. */ public static byte[] decodeHex(String input) { try { return Hex.decodeHex(input.toCharArray()); } catch (DecoderException e) { throw Exceptions.unchecked(e); } } /** * Base64编码. */ public static String encodeBase64(byte[] input) { return Base64.encodeBase64String(input); } /** * Base64编码, URL安全(将Base64中的URL非法字符'+'和'/'转为'-'和'_', 见RFC3548). */ public static String encodeUrlSafeBase64(byte[] input) { return Base64.encodeBase64URLSafeString(input); } /** * Base64解码. */ public static byte[] decodeBase64(String input) { return Base64.decodeBase64(input); } /** * Base62编码。 */ public static String encodeBase62(byte[] input) { char[] chars = new char[input.length]; for (int i = 0; i < input.length; i++) { chars[i] = BASE62[((input[i] & 0xFF) % BASE62.length)]; } return new String(chars); } /** * Html 转码. */ public static String escapeHtml(String html) { return StringEscapeUtils.escapeHtml4(html); } /** * Html 解码. */ public static String unescapeHtml(String htmlEscaped) { return StringEscapeUtils.unescapeHtml4(htmlEscaped); } /** * Xml 转码. */ public static String escapeXml(String xml) { return StringEscapeUtils.escapeXml(xml); } /** * Xml 解码. */ public static String unescapeXml(String xmlEscaped) { return StringEscapeUtils.unescapeXml(xmlEscaped); } /** * URL 编码, Encode默认为UTF-8. */ public static String urlEncode(String part) { try { return URLEncoder.encode(part, DEFAULT_URL_ENCODING); } catch (UnsupportedEncodingException e) { throw Exceptions.unchecked(e); } } /** * URL 解码, Encode默认为UTF-8. */ public static String urlDecode(String part) { try { return URLDecoder.decode(part, DEFAULT_URL_ENCODING); } catch (UnsupportedEncodingException e) { throw Exceptions.unchecked(e); } }}
?
?
?
?
用法如下:
// 得到8位盐byte[] salts = Digests.generateSalt(SALT_SIZE);// 将8位byte数组装换为springString salt = Encodes.encodeHex(salts);// 将spring数组转化为8位byte数组salts = Encodes.decodeHex(salt);// 原密码String password = "123456";// 对密码加盐进行1024次SHA1加密byte[] hashPassword = Digests.sha1(password.getBytes(), salts, 1024);// 将加密后的密码数组转换成字符串password = Encodes.encodeHex(hashPassword);
?
简单说一下就是用户输入密码，系统自动生成盐，并对密码加密。然后将盐的字符串跟加密后的密码字符串保存到数据库中。
?
?
三、配置1.web.xml主要内容如下，其他的如spring和MVC框架等配置自行添加
<context-param> <param-name>spring.profiles.default</param-name> <param-value>development</param-value></context-param><context-param> <param-name>contextConfigLocation</param-name> <param-value> classpath*:/applicationContext.xml classpath*:/activiti/applicationContext-security.xml</param-value></context-param><!-- Shiro Security filter --><filter> <filter-name>shiroFilter</filter-name> <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class></filter><filter-mapping> <filter-name>shiroFilter</filter-name> <url-pattern>/*</url-pattern> <dispatcher>REQUEST</dispatcher> <dispatcher>FORWARD</dispatcher></filter-mapping>
?
?
可以看到shiro是通过filter进行过滤的，所以如果还有其他filter注意放的位置，比如org.springframework.web.filter.CharacterEncodingFilter要放到前面，com.opensymphony.sitemesh.webapp.SiteMeshFilter这种就要放到它的后面。
?
2.applicationContext-shiro.xml和ehcache-shiro.xml
这两个配置文件是shiro的主要配置文件
applicationContext-shiro.xml
<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:util="http://www.springframework.org/schema/util"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsdhttp://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd"default-lazy-init="true"> <description>Shiro安全配置</description> <!-- Shiro's main business-tier object for web-enabled applications --> <bean id="securityManager" ref="shiroDbRealm" /> <property name="cacheManager" ref="shiroEhcacheManager" /> </bean> <!-- 目自定义的Realm --> <bean id="shiroDbRealm" /> <!-- Shiro Filter --> <bean id="shiroFilter" ref="securityManager" /> <!-- 用于调用Controller --> <property name="loginUrl" value="/login" /> <property name="successUrl" value="/" /> <!-- 自己实现的formAuthcFilter，加入key type--> <property name="filters"> <util:map> <entry key="authc"> <bean value="classpath:security/ehcache-shiro.xml" /> </bean> <!-- 保证实现了Shiro内部lifecycle函数的bean执行 --> <bean id="lifecycleBeanPostProcessor" /> <!-- AOP式方法级权限检查 --> <bean depends-on="lifecycleBeanPostProcessor"> <property name="proxyTargetClass" value="true" /> </bean> <bean ref="securityManager" /> </bean></beans>
?
注意:
1.com.myapp.rbac.authentication.ShiroDbRealm和com.myapp.rbac.authentication.CustomFormAuthenticationFilter是自定义的文件，一会儿有相关说明
2.shiroFilter属性中loginUrl会被ShiroFilter监控起来
3.shiroFilter属性中loginUrl会被successUrl是成功后返回的路径，这里面设置为“ / ”的原因是用的spring mvc
?
ehcache-shiro.xml
<ehcache updateCheck="false" name="shiroCache"> <defaultCache maxElementsInMemory="10000" eternal="false" timeToIdleSeconds="120" timeToLiveSeconds="120" overflowToDisk="false" diskPersistent="false" diskExpiryThreadIntervalSeconds="120" /></ehcache>
?
?
四.实现类为了演示自定义，所以从login.jsp(自己实现有个POST方法提交的表单即可)开始都有一个叫"custom"的无意义字段，实际项目中可以按需求选择方案，不一定自定义，直接用UsernamePasswordToken也很好。
1.authcToken及其实现类用于将前端页面传入的参数封装成Token，传给登陆认证的方法。常用的有org.apache.shiro.authc.UsernamePasswordToken。
这里自己实现了一个类
package com.myapp.rbac.authentication.token;import org.apache.commons.lang3.StringUtils;import org.apache.shiro.authc.HostAuthenticationToken;import org.apache.shiro.authc.RememberMeAuthenticationToken;public class CustomToken implements HostAuthenticationToken, RememberMeAuthenticationToken { private String loginName; private String password; private String host; private boolean rememberMe = false; private String custom; public CustomToken() { } public CustomToken(String loginName, String password) { this(loginName, password, false, null, null); } public CustomToken(String loginName, String password, String host) { this(loginName, password, false, host, null); } public CustomToken(String loginName, String password, boolean rememberMe) { this(loginName, password, rememberMe, null, null); } public CustomToken(String loginName, String password, boolean rememberMe, String host, String custom) { this.loginName = loginName; this.password = password; this.rememberMe = rememberMe; this.host = host; this.custom = custom; } public Object getPrincipal() { return getLoginName(); } public Object getCredentials() { return getPassword(); } public String getHost() { return host; } public boolean isRememberMe() { return rememberMe; } public void clear() { this.loginName = null; this.host = null; this.password = null; this.rememberMe = false; this.custom = null; } public String toString() { StringBuilder sb = new StringBuilder(); sb.append(getClass().getName()); sb.append(" - "); sb.append(loginName); sb.append(", rememberMe=").append(rememberMe); if (StringUtils.isNotBlank(host)) { sb.append(" (").append(host).append(")"); } return sb.toString(); } public String getLoginName() { return loginName; } public void setLoginName(String loginName) { this.loginName = loginName; } public String getPassword() { return password; } public void setPassword(String password) { this.password = password; } public String getCustom() { return custom; } public void setCustom(String custom) { this.custom = custom; } public void setHost(String host) { this.host = host; } public void setRememberMe(boolean rememberMe) { this.rememberMe = rememberMe; }}??
?
?
2.User/Subject?
将一些期望保存的属性属性，封装成一个自定义POJO，会被放到session中
?
package com.myapp.rbac.authentication.domain;import java.util.List;import com.google.common.base.Objects;import com.gqshao.common.util.Identities;public class ShiroUser implements java.io.Serializable { private static final long serialVersionUID = -2649983064333269618L; private String id; private String loginName; private List<String> roles; private List<String> permissions; private String ip; // 记录额外的一些信息 private String custom; public ShiroUser() { } public ShiroUser(User user) { this.id = Identities.uuid(); this.loginName = user.getLoginName(); } public ShiroUser(String id, String loginName, String ip, String custom) { this.id = id; this.loginName = loginName; this.ip = ip; this.custom = custom; } public String getId() { return id; } public void setId(String id) { this.id = id; } public List<String> getRoles() { return roles; } public void setRoles(List<String> roles) { this.roles = roles; } public List<String> getPermissions() { return permissions; } public void setPermissions(List<String> permissions) { this.permissions = permissions; } public String getIp() { return ip; } public void setIp(String ip) { this.ip = ip; } public String getLoginName() { return loginName; } public void setLoginName(String loginName) { this.loginName = loginName; } @Override public int hashCode() { return Objects.hashCode(id, loginName, custom); } public String toString() { return id + ":" + loginName + "- " + custom; } @Override public boolean equals(Object obj) { if (obj == null) { return false; } else if (this.hashCode() == obj.hashCode()) { return true; } else { return false; } }}?
?
?
3.AuthenticatingFilter及其实现类
AuthenticatingFilter主要与将前端提交的表单信息封装成Token，与authcToken的实现类要对应起来。比如与org.apache.shiro.authc.UsernamePasswordToken对应的是org.apache.shiro.web.filter.authc.FormAuthenticationFilter。
这里需要自定义一个CustomFormAuthenticationFilter，用于配合CustomToken。
?
package com.myapp.rbac.authentication.filter;import javax.servlet.ServletRequest;import javax.servlet.ServletResponse;import javax.servlet.http.HttpServletRequest;import org.apache.shiro.authc.AuthenticationException;import org.apache.shiro.authc.AuthenticationToken;import org.apache.shiro.subject.Subject;import org.apache.shiro.web.filter.authc.AuthenticatingFilter;import org.apache.shiro.web.util.WebUtils;import org.slf4j.Logger;import org.slf4j.LoggerFactory;public class CustomFormAuthenticationFilter extends AuthenticatingFilter { private static final Logger log = LoggerFactory.getLogger(CustomFormAuthenticationFilter.class); public static final String DEFAULT_ERROR_KEY_ATTRIBUTE_NAME = "shiroLoginFailure"; public static final String DEFAULT_LOGINNAME_PARAM = "loginName"; public static final String DEFAULT_PASSWORD_PARAM = "password"; public static final String DEFAULT_REMEMBER_ME_PARAM = "rememberMe"; // 自定义的输入字段 public static final String DEFAULT_CUSTOM_PARAM = "custom"; private String loginNameParam = DEFAULT_LOGINNAME_PARAM; private String passwordParam = DEFAULT_PASSWORD_PARAM; private String rememberMeParam = DEFAULT_REMEMBER_ME_PARAM; private String customParam = DEFAULT_CUSTOM_PARAM; private String failureKeyAttribute = DEFAULT_ERROR_KEY_ATTRIBUTE_NAME; public CustomFormAuthenticationFilter() { setLoginUrl(DEFAULT_LOGIN_URL); } @Override public void setLoginUrl(String loginUrl) { String previous = getLoginUrl(); if (previous != null) { this.appliedPaths.remove(previous); } super.setLoginUrl(loginUrl); if (log.isTraceEnabled()) { log.trace("Adding login url to applied paths."); } this.appliedPaths.put(getLoginUrl(), null); } /** * 在访问被拒绝 */ @Override protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception { if (isLoginRequest(request, response)) { if (isLoginSubmission(request, response)) { if (log.isTraceEnabled()) { log.trace("Login submission detected. Attempting to execute login."); } return executeLogin(request, response); } else { if (log.isTraceEnabled()) { log.trace("Login page view."); } return true; } } else { if (log.isTraceEnabled()) { log.trace("Attempting to access a path which requires authentication. Forwarding to the " + "Authentication url [" + getLoginUrl() + "]"); } saveRequestAndRedirectToLogin(request, response); return false; } } /** * 创建自定义的令牌 */ @Override protected AuthenticationToken createToken(ServletRequest request, ServletResponse response) { String loginName = getLoginName(request); String password = getPassword(request); boolean rememberMe = isRememberMe(request); String host = getHost(request); String custom = getCustom(request); return new CustomToken(loginName, password, rememberMe, host, custom); } protected boolean isLoginSubmission(ServletRequest request, ServletResponse response) { return (request instanceof HttpServletRequest) && WebUtils.toHttp(request).getMethod().equalsIgnoreCase(POST_METHOD); } protected boolean isRememberMe(ServletRequest request) { return WebUtils.isTrue(request, getRememberMeParam()); } protected boolean onLoginSuccess(AuthenticationToken token, Subject subject, ServletRequest request, ServletResponse response) throws Exception { issueSuccessRedirect(request, response); return false; } protected boolean onLoginFailure(AuthenticationToken token, AuthenticationException e, ServletRequest request, ServletResponse response) { setFailureAttribute(request, e); return true; } protected void setFailureAttribute(ServletRequest request, AuthenticationException ae) { String className = ae.getClass().getName(); request.setAttribute(getFailureKeyAttribute(), className); } protected String getLoginName(ServletRequest request) { return WebUtils.getCleanParam(request, getLoginNameParam()); } protected String getPassword(ServletRequest request) { return WebUtils.getCleanParam(request, getPasswordParam()); } protected String getCustom(ServletRequest request) { return WebUtils.getCleanParam(request, getCustomParam()); } public String getLoginNameParam() { return loginNameParam; } public void setLoginNameParam(String loginNameParam) { this.loginNameParam = loginNameParam; } public String getPasswordParam() { return passwordParam; } public void setPasswordParam(String passwordParam) { this.passwordParam = passwordParam; } public String getRememberMeParam() { return rememberMeParam; } public void setRememberMeParam(String rememberMeParam) { this.rememberMeParam = rememberMeParam; } public String getCustomParam() { return customParam; } public void setCustomParam(String customParam) { this.customParam = customParam; } public String getFailureKeyAttribute() { return failureKeyAttribute; } public void setFailureKeyAttribute(String failureKeyAttribute) { this.failureKeyAttribute = failureKeyAttribute; }}?
?
?
4.Realm实现
Realm用于登陆认证和权限的鉴权工作
?
package com.myapp.rbac.authentication.realm;import java.util.ArrayList;import java.util.List;import javax.annotation.PostConstruct;import org.apache.shiro.authc.AuthenticationException;import org.apache.shiro.authc.AuthenticationInfo;import org.apache.shiro.authc.AuthenticationToken;import org.apache.shiro.authc.SimpleAuthenticationInfo;import org.apache.shiro.authc.credential.HashedCredentialsMatcher;import org.apache.shiro.authz.AuthorizationInfo;import org.apache.shiro.authz.SimpleAuthorizationInfo;import org.apache.shiro.realm.AuthorizingRealm;import org.apache.shiro.subject.PrincipalCollection;import org.apache.shiro.util.ByteSource;import org.springframework.beans.factory.annotation.Autowired;import com.myapp.rbac.authentication..domain.ShiroUser;import com.genertech.commons.core.utils.Encodes;import com.myapp.rbac.authentication.token.CustomToken;import com.myapp.rbac.domain.Permission;import com.myapp.rbac.domain.Role;import com.myapp.rbac.domain.User;import com.myapp.rbac.service.PermissionService;import com.myapp.rbac.service.RoleService;import com.myapp.rbac.service.UserService;public class ShiroDbRealm extends AuthorizingRealm { public static final String HASH_ALGORITHM = "SHA-1"; public static final int SALT_SIZE = 8; public static final int HASH_INTERATIONS = 1024; @Autowired private UserService userService; @Autowiredprotected PermissionService permissionService;@Autowiredprotected RoleService roleService; public ShiroDbRealm() { super(); setAuthenticationTokenClass(CustomToken.class); } /** * 认证回调函数,登录时调用. */ @Override protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authcToken){ CustomToken token = (CustomToken) authcToken; String loginName = token.getLoginName(); String host = token.getHost(); User user = userService.getUserByLoginName(loginName); if (user != null) { ShiroUser root = new ShiroUser(user.getId(), loginName, user.getName(), user.getIsAdmin() == 1 ? true : false, host); byte[] salt = Encodes.decodeHex(user.getSalt()); return new SimpleAuthenticationInfo(root, user.getPassword(), ByteSource.Util.bytes(salt), getName()); } else { return null; } } /** * 授权查询回调函数, 进行鉴权但缓存中无用户的授权信息时调用. */ @Override protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) { ShiroUser shiroUser = (ShiroUser) principals.getPrimaryPrincipal();SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();List<Role> roleList = null;// 角色集合//List<String> pList = new ArrayList<String>();List<Permission> listP = null;// 权限集合//if (shiroUser.isAdmin()) {// 超级管理员获取所有角色//roleList = roleService.getAll();// 超级管理员获取所有权限//listP = permissionService.getAllPermissions();} else {roleList = roleService.getRolesByUserId(shiroUser.getId());listP = permissionService.getByUserId(shiroUser.getId());}// 遍历角色//for (Role role : roleList) {info.addRole(role.getName());}// 遍历权限//for (Permission per : listP) {if (per != null) {String[] ps = per.getCode().split(";");for (int i = 0; i < ps.length; i++) {pList.add(ps[i]);}}}if (shiroUser.isAdmin()) {pList.add("permissionmgt:administrator");}// 基于Permission的权限信息//info.addStringPermissions(pList);return info; } /** * 设定Password校验的Hash算法与迭代次数. */ @PostConstruct public void initCredentialsMatcher() { HashedCredentialsMatcher matcher = new HashedCredentialsMatcher(HASH_ALGORITHM); matcher.setHashIterations(HASH_INTERATIONS); setCredentialsMatcher(matcher); }}?
注意
1.实现登陆的前提是通过POST方法，提交到 loginUrl 配置的路径上。
2.doGetAuthenticationInfo完成登陆的认证工作。Shiro通过return的SimpleAuthenticationInfo中的参数，自动判断password是否正确。再次提醒，user保存在数据库中的password是通过salt加密过的密码；
3.认证的方法通过initCredentialsMatcher设置；
4.doGetAuthorizationInfo方法完成的是鉴权工作，这里需要注意的事情是，由于权限和角色都是通过整合Ehcache，缓存起来，所以当缓存失效的时候，会再次鉴权。
5.注意权限定义中 : 号有特殊用途,不要随便使用。
?
5.控制器
最后完成一个控制器，用于登陆跳转到登陆页面，或登陆失败后的页面调整
这里用的是spring mvc
?
@Controllerpublic class LoginController { Logger logger = LoggerFactory.getLogger(LoginController.class); @RequestMapping(value = "/login", method = RequestMethod.GET) public String login(Model model) { return "common/login"; } @RequestMapping(value = "/login", method = RequestMethod.POST) public String fail(@RequestParam(CustomFormAuthenticationFilter.DEFAULT_LOGINNAME_PARAM) String userName, Model model) { model.addAttribute(CustomFormAuthenticationFilter.DEFAULT_LOGINNAME_PARAM, userName); return "common/login"; }}?
?
五.使用JSP内容控制
页面部分可以通过导入 ?<%@ taglib prefix="shiro" uri="http://shiro.apache.org/tags" %> 使用标签
常用的有hasPermission、hasAnyRole等，参考http://shiro.apache.org/web.html#Web-taglibrary
?
方法级控制
@RequiresPermissions("User:Edit")
@RequiresRoles(value = { "Admin", "User" }, logical = Logical.OR)等等
可以参考http://shiro.apache.org/authorization.html#Authorization-ProgrammaticAuthorization
?
通过Shiro保存到Session中的对象可以通过以下方法得到
Subject shiroUser = SecurityUtils.getSubject();
?
?
六. 概念
。
Authentication
身份验证是验证Subject 身份的过程——实质上是证明某些人是否真的是他们所说的他们是谁。当认证尝试成
功后，应用程序能够相信该subject 被保证是其所期望的。
?Authorization
授权，又称为访问控制，是决定一个user/Subject 是否被允许做某事的过程。它通常是通过检查和解释。?
?
?Subject
的角色和权限（见下文），然后允许或拒绝到一个请求的资源或功能来完成的。
Cipher
密码是进行加密或解密的一种算法。该算法一般依赖于一块被称为key 的信息。基于不同的key 的加密算法
也是不一样的，所有解密没有它是非常困难的。
密码有不同的表现形式。分组密码致力于符号块，通常是固定大小的，而流密码致力于连续的符号流。对称
性密码加密和解密使用相同的密钥（key），而非对称性加密使用不同的密钥。如果非对称性加密的密钥不能
从其他地方得到，那么可以创建公钥/私钥对公开共享。
Credential
凭证是一块信息，用来验证user/Subject 的身份。在认证尝试期间，一个（或多个）凭证与Principals(s)被一
同提交，来验证user/Subject 所提交的确实是所关联的用户。证书通常是非常秘密的东西，只有特定的
user/Subject 才知道，如密码或PGP 密钥或生物属性或类似的机制。
这个想法是为principal 设置的，只有一个人会知道正确的证书来“匹配”该principal。如果当前user/Subject
提供了正确的凭证匹配了存储在系统中的，那么系统可以假定并信任当前user/Subject 是真的他们所说的他们
是谁。信任度随着更安全的凭证类型加深（如，生物识别签名 > 密码）。
Cryptography
加密是保护信息不受不希望的访问的习惯做法，通过隐藏信息或将它转化成无意义的东西，这样没人可以理
解它。Shiro 致力于加密的两个核心要素：加密数据的密码，如使用公钥或私钥的邮件，以及散列表（也称消
息摘要），它对数据进行不可逆的加密，如密码。
Hash
散列函数是单向的，不可逆转的输入源，有时也被称为消息，在一个编码的哈希值内部，有时也被称为消息
摘要。它通常用于密码，数字指纹，或以字节数组为基础的数据。
Permission
权限，至少按照Shiro 的解释，是在应用程序中描述原始功能的一份声明并没有更多的功能。权限是在安全策
略中最低级别的概念。它们仅定义了应用程序能够做“什么”。它们没有说明“谁”能够执行这些操作。权
限只是行为的声明，仅此而已。
一些权限的例子：
打开文件
浏览'/user/list'页面
打印文档
删除'jsmith'用户
Principal
Principal 是一个应用程序用户（Subject）的任何标志属性。“标志属性”可以是任何对你应用程序有意义的东
西——用户名，姓，名，社会安全号码，用户ID 等。这就是它——没什么古怪的。
Shiro 也引用一些我们称之为Subject 的primary principal 的东西。一个primary principal 是在整个应用程序中唯
一标识Subject 的principal。理想的primary principal 是用户名或RDBMS 用户表主键——用户ID。对于在应用
程序中的用户（Subject）来说，只有一个primary principal
Realm
Realm 是一个能够访问应用程序特定的安全数据（如用户，角色和权限）的组件。它可以被看作是一个特定
安全的DAO—ata Access Object）。Realm 将这些应用程序特定的数据转换成Shiro 能够理解的格式，这样Shiro
反过来能够提供一个单一的易于理解的Subject 编程API，无论有多少数据源存在或无论你的数据是什么样的
应用程序特定的格式。
Realm 通常和数据源是一对一的对应关系，如关系数据库，LDAP 目录，文件系统，或其他类似资源。因此，
Realm 接口的实现使用数据源特定的API 来展示授权数据（角色，权限等），如JDBC，文件IO，Hibernate 或
JPA，或其他数据访问API。
Role
基于你对话的对象，一个角色的定义是可以多变的。在许多应用程序中，它充其量是个模糊不清的概念，人
们用它来隐式定义安全策略。Shiro 偏向于把角色简单地解释为一组命名的权限的集合。这就是它——一个应
用程序的唯一名称，聚集一个或多个权限声明。
这是一个比许多应用程序使用的隐式的定义更为具体的定义。如果你选择了你的数据模型反映Shiro 的假设，
你会发现将有更多控制安全策略的权力。
Session
会话是一个在一段时间内有状态的数据，其上下文与一个单一的与软件系统交互的user/Subject 相关联。当
Subject 使用应用程序时，能够从会话中添加/读取/删除数据，并且应用程序稍后能够在需要的地方使用该数
据。会话会被终止，由于user/Subject 注销或会话不活动而超时。
对于那些熟悉HttpSession 的，Shiro Session 服务于同一目标，除了Shiro 会话能够在任何环境下使用，甚至在
没有Servlet 容器或EJB 容器的环境。
Subject
Subject 只是一个精挑细选的安全术语，基本上的意思是一个应用程序用户的安全特定的“视图”。然而Subject
不总是需要反映为一个人——它可以代表一个调用你应用程序的外部进程，或许是一个系统帐户的守护进程，
在一段时间内执行一些间歇性的东西（如一个cron job）。它基本上是任何使用应用程序做某事的实体的一个
代表。
?
?
?
?
?
