Perguntas[role](dba)

Em nosso banco de dados SQL Managed Instance, criamos uma função de banco de dados definida pelo usuário e adicionamos 20 usuários a ela. Agora, durante a verificação pelo Microsoft Defender for Cloud , estamos recebendo o seguinte erro/aviso:

Alguém pode explicar o erro e o que precisa ser feito para corrigir (resolver) o problema?

Ref : Regras de avaliação de vulnerabilidade

Eu gostaria de implementar a segurança em nível de linha em todas as minhas tabelas. Cada tabela tem uma coluna chamada data_classificationque possui uma lista de valores. Idealmente, gostaria de criar funções de banco de dados que tenham permissão para ver determinadas linhas. Isso permitirá escalabilidade quando eu adicionar novos usuários. Todos os exemplos de RLS que posso encontrar são para usuários.

Minha tentativa é a seguinte. Eu crio uma tabela com uma coluna para cada função e uma linha para cada tipo de permissão. Se uma função tiver acesso a essa permissão, o nome da permissão será preenchido, caso contrário, será Null. Dado um nome de usuário, eu uso

DECLARE @role_name nvarchar(50);
set @role_name = SELECT dp.name as role_name  
FROM sys.sysusers us right 
JOIN  sys.database_role_members rm ON us.uid = rm.member_principal_id
JOIN sys.database_principals dp ON rm.role_principal_id =  dp.principal_id
WHERE us.name = USER_NAME();
EXEC('SELECT ' + @role_name + ' FROM [admin].[data_permissions] WHERE ' + @role_name + ' IS NOT NULL')

Para selecionar todas as permissões que essa função possui. Mas não consigo encaixar isso em um predicado para filtrar, eu estava esperando algo assim

CREATE FUNCTION DataFilter.fn_data_classification(@data_classification AS varchar(20))  
    RETURNS TABLE  
WITH SCHEMABINDING  
AS  
    RETURN SELECT 1 AS result   
WHERE 
    @data_classification in (Query above)

Isso não funcionou e continuo recebendo erros de sintaxe. Qualquer ajuda seria muito apreciada. Alterar a tabela de permissões também é uma possibilidade se isso facilitar as coisas. Obrigado

======

EDIT: Eu tenho data_classifications a,b,c,d,ee roles role_x, role_y, role_z, role_xtem permissões para a,b,c,d,e, role_ytem permissão para ver a,c,de role_ztem permissão para ver b,c,e. Também gostaria de torná-lo extensível se for necessária uma nova função ou uma nova classificação de dados.

Eu também quero adicionar esse filtro em todas as tabelas, espero que com o mínimo de comandos possível.

Estou aprendendo Oracle e tenho que fazer funções. Eu criei um c##admina partir de um sys, concedi a ele todas as concessões. Então eu criei um c##manager_rolee c##manager. Eu concedi esse papel para c##manager. Depois disso, comecei a conceder privilégios para c##manager_role. Além disso, concedi o seguinte:

CREATE VIEW                              YES YES NO

CREATE ANY VIEW                          NO  NO  NO

DROP ANY VIEW                            YES YES NO 

Saída acima de:

select * from role_sys_privs where ROLE = 'C##MANAGER_ROLE' order by 1;

Agora, não consigo entender, por que CREATE ANY VIEWtem 3 "NÃO" e por que não consigo criar nenhuma visualização de c##manager.

De c##admin:

grant CREATE ANY VIEW TO c##manager_role with admin option CONTAINER=all;

De c##manager:

create view friends_v4 as select t1.nickname as "USER", t2.nickname as "FRIEND" from c##admin.clients t1, c##admin.clients t2, c##admin.friends where (t1.id = c##admin.friends.user_id and t2.id = c##admin.friends.friend_id);

Erro:

Relatório de erros - ORA-01031: привилегий недостаточно 01031. 00000 - "privilégios insuficientes"

*Causa: Foi feita uma tentativa de executar uma operação de banco de dados sem os privilégios necessários.

*Ação: Peça ao seu administrador de banco de dados ou administrador de segurança designado para conceder a você os privilégios necessários

Todas as tabelas indicadas existem.

