domingo, 16 de novembro de 2008

SSH Security Shell

SSH - Secure SHell

Secure Shell ou SSH é um conjunto de padrões e o protocolo que permite estabelecer um canal seguro entre dois computadores. O SSH utiliza o sistema de criptografia de chave pública para autenticar um computador remoto, podendo utilizar esse sistema de chaves também para autenticar usuários. A idéia do SSH é prover confidencialidade e integridade dos dados trocados entre dois computadores usando criptografia. Com SSH posso executar comandos em uma máquina remota, conexões X11 (com interface gráfica), além de transferência de arquivos.
O SSH é uma alternativa ao TELNET e FTP, uma vez que eles não utilizam criptografia. Ao configurar o SSH em uma estação estamos falando tanto de servidor como de cliente, pois outras clientes também podem se conectar á estação que assim será chamada se será chamada de servidor. E quando falo se conectar na minha máquina... estou falando em ter um shell como se fosse a máquina mesmo, tendo o total poder, levando em consideração com que usuário eu fiz a conexão! Ou seja, posso fazer tudo (em modo texto) acessando uma máquina remotamente... Mas sempre lembrando que eu preciso ter um usuário e permissão!!!
Existe uma diferença em minha máquina ser um servidor ssh, e ser cliente.

Ser Servidor SSH - Possibilito outras máquinas se conectarem na minha.
Ser Cliente SSH - Posso apenas me conectar em uma máquina que tenha Servidor SSH.

Antes de vermos a configuração do SSH, temos que entender como acontece uma conexão ssh. Entender como isso funciona ajuda muito na hora em que você for configurar um Firewall.

Tenho duas máquinas na rede:
ServerSSH <---------------------> ClientSSH

Ou seja, a minha máquina ClientSSH vai acessar o servidor, que nada mais é que qualquer outra máquina com o ssh instalado e configurado.

Agora, como ocorre essa conexão a nível de TCP/IP...

Para o cliente estabelecer uma conexão ele precisa saber a porta que o serviço está usando. Cada serviço no Linux usa uma porta específica. Por padrão, o SSH usa a porta 22.

Entendendo como funciona a conexão ssh...

Quando o cliente for estabelecer uma conexão SSH com o servidor para dar certo ele tem que bater na porta correta, ou seja, ele deverá bater na porta 22 para conversar.

ServerSSH <--(Porta 22)------ ClientSSH
O cliente tem que pedir uma conexão na Porta 22 do servidor, mas por qual porta o cliente sai? Não vai ser pela porta 22, pois a essa é para se conectarem nele por ssh. Podemos imaginar que seria a nossa porta dos fundos. Então, o cliente sai por qualquer porta que não é usada para um serviço específico. As portas que não são usadas para nenhum uso específico chamamos de portas altas. Elas vão de 1024 até 65535. Essa portas ficam disponíveis justamente para isso. E portas altas são tanto para entrada quando para saída Voltando ao exemplo...

O cliente pede a conexão para o servidor:
ServerSSH <--(Porta 22)----------(Portas Altas)--- ClientSSH

Agora se o servidor realmente está com essa porta disponível, ele tem que responder para o cliente. Para responder, ele vai ter que sair da máquina dele e se conectar ao no cliente falando que está disponível. Ficando assim:
ServerSSH <--(Porta 22)----------(Portas Altas)--- ClientSSH
ServerSSH --(Porta 22)----------(Portas Altas)---> ClientSSH

Resumindo:
O cliente vai pedir uma conexão da porta 22 e o servidor vai responder em qualquer porta alta que estiver disponível criando ai um túnel de conexão onde estarão sendo trafegadas as informações. Depois disso, o cliente precisará se autenticar, caso contrário o servidor irá rejeitar a conexão. Ou seja, você precisará ter um usuário e senha no servidor.
Sabendo como ocorre o processo de conexão, vamos então a configuração desse serviço.

Instalando o SSH:
# aptitude install ssh

