2. 程式人生 > >Shiro系統許可權管理、及原理剖析

Shiro系統許可權管理、及原理剖析

阿新 • • 發佈：2019-02-12

1.簡介       

        常用的JavaEE安全框架有shiro、spring security。shiro被應用非常廣泛，可以整合cas，搭建單點登入系統。spring security則被認為比較重，應用沒有shiro廣泛。shiro提供使用者名稱、密碼驗證，及密碼的加密儲存，會話Session的管理，與web整合，支援HTTPS的攔截。

2.Shiro原理簡析

shiro 原理剖析：

       shiro的核心是java servlet規範中的filter，通過配置攔截器，使用攔截器鏈來攔截請求，如果允許訪問，則通過。通常情況下，系統的登入、退出會配置攔截器。登入的時候，呼叫subject.login(token),token是使用者驗證資訊，這個時候會在Realm中doGetAuthenticationInfo方法中進行認證。這個時候會把使用者提交的驗證資訊與資料庫中儲存的認證資訊進行比較，一致則允許訪問，並在瀏覽器種下此次回話的cookie，在伺服器端儲存session資訊。退出的時候，呼叫subject.logout()，會清除回話資訊。       shiro中核心概念介紹：
         Filter：  1.AnonymousFilter：通過此filter修飾的url，任何人都可以進行訪問，即使沒有進行許可權認證                  2.FormAuthenticationFilter：通過此filter修飾的url，會對請求的url進行驗證，如果沒有通過，則會重定向返回到loginurl                  3.BasicHttpAuthenticationFilter：通過此filter修飾的url，要求使用者已經通過認證，如果沒有通過，則會要求通過Authorization 資訊進行認證                  4.LogoutFilter：通過此filter修飾的url，一旦收到url請求，則會立即呼叫subject進行退出，並重定向到redirectUrl                  5.NoSessionCreationFilter:通過此filter修飾的url，不會建立任何會話                  6.PermissionAuthorizationFilter:許可權攔截器，驗證使用者是否具有相關許可權                  7.PortFilter:埠攔截器，不是通過制定埠訪問url，將自動將埠重定向到指定埠                  8.HttpMethodPermissionFilter:rest風格攔截器，配置rest的訪問方式                  9.RolesAuthorizationFilter:角色攔截器，未登陸，將跳轉到loginurl，未授權，將跳轉到unauthorizedUrl                  10.SslFilter:HTTPS攔截器，需要以HTTPS的方式進行訪問                  11.UserFilter:使用者攔截器，需要使用者已經認證，或已經remember me          Subject：
表示當前操作的主體使用者，是一個抽象的概念，Subject可以進行登入、退出、許可權判斷等動作，通常一個subject與一個執行緒進行關聯。          Realm： 表示驗證的資料來源，儲存使用者的安全資料，可以進行使用者名稱和密碼的匹配，及使用者許可權查詢。

3.Shiro配置方法

