Uma das formas de facilitar sua vida no poderoso mundo da “tela preta” é o próprio recurso do auto completion, presente em shells com o bash. Outro truque bem simples e interessante, mas deconhecido por muitos, é comando shopt. Com ele, pode-se pedir uma ajuda da shell para completar seus comandos “cd” para mudar de diretório quando há apenas um pequeno erro de digitação.

Por exemplo, suponha que ao tentar entrar no diretório /tmp, vc execute o seguinte comando:

$ cd /tmx

Obviamente que você receberá uma mensagem de que esse diretório (/tmx) não existe. Entretanto, tente executar o comando shopt dessa maneira:

$ shopt -s cdspell

Em seguinda, tente executar o comando “cd /tmx” e confira que, mesmo tendo errado o caminho, você estará dentro do diretório pretendido, ou seja, o /tmp. Se você quiser que todas os seus terminais de comandos sejam executados já com essa opção, basta inserir o comando “shopt -s cdspell” no arquivo .bashrc ou .bash_profile (conforme sua distribuição Linux ou versão de Unix).

Antes de terminar, logicamente que o título desse pequeno post é completamente baseado nas “peripécias criativas” de meu grande amigo e mestre do shell Júlio Neves. Por fim, como se pode ver, mesmo no mundo da “tela preta”, às vezes, a ajuda cai do “shell”. Até a próxima!

Para evitar isso, o protocolo SSH possui um recurso muito interessante: a autenticação por meio de chaves públicas, que evita a necessidade de prover senhas durante a abertura de sessões SSH em máquinas remotas onde a chave pública do usuário já foi previamente copiada. Normalmente, esse processo se dá através da criação de um par de chaves criptográficas por meio do comando ssh-keygen, conforme apresentado no exemplo a seguir:

jansen@scadufax $ ssh-keygen -t dsa

Nesse caso, um par de chaves (pública e privada) está sendo criado usando-se o algorimo DSA. As chaves privada e pública, recém-criadas, são gravadas, nesse caso, nos arquivos id_dsa e id_dsa.pub, respectivamente, e ficam localizadas no diretório .ssh, dentro do home do usuário. Para se valer do recurso de não precisar prover senhas é preciso, então, copiar a chave pública para o arquivo .ssh/authorized_keys nos diretórios home dos usuários remotos, usando-se, por exemplo, o seguinte comando:

jansen@scadufax $ scp ~/.ssh/id_dsa.pub jsena@smeagol:~/.ssh/authorized_keys

Nesse caso, quando o usuário jansen, a partir da máquina scadufax, tentar abrir uma sessão SSH com o usuário jsena na máquina smeagol, nenhuma senha será necessária. O processo de autenticação se dará através das chaves criptográficas. Até nenhuma novidade, certo? Entretanto, imagine que mais de um usuário deseje acessar a conta jsena na máquina smeagol. Pode até ser a mesma pessoa utilizando um par de chaves criptográficas diferentes do anterior, gerado, por exemplo, em outro computador. Nesse caso, se o mesmo procedimento anterior for utilizado, o arquivo authorized_keys, que já contém a chave pública de outro usuário, será sobrescrito, passando a invalidar o acesso cadastrado anteriormente. Para evitar esse problema, a partir do segundo usuário, seria necessário adotar outros procedimentos para a cópia da chave-pública de forma a não sobrescrever o conteúdo já existente no arquivo authorized_keys.

Para facilitar esse processo, existe um utilitário chamado ssh-copy-id que é desconhecido por uma parcela considerável dos usuários de SSH. Essa pequena ferramenta resolve esse problema da cópia de diversas chaves para um mesmo arquivo authorized_keys:

jansen@scadufax $ ssh-copy-id jsena@smeagol

Caso seja necessário copiar outras chaves para acessar a conta jsena na máquina smeagol, basta utilizar o mesmo comando. Caso um mesmo usuário tenha mais de um par de chaves (sim, isso é possível), pode-se indicar quais delas se deseja copiar para a máquina remota:

jansen@gandalf $ ssh-copy-id -i .ssh/id_rsa.pub jansen.sena@boromir

