Script para validação de senhas em massa

Estreando uma nova categoria dentro de Learning no blog: Scripts.

Não… não sou programadora… mas quem administra sistemas, desde cedo aprende que quanto mais tarefas rotineiras for possível automatizar… mais tempo terá para fazer coisas interessantes, como por exemplo, iniciar um estudo de uma tecnologia que pode ser utilizada na empresa, ou trabalhar em algum projeto, enfim… ‘n’ coisas :).

Ainda tenho muito o que aprender em termos de script (começando pela lógica :(), mas andei brincando com alguns scripts e descobri que apesar de não saber programar, não é que eles foram de grande ajuda no meu dia-a-dia? 🙂

Mas vamos lá… Recentemente, precisei fazer uma validação em massa da senha de root em vários servidores, sendo que para cada um a senha era diferente.

Com a ajuda do expect [1] e um howto [2] bacana encontrado by google, consegui realizar a validação :).
pwtest.exp
#!/usr/bin/expect -f

################################################################################################################
## Script para testar a conexão com o servidor e checar se a senha do usuário root está correta ou não ##
## Utiliza o comando expect para fazer o acesso e inserir a senha ##
## Referência: http://www.pantz.org/software/expect/expect_examples_and_tips.html ##
## Nix - 23/08/2013 ##
################################################################################################################
######### Variaveis ######### 
set timeout 9
set HOST [lindex $argv 0]
set PASS [lindex $argv 1]
log_user 0

## Inicializa a conexão SSH 
spawn ssh -q -o StrictHostKeyChecking=no root@$HOST
## Mensagem de erro a ser exibida caso ocorra timeout na conexão SSH (prompt que solicita a senha não é exibido)
## *assword é para corresponder "Password" ou "password" :)
expect {
 timeout { send_user "\nFailed to get password prompt\n"; exit 1 }
 eof { send_user "\nSSH failure for $HOST\n"; exit 1 }
 "*assword"
}
## Caso o prompt que solicita a senha é exibido, a mesma é enviada
send "$PASS\r"

## Mensagem a ser exibida caso a senha esteja incorreta
## *\# indica o prompt do usuário - no caso, o root
expect {
 timeout { send_user "$HOST - Login failed. Password incorrect.\n"; exit 1}
 "*\# "
}
## Caso a senha esteja correta, é exibida a mensagem abaixo:
send_user "$HOST - Password is correct\n"

## Desconecta do servidor - o mesmo que Control+D:
send "exit\r"
## Encerra programa
close

==============================================================================================================================
valida_pw.sh
#!/bin/bash

################################################################################################################
## Script para validar senhas em massa a partir de um arquivo de servidores e outro com as respectivas senhas 
## Executa o arquivo pwtest.exp 
## Nix - 23/08/2013
################################################################################################################

######## Variaveis ########
# Lista de servidores
HOSTS=$(cat /root/temp/hosts_dev.txt)
# Arquivo de senhas
PWDS=$(cat /root/temp/pws_dev.txt)

####### Contador para ler o arquivo de senhas linha a linha #######
i=0
for pd in $PWDS; do
 pws[$i]=$pd;
 i=`expr $i + 1`
done

####### Contador para ler o arquivo de hosts linha a linha e testar a senha usando o script expect #######
### É passado como parâmetro o servidor ($j) e a senha do mesmo ($pws)
i=0
for j in $HOSTS; do
 /root/temp/pwtest.exp $j ${pws[$i]}
 i=`expr $i + 1`
done

============================================================================================================================== 

Para executar (antes é necessário dar permissão usando o comando chmod ;)):

$./valida_pw.sh

Até a próxima! 🙂
Referências:
[1] http://www.nist.gov/el/msid/expect.cfm
[2] http://www.pantz.org/software/expect/expect_examples_and_tips.html

Arquivo .bash_aliases

Já falei um post sobre o comando alias.

Esse comando é bem interessante, pois permite criar apelidos para os comandos de uma forma que seja mais fácil para lembrar.

Embora seja útil, eu sempre fui um tanto restritiva no uso do alias, pois acho que, se acostumar demais a usar o alias, pode acabar esquecendo como usar o comando de verdade, ou até esquecer o nome real para o comando… o que, para que está aprendendo a trabalhar com Linux, pode ser um tanto desastroso.

Mas… o comando alias existe, é útil e eu finalmente deixei de ser chata comigo mesma e comecei usar o alias :P. O motivo? Diariamente, preciso fazer acessos à muitas máquinas… muitas mesmo. E eu não lembro o IP, nem o nome da rede, e muito menos as portas que preciso acessar… Então achei que seria bacana utilizar o alias com o nome das máquinas com o comando ssh…