shiro 配置方法：

  1. <?xmlversion="1.0"encoding="UTF-8"?>
  2. <beansxmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.        xmlns:util="http://www.springframework.org/schema/util"
  4.        xsi:schemaLocation="http://www.springframework.org/schema/beans  
  5.             http://www.springframework.org/schema/beans/spring-beans-4.0.xsd  
  6.             http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd  
  7.             http://www.springframework.org/schema/aop  
  8.             http://www.springframework.org/schema/aop/spring-aop-4.0.xsd  
  9.             http://www.springframework.org/schema/context  
  10.             http://www.springframework.org/schema/context/spring-context-4.0.xsd  
  11.             http://www.springframework.org/schema/tx  
  12.             http://www.springframework.org/schema/tx/spring-tx-4.0.xsd">
  13.     <description>Apache Shiro Security Configuration</description>
  14.     <!-- Realm實現 -->
  15.     <beanid="userRealm"class="com.ttyc.mammon.service.shiro.UserRealm">
  16.         <propertyname="cachingEnabled"value="false"/>
  17.     </bean>
  18.     <!-- 會話ID生成器 -->
  19.     <beanid="sessionIdGenerator"class="org.apache.shiro.session.mgt.eis.JavaUuidSessionIdGenerator"/>
  20.     <!-- 會話Cookie模板 -->
  21.     <beanid="sessionIdCookie"class="org.apache.shiro.web.servlet.SimpleCookie">
  22.         <constructor-argvalue="sid"/>
  23.         <propertyname="domain"value=".ttyongche.com"/>
  24.         <propertyname="path"value="/"/>
  25.         <propertyname="httpOnly"value="false"/>
  26.         <propertyname="maxAge"value="-1"/>
  27.     </bean>
  28.     <!-- 會話DAO -->
  29.     <beanid="sessionDAO"class="org.crazycake.shiro.RedisSessionDAO">
  30.         <propertyname="sessionIdGenerator"ref="sessionIdGenerator"/>
  31.         <propertyname="redisManager"ref="redisManager"/>
  32.     </bean>
  33.     <!-- 會話管理器 -->
  34.     <beanid="sessionManager"class="org.apache.shiro.web.session.mgt.DefaultWebSessionManager">
  35.         <propertyname="globalSessionTimeout"value="1800000"/>
  36.         <propertyname="deleteInvalidSessions"value="true"/>
  37.         <propertyname="sessionDAO"ref="sessionDAO"/>
  38.         <propertyname="sessionIdCookieEnabled"value="true"/>
  39.         <propertyname="sessionIdCookie"ref="sessionIdCookie"/>
  40.     </bean>
  41.     <!-- 安全管理器 -->
  42.     <beanid="securityManager"class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
  43.         <propertyname="realm"ref="userRealm"/>
  44.         <propertyname="sessionManager"ref="sessionManager"/>
  45.         <propertyname="cacheManager"ref="redisCacheManager"/>
  46.     </bean>
  47.     <!-- 相當於呼叫SecurityUtils.setSecurityManager(securityManager) -->
  48.     <beanclass="org.springframework.beans.factory.config.MethodInvokingFactoryBean">
  49.         <propertyname="staticMethod"value="org.apache.shiro.SecurityUtils.setSecurityManager"/>
  50.         <propertyname="arguments"ref="securityManager"/>
  51.     </bean>
  52.     <beanid="authFilter"class="com.ttyc.mammon.controller.filter.AuthFilter"/>
  53.     <beanid="permissionFilter"class="com.ttyc.mammon.controller.filter.PermissionFilter"/>
  54.     <!-- Shiro的Web過濾器 -->
  55.     <beanid="shiroFilter"class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
  56.         <propertyname="securityManager"ref="securityManager"/>
  57.         <propertyname="loginUrl"value="/login"/>
  58.         <propertyname="filters">
  59.             <util:map>
  60.                 <entrykey="auth"value-ref="authFilter"/>
  61.                 <entrykey="perm"value-ref="permissionFilter"/>
  62.             </util:map>
  63.         </property>
  64.         <propertyname="filterChainDefinitions">
  65.             <value>
  66.                 /** = auth  
  67.             </value>
  68.         </property>
  69.     </bean>
  70.     <!-- Shiro生命週期處理器-->
  71.     <beanid="lifecycleBeanPostProcessor"class="org.apache.shiro.spring.LifecycleBeanPostProcessor"/>
  72.     <!-- cacheManager -->
  73.     <beanid="redisCacheManager"class="org.crazycake.shiro.RedisCacheManager">
  74.         <propertyname="redisManager"ref="redisManager"/>
  75.     </bean>
  76.     <!-- shiro redisManager -->
  77.     <beanid="redisManager"class="com.ttyc.mammon.service.shiro.RedisManager">
  78.         <propertyname="host"value="${redis.host}"/>
  79.         <propertyname="port"value="${redis.port}"/>
  80.         <propertyname="expire"value="${redis.expire}"/>
  81.         <propertyname="dataBase"value="${redis.database}"/>
  82.     </bean>
  83. </beans>

    Pom依賴：     <shiro.version>1.2.2</shiro.version>     <shiro.redis.version>2.4.2.1-RELEASE</shiro.redis.version>
  1. <dependency>
  2.             <groupId>org.apache.shiro</groupId>
  3.             <artifactId>shiro-core</artifactId>
  4.             <version>${shiro.version}</version>
  5.         </dependency>
  6.         <dependency>
  7.             <groupId>org.apache.shiro</groupId>
  8.             <artifactId>shiro-web</artifactId>
  9.             <version>${shiro.version}</version>
  10.         </dependency>
  11.         <dependency>
  12.             <groupId>org.apache.shiro</groupId>
  13.             <artifactId>shiro-spring</artifactId>
  14.             <version>${shiro.version}</version>
  15.         </dependency>
  16.         <dependency>
  17.             <groupId>org.crazycake</groupId>
  18.             <artifactId>shiro-redis</artifactId>
  19.             <version>${shiro.redis.version}</version>
  20.         </dependency>


    UserRealm：     繼承AuthorizingRealm，重寫doGetAuthorization和doGetAuthorication方法。
  1. @Override
  2.     protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {  
  3.         String username = (String)principals.getPrimaryPrincipal();  
  4.         SysUser user = getUserByName(username);  
  5.         SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();  
  6.         SysRole sysRole = sysRolePermService.getSysRoleByUserId(user.getId());  
  7.         addRole(authorizationInfo,sysRole);  
  8.         List<SysPermission> sysPermissions = sysRolePermService.getSysPermissionByUserId(user.getId());  
  9.         addPermissions(authorizationInfo,sysPermissions);  
  10.         return authorizationInfo;  
  11.     }  
  12.     @Override
  13.     protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {  
  14.         String username = (String)token.getPrincipal();  
  15.         SysUser user = getUserByName(username);  
  16.         //交給AuthenticatingRealm使用CredentialsMatcher進行密碼匹配，如果覺得人家的不好可以自定義實現
  17.         if (user != null){  
  18.             returnnew SimpleAuthenticationInfo(user.getUserName(),"", getName());  
  19.         }  
  20.         returnnull;  
  21.     }  


    AuthFilter： AuthFilter繼承AccessControllerFilter，需要重寫isAccessAllowed和onAccessDenied方法
  1. @Override
  2.     protectedboolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {  
  3.         HttpServletRequest httpRequest = (HttpServletRequest)request;  
  4.         HttpServletResponse httpResponse = (HttpServletResponse)response;  
  5.         //支援跨域
  6.         supportCrossDomain(httpResponse);  
  7.         // 對外API,通過Service-Token進行認證
  8.         String url = httpRequest.getRequestURI().substring(httpRequest.getContextPath().length());  
  9.         if (url.startsWith(HTTP_API_URL)) {  
  10.             if (validateSign(httpRequest.getHeader("Service-Token"))) {  
  11.                 returntrue;  
  12.             }  
  13.             else {  
  14.                 returnfalse;  
  15.             }  
  16.         }  
  17.         //運營後臺通過cookie,token,sid進行認證
  18.         Subject currentSubject = SecurityUtils.getSubject();  
  19.         if (! currentSubject.isAuthenticated()){  
  20.             SysUser sysTokenUser = loginAuthService.validTokenAuth((HttpServletRequest) request);  
  21.             SysUser sysCookieUser = loginAuthService.validCookieAuth((HttpServletRequest) request);  
  22.             if (sysTokenUser == null && sysCookieUser == null){  
  23.                 returnfalse;  
  24.             }  
  25.             SysUser sysUser = null;  
  26.             if (sysTokenUser != null){  
  27.                 sysUser = sysTokenUser;  
  28.             }else {  
  29.                 sysUser = sysCookieUser;  
  30.             }  
  31.             UsernamePasswordToken token = new UsernamePasswordToken(sysUser.getUserName(),"");  
  32.             currentSubject.login(token);  
  33.             Session session = currentSubject.getSession();  
  34.             session.setAttribute("LoginUser",sysUser);  
  35.         }  
  36.         //在request裡設定登入使用者
  37.         SysUser currentUser = (SysUser) currentSubject.getSession().getAttribute("LoginUser");  
  38.         request.setAttribute("loginId", currentUser.getId());  
  39.         returntrue;  
  40.     }  
  41.     @Override
  42.     protectedboolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {  
  43.         response.setContentType("application/json; charset=utf-8");  
  44.         response.getWriter().write(json);  
  45.         returnfalse;  
  46.     }  


    RedisManager： shiro原生不支援redis，只支援ehcache，ehcache只能單機快取，不適合於大型叢集應用。第三方crazycake支援shiro使用redis快取，配置方式如下：
  1. import redis.clients.jedis.Jedis;  
  2. import redis.clients.jedis.JedisPool;  
  3. import redis.clients.jedis.JedisPoolConfig;  
  4. import java.util.Set;  
  5. publicclass RedisManager extends org.crazycake.shiro.RedisManager {  
  6.     private String host = "127.0.0.1";  
  7.     privateint port = 6379;  
  8.     // 0 - never expire
  9.     privateint expire = 0;  
  10.     // timeout for jedis try to connect to redis server, not expire time! In
  11.     // milliseconds
  12.     privateint timeout = 0;  
  13.     private String password = "";  
  14.     privateint dataBase;  
  15.     privatestatic JedisPool jedisPool = null;  
  16.     public RedisManager() {  
  17.     }  
  18.     /** 
  19.      * 初始化方法 
  20.      */
  21.     publicvoid init() {  
  22.         if (jedisPool == null) {  
  23.             if (password != null && "".equals(password.trim())) {  
  24.                 password = null;  
  25.             }  
  26.             jedisPool = new JedisPool(new JedisPoolConfig(), host, port, timeout, password, dataBase);  
  27.         }  
  28.     }  
  29.     /** 
  30.      * get value from redis 
  31.      *  
  32.      * @param key 
  33.      * @return 
  34.      */
  35.     publicbyte[] get(byte[] key) {  
  36.         byte[] value = null;  
  37.         Jedis jedis = jedisPool.getResource();  
  38.         try {  
  39.             value = jedis.get(key);  
  40.         } finally {  
  41.             jedis.close();  
  42.         }  
  43.         return value;  
  44.     }  
  45.     /** 
  46.      * set 
  47.      *  
  48.      * @param key 
  49.      * @param value 
  50.      * @return 
  51.      */
  52.     publicbyte[] set(byte[] key, byte[] value) {  
  53.         Jedis jedis = jedisPool.getResource();  
  54.         try {  
  55.             jedis.set(key, value);  
  56.             if (this.expire != 0) {  
  57.                 jedis.expire(key, this.expire);  
  58.             }  
  59.         } finally {  
  60.             jedis.close();  
  61.         }  
  62.         return value;  
  63.     }  
  64.     /** 
  65.      * set 
  66.      *  
  67.      * @param key 
  68.      * @param value 
  69.      * @param expire 
  70.      * @return 
  71.      */
  72.     publicbyte[] set(byte[] key, byte[] value, int expire) {  
  73.         Jedis jedis = jedisPool.getResource();  
  74.         try {  
  75.             jedis.set(key, value);  
  76.             if (expire != 0) {  
  77.                 jedis.expire(key, expire);  
  78.             }  
  79.         } finally {  
  80.             jedis.close();  
  81.         }  
  82.         return value;  
  83.     }  
  84.     /** 
  85.      * del 
  86.      *  
  87.      * @param key 
  88.      */
  89.     publicvoid del(byte[] key) {  
  90.         Jedis jedis = jedisPool.getResource();  
  91.         try {  
  92.             jedis.del(key);  
  93.         } finally {  
  94.             jedis.close();  
  95.         }  
  96.     }  
  97.     /** 
  98.      * flush 
  99.      */
  100.     publicvoid flushDB() {  
  101.         Jedis jedis = jedisPool.getResource();  
  102.         try {  
  103.             jedis.flushDB();  
  104.         } finally {  
  105.             jedis.close();  
  106.         }  
  107.     }  
  108.     /** 
  109.      * size 
  110.      */
  111.     public Long dbSize() {  
  112.         Long dbSize = 0L;  
  113.         Jedis jedis = jedisPool.getResource();  
  114.         try {  
  115.             dbSize = jedis.dbSize();  
  116.         } finally {  
  117.             jedis.close();  
  118.         }  
  119.         return dbSize;  
  120.     }  
  121.     /** 
  122.      * keys 
  123.      *  
  124.      * @param pattern 
  125.      * @return 
  126.      */
  127.     public Set<byte[]> keys(String pattern) {  
  128.         Set<byte[]> keys = null;  
  129.         Jedis jedis = jedisPool.getResource();  
  130.         try {  
  131.             keys = jedis.keys(pattern.getBytes());  
  132.         } finally {  
  133.             jedis.close();  
  134.         }  
  135.         return keys;  
  136.     }  
  137.     public String getHost() {  
  138.         return host;  
  139.     }  
  140.     publicvoid setHost(String host) {  
  141.         this.host = host;  
  142.     }  
  143.     publicint getPort() {  
  144.         return port;  
  145.     }  
  146.     publicvoid setPort(int port) {  
  147.         this.port = port;  
  148.     }  
  149.     publicint getExpire() {  
  150.         return expire;  
  151.     }  
  152.     publicvoid setExpire(int expire) {  
  153.         this.expire = expire;  
  154.     }  
  155.     publicint getTimeout() {  
  156.         return timeout;  
  157.     }  
  158.     publicvoid setTimeout(int timeout) {  
  159.         this.timeout = timeout;  
  160.     }  
  161.     public String getPassword() {  
  162.         return password;  
  163.     }  
  164.     publicvoid setPassword(String password) {  
  165.         this.password = password;  
  166.     }  
  167.     publicint getDataBase() {  
  168.         return dataBase;  
  169.     }  
  170.     publicvoid setDataBase(int dataBase) {  
  171.         this.dataBase = dataBase;  
  172.     }  
  173. } 

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

