ipset et shorewall

Posted on Wed 28 August 2019 in Internet

Edit 2019-09-01 : j'ai mis le rafraîchissement en place toute les heures, c'est efficace a en juger les graphes Fail2ban.

ipset

--

Récemment j'ai pu faire la découverte d'ipset, une extension kernel Linux qui permet de faire des listes d'adresses ipv4/ipv6 et sous-réseaux utilisables avec iptables (et donc shorewall)

C'est très pratique quand vous en avez ras le bol de vous faire poutrer des services (SSH/FTP/Mail/etc) par des robots, fail2ban c'est bien mais si on peut bloquer le gros des méchants déjà connus c'est mieux.

Pour faire simple et à la main, il faut créer une liste en définissant son type (net/ip) puis l'alimenter :

## creation des sets
ipset create blacklist_net -exist hash:net family inet hashsize 16777216 maxelem 16777216 
ipset create blacklist_ipv4 -exist hash:ip family inet hashsize 16777216 maxelem 16777216
## alimentation d'une liste
ipset add blacklist_ipv4 8.8.8.8
ipset add blacklist_net 192.168.12.0/24

Exemples idiots mais vous voyez ou je veux en venir. Une fois la liste créé on peut l'utiliser dans une règle shorewall dans le fichier /etc/shorewall/rules par exemple :

DROP       net:+blacklist_ipv4 $FW
DROP        net:+blacklist_net  $FW
DROP        $FW         net:+blacklist_net
DROP        $FW         net:+blacklist_ipv4

Pour être plus efficace, et parce qu'alimenter ip par ip c'est pas l'objectif, il existe un projet open-source très bien fourni, Firehol, qui regroupe pour les besoins de sa solution un ensemble de listes d'adresses IP mises à jour régulièrement, toutes les heures voir toutes les minutes pour certaines.

Pour automatiser :

  • Première solution, utiliser la solution Firehol
  • Deuxième solution, pisser un script qui va télécharger les listes qui me plaisent et les bidouiller pour les utiliser dans mes ipset derrière.

J'ai mis en ligne une première ébauche d'un script bash+python qui fait tout ça sur mon dépôt Git : https://git.k3nny.fr/Tools/ipset_updater