Comecei fazendo o simples:

# vim ~/.bashrc
alias nix=’ssh ivani@nix.com.br’

A linha acima, eu inseri no arquivo .bashrc do meu usuário. Mas, dando uma lida mais atenta ao .bashrc, vemos que é possível ter um arquivo exclusivo de alias, o .bash_aliases.

Claro que você continua tendo a liberdade de manter seus alias no .bashrc, mas a idéia de concentrar todos alias em um arquivo só é legal porque facilita a manutenção.

A parte do .bashrc que chamou minha atenção é essa:

# Alias definitions.
# You may want to put all your additions into a separate file like
# ~/.bash_aliases, instead of adding them here directly.
# See /usr/share/doc/bash-doc/examples in the bash-doc package.

if [ -f ~/.bash_aliases ]; then
. ~/.bash_aliases
fi

A primeira providência, foi instalar o pacote bash-doc. Uso o Ubuntu 9.10, então fui no terminal e executei:

# sudo apt-get install bash-doc

Depois de instalado, copiei o arquivo Bash_aliases para o meu home:

# cp /usr/share/doc/bash-doc/examples/startup-files/Bash_aliases .bash_aliases

Em seguida editei o arquivo que copiei:

# vim ~/.bash_aliases

Quando editamos o arquivo, ele já vem com alguns exemplos de aliases, que podemos comentar. Eu comentei as linhas dos blocos “Some useful alias” e “Csh compatability” e acrescentei no final do arquivo os meus aliases:

alias ls=’ls –color=auto’
alias grep=’grep –color=auto’
alias fgrep=’fgrep –color=auto’
alias egrep=’egrep –color=auto’
alias nix=’ssh ivani@nix.com.br’

Aí depois salvei o arquivo, saí e atualizei com o comando abaixo:

#source ~/.bashr_aliases

E para ver os alias que estão disponíveis, execute:

# alias

Referência:

Adding Terminal Aliases to Ubuntu

Breve visão sobre o Linux

O Linux possui várias características que o faz diferente de outros sistemas operacionais e que o deixam bem próximo do Unix, fazendo assim, que seja uma escolha em várias aplicações que necessitam de estabilidade e segurança.

Vamos entender um pouco da arquitetura do Linux, que basicamente trabalha em camadas:

camadas do linux

Na camada mais interna da figura, temos o hardware, que é representado pelos dispositivos físicos (por exemplo, HD, cdrom, etc).

Em seguida, temos a camada do kernel, que é o coração (núcleo) do sistema operacional e que interage com o hardware. Algumas tarefas do kernel são:

✔ Implementar o sistema de arquivos e meios de acesso (leitura, escrita e execução);

✔ Gerenciar a swap

✔ Gerenciar software que implementa serviços de rede;

✔ Gerenciar comunicação entre processos;

✔ Prover facilidades para criar, examinar e modificar processos;

✔ Prover funções que tornam os recursos do sistema disponíveis aos processos.

Fechando essa camada, temos o shell. Basicamente, shell é um nome comum para um conjunto de programas que tem o propósito de fornecer uma interface interativa com o usuário, onde comandos podem ser digitados, tarefas podem ser controladas, manipuladas, etc.

Por outro lado, os shells também funcionam como linguagem de programação (interpretadas) e são uma forma relativamente eficiente de se executarem tarefas complexas.

Entre os shells conhecidos temos o bash, o csh, sh, ksh. O shell padrão do Linux é o bash.

As diversas faces do Linux

O Linux é um sistema operacional multiusuário, multitarefa e multiprocessado. Ufa!!! Além de tudo isto, ele segue o padrão POSIX/UNIX, o que garante que temos no Linux todo sistema de proteção do núcleo do kernel, ficando um pouco difícil um programa travar em Linux. (Sim! Apesar de ser difícil um Linux pode travar… ;)).

Linux multiusuário

Um sistema multiusuário é capaz de atender a vários usuários interativos simultaneamente. Isto é bem diferente de diversos usuários conectados a um servidor Novell ou NT. Esses usuários são apenas clientes do servidor de arquivos do Netware ou do NT, não são usuários interativos. Aliás, esses dois sistemas são monousuários.

A vantagem disso é que o Linux pode ser distribuído como um servidor de aplicativos; ou seja, Os usuários podem acessar um servidor Linux através da rede local e executar aplicativos no próprio servidor.

Linux multitarefa