1.對有沒有訪問許可權的理解。  我們這裡要對系統中的 角色組、角色、使用者、功能 之間的關係要理清楚，http://blog.csdn.NET/baicp3/article/details/45028013方便下面使用者是否具有某一url的訪問。

我們看shiro的配置檔案，所以的請求都是需要使用者登入的


因而使用者 在登入成功時候，shiro已經把該使用者是否有訪問某一url的許可權已經判斷好了。

看下面簡單的程式碼

   @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        //獲取當前登陸的使用者名稱
        String loginName = 
              (String) principalCollection.fromRealm(getName()).iterator().next();
        //根據使用者名稱查詢物件
        User user = userService.findByLoginName(loginName);
        if(user != null) {
            SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
            //新增角色(Set集合<字串>)
            info.setRoles(user.getGroupNameSet());
            //迭代使用者對應的角色集合，為了獲取角色對應的許可權
            for(UserGroup g : user.getUserGroupList()) {
                //新增permission
                info.addStringPermissions(g.getPermissionStringList());
            }
            return info;
        }
        return null;
    }


    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(
            AuthenticationToken authenticationToken) throws AuthenticationException {
        UsernamePasswordToken token = (UsernamePasswordToken) authenticationToken;
        //根據使用者名稱去查詢物件
        User user = userService.findByLoginName(token.getUsername());

        if(user != null) {
          return new SimpleAuthenticationInfo(user.getName(),
              user.getPassword(),getName());
        }
        return null;
    }

    public void setUserService(UserService userService) {
        this.userService = userService;
    }

}

