Segurança SSH

Use senhas fortes

Senhas fortes consistem em uma string que nenhum hacker conseguiria adivinhar nem por palpite nem por um bruteforce de poucas horas.

Procure escolher senhas com:

  • No mínimo 15 caracteres.
  • Combinação de letras (maiúsculas e minúsculas), números e caracteres não alfanuméricos.

Existem programas como o pwgen, o makepasswd, o apg, o KeePassX e comandos do Unix que geram senhas aleatórias seguras:

tr -dc '_A-Za-z0-9!"#$%&'\''()*+,-./:;<=>?@[\]^_`{|}~' < /dev/urandom | head -c25
pwgen -cnsy 25 1

Opções do pwgen:

  • -c: pelo menos uma letra maiúscula.
  • -n: pelo menos um caractere numérico.
  • -s: pelo menos um caractere especial.
  • -y: exclui caracteres ambíguos (como l, 1, I, 0, O, etc.).
  • 25: comprimento da senha.
  • 1: quantas senhas gerar.

As senhas geradas por esses programas são, de fato, seguras. Porém são muito difíceis de lembrar, o que faz com que você tenha que anotar em algum lugar. Portanto eu recomendo fortemente que você crie uma frase (passphrase) longa que você (e apenas você) consiga memorizar.

Desabilite o login do root por SSH

  • Edite a seguinte linha no arquivo /etc/ssh/sshd_config:

    PermitRootLogin no
    
  • Reinicie o daemon:

    sudo /etc/rc.d/sshd restart
    

    ou, caso use systemd:

    julio@acer ~> sudo systemctl restart sshd
    

Quando precisar de acesso como root, utilize o comando su.

Limite quem pode efetuar login por ssh

É útil quando apenas alguns usuários precisam acessar o sistema por ssh. Adicione a seguinte linha em /etc/ssh/sshd_config:

AllowUsers usr_1 usr_2 usr_3

Desative o “Protocol 1”

SSH possui dois protocolos. Como o Protocol 1 é antigo e inseguro, descomente a linha Protocol 2.

Altere a porta

Por padrão, a porta usada para ssh é a 22. Mude para algum número aleatório, preferivelmente acima de 1024. Exemplo: Port 2345

Perceba que agora teremos sempre que avisar a qual porta conectar:

ssh -p 2345 julio@casa.juliobs.com

Aqui eu também tive que abrir a porta (só TCP) pelo meu roteador.

Use um firewall

Podemos configurar o iptables para permitir que apenas alguns IPs específicos conectem à porta utilizada para SSH:

iptables -A INPUT -p tcp -s 201.43.81.111 --dport 22 -j ACCEPT

Aqui não posso utilizar a opção acima, pois frequentemente preciso conectar de IPs diferentes. Portanto uma solução mais interessante é limitar a quantidade de tentativas vindas do mesmo IP.

Registra IP que tentou acessar a porta 22 e rejeita pacotes caso o mesmo IP tenha tentado conectar 4 vezes ou mais no último minuto:

iptables -A INPUT -p tcp --dport 22 -m recent --set --name ssh --rsource

iptables -A INPUT -p tcp --dport 22 -m recent ! --rcheck --seconds 60 \
         --hitcount 4 --name ssh --rsource -j ACCEPT

Cancela a conexão se o mesmo IP tentar conectar mais de 3 vezes na porta 22 no mesmo minuto:

iptables -A INPUT -p tcp --dport 22 --syn -m limit --limit 1/m --limit-burst 3 -j ACCEPT

iptables -A INPUT -p tcp --dport 22 --syn -j DROP

Use chaves públicas/privadas para autenticação

  1. Crie uma chave:

    $ ssh-keygen -t rsa -b 4096 -f servidorx -C "pubkey para servidor X"
        Generating public/private rsa key pair.
        Enter passphrase (empty for no passphrase):
        Enter same passphrase again:
        Your identification has been saved in servidorx.
        Your public key has been saved in servidorx.pub.
        The key fingerprint is:
        e1:5c:44:b2:f4:48:c7:22:62:16:99:fb:44:11:23:a7 pubkey para servidor X
        The key's randomart image is:
        +--[ RSA 4096]----+
        |    o+=o+o+      |
        |    *+o+.B.      |
        |   oE+ .+.o      |
        |    . .o o       |
        |     o  S        |
        |      .          |
        |                 |
        |                 |
        |                 |
        +-----------------+
    

    O algoritmo padrão do ssh-keygen é RSA de 2048 bits, nesse exemplo eu usei RSA de 4096 bits. Pode até ser um exagero, mas nunca se sabe.

    Update de 2020: O RSA 4096 continua seguro, porém o recomendado é o Ed25519: ssh-keygen -t ed25519 -f servidorx -C "pubkey".

  2. Copie a chave para o servidor remoto.

    ssh-copy-id -i servidorx.pub '-p 2345 julio@servidorx.com'
    

    Esse comando é equivalente a concatenar o arquivo ~/.ssh/authorized_keys do servidor remoto com a chave pública servidorx.pub.

  3. Certifique que as permissões estão corretas:

    chmod 700 ~/.ssh
    chmod 600 ~/.ssh/servidorx
    
  4. Crie o arquivo ~/.ssh/config, que contem algumas configurações per-host, atalhos e aliases úteis:

    Host github.com
        HostName        github.com
        IdentityFile    ~/.ssh/github
        User            jbsilva
    
    Host juliobs.com
        HostName        juliobs.com
        IdentityFile    ~/.ssh/juliobs
        User            julio
    
    Host servidorx
        HostName        ssh.servidorx.com
        IdentityFile    ~/.ssh/servidorx
        User            usuariox
        Port            2345
    

    Esse arquivo facilita um pouco nossa vida, pois agora não precisamos mais lembrar o nome o usuário, o endereço completo do servidor nem a porta.

    Em vez de conectarmos ao servidorX usando:

    ssh -i servidorx -p 2345 usuariox@ssh.servidorx.com
    

    Podemos simplesmente:

    ssh servidorx
    

Julio Batista Silva
Julio Batista Silva
Engenheiro de Dados

Eu sou um engenheiro de computação apaixonado por ciência, tecnologia, fotografia e idiomas. Atualmente trabalhando como Engenheiro de Dados na Alemanha.

comments powered by Disqus