Simples, não? Bem, acho que é isso.

IMPORTANTE: Para que o mecanismo de autenticação através de chaves públicas funcione corretamente, é necessário que o servidor SSH esteja configurado para tal. Mas isso é assunto para outro momento!

Além de poder executar diversos comandos individuais de maneira ágil, a possibilidade de poder combinar comandos através do uso dos pipes é o que, particularmente, considero ser um dos grandes poderes “Jedi” da “tela preta”. Com esse recurso, é possível criar, facilmente, funcionalidades que não existem através de um único comando para atender às suas necessidades. É claro que, quanto maior a experiência com a “tela preta”, melhor será suas condições em usar do recurso dos pipes. E, logicamente, nada melhor do que praticar um pouco para desafiar a criatividade.

Diante disso, resolvi compartilhar por aqui um exemplo que pode ser útil para o seu dia a dia: reduzir o tamanho de suas fotos. Com câmeras digitais cada vez mais acessíveis e com a sua inclusão em diversos dispositivos como celulares e tablets, muitas pessoas costumam acumular muitos gigas armazenando suas imagens. Some-se a isso o fato das resoluções cada vez mais altas gerarem arquivos maiores. Diante disso, seja como uma forma de economizar espaço em seus meios de armazenamento (e.g. HDs externos) ou como facilitar o envio e o compartilhamento de suas fotos através da Internet, reduzir o tamanho de suas fotografias, às vezes, pode ser uma ideia interessante.

A questão é: como fazer isso de umam única vez aplicando a redução para todas as fotografias selecionadas? Bem, como você já deve ter desconfiado, a “tela preta” pode lhe ser útil nesse momento especialmente por meio do uso dos pipes. Vamos dar uma olhada?

Suponha que exista um diretório chamado /home/jansen/MyPictures repleto de fotografias com a extensão “JPG”. Todas essas fotografias estão com uma resolução muito alta e cada arquivo possui em torno de 5MB. A ideia é conseguir reduzir todos esses arquivos para uma resolução de 800×600.

O primeiro passo consiste em instalar um excelente gerenciador de imagens em linha de comando (sim, isso mesmo!), chamado imagemagick. Caso sua distribuição seja baseada no Debian (e.g. Ubuntu), basta executar o seguinte comando com o seu usuário convencional:

$ sudo apt-get install imagemagick

Em seguida, digite sua senha. Por outro lado, caso seu usuário não esteja configurado no sudo (isso é comum em instalações padrão do Debian, por exemplo), abra um terminal como root e digite o comando anterior diretamente:

# apt-get install imagemagick

Com o seu usuário convencional, entre no diretório /home/jansen/MyPictures, onde estão armazenadas as imagens e use do “poder Jedi” dos pipes:

$ cd /home/jansen/MyPictures

$ mkdir /tmp/MyReducedPictures && ls *JPG | cut -d. -f1 | xargs -t -i \ convert -resize 800x600 {}.JPG /tmp/MyReducedPictures/{}_REDUCED.JPG

Com isso, suas imagens vão começar a ser reduzidas de tamanho, uma a uma. Passados alguns segundos (de acordo com a quantidade de fotos), uma cópia com a resolução reduzida de todas as imagens, estará salva no diretório /tmp/MyReducedPictures!!! Simples, não?!

Quer entender um pouco melhor o que aconteceu? Então aguarde o próximo post…

Para verificar algumas das informações comumente reveladas por um servidor Web aos clientes que conectam-se a ele, basta utilizar o antiquado mas ainda útil telnet. Nesse caso, é suficiente escolher um site qualquer, direcionar a conexão para a porta 80 e submeter ao servidor algumas das poucas informações obrigatórias do protocolo HTTP (GET e Host, por exemplo), conforme mostrado a seguir:

# root@scadufax:~# telnet www.xxxxx.com.br 80
Trying 201.123.123.121...
Connected to server.xxxxx.com.br.
Escape character is '^]'.
GET / HTTP/1.1
Host: www.xxxxx.com.br

