segunda-feira, 24 de outubro de 2016

Espionando o uso do teclado no Linux

Para ambientes Windows, keylogger é um temível recurso muito conhecido quando vem como função adicional em um malware, tal como um trojan ou vírus que se instala sem o consentimento do usuário e então captura seus logins e senhas. Na prática um keylogger é simplesmente uma aplicação como qualquer outra cuja única finalidade é registrar as teclas digitadas pelo usuário e que pode ser usado como recurso adicional de segurança também em ambientes Linux. Conheça abaixo como instalar e usar um deles.

O que é um keylogger

como dito, um keylogger não é um vírus, nem mesmo um trojan (vide este meu texto sobre tipos de malware), embora estes tipos de malware possam conter e/ou instalar um keylogger no computador da vítima.
Seu funcionamento é bem simples e consiste apenas em capturar o pressionamento das teclas [todas] no teclado de um computador para que seja então as armazenado em um arquivo, enviado por e-mail etc para que então este conteúdo possa ser lido e analisado futuramente.

Uma mensagem de advertência

Fica então uma palavra de advertência quanto a responsabilidade de uso deste tipo de programa: Tal utilitário deve ser usado com cautela, prudência e responsabilidade visto que o seu uso pode implicar na invasão de privacidade alheia.
Esteja ciente, então, que usá-lo de forma leviana poderá rendê-lo um belo processo criminal sem qualquer possibilidade de responsabilizar o autor deste texto nem mesmo o autor do programa pelos seus atos.
Não vou entrar aqui no mérito de explicar onde, quando, e nem porque usá-los já que o uso deste tipo de aplicação é de inteira responsabilidade do seu usuário, então caso se julgue imaturo o bastante para usar tal tipo de ferramenta é melhor que pare a leitura deste texto aqui.

Keyloggers disponíveis para Linux

Como já disse no começo este tipo de recurso é muito popular como função adicional de vírus e trojans e ambientes Windows. No Linux eles são apenas ferramentas adicionais que podem ser instaladas inclusive via repositório oficial de pacotes da sua distribuição preferida.
Os três utilitários com este fim que encontrei em minhas pesquisas sobre o assunto, após responder um questionamento sobre este assunto em uma das várias listas de discussão que participo:

LKL

O LKL Linux KeyLogger[1] é um keylogger que roda sobre a arquitetura x86, “farejando” tudo o que digitado no teclado, traduzindo os keycodes para códigos ASC e então os registrando em um arquivo.
A sua última versão é a 0.1.1 e foi lançada em out/2005.

Uberkey

O Uberkey[2] também é um keylogger para arquitetura x86 que roda tanto em Linux quando em BSD (talvez no Mac OS também rode).
A sua última versão é a 1.2 está disponível em [3] e foi lançada em Nov/2003. Além de bem antiga os últimos relatos no site projeto registram a existência de um bug que impede o seu correto funcionamento com teclados Ps/2 e USB!

Logkeys

O Logkeys é um keylogger que como o seu autor afirma “não é melhor do que os demais disponíveis para Linux”, entretanto ele tem dois grandes diferenciais em relação aos outros dois que são, estar atualizado e funcionar de verdade.
Existem outros keylogger e o autor do Logkey apresenta alguns deles no site que, embora seja bem simples, é bem organizado e informativo.

Instalando o Logkeys

Sabendo que o Logkeys é mais funcional deles nós partiremos para sua instalação e para felicidade dos usuários do Ubuntu Linux já existe um pacote prontinho para esta distro (logkeys), nos repositórios oficiais, necessitanto apenas que você use o Synaptic (Menu principal > Sistema > Administração > Gerenciador de Pacotes Synaptics), ou mesmo o aptitude (via linha de comandos para instalá-lo).
Qualquer que seja o método lembre-se que você precisará de privilégios administrativos (senha de root) para poder instalar quaisquer coisas no seu sistema.
Pela linha  de comandos o procedimento então seria apenas este:

sudo aptitude install logkeys
 
Uma vez instalado você pode executá-lo manualmente ou então configurá-lo para iniciar junto com o boot do sistema (em ambos os casos você precisa ter privilégios administrativos).

Executando o Logkeys pela linha de comandos

A forma mais simples de iniciar o Logkeys é digitando:
sudo logkeys -s
Observe que para executar o logkeys você precisa privilégios de root. O parâmetro -s (de start) ordena que ele inicie a gravação no seu arquivo de log padrão que é o “/var/log/logkeys.log” e possui permissão de leitura/escrita apenas para o usuário root.
Se for desejável definir um arquivo de log diferente deste você pode incluir a opção -o (output) seguido do caminho e nome do arquivo que será criado com permissões 600 (rw——-), caso não exista, ou acrescentado caso já exista.

