精华内容
下载资源
问答
  • oracle 系统权限、对象权限大全和用户的授权解析
    万次阅读
    2018-08-02 11:52:42

    权限、角色、用户:
    Oracle 权限
    权限允许用户访问属于其它用户的对象或执行程序,ORACLE系统提供三种权限:Object 对象级、System 系统级、Role 角色级。这些权限可以授予给用户、特殊用户public或角色,如果授予一个权限给特殊用户”Public”(用户public是oracle预定义的,每个用户享有这个用户享有的权限),那么就意味作将该权限授予了该数据库的所有用户。
    对管理权限而言,角色是一个工具,权限能够被授予给一个角色,角色也能被授予给另一个角色或用户。用户可以通过角色继承权限,除了管理权限外角色服务没有其它目的。权限可以被授予,也可以用同样的方式撤销。
    权限分类
    1、系统权限:系统规定用户使用数据库的权限。(系统权限是对用户而言)。
    2、实体权限:某种权限用户对其它用户的表或视图的存取权限。(是针对表或视图而言的)。
    系统权限管理
    系统权限分类:
    DBA: 拥有全部特权,是系统最高权限,只有DBA才可以创建数据库结构。
    RESOURCE:拥有Resource权限的用户只可以创建实体,不可以创建数据库结构。
    RESOURCE:是系统一个角色;
    拥有的系统权限有:
    拥有的系统权限
    CREATE SEQUENCE –创建序列权限
    CREATE TRIGGER –创建触发器
    CREATE CLUSTER –创建游标
    CREATE PROCEDURE –创建存储过程
    CREATE TYPE –自定义类型
    CREATE OPERATOR –创建操作符
    CREATE TABLE –创建表
    CREATE INDEXTYPE –创建索引
    CONNECT:拥有Connect权限的用户只可以登录Oracle,不可以创建实体,不可以创建数据库结构。
    拥有的系统权限有:
    这里写图片描述
    CREATE SESSION – 用户被创建后,没有任何权限,包括登录。用户如果想登录,至少需要有 CREATE SESSION 的权限
    对于普通用户:授予connect, resource 系统角色。
    对于DBA管理用户:授予connect,resource, dba 系统角色。
    系统权限授权命令:
    系统权限只能由DBA用户授出:sys, system(最开始只能是这两个用户)
    授权命令:SQL> grant connect, resource, dba to 用户名1 [,用户名2]…;
    注:普通用户通过授权可以具有与system相同的用户权限,但永远不能达到与sys用户相同的权限,system用户的权限也可以被回收。
    例:
    SQL> connect system/manager
    SQL> create user user50 identified by user50;
    SQL> grant connect, resource to user50;

    查当前用户拥有哪些系统权限和角色
    select * from session_privs; –查看当前用户拥有的权限
    select * from session_roles; –查看当前用户拥有的角色
    删除用户
    SQL> drop user 用户名 cascade; //加上cascade则将用户连同其创建的东西全部删除
    系统权限传递:
    增加WITH ADMIN OPTION选项,则得到的权限可以传递。
    SQL> grant connect, resorce to user50 with admin option; //可以传递所获权限。
    系统权限回收:系统权限只能由DBA用户回收
    SQL> Revoke connect, resource from user50;
    说明:
    1)如果使用WITH ADMIN OPTION为某个用户授予系统权限,那么对于被这个用户授予相同权限的所有用户来说,取消该用户的系统权限并不会级联取消这些用户的相同权限。
    2)系统权限无级联,即A授予B权限,B授予C权限,如果A收回B的权限,C的权限不受影响;系统权限可以跨用户回收,即A可以直接收回C用户的权限。
    实体权限管理
    实体权限分类
    select, update, insert, alter, index, delete, all //all包括所有权限
    execute //执行存储过程权限
    user01:
    SQL> grant select, update, insert on product to user02;
    SQL> grant all on product to user02;
    user02:
    SQL> select * from user01.product;
    // 此时user02查user_tables,不包括user01.product这个表,但如果查all_tables则可以查到,因为他可以访问。
    将表的操作权限授予全体用户:
    SQL> grant all on product to public; // public表示是所有的用户,这里的all权限不包括drop。
    实体权限数据字典
    SQL> select owner, table_name from all_tables; // 用户可以查询的表
    SQL> select table_name from user_tables; // 用户创建的表
    SQL> select grantor, table_schema, table_name, privilege from all_tab_privs; // 获权可以存取的表(被授权的)
    SQL> select grantee, owner, table_name, privilege from user_tab_privs; // 授出权限的表(授出的权限)
    DBA用户可以操作全体用户的任意基表(无需授权,包括删除):
    DBA用户:
    SQL> Create table stud02.product(
    id number(10),
    name varchar2(20));
    SQL> drop table stud02.emp;

    SQL> create table stud02.employee
    as
    select * from scott.emp;
    实体权限传递(with grant option):
    user01:
    SQL> grant select, update on product to user02 with grant option; // user02得到权限,并可以传递。
    实体权限回收:
    user01:
    SQL>Revoke select, update on product from user02; //传递的权限将全部丢失。
    说明
    1)如果取消某个用户的对象权限,那么对于这个用户使用WITH GRANT OPTION授予权限的用户来说,同样还会取消这些用户的相同权限,也就是说取消授权时级联的。
    Oracle 角色管理
    角色是一组权限的集合,将角色赋给一个用户,这个用户就拥有了这个角色中的所有权限。系统预定义角色是在数据库安装后,系统自动创建的一些常用的角色。下介简单的介绍一下这些预定角色。角色所包含的权限可以用以下语句查询:
    sql>select * from role_sys_privs where role=’角色名’;
    CONNECT, RESOURCE, DBA:这些预定义角色主要是为了向后兼容。其主要是用于数据库管理。oracle建议用户自己设计数据库管理和安全的权限规划,而不要简单的使用这些预定角色。将来的版本中这些角色可能不会作为预定义角色。
    DELETE_CATALOG_ROLE, EXECUTE_CATALOG_ROLE, SELECT_CATALOG_ROLE:这些角色主要用于访问数据字典视图和包。
    EXP_FULL_DATABASE, IMP_FULL_DATABASE:这两个角色用于数据导入导出工具的使用。
    AQ_USER_ROLE, AQ_ADMINISTRATOR_ROLE:AQ:Advanced Query。这两个角色用于oracle高级查询功能。
    SNMPAGENT:用于oracle enterprise manager和Intelligent Agent
    RECOVERY_CATALOG_OWNER:用于创建拥有恢复库的用户。关于恢复库的信息,参考oracle文档《Oracle9i User-Managed Backup and Recovery Guide》
    HS_ADMIN_ROLE:A DBA using Oracle’s heterogeneous services feature needs this role to access appropriate tables in the data dictionary.
    管理角色
    建一个角色
    sql>create role role1;
    授权给角色
    sql>grant create any table,create procedure to role1;
    授予角色给用户
    sql>grant role1 to user1;
    查看角色所包含的权限
    sql>select * from role_sys_privs;
    创建带有口令以角色(在生效带有口令的角色时必须提供口令)
    sql>create role role1 identified by password1;
    修改角色:是否需要口令
    sql>alter role role1 not identified;
    sql>alter role role1 identified by password1;
    设置当前用户要生效的角色
    (注:角色的生效是一个什么概念呢?假设用户a有b1,b2,b3三个角色,那么如果b1未生效,则b1所包含的权限对于a来讲是不拥有的,只有角色生效了,角色内的权限才作用于用户,最大可生效角色数由参数MAX_ENABLED_ROLES设定;在用户登录后,oracle将所有直接赋给用户的权限和用户默认角色中的权限赋给用户。)
    sql>set role role1; //使role1生效
    sql>set role role,role2; //使role1,role2生效
    sql>set role role1 identified by password1; //使用带有口令的role1生效
    sql>set role all; //使用该用户的所有角色生效
    sql>set role none; //设置所有角色失效
    sql>set role all except role1; //除role1外的该用户的所有其它角色生效。
    sql>select * from SESSION_ROLES; //查看当前用户的生效的角色。
    修改指定用户,设置其默认角色
    sql>alter user user1 default role role1;
    sql>alter user user1 default role all except role1;
    详见oracle参考文档
    9.删除角色
    sql>drop role role1;
    角色删除后,原来拥用该角色的用户就不再拥有该角色了,相应的权限也就没有了。
    说明:
    1)无法使用WITH GRANT OPTION为角色授予对象权限
    2)可以使用WITH ADMIN OPTION 为角色授予系统权限,取消时不是级联

    与权限安全相关的数据字典表有:
    ALL_TAB_PRIVS
    ALL_TAB_PRIVS_MADE
    ALL_TAB_PRIVS_RECD
    DBA_SYS_PRIVS
    DBA_ROLES
    DBA_ROLE_PRIVS
    ROLE_ROLE_PRIVS
    ROLE_SYS_PRIVS
    ROLE_TAB_PRIVS
    SESSION_PRIVS
    SESSION_ROLES
    USER_SYS_PRIVS
    USER_TAB_PRIV
    oracle的系统和对象权限列表
    alter any cluster 修改任意簇的权限
    alter any index 修改任意索引的权限
    alter any role 修改任意角色的权限
    alter any sequence 修改任意序列的权限
    alter any snapshot 修改任意快照的权限
    alter any table 修改任意表的权限
    alter any trigger 修改任意触发器的权限
    alter cluster 修改拥有簇的权限
    alter database 修改数据库的权限
    alter procedure 修改拥有的存储过程权限
    alter profile 修改资源限制简表的权限
    alter resource cost 设置佳话资源开销的权限
    alter rollback segment 修改回滚段的权限
    alter sequence 修改拥有的序列权限
    alter session 修改数据库会话的权限
    alter sytem 修改数据库服务器设置的权限
    alter table 修改拥有的表权限
    alter tablespace 修改表空间的权限
    alter user 修改用户的权限
    analyze 使用analyze命令分析数据库中任意的表、索引和簇
    audit any 为任意的数据库对象设置审计选项
    audit system 允许系统操作审计
    backup any table 备份任意表的权限
    become user 切换用户状态的权限
    commit any table 提交表的权限
    create any cluster 为任意用户创建簇的权限
    create any index 为任意用户创建索引的权限
    create any procedure 为任意用户创建存储过程的权限
    create any sequence 为任意用户创建序列的权限
    create any snapshot 为任意用户创建快照的权限
    create any synonym 为任意用户创建同义名的权限
    create any table 为任意用户创建表的权限
    create any trigger 为任意用户创建触发器的权限
    create any view 为任意用户创建视图的权限
    create cluster 为用户创建簇的权限
    create database link 为用户创建的权限
    create procedure 为用户创建存储过程的权限
    create profile 创建资源限制简表的权限
    create public database link 创建公共数据库链路的权限
    create public synonym 创建公共同义名的权限
    create role 创建角色的权限
    create rollback segment 创建回滚段的权限
    create session 创建会话的权限
    create sequence 为用户创建序列的权限
    create snapshot 为用户创建快照的权限
    create synonym 为用户创建同义名的权限
    create table 为用户创建表的权限
    create tablespace 创建表空间的权限
    create user 创建用户的权限
    create view 为用户创建视图的权限
    delete any table 删除任意表行的权限
    delete any view 删除任意视图行的权限
    delete snapshot 删除快照中行的权限
    delete table 为用户删除表行的权限
    delete view 为用户删除视图行的权限
    drop any cluster 删除任意簇的权限
    drop any index 删除任意索引的权限
    drop any procedure 删除任意存储过程的权限
    drop any role 删除任意角色的权限
    drop any sequence 删除任意序列的权限
    drop any snapshot 删除任意快照的权限
    drop any synonym 删除任意同义名的权限
    drop any table 删除任意表的权限
    drop any trigger 删除任意触发器的权限
    drop any view 删除任意视图的权限
    drop profile 删除资源限制简表的权限
    drop public cluster 删除公共簇的权限
    drop public database link 删除公共数据链路的权限
    drop public synonym 删除公共同义名的权限
    drop rollback segment 删除回滚段的权限
    drop tablespace 删除表空间的权限
    drop user 删除用户的权限
    execute any procedure 执行任意存储过程的权限
    execute function 执行存储函数的权限
    execute package 执行存储包的权限
    execute procedure 执行用户存储过程的权限
    force any transaction 管理未提交的任意事务的输出权限
    force transaction 管理未提交的用户事务的输出权限
    grant any privilege 授予任意系统特权的权限
    grant any role 授予任意角色的权限
    index table 给表加索引的权限
    insert any table 向任意表中插入行的权限
    insert snapshot 向快照中插入行的权限
    insert table 向用户表中插入行的权限
    insert view 向用户视图中插行的权限
    lock any table 给任意表加锁的权限
    manager tablespace 管理(备份可用性)表空间的权限
    references table 参考表的权限
    restricted session 创建有限制的数据库会话的权限
    select any sequence 使用任意序列的权限
    select any table 使用任意表的权限
    select snapshot 使用快照的权限
    select sequence 使用用户序列的权限
    select table 使用用户表的权限
    select view 使用视图的权限
    unlimited tablespace 对表空间大小不加限制的权限
    update any table 修改任意表中行的权限
    update snapshot 修改快照中行的权限
    update table 修改用户表中的行的权限
    update view 修改视图中行的权限

    更多相关内容
  • gitlab master 用户分配权限

    千次阅读 2020-04-22 15:27:38
    ================================================ 以下是不通过 管理员来添加权限的: 点击 进入project ,选择setting --》 repostiory --》Protected Branches --》expand 

    ================================================

     以下是不通过 管理员来添加权限的:

    点击 进入project ,选择setting --》 repostiory --》Protected Branches --》expand 

      

    展开全文
  • Python Flask学习_用户角色和用户权限

    万次阅读 2018-07-04 23:36:06
    在Web App中 ,存在和游客(匿名用户),普通用户,协管员,管理...一、在数据库中表示不同的角色权限有这么几种:操作的权限使用8位二进制数表示,现在只用了5位,剩余的可以以后用来扩展。权限的叠加是按位与运算...

    在Web App中 ,存在和游客(匿名用户),普通用户,协管员,管理员等不同的角色,应当为不同的角色赋予不同的权限。各个用户只能在权限范围内访问页面、进行操作等。

    通过一个例子来说明。本例中的用户分为4中:游客、普通用户、协管员、管理员。不同的用户有着不同的权限。

    一、在数据库中表示不同的角色

    权限有这么几种:


    操作的权限使用8位二进制数表示,现在只用了5位,剩余的可以以后用来扩展。

    权限的叠加是按位与运算,列如:拥有关注用户和写文章的权限应当是0b00000001&0b00000100,结果是0b00000101。

    也容易反推出,0b00000011是0b00000001&0b00000010,因此权限是:关注用户和在他人文章中写评论。

    用户的不同角色在数据库SQLite中存储,权限的位值(permission)作为角色的一个字段。

    roles表的字段:


    使用python代码实现:

    # app/models.py
    
    class Role(db.Model):
        __tablename__ = 'roles'
        id = db.Column(db.Integer, primary_key=True)
        name = db.Column(db.String(64), unique=True)
        default = db.Column(db.Boolean,default=False,index=True)
        permissions = db.Column(db.Integer)                                      #值是整数,表示位标志。
        users = db.relationship('User', backref='role', lazy='dynamic')

    在Role类中定义一个静态方法,提供将记录写入数据库的方法

    # app/models.py
    
    class Role(db.model):
        @staticmethod
        def insert_roles():
            '''并不直接创建角色,而是根据数据库现有角色,然后进行更新。以后角色有更改也可执行同样操作。'''
            roles = {
                'User':(Permission.FOLLOW |Permission.COMMENT |Permission.WRITE_ARTICLES ,True),
                'Moderator':(Permission.FOLLOW |Permission.COMMENT |Permission.WRITE_ARTICLES |Permission.MODERATE_COMMENTS,False),
                'Administrator':(0xff,False)
            }
            for r in roles:
                role = Role.query.filter_by(name=r).first()
                if role is None:
                    role = Role(name=r)
                role.permissions = roles[r][0]
                role.default = roles[r][1]
                db.session.add(role)
            db.session.commit()

    roles有三种:

    'User':表示普通用户,权限值(permission)是(Permission.FOLLOW |Permission.COMMENT |Permission.WRITE_ARTICLES ,True),其中Permission是定义了各种权限的类(相当于C++中的枚举),default是True。

    'Modetator':表示协管员,权限值也列出来了,default是False。

    'Administrator':表示管理员,权限值是oxff,转化为二进制是0b11111111,表示拥有所有权限。default是False。

    调用这个静态方法,会把三种角色和各自的权限值写入数据库中。

    最后还有一个:游客,游客不需要登录,不需要在数据库中有表示。

    以上完成后,可以使用shell对话,去写入数据库。


    二、赋予角色

    一个新用户注册以后,要给他赋予一个角色。看他是普通用户,还是协管员,还是管理员。、

    新用户注册时,会实例化一个User类 ,然后调用db.session.add(u)和db.session.commit()直至提交到数据库。

    在实例化User类时,根据邮箱判断角色。

    # app/models
    
    class User(UserMixin,db.Model):
        __tablename__ = 'users'
        id = db.Column(db.Integer, primary_key=True)                        #id列
        username = db.Column(db.String(64), unique=True, index=True)        #username列
        role_id = db.Column(db.Integer, db.ForeignKey('roles.id'))          #role_id列
        password_hash = db.Column(db.String(128))                            #密码hash列
        email = db.Column(db.String(64),unique=True,index=True)             #email列
        confirmed = db.Column(db.Boolean,default=False)
    
        def __init__(self,**kwargs):
            '''构造函数:首先调用基类构造函数,如果创建基类对象后没定义角色,则根据email地址决定其角色'''
            super(User,self).__init__(**kwargs)
            if self.role is None:
                if self.email == current_app.config['FLASKY_ADMIN']:
                    self.role = Role.query.filter_by(permissions=0xff).first()
                if self.role is None:
                    self.role = Role.query.filter_by(default=True).first()

    role_id = db.Column(db.Integer, db.ForeignKey('roles.id'))          #users表

    users = db.relationship('User', backref='role', lazy='dynamic')      #roles表
       role_id是外键,和roles.id联结。可以通过u.role访问到联结的role对象。

    self.email == current_app.config['FLASKY_ADMIN']  :   判断email为特定地址的话,就设定 self.role = Role.query.filter_by(permissions=0xff).first()。

    三、验证角色

    为了更好更快的验证当前角色有没有某些权限,就为User定义了一些方法。

    # app/models.py
    
    class User(UserMixin,db.models):
        def can(self,permissions):
            '''检查permissions要求的权限角色是否允许'''
            return self.role is not None and (self.role.permissions & permissions)==permissions
    
        def is_administrator(self):
            '''检查是否管理员'''
            return self.can(Permission.ADMINISTER)

    self.role is not None and (self.role.permissions & permissions)==permissions: 

    要为True,需要满足两个条件:

    1、role不为空,

    2、role的权限值(self.role.permission)和要验证的权限(permission)的按位与操作值要和permission相等。

    处于一致性考虑,还定义了AnonymousUserMixin类,并实现了can()方法和is_administrator()方法。再把它设为用户未登录时的current_user值。

    # app/models.py
    
    class AnonymousUser(AnonymousUserMixin):
        '''为了和User类保持一致,
        匿名登录时,使用current_user对象的类'''
        def can(self,permissions):
            return False
    
        def is_administrator(self):
            return False
    
    login_manager.anonymous_user = AnonymousUser

    用户分好了,不同用户的权限分好了,验证用户权限的方法也实现了。下面就是在视图函数中根据用户的不同 决定是否可以访问某些页面 。

    首先,为了方便,定义了一些装饰器。

    # app/decorators.py
    '''定义装饰器'''
    
    from functools import wraps
    from flask import abort
    from flask_login import current_user
    from .models import Permission
    
    def permission_required(permission):
        '''定义装饰器@permission_required(permission)'''
        def decorator(f):
            @wraps(f)
            def decorated_function(*args,**kwargs):
                if not current_user.can(permission):                        #如果当前用户不具有permission则抛出403错误。
                    abort(403)
                return f(*args,**kwargs)
            return decorated_function
        return decorator
    
    def admin_required(f):
        '''定义装饰器@admin_required'''
        return permission_required(Permission.ADMINISTER)(f)

    注意:403.html也要实现一下。

    然后,在视图函数中使用这些装饰器 

    # app/main/views.py
    
    @main.route('/admin')
    @login_required
    @admin_required
    def for_admin_only():
        '''测试:管理员权限'''
        role = 'admin'
        return render_template('for_permission_test.html',role=role)
    
    @main.route('/moderator')
    @login_required
    @permission_required(Permission.MODERATE_COMMENTS)
    def for_moderator_only():
        '''测试:协管员权限'''
        role = 'moderator'
        return render_template('for_permission_test.html',role=role)

    /admin的URL只有拥有管理员权限的用户才能访问。

    /moderator的URL也只有拥有协管(以上)权限的用户才能访问。


    在模板中使用Permission类的方法。

    还记得Permission类是定义了各种权限的值的吗?为了在模板中也能使用Permission类,可以使用上下文管理器

    # app/main/__init__.py
    
    @main.app_context_processor
    def inject_permissions():
        '''使用上下文处理器,是变量在模板全局中可访问'''
        return dict(Permission=Permission)










    展开全文
  • Spring Security用户认证和权限控制(默认实现)

    万次阅读 多人点赞 2019-03-28 13:58:02
    使用oauth

    1 背景

    实际应用系统中,为了安全起见,一般都必备用户认证(登录)和权限控制的功能,以识别用户是否合法,以及根据权限来控制用户是否能够执行某项操作。

    Spring Security是一个安全相关的框架,能够与Spring项目无缝整合,本文主要是介绍Spring Security默认的用户认证和权限控制的使用方法和原理,但不涉及到自定义实现。

    Spring Security用户认证和权限控制(自定义实现)这篇文章专门讲解用户认证和权限控制相关的自定义实现。

    2 实战示例

    2.1 创建工程

    创建一个名为authentication-server的spring boot工程,项目结构如下图所示:
    在这里插入图片描述
    说明:该spring boot工程主要是整合了Spring Security框架和Spring MVC框架。

    2.2 配置说明

    pom.xml配置文件如下所示:

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.authentication.server</groupId>
        <artifactId>authentication-server</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>authentication-server</name>
        <description>统一用户认证中心</description>
    
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.1.3.RELEASE</version>
            <relativePath/> <!-- lookup parent from repository -->
        </parent>
    
        <properties>
            <java.version>1.8</java.version>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-security</artifactId>
            </dependency>
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    
    </project>
    

    application.yml配置文件如下所示:

    server:
      port: 8080
    

    2.2 用户认证

    要想使用Spring Security框架,配置类需要继承WebSecurityConfigurerAdapter类,并通过注解@EnableWebSecurity来启用Spring Security。

    本文的用户认证是使用Spring Security默认的基于用户名和密码的表单认证,需要在配置类中重写protected void configure(AuthenticationManagerBuilder auth)方法,并在重写的方法中指定默认从哪里获取认证用户的信息,即指定一个UserDetailsService接口的实现类。此外,还需要重写protected void configure(HttpSecurity http)方法,并在重写的方法中进行一系列的安全配置。本示例的配置类WebSecurityConfig代码如下所示:

    package com.authentication.server.config;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.annotation.Bean;
    import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
    import org.springframework.security.config.annotation.web.builders.HttpSecurity;
    import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
    import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
    import org.springframework.security.core.userdetails.UserDetailsService;
    import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
    import org.springframework.security.crypto.password.PasswordEncoder;
    
    /**
     * Spring Security配置类
     */
    @EnableWebSecurity
    public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
    
        @Autowired
        private UserDetailsService userDetailsServiceImpl;
    
        /**
         * 用户认证配置
         */
        @Override
        protected void configure(AuthenticationManagerBuilder auth) throws Exception {
            /**
             * 指定用户认证时,默认从哪里获取认证用户信息
             */
            auth.userDetailsService(userDetailsServiceImpl);
        }
    
        /**
         * Http安全配置
         */
        @Override
        protected void configure(HttpSecurity http) throws Exception {
            /**
             * 表单登录:使用默认的表单登录页面和登录端点/login进行登录
             * 退出登录:使用默认的退出登录端点/logout退出登录
             * 记住我:使用默认的“记住我”功能,把记住用户已登录的Token保存在内存里,记住30分钟
             * 权限:除了/toHome和/toUser之外的其它请求都要求用户已登录
             * 注意:Controller中也对URL配置了权限,如果WebSecurityConfig中和Controller中都对某文化URL配置了权限,则取较小的权限
             */
            http
                .formLogin()
                    .defaultSuccessUrl("/toHome", false)
                    .permitAll()
                    .and()
                .logout()
                    .permitAll()
                    .and()
                .rememberMe()
                    .tokenValiditySeconds(1800)
                    .and()
                .authorizeRequests()
                    .antMatchers("/toHome", "/toUser")
                    .permitAll()
                    .anyRequest()
                    .authenticated();
        }
    
        /**
         * 密码加密器
         */
        @Bean
        public PasswordEncoder passwordEncoder() {
            /**
             * BCryptPasswordEncoder:相同的密码明文每次生成的密文都不同,安全性更高
             */
            return new BCryptPasswordEncoder();
        }
    
    }
    

    Spring Security进行用户认证时,需要根据用户的账号、密码、权限等信息进行认证,因此,需要根据查询到的用户信息封装成一个认证用户对象并交给Spring Security进行认证。查询用户信息并封装成认证用户对象的过程是在UserDetailsService接口的实现类(需要用户自己实现)中完成的。本示例的UserDetailsService接口实现类UserDetailsServiceImpl的代码如下所示:

    package com.authentication.server.service.impl;
    
    import com.authentication.server.model.AuthUser;
    import com.authentication.server.service.AuthUserService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.security.core.GrantedAuthority;
    import org.springframework.security.core.authority.SimpleGrantedAuthority;
    import org.springframework.security.core.userdetails.User;
    import org.springframework.security.core.userdetails.UserDetails;
    import org.springframework.security.core.userdetails.UserDetailsService;
    import org.springframework.security.core.userdetails.UsernameNotFoundException;
    import org.springframework.stereotype.Component;
    import org.springframework.util.StringUtils;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * 自定义的认证用户获取服务类
     */
    @Component("userDetailsServiceImpl")
    public class UserDetailsServiceImpl implements UserDetailsService {
    
        @Autowired
        private AuthUserService authUserServiceImpl;
    
        /**
         * 根据用户名获取认证用户信息
         */
        @Override
        public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
            if(StringUtils.isEmpty(username)) {
                throw new UsernameNotFoundException("UserDetailsService没有接收到用户账号");
            } else {
                /**
                 * 根据用户名查找用户信息
                 */
                AuthUser authUser = authUserServiceImpl.getAuthUserByUsername(username);
                if(authUser == null) {
                    throw new UsernameNotFoundException(String.format("用户'%s'不存在", username));
                }
                List<GrantedAuthority> grantedAuthorities = new ArrayList<>();
                for (String role : authUser.getRoles()) {
                    //封装用户信息和角色信息到SecurityContextHolder全局缓存中
                    grantedAuthorities.add(new SimpleGrantedAuthority(role));
                }
                /**
                 * 创建一个用于认证的用户对象并返回,包括:用户名,密码,角色
                 */
                return new User(authUser.getUsername(), authUser.getPassword(), grantedAuthorities);
            }
        }
    }
    

    查询用户信息的接口AuthUserService 的代码如下所示:

    package com.authentication.server.service;
    
    import com.authentication.server.model.AuthUser;
    
    /**
     * 用户服务类
     */
    public interface AuthUserService {
    
        /**
         * 通过用户账号获取认证用户信息
         */
        AuthUser getAuthUserByUsername(String username);
    
    }
    

    查询用户信息的接口实现类AuthUserServiceImpl的代码如下所示:

    package com.authentication.server.service.impl;
    
    import com.authentication.server.model.AuthUser;
    import com.authentication.server.service.AuthUserService;
    import org.springframework.stereotype.Service;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * 用户服务实现类
     */
    @Service
    public class AuthUserServiceImpl implements AuthUserService {
    
        /**
         * 通过用户账号获取用户信息
         */
        @Override
        public AuthUser getAuthUserByUsername(String username) {
            /**
             * 实际上这里应该是从数据库中查询或者是调用其它服务接口获取,
             * 为了方便,这里直接创建用户信息
             * admin用户拥有 ROLE_ADMIN 和 ROLE_EMPLOYEE 这两个角色
             * employee用户拥有 ROLE_EMPLOYEE 这个角色
             * temp用户没有角色
             */
            if(username.equals("admin")) {
                AuthUser user = new AuthUser();
                user.setId(1L);
                user.setUsername("admin");
                /**
                 * 密码为123(通过BCryptPasswordEncoderl加密后的密文)
                 */
                user.setPassword("$2a$10$U6g06YmMfRJXcNfLP28TR.xy21u1A5kIeY/OZMKBDVMbn7PGJiaZS");
                List<String> roles = new ArrayList<>();
                roles.add("ROLE_ADMIN");
                roles.add("ROLE_EMPLOYEE");
                user.setRoles(roles);
                return user;
            } else if(username.equals("employee")) {
                AuthUser user = new AuthUser();
                user.setId(2L);
                user.setUsername("employee");
                /**
                 * 密码为123(通过BCryptPasswordEncoderl加密后的密文)
                 */
                user.setPassword("$2a$10$U6g06YmMfRJXcNfLP28TR.xy21u1A5kIeY/OZMKBDVMbn7PGJiaZS");
                List<String> roles = new ArrayList<>();
                roles.add("ROLE_EMPLOYEE");
                user.setRoles(roles);
                return user;
            } else if (username.equals("temp")) {
                AuthUser user = new AuthUser();
                user.setId(3L);
                user.setUsername("temp");
                /**
                 * 密码为123(通过BCryptPasswordEncoderl加密后的密文)
                 */
                user.setPassword("$2a$10$U6g06YmMfRJXcNfLP28TR.xy21u1A5kIeY/OZMKBDVMbn7PGJiaZS");
                List<String> roles = new ArrayList<>();
                user.setRoles(roles);
                return user;
            } else {
                return null;
            }
        }
    
    }
    

    用户信息实体类如下所示:

    package com.authentication.server.model;
    
    import java.util.List;
    
    /**
     * 用户实体类
     */
    public class AuthUser {
        /** 用户ID */
        private Long id;
        /** 用户账号 */
        private String username;
        /** 账号密码 */
        private String password;
        /** 角色集合 */
        private List<String> roles;
    
        public Long getId() {
            return id;
        }
    
        public void setId(Long id) {
            this.id = id;
        }
    
        public String getUsername() {
            return username;
        }
    
        public void setUsername(String username) {
            this.username = username;
        }
    
        public String getPassword() {
            return password;
        }
    
        public void setPassword(String password) {
            this.password = password;
        }
    
        public List<String> getRoles() {
            return roles;
        }
    
        public void setRoles(List<String> roles) {
            this.roles = roles;
        }
    }
    

    用户认证成功之后,可以通过@AuthenticationPrincipal注解来获取认证用户信息,本示例中获取认证用户信息的web入口类UserController的代码如下所示:

    package com.authentication.server.controller;
    
    import org.springframework.security.core.annotation.AuthenticationPrincipal;
    import org.springframework.security.core.userdetails.UserDetails;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.security.Principal;
    
    /**
     * 用户接口类(返回JSON)
     */
    @RestController
    public class UserController {
    
        /**
         * 获取登录后的Principal(需要登录)
         */
        @GetMapping("/getPrincipal")
        public Object getPrincipal(@AuthenticationPrincipal Principal principal){
            return principal;
        }
    
        /**
         * 获取登录后的UserDetails(需要登录)
         */
        @GetMapping("/getUserDetails")
        public Object getUserDetails(@AuthenticationPrincipal UserDetails userDetails) {
            return userDetails;
        }
    
    }
    

    2.3 权限控制

    Spring Security提供了默认的权限控制功能,需要预先分配给用户特定的权限,并指定各项操作执行所要求的权限。用户请求执行某项操作时,Spring Security会先检查用户所拥有的权限是否符合执行该项操作所要求的权限,如果符合,才允许执行该项操作,否则拒绝执行该项操作。

    本示例中使用的是Spring Security提供的方法级别的权限控制,即根据权限来控制用户是否能够请求某个方法。首先,需要在工程的主启动类中使用注解@EnableGlobalMethodSecurity(prePostEnabled = true)来启动方法级别的权限控制,并指定是在方法执行之前进行权限验证;然后,需要在方法的入口处通过注解@PreAuthorize()来指定执行对应方法需要什么样的权限。

    本示例的主启动类AuthenticationServerApplication的代码如下所示:

    package com.authentication.server;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
    
    /**
     * 主启动类
     */
    @ComponentScan("com.authentication.server.*")
    @EnableGlobalMethodSecurity(prePostEnabled = true)
    @SpringBootApplication
    public class AuthenticationServerApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(AuthenticationServerApplication.class, args);
        }
    
    }
    
    

    本示例中使用的是基于角色的权限控制,即验证用户所拥有的角色是否符合执行某个方法所需要的角色,如果符合,才允许执行该方法,否则拒绝执行该方法。需要在方法入口处通过注解 @PreAuthorize(“hasRole(‘角色名称’)”)来指定执行对应方法需要什么角色,并且是在执行对应方法之前进行角色验证。

    本示例的方法入口控制类PageController的代码如下所示:

    package com.authentication.server.controller;
    
    import org.springframework.security.access.prepost.PreAuthorize;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    
    /**
     * 页面接口类(页面跳转)
     */
    @Controller
    public class PageController {
    
        /**
         * 跳转到admin.html页面(需要登录,且需要ROLE_ADMIN角色)
         */
        @GetMapping("/toAdmin")
        @PreAuthorize("hasRole('ROLE_ADMIN')")
        public String toAdmin() {
            return "admin.html";
        }
    
        /**
         * 跳转到employee.html页面(需要登录,且需要ROLE_EMPLOYEE角色)
         */
        @GetMapping("/toEmployee")
        @PreAuthorize("hasRole('ROLE_EMPLOYEE')")
        public String toEmployee() {
            return "employee.html";
        }
    
        /**
         * 跳转到employee.html页面(需要登录,但不需要角色)
         * 注意:虽然WebSecurityConfig中配置了/toUser不需要登录,但是这里配置的权限更小,因此,/toUser以这里的配置为准
         */
        @GetMapping("/toUser")
        @PreAuthorize("isAuthenticated()")
        public String toUser() {
            return "user.html";
        }
    
        /**
         * 跳转到home.html页面(需要登录,但不需要角色)
         * 注意:虽然这里配置了/toAbout不需要登录,但WebSecurityConfig中配置的权限更小,因此,/toAbout以WebSecurityConfig中配置的为准
         */
        @RequestMapping("/toAbout")
        @PreAuthorize("permitAll")
        public String toAbout() {
            return "about.html";
        }
    
    
        /**
         * 跳转到home.html页面(不需要登录)
         */
        @RequestMapping("/toHome")
        public String toHome() {
            return "home.html";
        }
    
    }
    

    静态页面admin.html的代码如下所示:

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>admin页面</title>
    </head>
    <body>
        <h1>这是Admin页面(需要登录,且需要ROLE_ADMIN角色)</h1>
    </body>
    </html>
    

    静态页面employee.html、user.html、home.html、about.html的代码与admin.html的相似,就不一一展示。

    3 功能测试

    3.1 用户认证功能测试

    运行AuthenticationServerApplication主启动类以启动项目,然后通过浏览器访问以下地址请求toUser()方法(即访问user.html页面),由于toUser()方法需要用户经过认证之后才能访问,因此,会自动跳转到用户认证页面(如下图所示)进行认证:

    http://localhost:8080/toUser
    

    在这里插入图片描述
    输入用户名admin和密码123并点击Sign in按钮,认证成功后会自动请求/toHome路径并跳转到自定义的认证成功跳转页面home.hmtl(如下图所示):
    在这里插入图片描述
    通过浏览器访问以下地址可以查看到认证用户信息如下图所示:

    http://localhost:8080/getPrincipal
    http://localhost:8080/getUserDetails
    

    在这里插入图片描述
    在这里插入图片描述

    3.2 “记住我” 功能测试

    用户进行认证时,如果勾选了用户认证页面中的Remember me on this computer选项,则当用户关闭浏览器之后,系统会记住该用户一段时间(由设置的有效期决定,本示例中是1800秒),如果在这段时间之内,当用户重新访问该系统时,用户不需要重新进行认证就已经是已认证的状态。

    使用用户名admin和密码123进行用户认证时勾选上用户认证页面中的Remember me on this computer选项,然后重复执行关闭浏览器后再访问以下地址,并观察关闭了浏览器之后,再重新访问时是跳转到认证页面(未认证状态)还是直接跳转到了user.html页面(已认证状态):

    http://localhost:8080/toUser
    

    3.3 退出功能测试

    用户认证成功之后,用户就处于已认证的状态,就可以在权限之内访问系统,此时可以通过访问以下地址请求退出已认证状态:

    http://localhost:8080/logout
    

    首先会跳转到退出确认页面(如下图所示),用户点击了Log Out按钮之后才会真正的执行退出操作,即回到未认证状态。
    在这里插入图片描述

    3.4 权限控制功能测试

    用户在未认证的情况下通过浏览器访问以下地址请求toAdmin()方法(即访问admin.html页面),由于该方法要求用户已认证且具有ROLE_ADMIN权限才能访问,因此会自动跳转到用户认证页面。

    http://localhost:8080/toAdmin
    

    此时如果用用户名employee和密码123进行认证,认证成功之后由于该用户没有ROLE_ADMIN权限,因此会自动跳转到没有权限的页面(如下图所示):
    在这里插入图片描述
    如果用用户名admin和密码123进行认证,认证成功之后由于该用户拥有ROLE_ADMIN权限,因此会自动跳转到admin.html页面(如下图所示):
    在这里插入图片描述
    可见,确实起到了权限控制的作用。

    4 原理分析

    4.1 用户认证的过滤器链

    Spring Security的用户认证流程是由一系列的过滤器链来实现的,默认的关于用户认证的过滤器链大致如下图所示:
    在这里插入图片描述

    • SecurityContextPersistenceFilter: 在请求开始时,从配置好的 SecurityContextRepository 中获取 SecurityContext,并设置给 SecurityContextHolder。在请求完成后,把 SecurityContextHolder 所持有的SecurityContext 保存到配置好的 SecurityContextRepository,同时清除 securityContextHolder 所持有的 SecurityContext。

    • UsernamePasswordAuthenticationFilter: 用于处理来自表单提交的认证。该表单必须提供用户名和密码,其内部还有登录成功或失败后的处理器 AuthenticationSuccessHandler 和 AuthenticationFailureHandler。

    • ExceptionTranslationFilter: 能够捕获过滤器链中产生的所有异常,但只处理两类异常:AuthenticationException 和 AccessDeniedException,而其它的异常则继续抛出。
      如果捕获到的是 AuthenticationException,那么将会使用其对应的 AuthenticationEntryPoint 的commence()方法进行处理。在处理之前,ExceptionTranslationFilter会先使用 RequestCache 将当前的HttpServerletRequest的信息保存起来,以至于用户登录成功后可以跳转到之前的界面。
      如果捕获到的是 AccessDeniedException,那么将会根据当前访问的用户是否已经登录认证而做不同的处理,如果未登录,则使用关联的 AuthenticationEntryPoint 的 commence()方法进行处理,否则使用关联的 AccessDeniedHandler 的handle()方法进行处理。

    • FilterSecurityInterceptor: 用于保护HTTP资源的,它需要一个 AuthenticationManager 和一个 AccessDecisionManager 的引用。它会从 SecurityContextHolder 中获取 Authentication,然后通过 SecurityMetadataSource 可以得知当前请求是否在请求受保护的资源。对于请求那些受保护的资源,如果 Authentication.isAuthenticated() 返回false(即用户未认证),或者FilterSecurityInterceptor 的 alwaysReauthenticate 属性的值为 true,那么将会使用其引用的 AuthenticationManager 对Authentication进行认证,认证之后再使用认证后的 Authentication 替换 SecurityContextHolder 中原有的那个。然后使用 AccessDecisionManager 对用户当前请求进行权限检查。

    4.2 用户认证的流程

    Spring Security支持多种用户认证的方式,最常用的是基于用户名和密码的用户认证方式,其认证流程如下图所示:
    在这里插入图片描述

    4.3 “记住我” 功能的流程

    用户可以使用账号和密码进行认证,但是如果用户使用账号和密码进行认证时选择了“记住我”功能,则在有效期内,当用户关闭浏览器后再重新访问服务时,不需要用户再次输入账号和密码重新进行认证,而是通过“记住我”功能自动认证。

    “记住我”功能的认证流程如下图所示:
    在这里插入图片描述
    上述的用户认证处理逻辑都是基于Spring Security提供的默认实现,我们只需要自己实现一个UserDetailsService接口用于获取用户认证信息即可,十分简便。当然,Spring Security也能够支持我们使用自定义的用户认证处理逻辑,我们可以自己实现AuthenticationFilter和AuthenTicationProvider,以达到按照需求进行用户认证的目的。博主的另外一篇文章会专门分享自定义用户认证的实现。

    4.4 权限控制的原理

    Spring Security允许我们通过Spring EL权限验证表达式来指定访问URL或方法所需要的权限,用户在访问某个URL或方法时,如果对应的权限验证表达式返回结果为true,则表示用户拥有访问该URL或方法的权限,如果返回结果为false,则表示没有权限。Spring Security为我们提供了以下的权限验证表达式:

    表达式描述
    hasRole([role])当前用户是否拥有指定角色。
    hasAnyRole([role1,role2])多个角色是一个以逗号进行分隔的字符串。如果当前用户拥有指定角色中的任意一个则返回true。
    hasAuthority([auth])等同于hasRole
    hasAnyAuthority([auth1,auth2])等同于hasAnyRole
    Principle代表当前用户的principle对象
    authentication直接从SecurityContext获取的当前Authentication对象
    permitAll总是返回true,表示允许所有的
    denyAll总是返回false,表示拒绝所有的
    isAnonymous()当前用户是否是一个匿名用户
    isRememberMe()表示当前用户是否是通过Remember-Me自动登录的
    isAuthenticated()表示当前用户是否已经登录认证成功了。
    isFullyAuthenticated()如果当前用户既不是一个匿名用户,同时又不是通过Remember-Me自动登录的,则返回true。

    权限验证表达式只能验证用户是否具有访问某个URL或方法的权限,但是权限验证的这个步骤可以在不同的阶段进行。Spring Security中定义了以下四个支持使用权限验证表达式的注解,其中前两者可以用来在方法调用前或者调用后进行权限验证,后两者可以用来对集合类型的参数或者返回值进行过滤:

    • @PreAuthorize
    • @PostAuthorize
    • @PreFilter
    • @PostFilter

    权限验证表达式需要和注解结合使用,示例如下所示:

    @PreAuthorize("hasRole('ROLE_ADMIN')")
    public void addUser(User user) {
       ...
    }
    
    @PreAuthorize("hasRole('ROLE_USER') or hasRole('ROLE_ADMIN')")
    public User find(int id) {
       return null;
    }
    
    @PreAuthorize("#id<10")
    public User find(int id) {
       return null;
    }
    
    @PreAuthorize("principal.username.equals(#username)")
    public User find(String username) {
       return null;
    }
    
    @PreAuthorize("#user.name.equals('abc')")
    public void add(User user) {
       ...
    }
    
    @PostAuthorize("returnObject.id%2==0")
    public User find(int id) {
       ...
       return user;
    }
    
    @PostFilter("filterObject.id%2==0")
    public List<User> findAll() {
       List<User> userList = new ArrayList<User>();
       ...
       return userList;
    }
    
    @PreFilter(filterTarget="ids", value="filterObject%2==0")
    public void delete(List<Integer> ids, List<String> usernames) {
       ...
    }
    

    5 总结

    本文从使用方法和原理分析这两个方法简要的介绍了Spring Security的用户认证和权限控制这两大功能,但都是基于Spring Security的默认实现,我们也可以自定义用户认证和权限控制的实现逻辑,Spring Security用户认证和权限控制(自定义实现)详细介绍了用户认证相关和权限控制相关的自定义实现。关于授权服务器、资源服务器的内容可以查阅以下几篇文章:

    OAuth2授权服务器和四种授权方式 这篇文章介绍了授权服务器和四种授权方式的配置与使用方法。
    OAuth2资源服务器 这篇文章介绍了基于方法级别的权限控制的资源服务器的配置与使用方法。

    如果觉得本文对您有帮助,请关注博主的微信公众号,会经常分享一些Java和大数据方面的技术案例!
    在这里插入图片描述

    展开全文
  • 3. 掌握基于url的权限管理(不使用Shiro权限框架的情况下实现权限管理) 4. shiro实现用户认证 5. shiro实现用户授权 6. shiro与企业web项目整合开发的方法 权限管理原理知识 什么是权限管理 只要有用户参与的系统一般...
  • 数据库实验四 用户权限管理

    千次阅读 2019-05-22 16:08:13
    某种权限用户对其它用户的表或视图的存取权限(针对表或视图而言)。   二、系统权限管理:   1 、系统权限分类: DBA :拥有全部特权,是系统最高权限,只有DBA才可以创建数据库结构。 ...
  • 用户登陆权限管理

    千次阅读 2018-10-07 20:07:25
    版权声明:本文为博主原创文章,未经博主允许不得转载。... 知识清单 1.了解基于资源的权限管理方式 2. 掌握权限数据模型 3. 掌握基于url的权限管理(不使用Shiro权限框架的情况...
  • Oracle数据库用户权限查询和一些查看操作(汇总) 2018年07月22日 20:32:38 茶木君 阅读数:1222 标签: oracle 更多 个人分类: oracle dba权限:user为有dba权限的账号,如sys,system,或者是已经被授予...
  • 04 用户权限管理 实验报告

    千次阅读 2018-07-30 01:05:37
    04 用户权限管理 实验报告  广州大学学生实验报告  开课学院及实验室:计算机科学与工程实验室418B室 ...
  • LDAP系列三用户权限控制

    千次阅读 2019-05-24 18:12:15
    二:权限控制 8.1:访问控制 访问控制主要是通过在slapd.conf文件中配置来实现,具体配置解析如下: # Sample Access Control # Allow read access of root DSE # Allow self write access # Allow ...
  • 查看某个用户在某个对象的权限,可以查dba_tab_privs 或者user_tab_privs   如下:某普通用户登陆,查自己的角色 SQL> select * from user_role_privs;   查自己拥有哪些系统权限 ...
  • centos添加用户权限 介绍 (Introduction) When you first start using a fresh Linux server, adding and removing users is often one of first things you’ll need to do. In this guide, we will cover how to...
  • 13. 用户登录-准备工作 在开发注册功能时,在SecurityConfig类中配置以如下代码: @Override protected void configure(HttpSecurity http) throws Exception { http.csrf().disable(); } 以上代码的作用是关闭...
  • 数据库实验四(用户权限管理 )

    千次阅读 2017-06-04 20:44:38
    1. 用 SYSTEM 账户登录数据库,创建用户 A、B、C,密码分别为 A、B、C; create user A identified by A; create user B ...2. 用 SYSTEM 账户把 CREATE SESSION 和 CREATE TABLE 权限授予给用户 A,并 允许
  • linux中用户组和权限问题

    千次阅读 2018-12-18 08:56:09
    用户、组、权限 一、权限:r, w, x 1.文件权限:  r:可读,可以使用类似cat等命令查看文件内容;  w:可写,可以编辑或删除此文件;  x: 可执行,eXacutable,可以命令提示符下当作命令提交给内核运行; 2.目录...
  • 权限管理和权限继承

    千次阅读 2022-01-20 01:45:24
    权限管理,一般指根据系统设置的安全规则或者安全策略,用户可以访问而且只能访问自己被授权的资源。权限管理几乎出现在任何系统里面,只要有用户和密码的系统。 1.2 关键对象 subject:主体,可以理解为用户或者是...
  • wordpress注册用户权限

    千次阅读 2020-08-27 08:45:21
    WordPress支持多用户功能,并且默认给注册用户赋予五种默认权限,你完全可以把它打造为一个论坛,下面一起看看开启注册新用户权限分配。 开启注册功能 1、登录后台->设置->常规->成员资格->任何人都...
  • Gitlab用户权限管理

    千次阅读 2017-05-15 16:09:29
    使用的时候,需要创建项目,而且会有对应的用户在项目中。下面练习这个操作- 新建用户组1、点击右上角的扳手按钮2、在弹出的对话框中选择 new group3、Private:只有授权的用户才可以看到Internal:只要是登录上来...
  • 但是这些和我们只是单纯工具使用者来说,压根不受影响,最起码80%的api调用方式还是依照之前版本的方式,总之大的变动不明显,小的优化一堆堆。这也是作者想用新技术的原因,就贪了那点性能。 产品思路方向: 按照...
  • 例如,create table权限允许用户创建表,grant any privilege 权限允许用户授予任何系统权限。 对象权限( database object privilege )可以让用户能够对各个对象进行某些操作。例如delete权限允许用户删除表或视图...
  • 2.2.1、创建自定义UserDetailsService 这是实现自定义用户认证的核心逻辑,loadUserByUsername(String username)的参数就是登录时提交的用户名,返回类型是一个叫UserDetails 的接口,需要在这里构造出他的一个实现...
  • 用户权限管理 (Oracle实验)

    千次阅读 2018-07-17 17:07:04
    掌握Oracle中系统权限和对象权限的概念,能熟练进行用户权限的授予与回收;理解角色的基本概念,能熟练使用角色进行权限的授予与回收。 (二)实验要求 熟悉实验室实验环境,阅读实验预备知识,掌握本实验内容涉及...
  • TFS 使用心得--权限管理

    千次阅读 2017-11-13 19:06:44
    最近一段时间负责管理公司技术人员的TFS的权限分配,在此之前,我对tfs一点都不了解,没用过,也没听朋友用过,只在进公司时指导我的组长帮我把这个工具装上,告知要在上面报bug,即bug管理在上面,之后的很长一段...
  • 很多人觉得Spring Security实现登录验证很难,我最开始学习的时候也这样觉得。因为我好久都没看懂我该怎么...你只需要告诉Spring Security用户信息、角色信息、权限信息、登录页是什么?登陆成功页是什么?或者其他...
  • username role 权限 elastic superuser 内置的超级用户 kibana ...Kibana服务器以该用户身份提交请求以访问集群监视API和 .kibana索引。不能访问index。 logstash_system lo...
  • ORACLE 用户、Profile 及权限

    万次阅读 2014-05-25 18:50:25
    用户管理一、创建用户:创建的新用户是没有任何权限的,甚至连登陆的数据库的权限都没有,需要为其指定相应的权限。 SQL> Create User username Identified by password Default Tablespace tablespace ...
  • 在上一篇文章中我们搭建了svn服务器以及创建了一个demo仓库,使用匿名用户将这个demo仓库co到了本地。而这篇文章将会来学习一下如何设定相关的用户/组/权限相关信息。
  • Shiro权限控制+整合shiro

    万次阅读 多人点赞 2019-03-02 13:17:56
    Shiro权限控制 0.1传统的权限认证方式 特点:为每个人单独的分配权限模块,能够实现权限控制,但是当公司人员庞大之后,非常难管理 上述权限控制如何设计表? 关系:员工和菜单权限的关系:多对多 员工id 菜单...
  • 概要介绍: 历经半个多月的时间,Debug亲自撸的 “企业员工角色权限管理平台” 终于完成了。正如字面意思,本课程...其中的核心业务模块主要包括用户模块、部门模块、岗位模块、角色模块、菜单模块和系统日志模块;...
  • 帆软报表权限控制

    千次阅读 2019-04-02 15:52:07
    问题:实际应用环境中,不同角色的人可能对数据具有不同的访问权限,通过直接在SQL语句中筛选出需要的数据制作模板可以解决该需求,但对于角色较多的情况,就需要制作很多张样式相同只是数据集不同的报表,不利于...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 103,689
精华内容 41,475
关键字:

具有提交权限的用户使用