Como gerencio a complexidade e a expiração das senhas para conexões com um cluster de banco de dados compatível com o PostgreSQL do Aurora?

7 minuto de leitura

Quero gerenciar a complexidade e a expiração de senhas para conexões com um cluster de banco de dados da edição do Amazon Aurora compatível com PostgreSQL.

Breve descrição

Para gerenciar senhas em seu cluster de banco de dados compatível com o PostgreSQL do Aurora, é possível usar os seguintes métodos:

Crie um hook de verificação de senha com uma Trusted Language Extension (TLE).
Ative o atributo restrito de gerenciamento de senhas.
Use a Autenticação de banco de dados do AWS Identity and Access Management (AWS IAM).
Crie uma política de senha personalizada para usuários do IAM.
Use o AWS Secrets Manager.

Resolução

Use um hook de verificação de senha com um TLE

Para usar um hook de verificação de senha com um TLE, primeiro você deve configurar o TLE em seu cluster de banco de dados compatível com o PostgreSQL do Aurora. Em seguida, crie o hook de verificação de senha.

Observação: ao nomear o hook, não é possível usar as regras de verificação de senha e usuário.

Exemplo de código de hook para verificação de senha:

SELECT pgtle.install_extension(
  'user-password-check-rules',
  '1.0',
  'Do not let users use the 10 most commonly used passwords',
  $_pgtle_$
    CREATE SCHEMA password_check;
    REVOKE ALL ON SCHEMA password_check FROM PUBLIC;
    GRANT USAGE ON SCHEMA password_check TO PUBLIC;
    -- Create table for bad passwords
    CREATE TABLE password_check.bad_passwords (plaintext) AS
    VALUES
      ('123456'),
      ('password'),
      ('12345678'),
      ('qwerty'),
      ('123456789'),
      ('12345'),
      ('1234'),
      ('111111'),
      ('1234567'),
      ('dragon');
    -- Create table for tracking user password changes
    CREATE TABLE password_check.usertime (
      user_name text PRIMARY KEY,
      lasttime timestamp
    );
    CREATE UNIQUE INDEX ON password_check.bad_passwords (plaintext);
    CREATE FUNCTION password_check.passcheck_hook(username text, password text, password_type pgtle.password_types, valid_until timestamptz, valid_null boolean)
    RETURNS void AS $$
      DECLARE
        invalid bool := false;
        userexists bool;
        last_password_change timestamp;
      BEGIN
        -- Check if user already exists      
        SELECT EXISTS (SELECT user_name FROM password_check.usertime WHERE user_name = username) INTO userexists;
        -- If user exists, check password age
        IF (userexists) THEN
          SELECT lasttime INTO last_password_change
          FROM password_check.usertime
          WHERE user_name = username;
          -- Check if password is older than 90 days
          IF (CURRENT_TIMESTAMP - last_password_change) > INTERVAL '90 days' THEN
            RAISE EXCEPTION 'Password has expired. It must be changed every 90 days. Last change was on %', last_password_change;
          END IF;
          -- Update timestamp for new password change
          UPDATE password_check.usertime SET lasttime = CURRENT_TIMESTAMP WHERE user_name = username;
        ELSE
          -- First time user, add to tracking table
          INSERT INTO password_check.usertime VALUES(username, CURRENT_TIMESTAMP);
        END IF;
        -- Existing password length check
        IF length(password) < 8 THEN
          RAISE EXCEPTION 'Password must be at least 8 characters long.';
        END IF;
        -- Existing common password check
        IF password_type = 'PASSWORD_TYPE_MD5' THEN
          SELECT EXISTS(
            SELECT 1
            FROM password_check.bad_passwords bp
            WHERE ('md5' || md5(bp.plaintext || username)) = password
          ) INTO invalid;
          IF invalid THEN
            RAISE EXCEPTION 'Cannot use passwords from the common password dictionary';
          END IF;
        ELSIF password_type = 'PASSWORD_TYPE_PLAINTEXT' THEN
          SELECT EXISTS(
            SELECT 1
            FROM password_check.bad_passwords bp
            WHERE bp.plaintext = password
          ) INTO invalid;
          IF invalid THEN
            RAISE EXCEPTION 'Cannot use passwords from the common password dictionary';
          END IF;
        END IF;
        -- Existing complexity check
        IF NOT (password ~ '[A-Z]' AND password ~ '[a-z]' AND password ~ '[0-9]' AND password ~ '[^a-zA-Z0-9]') THEN
          RAISE EXCEPTION 'Password must contain uppercase letters, lowercase letters, numbers, and special characters';
        END IF;
      END
    $$ LANGUAGE plpgsql SECURITY DEFINER;
    GRANT EXECUTE ON FUNCTION password_check.passcheck_hook TO PUBLIC;
    SELECT pgtle.register_feature('password_check.passcheck_hook', 'passcheck');
  $_pgtle_$
);