Onde está o meu teclado?

Outro parâmetro importante de se conhecer é o -d (device) ele é quem define o dispositivo de teclado no seu sistema. Se você não souber qual ele é, talvez você não consiga gravar informação nenhuma. Para usá-lo simplesmente acrescente no final da linha de comandos o parâmetro -d /dev/input/eventX, onde “eventX” pode ser descoberto olhando o conteúdo do arquivo /proc/bus/input/devices.
No meu sistema, este arquivo se parece com isso:

$ cat /proc/bus/input/devices
I: Bus=0019 Vendor=0000 Product=0001 Version=0000
N: Name="Power Button"
P: Phys=PNP0C0C/button/input0
S: Sysfs=/devices/LNXSYSTM:00/LNXSYBUS:00/PNP0C0C:00/input/input0
U: Uniq=
H: Handlers=kbd event0
B: EV=3
B: KEY=100000 0 0 0
 
I: Bus=0019 Vendor=0000 Product=0001 Version=0000
N: Name="Power Button"
P: Phys=LNXPWRBN/button/input0
S: Sysfs=/devices/LNXSYSTM:00/LNXPWRBN:00/input/input1
U: Uniq=
H: Handlers=kbd event1
B: EV=3
B: KEY=100000 0 0 0
 
I: Bus=0003 Vendor=093a Product=2510 Version=0110
N: Name="PIXART USB OPTICAL MOUSE"
P: Phys=usb-0000:00:03.1-2.1/input0
S: Sysfs=/devices/pci0000:00/0000:00:03.1/usb3/3-2/3-2.1/3-2.1:1.0/input/input2
U: Uniq=
H: Handlers=mouse0 event2
B: EV=17
B: KEY=70000 0 0 0 0 0 0 0 0
B: REL=103
B: MSC=10
 
I: Bus=0003 Vendor=0ac8 Product=305b Version=0100
N: Name="zc3xx"
P: Phys=usb-0000:00:03.1-2.3/input0
S: Sysfs=/devices/pci0000:00/0000:00:03.1/usb3/3-2/3-2.3/input/input6
U: Uniq=
H: Handlers=kbd event5
B: EV=3
B: KEY=100000 0 0 0 0 0 0
 
I: Bus=0003 Vendor=0a81 Product=0101 Version=0110
N: Name="CHESEN USB Keyboard"
P: Phys=usb-0000:00:03.1-2.4/input0
S: Sysfs=/devices/pci0000:00/0000:00:03.1/usb3/3-2/3-2.4/3-2.4:1.0/input/input7
U: Uniq=
H: Handlers=sysrq kbd event3
B: EV=120013
B: KEY=10000 7 ff9f207a c14057ff febeffdf ffefffff ffffffff fffffffe
B: MSC=10
B: LED=1f
 
I: Bus=0003 Vendor=0a81 Product=0101 Version=0110
N: Name="CHESEN USB Keyboard"
P: Phys=usb-0000:00:03.1-2.4/input1
S: Sysfs=/devices/pci0000:00/0000:00:03.1/usb3/3-2/3-2.4/3-2.4:1.1/input/input8
U: Uniq=
H: Handlers=kbd event4
B: EV=13
B: KEY=2020000 3878 d801d001 1e0000 0 0 0
B: MSC=10
 
Não sei exatamente qual é o processo usado para determinar qual será o dispositivo usado por padrão, mas me parece que ele “chuta” este valor, e diga-se de passagem, chuta muito mal. No meu sistema ele escolheu por padrão o event5 e que se trata na verdade da minha webcam USB.
Conforme se pode ver neste log o correto seria event3 ou event4. Em resumo para rodar o logkeys manualmente em meu sistema eu poderia simplesmente executar o comando a seguir:

sudo logkeys -s -d /dev/input/event3
 
Com isso o logkeys iniciaria o processo em modo daemon que roda em segundo plano e registraria todas as teclas pressionadas em meu teclado a partir de então.

Parando o Logkeys

Se você iniciou o Logkeys manualmente para encerra-lo simplesmente digite o comando:
sudo logkeys -k
O parâmetro -k (kill) é o responsável por interromper a captura de teclas e encerrar o programa.

Configurando o Logkeys para iniciar no boot

O pacote do Logkeys para o Ubuntu já possui um arquivo de configuração padrão (em /etc/default/logkeys) e o script de inicialização (em /etc/init.d/logkeys).
Para ativarmos o monitoramento desde o boot, nós devemos apenas alterar este arquivo de configuração que se parece com o mostrado abaixo:

$ cat /etc/default/logkeys
ENABLED=0
LOGFILE=/var/log/logkeys
 
# This should be updated according to your hardware
# Check README.Debian for more info
DEVICE=/dev/input/event5
Observe que temos três variáveis a serem modificadas:

ENABLED=0
  Mude para ENABLED=1 para que no próximo boot o logkeys seja iniciado
LOGFILE=/var/log/logkeys
Se desejar que o arquivo de log seja criado em outro caminho altere-o aqui

DEVICE=/dev/input/event5 Altere o caminho para corresponder ao seu dispositivo de teclado, conforme explicado anteriormente.
Após alterar estas variáveis, salve o arquivo e então reinicie o seu computador ou então digite o comando abaixo para iniciar a gravação de teclas.

sudo invoke-rc.d logkeys start

Conclusão

Como visto a configuração e uso da ferramenta é bem simples e não requer muito conhecimento técnico. O único requisito é que se saiba a senha administrativa do sistema para configurá-lo e para ler o arquivo de log.
E por fim, não me cabe o dever de julgar como você irá usar esta ferramenta, mas não custa nada lembrar mais uma vez que é exclusivamente sua a responsabilidade sobre o uso deste programa.

Referências

http://blog.welrbraga.eti.br/?p=1130
 
[1] LKL Linux Keylogger. Disponível em <http://sourceforge.net/projects/lkl/>
[2] Uberkey. disponível em <http://freshmeat.net/projects/uberkey/>
[3] Uberkey Download. Disponível em <http://gnu.ethz.ch/linuks.mine.nu/uberkey/>
[4] Logkeys. Disponível em <http://code.google.com/p/logkeys/>

SSH: Autenticando através de chaves

Requisitos e instalação dos pacotes

Requisitos

Para este artigo iremos precisar de um Linux instalado, pode ser o de sua preferência, desde que o OpenSSH esteja em sua versão 3.8 ou superior.

Instalação dos pacotes

Caso não esteja instalado, o comando para a instalação deste pacote no Debian é:

# apt-get install ssh

O comando acima irá instalar tanto o módulo do cliente quanto o do servidor (se desejado)

Configuração

Na máquina de gerência, dentro do login responsável pela gerência (no nosso caso suporte), executaremos o comando ssh-keygen. Este comando irá gerar o par de chaves, perguntando também o arquivo que conterá a chave e a frase-chave:

$ ssh-keygen -t dsa
$ ssh-keygen -t rsa

- Coloque o nome do arquivo;
- Gere uma passphrase;
- Repita.

Será gerado duas chaves, uma PRIVADA e a outra PÚBLICA:
A chave Privada está em "/root/.ssh/id_rsa" e a Pública em "/root/.ssh/id_rsa.pub".

Envie para o Servidor:

$ ssh-copy-id -i ~/.ssh/id_rsa.pub login@servidor

domingo, 23 de outubro de 2016

Executando um determinado arquivo com python 3 no Windows

Lembrando que só para Windows:

if 'win' in sys.platform:
    os.startfile('ex' + os.sep + 'sons' + os.sep + 'sons_testes.wav')

Biblioteca OS.PATH do python 3

Vamos registrar algumas funções da biblioteca os.path do python 3:

os.path.isdir('diretorio') = True => Verifica se é diretório;

os.path.isfile('file.py') = True => Verifica se é arquivo;

os.path.exists('algum') = True => Verifica se existe alguma coisa, ex: arquivo, diretório e etc;

os.path.getsize('arquivo.py') = 2015 => Verifica o tamanho.

os.path.split("/diretorio/diretorio/arquivo.py") = ("/diretorio/diretorio","arquivo.py") => Separa o que é diretório e o que é arquivo;

os.path.join("diretorio","arquivo.py") = diretorio/arquivo.py => Junta os parâmetros passados;

os.path.dirname("/diretorio/arquivo.py") = /diretorio => Obtém o nome do diretório;

os.path.basename("/diretorio/arquivo.py") = arquivo.py => Obtém o nome do diretório;

os.path.splitext("arquivo.py") = ('arquivo','.py') => Separa o que é arquivo e o que é extensão;

os.path.normpath("diretorio\diretorio/diretorio/arquivo.py") = ('diretorio/diretorio/diretorio/arquivo.py') => corrige alguns detalhes de diretório, como exemplo a barra e contrabarra;

os.curdir => equivalente ao "."

os.pardir => equivalente ao ".."

os.path.abspath("diretorio") = ('c:\diretorio\diretorio') => Indica o caminho absoluto.




sábado, 22 de outubro de 2016

PARA IMPLANTAR O WYSIWYG-REDACTOR

Precisa do Pillow mas para instalá-lo precisamos das bibliotecas:

libjpeg-dev
zlib1g-dev

https://github.com/douglasmiranda/django-wysiwyg-redactor

sábado, 15 de outubro de 2016

CONEXÃO POSTGRES COM DJANGO