Note : d'un point de vu technique, l'ajout des ip/subnet par une boucle python ou bash est beaucoup trop long, ipset permet l'import massif en utilisant la restauration de fichier, c'est cette méthode qui est utilisé (voir le script : https://git.k3nny.fr/Tools/ipset_updater/src/branch/master/ipset_update.sh )

Une fois le script lancé on obtient ça :

* 2019-08-28 20:00:10 Runinng list update
Reading lists of URL to download
= Update ipv4
- Downloading spamhaus
- Downloading bi_any_2_7d
- Downloading blocklist
- Downloading stopforumspam
- Downloading haley_ssh
- Downloading blocklist_ssh
- Downloading bi_any_2_1d
- Downloading bi_any__1_7d
- Downloading bi_any_0_1d
- Downloading bi_any_2_30d
= Update net
- Downloading ru
- Downloading emerging
- Downloading cn2
- Downloading cn
- Downloading bogons
- Downloading firehol
- Downloading pk
- Downloading sa
- Downloading kor
= Saved 280625 elements to ipset_ipv4.set
= Saved 24751 elements to ipset_subnets.set
* Create ipset blocklists if not already existing
* Import lists into ipset
== Import ipv4 ipset
== Import subnets ipset
* Saving ipset
* Cleanup ipset files

Avec les listes incluses ça fonctionne déjà assez bien, je constate moins de tentative de connexion ssh intempestives, à vous de faire votre choix de blocage en fonction de vos besoins (blocage par pays, listes de blocages).

  • Je ne suis pas encore passé à Debian Buster, ni à nftables, visiblement nftables implémente les listes directement sans passer par une extension comme ipset.
  • J'ai commencé à modifier le script pour prendre en charge les listes ipv6 mais j'ai eu la flemme

Des ressources pour gratter :


Les buckets s3 c'est comme les FTP free

Posted on Wed 28 August 2019 in Non classé

En surfant sur les internets je suis malencontreusement tombé sur un bucket Amazon S3 utilisé par un site que je consultais.

Le problème avec ce service proposé par Amazon c'est qu'il est insécurisé par défaut : https://www.upguard.com/blog/s3-security-is-flawed-by-design .

\<salt>Pour caricaturer , auparavant les développeurs web crados y allaient à grand coup de chmod 777 à tout va sur le FTP, désormais on fout tout dans un bucket s3 et on l'ouvre en public. \</salt>

Un bucket s3 ouvert en public = tout le bucket accessible à tout va et à n'importe qui. En fouillant dans ce seau, je suis tombé sur des dump de la base SQL de production (oh bah merde alors).

Cela m'a permis d'apprendre à jouer avec les buckets, si jamais vous tombez sur une instance ouverte un jour, voici un script python qui permet dumper la liste de touts les objets présents (remplacer "bucket-tout-moisi") :

#!/usr/bin/python3
import boto3
import json
from botocore import UNSIGNED
from botocore.client import Config

client = boto3.client("s3", config=Config(signature_version=UNSIGNED))

paginator = client.get_paginator("list_objects_v2")

data = []
for page in paginator.paginate(Bucket="bucket-tout-moisi"):
    for elem in page["Contents"]:
        data.append(elem["Key"])

with open('output.json', 'w') as outfile:
    json.dump(data, outfile)

On creuse et on trouve que ce dump SQL est une base PostgreSQL. Si vous êtes sous Win10, je vous conseille d'installer un sous-système Linux (debian-wsl) + VcXsrv + Terminator puis d'installer postgresql, ça va vite, on importe le dump puis avez un outil simple comme PgAdmin on regarde ce qu'il y'a de beau à gratter.

Oh surprise, cette base contient 2600+ utilisateurs, hash de mot de passe, adresses, des données personnelles, etc,etc.

La table "users" est intéressante elle contient des hashs de mot de passe au format bcrypt, c'est à dire un sel différent pour chaque utilisateur + hash du mot de passe :

$2y$10$wxeXGxk6YJTN8MPXFAeoLewBJ6toW88x.xqiNq7c/Ip0Y8MYhD0DO

C'est pas mal du tout puisque ça permet en cas de fuite de la base de données d'éviter des attaques par table arc-en-ciel.

On peut quand même retrouver quelques mots de passe en utilisant Hashcatet un dictionnaire de mots de passe, en l’occurrence c'est un site français donc j'ai pris la liste des 5000 mots de passe Français les plus fréquents dans le projet Richelieu : https://github.com/tarraschk/richelieu

PS : si un de vos mot de passe est dans cette liste, bon, voilà hein.

Hashcat demande énormément de puissance de calcul puisque pour chaque sel et chaque élément du dictionnaire il va calculer le hash de mot de passe correspondant puis comparer avec tous les hashs de mots de passes de la liste. Temps estimé avec une GTX 1080 : 13h.

En laissant tourner quelques minutes, j'ai pu trouver 18 mots de passes simples.

En corrélant les résultat avec la liste des emails on obtient une liste comme celle-ci :

xxxxxxxxxxxxxxxxxx@wanadoo.fr:$2y$10$wxeXGxk6YJTN8MPXFAeoLewBJ6toW88x.xqiNq7c/Ip0Y8MYhD0DO:toto
xxxxxxxxxxxxxxxxxx@free.fr:$2y$10$wxeXGxk6YJTN8MPXFAeoLewBJ6toW88x.xqiNq7c/Ip0Y8MYhD0DO:motdepasse
xxxxxxxxxxxxxxxxxx@gmail.com:$2y$10$wxeXGxk6YJTN8MPXFAeoLewBJ6toW88x.xqiNq7c/Ip0Y8MYhD0DO:pierre
xxxxxxxxxxxxxxxxxx@numericable.fr:$2y$10$wxeXGxk6YJTN8MPXFAeoLewBJ6toW88x.xqiNq7c/Ip0Y8MYhD0DO:dodo
xxxxxxxxxxxxxxxxxx@laposte.net:$2y$10$wxeXGxk6YJTN8MPXFAeoLewBJ6toW88x.xqiNq7c/Ip0Y8MYhD0DO:coucou
xxxxxxxxxxxxxxxxxx@sfr.fr:$2y$10$wxeXGxk6YJTN8MPXFAeoLewBJ6toW88x.xqiNq7c/Ip0Y8MYhD0DO:password
etc...

Les combinaisons email+mot de passe sont très intéressantes puisqu'en général les gens sont fainéants et réutilisent le même mot de passe partout, donc il y'a fort à parier qu'on puisse se connecter avec les email/mot de passe à divers comptes Facebook/Mail/Twitter/etc

Après avoir gratté et appris à faire joujou avec Hashcat et les buckets s3 j'ai pris contact avec l'éditeur du site en défaut qui à depuis pris les mesures nécessaires pour faire le ménage.


DoH - DoT - Pi-hole - Unbound

Posted on Sun 19 May 2019 in Internet

Au commencement, pi-hole

Projet intéressant qu'est Pi-Hole : https://pi-hole.net/

pihole

C'est une solution qui installe de manière automatique un DNS menteur afin de s'éviter tous les sites qui hébergent de la publicité, trackers, etc..

Si vous disposez d'un RaspberryPi qui traine dans un coin à la maison c'est une excellente solution à mettre en place.

C'est bien mais pas top

Si vous disposez comme moi d'un serveur dédié ou d'une machine virtuelle hébergée, il pourrait être intéressant de mettre la chose en place en cas de déplacement ou pour son smartphone en 4G.

Il suffirait pour cela d'exposer votre serveur DNS Pi-Hole publiquement (TCP 53), personnellement je ne le fait pas directement, uniquement au travers d'un tunnel VPN.

Je suis tombé sur cet article très bien construit sur l'installation en plusieurs étapes d'un serveur DNS over HTTPS (DoH) + DNS over TLS (DoT) + Pi-hole + Unbound :

https://www.aaflalo.me/2018/10/tutorial-setup-dns-over-https-server/

  • DNS over HTTPS/DoH c'est la possibilité d'effectuer des requêtes DNS chiffrées sur HTTPS/TLS (TCP 443) via Nginx.
  • DNS over TLS/DoT c'est la peu ou prou la même chose, DNS sur TLS directement mais sur un port spécifique (TCP 853).
  • Pi-hole, cf. juste avant
  • Unbound est un recurseur DNS simple à installer et configurer.

Le fonctionnement est le suivant :

pihole

Les cas d'usage

  • Connecté en VPN, vous utilisez le DNS interne du serveur, en l'occurence pi-hole, vous beneficiez du DNS menteur/filtrage publicitaire. Pratique à condition que le port de votre VPN ne soit pas filtré.
  • Sur mobile Android à partir de la version 9, vous pouvez préciser un DNS privée (DNS over TLS, DoT) et vous utilisez alors votre DNS menteur quelque soit le réseau WiFi ou 4G.
    • Test effectué avec Chrome Android, pas de bloqueur en extension, les pages normalement infestées de publicités sont visitables.
    • Un détail cependant, le protocole nécessite d'utiliser le port TCP 853, donc filtrable.
  • Sur un poste de travail Windows/Linux/OSX, au moyen d'un client approprié (
    https://dnscrypt.info/implementations/) pour le protocole DNS over HTTPS/DoH, vous utilisez votre DNS menteur, y compris au travers de proxy HTTP.

Pour essayer/utiliser

Pour utiliser DoT sur votre mobile :

Options > Réseau > Avancé > DNS privée > dns.k3nny.fr

Pour tester DoH dans un navigateur :

https://dns.k3nny.fr/dns-query?name=www.toto.fr&type=A

{
    Status: 0,
    TC: false,
    RD: true,
    RA: true,
    AD: false,
    CD: false,
    Question: [
    {
        name: "www.toto.fr.",
        type: 1
    }
    ],
    Answer: [
    {
        name: "www.toto.fr.",
        type: 1,
        TTL: 3867,
        Expires: "Sun, 19 May 2019 15:46:27 UTC",
        data: "46.105.57.169"
    }
    ]
}

Pour aller plus loin

Pour comprendre plus en détails tous les enjeux et la technique derrière DoH/DoT, je vous invite à lire l'excellent billet de Stephane Bortzmeyer :

https://www.bortzmeyer.org/8484.html .

Et si au passage l'envie vous prend, je vous conseille d'acheter son livre "Cyberstructure" il est excellent.

https://cyberstructure.fr/


Déployer et configurer Mozilla Firefox en entreprise

Posted on Sat 01 July 2017 in Non classé

Mozilla

Quel dilemme que celui de déployer Mozilla Firefox correctement en entreprise/collectivité.

À l'opposé de Google Chrome,qui propose un installer MSI ainsi qu'un modèle d'administration ADMX très complet, Mozilla Firefox ne propose en tout et pour tout qu'un maigrichon Mozilla Firefox ESR (pour Extended Support Release) et pas de modèle d'administration du tout.

Des solutions existent, CCK2 ou encore FrontMotion Firefox, qui emulent le comportement de GPOs pour forcer des paramètres dans les confs de Firefox, c'est bien mais pas optimal (manque d'information en cas d'échec d'installation, pas assez souple).

