Software « Internet and programming stuff

Cet article est issu d’une précédente version de mon weblog, mais perdu dans l’oubli. Il remonte à Avril 2008. Je le remets ici à jour.

Un problème au taf, si ce n’est le prix du café au distributeur, est la non possibilité de se connecter sur sa box avec son ssh. Et bien, Dag Wiers propose une solution propre (qui n’oblige pas à installer son sshd sur le 443 et d’utiliser corkcrew), mais d’utiliser proxytunnel qui marche plutot bien.

Pour résumer la chose, cela implique d’avoir un serveur avec un apache où on a la main dessus, mod_proxy/mod_proxy_connect et mod_proxy_http d’installés, possiblement mod_ssl (mais ça crée un petit problème de taille à cause d’une non-feature d’apache2), et un peu de configuration.

N’ayant pas la main sur mon serveur au taf, c’est pas facile pour tester. J’ai donc aussi installé privoxy en local pour faire mes tests. Par contre, après utilisation, j’ai pas réussi à faire passer un CONNECT sur un port de destination 80, privoxy ne voulait pas, et le limit-connect semblait pas vouloir être changé. En même temps il était 5h du mat, j’ai peut être oublié un truc.

Alors, voilà la conf que j’ai faite sur ma debian (serveur ssh):

Server ssh sur le 22 et 2222;
Apache2 de base installé (bon, avec php mais là on s’en fiche);

On configure le bouzin:

remote# a2enmod ssl
remote# a2enmod proxy
remote# a2enmod proxy_connect

Il faut générer un certificat (.pem) pour notre nouveau serveur https. Pour çà, y a un super outil dans debian, et c’est make-ssl-cert:

remote# make-ssl-cert /usr/share/ssl-cert/ssleay.cnf /etc/apache2/ssl/apache.pem
remote# chmod a+r /etc/apache2/ssl/apache.pem

Et un virtualhost sur le 443, qui inclue directement les directives pour mod_ssl et mod_proxy:

<VirtualHost spine.minithins.net:443>
SSLEngine On
SSLCertificateFile /etc/apache2/ssl/apache.pem

ServerAdmin mycroft@minithins.net
DocumentRoot /home/web/minithins.net
ServerName cns.minithins.net

HostnameLookups On

ProxyRequests on
AllowCONNECT 2222
ProxyVia on

<proxy *>
Order deny,allow
Deny from all
Allow from client.monkeyz.eu
</proxy>
</VirtualHost>

Un redémarrage d’apache, et on va tester avec stunnel:

remote# service apache2 restart
Restarting web server: apache2 ... waiting .

client# apt-get install stunnel
...
client# stunnel -f -c -d 12345 -r spine.minithins.net:443
2011.04.02 12:22:22 LOG5[11844:140613013587712]: stunnel 4.29 on x86_64-pc-linux-gnu with OpenSSL 0.9.8o 01 Jun 2010
2011.04.02 12:22:22 LOG5[11844:140613013587712]: Threading:PTHREAD SSL:ENGINE Sockets:POLL,IPv6 Auth:LIBWRAP
2011.04.02 12:22:22 LOG5[11844:140613013587712]: 500 clients allowed
...

Sur une autre console:

client# telnet localhost 12345
Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
CONNECT spine.minithins.net:2222 HTTP/1.0

Connection closed by foreign host.

Hum. Ca ne fonctionne pas.

Un peu de recherche (ou de triche, car Dag Wieers donne la réponse), Apache, ou plus précisement le mod_proxy_connect est buggé. Mais un patch existe. Il faut appliquer un des patchs proposés (surement le dernier en date, dans mon exemple celui pour 2.2.16), et lancer un coup de rebuild des packages apache via les scripts debian:

remote# cd /tmp
remote# apt-get install devscripts fakeroot gcc bzip2 dpkg-dev
...
remote# apt-get build-dep apache2.2-common
...
remote# apt-get source apache2.2-common
...
remote# cd apache2-2.2.16/modules/proxy
remote# wget -O mod_proxy_connect.diff "https://issues.apache.org/bugzilla/attachment.cgi?id=26225"
remote# patch -p0 < mod_proxy_connect.diff

… et c’est parti pour tout rebuilder: …

remote# debuild -us -uc
remote# cd /tmp/apache2-2.2.16
... (long) ...

… et finalement on met à jour le package apache2.2-bin:

remote# dpkg -i ../apache2.2-bin_2.2.16-6+squeeze1_amd64.deb
(Reading database ... 48179 files and directories currently installed.)
Preparing to replace apache2.2-bin 2.2.16-6+squeeze1 (using .../apache2.2-bin_2.2.16-6+squeeze1_amd64.deb) ...
Unpacking replacement apache2.2-bin ...
Setting up apache2.2-bin (2.2.16-6+squeeze1) ...
Processing triggers for man-db ...
remote # service apache2 restart
Restarting web server: apache2 ... waiting .

On reteste avec stunnel:

client# telnet localhost 12345
Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
CONNECT spine.minithins.net:2222 HTTP/1.0

HTTP/1.0 200 Connection Established
Proxy-agent: Apache/2.2.16 (Debian)

SSH-2.0-OpenSSH_5.5p1 Debian-6

Yay ! First step donne. Plus qu’à tester via un proxy http et utiliser le client ssh.

Pour tester, j’installe en local un privoxy:

client# apt-get install privoxy

On pourra modifier l’adresse d’écoute de privoxy (localhost:8118), et le modifier (par exemple, 127.0.0.1:8080 pour éviter qu’il prenne l’adresse ipv6 au lieu de la v4).

On crée un profil ssh en accord, dans ~/.ssh/config:

Host spine-proxy
DynamicForward 1080
ServerAliveInterval 30
# proxy.dev pointe vers localhost car mon proxy est sur localhost.
ProxyCommand proxytunnel -v -X -p proxy.dev:8118 -r spine.minithins.net:443 -d %h:%p -H "User-Agent: Mozilla/4.0 (compatible; MSIE 6.0; Win32)\n"

On notera dans mon exemple que j’utilise le flag -X. Il permet de préciser que j’utilise une connection sécurisée ssl entre les deux proxy (entre mon proxy et le mod_proxy de mon apache). Il est possible que le proxy que vous utiliserez ne l’aime pas. Dans ce cas, n’hésitez pas à joeur avec -X, -e et -E).

Et si on restestait:

client# ssh spine-proxy
...
Tunneling to spine-proxy:2222 (destination)
Communication with remote proxy:
-> CONNECT spine-proxy:2222 HTTP/1.0
-> Proxy-Connection: Keep-Alive
-> User-Agent: Mozilla/4.0 (compatible; MSIE 6.0; Win32)\n
<- HTTP/1.1 502 Proxy Error
HTTP return code: 502 Proxy Error
...

What ?!
Dans les logs, on voit:

[error] [client 78.229.134.1] proxy: DNS lookup failure for: spine-proxy returned by spine-proxy:2222

Il n’aime pas trop que j’utilise « spine-proxy » comme alias. Solution, retirer le -d %h:%p (et le remplacer par le vrai host de la machine), ou changer l’alias. Après correction:

client# ssh -v spine
OpenSSH_5.5p1 Debian-4ubuntu5, OpenSSL 0.9.8o 01 Jun 2010
...
debug1: Executing proxy command: exec proxytunnel -v -X -p proxy.dev:8118 -r spine.minithins.net:443 -d spine:2222 -H "User-Agent: Mozilla/4.0 (compatible; MSIE 6.0; Win32)\\n"
...
SSL local to remote proxy enabled
Local proxy proxy.dev resolves to 127.0.0.1
Connected to proxy.dev:8118 (local proxy)

Tunneling to spine.minithins.net:443 (remote proxy)
Communication with local proxy:
-> CONNECT spine.minithins.net:443 HTTP/1.0
-> Proxy-Connection: Keep-Alive
-> User-Agent: Mozilla/4.0 (compatible; MSIE 6.0; Win32)\n
<- HTTP/1.0 200 Connection established
<- Proxy-Agent: Privoxy/3.0.16

Tunneling to spine:2222 (destination)
Communication with remote proxy:
-> CONNECT spine:2222 HTTP/1.0
-> Proxy-Connection: Keep-Alive
-> User-Agent: Mozilla/4.0 (compatible; MSIE 6.0; Win32)\n
<- HTTP/1.0 200 Connection Established
<- Proxy-agent: Apache/2.2.16 (Debian)

Tunnel established.
debug1: Remote protocol version 2.0, remote software version OpenSSH_5.5p1 Debian-6
...
remote#

Et ça marche ! Rock’n'Roll ! :°)

Pour BUTT j’ai voulu un mini système de plugins/modules afin de rajouter ou modifier du code sans redémarrer mon process. Et Python propose nativement cela grâce au module imp. On va utiliser spécifiquement la procédure load_source qui permet de charger un fichier source, de le parser, et de retourner son objet Module.

