创办属于别的Session的经过

 
创建其他Session(User)的进程需要拿到对应Session的Token作为CreateProcessAsUser的参数来启动进程。 

  1. 使用 JWT 做权限验证,相比 Session 的优点是,Session
    需要占用大量服务器内存,并且在多服务器时就会涉及到共享 Session
    问题,在手机等移动端访问时比较麻烦
  2. 而 JWT 无需存储在服务器,不占用服务器资源,用户在登录后拿到 Token
    后,访问需要权限的请求时附上 Token(一般设置在Http请求头),JWT
    不存在多服务器共享的问题,也没有手机移动端访问问题,若为了提高安全,可将
    Token 与用户的 IP 地址绑定起来案例源码下载

Windows 7已经隆重发布,但是很多程序员已经通过RTM等版本尝到了Windows
7的甜处。那么在Windows 7下用户界面特权隔离,将是本文我们介绍的重点。

一、发展史

1、最初、Web基本上就是文档的浏览而已,既然是浏览,作为服务器,不需要记录谁在某一段时间里都浏览了什么文档,每次请求都是一个新的HTTP协议,就是请求加相应,尤其是我不用记住是谁刚刚发了HTTP请求,每个请求对我来说都是全新的。
2、但是随着交互式Web应用的兴起,像在线购物网站,需要登录的网站等等,马上就面临一个问题,那就是要管理回话,必须记住哪些人登录系统,那些人往自己的购物车中放商品,也就是说必须把每个人区分开,这就是一个不小的挑战,因为HTTP请求是无状态,所以想出办法就是给大家发一个回话标识(session id),说白了就是一个随机的字串,每个人收到的都不一样,每次大家向我发起HTTP请求的时候,把这个字符串一并捎来,这样就能区分开谁是谁了
3、每个人只需要保存自己的session id,而服务器要保存所有人的session id!如果访问服务器多了,就得成千上万,甚至几十万个。
这对服务器说是一个巨大的开销,严重的限制了服务器的扩展能力,比如说我用两个服务器组成了一个集群,小F通过机器A登录了系统,那session id会保存在机器A上,假设小F的下一次请求被转发到机器B怎么办?机器B可没有小F的session id。
有时候会采用下小伎俩:session sticky,就是让小F的请求一直粘连在机器上,但是这也不管用,要是机器A挂掉了,还得转到机器B去。那只好做session的复制了,把session id在两个机器之间搬来搬去,快累死了。

永利官网ylg客户端 1

后来有个叫memcached的支了招:把session id集中存储到一个地方,所有的机器都来访问这个地方的数据,这样以来,就不用复制了,但是增加了单点失败的可能性,要是负责session的机器挂了,所有人都得重新登录一遍。

永利官网ylg客户端 2

也尝试把这个单点的机器也搞出集群,增加可靠性,但不管如何,这小小的session对我来说是一个沉重的负担
4、于是有人就思考,我为什么要保存sessions呢,只让每个客户端去保存session多好?
    可是如果不保存这些sessions id,怎么验证客户端发给我的sessiond id的确实是我生成的呢?如果不去验证,我们都不知道他们是不是合法登录的用户,那么不怀好意的家伙们就可以伪造session id,为所欲为了。
嗯,对了,关键点就是验证!
比如说,小F已经登录了系统,我给他发一个令牌(token),里面包含了小F的user id,下一次小F再次通过HTTP请求访问我的时候,把这个token通过HTTP header带过来不就可以了。
不过这和session id没有本质的区别啊,任何人都可以伪造,所以我得想点办法,让别人伪造不了。
那就对数据做一个签名吧,比如说我用HMAC-SHA256算法,加上一个只有我才知道的密钥,对数据做一个签名,把这个签名和数据一起作为token,由于密码别人不知道,就无法伪造token了。

永利官网ylg客户端 3

这个token我不保存,当小F把这个token给我发过来的时候,我再用同样的HMAC-SHA256算法和同样的密钥,对数据再计算一次签名,和token中的签名做个比较,如果相同,我就知道小F已经登录过了,并且可以直接取到小F的user id,如果不相同,数据部分肯定被人篡改过,我就告诉发送者:对不起,没有认证。

永利官网ylg客户端 4

Token中的数据是明文保存的(虽然我会用Base64做下编码,但那不是加密),还是可以被别人看到的,所以我不能在其中保存密码这样的敏感信息。
当然,如果一个人的token被别人偷走了,那我也没有办法,我也会认为小偷就是合法用户,这其实和一个人的sessions id被别人偷走是一样的。
这样以来,我就不保存session id了,我只是生成token,然后验证token,我用我的CPU计算时间获取了我的session存储空间!
解除了session id这个负担,可以说是无事一身轻,我的机器集群现在可以轻松地做水平扩展,用户访问量增大,直接加机器就行。这种无状态的感觉实在是太好了!

 
修改有System权限的Token的TokenId为其他Session的TokenId就可以在其他Session里面创建有System权限的进程了。

我们介绍了操作系统服务的Session 0隔离,通过Session 0隔离,Windows
7实现了各个Session之间的独立和更加安全的互访,使得操作系统的安全性有了较大的提高。从操作系统服务的Session
0隔离尝到了甜头后,雷德蒙的程序员们仿佛爱上了隔离这一招式。现在他们又将隔离引入了同一个Session之中的各个进程之间,带来全新的用户界面特权隔离。

二、Cookie

cookie是一个非常具体的东西,指的就是浏览器里面能永久存储的一种数据,仅仅是浏览器实现的一种数据存储功能。
cookie由服务器生存,发送给浏览器,浏览器把cookie以kv形式保存到某个目录下的文本文件内,下一次请求同一网站时会把该cookie发送给服务器。由于cookie是存在客户端上的,所以浏览器加入了一些限制确保cookie不会被恶意使用,同时不会占据太对磁盘空间,所以每个域的cookie数量是有限的。

  相关的Blog: 

  1. 用户通过 AJAX 进行登录得到一个 Token
  2. 之后访问需要权限请求时附上 Token 进行访问

用户界面特权隔离

三、Session

session从字面上讲,就是会话。这个就类似于你和一个人交谈,你怎么知道当前和你交谈的是张三而不是李四呢?对方肯定有某种特征(长相等)表明他就是张三。
session也是类似的道理,服务器要知道当前发请求给自己的是谁。为了做这种区分,服务器就要给每个客户端分配不同的“身份标识”,然后客户端每次向服务器发请求的时候,都带上这个“身份标识”,服务器就知道这个请求来自于谁了。至于客户端怎么保存这个“身份标识”,可以有很多种方法,对于浏览器客户端,大家都知道默认采用cookie的方式。
服务器使用session把用户的信息临时保存在了服务器上,用户离开网站后session会被销毁。这种用户信息存储方式相对于cookie来说更安全,可是session有一个缺陷:如果web服务器做了负载均衡,那么下一个操作请求到了另一个服务器的时候session会丢失。

在早期的Windows操作系统中,在同一用户下运行的所有进程有着相同的安全等级,拥有相同的权限。例如,一个进程可以自由地发送一个Windows消息到另外一个进程的窗口。从Windows
Vista开始,当然也包括Windows
7,对于某些Windows消息,这一方式再也行不通了。进程(或者其他的对象)开始拥有一个新的属性——特权等级(Privilege
Level)。一个特权等级较低的进程不再可以向一个特权等级较高的进程发送消息,虽然他们在相同的用户权限下运行。这就是所谓的用户界面特权隔离(User
Interface Privilege Isolation ,UIPI)。

四、Token

在Web领域基于Token的身份验证随处可见。在大多数使用Web
API的互联网公司中,tokens是多用户下处理认证的最佳方式。

以下几点特性会让你在程序中使用基于Token的身份验证

  1. 无状态、可扩展
  2. 支持移动设备
  3. 跨程序调用
  4. 安全