INSTALAR POSTGRESQL

# apt-get install postgresql

ACESSAR O POSTGRESQL E CRIAR UMA SENHA

# sudo su - postgres
# psql -d postgres -U postgres
# alter user postgres with password 'senha';
# \q


FAZER A CONEXÃO ENTRE O POSTGRES DE O PYTHON - PSYCOPG2

# apt-get install libpq-dev
# apt-get install pyscopg2



DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql_psycopg2',
        'NAME': 'mydb',
        'USER': 'myuser',
        'PASSWORD': 'mypassword',
        'HOST': '127.0.0.1',
        'PORT': '5432',
    }
}

sexta-feira, 7 de outubro de 2016

Enviando emails com o Python

Vale ressaltar que o exemplo é indicado para envio de e-mail mais simples, para enviar e-mail com formatações especiais e anexos é recomendado o uso do módulo email.


O módulo smtplib define um cliente SMTP que pode ser usado para enviar emails tanto via SMTP quanto ESMTP. O smtplib segue os padrões da RFC 821 (SMTP), RFC 1869 (ESMTP), RFC 2554 (Autenticação SMTP) e RFC 2487 (SMTP Seguro via TLS).


Como este módulo já está incluso nas bibliotecas do Python você não precisará instalar nenhuma biblioteca adicional.
Agora que já demos uma boa introdução sobre o módulo smtplib vamos ao que interessa.
Inicialmente vamos importar o módulo:

Inicialmente vamos importar o módulo:

import smtplib

Vamos criar a instância do SMTP de acordo com a forma de autenticação:
 
TLS
smtp = smtplib.SMTP('localhost', 587)
smtp.starttls()
 
SSL
smtp = smtplib.SMTP_SSL('localhost', 465)
 
Sem autenticação
smtp = smtplib.SMTP('localhost', 25)
 
Se escolhemos TLS ou SSL devemos fazer a autenticação:
 
smtp.login('usuário', 'senha')
 
Caso seja sem autenticação devemos nos identificar enviando o comando EHLO ou HELO:
 
# EHLO
smtp.ehlo()
 
# HELO
smtp.helo()
 
# De forma genérica. Tenta EHLO primeiro.
smtp.ehlo_or_helo_if_needed()
 Não há necessidade de chamar os métodos ehlo ou helo quando se utiliza SSL ou TLS, pois o método login faz a chamada desses métodos caso seja necessário.
Enviando um email:

msg = """From: Seu Nome <seuemail@seudominio.com.br>
To: outroemail@seudominio.com.br
Subject: Buteco Open Source
 
Email de teste do Buteco Open Source"""
 
smtp.sendmail('seuemail@seudominio.com.br', ['outroemail@seudominio.com.br'], msg)
-----------------------------------------------------------------------------------------
Abaixo você pode verificar como enviar usando TLS:
 
import smtplib

smtp = smtplib.SMTP('smtp.gmail.com', 587)
smtp.starttls()

smtp.login('seuemail@gmail.com', 'suasenha')

de = 'seuemail@gmail.com'
para = ['seuemail@gmail.com']
msg = """From: %s
To: %s
Subject: Buteco Open Source

Email de teste do Buteco Open Source.""" % (de, ', '.join(para))

smtp.sendmail(de, para, msg)

smtp.quit()
--------------------------------------------------------------------------------------------
 Já neste outro exemplo você pode verificar como enviar via SSL:
 
 
import smtplib

smtp = smtplib.SMTP_SSL('smtp.gmail.com', 465)

smtp.login('seuemail@gmail.com', 'suasenha')

de = 'seuemail@gmail.com'
para = ['seuemail@gmail.com']
msg = """From: %s
To: %s
Subject: Buteco Open Source

Email de teste do Buteco Open Source.""" % (de, ', '.join(para))

smtp.sendmail(de, para, msg)

smtp.quit()
 
 
 Confira abaixo uma lista dos servidores de email mais comuns e suas configurações.
Nome Servidor Autenticação Porta
Gmail smtp.gmail.com SSL 465
Gmail smtp.gmail.com StartTLS 587
Hotmail smtp.live.com SSL 465
Mail.com smtp.mail.com SSL 465
Outlook.com smtp.live.com StartTLS 587
Office365.com smtp.office365.com StartTLS 587
Yahoo Mail smtp.mail.yahoo.com SSL 465

Espero que você tenha gostado desta publicação. Continue acompanhando que faremos uma continuação falando sobre o módulo email.
 
 
 
 
 
 
 
 
 
 

Python 3 – Servindo arquivos via HTTP Server



Tendo Python 3 instalado, basta ir ao terminal. No diretório que deseja servir arquivos HTML, digite:

python -m http.server 8000


Quem é Almir JR