Illustrons. Voici le code du très simple module à importer:

#!/usr/bin/env python

class TestModule:
def __init__(self):
pass

def myfunction(self):
print "Calling myfunction"

Procédure de chargement du module:

#!/usr/bin/env python

import os, shutil
import imp

def load_module(module_name):
print "Loading module %s" % module_name

modfile = os.path.join(os.getcwd(), module_name + '.py')

module = imp.load_source(module_name, modfile)

print module
# Returns <module 'test' from '/home/mycroft/imp/test.pyc'>

print dir(module)
# Permet de lister les differents attributs de l'objet importé.
# Returns ['TestModule', '__builtins__', '__doc__', '__file__', '__name__', '__package__']

for objname in dir(module):
# Je veux specifiquement les modules suffixés "Module":
if objname.endswith('Module'):
modclass = getattr(module, objname)
print modclass
# Returns test.TestModule
print dir(modlass)
# Returns ['__doc__', '__init__', '__module__', 'myfunction']
return modclass

return None

Il ne reste plus qu’à montrer par l’exemple le fonctionnement et le reload d’un module dans le main:

if __name__ == '__main__':

modclass = load_module('test')
instance = modclass()
instance.myfunction()

# We move away test.py, and copy test_new.py to test.py.

print

shutil.move('test.py', 'test_old.py')
shutil.move('test_new.py', 'test.py')

modclass = load_module('test')
instance = modclass()
instance.myfunction()

shutil.move('test.py', 'test_new.py')
shutil.move('test_old.py', 'test.py')

Qui nous donnera:

$ ./modules.py
Loading module test
<module 'test' from '/home/mycroft/imp/test.py'>
['TestModule', '__builtins__', '__doc__', '__file__', '__name__', '__package__']
test.TestModule
['__doc__', '__init__', '__module__', 'myfunction']
Calling myfunction

Loading module test
<module 'test' from '/home/mycroft/imp/test.py'>
['TestModule', '__builtins__', '__doc__', '__file__', '__name__', '__package__']
test.TestModule
['__doc__', '__init__', '__module__', 'myfunction']
Calling (new) myfunction

Le code modifié (ici test.py a été remplacé par test_new.py, qui contient du code modifié) a bien été relu par python et est à présent utilisé.

Quand il faut écrire une application réseau, les développeurs Python n’ont qu’un mot à la bouche: Twisted. Il s’agit d’un moteur réseau « event-driven », et comprend un grand nombre de protocoles de niveau 3 (TCP, UDP, socket unix) et 7 (HTTP, SSH, IMAP, IRC…).

On va donc simplement voir ici comment coder un bot irc (quasi) complet. On prend la doc « Writing Clients » et celle de la classe irc.IRCClient.

On a donc besoin d’écrire une classe de base pour le bot, et sa factory utilisable dans le reactor de twisted.

#!/usr/bin/env python

import sys

from twisted.words.protocols import irc
from twisted.internet import protocol
from twisted.internet import reactor

class QuickBot(irc.IRCClient):
def _get_nickname(self):
return self.factory.nickname
nickname = property(_get_nickname)

def signedOn(self):
self.join(self.factory.channel)
pass

def privmsg(self, user, channel, msg):
pass

class QuickBotFactory(protocol.ClientFactory):
protocol = QuickBot

def __init__(self, channel, nickname):
self.channel = channel
self.nickname = nickname

def clientConnectionLost(self, connector, reason):
connector.connect()

def clientConnectionFailed(self, connector, reason):
connector.connect()

Et le point d’entrée:

if __name__ == "__main__":
reactor.connectTCP('localhost',
6667,
QuickBotFactory('#bot', 'quicky'))
reactor.run()

Et du coup, j’ai un peu étendu le truc et j’ai créé Another Python Bot Using The Twisted Framework, aka Butt, avec un système de modules chargeables dynamiquement (avec imp) et l’utilisation de python-yaml pour les fichiers de conf. Un bon exemple pour commencer un bot IRC ! Les sources sont disponibles sur le projet Butt sur mon compte Github.

Je suis en train de développer sygit, une interface web light pour naviguer dans un dépôt git. J’ai alors décidé de mettre au clair mes dépots et de monter ma propre architecture d’hosting git, sous debian.

Emplacement des dépôts

Les dépôts vont être accessible via ssh (lecture+écriture) et via git-daemon (par dessus d’inetd, en lecture seule). On décide de créer un groupe « git-users » pour ceux qui auront accès aux dépots. On édite donc /etc/group:

git-users:x:199:mycroft,patrick

Le dépôt sera physiquement dans /git. On le crée (et on n’oublie pas le –bare !):

# mkdir -p /git/newproject
# cd !-1:2
# git --bare init
Initialized empty Git repository in /git/newproject/

On pourra également réutiliser un projet déjà existant dont on créerait un dépôt bare:

# cd /git
# git clone --bare git://github.com/mycroft/sygit.git
Cloning into bare repository sygit.git...
remote: Counting objects: 48, done.
remote: Compressing objects: 100% (47/47), done.
remote: Total 48 (delta 21), reused 0 (delta 0)
Receiving objects: 100% (48/48), 8.77 KiB, done.
Resolving deltas: 100% (21/21), done.

Pour ces projets, il faudra changer la configuration et leur indiquer qu’il s’agit d’un dépôt partagé sur la base du groupe. Pour cela, il faut modifier la propriété core.sharedRepository:

# cd sygit.git
# git repo-config core.sharedRepository group

On n’a plus qu’à fixer les permissions manuellement:

# chgrp -R git-users /git/sygit.git
# find /git/sygit.git -type d -exec chmod g+ws {} \;

Mise en place de git-daemon

On utilise inetd pour partager les dépôts. On édite donc /etc/inetd.conf …

git stream tcp nowait nobody /usr/bin/git git daemon --inetd --verbose --export-all --base-path=/git /git

… et on redémarre le daemon:

/etc/init.d/openbsd-inetd restart

Testons !

Sur ma machine de travail, on clone le dépôt en read-only:

$ git clone git://mkz.me/sygit.git
Initialized empty Git repository in /tmp/testgit/sygit/.git/
remote: Counting objects: 48, done.
remote: Compressing objects: 100% (26/26), done.
remote: Total 48 (delta 21), reused 48 (delta 21)
Receiving objects: 100% (48/48), 8.77 KiB, done.
Resolving deltas: 100% (21/21), done.

$ cd sygit
$ git remote -v
origin git://mkz.me/sygit.git (fetch)
origin git://mkz.me/sygit.git (push)

Pour le moment, le seul remote configuré est le serveur git. Celui là étant en read-only, il va faloir le modifier pour pouvoir push:

$ git remote rm origin
$ git remote add origin mycroft@mkz.me:/git/sygit.git
$ git remote -v
origin mycroft@mkz.me:/git/sygit.git (fetch)
origin mycroft@mkz.me:/git/sygit.git (push)

Il ne reste plus qu’à modifier un fichier, le commiter et le pusher:

$ vim README
$ git add README
$ git commit -m "Update README"
[master 2d98128] Update README
1 files changed, 6 insertions(+), 0 deletions(-)
$ git push origin master
Counting objects: 5, done.
Delta compression using up to 2 threads.
Compressing objects: 100% (3/3), done.
Writing objects: 100% (3/3), 375 bytes, done.
Total 3 (delta 2), reused 0 (delta 0)
To mycroft@mkz.me:/git/sygit.git
826d9b0..2d98128 master -> master

Et voilà !

Le code est très inspiré du chapitre « Reading the Request body » du livre Writing Apache Modules with Perl and C.

Pour expérimenter un peu les modules Apache (suite à un nouvel entretien d’embauche), je me suis mis en tête de coder un mini service via un module pour générer des nombres aléatoire.

Le service devra être très simple et sera exécuté lors de l’appel de l’url http://localhost/randomint, et l’on pourra l’appeler en POST en donnant, par exemple, l’argument count pour préciser le nombre d’entiers aléatoires que l’on désire.

Et finalement, l’étape la plus complexe aura été de reconstruire le body envoyé lors de la requête POST, et de le parser pour en sortir un tableau associatif (key/value).

Reconstruction du body

Cette fonction attend l’envoie du body par le client et reconstruit en un seul block toutes les données envoyées.

static int chunk_reader(request_rec *r, const char **rbuf)
{
int ret;

if(OK != (ret = ap_setup_client_block(r, REQUEST_CHUNKED_ERROR))) {
return ret;
}

if(ap_should_client_block(r)) {
char argsbuffer[HUGE_STRING_LEN];
int rsize, len_read, rpos=0;
long length = r->remaining;

*rbuf = apr_pcalloc(r->pool, length + 1);

while(0 < (len_read = ap_get_client_block(r, argsbuffer, sizeof(argsbuffer)))) {
if ((rpos + len_read) > length) {
rsize = length - rpos;
}
else {
rsize = len_read;
}

memcpy((char*)*rbuf + rpos, argsbuffer, rsize);
rpos += rsize;
}
}

return ret;
}