<!DOCTYPE html><html lang="en"><head> <meta charset="UTF-8"> <title>Title</title> <script src="http://apps.bdimg.com/libs/jquery/2.1.4/jquery.min.js"></script> <script type="application/javascript"> var header = ""; function login() { $.post("http://localhost:8080/auth/login", { username: $("#username").val(), password: $("#password").val() }, function  { console.log; header = data; }) } function toUserPageBtn() { $.ajax({ type: "get", url: "http://localhost:8080/userpage", beforeSend: function  { request.setRequestHeader("Authorization", header); }, success: function  { console.log; } }); } </script></head><body> <fieldset> <legend>Please Login</legend> <label>UserName</label><input type="text" > <label>Password</label><input type="text" > <input type="button" onclick="login()" value="Login"> </fieldset> <button onclick="toUserPageBtn()">访问UserPage</button></body></html>

UIPI的引入,最大的目的是防止恶意代码发送消息给那些拥有较高权限的窗口以对其进行攻击,从而获取较高的权限等等。这就像一个国家,原本人人平等,大家之间可以互相交流问候,但是后来坏人多了,为了防止坏人以下犯上,获得不该有的权利,就人为地给每个人划分等级,等级低的不可以跟等级高的说话交流。在人类社会,这是一种令人讨厌的等级制度,但是在计算机系统中,这却是一种维护系统安全的合适方式。

Token的起源

在介绍基于Token的身份验证的原理及优势之前,不妨先看看之前的认证都是怎么做的。

  • 基于服务器的验证

    我们都知道HTTP协议是无状态的,这种无状态意味着程序需要验证每一次请求,从而辨别客户端的身份。在这之前,程序都是通过在服务端存储的额登录信息来辨别请求的。这中方式一般都是通过存储session来完成的。
    下图展示了基于服务器验证的原理。

随着web应用程序,已经移动端的兴起,这种验证的方式逐渐暴露出了问题。尤其是在可扩展性方面。

思路:

  1. 创建用户、权限实体类与数据传输对象

  2. 编写 Dao 层接口,用于获取用户信息

  3. 实现 UserDetails(Security 支持的用户实体对象,包含权限信息)

  4. 实现
    UserDetailsSevice(从数据库中获取用户信息,并包装成UserDetails)

  5. 编写 JWTToken 生成工具,用于生成、验证、解析 Token

  6. 配置 Security,配置请求处理 与 设置 UserDetails 获取方式为自定义的
    UserDetailsSevice

  7. 编写 LoginController,接收用户登录名密码并进行验证,若验证成功返回
    Token 给用户

  8. 编写过滤器,若用户请求头或参数中包含 Token 则解析,并生成
    Authentication,绑定到 SecurityContext ,供 Security 使用

  9. 用户访问了需要权限的页面,却没附上正确的
    Token,在过滤器处理时则没有生成
    Authentication,也就不存在访问权限,则无法访问,否之访问成功

User实体类

@Data@Entitypublic class User { @Id @GeneratedValue private int id; private String name; private String password; @ManyToMany(cascade = {CascadeType.REFRESH}, fetch = FetchType.EAGER) @JoinTable(name = "user_role", joinColumns = {@JoinColumn(name = "uid", referencedColumnName = "id")}, inverseJoinColumns = {@JoinColumn(name = "rid", referencedColumnName = "id")}) private List<Role> roles;} 

Role实体类

@Data@Entitypublic class Role { @Id @GeneratedValue private int id; private String name; @ManyToMany(mappedBy = "roles") private List<User> users;}

插入数据

User 表

id name password
1 linyuan 123

Role 表

id name
1 USER

User_ROLE 表

uid rid
1 1

Dao 层接口,通过用户名获取数据,返回值为 Java8 的 Optional 对象

public interface UserRepository extends Repository<User,Integer> { Optional<User> findByName(String name);}

编写 LoginDTO,用于与前端之间数据传输

@Datapublic class LoginDTO implements Serializable { @NotBlank(message = "用户名不能为空") private String username; @NotBlank(message = "密码不能为空") private String password;}

编写 Token 生成工具,利用 JJWT 库创建,一共三个方法:生成 Token、解析
Token(返回Authentication认证对象)、验证 Token