Após a cláusula “Host”, pressione duas vezes Enter. Em seguida, o servidor Web deve retornar os cabeçalhos HTTP de resposta e o conteúdo da página, de acordo como mostrado abaixo:

HTTP/1.1 200 OK
Date: Fri, 08 Jul 2011 00:47:40 GMT
Server: Apache/2.2.9 (Debian) PHP/5.2.6-1+lenny10 with Suhosin-Patch
Last-Modified: Thu, 20 Apr 2006 18:44:51 GMT
ETag: "9f132-c96-411e12ad8aec0"
Accept-Ranges: bytes
Content-Length: 3222
Content-Type: text/html; charset=ISO-8859-1

<<< CONTEÚDO DA PÁGINA>>>

Dentre os cabeçalhos de resposta, dedique atenção especial ao “Server”, em destaque. Nele, é possível identificar o servidor Web (Apache), sua versão (2.2.9), o sistema operacional (Debian) e ainda a versão do PHP (5.2.6-1+lenny10). Tais informações já ajudam um atacante a escolher quais ferramentas ele poderá ajudar em um eventual ataque. Pior ainda: o atacante consegue descobrir se seu servidor encontra-se completamente desatualizado e, portanto, possivelmente vulnerável contra um conjunto maior de exploits. Revelar essas informações no cabeçalho “Server” é o comportamento mais comum para um servidor Apache instalado diretamente dos repositórios de pacotes de sua distribuição.

Outra forma de identificar se o servidor está revelando mais informações do que deveria consiste simplesmente em provocar algum erro, acessando, por exemplo, uma página que, certamente, não existe naquele servidor Web:

http://www.xxxxx.com.br/abcdefghijklmnop

Servidor Apache revelando informações desnecessárias.

Normalmente, em sites mais bem configurados, as páginas de erro são todas customizadas. Nesses casos, algumas vezes, as informações sobre o servidor não são apresentadas.

Surpreso? É nesse estado que se encontra seu servidor? Bem, então é hora de corrigir esse problema.

O Apache possui duas configurações bem simples mas que são costumeiramente ignoradas, fundalmentalmente pelos administradores de sistemas menos experientes: ServerTokens e ServerSignature que podem impedir que o servidor revele informações mais detalhadas no cabeçalho “Server” do HTTP e que informações desnecessárias sejam apresentadas nas páginas de erro default do Apache, respectivamente. Para fazê-las desempenhar essas funções, basta adicioná-las no arquivo de configuração do Apache da seguinte maneira:

ServerTokens Prod
ServerSignature Off

Depois, reinicie o seu servidor Apache e veja se agora, seu servidor passou a “falar” um pouco menos…

Logicamente que existem muitas outras providências a serem tomadas para fazer um bom trabalho de hardening de um servidor Apache. Entretanto, deixaremos isso para uma outra oportunidade.

Bem, acho que é isso. Até o próximo post.

Já utilizei diversas distribuições Linux nesse equipamento. Aliás, foi essa uma das razões pelas quais eu o adquiri. Testar algumas distribuições Linux é um hobby antigo. Além da distro original, o Xandros, que durou poucas horas no equipamento, já testei diversas outras opções baseadas em Debian, o Eeebuntu, o Easy Peasy, dentre outros. O Ubuntu passou, então, a ter uma versão oficial para esses equipamentos: o Ubuntu Netbook Remix, que comecei a utilizar em meu Asus eeePC 701. Entretanto, esse produto passou a ser integrado ao Ubuntu padrão. Ou seja, a partir de então, a mesma imagem ISO poderia ser utilizada para notebooks e netbooks.

Recentemente, então, resolvi atualizar o sistema operacional dele para o Ubuntu 11.04 (32 bits). Aproveito, então, esse rápido post para compartilhar algumas informações mais básicas. Gravei a imagem ISO em um pen drive mas, para minha surpresa, o instalador detectou um problema que impedia a instalação de prosseguir: o espaço mínimo sugerido para instalação é 4.4 GB, entretanto, o Asus eeePC 701 conta apenas com um SSD de 4 GB. A solução foi, então, fazer o download da versão alternate do Ubuntu 11.04 e a instalação transcorreu sem mais problemas.