shiro其實已經幫我們寫好了方法，我們只要去重寫 首先看原始碼

本人系統這個類RapShiroRealm 去實現(

相關推薦

Shiro系統許可權管理、及原理剖析

1.簡介                常用的JavaEE安全框架有shiro、spring security。shiro被應用非常廣泛，可以整合cas，搭建單點登入系統。spring security則被認為比較重，應用沒有shiro廣泛。shiro提供使用者名稱、

Linux平臺下使用者基本管理機制及原理剖析（二）

Linux平臺下使用者基本管理機制及原理剖析（二） 在前面的部落格中，我們對虛擬環境下使用者的新建、檢視、刪除以及使用者組的新建和管理有了一定的瞭解，這篇文章我們 接著瞭解虛擬環境下的使用者資訊的更改、使用者認證資訊的檢視，使用者密碼的管理以及使用者授權。   1.使用者資

Linux平臺下使用者基本管理機制及原理剖析（一）

Linux平臺下使用者基本管理機制及原理剖析（一）  Linux是一個多使用者、多工的作業系統，具有很好的安全性和穩定性。 使用者和群組存在的意義 使用者的存在是為了使你的工作環境更加安全，就是有一個隱私空間，這個空間只有使用者本人有許可權。 而群組存在的意義是為了讓大家有

SAP系統許可權管理及引數設定

SAP系統的許可權管理主要是通過事務程式碼,許可權物件,許可權等3個關鍵物件構築的. 1. 事務程式碼(Tcode) SAP系統中,每個操作命令都是唯一對應一個事務程式碼.事務程式碼是操作命令的表現形式.使用者通過輸入相應的事務程式碼

shell命令以及執行原理、檢視或修改掩碼（umask）、Linux許可權管理、Linux設定檔案訪問許可權（chmod）、粘滯位、修改檔案的擁有者（chown）、修改檔案的所屬組（chgrp）

shell命令以及執行原理：   Linux嚴格意義上說的是一個作業系統，我們稱之為”核心”，但是我們普通使用者，不能直接使用核心，而是通過核心的”外殼”程式,也就是所謂的shell，來與核心溝通。   Linux中的命令大多數都是可執行程式。但其實捕捉我們

SpringBoot+mybatis+Shiro+redis許可權管理系統原始碼

演示地址： http://111.230.157.133/login 技術選型 後端 基礎框架：Spring Boot 2.0.4.RELEASE 持久層框架：Mybatis 3.4.5 安全框架：Apache Shiro 1.4.0 （店鋪裡面有 Spring Se

Linux系統管理初步（七）系統服務管理、chkconfig與systemd 編輯中

方便 sub text log 過去時 需要 cbe 理解 term Linux系統本身包含了很多服務，CentOS6之前系統的服務用SysV控制，CentOS7改為systemd控制 一、chkconfig服務管理機制 簡而言之，chkconfig就是CentOS6以前用

HTML5總結及原理剖析

html5中新增的特性 1.語義化標籤，比如：<header> <footer> <article>等，可以使我們建立更友好的頁面結構，便於搜尋引擎抓取； div是division的縮寫，你在網頁中寫了大量的div,就算你寫了class

Windows系統檢視程序、及殺死程序的相關命令

檢視所有程序：netstat -ano檢視指定埠的程式：netstat -ano | findstr "8080" 殺死相關的程序：            tasklist     

潭州課堂25班：Ph201805201 django框架 第十三課 自定義404頁面，auth系統中的User模型，auth系統許可權管理 (課堂筆記)

 當 DEBUG=True 時，django 內部的404報錯資訊， 自帶的報錯資訊， 要自定義404資訊，要先把 DEBUG=False ， 之後要自定義4040頁面，有兩種方法， 　　方法1，在建立404頁面 這樣就配置完成，當訪問不存在的頁面時，跳轉到自定義的4

Jenkins常用外掛分享(role許可權管理、密碼掩蓋)

文章目錄 role許可權管理，對不同的角色可授予不同許可權，顯示不同專案。 密碼等私密資訊過濾顯示 role許可權管理，對不同的角色可授予不同許可權，顯示不同專案。 需要安裝外掛：Role-based Authoriz

後臺管理系統 – 許可權管理

最近在重新整理搜書吧(一個做圖書比價的平臺)的系統架構，目前圖書產品數量超過了200萬條。各種資料加起來超過40G了，使用Mysql資料庫儲存伺服器吃不消，於是考慮使用HBase儲存大部分資料。   一、摘要 以前搜書吧的資料量比較小，使用資料庫+靜態檔案儲存的方式就可以搞

Liinux（許可權管理、組管理）

許可權：（檔案和目錄的許可權） -rw-r--r--. 1 tom police 0 Sep 29 19:05 ok.txt -：{檔案型別：- 表普通檔案 d：目錄 l:軟連結 c:字元裝置【鍵盤，滑鼠】 b:塊檔案，硬碟   } rw- :{表示檔案所有者擁有的許可

week2(2)許可權管理、vi的使用

檔案許可權管理 suid,sgid,sbit 1.suid 讓二進位制程式的執行者臨時擁有屬主的許可權 2.sgid 讓二進位制程式的執行者臨時擁有屬組的許可權，並且在某個目錄中建立的檔案自動繼承該目錄的使用者組（只可以對目錄進行設定）。 3.sticky 特殊

【Linux】使用者和使用者組管理、許可權管理、vi編輯器、sudo許可權管理

使用者和使用者組管理 1、使用者配置檔案位置 -》cat /etc/passwd 2、root: x:0:0:root:/root:/bin/bash -》root 代表使用者名稱 -》x 密碼標識，

Flask上下文管理、session原理和全域性g物件

一、一些python的知識 1、偏函式 def add(x, y, z): print(x + y + z) # 原本的寫法：x,y,z可以傳任意數字 add(1,2,3) # 如果我要實現一個功能，這三個數中，其中一個數必須是3 # 我們就可以使用偏函式來幫著我們

[教程]linux/UNIX作業系統檔案系統許可權管理

linux/UNIX檔案的存取有三種許可權：許可權 普通檔案的存取許可權 目錄的存取許可權R 具有讀取檔案的權利 能讀取檔名稱W 具有寫入檔案的權利 能建立和刪除檔案，可以改變檔名X 具有執行檔案的權利 能使用該目錄下的檔案(如cd命令)搜尋檔案等能夠存取檔案的使用者型別有三種類型的使用者可以存取檔案：使用者

Linux使用者管理、許可權管理、歸檔、壓縮以及建立連線和測試網路網路連通性

uid：使用者標識號 gid：組標識號 預設情況下，使用者uid和gid一樣 使用者的分類： 超級使用者（root）：許可權特別大，uid=0，gid=0，生產環境建議不要使用 普通使用者：uid>=500，Ubuntu一般>=1000，一般許可權系統管理，

SpringBoot與Shiro整合-許可權管理實戰視訊筆記（之三）

本文內容大部分來自黑馬視訊的SpringBoot與Shiro整合-許可權管理實戰視訊，在此記錄為個人學習筆記。 可按步驟操作，無法實操的實戰blog都是耍流氓。 七、Shiro授權-使用Shiro過濾器實現授權頁面攔截 1. 在S

Java Web許可權管理設計及實現

最近在做一個許可權相關的功能，在專案原有許可權管理上面進行擴充套件，一方面支援介面上控制到按鈕級別，後端介面沒有許可權不能進行訪問；另一個方面，對專案中應用管理模組的應用管理員授權，使其具有對其名下的