Hugo Doria

O número de aplicações WEB tem aumentado bastante nos últimos anos, mas, infelizmente, os desenvolvedores parecem não se preocupar com a segurança delas.

É cada vez mais comum encontrarmos vulnerabilidades nas páginas WEB e uma das mais populares é a SQL Injection.

Felizmente, existem algumas ferramentas que servem para proteger suas aplicações desta falha. Uma delas é o GreenSQL, um um firewall usado para proteger uma base de dados MySQL de ataques de SQL Injection.

Veja o artigo completo aqui.

Hoje eu precisei migrar um projeto do git para o mercurial. Achei que ia dar um trabalho enorme, mas , felizmente, o processo é bem simples. Segue um passo-a-passo rápido:

Para fazer a migração é preciso da extensão "convert" do mercurial, mas ela vem desabilitada por padrão. Para reverter isso adicione as seguintes linhas ao arquivo ~/.hgrc :

[extensions]
hgext.convert=

Agora para importar seu código faça:

$ hg convert seu-repositório-git

Exemplo:

$ hg convert ~/projetos/meu-git

Isso vai criar um novo diretório, chamado "meu-git-hg". Se preferir, você pode definir o diretório para onde o código será convertido. Para fazer isso basta rodar o comando dessa forma:

$ hg convert seu-repositório-git meu-novo-repositório-mercurial

Exemplo:

$ hg convert ~/projetos/meu-git ~/projetos/meu-hg

Ao tentar listar o conteúdo deste diretório você verá que ele está vazio. Para que seus arquivos originais apareçam neste é preciso fazer o seguinte:

$ cd meu-git-hg

$ hg checkout

Pronto! Seus arquivos aparecerão novamente e já estarão sob o mercurial. :-)

Maiores informações: http://mercurial.selenic.com/wiki/ConvertExtension

As festas chegaram e, com elas, os amigos secretos. Para facilitar a vida dos sorteios segue um pequeno script que fiz ano passado. O script pega um lista de pessoas, sorteia e envia um email para cada uma com o nome do seu amigo secreto. Ele evita que uma pessoa pegue a si mesmo, ou alguém deixe de ser sorteado:

 
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# Script para sorteio de amigo secreto
# Hugo Doria
 
from random import shuffle
import os
 
arquivo = open("amigos.txt","r")
 
pessoas = arquivo.readlines()
shuffle(pessoas)
 
for par in zip(pessoas, pessoas[1:] + pessoas [:1]):
  envia = os.popen("/usr/bin/mail -s '[sorteio] Seu amigo secreto é ...'" + par[0].replace("\n","").split("-")[1], "w")
  envia.write("Seu amigo secreto é .... \n\n\n" + par[1].replace("\n","").split("-")[0])
 
  envia.close()
  print par
 
arquivo.close()
 

Para rodar o script você só precisa do python e de um arquivo chamado amigos.txt, com o nome das pessoas dentro no formato Nome - email.

Exemplo:

Fulana - meu@email.com.br
Sicrana - sicrana@hotmail.com
Beltrana - com-cam@tal.com.br

Há algum tempo coloquei 2 links ADSL aqui em casa e criei o script abaixo para fazer o balanceamento entre eles. Hoje dei um geral no script e lembrei que nunca havia publicado ele por aqui. Então, lá vai:

#!/bin/bash
#
# Script para fazer o balanceamento de links ADSL
# Para adicionar mais um link é so adicionar um item
# às variaveis IFACES, IPS, GATEWAYS, NETWORKS,
# WEIGHTS e NAMES
#
# É extremamente importante manter a ordem dentro das
# variáveis. O primeiro campo da variável "IFACES"
# corresponde ao primeiro campo da variável "IPS"
# e por aí vai.
#
# Ultima modificacao:  22/11/2009
# Hugo Doria 
 
# Interfaces de rede
IFACES=("eth1" "eth2" "eth3")
 
# IP das interfaces de rede. Isto NÂO é o ip do modem.
# É extremamente importante que siga a mesma ordem das interfaces
# listadas na variável IFACES
IPS=("192.168.254.2" "192.168.254.10" "192.168.254.18")
 
# IP dos Gateways. Geralmente esse é o ip do Roteador ou do modem ADSL
GATEWAYS=("192.168.254.1" "192.168.254.9" "192.168.254.17")
 
# IP das redes que o modem e as interfaces pertencem
NETWORKS=("192.168.254.0/29" "192.168.254.8/29" "192.168.254.16/29")
 
# Peso de cada link. Se os links tiverem a mesma banda, entao deve-se
# colocar 1 para todos. Se um link for maior que outro, entao coloque
# os pesos correspondentes
WEIGHTS=("1" "1" "1")
 
# Nome dos links. Usado para criar um alias da conexão
NAMES=("velox1" "velox2" "velox3")
 
#-----------------------------------------------
# NÂO ALTERE A PARTIR DAQUI
#-----------------------------------------------
 
# Comando padrão de adicionar rota
ROUTEADD="ip route add default scope global"
 
# Comando para deletar uma roda
ROUTEDEL="`which route` del default gw"
 
####################################################
# Deletando as rotas
####################################################
 