Um sistema multitarefa é capaz de executar simultaneamente vários programas, garantindo a melhor distribuição de recursos entre esses programas. Por exemplo, você pode editar a planilha do seu fluxo de caixa enquanto baixa os seus e-mails.

Linux multiprocessado

Um sistema multiprocessado é capaz de tirar proveito de placas-mãe com várias CPUs, ou seja, permite o uso de mais de um processador.

O Linux reconhece mais de um processador e trabalha com SMP (Multiprocessamento Simétrico), clusters de máquinas, na qual uma máquina central controla os processadores das outras para formar uma “única” máquina, principalmente nas versões de kernel mais atuais (graças ao Linux, o Titanic afundou ;))

E além disso…

O Linux oferece diversas vantagens para que o utiliza. A primeira vista, pode parecer um sistema operacional complicado e difícil de trabalhar. Mas aprender Linux, é como aprender um novo idioma… no começo, as palavras são estranhas, não dá pra entender nada e parece que nunca vamos aprender.

Depois de um tempo, com dedicação,começamos arriscar umas palavrinhas, e, quando menos esperamos estamos tagarelando no novo idioma.

Assim é com o Linux. Aprende um comando aqui, um jeito de usar o gerenciador de janelas acolá… quando formos ver, estaremos utilizando o sistema… e o melhor de tudo: sempre aprendendo coisas novas; afinal de contas, no Linux não existe só um jeito pra se fazer as coisas!

Ah, e se não gostar do Linux, não se preocupe: o máximo que vai acontecer é você aprender algo novo! =)

Variáveis de ambiente

Como já falamos em um post anteriormente, o shell é a interface entre o usuário e o kernel do sistema operacional.

O shell padrão do Linux é o bash; ele é executado em um ambiente controlado pelas variáveis de ambiente, que nada mais são do que definições e valores que, tanto o shell como outros programas utilizam para configuração do ambiente do usuário no momento em que é realizado o login.

Existem dois tipos de variáveis:

✔ Variáveis de Usuários – variáveis criadas pelo próprio usuário.
✔ Variáveis de Sistema – variáveis criadas pelo próprio sistema.

Variáveis de Ambiente

Como dito anteriormente, variáveis são nomes que contém algum valor e tem a forma Nome=Valor. Lembram, quando estavam na escola e tinha que fazer as continhas para descobrir o valor da variável x? Por exemplo, x=10. Traduzindo para a forma Nome=Valor, aqui o x, seria o Nome, e Valor, o conteúdo da variável.

As variáveis de ambiente são individuais para cada usuário do sistema ou consoles virtuais e permanecem residentes na memória RAM até que o usuário saia do sistema (logoff) ou até que o sistema seja desligado.

Algumas variáveis do GNU/Linux afetam o comportamento de todo o Sistema Operacional, como por exemplo, o idioma utilizado e o path.

A declaração de variáveis é feita da seguinte forma:

NOME_DA_VARIAVEL=valor_inicial

Onde:

NOME_DA_VARIAVEL – Nada mais é que o nome que queremos dar a nossa variável.

valor_inicial – É o primeiro valor que daremos a nossa variável. Este valor se faz necessário para determinar ao sistema que “tipo” de informação iremos ter na variável.

Exemplo:

Criar uma variável chamada LINUX com o valor Debian:

# LINUX=Debian

Para visualizarmos o conteúdo de uma variável, utilizamos o comando echo, que, além de exibir mensagens na tela, também tem o poder de exibir o conteúdo de uma variável.

Visualizando o conteúdo da variável criada:

# echo $LINUX
Debian

No exemplo acima, estamos visualizando o valor da variável LINUX, que é Debian.

Para que o shell saiba que o comando echo deve exibir o conteúdo de uma variável e não mostrar uma mensagem na tela, devemos adicionar no início do nome da variável o caractere $.

Comandos para manipular variáveis de ambiente

set
O comando set lista todas as variáveis de ambiente do usuário tais como o nome da máquina, arquitetura da máquina, usuário logado, etc…

Exemplo:

# set
HOSTNAME=switch
HOSTTYPE=i486
USER=root
MACHTYPE=i486-pc-linux-gnu
OSTYPE=linux-gnu

Se quisermos visualizar a variável que criamos, podemos filtrar a saída do comando set:

# set | grep LINUX
LINUX=Debian

export
O comando export faz com que a variável criada seja visualizada em todos shells. No exemplo em que criamos a variável LINUX, esta ficou disponível somente no shell em que foi criada… para que seja visualizada em um novo shell, é necessário exportar; e aí, utilizamos o comando export.

Exemplo:

# export LINUX