Estou tentando configurar o RBAC no Postgres onde tenho um banco de dados e um esquema. Eu tenho alguns papéis provisioner, service, mydb_ro, e mydb_rw. Eu executei o seguinte para alterar os privilégios padrão

ALTER DEFAULT PRIVILEGES FOR ROLE provisioner IN SCHEMA mydb_schema
    GRANT SELECT                           ON TABLES TO mydb_ro;  -- only read

ALTER DEFAULT PRIVILEGES FOR ROLE provisioner IN SCHEMA mydb_schema
    GRANT INSERT, UPDATE, DELETE, TRUNCATE ON TABLES TO mydb_rw;  -- + write, TRUNCATE optional

ALTER DEFAULT PRIVILEGES FOR ROLE provisioner IN SCHEMA mydb_schema
    GRANT REFERENCES, TRIGGER              ON TABLES TO mydb_rw;  -- + TRIGGER

ALTER DEFAULT PRIVILEGES FOR ROLE provisioner IN SCHEMA mydb_schema
    GRANT USAGE, SELECT, UPDATE            ON SEQUENCES TO mydb_rw;  -- SELECT, UPDATE are optional

ALTER DEFAULT PRIVILEGES FOR ROLE provisioner IN SCHEMA mydb_schema
    GRANT EXECUTE                          ON FUNCTIONS TO mydb_rw;

isso é o que eu vejo nos privilégios padrão

postgres@mydb=> \ddp
                           Default access privileges
┌─────────────┬──────────────────┬──────────┬─────────────────────────────────┐
│    Owner    │      Schema      │   Type   │        Access privileges        │
├─────────────┼──────────────────┼──────────┼─────────────────────────────────┤
│ provisioner │ mydb_schema      │ function │ mydb_rw=X/provisioner           │
│ provisioner │ mydb_schema      │ sequence │ mydb_rw=rwU/provisioner         │
│ provisioner │ mydb_schema      │ table    │ mydb_ro=r/provisioner          ↵│
│             │                  │          │ mydb_rw=awdDxt/provisioner      │
└─────────────┴──────────────────┴──────────┴─────────────────────────────────┘

Mas quando estou logado como um usuário que tem a provisionerfunção e crio uma tabela, um usuário que tem a servicefunção não pode vê-la. O que estou fazendo errado?

agora eu corri

GRANT mydb_ro TO mydb_rw;
GRANT mydb_rw TO service;

Mas isso não ajudou com o problema de permissão.

Estou tentando entender se está tudo bem para mim descartar o papel "postgres", ou pelo menos removê-lo como superusuário. Obrigado!

Eu quero criar uma função que por padrão não tem permissão para fazer nada. Ele tem basicamente zero permissões. A partir dessa função, quero conceder o conjunto mínimo de permissões.

Como você pode criar uma função sem nenhum tipo de permissão?

Mongodb V 4.0

Desejo restringir a função de um usuário permitindo apenas novas inserções na coleção. Seja como um novo documento ou como um anexo ao documento. Eu não quero que o usuário possa atualizar (substituir) campos no documento, mas atualizar/(anexar/adicionar) está bem. Existe alguma boa estratégia lá fora para isso. Minhas duas opções agora são:

Crie duas coleções. Restrinja uma e permita atualizações completas na outra, assim que todas as atualizações estiverem completas, copie/mova o documento de uma coleção para outra.

Alternativa 2) limitar as funções apenas ao operador update.$push, que é um tipo de acréscimo ao operador de matriz. Eu não encontrei uma maneira de fazer isso a partir de agora.

Enquanto correndo

select * from sys.server_principals

para publicfunção, na coluna is_fixed_roleé mostrado 0

Mas a documentação afirma que é uma função de servidor fixa.

Link da Documentação

Embora seja declarado que public é um pouco diferente de outras funções, porque podemos atribuir permissões a ele. De qualquer forma, é mencionado como um papel fixo.

Alguém pode explicar esse dilema?

A versão curta primeiro:

É possível ter uma nova conexão de banco de dados PostgreSQL invocada automaticamente SET ROLEcom uma função específica, seja por configurações na função de conexão (usando ALTER ROLE), ou uma opção no final de um URI de conexão?

Mais longo, com contexto:

Estou configurando um aplicativo da Web para usar credenciais de banco de dados rotativas (portanto, há uma variedade de funções em jogo). No entanto, essas credenciais também são usadas para modificações no banco de dados (via migrações do Rails), e isso significa que as tabelas se tornam propriedade de uma função que não deveria existir a longo prazo.

Eu posso modificar as credenciais rotativas para que elas herdem de uma função pai (que não tem a capacidade de fazer login) e, em seguida, SET ROLEtodas as modificações do banco de dados são de propriedade do pai, em vez da função filho de curto prazo. Isso resolve o problema de propriedade, mas exige que todas as conexões sejam invocadas SET ROLE parent- não é realmente viável.

Portanto, quero uma maneira de garantir que cada conexão filha sempre opere dentro do contexto da função pai. Isso é possível?

Estamos limpando/padronizando contas de usuário/aplicativo de banco de dados no sistema que tem uma mistura de contas que foram criadas usando comandos diferentes em momentos diferentes por indivíduos diferentes.

Temos uma situação em que, para algumas contas, o atributo de data de expiração da senha foi definido explicitamente como infinito e, para algumas, não conforme:

postgres=# \du+                                                                                    List of roles
    Role name     |                         Attributes                         | Member of |                                       Description
------------------+------------------------------------------------------------+-----------+-----------------------------------------------------------------------------------------
 user_1           |                                                            | {}        |
 user_2           |                                                            | {}        |
 user_3           | Password valid until infinity                              | {}        |
 user_4           | Password valid until infinity                              | {}        |

de modo a:

postgres=# SELECT * FROM pg_shadow;
     usename    | usesysid | usecreatedb | usesuper | userepl | usebypassrls |               passwd                | valuntil | useconfig
 ---------------+----------+-------------+----------+---------+--------------+-------------------------------------+----------+-----------
  user_1        |    12345 | f           | f        | f       | f            | md5_foo                             |          |
  user_2        |    12346 | f           | f        | f       | f            | md5_foo                             |          |
  user_3        |    12347 | f           | f        | f       | f            | md5_bar                             | infinity |
  user_4        |    12348 | f           | f        | f       | f            | md5_bar                             | infinity |
 (4 rows)

e:

postgres=# SELECT * FROM pg_roles;
     rolname    | rolsuper | rolinherit | rolcreaterole | rolcreatedb | rolcanlogin | rolreplication | rolconnlimit | rolpassword | rolvaliduntil | rolbypassrls | rolconfig |  oid
 ---------------+----------+------------+---------------+-------------+-------------+----------------+--------------+-------------+---------------+--------------+-----------+-------
  user_1        | f        | f          | f             | f           | t           | f              |           -1 | ********    |               | f            |           | 12345
  user_1        | f        | f          | f             | f           | t           | f              |           -1 | ********    |               | f            |           | 12346
  user_1        | f        | f          | f             | f           | t           | f              |           -1 | ********    | infinity      | f            |           | 12347
  user_1        | f        | f          | f             | f           | t           | f              |           -1 | ********    | infinity      | f            |           | 12348
 (4 rows)

Ex: user_1e user_2foram criados com:

CREATE USER user_1/2 WITH ENCRYPTED PASSWORD 'foo';

considerando que user_3e user_4foram criados com:

CREATE USER user_3/4 WITH ENCRYPTED PASSWORD 'bar' VALID UNTIL 'infinity';

Queremos redefinir o VALID UNTILatributo para que:

postgres=# \du+                                                                                    List of roles
     Role name     |                         Attributes                         | Member of |                                       Description
 ------------------+------------------------------------------------------------+-----------+-----------------------------------------------------------------------------------------
  user_1           |                                                            | {}        |
  user_2           |                                                            | {}        |
  user_3           |                                                            | {}        |
  user_4           |                                                            | {}        |

Tentamos, sem sucesso:

1. ALTER ROLE user_1/2 WITH VALID UNTIL NULL;
2. ALTER ROLE user_1/2 WITH VALID UNTIL '';
3. ALTER ROLE user_1/2 WITH VALID UNTIL DEFAULT;

Portanto, a pergunta é: é possível redefinir o atributo de função de data de expiração de senha para NULL/ DEFAULT, de preferência sem precisar recriar a função?