Quanto ao particionamento, não utilizei partições separadas para os diversos diretórios muito menos qualquer recurso de LVM. Afinal de contas, trata-se de um pequeno disco de 4 GB. Outra recomendação interessante: não utilizei qualquer partição de swap. Existem muitas discussões com relação ao limite de operações de escrita que um SSD pode suportar antes de apresentar problemas. Fóruns repletos de comentários sobre essas questões estão publicados Internet a fora. Não utilizar uma partição de swap é uma forma de reduzir um pouco essas operações e ainda uma boa oportunidade para ver como o sistema iria se comportar. Em meu caso, a ausência do swap não foi um problema uma vez que meu Asus eeePC 701 possui 2 GB de RAM, mais do que suficiente para o tipo de uso que faço desse equipamento. Após a fase de particionamento, o instalador “reclamou” da ausência de uma partição de swap, mas não impediu que eu prosseguisse com a instalação.

Feito isso, decorridos alguns minutos, estava com o Ubuntu 11.04 instalado em meu eeePC. De imediato, desinstalei alguns pacotes desnecessários para economizar espaço tal como o Evolution, jogos, dentre outros.

Por fim, utilizei o tmpfs, um sistema de arquivos que é mapeado na memória RAM, para montar os diretórios /tmp e /var/tmp. Para isso, basta editar o arquivo /etc/fstab acrescentando as seguintes linhas:

tmpfs		/tmp		tmpfs	size=100M,mode=1777	0 0
tmpfs		/var/tmp	tmpfs	size=100M,mode=1777	0 0

Logicamente, como tmpfs é mapeado na memória RAM, o conteúdo desses diretórios é apagado todas vezes que seu noteebok é desligado. Bem, sem problemas nesse caso porque o conteúdo desses diretórios deve ser, presumidamente, temporário. Feito esse processo, no próximo reboot o pequeno eeePC já deve separar os dois diretórios dos demais que estão gravados no SSD.

Para verificar se essa configuração funcionou, após reiniciar o computador, execute o comando “mount” e tente localizar linhas semelhantes às apresentadas a seguir:

tmpfs on /tmp type tmpfs (rw,size=100M,mode=1777)
tmpfs on /var/tmp type tmpfs (rw,size=100M,mode=1777)

A maneira mais comum para remover um LV consiste, simplesmente, em utilizar o comando lvremove. Por exemplo:

# lvremove /dev/MyVG/lvol_test

Entretanto, em alguns sistemas, me deparei com o seguinte erro ao tentar remover LV:

# lvremove /dev/MyVG/lvol_test
Can't remove open logical volume "lvol_test"

Bem, caso você esteja com esse problema, existe uma solução muito simples por meio da utilização do dmsetup.

# dmsetup info -c MyVG-lvol_test

Name               Maj Min Stat   Open Targ Event  UUID
MyVG-lvol_test     253   8 L–w       1    1      0 XiuqlKY91paW...

Nesse caso, o valor que interessa é o da coluna Open. O  número “1″ identifica que o LV encontra-se no status de aberto e isso pode ser a causa do problema. Se esse for o seu caso, execute o comando dmsetup da seguinte maneira:

# dmsetup remove MyVG-lvol_test

Em seguida, tente executar novamente o comando lvremove que, dessa vez, deve reportar a remoção com sucesso do LV:

# lvremove /dev/MyVG/lvol_test
Logical volume "lvol_test" successfully removed

Bem, acho que é isso.

Bem, primeiramente, permita que eu me desculpe por ‘descortinar’ essa verdade caso você ainda achasse, até o parágrafo anterior, que um “rm -f” era um comando forte e com tanta ‘personalidade’ ao ponto de mandar pro espaço qualquer arquivo ou diretório. O fato é que ao remover um arquivo com esse comando o sistema operacional, em poucas palavras, simplesmente retira os “ponteiros” para os blocos de dados que formavam o arquivo. Por outro lado, esses blocos estão lá em seu HD e podem, com a ajuda de algumas ferramentas, ser recuperados. Provavelmente esses blocos irão ser sobrescritos apenas quando novos arquivos forem utilizando aqueles mesmos espaços e isso pode demorar um tempo bastante considerável principalmente se o computador em questão não tiver operações um fluxo de gravação de arquivos muito intenso.