@Componentpublic class JWTTokenUtils { private final Logger log = LoggerFactory.getLogger(JWTTokenUtils.class); private static final String AUTHORITIES_KEY = "auth"; private String secretKey; //签名密钥 private long tokenValidityInMilliseconds; //失效日期 private long tokenValidityInMillisecondsForRememberMe; //失效日期 @PostConstruct public void init() { this.secretKey = "Linyuanmima"; int secondIn1day = 1000 * 60 * 60 * 24; this.tokenValidityInMilliseconds = secondIn1day * 2L; this.tokenValidityInMillisecondsForRememberMe = secondIn1day * 7L; } private final static long EXPIRATIONTIME = 432_000_000; //创建Token public String createToken(Authentication authentication, Boolean rememberMe){ String authorities = authentication.getAuthorities().stream() //获取用户的权限字符串,如 USER,ADMIN .map(GrantedAuthority::getAuthority) .collect(Collectors.joining; long now = (new Date.getTime(); //获取当前时间戳 Date validity; //存放过期时间 if (rememberMe){ validity = new Date(now + this.tokenValidityInMilliseconds); }else { validity = new Date(now + this.tokenValidityInMillisecondsForRememberMe); } return Jwts.builder() //创建Token令牌 .setSubject(authentication.getName //设置面向用户 .claim(AUTHORITIES_KEY,authorities) //添加权限属性 .setExpiration //设置失效时间 .signWith(SignatureAlgorithm.HS512,secretKey) //生成签名 .compact(); } //获取用户权限 public Authentication getAuthentication(String token){ System.out.println("token:"+token); Claims claims = Jwts.parser() //解析Token的payload .setSigningKey(secretKey) .parseClaimsJws .getBody(); Collection<? extends GrantedAuthority> authorities = Arrays.stream(claims.get(AUTHORITIES_KEY).toString().split //获取用户权限字符串 .map(SimpleGrantedAuthority::new) .collect(Collectors.toList; //将元素转换为GrantedAuthority接口集合 User principal = new User(claims.getSubject(), "", authorities); return new UsernamePasswordAuthenticationToken(principal, "", authorities); } //验证Token是否正确 public boolean validateToken(String token){ try { Jwts.parser().setSigningKey(secretKey).parseClaimsJws; //通过密钥验证Token return true; }catch (SignatureException e) { //签名异常 log.info("Invalid JWT signature."); log.trace("Invalid JWT signature trace: {}", e); } catch (MalformedJwtException e) { //JWT格式错误 log.info("Invalid JWT token."); log.trace("Invalid JWT token trace: {}", e); } catch (ExpiredJwtException e) { //JWT过期 log.info("Expired JWT token."); log.trace("Expired JWT token trace: {}", e); } catch (UnsupportedJwtException e) { //不支持该JWT log.info("Unsupported JWT token."); log.trace("Unsupported JWT token trace: {}", e); } catch (IllegalArgumentException e) { //参数错误异常 log.info("JWT token compact of handler are invalid."); log.trace("JWT token compact of handler are invalid trace: {}", e); } return false; }}

实现 UserDetails 接口,代表用户实体类,在我们的 User
对象上在进行包装,包含了权限等性质,可以供 Spring Security 使用

public class MyUserDetails implements UserDetails{ private User user; public MyUserDetails(User user) { this.user = user; } @Override public Collection<? extends GrantedAuthority> getAuthorities() { List<Role> roles = user.getRoles(); List<GrantedAuthority> authorities = new ArrayList<>(); StringBuilder sb = new StringBuilder(); if (roles.size{ for (Role role : roles){ authorities.add(new SimpleGrantedAuthority(role.getName; } return authorities; } return AuthorityUtils.commaSeparatedStringToAuthorityList; } @Override public String getPassword() { return user.getPassword(); } @Override public String getUsername() { return user.getName(); } @Override public boolean isAccountNonExpired() { return true; } @Override public boolean isAccountNonLocked() { return true; } @Override public boolean isCredentialsNonExpired() { return true; } @Override public boolean isEnabled() { return true; }}

实现 UserDetailsService 接口,该接口仅有一个方法,用来获取
UserDetails,我们可以从数据库中获取 User 对象,然后将其包装成
UserDetails 并返回

@Servicepublic class MyUserDetailsService implements UserDetailsService { @Autowired UserRepository userRepository; @Override public UserDetails loadUserByUsername throws UsernameNotFoundException { //从数据库中加载用户对象 Optional<User> user = userRepository.findByName; //调试用,如果值存在则输出下用户名与密码 user.ifPresent->System.out.println("用户名:"+value.getName()+" 用户密码:"+value.getPassword; //若值不再则返回null return new MyUserDetails(user.orElse; }}

编写过滤器,用户如果携带 Token 则获取 Token,并根据 Token 生成
Authentication 认证对象,并存放到 SecurityContext 中,供 Spring
Security 进行权限控制

public class JwtAuthenticationTokenFilter extends GenericFilterBean { private final Logger log = LoggerFactory.getLogger(JwtAuthenticationTokenFilter.class); @Autowired private JWTTokenUtils tokenProvider; @Override public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException { System.out.println("JwtAuthenticationTokenFilter"); try { HttpServletRequest httpReq = (HttpServletRequest) servletRequest; String jwt = resolveToken; if (StringUtils.hasText && this.tokenProvider.validateToken { //验证JWT是否正确 Authentication authentication = this.tokenProvider.getAuthentication; //获取用户认证信息 SecurityContextHolder.getContext().setAuthentication(authentication); //将用户保存到SecurityContext } filterChain.doFilter(servletRequest, servletResponse); }catch (ExpiredJwtException e){ //JWT失效 log.info("Security exception for user {} - {}", e.getClaims().getSubject(), e.getMessage; log.trace("Security exception trace: {}", e); ((HttpServletResponse) servletResponse).setStatus(HttpServletResponse.SC_UNAUTHORIZED); } } private String resolveToken(HttpServletRequest request){ String bearerToken = request.getHeader(WebSecurityConfig.AUTHORIZATION_HEADER); //从HTTP头部获取TOKEN if (StringUtils.hasText(bearerToken) && bearerToken.startsWith("Bearer ")){ return bearerToken.substring(7, bearerToken.length; //返回Token字符串,去除Bearer } String jwt = request.getParameter(WebSecurityConfig.AUTHORIZATION_TOKEN); //从请求参数中获取TOKEN if (StringUtils.hasText { return jwt; } return null; }}

编写 LoginController,用户通过用户名、密码访问 /auth/login,通过
LoginDTO 对象接收,创建一个 Authentication 对象,代码中为
UsernamePasswordAuthenticationToken,判断对象是否存在,通过
AuthenticationManager 的 authenticate
方法对认证对象进行验证,AuthenticationManager 的实现类 ProviderManager
会通过 AuthentionProvider 进行验证,默认 ProviderManager 调用
DaoAuthenticationProvider 进行认证处理,DaoAuthenticationProvider
中会通过 UserDetailsService 获取 UserDetails
,若认证成功则返回一个包含权限的 Authention,然后通过
SecurityContextHolder.getContext().setAuthentication() 设置到
SecurityContext 中,根据 Authentication 生成 Token,并返回给用户

@RestControllerpublic class LoginController { @Autowired private UserRepository userRepository; @Autowired private AuthenticationManager authenticationManager; @Autowired private JWTTokenUtils jwtTokenUtils; @RequestMapping(value = "/auth/login",method = RequestMethod.POST) public String login(@Valid LoginDTO loginDTO, HttpServletResponse httpResponse) throws Exception{ //通过用户名和密码创建一个 Authentication 认证对象,实现类为 UsernamePasswordAuthenticationToken UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(loginDTO.getUsername(),loginDTO.getPassword; //如果认证对象不为空 if (Objects.nonNull(authenticationToken)){ userRepository.findByName(authenticationToken.getPrincipal().toString .orElseThrow->new Exception; } try { //通过 AuthenticationManager(默认实现为ProviderManager)的authenticate方法验证 Authentication 对象 Authentication authentication = authenticationManager.authenticate(authenticationToken); //将 Authentication 绑定到 SecurityContext SecurityContextHolder.getContext().setAuthentication(authentication); //生成Token String token = jwtTokenUtils.createToken(authentication,false); //将Token写入到Http头部 httpResponse.addHeader(WebSecurityConfig.AUTHORIZATION_HEADER,"Bearer "+token); return "Bearer "+token; }catch (BadCredentialsException authentication){ throw new Exception; } }}

编写 Security 配置类,继承 WebSecurityConfigurerAdapter,重写
configure 方法

@Configuration@EnableWebSecurity@EnableGlobalMethodSecurity(prePostEnabled = true)public class WebSecurityConfig extends WebSecurityConfigurerAdapter { public static final String AUTHORIZATION_HEADER = "Authorization"; public static final String AUTHORIZATION_TOKEN = "access_token"; @Autowired private UserDetailsService userDetailsService; @Override protected void configure(AuthenticationManagerBuilder auth) throws Exception { auth //自定义获取用户信息 .userDetailsService(userDetailsService) //设置密码加密 .passwordEncoder(passwordEncoder; } @Override protected void configure(HttpSecurity http) throws Exception { //配置请求访问策略 http //关闭CSRF、CORS .cors().disable.disable() //由于使用Token,所以不需要Session .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS) .and() //验证Http请求 .authorizeRequests() //允许所有用户访问首页 与 登录 .antMatchers("/","/auth/login").permitAll() //其它任何请求都要经过认证通过 .anyRequest().authenticated() //用户页面需要用户权限 .antMatchers("/userpage").hasAnyRole .and() //设置登出 .logout().permitAll(); //添加JWT filter 在 http .addFilterBefore(genericFilterBean(), UsernamePasswordAuthenticationFilter.class); } @Bean public PasswordEncoder passwordEncoder() { return new BCryptPasswordEncoder(); } @Bean public GenericFilterBean genericFilterBean() { return new JwtAuthenticationTokenFilter(); }}

编写用于测试的Controller

@RestControllerpublic class UserController { @PostMapping public String login() { return "login"; } @GetMapping public String index() { return "hello"; } @GetMapping("/userpage") public String httpApi() { System.out.println(SecurityContextHolder.getContext().getAuthentication().getPrincipal; return "userpage"; } @GetMapping("/adminpage") public String httpSuite() { return "userpage"; }}

UIPI的运行机制

基于服务器验证方式暴露的一些问题

  1. Session:每次认证用户发起请求时,服务器需要去创建一个记录来存储信息。当越来越多的用户发起请求时,内存的开销也会不断增加。
  2. 可扩展性:在服务器的内存中使用Session存储登录信息,伴随而来的是可扩展性问题。
  3. CORS(跨域资源共享):当我们需要让数据跨多台移动设备上使用时,跨域资源的共享会是一个让人头疼的问题。在使用Ajax抓取另一个域的资源,就可以会出现禁止请求的情况。
  4. CSRF(跨站请求伪造):用户在访问银行网站时,他们很容易受到跨站请求伪造的攻击,并且能够被利用其访问其他的网站。

在这些问题中,可扩展性是最突出的。因此我们有必要去寻求一种更有性之有效的方法。

在Windows 7中,当UAC(User Account
Control)启用的时候,UIPI的运行可以得到最明显的体现。在UAC中,当一个管理员用户登录系统后,操作系统会创建两个令牌对象(Token
Object):第一个是管理员令牌,拥有大多数特权(类似于Windows
Vista之前的System中的用户),而第二个是一个经过过滤后的简化版本,只拥有普通用户的权限。

基于Token的验证原理

基于Token的身份验证是无状态的,我们不将用户信息存在服务器或Session中。

这种概念解决了在服务端存储信息时的许多问题

NoSession意味着你的程序可以根据需要去增减机器,而不用担心用户是否登录。

基于Token的身份验证的过程如下:

  1. 用户通过用户名和密码发送请求。
  2. 程序验证。
  3. 程序返回一个签名的Token给客户端。
  4. 客户端储存token,并且每次用于每次发送请求。
  5. 服务端验证token并返回数据。

每一次请求都需要token。token应该在HTTP的头部发送从而保证了HTTP请求无状态。我们同样通过设置服务器属性Access-Control-Origin:*,让服务器能接受到来自所有域的请求。需要注意的是,在ACAO头部标明(designating)*时,不得带有像HTTP认证,客户端SSL整肃和cookie的证书。

实现思路:

永利官网ylg客户端 5

  1. 用户登录校验,校验成功后就返回token给客户端。
  2. 客户端收到数据后保存在客户端。
  3. 客户端每次访问API是携带Token到服务端。
  4. 服务端采用filter过滤器校验。校验成功则返回请求数据,校验失败则返回错误码。

当我们在程序中认证了信息并取得token之后,我们便能通过这个Token做许多的事情。

我们甚至基于创建一个基于权限的token传给第三方应用程序,这些第三方程序能够获取到我们的数据(当然只有在我们允许的特定的token)

永利官网ylg客户端,默认情况下,以普通用户权限启动的进程拥有普通特权等级(UIPI的等级划分为低等级(low),普通(normal),高等级(high),系统(system))。相同的,以管理员权限运行的进程,例如,用户右键单击选择“以管理员身份运行”或者是通过添加“runas”参数调用ShellExecute运行的进程,这样的进程就相应地拥有一个较高(high)的特权等级。

Tokens的优势

  • 无状态、可扩展

    在客户端存储的Tokens是无状态的,并且能够被扩展。基于这种无状态和不存储Session信息,负载均衡器能够将用户信息丛一个服务器传到其他服务器上。如果我们将已验证的用户的信息保存在Session中,则每次请求都需要用户向已验证的服务器发送验证信息(称为Session亲和性)。用户量大时,可能会造成一些拥堵。
    但是不要着急。使用tokens之后这些问题都迎刃而解,因为tokens自己hold住了用户的验证信息。

  • 安全性

    请求中发送token而不再是发送cookie能够防止CSRF(跨站请求伪造)。即使在客户端使用cookie存储token,cookie也仅仅是一个存储机制而不是用于认证。不讲信息存储在Session中,让我们少了对session操作。
    token是有实效的,一段时候之后用户需要重新验证。我们也不一定需要等到token自动失效,token有撤回的操作,通过token revocation可以使一个特定的token或是一组相同认证的token无效。

  • 可扩展性

    Tokens能够创建与其他程序共享权限的程序,例如,能将一个随便的社交账号和自己的大号(Fackbook或事Twitter)联系起来。当通过服务登录Twitter(我们将这个过程Buffer)时,可以提供可选的权限给第三方应用程序。当用户想让另一个应用程序访问它们的数据,我们可以通过建立自己的API,得出特殊权限的tokens。

  • 多平台跨域

    我们提前先来谈论一下CORS(跨域资源共享),对应用程序和服务进行扩展的时候,需要介入各种各种的设备和应用程序。

    Having our API just serve data, we can also make the design choice to serve assets from a CDN. This eliminates the issues that CORS brings up after we set a quick header configuration for our application.

    只要用户有一个通过了验证的token,数据和资源就能够在任何域上被请求到。

  • 基于标准

    创建token的时候,你可以设定一些选项。我们在后续的文章中会进行更加详尽的描述,但是标准的用法会在JSON Web Tokens体现。

    最近的程序和文档是供给JSON Web Tokens的。它支持众多的语言。这意味在未来的使用中你可以真正的转换你的认证机制。

 

这将导致系统会运行两种不同类型,不同特权等级的进程(当然,从技术上讲这两个进程都是在同一用户下)。我们可以使用Windows
Sysinternals工具集中的进程浏览器(Process
Explorer)查看各个进程的特权等级。
()

永利官网ylg客户端 6

图1 进程浏览器

下图展示了以不同特权等级运行的同一个应用程序,进程浏览器显示了它们拥有不同的特权等级:

永利官网ylg客户端 7

图2  不同特权等级的同一应用程序

所以,当你发现你的进程之间Windows消息通信发生问题时,不妨使用进程浏览器查看一下两个进程之间是否有合适的特权等级。

UIPI所带来的限制

正如我们前文所说,等级的划分,是为了防止以下犯上。所以,有了用户界面特权隔离,一个运行在较低特权等级的应用程序的行为就受到了诸多限制,它不可以:

验证由较高特权等级进程创建的窗口句柄

通过调用SendMessage和PostMessage向由较高特权等级进程创建的窗口发送Windows消息

发表评论

电子邮件地址不会被公开。 必填项已用*标注