Daí, já posso entrar no diretório onde ficam os arquivos de configuração.
#cd /etc/ssh/

Lá terei 2 arquivos principais:
sshd_config - Arquivo de configuração do servidor
ssh_config - Arquivo de configuraçõ do cliente

Vamos editar o arquivo de configuração do servidor:
# vi /etc/ssh/sshd_config

Comentarei as principais linhas

Lembrando que a maior parte das linhas dizem respeito aos arquivos para a criptografia do serviço e não é aconselhável mudar!

Pacote servidor SSH:
Servidor: # aptitude install openssh-server
Cliente: # aptitude install openssh-client

A primeira linha:

Port 2245
Porta padrão usada pelo servidor sshd. Posso mudar a porta, caso queira fugir do padrão, mas o cliente deverá saber disso para poder especificar em que porta bater. No caso do SSH é extremamente recomendado trocar essa porta já que provavelmente você (ADM) que será o cliente para administrar a máquina, com isso esse serviço não fica aberto para qualquer um, apenas para os que realmente sabem a porta que você setou! Claro que isso não significa que mudando a porta você está totalmente seguro, mas é interessante que mude. Se for mudar a porta, escolha uma porta alta, como, por exemplo, 2245

Próxima linha:

Protocol 2,1
São Protocolos aceitos pelo servidor.Devemos sempre apenas usar o Protocolo 2. O protocolo 1 do ssh já está totalmente bugado. Quando falo bugado estou me referindo a exploits que já me dão acesso root, explorando essas brechas no serviço! Nas últimas versões do SSH já nem vem mais o protocolo 1 setado, mas se você for da manutenção em um servidor mais antigo é importante que saiba desse detalhe. Protocolo nesse caso é apenas um conjunto de ações que o servidor realiza. Ou seja, protocolos determinam como o SSH vai se comportar. Do jeito que está a minha linha, estou aceitando os 2, mas dando preferência para o 2.
Protocol 2,1
Não devemos deixar assim. Deixe apenas o número 2,
Protocol 2

Próxima linha:

LoginGraceTime 30
A função dessa linha é determinar o tempo limite em segundos permitido para fazer login. Nesse caso então 30 segundos são suficientes para você digitar login e senha. Quanto mais tempo for colocado aqui, mas inseguro a autenticação pode ficar, pois daí alguém pode ficar tentando autenticar “chutando” senhas.

Próxima linha:

PermitRootLogin yes
Permite (yes) ou não (no) o login do usuário root. E essa com certeza temos que sempre deixar no.
PermitRootLogin no

A idéia é sempre fazer a conexão sendo um usuário mortal (limitado) e depois virar root quando já estiver lá dentro com o comando su. Sendo assim, o invasor terá que saber além da senha do root, uma senha de usuário normal também. Como medida de segurança nunca deixem que o root tenha acesso. Por padrão, o SSH permite que qualquer usuário cadastrado no sistema se logue remotamente, mas você pode criar uma lista de quem vai ou não acessar o sistema remotamente.

Próxima linha:

AllowUsers falexreis alexandre linus
Nesse caso, apenas os usuários falexreis, alexandre e linus conseguiriam fazer acesso remoto.

O contrário é: DenyUsers
Exemplo:
DenyUsers debian

Atenção: O usuário estar na linha DenyUsers não significa que ele não poderá o usar o sistema. Ele só não poderá fazer acesso remoto. Localmente ele continuará usando o sistema. Ou você usa a linha AllowUsers ou DenyUsers. Não use as duas juntas, pois não é necessário, isto é, quem não estiver na AllowUsers não pode acessar remotamente.

PermitEmptyPasswords no
Essa linha permite ou não que o SSH aceite senhas vazias. O padrão é no. Deixe como no.

Próxima linha:

ListenAddress 0.0.0.0
Se você quiser que o SSH só fique disponível para rede local, substitua o 0.0.0.0 pelo IP que o servidor tiver utilizando, por exemplo:

ListenAddress 192.168.0.1

0.0.0.0 quer dizer, sem restrição de IP, ou seja, que não importa o endereço da interface.

Essa opção permite limitar o SSH a uma única placa de rede. É usada quando o computador tem duas ou mais placas de rede.

Se você quer exibir uma mensagem antes do prompt de login, a mensagem é especificada através dessa linha. Essa opção aponta para o arquivo que conterá a mensagem. Geralmente essa linha vem comentada, portanto é necessário descomentá-la caso você queira usar.

Próxima linha:

X11Forwarding yes
Essa linha define se o servidor permitirá que os clientes executem aplicativos gráficos remotamente.
Se o servidor será acessado via internet ou se possui um link lento, você pode deixar esta opção como no para economizar banda

Leitura sugerida:
# man sshd_config

Pronto! Podemos salvar o arquivo.

Para levantar o serviço (Debian):
# /etc/init.d/ssh start

Red Hat
# service sshd start

Agora meu serviço está no ar, mas tenho que garantir isso.
Então, executo alguns passos que chamamos de "checklist do administrador".

O primeiro passo a fazer depois que executei o serviço é ver se o processo está rodando:

#ps aux
ou
#pgrep ssh
ou
#ps aux | grep ssh

Se o processo está rodando significa que o serviço subiu.

Depois tenho que ver se a porta do ssh está disponível, ou seja, se o meu cliente vai poder selçicitar uma conexão.

Executo esse comando para isso:

# netstat -anp | grep 22
tcp 0 0 0.0.0.0:22 0.0.0.0:* OUÇA 2248/sshd

Onde:
a é para todas (all);
n é para ser numérico, ou seja, não vai resolver nome.
p para verificar o processo responsável (PID).

Lembrando que se você trocou a porta padrão, terá que mudar o comando também!

Se minha porta estiver em estado de LISTEN ou OUÇA significa que ela está ouvindo, ou seja, está disponível.

Depois façam o teste, se você derrubar o servidor ssh e der o comando novamente, verá que ela não vai aparecer disponível.

Uma outra forma para ver se o cliente vai enxergar a porta aberta é com o comando:

#nmap localhost -p 22
Starting nmap 3.75 ( http://www.insecure.org/nmap/ ) at 2005-06-20 19:40 BRT
Interesting ports on localhost.localdomain (127.0.0.1):
PORT STATE SERVICE
22/tcp open ssh

Nmap run completed -- 1 IP address (1 host up) scanned in 0.136 seconds


Você pode utilizar o Windows através um cliente SSH feito para Windows chamado Putty para acessar o Linux.

Esse comando mostra se a porta que está aberta na minha máquina.
Em algumas distros (Debian é uma) esse comando não vem instalado.
Portanto:
# aptitude install nmap

Vamos ver agora como utilizar o SSH como cliente, acesso e transferência de arquivos.

O SSH possui diversas formas de utilização.

Para fazer um acesso remoto:
# ssh @

Exemplo:
# ssh falexreis@200.6.243.31

Se a porta do servidor não é a padrão (22), você precisa especificar a porta:
# ssh falexreis@200.6.243.31 -p 2245
Coloco a senha e já estou com o shell do servidor!

Como dito anteriormente, o SSH usa um sistema baseado em chaves assimétricas para verificar a identidade do servidor. O servidor tem uma chave pública, que é enviada ao cliente na primeira conexão. As identificações de todos os servidores conhecidos ficam armazenadas no arquivo .ssh/known_hosts dentro do diretório pessoal do cliente. Sempre após a primeira conexão em que você se conecta, é necessário verificar se a chave pública se encaixa com a chave privada. Isso é útil para prevenir um ataque chamado de "man-in-the-middle", no qual alguém substitui o servidor por outra máquina, usando o mesmo endereço IP. O falso servidor pode ser configurado para pegar sua senha. Mas por sorte, o SSH percebe que a identificação do servidor mudou e lhe avisa do problema.

Você só conseguirá acessar o servidor novamente sem a mensagem de erro se a linha no arquivo known_hosts do fingerprint do servidor for removida, as vezes, o mais prático é remover o known_hosts. Na próxima conexão com o servidor esse arquivo é criado novamente.

Para copiar arquivos de uma máquina para outra, deve-se seguir a mesma lógica do comando cp, que funciona da seguinte forma:
# cp

Só que o comando de cópia no SSH chama-se scp:
# scp

A diferença agora é que a origem e/ou destino podem ser remotos.

Exemplos:
Da máquina local para a máquina remota (upload):
# scp @

Da máquina remota para a máquina local(download):
# scp @:

Vamos supor que eu máquina cliente quero pegar um arquivo que está lá no servidor dentro do diretório /tmp por exemplo. Primeiro, lógico, tenho que ter acesso a esse diretório pelo usuário que vou me autenticar. Estou considerando o /tmp por ser público

Então faço assim:
#scp falexreis@200.6.243.31:/tmp/arquivo.txt /tmp

Ou seja, o usuário falexreis, vai logar no servidor (200.6.243.31) e dentro do tmp (:/tmp), vai copiar o arquivo arquivo.txt para o /tmp minha máquina.
Agora vamos fazer assim:
Eu usuário falexreis quer pegar todos os arquivos que estão no home (tem acesso a isso)
#scp -r 200.6.243.31:/home/falexreis/ /tmp
Ou seja, o -r aqui está falando que deverá ser recursivo, vai copiar o diretório e tudo que tem dentro dele! Depois do IP sempre tenho que colocar : e o caminho completo do arquivo no servidor.

Outro exemplo:

Mandando um arquivo da minha máquina para o servidor (upload):

$ scp -P 2245 artigos.bz2 200.6.243.31:/home/falexreis/artigos

Nesse caso a porta do servidor não é a padrão, então basta autenticar para que o arquivo seja enviado.

Aprofundando o assunto sobre chaves de criptografia assimétrica.

Vantagens:
Serve para aumentar o nível de segurança;
Facilita a execução de scripts remotamente;

Consiste em 2 arquivos:
- Chave privada (id_rsa);
- Chave pública (id_rsa.pub)

A chave privada é absolutamente sua, e, por segurança, ninguém deve ter acesso à ela. Então, o cliente só vai conseguir acessar o servidor, se sua chave se encaixar com a chave do servidor. A chave publica fica no servidor. A chave privada fica na sua máquina (ou melhor fica na máquina que você usa para acessar o servidor ssh)

Isso aumenta a segurança porque:
- Você precisa ter a chave privada para acessar o servidor;
- Além da chave, você precisa saber passphrase.

Vamos criar a chave (isso na máquina cliente):

$ ssh-keygen -t rsa

Vai ser pedido a passphrase, aí você escolhe uma.
As chaves vão ficar em:

$ cd ~/.ssh

Isso vai gerar os arquivos id_rsa e id_rsa.pub dentro do seu diretório home

A chave pública deve ser mandada para a máquina remota (servidor):

$ scp ~/.ssh/id_rsa.pub seu_login@ip_do_servidor:.ssh/authorized_keys

Se mudar a porta coloca-se -p porta

Ou você pode fazer isso (é bem mais prático):

$ ssh-copy-id login@servidor

O ssh-copy-id copia o conteúdo do arquivo .ssh/id_rsa.pub, dentro do seu diretório home para dentro do arquivo .ssh/authorized_keys dentro do diretório home do servidor remoto. Esse passo pode ser feito manualmente em caso de problemas, por isso passei os dois modos.

Aí depois é só acessar o servidor:
$ ssh seu_login@ip_do_servidor

Juiz de Fora 16/11/2008

Por hoje é só...

Esse é meu primeiro Artigo aqui, em breve postarei mais.

Fonte: Curso Linux System Administrator - 4Linux