for (( X=0; X < ${#IPS[@]}; X++ )); do
    echo "Deletando as rotas para ${IPS[$X]}"
    ${ROUTEDEL} ${IPS[$X]}
done
 
#######################################################
# Limpando as rotas
#######################################################
 
for (( X=0; X < ${#IPS[@]}; X++ )); do
    echo "Limpando as rotas da tabela ${NAMES[$X]}"
    ip route flush tables ${NAMES[$X]}
done
 
#######################################################
# Aplicando as regras das redes
#######################################################
 
for (( X=0; X < ${#IPS[@]}; X++ )); do
    echo "Aplicando a regra da rede ${NETWORKS[$X]}"
    ip route add ${NETWORKS[$X]} dev ${IFACES[$X]} src ${IPS[$X]} tables ${NAMES[$X]}
done
 
#######################################################
# Adicionando as regras
######################################################
 
for (( X=0; X < ${#IPS[@]}; X++ )); do
    echo "Adicionando a regra do ${IPS[$X]} na tabela ${NAMES[$X]}"
    ip rule add from ${IPS[$X]} table ${NAMES[$X]}
done
 
##########################################################
# Regra padrão e limpeza do cache
##########################################################
 
for (( X=0;X < ${#IPS[@]}; X++ )); do
    ROUTEADD="${ROUTEADD} nexthop via ${GATEWAYS[$X]} dev ${IFACES[$X]} weight ${WEIGHTS[$X]}"
done
 
echo "Adicionando a regra padrao"
${ROUTEADD}
 
echo "Limpando o cache"
ip route flush cache

# Fim do script

O script serve para mais de dois links ADSL. Para adicionar mais um link é so adicionar um item às variaveis IFACES, IPS, GATEWAYS, NETWORKS, WEIGHTS e NAMES. Lembre-se sempre de manter a ordem dos itens dentro das variáveis.

Resolvi criar uma ferramenta para me ajudar a fazer hardening de servidores linux e facilitar a minha vida no trabalho. Assim nasceu o hntool (hardening tool), uma ferramenta escrita em python cujo objetivo é fazer uma análise simples do servidor e dizer quais as falhas de segurança que existem.

Todas as falhas são niveladas de acordo com risco que podem causar ao servidor. Falhas leves (low), médias (medium) e graves (high). Além destas categorias há mais duas: ok e info.

A ferramenta ainda está em um estágio bem inicial, mas resolvi compartilhá-la logo para ajudar aqueles que querem contribuir com algo e, claro, acelerar o desenvolvimento.

Algumas características:

• Criei uma estrutura bem modular, baseando-me em outro projeto que mantenho: o namcap. Acredito que com essa estrutura fica muito mais fácil manter e contribuir com o projeto.
• Não quero que o hntool realize nenhum hardening automaticamente. Quero apenas que ele me avise das falhas que existem. A decisão sobre o que (e como) fazer para consertar a falha cabe ao administrador do sistema.
• A intenção é fazer com que o hntool sirva para qualquer distribuição, mas no momento eu só tenho testado no Arch Linux.

Usando o hntool

Para testar o hntool é fácil. Baixe-o daqui e descompacte-o. Depois é só entrar no diretório descompactado e rodar:

# python hntool.py

Sim, você só precisa do python.

Segue um exemplo do resultado do hntool (clique para ampliar):

Acho que deu para entender onde quero chegar, né?

Como contribuir

Você pode contribuir com o hntool de diversas formas: enviando código, patchs, reportando bugs e pedindo recursos. Tudo isso pode ser feito através do bug tracker do Google Code ou enviando um email para contato arroba hugodoria.org.

Todo o código do projeto está disponível no Google Code. Para baixá-lo e gerar seus patchs faça:

$ hg clone https://hntool.googlecode.com/hg/ hntool

$ cd hntool

(faça suas mudanças no código)

A ferramenta também está precisando de um ícone simples e bonito. Sou um zero à esquerda quando se trata de desenho e totalmente incapaz de fazer algo decente. Fica aí a dica. :P

Estrutura modular

Como falei, resolvi criar o hntool de forma modular. A estrutura de um modulo é, mais ou menos, assim:

import os
 
class rule:
	def short_name(self):
		return "ssh"
	def long_name(self):
		return "Checks security problems on sshd config file"
	def analyze(self):
		check_results = [[],[],[],[],[]]
		ssh_conf_file = ['/etc/ssh/sshd_config', '/etc/sshd_config']
 
		for sshd_conf in ssh_conf_file:
			if os.path.isfile(sshd_conf):
				fp = open(sshd_conf,'r')
				lines = [x.strip('\n') for x in fp.readlines()]
 
				# Checking if SSH is using the default port
				if 'Port 22' in lines or '#Port 22' in lines:
					check_results[1].append('SSH is using the default port')
				else:
					check_results[0].append('SSH is not using the default port')				
 
				# Closing the sshd_config file
				fp.close()
 
		return check_results
	def type(self):
		return "config"

Explicando melhor:

• short_name(self): Uma string contendo o nome curto do modulo. Ele será usado, por exemplo, na hora de listar todos os módulos existentes (hntool -l).
• long_name(self) : Aqui é a descrição do módulo. Também será mostrada na listagem dos módulos.
• analyze(self): É aqui que fica o código de verdade. O resultado desse método deve ser sempre uma lista com 5 elementos, que correspondem aos níveis de segurança encontrados - ok, info, low, medium e high, respectivamente.
• type(self): Cada módulo será de um tipo. "files" para módulos que lidam com arquivos de texto simples(/etc/passwd, por exemplo) ou de configuração. "services" para módulos que lidam com serviços.

Há, também, um arquivo README explicando mais detalhes sobre o hntool. Obviamente, ele será melhorado com o tempo.

Bem, pessoal. É isso. Estarei sempre postando novidades desse projeto à partir de agora. :)