Alors que faire ?

Se résigner à utiliser un navigateur qui remonte moultes informations à ses concepteurs ? Non, continuons d'utiliser Firefox mais déployons le correctement et configurons le de manière pérenne et sécurisée.

Vous l'aurez peut être deviné, on utilise à cet effet WAPT, la solution open-source de déploiement logiciel.  Et coup de chance Mozilla Firefox ESR est déjà packagé !

Voyons un peu ce qui est fait dans le paquet Firefox :

# -*- coding: UTF-8 -*-
from setuphelpers import *

uninstallkey = []


def install():
    version = control.version.split('-',1)[0]
    ukey = 'Mozilla Firefox %s ESR (x86 fr)'%version

    exe = 'Firefox Setup %sesr.exe'%version
    install_exe_if_needed(exe,'-ms',key=ukey,min_version=version,killbefore='firefox.exe')

    print("Disabling auto update")
    filecopyto("mozilla.cfg",makepath(install_location('Mozilla Firefox %s ESR (x86 fr)' %version )))
    filecopyto("local-settings.js",makepath(install_location('Mozilla Firefox %s ESR (x86 fr)' %version ),"defaults","pref"))

    print ("Disabling profile migration from ie")
    filecopyto("override.ini",makepath(install_location('Mozilla Firefox %s ESR (x86 fr)' %version ),"browser"))

    print ("Override User UI")
    ensure_dir(makepath(install_location('Mozilla Firefox %s ESR (x86 fr)' %version ),"browser","defaults","profile","chrome",""))
    filecopyto("userChrome.css",makepath(install_location('Mozilla Firefox %s ESR (x86 fr)' %version ),"browser","defaults","profile","chrome"))

    """
    print ("Deploy extensions")
    ensure_dir(makepath(programfiles32,"Mozilla Firefox","browser","extensions",""))
    copytree2("extensions",makepath(programfiles32,"Mozilla Firefox","browser","extensions"))
    """