E, antes que você se pergunte, mas quem pode ter acesso ao meu HD? Bem, fácil. Seu computador pode ser invadido através da Internet, você pode perdê-lo, você pode ser roubado, você pode vendê-lo ou você pode mandá-lo para uma assistência técnica para consertar um problema, por exemplo. Enfim, são muitas as possibilidade, não é verdade? Pior ainda quando se está falando dos pequenos e portáteis pen drives que carregamos conosco o tempo todo para todo lugar. Quando é possível, pode-se utilizar os sistemas de arquivos criptografados. Entretanto, em situações onde não é possível utilizar essas soluções, é preciso tomar cuidado para garantir que arquivos sensíveis foram, de fato, removidos.

A notícia boa é que existe um “irmão” do rm que pode ser utilizado para fazer a remoção de arquivos cujo conteúdo você deseja manter longe das mãos dos curiosos. Trata-se do shred. E sabe o qué melhor? Provavelmente ele já encontra-se instalado em seu sistema GNU/Linux mesmo que você nunca o tenha utilizado. Vamos, então, dar uma olhada nesse comando?

Suponnha que você tenha um arquivo com algum dado sensível:

$ echo "Esse arquivo possui dados secretos." > /tmp/segredo.txt
$ cat /tmp/segredo.txt
Esse arquivo possui dados secretos.

Em seguida, utilize o comando shred simplesmente indicando o arquivo recém-criado:

$ shred /tmp/segredo.txt

E agora, tente dar uma olhada no conteúdo do arquivo utilizando o comando cat:

$ cat /tmp/segredo.txt

E aí, surpreso com o que você viu?

Caso você deseje que o shred remova o arquivo após “bagunçar” seus dados você pode utilizar a opção “-u”. E ainda, se quiser acompanhar de perto o que o shred está fazendo durante seu período de execução basta acrescentar, como em muitos outros comandos dos sistemas Unix, o parâmetro “-v”. Então, experimente executar o shred com a seguinte sintaxe:

$ shred -u -v /tmp/segredo.txt

shred: /tmp/segredo.txt: pass 1/3 (random)...
shred: /tmp/segredo.txt: pass 2/3 (random)...
shred: /tmp/segredo.txt: pass 3/3 (random)...
shred: /tmp/segredo.txt: removing
shred: /tmp/segredo.txt: renamed to /tmp/00000000000
shred: /tmp/00000000000: renamed to /tmp/0000000000
shred: /tmp/0000000000: renamed to /tmp/000000000
shred: /tmp/000000000: renamed to /tmp/00000000
shred: /tmp/00000000: renamed to /tmp/0000000
shred: /tmp/0000000: renamed to /tmp/000000
shred: /tmp/000000: renamed to /tmp/00000
shred: /tmp/00000: renamed to /tmp/0000
shred: /tmp/0000: renamed to /tmp/000
shred: /tmp/000: renamed to /tmp/00
shred: /tmp/00: renamed to /tmp/0
shred: /tmp/segredo.txt: removed

É interessante notar que durante sua execução, o shred preencheu o conteúdo do arquivo três vezes com dados aleatórios e depois, antes de removê-lo, o comando renomeou o arquivo 11 vezes.

Para promover um processo um pouco mais seguro, você pode ainda selecionar o número de interações que o shred irá fazer substituindo o conteúdo do arquivo utilizando o parâmetro “-n <qtde>”. Por exemplo:

$ shred -n 25 -u -v /tmp/segredo.txt

Observe que, nesse caso, alternou o processo de substituição do conteúdo com alguns padrões fixos e dados aleatórios. Outra opção interessante até para “esconder” a ação do shred é solicitar que depois de todas as interações, ele substitua os dados do arquivo com zeros. Isso pode ser feito por meio da adição do parâmetro “-z”:

$ shred -n 25 -u -v -z /tmp/segredo.txt

