精华内容
下载资源
问答
  • SQL中使用GRAND和REVOKE语句向用户授予或收回对数据的操作权限。GRANT语句向用户授予权限。REVOKE语句收回已经授予用户的权限 1、GRANT: GRANT语句的格式一般为: GRANT[,]… ON[,]… TO[,]… [WITH GRANT OPTION];...
  • 【4.1】把查询Student表权限授给用户U1 GRANT SELECT ON TABLE Student TO U1; --标准SQL GRANT SELECT ON Student TO U1; ...在SQLserver中要运行此语句,必须删除TABLE。...结果报错说“拒绝了对对象 ‘Student’
  • GRANT GRANT [,]... ON [, ]… TO [,]... [WITH GRANT OPTION]; WITH GRANT OPTION子句,指定:可以再授予,没有指定:不能传播 语义:将对指定操作对象的指定操作权限授予指定的用户 首先,建立登录名U1-U7,再...
  • 这使revoke.cash可以显示诸如Aave或Compound的应用程序名称,而不是其智能合约地址。 此列表可由任何其他应用程序使用,有关此集成的示例,请参见。 在本地运行 git clone git@github.com:rkalis/r
  • 文章目录 第六十六章 SQL命令 REVOKE大纲参数描述撤销的角色撤销对象权限撤销对象所有者特权撤销表级和列级特权CASCADE 或 RESTRICT对缓存查询的影响IRIS Security示例 第六十六章 SQL命令 REVOKE 从用户或角色中...

    第六十六章 SQL命令 REVOKE

    从用户或角色中删除特权。

    大纲

    REVOKE admin-privilege FROM grantee 
    
    REVOKE role FROM grantee 
    
    REVOKE [GRANT OPTION FOR] object-privilege
           ON object-list FROM grantee [CASCADE | RESTRICT] [AS grantor] 
    
    REVOKE [GRANT OPTION FOR] SELECT ON CUBE[S] object-list  FROM grantee 
    
    REVOKE column-privilege (column-list) 
          ON table FROM grantee  [CASCADE | RESTRICT]
    

    参数

    • admin-privilege - 管理员级特权或以前授予要撤销的管理员级特权的以逗号分隔的列表。
      可用的syspriv选项包括16个对象定义权限和4个数据修改权限。对象定义权限为:%CREATE_FUNCTION%DROP_FUNCTION%CREATE_METHOD%DROP_METHOD%CREATE_PROCEDURE%DROP_PROCEDURE%CREATE_QUERY%DROP_QUERY%CREATE_TABLE%ALTER_TABLE%DROP_TABLE%CREATE_VIEW%ALTER_VIEW%DROP_VIEW%CREATE_TRIGGER%DROP_TRIGGER
      或者,可以指定%DB_OBJECT_DEFINITION,这将撤销所有16个对象定义特权。数据修改权限为INSERTUPDATEDELETE操作的%NOCHECK%NOINDEX%NOLOCK%NOTRIGGER权限。
    • grantee - 拥有SQL系统权限、SQL对象权限或角色的一个或多个用户的列表。
      有效值是一个以逗号分隔的用户或角色列表,或“*”
      星号(*)指定当前定义的所有没有%all角色的用户。
    • AS grantor - 此子句允许通过指定原始授予者的名称来撤销另一个用户授予的特权。
      有效的授予者值是用户名、以逗号分隔的用户名列表或“*”
      星号(*)指定当前定义的所有授予者。
      要使用AS授予器子句,必须具有%All角色或%Admin_Secure资源。
    • role - 一个角色或以逗号分隔的角色列表,这些角色的权限将从用户被撤销。
    • object-privilege - 基本级别特权或先前授予要撤销的基本级别特权的逗号分隔列表。
      该列表可以包含以下一个或多个:%ALTERDELETESELECTINSERTUPDATEEXECUTEREFERENCES
      要撤销所有特权,可以使用“all [privileges]”“*”作为此参数的值。
      注意,您只能从多维数据集撤销SELECT特权,因为这是惟一可授予的多维数据集特权。
    • object-list - 一个以逗号分隔的列表,其中包含一个或多个正在撤销对象特权的表、视图、存储过程或多维数据集。
      可以使用SCHEMA关键字指定从指定模式中的所有对象撤销对象特权。
      可以使用" * "指定从当前命名空间中的所有对象撤销对象特权。
    • column-privilege - 从一个或多个列列表列出的列撤销基本权限。
      可用选项有SELECTINSERTUPDATEREFERENCES
    • column-list - 由一个或多个列名组成的列表,用逗号分隔,用括号括起来。
    • table - 包含列列表列的表或视图的名称。

    描述

    REVOKE语句撤销允许用户或角色在指定的表、视图、列或其他实体上执行指定任务的权限。
    REVOKE还可以撤销用户分配的角色。
    REVOKE撤销GRANT命令的操作;

    特权只能由授予特权的用户撤消,或者通过CASCADE操作(如下所述)。

    可以从指定用户、用户列表或所有用户(使用*语法)撤销角色或特权。

    因为REVOKE的准备和执行速度很快,而且通常只运行一次,所以IRIS不会在ODBCJDBC或动态SQL中为REVOKE创建缓存查询。

    即使不能执行实际的撤销(例如,指定的特权从未被授予或已经被撤销),REVOKE也会成功地完成。
    但是,如果在REVOKE操作期间发生错误,SQLCODE将被设置为负数。

    撤销的角色

    角色可以通过SQL GRANTREVOKE命令授予或撤销,也可以通过^SECURITY IRIS System SECURITY命令授予或撤销。
    可以使用REVOKE命令从某个用户撤消一个角色,也可以从另一个角色撤消一个角色。
    不能使用IRIS System Security将角色授予或撤销给其他角色。
    特殊变量$ROLES不显示授予角色的角色。

    REVOKE可以指定单个角色,也可以指定要撤销的角色列表,以逗号分隔。
    REVOKE可以从指定的用户(或角色)、用户(或角色)列表或所有用户(使用*语法)中撤销一个或多个角色。

    GRANT命令可以将一个不存在的角色授予用户。
    可以使用REVOKE命令从现有用户撤销不存在的角色。
    但是,角色名必须使用与授予角色时相同的字母大小写来指定。

    如果试图从不存在的用户或角色撤销现有角色, IRIS将发出SQLCODE -118错误。
    如果不是超级用户,并且试图撤销一个不拥有且没有ADMIN OPTION的角色,InterSystems IRIS将发出SQLCODE -112错误。

    撤销对象权限

    对象特权赋予用户或角色对特定对象的某些权限。
    从一个被授予者的对象列表上撤销一个对象特权。
    对象列表可以在当前名称空间中指定一个或多个表、视图、存储过程或多维数据集。
    通过使用逗号分隔的列表,单个REVOKE语句可以从多个用户和/或角色中撤销多个对象上的多个对象特权。

    可以使用星号(*)通配符作为对象列表值,从当前名称空间中的所有对象撤销对象特权。
    例如,REVOKE SELECT ON * FROM Deborah将撤销该用户对所有表和视图的SELECT权限。
    REVOKE EXECUTE ON * FROM Deborah将撤销该用户对所有非隐藏存储过程的EXECUTE权限。

    可以使用SCHEMA SCHEMA -name作为对象列表值,以撤销指定模式中当前名称空间中的所有表、视图和存储过程的对象特权。
    例如,REVOKE SELECT ON SCHEMA Sample FROM Deborah将撤销该用户对Sample模式中所有对象的SELECT权限。
    可以将多个模式指定为逗号分隔的列表;
    例如,REVOKE SELECT ON SCHEMA Sample,Cinema FROM Deborah撤销SampleCinema模式中所有对象的SELECT权限。

    可以从用户或角色撤消对象特权。
    如果从某个角色撤销该权限,则仅通过该角色拥有该权限的用户将不再拥有该权限。
    不再拥有特权的用户不能再执行需要该对象特权的现有缓存查询。

    REVOKE撤销对象特权时,它将成功完成并将SQLCODE设置为0。
    如果REVOKE没有执行实际的撤销(例如,指定的对象权限从未被授予或已经被撤销),它将成功完成,并将SQLCODE设置为100(不再有数据)。
    如果在REVOKE操作期间发生错误,它将SQLCODE设置为负数。

    多维数据集是不受模式名称限制的SQL标识符。
    要指定多维数据集对象列表,必须指定CUBE(或cubes)关键字。
    因为多维数据集只能有SELECT权限,所以您只能从多维数据集撤销SELECT权限。

    对象权限可以通过以下任意方式撤销:

    • REVOKE command.
    • $SYSTEM.SQL.Security.RevokePrivilege()方法。
    • 通过IRIS系统安全。
      转到管理门户,选择系统管理、安全、用户(或系统管理、安全、角色),为所需的用户或角色选择Edit,然后选择SQL表或SQL视图选项卡。
      在下拉列表中选择Namespace
      向下滚动到所需的表,然后单击revoke来撤销权限。

    可以通过调用%CHECKPRIV命令来确定当前用户是否具有指定的对象特权。
    通过调用$SYSTEM.SQL.Security.CheckPrivilege()方法,可以确定指定的用户是否具有指定的表级对象特权。

    撤销对象所有者特权

    如果从对象的所有者那里撤消对SQL对象的特权,那么所有者仍然隐式地拥有对对象的特权。
    为了从对象的所有者完全撤销对象上的所有特权,必须更改对象以指定不同的所有者或没有所有者。

    撤销表级和列级特权

    REVOKE可用于撤销表级特权或列级特权的授予。
    表级特权提供对表中所有列的访问。
    列级特权提供对表中每个指定列的访问。
    向表中的所有列授予列级特权在功能上等同于授予表级特权。
    然而,这两者在功能上并不完全相同。
    列级REVOKE只能撤销在列级授予的权限。
    不能向表授予表级特权,然后在列级为一个或多个列撤销此特权。
    在这种情况下,REVOKE语句对已授予的权限没有影响。

    CASCADE 或 RESTRICT

    IRIS支持可选的CASCADEESTRICT关键字来指定REVOKE对象特权行为。
    如果没有指定关键字,则默认为RESTRICT

    可以使用CASCADERESTRICT来指定从一个用户撤销对象特权或列特权是否也会从通过WITH GRANT OPTION接收到该特权的任何其他用户撤销该特权。
    CASCADE撤销所有这些关联的特权。
    当检测到关联的特权时,RESTRICT(默认值)导致REVOKE失败。
    相反,它设置SQLCODE -126错误“REVOKE with RESTRICT failed”

    下面的例子展示了这些关键字的使用:

    --UserA
       GRANT Select ON MyTable TO UserB WITH GRANT OPTION
    
    --UserB
       GRANT Select ON MyTable TO UserC
    
    --UserA
       REVOKE Select ON MyTable FROM UserB
       -- This REVOKE fails with SQLCODE -126
    
    --UserA
       REVOKE Select ON MyTable FROM UserB CASCADE
       -- This REVOKE succeeds
       -- It revokes this privilege from UserB and UserC
    

    注意,CASCADERESTRICTUserB创建的引用MyTable的视图没有影响。

    对缓存查询的影响

    当撤销特权或角色时, IRIS将更新系统上所有缓存的查询,以反映特权中的这一更改。
    但是,当无法访问某个名称空间时——例如,当连接到数据库服务器的ECP连接关闭时——REVOKE会成功完成,但不会对该名称空间中的缓存查询执行任何操作。
    这是因为REVOKE不能更新不可达名称空间中的缓存查询,以撤销缓存查询级别的特权。
    没有发出错误。

    如果数据库服务器稍后启动,则该名称空间中缓存查询的权限可能不正确。
    如果某个角色或特权可能在某个名称空间不可访问时被撤销,建议清除该名称空间中的缓存查询。

    IRIS Security

    REVOKE命令是一个特权操作。
    在嵌入式SQL中使用REVOKE之前,必须以具有适当特权的用户身份登录。
    如果不这样做,将导致SQLCODE -99错误(特权冲突)。

    使用$SYSTEM.Security.Login()方法为用户分配适当的权限:

       DO $SYSTEM.Security.Login("_SYSTEM","SYS")
       &sql(      )
    

    必须具有%Service_Login:Use权限才能调用$SYSTEM.Security
    登录方法。

    示例

    下面的嵌入式SQL示例创建两个用户,创建一个角色,并将角色分配给用户。
    然后,它使用星号(*)语法从所有用户撤销该角色。
    如果用户或角色已经存在,CREATE语句将发出SQLCODE -118错误。
    如果用户不存在,GRANTREVOKE语句将发出SQLCODE -118错误。
    如果用户存在但角色不存在,则GRANTREVOKE语句发出SQLCODE 100
    如果用户和角色存在,则GRANTREVOKE语句发出SQLCODE 0
    即使已经完成了角色的授予或撤销,如果您试图撤销从未被授予的角色,也是如此。

    ClassMethod Revoke()
    {
    	d $SYSTEM.Security.Login("_SYSTEM","SYS")
    	&sql(
    		CREATE USER User1 IDENTIFY BY fredpw
    	)
    	&sql(
    		CREATE USER User2 IDENTIFY BY barneypw
    	)
    	w !,"CREATE USER error code: ",SQLCODE
    	&sql(
    		CREATE ROLE workerbee
    	)
    	w !,"CREATE ROLE error code: ",SQLCODE
    	&sql(
    		GRANT workerbee TO User1,User2
    	)
    	w !,"GRANT role error code: ",SQLCODE
    	&sql(
    		REVOKE workerbee FROM *
    	)
    	w !,"REVOKE role error code: ",SQLCODE
    }
    

    在下面的示例中,使用AS授予子句,一个用户(Joe)授予一个特权,另一个用户(John)撤销该特权:

       /* User Joe */
       GRANT SELECT ON Sample.Person TO Michael
    
       /* User John */
       REVOKE SELECT ON Sample.Person FROM Michael AS Joe
    

    注意,John必须具有%All角色或%Admin_Secure资源。

    展开全文
  • 从今天开始就要开始第四章——数据库安全性的学习。现在,开始练习。 关系数据库系统中存取控制对象 此次练习需要多个用户,所以首先应该创造几个用户。 然后就是发现,用户的登录名不能相同,不然会报错。...
  • SQLPLUSSYSASSYSDBA;...例如:CONNLAOSAN/LAOSAN;ORACLE的表空间分了几种类型,临时表空间[TEMPFILE],用户表空间 [DATAFILE],大文件表空间[BIGFILE]等,创建表空间,一般都是DBA干的事情。SIZE*[K,M]表空间的初始大小...
  • MySQL 赋予用户权限命令的简单格式可概括为: grant 权限 on 数据库对象 to 用户 一、grant 普通数据用户,查询、插入、更新、删除 数据库中所有表数据的权利 grant select on testdb.* to common_user@'%' ...
  • GRANT、REVOKE是我们常用的,但有时会遇到使用DENY的情形。从英文单词的字面意思来看,GRANT是赋予权限,REVOKE是收回我们已经授予的权限;而DENY是禁掉某个权限。这三者内部到底有什么联系、区别?什么情景下使用...

    在SQL Server数据库登陆账户、数据库用户权限管理中,经常会授予权限、回收权限,有时还会拒绝权限。GRANT、REVOKE是我们常用的,但有时会遇到使用DENY的情形。从英文单词的字面意思来看,GRANT是赋予权限,REVOKE是收回我们已经授予的权限;而DENY是禁掉某个权限。这三者内部到底有什么联系、区别?什么情景下使用GRANT?什么情景下使用REVOKE?什么情景下使用DENY?单独从文字描述上,我们很难理解。接下来,本文将通过试验的方式,逐步揭示两者的秘密。

    本打算将结论放在各试验后面揭示,写试验案例时发现写的又臭又长,最终还是决定将结论提前,让我们能找到读阅读的主线:

    1. GRANT赋予主体各类权限。

    2. 用户成为角色的成员可以继承角色的权限。

    3. REVOKE、DENY同时可以收回GRANT赋予的权限,但两者影响不同,REVOKE仅仅收回了权限,DENY撤销GRANT赋予的权限后并拒绝该权限,具体影响见下面的6、8结论。

    4. REVOKE可以撤销DENY拒绝的权限。

    5. 赋予(GRANT)数据库SELECT权限,则获得数据库下所有子对象(如数据库的表、视图及所有列,包括新建的表和列)的SELECT权限,某些单独拒绝(DENY)SELECT的子对象除外。

    6. 拒绝(DENY)数据库的SELECT权限,则拒绝父对象下所有子对象(如数据库的表、表的列,包括新建的表和列)的SELECT权限,即使单独赋予子对象的SELECT权限。

    7. 赋予表SELECT权限,则对表的所有列(包括新建列)有SELECT权限,单独拒绝SELECT的列除外。

    8. 拒绝表的SELECT权限,则拒绝表的所有列(包括新建列)SELECT权限,单独赋予SELECT的列除外。

    值得注意的是,在EXEC AS user上下文中,无论是赋予表SELECT权限,还是拒绝表SELECT权限,对新增列都无SELECT权限(这是在SQL Server 2008(SP2)版本试验中发现)其他版本表现的有所不同,所以如果有使用这样情景,需要重点测试,以免出现不必要的影响。

    应用场景:根据最小化用户权限原则,对重要信息表,我们可以拒绝所有用户的SELECT权限,而仅仅赋予特定用户查看特定列的SELECT权限,最大化避免信息泄漏。

    到此本文的核心结论您已经了然,当然文字描述相对较为抽象,如果您有时间,可以看完此文。当然我建议您耐心看完后文,并亲自动手实践,一则可以加深我们对三者区别的理解;二则对于新的内容,我们可以使用试验方式去学习,这是一个很好的学习方式,避免人云亦云,做到真正的了然于胸。最后,本文仅仅针对表的SELECT权限进行说明,有兴趣的同学可以参照本文的测试过程,设计INSERT、DELETE、UPDATE、EXEC等权限的样例,进行试验学习。

    测试的环境

    数据库的版本为 SQL Server 2008(SP2)企业版:

    SELECT @@VERSION

    Microsoft SQL Server 2008 (SP2) - 10.0.4000.0 (X64)   Sep 16 2010 19:43:16   Copyright (c) 1988-2008 Microsoft Corporation  Enterprise Edition (64-bit) on Windows NT 6.1 <X64> (Build 7601: Service Pack 1)

    测试准备:创建一个登陆名Jack,在test数据库下创建用户Jack,关联到登陆名Jack;然后在test 数据库下创建表test、test1,并在Jack用户的上下文下执行查询,脚本如下

    USE master
    GO
    IF EXISTS(SELECT name FROM sys.database_principals WHERE name='Jack')
          DROP LOGIN Jack
    CREATE LOGIN Jack WITH PASSWORD='Password'
        ,CHECK_POLICY=OFF,CHECK_EXPIRATION=OFF
    USE test
    GO
    IF EXISTS(SELECT name FROM sys.sysusers WHERE name='Jack')
          DROP USER Jack
    CREATE USER Jack FOR LOGIN Jack
    EXEC sys.sp_helprotect NULL,Jack
    USE test
    CREATE TABLE [dbo].[test](
          [a] [int] IDENTITY(1,1) NOT NULL,
          [b] [varchar](30) NULL,
          [d] [datetime] NULL
    )
    CREATE TABLE [dbo].[test1](
          [e] [int] IDENTITY(1,1) NOT NULL,
          [f] [varchar](30) NULL,
          [g] [datetime] NULL
    )
    EXEC AS USER='Jack'
    GO
    SELECT * FROM test
    GO
    REVERT
    GO

    消息229,级别14,状态5,第1 行

    拒绝了对对象'test' (数据库'test',架构'dbo')的SELECT 权限。

    因为test数据库下新创建的Jack用户,没有查询权限,所以报了如上错误。

    GRANT、REVOKE和DENY三者之间的关系

    GRANT赋予用户各种权利,REVOKE、DENY收回GRANT权限。

    赋予Jack用户SELECT权限,并使用sp_helprotect查看Jack的权限,脚本如下:

    --赋予Jack用户SELECT权限
    ​GRANT SELECT TO Jack
    --查看Jack用户拥有的权限
    EXEC sys.sp_helprotect NULL,Jack

    从结果可以看到,数据库用户Jack拥有SELECT权限(刚刚赋予的),同时还有CONNECT连接权限(创建数据库用户时默认赋予的)。

    此时在Jack 上下文中执行对test表的查询是OK的:

     

    试验1:使用REVOKE收回SELECT权限,再次查看Jack拥有的权限

    --试验1:
    --收回Jack SELECT 权限
    REVOKE SELECT FROM Jack
    --查看Jack用户拥有的权限
    EXEC sys.sp_helprotect NULL,Jack

    从结果可以看到Jack的SELECT权限没有了。

    试验2:重新赋予Jack 用户SELECT权限,使用DENY 拒绝掉其SELECT权限,并查看Jack的权限:

    --试验2:
    --重新赋予Jack用户SELECT 权限
    GRANT SELECT TO Jack
    --查看Jack用户拥有的权限
    EXEC sys.sp_helprotect NULL,Jack
    --拒绝Jack 的SELECT 权限
    DENY SELECT TO Jack
    --查看Jack用户拥有的权限
    EXEC sys.sp_helprotect NULL,Jack

    比较REVOKE和DENY 的结果,可以看出REVOKE后,Jack拥有的SELECT权限直接没有了;而DENY的结果是将GRANT 改为了DENY。此时我们再次在Jack用户的上下文中执行test表的查询,结果如下:

    这个错误和上面没有SELECT权限相同。同样说明了REVOKE和DENY均有收回GRANT赋予的权限的功能。那么是不是说明DENY是多余的呢?我们继续下面的试验:

    --使用REVOKE 收回DENY 拒绝的权限
    REVOKE SELECT FROM Jack
    --查看Jack用户拥有的权限
    EXEC sys.sp_helprotect NULL,Jack

    从结果可以看到,REVOKE不仅可以收回GRANT赋予的权限,同样可以收回 DENY 拒绝的权限;同时DENY可以收回GRANT赋予的权限。这虽然反应了REVOKE和DENY的一点不同,但还不能体现其真正内在的区别。下面我继续设计稍显复杂的试验,继续深入。

    新增加列对权限的继承

    GRANT SELECT TO Jack
    EXEC sp_helprotect NULL,Jack
    --增加列c
    ALTER TABLE test ADD c int
    EXEC AS USER='Jack'
    GO
    SELECT c FROM test
    REVERT
    GO

    --删除增加的列
    ALTER TABLE test DROP column  c
    DENY SELECT TO Jack
    EXEC sp_helprotect NULL,Jack
    ALTER TABLE test ADD c int
    EXEC AS USER='Jack'
    GO
    SELECT c FROM test
    REVERT
    GO

    结论:赋予/拒绝数据库的SELECT的权限,则会赋予/拒绝新表或者表的新列的SELECT权限。

    --删除增加的列
    ALTER TABLE test DROP column  c
    GRANT SELECT ON OBJECT::test TO Jack
    EXEC sp_helprotect NULL,Jack
    --增加列c
    ALTER TABLE test ADD c int
    EXEC AS USER='Jack'
    GO
    SELECT c FROM test
    REVERT
    GO

    --删除增加的列
    ALTER TABLE test DROP column  c
    DENY SELECT ON OBJECT::test TO Jack
    EXEC sp_helprotect NULL,Jack
    ALTER TABLE test ADD c int
    EXEC AS USER='Jack'
    GO
    SELECT c FROM test
    REVERT
    GO

    结论:赋予/拒绝表的SELECT的权限,则会赋予/拒绝表的新列的SELECT权限。

    赋予/拒绝数据库或表SELECT权限

    试验3:赋予Jack用户整个数据库的SELECT权限,拒绝Jack用户对表test 的SELECT权限,查看Jack的权限,并在用户Jack上下文中查询表test。

    --试验3:
    GRANT SELECT TO Jack
    DENY SELECT ON OBJECT::test TO Jack
    EXEC sys.sp_helprotect  NULL ,Jack
    EXEC AS USER='Jack'
    GO
    SELECT * FROM test
    SELECT * FROM test1
    GO
    REVERT
    GO

    结论:赋予用户(Jack)父级对象(本试验指数据库)SELECT权限,则用户具有除单独拒绝的子对象(这里拒绝了test表的SELECT权限),对其余子对象均有SELECT权限。

    --恢复Jack权限
    REVOKE SELECT TO Jack
    REVOKE SELECT ON OBJECT::test TO Jack
    EXEC sys.sp_helprotect  NULL ,Jack

    试验4:反之拒绝了Jack对数据库的SELECT权限,赋予Jack 对数据库下表test 的SELECT权限。

    --试验4:
    DENY SELECT TO Jack
    GRANT SELECT ON OBJECT::test TO Jack
    EXEC sys.sp_helprotect  NULL ,Jack
    EXEC AS USER='Jack'
    GO
    SELECT * FROM test
    SELECT * FROM test1
    GO
    REVERT
    GO

    从试验3、4获得这样的一个结论:拒绝用户数据库SELECT权限,则会拒绝用户对数据库所有对象的SELECT权限,即使再单独赋予该对象SELECT权限。而赋予用户数据库SELECT权限,仅仅拒绝用户对数据库中的某些对象的SELECT权限,则用户对除拒绝对象外的其他对象仍然有SELECT权限。

    恢复Jack的权限

    --恢复Jack权限
    REVOKE SELECT TO Jack
    REVOKE SELECT ON OBJECT::test TO Jack

    赋予/拒绝数据库或表列的SELECT权限

    试验5:赋予Jack用户SELECT权限,拒绝Jack用户对表test的字段a、d的SELECT权限,然后在Jack用户的上下文中,分别查询test全表、test的字段b,试验脚本如下。

    --试验5:
    --赋予Jack用户SELECT权限
    GRANT SELECT TO Jack
    --禁止用户Jack 查看表test字段a、d
    DENY SELECT ON OBJECT::dbo.test(a,d) TO Jack
    --查看Jack用户拥有的权限
    EXEC sys.sp_helprotect NULL,Jack
    EXEC AS USER='Jack'
    GO
    SELECT * FROM test
    GO
    SELECT b FROM test
    REVERT
    GO

    显然,对test的全表查询报错,在消息下可以看到的错误如下:

    这样即使通过GRANT给予了用户Jack数据库的查询权限,但拒绝了Jack用户对表test 的字段a、d的SELECT权限,Jack 用户只能查询test表的b字段,而不能查询test表的a、d字段。

    恢复Jack权限:

    REVOKE SELECT FROM Jack
    REVOKE SELECT ON OBJECT::test(a,d) FROM Jack

    试验6:反过来,拒绝Jack的SELECT权限,赋予Jack用户对表test 的字段a、d的SELECT权限

    --试验6:
    --赋予Jack用户SELECT权限
    DENY SELECT TO Jack
    --禁止用户Jack 查看表test字段a、d
    GRANT SELECT ON OBJECT::dbo.test(a,d) TO Jack
    --查看Jack用户拥有的权限
    EXEC sys.sp_helprotect NULL,Jack
    EXEC AS USER='Jack'
    GO
    SELECT * FROM test
    GO
    SELECT a,d FROM test
    REVERT

    这样即使Jack用户对表test的字段a、d有SELECT权限,但是由于对Jack拒绝了SELECT权限,所以无论是对test表的a、d字段,还是对test表都没有了SELECT权限。即拒绝父对象(这里只数据库)的SELECT权限,则会拒绝父对象的所有子对象的SELECT权限,即使另外赋予该子对象(这里只表test的字段a、d列)SELECT权限。

    恢复Jack权限:

    REVOKE SELECT FROM Jack
    REVOKE SELECT ON OBJECT::test(a,d) FROM Jack

    赋予/拒绝表或表列的SELECT权限

    试验7:拒绝用户Jack对表test 的SELECT 权限,赋予用户Jack对表test字段a、d的SELECT权限:

    --试验7:
    --赋予Jack用户SELECT权限
    DENY SELECT ON OBJECT::dbo.test TO Jack
    --禁止用户Jack 查看表test字段a、d
    GRANT SELECT ON OBJECT::dbo.test(a,d) TO Jack
    --查看Jack用户拥有的权限
    EXEC sys.sp_helprotect NULL,Jack
    EXEC AS USER='Jack'
    GO
    SELECT * FROM test
    GO
    SELECT a,d FROM test
    REVERT
    GO

    拒绝父对象(这里指表test)的SELECT权限,则拒绝除另外赋予了SELECT的子对象(这里指test表的列a、d)之外的所有子对象,包括对象新增的子对象(新增字段),下面的试验8刚好说明了这一点。

    试验8:在试验7的基础上为表test增加一列c,然后在Jack上下文中查看c列。

    --试验8:
    ALTER TABLE test ADD  c int
    --查看Jack用户拥有的权限
    EXEC sys.sp_helprotect NULL,Jack
    EXEC AS USER='Jack'
    GO
    SELECT * FROM test
    GO
    SELECT c FROM test
    REVERT
    GO

    用户Jack使用DENY拒绝表的SELECT权限,表新增的字段的SELECT权限对用户Jack也是拒绝的。

    从试验7、8这两个试验我们可以得到DENY的一个应用场景,对于特定的信息(字段)如涉及用户隐私的信息(姓名、身份证号、手机号、银行卡号、密码、虚拟币余额等等),一般用户可以赋予表的查询权限,而拒绝其查询、更新特定隐私信息的权限,从而使用户权限最小化。

    恢复用户Jack 权限,并恢复test表结构:

    REVOKE SELECT ON OBJECT::test FROM Jack
    REVOKE SELECT ON OBJECT::test(a,d) FROM Jack
    --删除增加的列
    ALTER TABLE test DROP column  c

    试验9:赋予用户Jack对表test的SELECT权限,禁止用户Jack查看表test的字段a、d列:

    --试验9:
    --赋予Jack用户SELECT权限
    GRANT SELECT ON OBJECT::dbo.test TO Jack
    --禁止用户Jack 查看表test字段a、d
    DENY SELECT ON OBJECT::dbo.test(a,d) TO Jack
    --查看Jack用户拥有的权限
    EXEC sys.sp_helprotect NULL,Jack
    EXEC AS USER='Jack'
    GO
    SELECT * FROM test
    GO
    SELECT b FROM test
    REVERT
    GO

    赋予表test的SELECT权限,拒绝对表的字段a、d的SELECT权限,用户对表test的其他字段(如试验中的b列)仍有SELECT权限。

    试验10:在试验9的基础上,为表test新增字段c,检验其是否具有SELECT权限

    --试验10:
    --表test 增加字段c
    ALTER TABLE test ADD  c int
    --查看Jack用户拥有的权限
    EXEC sys.sp_helprotect NULL,Jack
    EXEC AS USER='Jack'
    GO
    SELECT * FROM test
    GO
    SELECT c FROM test
    REVERT
    GO

    由于使用EXEC AS user='Jack' 上下文的问题,使用GRANT 为用户Jack赋予表test 的SELECT权限,用户Jack获得了新增列c的SELECT权限。但此时用户并没有列c的SELECT权限(试验环境SQL Server 2008(SP2) 这应该是SQL Server的一个Bug。SQL Server 2016(RTM-GDR)版本只要对列DENY了SELECT权限,对所有表都没有了SELECT权限;SQL Server 2016(SP1)又恢复了SQL Server 2008(SP2)情景 )。当我使用Jack用户直接登录服务器,连接数据库test,查询新列c是有SELECT权限的。对于使用 EXEC AS user 的情景,此时需要对新列单独赋予SELECT权限:

    GRANT SELECT ON OBJECT::test(c) TO Jack

    试验7、8、9、10表明,根据最小化权限原则,如果想要用户查看表尽可能少的信息,我们可以拒绝表的SELECT权限,再赋予用户特定字段的SELECT权限。以避免新增加的字段被不必要的用户看到,造成信息泄漏。

    所以要慎用DENY,原因为SQL Server 中使用EXEC AS user上下文的情景和直接登录时,对新列的权限界定不一致。

    恢复用户Jack 权限,并恢复test表结构:

    REVOKE SELECT ON OBJECT::test FROM Jack
    REVOKE SELECT ON OBJECT::test(a,d) FROM Jack
    --删除增加的列
    ALTER TABLE test DROP column  c

    数据库角色成员继承角色权限的试验

    用户除了可以直接对其赋予、拒绝权限外,还可以通过成为角色的成员,继承其权限,接下来我将试验用户直接获得的权限和从角色中继承的权限或者不同角色权限之间的影响。

    首先在数据库test中创建两个角色,GrantRole和DenyRole,并查看其具有的权限:

    --创建数据库角色
    USE test
    GO
    CREATE ROLE GrantRole
    CREATE ROLE DenyRole
    --查看数据库角色权限
    EXEC sys.sp_helprotect  NULL ,GrantRole
    EXEC sys.sp_helprotect  NULL ,DenyRole

    可以看到,数据库角色刚创建的时候是没有任何权限的,所以报没有要报告的匹配行错误。

    分别对角色/用户赋予或拒绝相同对象的权限测试

    试验11:赋予角色对数据库的SELECT权限,将Jack加入为其成员,拒绝Jack对数据库的SELECT权限,检验在用户Jack上下文中执行对表test的查询情况

    --试验11:
    GRANT SELECT TO GrantRole
    EXEC sys.sp_addrolemember GrantRole,Jack
    DENY SELECT TO Jack
    EXEC sp_helprotect  NULL ,Jack
    EXEC sp_helprotect  NULL ,GrantRole
    EXEC AS USER='Jack'
    GO
    SELECT * FROM test
    GO
    REVERT
    GO

     

    试验12:拒绝角色GrantRole对数据库的SELECT权限,赋予用户Jack对数据库的SELECT权限,检验在用户Jack上下文中执行对表test的查询情况

    --试验12:
    DENY SELECT TO GrantRole
    GRANT SELECT TO Jack
    EXEC sp_helprotect  NULL ,Jack
    EXEC sp_helprotect  NULL ,GrantRole
    EXEC AS USER='Jack'
    GO
    SELECT * FROM test
    GO
    REVERT
    GO

    结论:用户权限和用户从数据库角色中继承的权限互斥时(GRANT<<=>>DENY),用户最终获得的是拒绝权限

    恢复角色RrantRole和用户Jack的权限:

    REVOKE SELECT FROM GrantRole
    REVOKE SELECT FROM Jack

    试验13:赋予角色GrantRole对数据库的SELECT权限,拒绝用户Jack对数据库的SELECT权限,检验在用户Jack上下文中执行对表test的查询情况

    --试验13:
    GRANT SELECT ON OBJECT::test TO GrantRole
    DENY SELECT ON OBJECT::test TO Jack
    EXEC sp_helprotect  NULL ,Jack
    EXEC sp_helprotect  NULL ,GrantRole
    EXEC AS USER='Jack'
    GO
    SELECT * FROM test
    GO
    REVERT
    GO

    结论同试验12.

     

    试验14:拒绝角色GrantRole对数据库对象表test的SELECT权限,赋予用户Jack对数据库对象表test的SELECT权限,检验在用户Jack上下文中执行对表test的查询情况

    --试验14:
    DENY SELECT ON OBJECT::test TO GrantRole
    GRANT SELECT ON OBJECT::test TO Jack
    EXEC sp_helprotect  NULL ,Jack
    EXEC sp_helprotect  NULL ,GrantRole
    EXEC AS USER='Jack'
    GO
    SELECT * FROM test
    GO
    REVERT
    GO

    结论同试验12.

    恢复角色GrantRole、用户Jack的权限

    REVOKE SELECT ON OBJECT::test TO GrantRole
    REVOKE SELECT ON OBJECT::test TO Jack

    试验15:拒绝角色GrantRole对数据库对象表test的a、d列SELECT权限,赋予用户Jack对数据库对象表test的a、d列SELECT权限,检验在用户Jack上下文中执行对表test的查询情况

    --试验15:
    DENY SELECT ON OBJECT::test(a,d) TO GrantRole
    GRANT SELECT ON OBJECT::test(a,d) TO Jack
    EXEC sp_helprotect  NULL ,Jack
    EXEC sp_helprotect  NULL ,GrantRole
    EXEC AS USER='Jack'
    GO
    SELECT * FROM test
    GO
    REVERT
    GO

    结论同试验12.

    试验16:赋予角色GrantRole对数据库对象表test的a、d列SELECT权限,拒绝用户Jack对数据库对象表test的a、d列SELECT权限,检验在用户Jack上下文中执行对表test的查询情况

    --试验16:
    GRANT SELECT ON OBJECT::test(a,d) TO GrantRole
    DENY SELECT ON OBJECT::test(a,d) TO Jack
    EXEC sp_helprotect  NULL ,Jack
    EXEC sp_helprotect  NULL ,GrantRole
    EXEC AS USER='Jack'
    GO
    SELECT * FROM test
    GO
    REVERT
    GO

    试验11~16说明,赋予或拒绝角色或用户对相同对象的权限时,拒绝权限具有较高优先级

    恢复角色GrantRole、用户Jack权限:

    REVOKE SELECT ON OBJECT::test(a,d) TO GrantRole
    REVOKE SELECT ON OBJECT::test(a,d) TO Jack

    用户从不同角色中继承权限的相互影响

    试验17:赋予角色GrantRole对数据库SELECT权限,拒绝角色DenyRole对数据库SELECT权限,检验在用户Jack上下文中执行对表test的查询情况

    --试验17:
    EXEC sys.sp_addrolemember DenyRole,Jack
    GRANT SELECT TO GrantRole
    DENY SELECT TO DenyRole
    EXEC sys.sp_helprotect NULL,GrantRole
    EXEC sys.sp_helprotect NULL,DenyRole
    EXEC AS USER='Jack'
    GO
    SELECT * FROM test
    GO
    REVERT
    GO

    结论:从不同角色继承对相同对象的互斥权限(GRANT<<==>>DENY),用户最终获得的是拒绝权限。

    恢复角色GrantRole、用户Jack权限:

    REVOKE SELECT TO GrantRole
    REVOKE SELECT TO DenyRole

    试验18:赋予角色GrantRole对数据库对象表test的SELECT权限,拒绝角色DenyRole对数据库对象表test的SELECT权限,检验在用户Jack上下文中执行对表test的查询情况

    --试验18:
    GRANT SELECT ON OBJECT::test TO GrantRole
    DENY SELECT ON OBJECT::test TO DenyRole
    EXEC sys.sp_helprotect NULL,GrantRole
    EXEC sys.sp_helprotect NULL,DenyRole
    EXEC AS USER='Jack'
    GO
    SELECT * FROM test
    GO
    REVERT
    GO

    结论同试验17.

    恢复角色GrantRole、用户Jack权限:

    REVOKE SELECT ON OBJECT::test TO GrantRole
    REVOKE SELECT ON OBJECT::test TO DenyRole

    试验19:赋予角色GrantRole对数据库对象表test的a、d列SELECT权限,拒绝角色DenyRole对数据库对象表test的a、d列SELECT权限,检验在用户Jack上下文中执行对表test的查询情况

    --试验19:
    GRANT SELECT ON OBJECT::test(a,d) TO GrantRole
    DENY SELECT ON OBJECT::test(a,d) TO DenyRole
    EXEC sys.sp_helprotect NULL,GrantRole
    EXEC sys.sp_helprotect NULL,DenyRole
    EXEC AS USER='Jack'
    GO
    SELECT * FROM test
    GO
    REVERT
    GO

    试验17~19说明,Jack用户从两个角色中继承相反同对象的权限,仍然是拒绝权限占较高优先级,同试验11~16结论相同。

    恢复角色GrantRole、用户Jack权限:

    REVOKE SELECT ON OBJECT::test(a,d) TO GrantRole
    REVOKE SELECT ON OBJECT::test(a,d) TO DenyRole

    同时先删除DenyRole的成Jack,避免测试时其他因素影响:

    EXEC sys.sp_droprolemember DenyRole,Jack

    分别对角色/用户赋予或拒绝父子对象的权限测试

    试验20:赋予角色GrantRole对数据库SELECT权限,拒绝用户Jack对数据库对象表test的SELECT权限,检验在用户Jack上下文中执行对表test的查询情况

    --试验20:
    GRANT SELECT TO GrantRole
    DENY SELECT ON OBJECT::test TO Jack
    EXEC sp_helprotect  NULL ,Jack
    EXEC sp_helprotect  NULL ,GrantRole
    EXEC AS USER='Jack'
    GO
    SELECT * FROM test
    SELECT * FROM test1
    GO
    REVERT
    GO

    因为对角色GrantRole赋予了数据库的SELECT权限,对用户Jack仅拒绝了表test的SELECT权限,所以Jack用户仍然具有查看数据库下除test表以外的对象的权限。

    试验21:拒绝角色GrantRole对数据库SELECT权限,赋予用户Jack对数据库对象表test的SELECT权限,检验在用户Jack上下文中执行对表test的查询情况

    --试验21:
    DENY SELECT TO GrantRole
    GRANT SELECT ON OBJECT::test TO Jack
    EXEC sp_helprotect  NULL ,Jack
    EXEC sp_helprotect  NULL ,GrantRole
    EXEC AS USER='Jack'
    GO
    SELECT * FROM test
    SELECT * FROM test1
    GO
    REVERT
    GO

    640?wx_fmt=pnguploading.4e448015.gif正在上传…重新上传取消

    640?wx_fmt=pnguploading.4e448015.gif正在上传…重新上传取消

    拒绝父级对象(这里是数据库)的SELECT权限、则拒绝所有子级(这里是数据库中的表test)对象的SELECT权限,即使单独为子级对象赋予了SELECT权限

    恢复角色GrantRole、用户Jack权限:

    拒绝父级对象(这里是数据库)的SELECT权限、则拒绝所有子级(这里是数据库中的表test)对象的SELECT权限,即使单独为子级对象赋予了SELECT权限

    恢复角色GrantRole、用户Jack权限:

    REVOKE SELECT TO GrantRole
    REVOKE SELECT ON OBJECT::test TO Jack

    试验22:拒绝角色GrantRole对数据库SELECT权限,赋予用户Jack对数据库对象表test的a、d列SELECT权限,检验在用户Jack上下文中执行对表test的查询情况

    --试验22:
    DENY SELECT TO GrantRole
    GRANT SELECT ON OBJECT::test(a,d) TO Jack
    EXEC sp_helprotect  NULL ,GrantRole
    EXEC sp_helprotect  NULL ,Jack
    EXEC AS USER='Jack'
    GO
    SELECT a,d FROM test
    SELECT b FROM test
    GO
    REVERT
    GO

    拒绝父级对象(这里是数据库)的SELECT权限、则拒绝所有子级(这里是数据库中表test的字段a、d)对象的SELECT权限,即使单独为子级对象赋予了SELECT权限

    试验23:赋予角色GrantRole对数据库SELECT权限,拒绝用户Jack对数据库对象表test的a、d列SELECT权限,检验在用户Jack上下文中执行对表test的查询情况

    --试验23:
    GRANT SELECT TO GrantRole
    DENY SELECT ON OBJECT::test(a,d) TO Jack
    EXEC sp_helprotect  NULL ,GrantRole
    EXEC sp_helprotect  NULL ,Jack
    EXEC AS USER='Jack'
    GO
    SELECT a,d FROM test
    SELECT b FROM test
    GO
    REVERT
    GO

    赋予父级对象(这里指数据库)SELECT权限,则仅仅拒绝子级对象中被拒绝的子级对象(这里拒绝了子级对象表test的字段a、d列),对其他子级对象仍然有SELECT权限。

    恢复角色GrantRole、用户Jack权限:

    REVOKE SELECT TO GrantRole
    REVOKE SELECT ON OBJECT::test(a,d) TO Jack

    试验24:赋予角色GrantRole对数据库对象表test的SELECT权限,拒绝用户Jack对数据库对象表test的a、d列SELECT权限,检验在用户Jack上下文中执行对表test的查询情况

    --试验24:
    GRANT SELECT ON OBJECT::test TO GrantRole
    DENY SELECT ON OBJECT::test(a,d) TO Jack
    EXEC sp_helprotect  NULL ,GrantRole
    EXEC sp_helprotect  NULL ,Jack
    EXEC AS USER='Jack'
    GO
    SELECT a,d FROM test
    SELECT b FROM test
    GO
    REVERT
    GO

    赋予父级对象(这里指表test)SELECT权限,则仅仅拒绝子级对象中被拒绝的子级对象(这里拒绝了子级对象表test的字段a、d列),对其他子级对象仍然有SELECT权限。

    试验25:在试验24的基础上增加字段e列,检验赋予权限后,新增加的对权限的继承情况

    --试验25:
    ALTER TABLE test ADD e int
    EXEC sp_helprotect  NULL ,GrantRole
    EXEC sp_helprotect  NULL ,Jack
    EXEC AS USER='Jack'
    GO
    SELECT e FROM test
    GO
    REVERT
    GO

    角色GrantRole对表test有SELECT权限,并且对于新增的列(在赋予权限后创建的列)也有SELECT权限,但此时和10一样,对新增的列拒绝了SELECT权限。

    解决方案为重新单独为其赋予权限。

    GRANT SELECT ON OBJECT::test(e) TO GrantRole
    EXEC sp_helprotect  NULL ,GrantRole
    EXEC sp_helprotect  NULL ,Jack
    EXEC AS USER='Jack'
    GO
    SELECT e FROM test
    GO
    REVERT
    GO

    从结果来看,赋予角色GrantRole权限并没有单独增加对test表字段e的SELECT权限信息,而我们此时已经有了对test表字段e的SELECT权限(如图中的结果)。

    删除e列,再重新创建e列,重新在Jack上下问中执行对e列的查询

    ALTER TABLE test DROP column e
    ALTER TABLE test ADD e int
    EXEC sp_helprotect  NULL ,GrantRole
    EXEC sp_helprotect  NULL ,Jack
    EXEC AS USER='Jack'
    GO
    SELECT e FROM test
    GO
    REVERT
    GO

    发现又报上面的错误了。这也许算是SQL Server中EXEC AS user的一个Bug吧!!!

    同样在使用账户登录服务器,连接数据库test时,查询新列e,有SELECT权限。

    恢复test表结构:

    ALTER TABLE test DROP COLUMN c,e

    试验26:拒绝角色GrantRole对数据库对象表test的SELECT权限,赋予用户Jack对数据库对象表test的a、d列SELECT权限,检验在用户Jack上下文中执行对表test的查询情况

    --试验26:
    DENY SELECT ON OBJECT::test TO GrantRole
    GRANT SELECT ON OBJECT::test(a,d) TO Jack
    EXEC sp_helprotect  NULL ,GrantRole
    EXEC sp_helprotect  NULL ,Jack
    EXEC AS USER='Jack'
    GO
    SELECT a,d FROM test
    SELECT b FROM test
    GO
    REVERT
    GO

    拒绝父级对象(这里指test表)的SELECT权限,则拒绝其所有子级对象(这里列出test表字段a、d)的SELECT权限,即使再单独赋予子级对象SELECT权限。

    恢复角色GrantRole、用户Jack权限:

    REVOKE SELECT ON OBJECT::test TO GrantRole
    REVOKE SELECT ON OBJECT::test(a,d) TO Jack

    试验从不同角色中继承对不同对象权限的相互影响

    试验27:赋予角色GrantRole对数据库的SELECT权限,拒绝角色DenyRole对数据库对象表test的SELECT权限,检验在用户Jack上下文中执行对表test、test1的查询情况

    --试验27:
    EXEC sp_addrolemember DenyRole,Jack
    GRANT SELECT TO GrantRole
    DENY SELECT ON OBJECT::test TO DenyRole
    EXEC sp_helprotect  NULL ,GrantRole
    EXEC sp_helprotect  NULL ,DenyRole
    EXEC sp_helprotect  NULL ,Jack
    EXEC AS USER='Jack'
    GO
    SELECT * FROM test
    SELECT * FROM test1
    GO
    REVERT
    GO

    继承角色对数据库test的SELECT权限,同时继承了拒绝表test的SELECT权限,在用户有对数据库的所有对象有SELECT权限,除拒绝的对象外。

    试验28:拒绝角色GrantRole对数据库的SELECT权限,赋予角色DenyRole对数据库对象表test的SELECT权限,检验在用户Jack上下文中执行对表test、test1的查询情况

    --试验28:
    DENY SELECT TO GrantRole
    GRANT SELECT ON OBJECT::test TO DenyRole
    EXEC sp_helprotect  NULL ,GrantRole
    EXEC sp_helprotect  NULL ,DenyRole
    EXEC AS USER='Jack'
    GO
    SELECT * FROM test
    SELECT * FROM test1
    GO
    REVERT
    GO

    用户从角色中继承了拒绝数据库test的SELECT权限,并继承角色对表test的SELECT权限,可以看到拒绝了数据库的SELECT权限,则拒绝了数据库所有对象的SELECT权限,即使单独给这个对象赋予SELECT权限。

    REVOKE SELECT TO GrantRole
    REVOKE SELECT ON OBJECT::test TO DenyRole

    试验29:赋予角色GrantRole对数据库的SELECT权限,拒绝角色DenyRole对数据库对象表test的列a、d的SELECT权限,检验在用户Jack上下文中执行对表test各列的查询情况

    --试验29:
    GRANT SELECT TO GrantRole
    DENY SELECT ON OBJECT::test(a,d) TO DenyRole
    EXEC sp_helprotect  NULL ,GrantRole
    EXEC sp_helprotect  NULL ,DenyRole
    EXEC AS USER='Jack'
    GO
    SELECT b FROM test
    SELECT a,d FROM test
    GO
    REVERT
    GO

    用户继承了角色对数据库test的SELECT权限,同时继承了拒绝表test的a、d列的SELECT权限。用户对数据库有SELECT权限,在用户对除数据库中拒绝的对象以外的所有对象有SELECT权限。

    REVOKE SELECT TO GrantRole
    REVOKE SELECT ON OBJECT::test(a,d) TO DenyRole

    试验30:拒绝角色GrantRole对表test的SELECT权限,赋予角色DenyRole对数据库对象表test的列a、d的SELECT权限,检验在用户Jack上下文中执行对表test各列的查询情况

    --试验30:
    DENY SELECT ON OBJECT::test TO GrantRole
    GRANT SELECT ON OBJECT::test(a,d) TO DenyRole
    EXEC sp_helprotect  NULL ,GrantRole
    EXEC sp_helprotect  NULL ,DenyRole
    EXEC sp_helprotect  NULL ,Jack
    EXEC AS USER='Jack'
    GO
    SELECT b FROM test
    SELECT a,d FROM test
    GO
    REVERT
    GO

    用户继承了角色拒绝表test的SELECT权限,同时继承了赋予角色对表test的a、d列的SELECT权限。用户拒绝表test的SELECT权限,在用户对拒绝表中所有列的SELECT权限(包括新增列),即使再单独赋予用户对某些列的SELECT权限。

    试验31:赋予角色GrantRole对数据库的SELECT权限,拒绝角色DenyRole对数据库对象表test的列a、d的SELECT权限,检验在用户Jack上下文中执行对表test各列的查询情况

    --试验31:
    GRANT SELECT ON OBJECT::test TO GrantRole
    DENY SELECT ON OBJECT::test(a,d) TO DenyRole
    EXEC sp_helprotect  NULL ,GrantRole
    EXEC sp_helprotect  NULL ,DenyRole
    EXEC sp_helprotect  NULL ,Jack
    EXEC AS USER='Jack'
    GO
    SELECT b FROM test
    SELECT a,d FROM test
    GO

    用户继承了赋予角色对表test的SELECT权限,同时继承了拒绝角色对表test的a、d列的SELECT权限。用户对表test有SELECT权限,则用户对表中的所有列有SELECT权限,除单独拒绝的某些列外。

    展开全文
  • REVOKE

    2015-09-07 16:03:56
    REVOKE 功能:取消权限。 语法: REVOKE privilege [, ...] ON object [, ...] FROM { PUBLIC | GROUP | username }

    REVOKE

    功能:取消权限。


    语法:

    REVOKE privilege [, ...] ON object [, ...] FROM { PUBLIC | GROUP | username }

    展开全文
  • revoke 语句

    千次阅读 2020-02-25 09:50:12
    授予的权限可以由dba或其他授权者用revoke语句收回,revoke语句的一般格式 revoke<权限>[,<权限>]...... [on <对象类型><对象名>] from <用户>[,<用户>]... ...
    授予的权限可以由dba或其他授权者用revoke语句收回,revoke语句的一般格式
    revoke<权限>[,<权限>]......
    [on <对象类型><对象名>]
    from <用户>[,<用户>]...
    
    展开全文
  • mysql关于grant与revoke的详细教程

    千次阅读 2018-01-05 20:57:16
    MySQL关于grant与revoke的详细教程 grant命令主要是用来授权 语法: 1 grant 权限 on 数据库对象 to 用户; //仅给某用户授予某数据库对象某权限  grant 权限 on 数据库对象 to 用户@'ip或者...
  • 文章目录1 概述2 分类2.1 系统权限2.2 对象权限2.3 角色权限3 示例3.1 权限回收3.2 权限传递 ... (2) revoke select, insert on scott.emp from hr; -- 回收 2 分类 区别:'权限的 颗粒度 不同' 1. 系统权限 '
  • 八、MySQL grant、revoke 用户权限注意事项 grant, revoke 用户权限后,该用户只有重新连接 MySQL 数据库,权限才能生效。 如果想让用户具有授权的权利,也可以将这些权限 grant 给其他用户,需要选项 “grant ...
  • 文章目录撤销用户对某个数据库的全部权限撤销用户对某个数据库的部分...revoke 的含义:撤销、取消、使无效、作废。 撤销用户对某个数据库的全部权限 mysql> REVOKE ALL PRIVILEGES ON database_name.* TO 'user_na
  • SQL练习7 - GRANT/ REVOKE / AUDIT

    千次阅读 2020-03-27 13:10:18
    SQL中使用GRAND和REVOKE语句向用户授予或收回对数据的操作权限。GRANT语句向用户授予权限。REVOKE语句收回已经授予用户的权限 1、GRANT: GRANT语句的格式一般为: GRANT<权限>[,<权限>]… ON<对象...
  • revoke语句使用1

    千次阅读 2020-02-26 09:33:21
    把用户user4修改雇员编号的权限收回 revoke update(employee_id) on table_employees from user4
  • REVOKE - 删除访问权限

    2019-06-27 16:38:00
    SYNOPSIS ...REVOKE [ GRANT OPTION FOR ] { { SELECT | INSERT | UPDATE | DELETE | RULE | REFERENCES | TRIGGER } [,...] | ALL [ PRIVILEGES ] } ON [ TABLE ] tablename [, ...] FROM { u...
  • sql练习 grant /revoke

    2020-03-28 16:23:24
    revoke<权限>[,<权限>] on <对象类型><对象名>[,<对象类型>] from <用户>[,<用户>]...[cascade] 【例4.8】 revoke update (Sno) on TEST.Student from u4 【例 4.9】 收回所有的用户的SC查询权限 revoke select on ...
  • 在 MySQL 中,可以使用 REVOKE 语句删除某个用户的某些权限(此用户不会被删除),在一定程度上可以保证系统的安全性。例如,如果数据库管理员觉得某个用户不应该拥有 DELETE 权限,那么就可以删除 DELETE 权限。 ...
  • MySQL访问权限管理(grant、revoke)

    千次阅读 2020-01-20 21:19:23
    三、移除用户权限(revokerevoke用来移除用户的权限(注意:被撤销的权限必须存在,否则会出错) 例如:下面移除bforta用户在crashcourse数据库上的select权限 revoke select on crashcourse.* from bforta;...
  • 在mysql8.0中使用root执行REVOKE语句报错 :1227 – Access denied; you need (at least one of) the SYSTEM_USER privilege(s) for this ... 很奇怪今天MySQL8突然出现一些莫明的错误,比如我对昨天创建的帐户用...
  • 权限回收(同时将用户授予第三者的权限回收): revoke 权限0,权限1… on 表名/数据库名 from 用户0,用户1…;
  • 下面呢是我在学习数据控制时遇到的问题和解决方法,可能也不是很对,希望看到我这...根据数据控制的定义我们便引入了GRANT(授权)语句和REVOKE(回收)语句 首先来看GRANT语句: GRANT语句的一般格式: GRANT <权
  • //达到执行bulk revoke的阈值,执行bulk revoke return HR_BULK_REVOKE; } if (revocation_count == BiasedLockingBulkRebiasThreshold) { //达到 bulk rebias的阈值,执行bulk rebias return HR_BULK_REBIAS;...
  • 3、撤销某一权限 (比如 select权限) revoke select on testdb.* from wanshepi@localhost; 4、检查撤销的权限是否已生效 select * from testdb.score; 5、检查其他权限是否有效: (看其他权限是否受到所撤销的权限...
  • grant授权和revoke回收权限

    千次阅读 2017-08-25 14:30:35
    在mysql维护工作中,做好权限管理是一个很重要的环节。下面对mysql权限操作进行梳理: mysql的权限命令是grant,权限撤销...revoke回收权限格式:revoke 权限列表 on 库.表 from 用户名@'ip'; 下面通过一些例子说明:
  • 下表是执行了[例1]到[例7]的语句后,学生-课程数据库中的用户权限定义表 二、REVOKE 授予的权限可以由DBA或其他授权者用REVOKE语句收回 REVOKE语句的一般格式为: REVOKE [,]… [ON ] FROM [,]…; [例8] 把用户...
  • MySQL 数据库中可以使用 REVOKE 语句删除一个用户的权限,此用户不会被删除。 语法格式有两种形式,如下所示: 1) 第一种: REVOKE <权限类型> [ ( <列名> ) ] [ , <权限类型> [ ( <列名&...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 72,508
精华内容 29,003
关键字:

revoke