On peut voir que Mozilla Firefox est installé selon les recommandations de la documentation officielle, des paramétrages par défaut sont appliqués dans ce paquet :

  • Désactivation de la mise à jour automatique
  • Désactivation de la migration depuis Internet Explorer)
  • Application de préférences par défaut (mozilla.cfg et local-settings.js) :

local-settings.js - indiquer le fichier de personnalisation

// Process mozilla.cfg in FireFox root directory.
pref("general.config.obscure_value", 0);
pref("general.config.filename","mozilla.cfg");

mozilla.cfg - indiquer les préférences du navigateur

// Disable Auto Updates
pref("app.update.enabled", false);
pref("extensions.update.enabled", false);
pref("app.update.service.enabled", false);

//disable feedback
pref("toolkit.telemetry.prompted",2);

//disable browser rights info toolbar
pref("browser.rights.3.shown", true);
pref("browser.rights.3.shown",true);

// disable default browser check
pref("browser.shell.checkDefaultBrowser", false);
pref("browser.startup.homepage_override.mstone", "ignore");
pref("general.smoothScroll", false);

//configurer proxy detection automatique wpad
pref("network.proxy.type",4);

//disable ipv6
pref("network.dns.disableIPv6",true);

//disable pdf integre
pref("pdfjs.disabled",true);

