Durante a décima edição do Fórum Internacional do Software Livre [0] em Porto Alegre – RS, Brasil participei da Arena de Programação do evento. O desafio desse ano foi implementar um servidor e um cache DNS que suportasse o DNSCurve[1], protocolo de criptografia para DNS criado por Daniel J. Bernstein[2], também criador do djbdns[3]. O desafio foi proposto e julgado pelo djb.

A arena durou 3 dias. Às 22 horas do terceiro dia deveríamos entregar o servidor e o cache com DNSCurve para o Daniel. Meu grupo era formado por mim, pelo João Paulo Rechi Vita[4], que também é aluno aqui da Unicamp e assim como eu, está no Google Summer of Code pelo projeto BlueZ. E por Rodrigo Exterckötter Tjäder, aluno de Ciência da Computação da UFSM – Universidade Federal de Santa Maria.

Ficamos sabendo o que teríamos que fazer apenas no início do primeiro dia, então passamos as primeiras horas descobrindo do que se tratava o DNSCurve (principalmente eu, que não estudei Redes formalmente na Unicamp ainda). Após entendermos o DNSCurve fomos atrás de implementações de DNS para tomarmos como ponto de partida para nossa implementação. Partimos preferencialmente para implementações em python, pois seria bem mais rápido e tranquilo desenvolver.

Rechi Vita encontrou uma implementação de servidor DNS em python, chamada pymds[5] e uma implementação de cache chamada PyDNSCache[6]. Ambas as implementações são extremamente pequenas, o que facilitou o nosso entendimento e a expansão desses códigos para suportar o DNSCurve.

Para a parte cripotográfica do DNSCurve usamos a slownacl[7] biblioteca que implementa a todo calculo criptográfico do DNSCurve. Acompanhavam a slowsalt pequenas bibliotecas para manipulação pacotes DNS, isto é, funções prontas pra descriptografar e criptografar pacotes DNS que são enviados e recebidos pelos servidor e cache.

Passamos os dois primeiros dias integrando esses 3 códigos: pymds, PyDNSCache e slownacl. No final do segundo dia tinhamos um servidor e um cache funcionando para o envio e recebimento de pacotes. Mas esse cache nao resolvia nomes recursivamente e como ia dar muito trabalho implementar isso no nosso cache, resolvemos abandoná-lo e partir para uma nova implementação de cache usando a biblioteca dnspython[8]. Com esse novo código foi possível fazer o cache resolver nomes recursivamente e consequentemente conseguir pegar a chave pública do servidor DNS.

O Resultado desses três dias de maratona foi recompesado com a vitória. Nossa solução foi eleita a melhor e recebemos um celular G1 rodando Android cada e muitos elogios do djb sobre o nosso código. =)

Nosso código está aqui[9] e abaixo coloco a descrição sobre a implementação que enviamos ao Daniel junto com nosso código:

We implemented the two proposed parts separately.

(1) DNS Server — pymdscurve.tar.bz2

We based our implementation on pymds [5], a modular python DNS server
licensed under the MIT license. It’s a standalone DNS server, in terms
it doesn’t resolve any names it doesn’t know. For the NaCl functions,
we used the slownacl lib from dnscurve [1]. Despite it doesn’t says on
the website, we contacted the authors (both Matthew and Angel) and
both of them told us the is public domain and a note on the project
page is missing. Matthew even added a README to the code which says
it’s public domain and updated some code on the lib to make it
compliant with NaCl spec (article on your website).

(2) DNS Cache

For the cache we tried two different approaches.

(i) PyDNSCacheCurve.tar.bz2 — First we added the DNSCurve messages to
PyDNSCache [6], which is a very simple DNS cache written in python and
intended to be used as a python library. This code didn’t had any
license note on the project page either, but we contacted the author
and he licensed it under Creative Commons Attribution 3.0 United
States License. Since it’s just a cache of DNS information, it used
gethostbyname() from the socket module. We changed it to use a
function we implemented, gethostfromDNS(), to send the necessary DNS
messages to get the information from a server. For the cryptography
part we’ve also used slownacl from dnscurve [1]. We didn’t implemented
the ability to resolve names recursively on PyDNSCache, so we
hardcoded the server public key inside the code.

(ii) dnspythoncurve.tar.bz2 — Since solution (i) was unable to
resolve names recursively, we decided to use dnspython [8], which
provides a lot of helper functions to deal with DNS. We’ve added
DNSCurve extensions to it and also added a recursive resolver.
dnspython [4] is released under a BSD-style license. Since recursive
resolution works we can get the server name to check if it a DNSCurve
enabled server and, if so, obtain it’s public key.

We’ve tested pymdscurve and dnspythoncurve under a scenery with two
servers, one configured as authority for .com and other as authority
for example.com, in order to test recursive resolution. Both config
files are shipped in pymdscurve package.

We plan to send patches back to all projects we’ve added code to. We
have also added some code to some dns helper functions on dnscurve
[1], outside of slownacl

[0] http://fisl.softwarelivre.org
[1] http://dnscurve.org
[2] http://cr.yp.to/djb.html
[3] http://cr.yp.to/djbdns.html
[4] http://jprvita.wordpress.com
[5] http://sourceforge.net/projects/pymds/
[6] http://www.rbgrn.net/projects
[7] http://github.com/mrd/dnscurve/tree/master
[8] http://www.dnspython.org/
[9] http://www.las.ic.unicamp.br/~joaopaulo/arena/