Como “tudo” em sistemas GNU/Linux (Unix, na verdade) é representado por meio de arquivos, você pode utilizar o shred como uma ferramenta para apagar HDs ou outros dispositivos de armazenamento inteiros. Isso pode ser útil quando você vai repassar esse equipamento para outra pessoa. Para isso, basta passar como argumento o arquivo que representa o seu dispositivo de armazenamento. Por exemplo:

# shred -n 30 -v -z /dev/sda

Duas observações importantes aqui: primeiro, essa operação, salvo alguma configuração prévia, requer privilégios de root (observe o prompt como “#” no exemplo anterior). Segundo, tome muito cuidado para não passar o dispositivo errado e apagar coisas erradas! Ou seja, esse comando não é recomendado se você não estiver em paz e bem tranquilo!

Sim, é certo que com algum investimento em tecnologias mais avançadas de hardware e software, é possível recuperar dados mesmo que eles tenham sido sobrescritos diversas vezes.

Em algumas versões anteriores do Ubuntu, por exemplo, era necessário instalar alguns pacotes e fazer algumas configurações para que fosse possível acessar um iPhone a partir de seu sistema operacional. Com o Ubuntu 10.10 (Maverick Meerkat) as coisas evoluíram bastante: ao conectar um iPhone, o sistema já apresenta o seu sistema de arquivos automaticamente e ainda fica apto a conectar com ferramentas como o gtkpod, o Banshee e o RhythmBox. Maravilha, não? Isso funciona muito bem… ou, pelo menos, funcionava até atualizar a versão do iOS para a 4.2.1… Com essa versão, a conexão do aparelho celular ao seu computador deve apresentar um erro ao invés da tela que você estava acostumado a ver.

Com uma rápida pesquisa na Internet, encontrei uma solução muito simples que resolveu o problema.  Em poucas palavras, a saída consiste em atualizar alguns pacotes, dentre os quais o libimobiledevices, uma biblioteca que provê a interface de comunicação de dispositivos como iPhones e iPod Touchs com o sistema operacional, através de um repositório que deve ser adicionado ao seu sistema operacional.

Para isso, abra um terminal como super-usuário e execute os seguintes comandos:

# add-apt-repository ppa:pmcenery/ppa

# apt-get update

# apt-get dist-upgrade

Caso seu terminal não seja de super-usuário, não esqueça de acrescentar o “sudo” antes de cada um dos três comandos anteriores.

Após a execução dos comandos anteriores, basta reconectar o iPhone ao Ubuntu e tudo deve estar funcionando novamente. Simples, não?

Essas facilidades, entretanto, aumentam em muito a possibilidade de se perder esses equipamentos ou mesmo tê-los furtados por outra pessoa. Ainda que sejam arquivos de natureza pessoal, tais como fotos, e-mails e outros documentos, a maioria das pessoas não gostaria de ver esses arquivos em mãos erradas, não é mesmo? Trocando o contexto para o meio corporativo, o comprometimento de informações pode inviabilizar projetos, negócios, estratégias e até a própria sobrevivência da instituição. Por outro lado, são poucas as pessoas e as instituições que têm implementados mecanismos que possam proteger as informações contra a perda ou o roubo dos meios de armazenamento. A grande maioria prefere sofrer com o arrependimento e com as lamentações quando perdem seus dados e os deixam expostos sem qualquer proteção para evitar que os mesmos sejam acessados (e explorados) livremente.

A boa notícia é que existem recursos muito simples para instalar e configurar alguns mecanismos e ferramentas para melhorar a confidencialidade de suas informações. Dentre os diversos recursos e ferramentas disponíveis, uma das mais eficazes são os sistemas de arquivos criptografados e, em ambientes GNU/Linux é algo simples de fazer. A seguir, compartilho uma das maneiras que costumo utilizar para criar, rapidamente, sistemas de arquivos criptografados. Vamos lá?

Irei tomar como referência o Ubuntu Linux. Entretanto, respeitadas as diferenças no processo de instalação dos pacotes necessários, o restante do processo é semelhante em outras distribuições. Em tempo, o processo a seguir mostra os procedimentos utilizando-se utilitários de linha de comando. Com isso, esse mesmo processo pode ser utilizado para criar sistemas de arquivos criptografados em servidores e/ou desktops da mesma maneira.

O primeiro passo consiste em instalar os pacotes necessários. Para tal, a partir de um terminal com privilégios de super-usuário, execute o seguinte comando:

# apt-get install cryptsetup cryptmount

Em seguida, supondo que você reservou a partição /dev/sda5 para criar o seu sistema de arquivos seguro, o próximo passo consiste em formatá-la já considerando a camada de criptografia. Esse processo irá exigir a inserção de uma “frase-senha” que irá proteger o sistema de arquivos. Portanto, a segurança de seus dados será proporcional à força dessa senha. Esse passo deve ser executado por meio do comando abaixo:

# cryptsetup luksFormat /dev/sda5

WARNING!
========
This will overwrite data on /dev/sda5 irrevocably.

Are you sure? (Type uppercase yes): YES
Enter LUKS passphrase:
Verify passphrase:

IMPORTANTE: Caso você esteja criptografando o conteúdo de um pen drive ou de qualquer outro dispositivo de armazenamento que já contenha um sistema de arquivos convencional e que seja, por conta disso, montado automaticamente em seu ambiente, tome o cuidado de desmontá-lo antes de prosseguir com as configurações. Caso contrário, o comando “cryptsetup luksFormat” irá falhar!

Observe que, antes de solicitar a senha, o comando irá confirmar se pode prosseguir sua execução uma vez que esse processo irá sobrescrever todos os dados que possam estar, eventualmente, presentes nessa partição. Para confirmar, é necessário responder com “YES” (em caixa alta). Logo depois, a “frase-senha” e sua respectiva confirmação são solicitadas.

Uma vez criado o sistema criptografado, é necessário “abrir” o dispositivo de forma que ele possa ser acessado como um device convencional e que, portanto, possa conter um sistema de arquivos como o ext3, por exemplo. Isso deve ser feito através do seguinte comando que irá solicitar a “frase-senha”:

# cryptsetup luksOpen /dev/sda5 MYCRYPT
Enter passphrase for /dev/sda5:
Key slot 0 unlocked.

Executado esse comando, o sistema operacional deve ter criado um dispositivo chamado /dev/mapper/MYCRYPT que é, na verdade, um dispositivo normal de armazenamento como outro qualquer e que pode, portanto, ser formatado. Entretanto, nesse caso, os dados armazenados em /dev/mapper/MYCRYPT são salvos, fisicamente, no sistema de arquivos criptografado criado em /dev/sda5. Em outras palavras, uma vez que seus meios de armazenamento caiam em mãos erradas, o que o “novo dono” terá acesso é um monte de dados criptografados que não representam nada (a não ser que você tenha deixado sua “frase-senha” à mostra em algum lugar).

Para formatar o sistema de arquivos mapeado com ext3, por exemplo, utilize o próprio comando mkfs.ext3:

# mkfs.ext3 -L MYCRYPT /dev/mapper/MYCRYPT

Criado o sistema de arquivos, monte-o normalmente para poder começar a salvar seus dados mais sensíveis:

# mount  /dev/mapper/MYCRYPT /media

No Ubuntu Desktop, o processo de montagem também pode ser feito pela própria interface gráfica. Ou seja, após criar e formatar o sistema de arquivo, ao acessar a opção Places (Lugares) na barra superior, já é possível ver o reconhecimento do dispositivo criptografado recém-criado. Ao selecionar esse disco, o próprio ambiente gráfico já solicita a senha para montagem do dispositivo.

Voltando pra linha de comando, após utilizar o sistema de arquivos seguro, você deve desmontá-lo e, em seguida, desfazer o mapeamento criado entre o dispositivo criptografado (/dev/sda5) e o mapeado (/dev/mapper/MYCRYPT):

# umount /media

# cryptsetup luksClose MYCRYPT

Para explorar mais funcionalidades tais como trocar ou adicionar senhas para o sistema de arquivos criptografos, consulte a man page do comando cryptsetup.

Existem ainda opções para fazer com que o sistema de arquivos criptografado seja montado automaticamente todas as vezes que o usuário efetua o seu login no sistema. Isso pode ser feito por meio do PAM combinado com outras configurações. Mas, vamos deixar isso pra uma outra oportunidade.

Espero que essa dica seja, de alguma maneira, útil e que, depois dela, seus dados mais críticos recebam a proteção que eles merecem!

]]> http://www.jsena.info/2010/10/24/criando-um-sistema-de-arquivos-criptogrado-no-gnulinux/feed/ 1 http://www.jsena.info/2010/10/17/rsync-funciona-com-o-ssh-em-uma-porta-diferente-da-22/ http://www.jsena.info/2010/10/17/rsync-funciona-com-o-ssh-em-uma-porta-diferente-da-22/#comments Sun, 17 Oct 2010 21:44:11 +0000 Jansen Sena http://www.jsena.info/?p=246 O rsync é uma ferramenta extremamente útil e bastante utilizada por diversos administradores de sistemas Unix/Linux e até mesmo por usuários mais avançados. O próprio nome do utilitário já se confunde com a função de sincronizar arquivos e diretórios. Basicamente, quando se deseja utilizar essa ferramenta para sincronizar arquivos entre máquinas distintas, existem duas maneiras básicas e mais comuns: ou por meio de um daemon rsync que deve estar sendo executado na máquina onde se deseja sincronizar os arquivos; ou através do popular servidor SSH. Como a última alternativa já se aproveita de um serviço de acesso remoto seguro, presente na grande maioria das máquinas que possui Unix e/ou alguma distribuição GNU/Linux, essa pode ser a maneira mais prática.