//disable cache 
pref("network.http.use-cache",true);
pref("browser.cache.disk.enable",false);


//disable migration
pref("profile.confirm_automigration",false);
pref("profile.migration_behavior",0);
pref("profile.migration_directory", "")


// Clear privacy data
// on shutdown
lockPref("privacy.clearOnShutdown.cache", true);
lockPref("privacy.clearOnShutdown.downloads", false);
defaultPref("privacy.clearOnShutdown.formdata", false);
lockPref("privacy.clearOnShutdown.passwords", false);
lockPref("privacy.clearOnShutdown.sessions", false);
lockPref("privacy.clearOnShutdown.siteSettings", false);
defaultPref("privacy.clearOnShutdown.cookies", false);
defaultPref("privacy.clearOnShutdown.history", false);
defaultPref("privacy.clearOnShutdown.offlineApps", false);
lockPref("privacy.sanitize.sanitizeOnShutdown", false);

// Changes to Root Certificates in Firefox on Windows
lockPref("security.enterprise_root.enable", true);

Dans ce paquet, l'installation et la configuration sont effectuée d'un seul tenant.

Problème pour ma structure, le proxy est définit spécifiquement dans la configuration de Firefox (absence de proxy.pac / wpad). Voici rapidement ce qu'il faut modifier dans le fichier mozilla.cfg

//set proxy server settings
 lockPref("network.proxy.ftp", "srvproxy.domain.lan");
 lockPref("network.proxy.ftp_port", 3128);
 lockPref("network.proxy.gopher", "srvproxy.domain.lan");
 lockPref("network.proxy.gopher_port", 3128);
 lockPref("network.proxy.http", "srvproxy.domain.lan");
 lockPref("network.proxy.http_port", 3128);
 lockPref("network.proxy.no_proxies_on", "localhost, 127.0.0.1, *.domain.lan");
 lockPref("network.proxy.type", 1);
 lockPref("network.proxy.share_proxy_settings", true); // use the same proxy settings for all protocols

Ainsi la préférence est bloquée dans la configuration de Firefox et les utilisateurs ne pourront pas la modifier.

Pour plus de sécurité, j'installe l'extension uBlock, le paquet existe déjà : paquet WAPT uBlock

On décline l'installation de Firefox comme ceci :

  • Paquet Mozilla Firefox sans personnalisation
  • Paquet extension uBlock
  • Paquet de configuration Firefox

En utilisant le principe de dépendance de WAPT, je suis assuré d'avoir déployé correctement ces trois éléments.

Simon des Fourmis du Web a déjà fait ce travail de séparation de la configuration et de l'installation :

Modifiez le paquet de configuration à votre convenance et à vous Mozilla Firefox déployé correctement !

Sources :