Para visualizar a variável que foi exportada, utilizamos o comando env, que é o responsável por visualizar as variáveis definidas globalmente:

# env

Visualizar somente a variável LINUX que foi exportada:

# env | grep -i linux
LINUX=Debian

Arquivos de configuração do ambiente do usuário

Além dos comandos que vimos acima, existem arquivos que são utilizados para configurar e carregar o ambiente do usuário. Isso quer dizer que, em um shell que exige login, ou seja, pede um nome de usuário e senha, o sistema irá verificar a existência dos arquivos listados abaixo e executará os comandos que estiverem dentro dos mesmos:

1) /etc/profile
2) ~/.bash_profile
3) ~/.bash_login
4) ~/.profile

/etc/profile
Este arquivo contém comandos que são executados para todos os usuários do sistema no momento do login; somente o usuário root tem permissão para modificar este arquivo.

Ele é lido antes do arquivo de configuração pessoal de cada usuário (.profile caso seja root e .bash_profile caso seja um usuário comum).
.bash_profile
Este arquivo reside no diretório pessoal de cada usuário. É executado em ambientes que usam autenticação (nome e senha). O .bash_profile contém comandos que são executados para o usuário no momento do login no sistema.

Lembrando que se trata de um arquivo oculto pois tem um “.” no início do nome. Aqui, podemos configurar por exemplo, os alias que vimos no post anterior.

Por exemplo:

# echo “alias rm=’rm i'” >> ~/.bash_profile

O comando acima, irá acrescentar a linha alias dentro do arquivo .bash_profile. Fique atento ao operador de redirecionamento, que é o >>, isto é, está acrescentando a linha no arquivo!

Variável PS1
Essa é a variável que contém o formato do prompt do Linux. Ela pode ser modificada através do arquivo .bash_profile (para usuários comuns) ou no .profile (para usuário root).

Por padrão, ela vem configurada da seguinte forma:

PS1=”[\u@\h \W]\$”

Cada uma dessas letras, exibe uma informação no prompt:
\u => Exibe o usuário no momento;
\h => Exibe o nome da máquina;
\W => Exibe o caminho completo do diretório que você está no momento
\$ => Indica o tipo de usuário logado. Se você for usuário comum, será apresentado o símbolo $, em caso do superusuário (root), será #.

Assim como praticamente tudo no Linux, seu prompt pode ser personalizado também. Por exemplo, alguém pode sentir saudade do ‘cebiquim’, isto é, do famoso C:\>.

Não é elegante como o prompt do Linux, mas… se quiser matar a saudade, faça assim:

PS1=”C:\> “

Configurando a variável PS1 conforme mostrado acima, seu terminal trará o C:\>.

Depois que altera o arquivo, é necessário atualizá-lo para que as configurações sejam aplicadas. Você pode deslogar e logar novamente, ou então, utilizar o comando source:

# source ~/.bashrc

O comando acima, irá reler o arquivo .bashrc e efetuar as alterações no prompt.

É isso aí, pessoas… até o próximo post 😉 !

Comando alias

Neste post, vou falar sobre alias, que seriam mais ou menos como apelidos que podemos colocar em comandos. Muitas vezes temos uma linha de comando muito extensa, então é mais fácil criar um apelido para essa  linha de comando ao invés de digitar a linha toda.

O comando que cria os tais apelidos, é o alias… e sua sintaxe é:

alias <apelido>='<comando_linux>

Onde, <apelido> é o “apelido”, e, <comando_linux>, é o comando real que receberá o alias.

E detalhe… não deve existir espaços antes e depois do “=” e, caso o <comando_linux> tenha mais de uma palavra, ele deve vir entre ‘aspas simples’.

Por exemplo… teve um post que falei sobre o comando rm… e até mencionei que este é um comando que deve ser utilizado com muito cuidado!

Nos exemplos do comando rm, vimos que existe a opção -i, que é interativo… e teve até um comentário no post, falando sobre criar um alias para pedir confirmação ao remover um arquivo ou diretório!

Então, vamos criar o alias aqui:

# alias rm=’rm -i’

Após executar o comando acima, toda vez que for remover um arquivo ou diretório, será solicitado uma confirmação. Por exemplo:

# cd /tmp

# touch teste.txt

