segunda-feira, 4 de fevereiro de 2008

Conexão segura - Apache2 + OpenSSL no Linux

Com certeza falei neste blog e no meu outro que sempre quis montar uma estação de trabalho para web development bacana em Linux.

Batalhei bastante com isso, mas nunca de forma contínua. Sempre foram de saltos, afinal também preciso estudar, trabalhar e dividir minhas atenções com entes queridos.

Para mim a estação de desenvolvimento ideal é aquela que simula os recursos disponíveis nos servidores. Então além de um servidor web, também deve ter um servidor de e-mail, interpretadores de código (PHP, Perl, Python...), container Java (Tomcat), servidores de bancos de dados (MySQL, Postgre), e por aí vai... Além de ferramentas que ajudem em outras funções, como programar (Eclipse, Quanta Plus, Bluefish) e criar layouts (GIMP, Inkscape)...

Faz um tempão que eu estava querendo colocar aqui SSL, para simular ambientes de produção onde se reproduzem operações seguras, em geral financeiras; hoje realizei. Passei o final da tarde da segundona de carnaval aprontando essa e vou compartilhar aqui com vocês.

O ambiente: Ubuntu 6.06 + Apache 2 (instalado pelo Synaptic) + OpenSSL (também instalado pelo Synaptic).

Creio que as únicas diferenças significativas aqui para que este tutorial se torne válido para outros sabores do GNU/Linux, e formas de instalação (via pacotes RPM, compilando na unha, por outro gerenciador de pacotes) são:
- a localização de alguns arquivos e paths;
- a instalação pelo Synaptic deixa o httpd.conf bem fragmentado. Citarei vários arquivos aqui que nada mais são que partes do httpd.conf que foram separadas.

Bem vamos ao desafio:
Quero que uma parte do site seja pública (passando por uma conexão comum) e outra privada (passando por SSL).

Então criei um diretório para o site e dois subdiretórios, assim:
/var/www/meusite/
/var/www/meusite/public/
/var/www/meusite/private/

Quero que a parte pública seja acessada como "http://www.meusite.com/" e que a parte privada seja acessada como "https://secure.meusite.com/

O primeiro passo é instalar os pacotes. Deixo isso por sua conta o que importa é ter o Apache 2.0 e o OpenSSL instalados. Tem muitos tutoriais de como se fazer isso e como não vou reinventar a roda, dê uma boa lida nas documentações. Estes tutoriais aqui podem dar uma simplificada na sua vida: este e este.

O que interessa é dividir o site em duas partes. Edite o arquivo /etc/hosts. Acrescente lá os sites que você quer. Eu acrescentei as linhas:

127.0.0.1 meusite www.meusite.com
127.0.0.1 secure.meusite secure.meusite.com


E dê uma conferida no arquivo "/etc/host.conf", ele deve conter uma linha assim:

order hosts,bind


Isso significa que quando uma requisição for feita, sua máquina olhará primeiro no arquivo hosts que acabamos de editar, depois vai para os resolvedores de nome. Isso é o que permite que você possa ter e acessar um site com o nome www.algumacoisa.com no seu PC sem conflitar com um da internet (note que se você nomear o site com algum nome existente como google.com, por exemplo - você não conseguirá mais acessar este site pelo nome, já que o arquivo /etc/hosts vai resolver ele antes de procurar nos resolvedores de nome!).

Agora para configurar os virtual hosts no Apache.
Para o parte pública acrescente:

<VirtualHost *>
ServerName www.meusite.com
DocumentRoot /var/www/meusite/public
</VirtualHost>


No httpd.conf ou no arquivo /etc/apache2/sites-available/default
Se você criou o arquivo /etc/apache2/sites-available/ssl
acrescente isso como conteúdo dele:

NameVirtualHost *:443
<VirtualHost *:443 >
ServerName secure.meusite.com
DocumentRoot /var/www/meusite/private

SSLEngine On
SSLCertificateFile /etc/apache2/ssl/apache.pem
</VirtualHost>


Ou acrescente isso depois dos outros virtual hosts comuns.

Isso deve dar conta do recado.
Confira se você não esqueceu de colocar a porta 443 na escuta. No httpd.conf ou no ports.conf deve estar uma linha assim:

Listen 443


Também não esqueça de gerar e corrigir os nomes e paths dos certificados.

Se tudo der certo, depois de você reiniciar o Apache, abra um navegador e digite:
http://www.meusite.com/
https://secure.meusite.com/

E veja o resultado =]

Até mais.
-----------
keepReading

quarta-feira, 9 de janeiro de 2008

PostgreSQL - Inserindo múltiplas linhas só depois da versão 8.2

A batalha de hoje foi contra um velho costume (mal) adquirido do MySQL.

Criei uma tabela muito simples no PostgreSQL através do psql, na linha de comando mesmo.

CREATE TABLE pessoas (
id INT,
nome varchar(40),
sexo char(1)
);


Incluí um registro. Ótimo. Depois tentei incluir mais de um com um comando só:

INSERT INTO pessoas (id, nome, sexo) VALUES (2, 'José', 'M'), (3, 'Maria', 'F');


E ganhei um erro próximo dá vírgula.

...('M'), (3,...
^


Não ia nem com reza. Horas de pesquisa depois descobri algumas coisas interessantes.
1 - Esse tipo de construção não faz parte da norma SQL.
2 - Ela é popular devido ao popular MySQL (que disponibiliza essa construção como válida) e do seu fiel parceiro phpMyAdmin (que além de permitir a inclusão de múltiplos registros, ainda mostra o código SQL que foi executado, para todo mundo aprender como se faz!).
3 - Este tipo de construção é aceita pelo PostgreSQL 8.2 ou posterior. O server que tenho é o 8.1. E o manual que eu estava lendo do 8.3!
4 - Vou dar uma estudada em Java ou Shell Script para relaxar.

Té+
-----------
keepReading

segunda-feira, 7 de janeiro de 2008

PostgreSQL - instalando

A tempos atrás instalei o PostgreSQL 8.0 na minha máquina. Lembro que foi um tanto penoso para entender como proceder logo após a instalação dele no sistema, pensei até em escrever aqui mas devido à falta de tempo não escrevi nada, e é o que venho fazer agora.

O material é um tanto escasso em português, e as explicações geralmente confusas. Vou tentar dar um passo-a-passo.

Instalei no Ubuntu 6.06 pelo Synaptic (bem fácil), mas creio que o processo de compilação está bem descrito na documentação do PostgreSQL, então não vou me ater à este processo. O galho me veio após a instalação. Também recomendo que se instale o phppgAdmin, que dá uma interface mais agradável de trabalhar (nesse caso você precisará do Apache2 e do PHP5).

Primeiramente, saiba que quando se instala o PostgreSQL, assim como o Apache, o CUPS, é criado um usuário no sistema, para que este possa iniciar o servidor. É mais uma questão de organização e controle. Não se preocupe com isso, basta saber que o nome do usuário é postgres.

Além de criar este usuário, alguns comandos são adicionados ao sistema. São comandos administrativos que podem ser chamados direto pelo terminal.

Mais um detalhe importante: o PostgreSQL não permite que se crie e faça login com usuários com nomes sugestivos como admin, root, etc... Anotado? Então vamos lá, temos comandos para agir externamente e sabemos que não podemos criar nenhum usuário com nome sugestivo.

Abra um terminal e digite o comando:

$sudo su - postgres createuser seu_nome_de_usuario_do_linux

Se não funcionar dessa forma tente:

$sudo su - postgres
$createuser seu_nome_de_usuario_do_linux

A seguir serão feitas algumas perguntas (o novo usuário poderá criar um super-usuário? o novo usuário poderá criar bancos de dados?...poderá criar um novo usuário?). Responda a estas perguntas (sugiro um não-sim-não).

NOTA: o seu_nome_de_usuário_do_linux irá facilitar sua vida na hora de criar bancos de dados e fazer manutenção.

Temos um usuário criado, mas ele não tem senha ainda.
Faça assim:

$sudo su - postgres psql

Se não der certo tente:

$sudo su - postgres
$psql

Isso irá abrir um outro tipo de terminal, um terminal interativo com o servidor de banco de dados. Entre com a seguinte linha nele:

postgres=#ALTER ROLE seu_nome_de_usuário_do_linux WITH PASSWORD 'sua_senha';

Dê enter (aí você acaba de setar sua senha) e depois digite:

postgres=#\q

E dê enter novamente (para sair do terminal interativo do PostgreSQL).

Pronto. Agora você tem um usuário e senha do PostgreSQL com o qual poderá criar e editar seus bancos de dados no PostgreSQL.

Você pode criar um banco de dados mesmo sem senha com o comando:

$createdb nome_do_banco

Mas para logar pelo phppgAdmin a senha se faz necessária.

Agora vamos supor que você tenha criado um banco com o nome dummy. Para acessá-lo pelo terminal interativo do postgreSQL, basta fazer:

$psql -d dummy

E a partir daí enviar suas queries à este banco.

Espero que isso tenha ajudado a dar o ponta-pé inicial para o uso do PostgreSQL. Abaixo passo alguma informações extras.

Os comandos que podem ser usados direto pelo terminal são:
clusterdb -- cluster a PostgreSQL database
createdb -- create a new PostgreSQL database
createlang -- define a new PostgreSQL procedural language
createuser -- define a new PostgreSQL user account
dropdb -- remove a PostgreSQL database
droplang -- remove a PostgreSQL procedural language
dropuser -- remove a PostgreSQL user account
ecpg -- embedded SQL C preprocessor
pg_config -- retrieve information about the installed version of PostgreSQL
pg_dump -- extract a PostgreSQL database into a script file or other archive file
pg_dumpall -- extract a PostgreSQL database cluster into a script file
pg_restore -- restore a PostgreSQL database from an archive file created by pg_dump
psql -- PostgreSQL interactive terminal
reindexdb -- reindex a PostgreSQL database
vacuumdb -- garbage-collect and analyze a PostgreSQL database

-----------
keepReading

O MySQL não checa chaves estrangeiras!

Dando uma lida na documentação recentemente fiquei pasmo ao descobrir que as chaves estrangeiras não servem para absolutamente nada funcional no MySQL.

Sim, você leu direito. As chaves estrangeiras não servem para absolutamente nada no MySQL.

Ao definí-las, elas podem ser usadas como um lembrete, um aviso, etc... Mas os engines, com exceção ao InnoDB, não fazem checagem se o mesmo existe (na verdade eles não checam nem se a tabela onde é feita a referência!).

No InnoDB elas funcionam normalmente, mas nos outros a criação de chaves estrangeiras apenas criam uma coluna. Nem ao menos um índice é criado.

Uma vergonha para um banco com tantas funções, recursos, tipos de dados, extensões, conectores, etc...

A manual em questão é da versão 5.1 do MySQL, mais especificamente na seção 3.6.6.

Isso moçada: fiquem de olho.

-----------
keepReading

domingo, 6 de janeiro de 2008

Dicas de otimização e segurança

Olá, amigos. Depois de muito tempo away deste blog volto a publicar algumas informações coletadas e experimentadas.

Estudei bastante e fiz várias anotações durante os últimos meses. Além deste post se preparem para mais novidades legais em breve.

Neste reinício trago a vocês dicas sobre otimização e segurança. Algumas boas práticas que espero ser de valia.

Uma das decisões mais importantes durante o desenvolvimento de um sistema é onde implementar as regras do negócio. É comum deixar as regras ao encargo do linguagem de programação, mas quero mostrar que o melhor lugar para se fazer isso, sempre que possível, é no banco de dados.

Quando se implementa a lógica do negócio na linguagem de programação algumas coisas aumentam, como o tempo de desenvolvimento, o volume de códigos e a dificuldade em se fazer manutenção. Além de diminuir a portabilidade da aplicação (no caso de uma migração por exemplo).

Isso sem falar no ponto mais crítico: o aumento do tráfego e do processamento.

Vou exemplificar com um cenário comum - Apache 2, PHP 5 e MySQL 5.

Quando se tem a lógica implementada nos scripts/classes PHP, o fluxo segue mais ou menos como na figura:


Explicando... o cliente faz uma requisição ou envia um form. Estas informações são recebidas pelo servidor web que chamará o engine. O engine irá processar as requisições, se conectar com o banco de dados, enviar a(s) query(ies), processar a(s) resposta(s), fechar a conexão com o banco de dados, preparar a saída, repassá-la para o servidor e este por fim enviará para o cliente.

Isso é o processo que acontece geralmente em qualquer aplicação. Mas note que quando se deixa a regra dos negócios para o engine resolver, podem ser necessárias várias conexões e consultas ao banco de dados, e é aí onde o sistema perde performance - e muita.

A meta é diminuir este gargalo e aliviar este ponto crítico (a conversa entre o engine e o banco de dados). Deixando a lógica de dados implementada no banco de dados, o engine que trabalha com ele fará menos conexões, diminuirá a carga de processamento e melhorará o tempo de resposta, além de deixar o sistema mais robusto.

Assim, é altamente recomendável lançar mão de recursos como Views, Triggers, Procedures, Functions, e fazer um bom uso de índices e chaves disponíveis no banco de dados.

Digo isso porque tive uma experiência realmente dura em um sistema onde TODA a lógica dos dados estava implementada com o design pattern MVC. E para retornar um simples relatório com 50 linhas o sistema demorava uns 6 minutos - simplesmente crítico.

O problema é que haviam várias tabelas com relação Muitos-para-Muitos e a cada linha que se queria obter era necessário realizar uma série de queries e filtragens. Posso citar um dos casos onde para cada usuário era feita uma consulta numa tabela de relacionamento que retornava cerca de 8 chaves, que depois seriam pesquisadas em outra tabela, comparados, validados segundo sua data, organizados (aí já tinha apenas uns 2 ou 3 registros que realmente seriam úteis para o relatório), para depois fazer mais queries em duas ou três tabelas.

Ou seja para produzir uma linha, era necessário um volume de tráfego e processamento absurdo, sendo que isso poderia ser facilmente resolvido (ou pelo menos fortemente otimizado) com a criação de uma view e de uma function.

Aqui cabe um adendo: a diferença entre o modelo entidade-relacional dos bancos de dados e do que se pode implementar na programação orientada a objeto se chama impedância, e as boas práticas aqui citadas visam diminuir este problema. Eis um bom artigo aqui: http://www.linhadecodigo.com.br/ArtigoImpressao.aspx?id=70

Então a dica de otimização é essa: implemente a lógica de dados sempre que possível na própria base de dados.

Mas e a linguagem de programação seria útil para quê então?
Ora, para validar os dados enviados, fazer a conexão, enviar e receber dados do servidor, enviar e-mails, montar páginas dinamicamente... as mesmas coisas que antes. O que quero dizer é que ao invés de rechear seus scripts e classes com ifs, elses, switch cases e queries, você deve diminuir isso e usar apenas onde for realmente necessário.

Em relação à segurança, ela aumenta quando se adota esse procedimento e estes cuidados. Além disso você terá mais tempo livre para criar validações nos seus scripts server-side, e contará com mais uma camada de validação - a do servidor de bancos de dados.

É mais econômico para o sistema você checar se, por exemplo, um id existe numa determinada tabela do que fazer uma query select e depois uma comparação no script.

Algo assim: ao invés de fazer
<?
...
$valid_user = 0;
$sql = "SELECT 1 FROM users WHERE id = $posted_id";
$result = mysql_query($sql);
$x = mysql_fetch_assoc($result);
if ($x) {
$valid_user = 1;
}

if ($valid_user == 1) {
$sql_2 = "INSERT INTO...";
...
}
...

?>


Faça assim:
<?
$sql = INSERT INTO table_x VALUES ($x,$y,$z) WHERE $z INTO (SELECT id FROM users);
?>


Ou que você crie uma function no banco de dados para fazer isso.

Até mais.
-----------
keepReading

segunda-feira, 28 de maio de 2007

Indo a fundo - assembly e engenharia reversa

Aprender assembly e engenharia reversa. Eis o galho. Difícil de encontrar material, e principalmente códigos para ler.

Nem tanto. Um ótimo livro, The Art of Assembly Programming, de Randall Hyde. Abrange desde o que é um sistema de numeração binária, até HLA (High-Level Assembly). Referência em tantas outras obras, este livro só falta pegar no colo.

O site Numa Boa, também tem um tutorial em português, além de uma referência bem completa sobre as API's do Win32. Ah sim, o pessoal do Linux também tem um site de referência sobre assembly bem aqui.

Se você acha que precisa de mais códigos para entender o que se passa, há um comando no Linux que pode ajudar muito (inclusive no que diz respeito a engenharia reversa): o objdump.

Você pode usá-lo para disassemblar qualquer programa nos formatos PE (Portable Executable, que é o padrão do Win32), no formato ELF (Executable and Linking Format, que é o padrão atual dos UNIX-like), ou ainda em alguns outros formatos.

Criar códigos "hello world" em C, e depois disassemblá-los com o objdump é uma boa forma de se aprender.

Para a engenharia reversa e debbuging ainda há outros comandos no Linux que são muito úteis e que já vêm inclusos na maioria das distribuições, entre eles:
readelf que "disseca" o executável;
od que retorna byte a byte o conteúdo do arquivo;
ar que serve para alterar/criar/modificar arquivos de uma forma bem seleta.

Utilize-os com moderação!
-----------
keepReading

sexta-feira, 27 de abril de 2007

O modo texto

O pessoal que entra no mundo linux logo descobre que as coisas mais animais que dá pra se fazer é através da linha de comando. Porém para a maioria das atividades rotineiras, acaba-se usando ferramentas gráficas para isso.

Usar o OpenOffice.org, navegar com o Firefox, usar o K3B para gravar um CD,.... tarefas comuns, rotineiras e que têm uma solução de interface gráfica, que praticamente dispensa prática ou muitos conhecimentos.

Nos ultimos dias também andei experimentando soluções em modo texto para tarefas comuns. Descobri que o shell por si só é muito mais poderoso do que imaginava. Também experimentei os editores nano e VI Improved (VIM), que são demais.

Têm recusos incomuns à primeira vista, e podem até parecer complicados de se usar, mas depois de mais ou menos uma hora trabalhando com eles já se nota a diferença na velocidade com que se pode realizar as tarefas comuns. E ainda por cima pode-se customizar funcionalidades e recursos de forma a tornar o trabalho mais ágil.

Navegadores de modo texto também são um barato. Experimentei dois: o lynx e o w3m. O Lynx é um clássico, muito bom e com vários recursos. Mas o w3m me surpreendeu. Ele tem suporte a navegação em abas, suporte a várias codificações diferentes, gerenciamento de cookies, recursos de segurança, gerenciador de downloads, 'favoritos' e histórico. Em outras palavras: completo.

Outras coisas que quero experimentar no modo texto são: gravar CD direto pela linha de comando (dizem que é absurdamente mais rápido, e eu não duvido, basta ver a diferença entre o Nero e o K3B); usar o talk para mensagens instantâneas; e o ffmpeg para converter arquivos, como .avi para .mpg.

Talvez esse mundo só fique proibido dos designers, que dependem do GIMP, Inkscape, Blender e Cia, para trabalhar. Mesmo assim, quem sabe realmente usar estes programas afirma que eles são as ferramentas de produção mais eficazes do mercado.

Té+
-----------
keepReading

Uma referência da linguagem C

Eu sempre gostei de referências completas. O problema sempre foi achá-las. E nos últimos dias procurei algo sobre linguagem C.

A idéia surgiu depois de eu ter lido um código-fonte cheio de includes. Me perguntei se era necessário tudo aquilo, e mais importante, quais funções são fornecidas por cada um dos header files.

Ao conferir os próprios arquivos, vi que apesar de bem documentados, eram numerosos e extensos demais. O que eu queria era apenas uma lista. Decidi criar algum algoritmo ou script que criasse essa lista para mim. No entanto, cada arquivo tem um formato interno diferente, o que dificultou (e ainda está dificultando no presente momento) meu trabalho.

Achei algumas referências na internet e gostaria de compartilhá-las, ainda que nenhuma delas me atenda por completo.

Site de Eric Huss

Site da GNU

O site da GNU é mais que um curso completo, porém não aborda todas as bibliotecas, a informação não está organizada da forma que eu queria (como no site de Eric Huss). O site de Eric Huss, por sua vez apresenta-se com uma organização mais agradável, porém a quantidade de informação é muito menor, assim como as bibliotecas abordadas.

Mas, enquanto estudo e crio uma solução (desejo criar um tarball de arquivos html ou xml), as referências acima dão conta da maioria das dúvidas.

PS: Se quiser entender o por quê da linguagem C, leia este texto de Eric S. Raymond.
-----------
keepReading

quinta-feira, 19 de abril de 2007

Conhecendo o linux um pouco mais a fundo

O GNU/Linux tem uma infinidade de comandos e utilitários. Não conheço uma pessoa sequer que conheça todos os comandos. Digitando:
$ echo $PATH;

num console você vê os caminhos onde o sistema busca os programas para executar (geralmente /bin/, /sbin/, /usr/bin/,...). Fui conferir o que existia nestes diretórios e me deparei com uma quantidade muito maior de programas do que eu imaginava.

Digitar man nome_do_comando exibe o conteúdo do manual, mas isso era impensável para milhares de programas. Daí surgiu a idéia de criar um script em shell que fizesse isso por mim. Só que lendo o manual do comando man, vi que ele podia mandar a saída para um navegador. Não conseguia mandar para o firefox, apenas para o w3m, um navegador de modo texto, similar ao lynx.

Após googladas e algumas tentativas frustradas, instalei o pacote groff e o pacote man2html pelo synaptic.

Mais algumas tentativas e voilá. Tinha um script que lia o conteúdo de um diretório e mandava as man pages para um outro diretório, salvando cada uma em um arquivo já no formato html.

Mas como nem tudo são flores, algumas entradas não tinham manual, e resultaram em arquivos vazio.
Dá-lhe outra rodada de shell script para criar uma rotina que verificasse quais arquivos estavam vazio e os deletassem.

Ótimo. Bastou criar um index.php dentro dos diretórios que gerasse os links. Agora posso ler tranquilamente as várias man pages pelo firefox, da mesma forma com a qual eu leio os manuais do PHP, Java, MySQL, PostgreSQL, Python, Ruby, Guia Foca Linux,... com direito a um lugar no favoritos e tudo mais.

Abaixo seguem os códigos de shell script que usei.


exporta_manual
#!/bin/bash
#
#autor: Davis Leandro P. Peixoto
#data: 19-04-2007
#script para exportação de manuais

for i in *;
do {
echo Tentando exportar o manual de $i;
man -Thtml $i > /home/user_dir/manual_folder/$i.html;
echo Manual de $i exportado;
};
done;

///////////////////


limpa_vazios
#!/bin/bash
#
#autor: Davis Leandro P. Peixoto
#data: 19-04-2007
#script limpeza de arquivos vazios

count=0;
for i in *;
do {
a=`head -n 1 $i`;
b='';
if [ "$a" = "$b" ];
then
echo apagando $i;
rm -r $i;
echo arquivo apagado com sucesso!;
count=`expr $count + 1`;
else
echo O arquivo $i está cheio e não será apagado;
fi;
};
done;

echo Foram apagados $count arquivos que estavam vazios;
echo Limpeza finalizada com sucesso;

/////////////////////////////////////////


index.php
/* criando um manipulador de diretórios */
$handle = opendir('.');

/* listando o diretório */
while (false !== ($file = readdir($handle))) {

/* e escrevendo os links */
echo "<a href=\"$file\">$file</a>";
}

/* fechando o diretório */
closedir($handle);
?>

////////////////
Nota: os scripts precisam ser executados de dentro dos diretórios (/bin/, /sbin/, etc...)

Té+
-----------
keepReading

quarta-feira, 28 de março de 2007

De tirar o chapéu

Foi divulgada a segunda falha de segurança remota no sistema operacional OpenBSD... em 10 anos!

Tá certo que ele é um sistema projeto para ser o mais seguro quanto possível, mas assim é demais. Duas falhas em 10 anos de existência não é pra qualquer um.

E aliás a falha já foi corrigida rapidamente, como é quase regra no mundo dos Unix-Like.


Ah, se meu banco usasse esse sistema...

-----------
keepReading