Por exemplo, suponha que você deseje sincronizar o conteúdo do diretório /home/jansen/docs com o diretório /home/bkp/jansen que fica na máquina chamada aragorn.jsena.com.br. Considerando que existe um usuário chamado jsena no host aragorn.jsena.com.br e um servidor SSH, basta utilizar o seguinte comando para realizar essa tarefa:

$ rsync -avz /home/jansen/docs jsena@aragorn.jsena.com.br:/home/jsena/bkp

Simples, não? É claro que existem outras opções do rsync bastante úteis e que podem ser consideradas para fazer operações de sincronismo mais customizadas e específicas. Normalmente, o SSH irá solicitar a senha para autenticar o usuário jsena no host aragorn.jsena.com.br. Entretanto, caso seja de seu interesse executar esse sincronismo automaticamente, sem a necessidade de inserção de senha, basta gerar um par de chaves com o aplicativo ssh-keygen e transferir a chave pública do usuário (criada normalmente com o nome de id_pub.dsa ou id_pub.rsa) em seu computador local para o arquivo /home/jsena/.ssh/authorized_keys. Mas, isso é assunto para outra oportunidade. A questão aqui é tratar do seguinte problema: como fazer o rsync funcionar por meio do SSH se esse servidor não estiver sendo executado em sua porta TCP padrão, a 22?

Antes que você possa se perguntar: “afinal de contas, por que utilizar o SSH em uma porta diferente da padrão?”, aí vai uma rápida explicação. Sempre coloco esse serviço para executar em outras portas, diferentes da padrão por questões de segurança e de hábito. Isso não representa muita segurança (e uma melhor solução seria utilizar o SPA, Single Packet Authorization). Po outro lado, quando isso não é aplicável, essa medida pode, ao menos, desviar a atenção principalmente dos atacantes e/ou curiosos menos experientes. O problema é que o rsync não possui um parâmetro do tipo “port” ou “-p” para se indicar a utilização de uma outra porta quando o SSH está sendo utilizado para o sincronismo de arquivos. A solução é, por outro lado, bastante simples. Tomando como base o exemplo apresentado e supondo que o servidor SSH no host aragorn.jsena.com.br esteja funcionando na porta 22119, basta executar o comando anterior da seguinte maneira:

$ rsync -avz -e 'ssh -p 22119' /home/jansen/docs \
      jsena@aragorn.jsena.com.br:/home/jsena/bkp

Pronto. O problema está resolvido!