# rm teste.txt
rm: remove arquivo comum vazio `teste.txt’? y

Para confirmar a remoção, basta teclar y ou então, se desistir de remover, basta teclar n.

Outro exemplo de alias: para limpar o terminal, no Linux utilizamos o comando clear. Para quem tem saudades do DOS e quer usar o cls, basta criar um alias com esse nome:

# alias cls=’clear’

Aí, toda vez que executar o comando cls, irá limpar a tela.

É importante lembrar que, ao criar o alias, o comando original, não será apagado! Isso quer dizer que, caso digite o comando clear, ele irá limpar a tela normalmente! Só no caso do comando rm que, se você não remover o alias ele sempre irá pedir confirmação… se bem que no caso do rm, sempre é bom manter o alias que pede a confirmação 😉 !

Para checar os alias disponíveis, basta executar o comando alias sem argumentos:

# alias
alias rm=’rm -i’
alias cls=’clear’

Para remover um alias, basta executar:

# unalias cls

# alias
alias rm=’rm -i’

Para remover todos os alias:

# unalias -a

Onde a opção -a irá remover todas as definições de alias.

Até o próximo post! 😉

Perdeu algo no sistema? Utilize o find ou o locate!

Neste post, irei abordar os comandos find e locate que são utilizados para fazer buscas no sistema.

Ambos tem a mesma função; porém o comando find executa a busca direto no local que você especificou, enquanto o comando locate executa a busca a partir de uma base.

Explicando melhor… com o comando find, cada vez que solicitamos uma busca, ele tenta localizar o que pedimos dentro do local que especificamos e aproveita checa os subdiretórios também. Assim, uma busca com o find pode demorar um pouco, principalmente se o local especificado tiver muitos diretórios!

A sintaxe do comando find é:

find caminho opções nome_do_que_será_procurado

Exemplo:

# find / -name passwd
/etc/passwd
/etc/pam.d/passwd
/usr/bin/passwd
/usr/share/lintian/overrides/passwd
/usr/share/linda/overrides/passwd
/usr/share/doc/passwd

A leitura do comando acima, seria algo como “procure no diretório / algo que case com o nome (opção -name) passwd”; ou seja, pedimos para o find procurar dentro da estrutura do diretório / algo que tenha passwd no nome!

Outro exemplo de uso do find:

# find /etc/ -type d -name apt
/etc/apt

Acima, pedi para o comando find localizar dentro da estrutura do /etc algum diretório (opção type -d) algo que case com o nome apt!

A opção -type aceita os seguintes argumentos: farquivos; ddiretórios e llinks simbólicos.

Agora, falando sobre o comando locate, ele faz a busca dentro de uma base que é construída com um outro comando, o updateb.

Assim a busca sendo um pouco mais rápida, pois o locate vai usar a base que o updatedb construiu! Só um detalhe muito importante: imagine que você tenha atualizado a base do comando locate e em seguida crie um novo arquivo. Se você não executar o updatedb novamente, o arquivo que acabou de ser criado não será localizado pelo locate!

Então, antes de vermos um exemplo do locate, vamos construir a base que ele irá utilizar:

# updatedb

Esse comando pode demorar um pouquinho para ser terminar e deve ser rodado como root (o usuário administrador da máquina). Enquanto o updatedb estiver rodando, o terminal fica indisponível… quando você receber o prompt de volta, significa que o comando terminou e aí pode passar para o próximo passo, que é executar uma busca com o locate.

Exemplo:

# locate passwd
/etc/pam.d/passwd
/etc/passwd
/etc/passwd-
/lib/security/pam_unix_passwd.so
/usr/bin/gpasswd

Um outro exemplo… imagine que você tenha criado um arquivo no sistema e não lembre onde está guardado. E o pior, não faz nem idéia se criou o arquivo como Marketing.txt ou marketing.txt ou MARKETING.TXT….

Aí complicou… são muitas possibilidades, e você está perdido… então vamos usar a opção -i do locate para localizar o tal arquivo! Essa opção é ignore-case, ou seja, ele vai procurar independente do arquivo estar nomeado em maiúsculo ou não!

Então.. primeiro a gente atualiza a base do locate:

# updatedb

Agora, vamos tentar localizar o arquivo:

# locate -i marketing
/root/MaRkEtIng.tXt

Mmmmm.. que nome hein! Se não existisse a opção -i ia ser difícil advinhar onde estava o arquivo!

Bem, esses são os exemplos deste post.Os comandos find e locate são muito úteis para localizar algo dentro do sistema….

O comando find é poderoso (tem um monte de opções bacanas) e, reza a lenda que ele acha até moeda de um centavo perdida no limbo do seu home 😉 !

Ficam aí duas opções que podemos usar para localizar arquivos e diretórios, mas é importante lembrar que o que foi mostrado aqui não é tudo! Então, para saber mais…

# man find

# find –help

# man locate

# locate –help