Création du tableau associatif

Avec le block recomposé, on fait ensuite appel aux fonctions ap_getword ap_getword et aux fonctions apr_tables de apr afin de découper et stocker les différentes valeurs envoyées:

static int read_post(request_rec *r, apr_table_t **tab)
{
const char *data;
const char *key, *val, *type;
int ret = OK;

if(r->method_number != M_POST) {
return ret;
}

// On verifie que le content type soit bien application/x-www-form-urlencoded
type = apr_table_get(r->headers_in, "Content-Type");

if(strcasecmp(type, DEFAULT_ENCTYPE) != 0) {
return DECLINED;
}

if((ret = chunk_reader(r, &data)) != OK) {
return ret;
}

// Creation ou RAZ de la apr_table_t
if(*tab) {
apr_table_clear(*tab);
}
else {
*tab = apr_table_make(r->pool, 8);
}

// Tant qu'il y a des datas...
while(*data && (val = ap_getword(r->pool, &data, '&'))) {
key = ap_getword(r->pool, &val, '=');
ap_unescape_url((char*)key);
ap_unescape_url((char*)val);
apr_table_merge(*tab, key, val);
}

return OK;
}

Récupérer la bonne valeur

Une fois qu’on a le tableau associatif, il nous faut une fonction pour récupérer la valeur voulue:

int get_value(request_rec *r, const char *name)
{
apr_table_t *post_values = NULL;
apr_array_header_t *arr;
apr_table_entry_t *elt;

int i, ret, value;

if(OK != (ret = read_post(r, &post_values))) {
return -1;
}

if(NULL == post_values) {
return -1;
}

arr = apr_table_elts(post_values);
elt = (apr_table_entry_t*)arr->elts;

for(i = 0; i < arr->nelts; ++i) {
if(strcmp(elt[i].key, name) == 0
&& LONG_MIN != (value = strtol(elt[i].val, NULL, 10))) {
return value;
}
}

return -1;
}

Revenons au code du module lui-même…

Il ne reste plus qu’à coder le handler de génération, et rajouter les structures nécessaires pour le module:

static int mod_randomint_method_handler (request_rec *r)
{
int ret = OK, i, count = 8, new_count;
unsigned int random_value;

new_count = get_value(r, "count");

if(new_count > 0 && new_count < MAX_COUNT) {
count = new_count;
}

ap_set_content_type(r, "text/plain");

int random_fd = open("/dev/urandom", O_RDONLY);
for(i = 0; i < count; i ++) {
read(random_fd, (void*)&random_value, sizeof(random_value));
ap_rprintf(r, "%u\n", random_value);
}
close(random_fd);

// fprintf(stderr, "Count: %d\n", count);
// fflush(stderr);

return ret;
}

static void mod_randomint_register_hooks (apr_pool_t *p)
{
ap_hook_handler(mod_randomint_method_handler, NULL, NULL,APR_HOOK_LAST);
}

module AP_MODULE_DECLARE_DATA randomint_module =
{
STANDARD20_MODULE_STUFF,
NULL,
NULL,
NULL,
NULL,
NULL,
mod_randomint_register_hooks, /* callback for registering hooks */
}

Il ne reste plus qu’à compiler le code …:

apxs2 -c -a -i mod_randomint.c

… et le configurer dans httpd.conf:

LoadModule randomint_module /usr/lib/apache2/modules/mod_randomint.so

<Location /randomint>
SetHandler randomint-handler
</Location>

Et après un redémarrage d’apache:

$ curl http://localhost/randomint
4162010288
1220025110
2641785880

On pourra voir le résultat dans mes snippets et le télécharger dans mes projets directement.

Mise à jour:

J’ai oublié de filtrer par handler dans le code. On incluera donc dans mod_randomint_method_handler:

if(strcmp(r->handler, "randomint-handler")) {
return DECLINED;
}

Internet and programming stuff

Quelques notes à propos d'Internet, linux, de la programmation et d'autres choses…

Category Archives: Software

Se connecter proprement à ssh via un proxy web

Python: Chargement de fichiers sources en live

Ecrire un bot IRC grâce à Python et Twisted

Mise en commun d’un serveur git via ssh et mise à disposition à tous

Apache: Lire et découper le corps d’une requête POST dans un module Apache