Observação: modifique o código de acordo com seus requisitos. Por exemplo, é possível adicionar mais senhas à tabela bad_passwords, alterar o tamanho necessário da senha ou verificar a complexidade da senha.

Para verificar se uma senha atende aos requisitos de tamanho, execute o seguinte comando:

CREATE ROLE user1 PASSWORD '123456';

Saída esperada:

ERROR: Password must be at least 8 characters long.
CONTEXT: PL/pgSQL function password_check.passcheck_hook(text,text,pgtle.password_types,timestamptz,bool)
SQL statement "SELECT password_check.passcheck_hook($1::pg_catalog.text, $2::pg_catalog.text, $3::pgtle.password_types, $4::pg_catalog.timestamptz, $5::pg_catalog.bool)"

Observação: o exemplo anterior indica um erro porque a senha deve ter pelo menos oito caracteres.

Para verificar se uma senha é muito comum, execute o seguinte comando:

CREATE ROLE user1 PASSWORD 'password';

Saída esperada:

ERROR: Cannot use passwords from the common password dictionary
CONTEXT: PL/pgSQL function password_check.passcheck_hook(text,text,pgtle.password_types,timestamptz,bool)
SQL statement "SELECT password_check.passcheck_hook($1::pg_catalog.text, $2::pg_catalog.text, $3::pgtle.password_types, $4::pg_catalog.timestamptz, $5::pg_catalog.bool)"

Observação: o exemplo anterior indica um erro porque não é possível usar senhas do dicionário de senhas comuns.

Para verificar a expiração da senha, conclua as seguintes etapas:

Execute o comando a seguir para verificar quando foi a última vez que um usuário alterou uma senha:

SELECT * FROM password_check.usertime WHERE user_name = 'user1';

Saída esperada:

user_name | lasttime
----------+----------------------------
user1     | 2025-10-01 18:48:07.319908
(1 row)

Execute o comando a seguir para definir a última vez como sendo 91 dias:

UPDATE password_check.usertime
SET lasttime = CURRENT_TIMESTAMP - INTERVAL '91 days'
WHERE user_name = 'user1';

Saída esperada:

UPDATE 1

Execute o comando a seguir para verificar se a última vez tem 91 dias:

SELECT * FROM password_check.usertime WHERE user_name = 'user1';

Saída esperada:

user_name | lasttime
----------+----------------------------
user1     | 2025-07-02 18:55:36.248913
(1 row)

Execute o comando a seguir para testar a função de expiração da senha:

ALTER USER user1 WITH PASSWORD 'NewTestPass786!';

Saída esperada:

NOTICE: Password has expired. It must be changed every 90 days. Last change was on 2025-07-02 18:55:36.248913
ALTER ROLE

Execute o comando a seguir para verificar se a senha do usuário foi alterada e quando foi atualizada pela última vez:

SELECT * FROM password_check.usertime WHERE user_name = 'user1';

Saída esperada:

user_name | lasttime
----------+----------------------------
user1     | 2025-10-01 19:18:42.028533
(1 row)

Ative o atributo restrito de gerenciamento de senhas

Defina o parâmetro rds.restrict_password_commands como 1 para que somente os usuários do banco de dados aos quais você concede o perfil rds_password possam gerenciar senhas.

Conclua as etapas a seguir: