LVM sous NetBSD est ancien et aujourd'hui difficilement utilisable, mais il existe aussi dump !

dump permet de faire des "dump", copies parfaites (et incrémentielles.. il y a 9 types de sauvegardes !) de bas niveau, du contenu d'un dossier (ou volume monté) vers un fichier.dump

On peut néanmoins faire une copie parfaite d'un dossier vers un autre !

A savoir, il est impératif de faire une sauvegarde parfaite (-0u) AVANT d'essayer un autre type de sauvegarde !!

Exemples :

- Sauvegarde complète initiale

cd /DESTINATION-SAUVEGARDE

dump -0u -f - /SOURCE-SAUVEGARDE | restore -rf -

- Sauvegarde incrémentielle

cd /DESTINATION-SAUVEGARDE

dump -1u -f - /SOURCE-SAUVEGARDE | restore -rf -

On peut également manipuler dump avec SSH, sshfs, NFS pour envoyer des copies sur des serveurs distants :
Exemple avec SSH :

dump -0u -f - /SOURCE-SAUVEGARDE | ssh utilisateur-distant@serveur-distant "cd /DESTINATION-SAUVEGARDE && restore -rf -"

miniIRCd est un serveur IRC minimaliste.
Pas de contrôle des utilisateurs entrants, pas d'authentification (autre qu'un mot de passe d'accès), juste du SSL.
ça peut servir dans certains cas...
On peut facilement écrire un filtre fail2ban et configurer le pare-feu pour limiter les risques.

(Installation effectuée sur un serveur NetBSD installé en mode "minimaliste")

Passez en root pour toute la procédure.


1) Installer git, python3 et openssl

pkgin -y in git python311 openssl tmux mozilla-rootcerts

mozilla-rootcerts install

2) Télécharger installer miniIRCd 

cd /tmp && git clone https://github.com/jrosdahl/miniircd.git && cd miniircd && cp miniircd /usr/pkg/bin/

3) Générer le certificat SSL autosigné et créer le chroot
- Modifiez les informations pour le certificat SSL auto-signé avant de copier/coller l'encart ci-dessous :

cat > /usr/pkg/etc/openssl/openssl-minimal.cnf <<EOL
[ req ]
default_bits       = 2048
default_md         = sha256
default_keyfile    = privkey.pem
prompt             = no
encrypt_key        = no

distinguished_name = req_distinguished_name

[ req_distinguished_name ]
C            = US
ST           = California
L            = San Francisco
O            = My Company
OU           = My Division
CN           = localhost
EOL

mkdir -p /var/jail/miniircd ; cd /var/jail/miniircd ; openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout miniircd.key -out miniircd.crt -config /usr/pkg/etc/openssl/openssl-minimal.cnf

4) Créer un lien symbolique pour Python3

ln -s /usr/pkg/bin/python3.11 /usr/pkg/bin/python3

5) Lancer le serveur en arrière-plan

tmux new-session -d -s MINIIRCD "/usr/pkg/bin/miniircd --listen=0.0.0.0 --ssl-cert-file=/var/jail/miniircd/miniircd.crt --ssl-key-file=/var/jail/miniircd/miniircd.key --verbose --chroot=/var/jail/miniircd --setuid=nobody --password 'Super-Mot-De-PAsse'" 

Sur Android, l'application CoreIRC Go (ou sa version payante) sont compatibles avec miniIRCd


Rappel des commandes IRC de base (compatibles avec miniIRCd) sur les clients type Hexchat :

- Rejoindre un canal ou en créer un :

/join #NOM-DU-CANAL-A-CREER-OU-A-JOINDRE

- Quitter le canal "#CANAL" avec un message d'au-revoir

/part #CANAL Au revoir tout le monde

- Changer de pseudonyme

/nick NouveauPseudo

- Envoyer le message "Bonjour" à l'utilisateur "Utilisateur"

/msg Utilisateur Bonjour !

- Envoyer un fichier à un utilisateur

/dcc send UTILISATEUR-DESTINATAIRE

Comment sécuriser un peu miniIRCd.

1) Mettre en place NPF :

echo "npf=YES" >> /etc/rc.conf

2) rédiger un fichier de règles : /etc/npf.conf :
(Attention à bien remplacer le nom de votre interface WAN_if et WAN_addrs !!)

########################################################################
 
# 1 - Provide information about your network interface(s):
 
# WAN Interface :
$WAN_if = "vioif0"
$WAN_addrs = ifaddrs(vioif0)
 
alg "icmp"
 
########################################################################
 
# 2 - Define the networks
 
# The RFC protects the server from private networks in case it is directly facing the internet.
# (Uncomment only if the WAN IP is a public IP address)
#$RFC1918 = { 10.0.0.0/8, 172.16.0.0/14, 192.168.0.0/16 }
 
# (Uncomment only if the server acts as a gateway)
#$LAN_net = { 10.10.10.0/24 }
 
########################################################################
 
# 3 - Create a procedure for logging connections:
 
procedure "log" {
        # Send all events to a log (see npfd))
        log: npflog0
}
 
########################################################################
 
# 5 - Create tables

# Create a table for miniircd
table <blocklist> type ipset
 
########################################################################
 
# 4 - Rule group for the WAN interface:
 
group "WAN" on $WAN_if {
 
        # Block IP from blocklist table
        block in final from <blocklist> apply "log"
 
        # Allow all stateful outgoing traffic (all protocols).
        pass stateful out final all
 
        # SSH: Allow SSH connections to the server
        pass stateful in on $WAN_if proto tcp to $WAN_addrs port ssh

        # IRC : Allow IRC connections to the server
        pass stateful in on $WAN_if proto tcp to $WAN_addrs port 6697
 
}
 
########################################################################
 
# 5 - Default rule group:
 
group default {
 
       # Loopback : Allow traffic
       pass final on lo0 all
 
        # Close the firewall
       block all apply "log"
 
}
########################################################################

- Lancer NPF :

service npf start

La connexion SSH saute, c'est normal... mais si vous ne vous êtes pas trompés dans le fichier de règles, vous pouvez vous reconnecter.

3) Ecrire un petit démon de ban d'IP : /var/jail/miniircd/banip.sh

#!/bin/sh

LOG_FILE="/var/jail/miniircd/miniircd.log"
BLOCKLIST_TABLE="blocklist"

ban_ip() {
    IP=$1
    # Vérifier si l'IP est déjà dans la table de blocage
    if ! /sbin/npfctl table $BLOCKLIST_TABLE list | grep -q "$IP"; then
        # Ajouter l'IP à la table de blocage
        /sbin/npfctl table $BLOCKLIST_TABLE add "$IP"
		npfctl reload
        echo "$(date): Banned IP $IP" >> /var/jail/miniircd/miniircd_bans.log
    fi
}

# Utiliser tail -F pour suivre le fichier de log
tail -F "$LOG_FILE" | while read -r line; do
    # Vérifier si la ligne contient le code d'erreur 464
    if echo "$line" | grep -q "464 :Password incorrect"; then
        # Extraire l'adresse IP
        IP=$(echo "$line" | grep -Eo '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}')
        if [ -n "$IP" ]; then
            ban_ip "$IP"
        fi
    fi
done

- Autoriser son exécution :

chmod 740 /var/jail/miniircd/banip.sh

4) Lancer le serveur et exécuter le script banip. Le tout dans des sessions tmux différentes :

tmux new-session -d -s MINIIRCD "/usr/pkg/bin/miniircd --listen=0.0.0.0 --ssl-cert-file=/var/jail/miniircd/miniircd.crt --ssl-key-file=/var/jail/miniircd/miniircd.key --verbose --chroot=/var/jail/miniircd --setuid=nobody --password 'Super-Mot-De-Passe' --debug > /var/jail/miniircd/miniircd.log"

tmux new-session -d -s BANIP "/var/jail/miniircd/banip.sh"

En cas de redémarrage du serveur, relancer les 2 commandes ci-dessus ou mettre en place un démarrage au démarrage du serveur.

Debannir une IP :
- Repérer l'IP :

npfctl table blocklist list

- Debannir :

npfctl table blocklist rem 192.168.36.32

npfctl reload

Sur NetBSD 9.4, OpenSSL peut poser quelques difficultés en raison de l'absence de la librairie libproviders.
Un contournement simple est d'écrire un fichier de configuration minimaliste pour générer notre certif/autorité :

Etre en root :

su -

Installer openssl :

pkgin -y in openssl mozilla-rootcerts

mozilla-rootcerts install

Créer un fichier de configuration minimaliste :

cd /usr/pkg/etc/openssl

cat > openssl-minimal.cnf <<EOL
[ req ]
default_bits       = 2048
default_md         = sha256
default_keyfile    = privkey.pem
prompt             = no
encrypt_key        = no

distinguished_name = req_distinguished_name

[ req_distinguished_name ]
C            = US
ST           = California
L            = San Francisco
O            = My Company
OU           = My Division
CN           = localhost
EOL

Créer notre certificat auto-signé :

openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout maclefprivee.key -out moncertif.crt -config openssl-minimal.cnf

miniIRCd est un serveur IRC minimaliste.
Pas de contrôle des utilisateurs entrants, pas d'authentification (autre qu'un mot de passe d'accès), juste du SSL.
ça peut servir dans certains cas...
On peut facilement écrire un filtre fail2ban et configurer le pare-feu pour limiter les risques.

(Installation effectuée sur un serveur NetBSD installé en mode "minimaliste")

Passez en root pour toute la procédure.


1) Installer git, python3 et openssl

pkgin -y in git python311 openssl tmux

2) Télécharger installer miniIRCd 

cd /tmp && git clone https://github.com/jrosdahl/miniircd.git && cd miniircd && cp miniircd /usr/pkg/bin/

3) Générer le certificat SSL autosigné et créer le chroot

mkdir -p /var/jail/miniircd ; cd /var/jail/miniircd ; openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout miniircd.key -out miniircd.crt -config /usr/pkg/etc/openssl/openssl.cnf

4) Créer un lien symbolique pour Python3

ln -s /usr/pkg/bin/python3.11 /usr/pkg/bin/python3

5) Lancer le serveur en arrière-plan

/usr/pkg/bin/miniircd --listen=0.0.0.0 --ssl-cert-file=/var/jail/miniircd/miniircd.crt --ssl-key-file=/var/jail/miniircd/miniircd.key --verbose --chroot=/var/jail/miniircd --setuid=nobody --password "Mon-Super-Mot-DE-PaSse" -d

Sur Android, l'application CoreIRC Go (ou sa version payante) sont compatibles avec miniIRCd


Rappel des commandes IRC de base (compatibles avec miniIRCd) sur les clients type Hexchat :

- Rejoindre un canal ou en créer un :

/join #NOM-DU-CANAL-A-CREER-OU-A-JOINDRE

- Quitter le canal "#CANAL" avec un message d'au-revoir

/part #CANAL Au revoir tout le monde

- Changer de pseudonyme

/nick NouveauPseudo

- Envoyer le message "Bonjour" à l'utilisateur "Utilisateur"

/msg Utilisateur Bonjour !

- Envoyer un fichier à un utilisateur

/dcc send UTILISATEUR-DESTINATAIRE

Comment sécuriser un peu miniIRCd.

1) Mettre en place NPF :

echo "npf=YES" >> /etc/rc.conf

2) rédiger un fichier de règles : /etc/npf.conf :
(Attention à bien remplacer le nom de votre interface WAN_if et WAN_addrs !!)

########################################################################
 
# 1 - Provide information about your network interface(s):
 
# WAN Interface :
$WAN_if = "vioif0"
$WAN_addrs = ifaddrs(vioif0)
 
alg "icmp"
 
########################################################################
 
# 2 - Define the networks
 
# The RFC protects the server from private networks in case it is directly facing the internet.
# (Uncomment only if the WAN IP is a public IP address)
#$RFC1918 = { 10.0.0.0/8, 172.16.0.0/14, 192.168.0.0/16 }
 
# (Uncomment only if the server acts as a gateway)
#$LAN_net = { 10.10.10.0/24 }
 
########################################################################
 
# 3 - Create a procedure for logging connections:
 
procedure "log" {
        # Send all events to a log (see npfd))
        log: npflog0
}
 
########################################################################
 
# 5 - Create tables

# Create a table for miniircd
table <blocklist> type ipset
 
########################################################################
 
# 4 - Rule group for the WAN interface:
 
group "WAN" on $WAN_if {
 
        # Block IP from blocklist table
        block in final from <blocklist> apply "log"
 
        # Allow all stateful outgoing traffic (all protocols).
        pass stateful out final all
 
        # SSH: Allow SSH connections to the server
        pass stateful in on $WAN_if proto tcp to $WAN_addrs port ssh

        # IRC : Allow IRC connections to the server
        pass stateful in on $WAN_if proto tcp to $WAN_addrs port 6697
 
}
 
########################################################################
 
# 5 - Default rule group:
 
group default {
 
       # Loopback : Allow traffic
       pass final on lo0 all
 
        # Close the firewall
       block all apply "log"
 
}
########################################################################

- Lancer NPF :

service npf start

La connexion SSH saute, c'est normal... mais si vous ne vous êtes pas trompés dans le fichier de règles, vous pouvez vous reconnecter.

3) Ecrire un petit démon de ban d'IP : /var/jail/miniircd/banip.sh

#!/bin/sh

LOG_FILE="/var/jail/miniircd/miniircd.log"
BLOCKLIST_TABLE="blocklist"

ban_ip() {
    IP=$1
    # Vérifier si l'IP est déjà dans la table de blocage
    if ! /sbin/npfctl table $BLOCKLIST_TABLE list | grep -q "$IP"; then
        # Ajouter l'IP à la table de blocage
        /sbin/npfctl table $BLOCKLIST_TABLE add "$IP"
		npfctl reload
        echo "$(date): Banned IP $IP" >> /var/jail/miniircd/miniircd_bans.log
    fi
}

# Utiliser tail -F pour suivre le fichier de log
tail -F "$LOG_FILE" | while read -r line; do
    # Vérifier si la ligne contient le code d'erreur 464
    if echo "$line" | grep -q "464 :Password incorrect"; then
        # Extraire l'adresse IP
        IP=$(echo "$line" | grep -Eo '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}')
        if [ -n "$IP" ]; then
            ban_ip "$IP"
        fi
    fi
done

- Autoriser son exécution :

chmod 740 /var/jail/miniircd/banip.sh

4) Lancer le serveur et exécuter le script banip. Le tout dans des sessions tmux différentes :

tmux new-session -d -s MINIIRCD "/usr/pkg/bin/miniircd --listen=0.0.0.0 --ssl-cert-file=/var/jail/miniircd/miniircd.crt --ssl-key-file=/var/jail/miniircd/miniircd.key --verbose --chroot=/var/jail/miniircd --setuid=nobody --password 'Super-Mot-De-Passe' --debug > /var/jail/miniircd/miniircd.log"

tmux new-session -d -s BANIP "/var/jail/miniircd/banip.sh"

En cas de redémarrage du serveur, relancer les 2 commandes ci-dessus ou mettre en place un démarrage au démarrage du serveur.

Debannir une IP :
- Repérer l'IP :

npfctl table blocklist list

- Debannir :

npfctl table blocklist rem 192.168.36.32

npfctl reload

5) Configurer SSH pour une connexion par clef uniquement...  etc..

Auparavant on utilisait rdesktop, malheureusement, c'est fini.
ça ne fonctionne plus.

Place à "freedrp2"

su - 

pkgin -y in freerdp2

Ensuite on ouvre une connexion RDP en tant qu'utilisateur standard :

xfreerdp2 /u:UTILISATEUR-WINDOWS /p:MOT-DE-PASSE-UTILISATEUR-WINDOWS /v:IP:PORT-RDP

De nombreuses options existent, notamment pour indiquer la résolution d'écran(/size:1920x1080) ou activer le son (/sound)

Pré-requis :
- avoir suivi l'article précédent pour activer NVMM
- disposer d'une connexion internet
- disposer d'un accès root
- disposer d'un ISO d'installation de Windows 10 ou 11
- disposer d'un ISO d'installation des driver virtio-win pour la carte réseau.

Le fichier de configuration suivant vous permet de créer une machine virtuelle très rapidement, simplement en cherchant/remplaçant chaque caractéristique de la VM présentée au début du fichier.
Vous remplacez dans tout le fichier chaque valeur par ce que vous souhaitez, et tout est alors prêt.
Il ne vous restera plus qu'à faire des copiers/collers de chaque bloc de commandes !

###############################################
# CARTE D'IDENTITIE DE LA VM :
# (procéder à des chercher/remplacer des valeurs ci-dessous dans tout le document à la fois pour préparer toutes les commandes d'un coup)

Nom de la VM : 	windows11pron 
Interface réseau : 	tap2
Périphérique rés.:	tap2 c 169 2  		# tapX c 169 X ...  tapY c 169 Y ! Attention !
Pont :			bridge0
WAN :			wm0
Taille stockage :	80G
Utilisateur :	myuser
RAM :			-m 10G
CPU :			cpus=2
ISO système : 	/home/myuser/ISO/11-21H2-Consumer-x64-fr-FR.iso
ISO virtio :		/home/myuser/ISO/virtio-win-0.1.248.iso
Display :           sdl,gl=on                # ou vnc=:0


############
# INSTALLATION :
# (en root)

mkdir /home/myuser/VM
qemu-img create -f qcow2 /home/myuser/VM/windows11pron.qcow2 80G
chown -R myuser:users /home/myuser/VM

# Création du périphérique /dev/tap2
rm /dev/tap2
mknod /dev/tap2 c 169 2
chmod 660 /dev/tap2
chown root:wheel /dev/tap2

# Création de l'interface permanente :
echo "create" > /etc/ifconfig.tap2 && echo 'descr "NetBSD VM" up' >> /etc/ifconfig.tap2 && echo "! ifconfig bridge0 create" >> /etc/ifconfig.tap2 && echo '! ifconfig bridge0 descr "LAN VM bridge" up' >> /etc/ifconfig.tap2 && echo "! brconfig bridge0 add tap2 add wm0" >> /etc/ifconfig.tap2

# Création de l'interface temporaire et du pont bridge0
ifconfig bridge0 create ; sleep 1
ifconfig bridge0 descr "LAN VM bridge" up ; sleep 1
brconfig bridge0 add wm0 ; sleep 1
ifconfig tap2 create ; sleep 1
ifconfig tap2 up ; sleep 1
brconfig bridge0 add tap2 ; sleep 1

# 1er lancement de la VM : installation de l'OS.
# (pas en root)
qemu-system-x86_64 -accel nvmm -cpu qemu64 -smp cpus=2 -m 10G -display sdl,gl=on -usb -device usb-mouse,bus=usb-bus.0 -device usb-tablet -drive file='/home/myuser/ISO/11-21H2-Consumer-x64-fr-FR.iso',media=cdrom -drive file='/home/myuser/VM/windows11pron.qcow2' -drive file='/home/myuser/ISO/virtio-win-0.1.248.iso',media=cdrom -netdev tap,id=tap2,ifname=tap2,script=no -device virtio-net-pci,netdev=tap2 -object rng-random,filename=/dev/urandom,id=viornd0 -audiodev oss,id=oss,out.dev=/dev/audio,in.dev=/dev/audio -device ac97,audiodev=oss -bios /usr/pkg/share/ovmf/OVMFX64.fd -boot d


################
# LANCEMENT USUEL :
# (pas en root)
qemu-system-x86_64 -accel nvmm -cpu qemu64 -smp cpus=2 -m 10G -display sdl,gl=on -usb -device usb-mouse,bus=usb-bus.0 -device usb-tablet -drive file='/home/myuser/VM/windows11pron.qcow2' -netdev tap,id=tap2,ifname=tap2,script=no -device virtio-net-pci,netdev=tap2 -object rng-random,filename=/dev/urandom,id=viornd0 -audiodev oss,id=oss,out.dev=/dev/audio,in.dev=/dev/audio -device ac97,audiodev=oss -bios /usr/pkg/share/ovmf/OVMFX64.fd -boot d

Pré-requis :
- avoir suivi l'article précédent pour activer NVMM
- disposer d'une connexion internet
- disposer d'un accès root
- disposer d'un ISO d'installation de Debian ou d'une autre distri Linux

Le fichier de configuration suivant vous permet de créer une machine virtuelle très rapidement, simplement en cherchant/remplaçant chaque caractéristique de la VM présentée au début du fichier.
Vous remplacez dans tout le fichier chaque valeur par ce que vous souhaitez, et tout est alors prêt.
Il ne vous restera plus qu'à faire des copiers/collers de chaque bloc de commandes !

###############################################
# CARTE D'IDENTITIE DE LA VM :
# (procéder à des chercher/remplacer des valeurs ci-dessous dans tout le document à la fois pour préparer toutes les commandes d'un coup)

Nom de la VM : 	debian12 
Interface réseau : 	tap0
Périphérique rés.:	tap0 c 169 0  		# tapX c 169 X .... tapY c 169 Y ! Attention !
Pont :			bridge0
WAN :			wm0
Taille stockage :	12G
Utilisateur :	myuser
RAM :			-m 2G
CPU :			cpus=1
ISO système : 	/home/myuser/ISO/debian-12.5.0-amd64-netinst.iso
Display :           sdl,gl=on                # ou vnc=:0

############
# INSTALLATION :
# (en root)

mkdir /home/myuser/VM
qemu-img create -f qcow2 /home/myuser/VM/debian12.qcow2 12G
chown -R myuser:users /home/myuser/VM

# Création du périphérique /dev/tap0
rm /dev/tap0
mknod /dev/tap0 c 169 0
chmod 660 /dev/tap0
chown root:wheel /dev/tap0

# Création de l'interface permanente :
echo "create" > /etc/ifconfig.tap0 && echo 'descr "NetBSD VM" up' >> /etc/ifconfig.tap0 && echo "! ifconfig bridge0 create" >> /etc/ifconfig.tap0 && echo '! ifconfig bridge0 descr "LAN VM bridge" up' >> /etc/ifconfig.tap0 && echo "! brconfig bridge0 add tap0 add wm0" >> /etc/ifconfig.tap0

# Création temporaire du pont bridge0 ainsi que de l'interface tap0 :
ifconfig bridge0 create ; sleep 1
ifconfig bridge0 descr "LAN VM bridge" up ; sleep 1
brconfig bridge0 add wm0 ; sleep 1
ifconfig tap0 create ; sleep 1
ifconfig tap0 up ; sleep 1
brconfig bridge0 add tap0 ; sleep 1

# 1er lancement de la VM : installation de l'OS.
# (pas en root)
# Directement depuis le serveur :
qemu-system-x86_64 -accel nvmm -cpu qemu64 -smp cpus=1 -m 2G -display sdl,gl=on -usb -device usb-mouse,bus=usb-bus.0 -cdrom '/home/myuser/ISO/debian-12.5.0-amd64-netinst.iso' -drive file='/home/myuser/VM/debian12.qcow2',if=none,id=hd0 -device virtio-blk-pci,drive=hd0 -object rng-random,filename=/dev/urandom,id=viornd0 -device virtio-rng-pci,rng=viornd0 -audiodev oss,id=oss,out.dev=/dev/audio,in.dev=/dev/audio -device ac97,audiodev=oss -netdev tap,id=tap0,ifname=tap0,script=no -device virtio-net-pci,netdev=tap0 -bios /usr/pkg/share/ovmf/OVMFX64.fd -boot menu=on

################
# LANCEMENT USUEL :
# (pas en root)
# Directement depuis le serveur :
qemu-system-x86_64 -accel nvmm -cpu qemu64 -smp cpus=1 -m 2G -display sdl,gl=on -usb -device usb-mouse,bus=usb-bus.0 -drive file='/home/myuser/VM/debian12.qcow2',if=none,id=hd0 -device virtio-blk-pci,drive=hd0 -object rng-random,filename=/dev/urandom,id=viornd0 -device virtio-rng-pci,rng=viornd0 -audiodev oss,id=oss,out.dev=/dev/audio,in.dev=/dev/audio -device ac97,audiodev=oss -netdev tap,id=tap0,ifname=tap0,script=no -device virtio-net-pci,netdev=tap0 -bios /usr/pkg/share/ovmf/OVMFX64.fd -boot menu=on

Il est possible de créer des VM de Debian, FreeBSD, NetBSD, Windows 10&11, et sûrement d'avantage.

Pré-requis :
- avoir une installation complète de NetBSD 10.0 (avec X11).
- être connecté à internet
- avoir les accès root

Pour pouvoir faire des VM avec qemu, il faut activer l'accélérateur NVMM.
Les manipulations suivantes ne sont à faire qu'une seule fois, puis on passe à la création des VM dans les articles suivants.

1) Charger le module nvmm
nvmm est un accélérateur, que l'on va utiliser conjointement avec qemu

su -

modload nvmm

- Configurer le chargement du module au démarrage :

echo nvmm >> /etc/modules.conf

- Autoriser marcel à utiliser nvmm

chown marcel:wheel /dev/nvmm

2) Installer qemu, les outils vmware et l'UEFI OVMF

pkgin -y in qemu open-vm-tools OVMF

- Profitez-en pour mettre en place les copier/collers futurs :

mkdir /var/run/vmblock-fuse ; vmware-vmblock-fuse /var/run/vmblock-fuse ; echo vmtools=YES >> /etc/rc.conf

Redevenez votre utilisateur normal puis :

vmware-user-suid-wrapper

A présent redevenez root

3) Régler un futur problème de latence dans le son de la VM :

sysctl -w hw.audio0.blk_ms=100

# NOTE :
- Des erreurs de l'accélérateur NVMM se produisent par moments, qui peuvent bloquer l'exécution de la VM quelques secondes. Il suffit d'attendre. C'est notable lors des installations.

# NOTES CONCERNANT WINDOWS :
- La commande qemu est très différente de celle pour créer une VM type Linux/BSD, en raison du besoin d'un driver différent pour le support de stockage. Le modèle que je donne fonctionne.
- Une fois avoir appuyé sur la barre d'espace pour booter sur l'ISO d'installation, il faut attendre 2min (problème d'OVMF) avant que l'installeur de windows ne se lance enfin.
- Parfois la souris bug lors de l'installation.. pas d'inquiétudes, ce n'est pas le cas après.
- Avec Windows 11, il faut parfois pousser le nombres de vCPU à 4 suivant votre machine.

Je m'y prends un peu tard pour rédiger un article à ce sujet, d'autant plus qu'il s'agît d'une grave vulnérabilité de la version SSH embarquée dans NetBSD 10.0.

Un site spécialisé dans les annonces et les vulnérabilités sur BSD existe : https://bsdsec.net/

Malheureusement, et c'est pas faute d'y avoir consacré du temps, je ne suis absolument pas parvenu à recompiler SSH avec la librairie en question.. ya toujours un truc qui déconne !!!

Donc à la place, on peut simplement installer une version à jour de NetBSD 10.0 en cherchant dans les fameuses images régulières qui sont publiées :
https://nycdn.netbsd.org/pub/NetBSD-daily/netbsd-10/latest/amd64/installation/cdrom/boot.iso

Vu la sévérité de la faille, c'est peut-être pas une option inenvisageable... !
Et ça va plus vite que de passer 20h à essayer comprendre pourquoi ça ne build pas !!

Attention, il s'agît d'un installeur "boot", nécessitant une connexion internet pour télécharger et installer NetBSD.
Vous devrez choisir d'installer via HTTP ou FTP au moment où ce sera demandé lors de l'installation.

Désireux de savoir si je pourrais utiliser rclone-browser sur NetBSD 10.0, j'ai entrepris de le compiler.
C'est chose faîte !

(rester en root tout au long de la procédure)

Depuis une installation "Complete" de NetBSD 10.0 (avec X11) :

pkgin install git cmake qt5-qtdeclarative rclone

cd /usr/pkg

git clone https://github.com/kapitainsky/RcloneBrowser.git

Ouvrez le fichier /usr/pkg/RcloneBrowser/src/main_window.cpp:
- Remplacez la ligne suivante :

QStringList lines = version.split("\n", QString::SkipEmptyParts);

- Par :

QStringList lines = version.split("\n", Qt::SkipEmptyParts);

- Remplacez également la ligne suivante :

player->start(stream, QProcess::ReadOnly);

- Par :

QStringList arguments;
arguments << stream;
player->start("playerExecutable", arguments, QProcess::ReadOnly);

Vous pouvez directement effectuer les 2 modifications précédentes en exécutant simplement les commandes suivantes :

sed -i 's/QString::SkipEmptyParts/Qt::SkipEmptyParts/' /usr/pkg/RcloneBrowser/src/main_window.cpp

sed -i 's/player->start(stream, QProcess::ReadOnly);/QStringList arguments;\n  arguments << stream;\n  player->start("playerExecutable", arguments, QProcess::ReadOnly);/' /usr/pkg/RcloneBrowser/src/main_window.cpp

Compiler :

cd /usr/pkg/RcloneBrowser

mkdir build && cd build

cmake .. -DCMAKE_PREFIX_PATH:PATH=/usr/pkg/qt5 -DCMAKE_INSTALL_RPATH=/usr/pkg/qt5/lib

make

make install

unison est un logiciel très ancien (mais toujours fonctionnel), de synchronisation parfaite entre 2 répertoires.
Il est également possible de le faire fonctionner entre 2 serveurs distants via SSH.
Cependant, à la différence de rsync dont le fonctionnement ne laisse pas trop de doutes, le concept, pourtant simple, d'unison est beaucoup plus traître.

Au risque de me répéter, ce logiciel synchronise 2 dossiers, de façon bi-directionnelle (dans les 2 sens).
Ce qui signifie que toute modification de l'un des 2 dossiers, provoquera la modification des 2 dossiers une fois la commande exécutée (unison n'est pas un démon, il faut exécuter une commande, tout comme rsync).
Vous allez comprendre.

Premier exemple :

- Soient 2 dossiers "A" et "B"
"A" contient une foule de fichiers et dossiers.
"B" est vide.
unison n'a encore jamais été utilisé entre ces 2 dossiers.

Ce que nous voulons : Synchroniser le contenu de A et B. (en gros, copier le contenu de A vers B).
Rien de plus simple :

unison /chemin/vers/A /chemin/vers/B

ça produit l'équivalent d'une copie simple, du contenu de A vers B. (cp -r /chemin/vers/A/* /chemin/vers/B/).
Les données dans A sont copiées dans B.
unison mémorise alors l'index de ce qui a été copié (un peu comme rsync).

A partir de là, si vous effectuez une modification dans A ou dans B et que vous exécutez la commande à nouveau, unison tentera alors de recréer "l'unison" entre A et B, en ne s'occupant pas de restaurer quoique ce soit (et oui, attention à ce point !! Il est fondamental).
Si une fois l'unison obtenu entre les 2 répertoire, vous décidez de supprimer un fichier dans B, unison vous demandera si vous souhaitez également le supprimer dans A. Vous pourrez alors choisir de supprimer ou non le fichier dans A, mais pas de restaurer le fichier dans A à partir de la copie dans B !!! Il faut bien comprendre ça !!!
Il n'y a pas de possibilité simple de "restaurer" avec unison. On ne peut qu'ignorer la suppression ou la copie d'un fichier.

Deuxième exemple :

- Soient 2 dossiers "A" et "B"
Leur contenu est identique.
unison a déjà été utilisé (soit pour copier les données de "A" vers "B", avec un B initialement vide, soit simplement pour créer l'index et vérifier que les 2 dossiers sont bien identiques par la même occasion. Cette première exécution peut d'ailleurs prendre beaucoup de temps si vos dossiers sont lourds).

Si vous ajoutez 2 nouveaux fichiers à A ou à B et lancez la même commande unison entre les 2 dossiers, alors unison vous demandera, fichier par fichier, si vous souhaitez également le copier dans l'autre répertoire. Vous aurez alors le choix de répondre oui ("f") ou de ne pas copier le fichier ("n").
Lorsqu'il n'y aura plus de décision à prendre, unison vous proposera d'appliquer ces décisions ("Proceed with propagating updates? []).
Si vous souhaitez alors appliquer les décisions, c'est "y", si vous ne souhaitez pas, c'est "q". Si vous tapez "n" alors le processus de décision repart à 0 pour tous les fichiers et vous devrez choisir à nouveau pour chacun d'eux... ça c'est vraiment con comme syntaxe !!!

L'automatisation !

Il est bien entendu possible d'automatiser la prise de décision et d'empêcher unison de poser interactivement la question pour tous les fichiers. Ainsi, ce sont des décisions par défaut qui seront appliquées.

unison -batch -auto /chemin/vers/A /chemin/vers/B

Je rappelle donc ce que va produire cette commande très dangereuse :
- tout nouveau fichier (ajouté, donc, depuis la dernière exécution d'unison) copié dans A ou B sera automatiquement copié dans l'autre répertoire lors de la prochaine exécution d'unison.
- tout fichier déjà existant lors d'une précédente synchro, qui est ensuite supprimé de A ou B, sera également automatiquement supprimé dans l'autre dossier lors de la prochaine exécution de commande.

Troisième exemple :

- Soient 2 dossiers "A" et "B"
Leur contenu est presque identique.
En gros, vous avez déjà une base commune mais vous avez en plus ajouté des fichiers à A mais pas à B, et ajouté des fichiers à B mais pas à A.

-- 1er cas de figure : unison n'a jamais été utilisé.
Rappelez-vous, cette première exécution peut prendre beaucoup de temps si vos répertoires A et B sont très chargés en données car unison compare tout, scrupuleusement.
Lorsque vous exécuterez la commande avec les options automatiques, les 2 dossiers se mettront à l'unison.
Les fichiers présents dans A mais pas dans B se copieront dans B.
Les fichiers présents dans B, mais pas dans A se copieront dans A.
Tout va bien dans le meilleur des mondes !

-- 2nd cas de figure : unison a déjà été utilisé et vous avez depuis ajouté des fichiers à A mais pas à B et également ajouté des fichiers à B mais pas à A.
Lorsque vous exécuterez la commande avec les options automatiques, les 2 dossiers se mettront à l'unison.
Les fichiers présents dans A mais pas dans B se copieront dans B.
Les fichiers présents dans B, mais pas dans A se copieront dans A.
Là aussi, tout va bien dans le meilleur des mondes !

Conclusion :

Il ne s'agît pas d'une synchronisation unidirectionnelle entre A et B comme avec rsync, mais d'une synchronisation bidirectionnelle.
Autrement dit, toute altération de l'un ou l'autre des dossiers (A ou B) sera reproduite dans l'autre dossier.
C'est particulièrement dangereux dans le cas où A et B seraient sur 2 supports de stockage différents et que l'un d'eux se mettrait à défaillir avant l'exécution de la commande. Vous pourriez potentiellement perdre beaucoup de données en une seule commande !
Et c'est l'une des raisons pour laquelle unison n'est plus beaucoup utilisé (sans parler du fait que des systèmes de fichiers comme ZFS font ce travail en 50 fois moins de temps aujourd'hui avec les options send/receive).
Pour éviter cette situation, il faut vérifier l'état des disques AVANT l'exécution de la commande.
Ou plus simple, utiliser rsync (unidirectionnel) pour éviter de foutre la pagaille partout en même temps.

unison est très performant et rapide... mais attention, vous êtes prévenus des risques !

youtube-dl devient peu à peu obsolète... qu'à cela ne tienne, il existe un fork : yt-dlp !

On se met en root :

su -

Puis on installe :

pkgin -y in yt-dlp ffmpeg5 ffmpeg6

Pour télécharger une vidéo dans la meilleure résolution vidéo et audio possible

yt-dlp -f bestvideo+bestaudio https://URL-DE-LA-VIDEO

Là, c'est un peu plus délicat, surtout lorsque les périphériques USB ont plusieurs partitions.
Nous allons prendre l'exemple le plus casse-bonbon qui soit : une clef USB Ventoy !
Evidemment, on veut monter la partition qui contient les .iso... et qui est donc en ExFAT

D'abord, on se met en root tout du long :

su -

1) Installer le nécessaire !

pkgin -y in fuse fuse-ntfs fuse-exfat fuse-ext2 fuse-httpfs fuse-sshfs ntfsprogs

(Il y a plus que de raison.. mais autant installer toute la série, vous en aurez sûrement besoin à un moment ou un autre)

2) Brancher le périphérique USB puis repérez-le

dmesg | tail -n 10

Il apparaîtra sous sdX où X est un chiffre, mais cette fois, il ne sera pas associé à un volume logique de type dkY (où Y est un chiffre également).

Etant donné qu'il s'agît d'un périphérique ExFAT, aucune géométrie ne se fabriquera automatiquement.
Il est donc fort probable que vous voyez "Fabricating geometry" s'afficher... indéfiniment.

Exemple de résultat :

[  2707.537422] sd0 at scsibus0 target 0 lun 0: <Lexar, USB Flash Drive, 1100> disk removable
[  2707.537422] sd0: fabricating a geometry
[  2707.537422] sd0: 231 GB, 236650 cyl, 64 head, 32 sec, 512 bytes/sect x 484659200 sectors
[  2707.537422] sd0: fabricating a geometry
SERVEUR# 

Prenons donc sd0 pour exemple de ma clef Ventoy.

2bis) Vérifier les partitions présentes sur le périphérique USB :

disklabel sd0

Voici ce qu'affiche la commande :

SERVEUR# disklabel sd0
# /dev/rsd0:
type: SCSI
disk: USB Flash Drive 
label: fictitious
flags: removable
bytes/sector: 512
sectors/track: 32
tracks/cylinder: 64
sectors/cylinder: 2048
cylinders: 236650
total sectors: 484659200
rpm: 3600
interleave: 1
trackskew: 0
cylinderskew: 0
headswitch: 0           # microseconds
track-to-track seek: 0  # microseconds
drivedata: 0 

6 partitions:
#        size    offset     fstype [fsize bsize cpg/sgs]
 d: 484659200         0     unused      0     0        # (Cyl.      0 - 236649)
 e: 484591616      2048       NTFS                     # (Cyl.      1 - 236617)
 f:     65536 484593664    unknown                     # (Cyl. 236618 - 236649)
disklabel: boot block size 0
disklabel: super block size 0
SERVEUR# 

Comme vous le constatez, il y a un problème avec la reconnaissance d'ExFAT... (qui est pris pour du NTFS).
MAIS ! Nous avons une information fondamentale : la lettre de la partition !
En effet, le "e" est l'information cruciale qui va nous permettre de monter la partition.

Nous pouvons donc à présent passer au montage !

3) Créer un point de montage :

mkdir -p /media/sd0e

4) Monter la partition sur /media/sd0e :

env PERFUSE_BUFSIZE=135168 /usr/pkg/sbin/mount.exfat /dev/sd0e /media/sd0e

On est obligé d'utiliser cette petite triche car sinon la copie des gros fichiers va poser beaucoup de problèmes !

Voilà, la partition en ExFAT est montée.
Je vous suggère d'effectuer vos copies via root et via le shell, parce que j'ai rencontré pas mal de soucis avec mon utilisateur marcel et les explorateurs de fichiers type thunar. La partition saute souvent...

Toute la question est de savoir comment faire la distinction entre NTFS et ExFAT, vu qu'on ne la voit pas dans les commandes tapés (ni avec disklabel, ni avec fdisk)... eh bien à ma connaissance, on ne peut pas ! :-D
Il faudra essayer de monter en NTFS, et si ça ne fonctionne pas, supposer que c'est du ExFAT et monter en ExFAT comme ci-dessus !

Montage d'un volume SFTP sur un système NetBSD.

Pour se connecter à un espace de stockage distant via SFTP (FTP over SSH), on peut bien entendu utiliser le shell avec la commande sftp, ou le logiciel Filezilla.

On peut aussi monter un volume directement sur le système de fichiers grâce à fuse, si on préfère pouvoir utiliser un explorateur de fichiers comme Thunar ou naviguer plus facilement dans l'arborescence avec le shell

1) Installer fuse-sshfs

su -

pkgin -y in fuse-sshfs

2) Créer un point de montage :

mkdir -p /media/VolumeSFTP

3) Ouvrir la connexion et monter le volume

sshfs -p 12345 utilisateur@IP-DU-SERVEUR-DISTANT:/ /media/VolumeSFTP/

4) Démonter le volume :

fusermount -u /media/VolumeSFTP 

C'est aussi simple.

Lorsque vous procédez à l'installation "Complete" de NetBSD (avec X11), vous obtenez un environnement de bureau : CTWM.

Il fait un peu vieillot à première vue... sauf qu'en réalité, il est hyper personnalisable !
Je n'utilise plus les autres depuis j'ai appris à m'en servir.

2 configurations sont possibles :
- La configuration par défaut (système).
- La configuration par utilisateur.


Le fichier de configuration utilisé par défaut lorsque CTWM se lance est ici : /etc/X11/ctwm/system.ctwmrc

Pour configurer un environnement CTWM différent d'un utilisateur à l'autre, il faut rédiger un fichier ~/.ctwmrc (dans le répertoire de base de chaque utilisateur).
En gros, vous copiez le fichier par défaut depuis /etc/X11/ctwm/ vers votre espace personnel en le renommant puis vous modifiez votre propre configuration.

Ici, je préfère utiliser la même configuration pour tous les utilisateurs (puisqu'il n'y a que marcel, comme toujours), donc je vais toucher directement au fichier par défaut.

On se met en root :

su -

D'abord, on en fait une copie par sécurité :

cp /etc/X11/ctwm/system.ctwmrc /etc/X11/ctwm/system.ctwmrc.BAK

Voici un fichier de configuration d'exemple modifié, avec le nom des menus en Français, ainsi que quelques raccourcis claviers personnalisés :
- touchewindows + E (= mod4+E) pour ouvrir l'explorateur Thunar - à condition de l'avoir installé au préalable
- touchewindows + L (= mod4+L) pour verrouiller l'écran - ça lance xscreensaver - à condition de l'avoir installé au préalable et de l'avoir configuré pour qu'il verrouille l'écran).
- touchewindows + M (= mod4+B) pour redimensionner la fenêtre active de l'écran afin qu'elle occupe 100% de l'écran (il est très rapide après de la redimensionner à la souris pour qu'elle n'occupe que la moitié gauche ou droite de l'écran... je ne suis pas parvenu à faire cela en raccourics).
- mod4+F : Lancer Firefox (il faut l'avoir installé)
- mod4+T : Lancer Thunderbird (idem)
- mod4+C : Lancer xfce4-screenshooter (idem)

Ah au fait, je n'ai pas trouvé comment afficher les caractères accentués.. ça n'a pas fonctionné chez moi..
Si quelqu'un sait, je suis preneur.

#
# $NetBSD: system.ctwmrc,v 1.19 2022/05/27 17:04:16 nia Exp $
#
# ctwmrc by nia
#
# An attempt to strike a usability balance that makes keys and buttons
# do the thing users of various operating systems expect them to do.
#
# Most things should be possible to accomplish with only the keyboard.
#
# Also, mostly inoffensive colours (avoiding potentially inaccessible
# combinations like red-green).
#

# -*- coding: utf-8 -*-


# don't use the default buttons or key bindings, we define our own
NoDefaults

DontShowWelcomeWindow

ShowWorkSpaceManager
ShowIconManager

# 3D icon managers do not seemingly honor IconManagerHighlight,
# which makes them slightly less useful
#UseThreeDIconManagers
#UseThreeDWMap
UseThreeDBorders
#UseThreeDMenus
UseThreeDTitles

esyscmd(`printf "define(fontsize, %d)\n" "$(/usr/X11R7/libexec/ctwm_font_size)"')

ifelse(fontsize, `64', `
TitleFont        "-*-spleen-*-*-*-*-64-*-*-*-*-*-*-*"
MenuFont         "-*-spleen-*-*-*-*-64-*-*-*-*-*-*-*"
IconManagerFont  "-*-spleen-*-*-*-*-64-*-*-*-*-*-*-*"
IconFont         "-*-spleen-*-*-*-*-64-*-*-*-*-*-*-*"
ResizeFont       "-*-spleen-*-*-*-*-64-*-*-*-*-*-*-*"
WorkSpaceFont    "-*-spleen-*-*-*-*-32-*-*-*-*-*-*-*"
WorkSpaceManagerGeometry  "240x960-4-4" 1
IconManagerGeometry       "800x-1-1+0" 1
ThreeDBorderWidth         12
BorderWidth               12
define(setsizes, `yes')
')

ifelse(fontsize, `32', `
TitleFont        "-*-spleen-*-*-*-*-32-*-*-*-*-*-*-*"
MenuFont         "-*-spleen-*-*-*-*-32-*-*-*-*-*-*-*"
IconManagerFont  "-*-spleen-*-*-*-*-32-*-*-*-*-*-*-*"
IconFont         "-*-spleen-*-*-*-*-32-*-*-*-*-*-*-*"
ResizeFont       "-*-spleen-*-*-*-*-32-*-*-*-*-*-*-*"
WorkSpaceFont    "-*-spleen-*-*-*-*-24-*-*-*-*-*-*-*"
WorkSpaceManagerGeometry  "120x480-4-4" 1
IconManagerGeometry       "400x-1-1+0" 1
ThreeDBorderWidth         6
BorderWidth               6
define(setsizes, `yes')
')

ifelse(fontsize, `24', `
TitleFont        "-*-spleen-*-*-*-*-24-*-*-*-*-*-*-*"
MenuFont         "-*-spleen-*-*-*-*-24-*-*-*-*-*-*-*"
IconManagerFont  "-*-spleen-*-*-*-*-24-*-*-*-*-*-*-*"
IconFont         "-*-spleen-*-*-*-*-24-*-*-*-*-*-*-*"
ResizeFont       "-*-spleen-*-*-*-*-24-*-*-*-*-*-*-*"
WorkSpaceFont    "-*-spleen-*-*-*-*-16-*-*-*-*-*-*-*"
WorkSpaceManagerGeometry  "90x360-4-4" 1
IconManagerGeometry       "300x-1-1+0" 1
ThreeDBorderWidth         4
BorderWidth               4
define(setsizes, `yes')
')

ifelse(fontsize, `12', `
TitleFont        "-*-spleen-*-*-*-*-12-*-*-*-*-*-*-*"
MenuFont         "-*-spleen-*-*-*-*-12-*-*-*-*-*-*-*"
IconManagerFont  "-*-spleen-*-*-*-*-12-*-*-*-*-*-*-*"
IconFont         "-*-spleen-*-*-*-*-12-*-*-*-*-*-*-*"
ResizeFont       "-*-spleen-*-*-*-*-12-*-*-*-*-*-*-*"
WorkSpaceFont    "-*-spleen-*-*-*-*-8-*-*-*-*-*-*-*"
WorkSpaceManagerGeometry  "45x180-4-4" 1
IconManagerGeometry       "150x-1-1+0" 1
ThreeDBorderWidth         1
BorderWidth               1
define(setsizes, `yes')
')

# Fallback in case a valid font size was not returned.
# "Default case" is 16px.

ifdef(`setsizes', `', `
TitleFont        "-*-spleen-*-*-*-*-16-*-*-*-*-*-*-*"
MenuFont         "-*-spleen-*-*-*-*-16-*-*-*-*-*-*-*"
IconManagerFont  "-*-spleen-*-*-*-*-16-*-*-*-*-*-*-*"
IconFont         "-*-spleen-*-*-*-*-16-*-*-*-*-*-*-*"
ResizeFont       "-*-spleen-*-*-*-*-16-*-*-*-*-*-*-*"
WorkSpaceFont    "-*-spleen-*-*-*-*-12-*-*-*-*-*-*-*"
WorkSpaceManagerGeometry  "60x240-4-4" 1
IconManagerGeometry       "200x-1-1+0" 1
ThreeDBorderWidth         3
BorderWidth               3
')

RestartPreviousState

DecorateTransients

# allow the user to have their root window recolored as they choose
DontPaintRootWindow

# hide window contents while altering windows for performance
NoOpaqueMove
NoOpaqueResize

AutoOccupy
AutoRelativeResize

CenterFeedbackWindow

NoGrabServer

RaiseOnClick

DontMoveOff
MoveOffResistance	  150

ConstrainedMoveTime       0

IgnoreLockModifier

# Not actually that random.
# Means that windows do not have to be placed by hand with a mouse,
# which helps if you are using a keyboard only.
RandomPlacement          "on"

MoveDelta                 3
ClearShadowContrast       40
DarkShadowContrast        60
MovePackResistance        100

RaiseWhenAutoUnSqueeze
ShortAllWindowsMenus

#BeNiceToColorMap

NoStackMode

StayUpMenus
WarpToDefaultMenuEntry
MenuShadowDepth      1

# warp through all windows in the current workspace
WindowRing
WarpRingOnScreen

NoTitleHighlight

TitleButtonShadowDepth    1
TitleShadowDepth          1
TitleButtonBorderWidth    0
TitlePadding              0
TitleJustification        "left"
ButtonIndent              0
FramePadding		  0

LeftTitleButton           ":xpm:dot"      = f.menu "titleops"
RightTitleButton          ":xpm:resize"   = f.resize
RightTitleButton          ":xpm:cross"    = f.delete

BorderShadowDepth         2
BorderResizeCursors

MaxIconTitleWidth         120
NoIconManagerFocus
IconManagerShadowDepth    1
IconifyByUnmapping

ReallyMoveInWorkspaceManager
MapWindowCurrentWorkSpace {  "black" "firebrick" }
DontToggleWorkSpaceManagerState
DontWarpCursorInWMap
NoShowOccupyAll	
ReverseCurrentWorkspace	
StartInMapState
WMgrHorizButtonIndent     0
WMgrVertButtonIndent      0

WorkSpaces 
{
    "1"    { "lavender" "black" "darkslateblue" "white" }
    "2"    { "lavender" "black" "darkslateblue" "white" }
    "3"    { "lavender" "black" "darkslateblue" "white" }
    "4"    { "lavender" "black" "darkslateblue" "white" }
    "5"    { "lavender" "black" "darkslateblue" "white" }
}

Cursors
{
  Frame    "left_ptr"
  Title    "left_ptr"
  Icon     "left_ptr"
  IconMgr  "left_ptr"
  Move     "fleur"
  Resize   "fleur"
  Menu     "left_ptr"
  Button   "hand2"
  Wait     "watch"
  Select   "dot"
  Destroy  "pirate"
}

Color
{
  BorderColor           "firebrick"

  BorderTileBackground  "steelblue"
  BorderTileForeground  "steelblue"

  DefaultBackground     "grey70"
  DefaultForeground     "black"

  TitleBackground       "lavender"
  TitleForeground       "black" 

  MenuBackground        "lavender"
  MenuForeground        "black"
  MenuTitleBackground   "darkorange2"
  MenuTitleForeground   "black"
  MenuShadowColor 	"gray15"

  IconBackground        "black"
  IconForeground        "white"
  IconBorderColor       "gray45"

  IconManagerBackground "lavender"
  IconManagerForeground "black"
  IconManagerHighlight  "firebrick"

  MapWindowBackground   "lavender"
  MapWindowForeground   "black"	
}

Monochrome
{
    BorderColor 			"black"

    BorderTileForeground 	"black"
    BorderTileBackground 	"white"

    TitleForeground 			"black"
    TitleBackground 		"white"

    MenuForeground 		"black"
    MenuBackground 		"white"
    MenuTitleForeground 	"black"
    MenuTitleBackground 	"white"

    MapWindowForeground 	"white"
    MapWindowBackground 	"white"
}

syscmd(/usr/X11R7/libexec/ctwm_app_menu)

menu "appmenu"
{
    "Applications pkgsrc"	f.title
    " Accessoires"		f.menu "Accessories"
    " Jeux"				f.menu "Games"
    " Graphique"		f.menu "Graphics"
    " Internet"			f.menu "Internet"
    " Multimedia"		f.menu "Multimedia"
    " Bureautique"		f.menu "Office"
    " Programmation"	f.menu "Programming"
    " Systeme"			f.menu "System"
    " Divers"			f.menu "Misc"
}


menu "deskutils"
{
    "Utilitaires de bureau"	f.title
    " Calculatrice"			!"xcalc &"
    " Editeur de texte"		!"xedit &"
    ""						f.separator
    " XEyes"				!"xeyes &"
    " OpenGL Gears"		!"glxgears &"
    " Cube tournant"			!"ico -sleep 0.016 -obj cube -colors darkorange &"
    ""						f.separator
    " Compositeur (ombres)"	!"pkill xcompmgr; xcompmgr -c &"
    " Compositeurr (simple)"	!"pkill xcompmgr; xcompmgr -n &"
    ""						f.separator
    " Loupe"				!"xmag -source 100x100 &"
    " Fermer la fenêtre"		!"xkill &"
}

menu "termutils"
{
    "Utiliaires du Terminal"	f.title
    ""						f.separator
    " Editeur VIsual"			!"xterm -class UXTerm -e vi &"
    " Tetris"				!"xterm -class UXTerm -e tetris &"
    ""						f.separator
    " Egaliseur audio"		!"xterm -class UXTerm -e aiomixer &"
    ""						f.separator
    " Liste des processus"	!"xterm -class UXTerm -e top &"
    " I/O stats"				!"xterm -class UXTerm -e 'sysstat iostat' &"
    " Statistiques reseau"	!"xterm -class UXTerm -e 'sysstat ifstat' &"
    " Utilisation du disque"	!"xterm -class UXTerm -e 'sysstat df' &"
}

menu "NetBSD"
{
    "NetBSD"			f.title
    ""				f.separator
    " Terminal"			!"uxterm &"
    ""				f.separator
    " Applications"		f.menu "appmenu"
    " Utilitaires de Bureau"	f.menu "deskutils"
    " Utilitaires du Terminal"	f.menu "termutils"
    ""				f.separator
    " Redemarrer CTWM"		f.twmrc
    " Quitter"			f.quit
}

menu "titleops"
{
    "Fenetre"       f.title
    ""             f.separator
    " Iconifier"     f.iconify
    " Redimensionner"      f.resize
    " Deplacer"        f.move
    ""             f.separator
    " Occuper ..."  f.occupy
    " Occuper tout"  f.occupyall
    ""             f.separator
    " Elever"       f.raise
    " Abaisser"       f.lower
    ""             f.separator
    " Zoom"        f.fullzoom
    " Zoom-V"      f.zoom
    " Zoom-H"      f.horizoom
    ""             f.separator
    " Arreter"        f.destroy
    " Fermer"       f.delete
}

IconManagerDontShow
{
} 

OccupyAll 
{
   "XClock"
   "xsm"
   "xconsole"
   "XVidCap"
}

AlwaysOnTop
{
   "XEyes"
   "XVidCap"
}

NoTitle 
{
   "TWM Icon Manager"
   "WorkSpaceManager"
   "XClock"
}

WindowRingExclude
{
   "TWM Icon Manager"
   "WorkSpaceManager"
   "XClock"
   "xsm"
   "xconsole"
}

StartIconified 
{ 
}

NoBorder
{
}

Function "raise-move"          { f.raise f.deltastop f.forcemove }
Function "raise-and-resize"    { f.raise f.deltastop f.resize }

# These are basically essential for basic functionality.

Button1 =	: title		: f.function "raise-move"
Button2 =	: title		: f.function "raise-and-resize"
Button3 =	: title | frame	: f.menu "titleops"

Button1 =	: frame		: f.function "raise-and-resize"

Button1 =	: icon | iconmgr	: f.iconify
Button2 =	: icon			: f.move
Button3 =	: icon | iconmgr	: f.raiselower

Button1 =	: root		: f.menu "NetBSD"
Button2 =	: root		: f.menu "TwmAllWindows"
Button3 =	: root		: f.menu "NetBSD"

#
# Mod1 is the "Alt/Meta" key.
# Mod4 is the "OS" key.
#

Button1 = mod1	: window	: f.forcemove
Button1 = mod4	: window	: f.forcemove
Button3 = mod1	: window 	: f.resize
Button3 = mod4	: window 	: f.resize

"Up"     = mod4           : all : f.upworkspace
"Down"   = mod4           : all : f.downworkspace
"Left"   = mod4           : all : f.prevworkspace
"Right"  = mod4           : all : f.nextworkspace


###################
# Raccourcis personnalisés :
#

# - Lancer Thunar :
"e"		= mod4		: all : !"thunar &"

# - Lancer xscreensaver
"L"		= mod4		: all : !"xscreensaver-command -lock &"

# - Maximiser l'affichage d'une fenêtre :
"B"		= mod4		: window : f.fullzoom

# - Lancer firefox
"F"		= mod4		: all : !"firefox &"

# - Lancer thunderbird
"T"		= mod4		: all : !"thunderbird &"

# - Lancer l'outil de captures d'écran :
"C"		= mod4		: all : !"xfce4-screenshooter &"

###################


"Up"     = mod1 | control : all : f.upworkspace
"Down"   = mod1 | control : all : f.downworkspace
"Left"   = mod1 | control : all : f.prevworkspace
"Right"  = mod1 | control : all : f.nextworkspace

"1"      = mod1 | control : all : f.gotoworkspace "1"
"2"      = mod1 | control : all : f.gotoworkspace "2"
"3"      = mod1 | control : all : f.gotoworkspace "3"
"4"      = mod1 | control : all : f.gotoworkspace "4"
"5"      = mod1 | control : all : f.gotoworkspace "5"
"6"      = mod1 | control : all : f.gotoworkspace "6"
"7"      = mod1 | control : all : f.gotoworkspace "7"
"8"      = mod1 | control : all : f.gotoworkspace "8"
"9"      = mod1 | control : all : f.gotoworkspace "9"

"1"      = mod4 : all : f.gotoworkspace "1"
"2"      = mod4 : all : f.gotoworkspace "2"
"3"      = mod4 : all : f.gotoworkspace "3"
"4"      = mod4 : all : f.gotoworkspace "4"
"5"      = mod4 : all : f.gotoworkspace "5"
"6"      = mod4 : all : f.gotoworkspace "6"
"7"      = mod4 : all : f.gotoworkspace "7"
"8"      = mod4 : all : f.gotoworkspace "8"
"9"      = mod4 : all : f.gotoworkspace "9"

"XF86AudioRaiseVolume" = : all : !"mixerctl -w outputs.master+=5"
"XF86AudioLowerVolume" = : all : !"mixerctl -w outputs.master-=5"
#"XF86AudioMute"        = : all : !"mixerctl -w outputs.master=0"

#
# "Windows" style keyboard shortcuts
#

"Tab"    = mod1           : all : f.warpring "next"
"Tab"    = mod1 | s       : all : f.warpring "prev"
"Tab"    = mod4           : all : f.warpring "next"
"Tab"    = mod4 | s       : all : f.warpring "prev"
"space"  = mod1           : window : f.menu "titleops"
"F4"     = mod1           : window : f.delete

#
# "Mac" style keyboard shortcuts
#

"w"      = mod4           : window : f.delete
"m"      = mod4           : window : f.iconify

#
# "evilwm" style keyboard shortcuts
#

# it is useful to be able to spawn a terminal without clicking.
"Return" = mod1 | c : all : !"uxterm &"
"Return" = mod4 | s : all : !"uxterm &"

"slash"  = mod1 | c : all : f.menu "TwmAllWindows"
"slash"  = mod4 : all     : f.menu "TwmAllWindows"
"p"      = mod1 | c : all : f.menu "NetBSD"
"p"      = mod4 : all     : f.menu "NetBSD"

# vi-style directions
"j"      = mod1 | control : window : f.jumpdown "10"
"k"      = mod1 | control : window : f.jumpup "10"
"h"      = mod1 | control : window : f.jumpleft "10"
"l"      = mod1 | control : window : f.jumpright "10"

"j"      = mod4 : window : f.jumpdown "10"
"k"      = mod4 : window : f.jumpup "10"
"h"      = mod4 : window : f.jumpleft "10"
"l"      = mod4 : window : f.jumpright "10"

"j"      = mod4 | s : window : f.changesize "bottom +10"
"k"      = mod4 | s : window : f.changesize "bottom -10"
"h"      = mod4 | s : window : f.changesize "right -10"
"l"      = mod4 | s : window : f.changesize "right +10"

"j"      = mod1 | c | s : window : f.changesize "bottom +10"
"k"      = mod1 | c | s : window : f.changesize "bottom -10"
"h"      = mod1 | c | s : window : f.changesize "right -10"
"l"      = mod1 | c | s : window : f.changesize "right +10"

Pour activer les modifications, suffit de cliquer n'importe où "Restart CTWM"

Si vous avez des soucis avec le son dans Firefox (notamment avec l'environnement de bureau minimaliste ctwm) mais que vous pouvez tout de même regarder des vidéos avec du son dans VLC en choisissant la source audio vous-même dans le menu "audio" (ou idem dans Firefox, mais en installant une extension du genre "audioff - audio device selector" ou "Audio Output Selector"), c'est que c'est le choix de la sortie du son par défaut sur le système qui pose problème.
Il arrive que la source de sortie du son par défaut soit celle de la carte NVIDIA par exemple.. et comme elle est interne, bah, on entend rien !!

Pour cela, même sur l'environnement de bureau minimaliste ctwm, il est possible de changer ce réglage :
Ouvrez un terminal, passez en root

su -

Puis affichez les périphériques audio :

audiocfg list

Vous devriez voir plusieurs entrées, numérotées. L'une d'elle est sélectionée ([*])
Pour sélectionner la source qui vous intéresse (mettons la 2, une carte audio RealTek par exemple, au lieu de la NVIDIA qui est en 1) :

audiocfg default 2

Après cela, rechargez la page youtube ou vidéo sur Firefox et le son arrivera !

Ce script permet de réaliser certaines des opérations de base (mise en place de pare-feu, installation d'environnement de bureau etc...)
Si j'ai le temps, je le continuerai prochainement

Télécharger « global-netbsd.sh »

Pour l'utiliser, téléchargez-le directement depuis votre machine sous NetBSD.
(Il vous faut wget ou fetch pour le télécharger)

wget https://lstu.fr/global-netbsd106 -P /tmp

cd /tmp

chmod +x global-netbsd106

./global-netbsd106

La plupart des syntaxes et des commandes de base du système y sont...
On peut donc l'ouvrir et le décortiquer pour voir comment je procède pour la plupart des opérations de configuration de base.

Le but :
- permettre à des utilisateurs d'accéder à un espace de stockage personnel sur le serveur (via SSH).
- les utilisateurs n'ont pas le droit d'accéder en SSH au serveur, seulement en SFTP
- les utilisateurs doivent être chrootés (enfermés) dans un répertoire particulier sur le serveur (ils ne doivent pas pouvoir en sortir ni consulter l'arborescence antérieure).

On peut utiliser un logiciel (Pro-FTP, VsFTPd etc..)... ou simplement utiliser OpenSSH...
ça se fait en un tour de main !

Je vous montre ici 2 méthodes.
La première est la plus simple, la seconde est un peu plus élaborée.

Méthode 1 :

• On se met en root pour la suite !
  

  su -
  

   

• Création des groupes d'utilisateurs : Créer un groupe pour chaque utilisateur.

  groupadd UTILISATEUR1
  groupadd UTILISATEUR2
  groupadd UTILISATEUR3
  groupadd UTILISATEUR4
  

   

• Création des utilisateurs : Créer les utilisateurs UTILISATEUR1, UTILISATEUR2, UTILISATEUR3 et UTILISATEUR4 sans shell de connexion pour des raisons de sécurité. Assurez-vous de les ajouter au groupe correspondant.

  useradd -G UTILISATEUR1 -m -d /SFTP/UTILISATEUR1 -s /sbin/nologin UTILISATEUR1
  useradd -G UTILISATEUR2 -m -d /SFTP/UTILISATEUR2 -s /sbin/nologin UTILISATEUR2
  useradd -G UTILISATEUR3 -m -d /SFTP/UTILISATEUR3 -s /sbin/nologin UTILISATEUR3
  useradd -G UTILISATEUR4 -m -d /SFTP/UTILISATEUR4 -s /sbin/nologin UTILISATEUR4
  

   

• Définir les mots de passe des utilisateurs : Utiliser la commande passwd pour définir les mots de passe des utilisateurs.

  passwd UTILISATEUR1
  passwd UTILISATEUR2
  passwd UTILISATEUR3
  passwd UTILISATEUR4
  

   

• Création des répertoires : Créer les répertoires nécessaires pour chaque utilisateur.

  mkdir -p /SFTP/UTILISATEUR1/DATA
  mkdir -p /SFTP/UTILISATEUR2/DATA
  mkdir -p /SFTP/UTILISATEUR3/DATA
  mkdir -p /SFTP/UTILISATEUR4/DATA
  

   

• Définir les permissions : Configurer les permissions pour le chroot.

  chown root:wheel /SFTP
  chmod 755 /SFTP
  
  chown root:UTILISATEUR1 /SFTP/UTILISATEUR1
  chmod 755 /SFTP/UTILISATEUR1
  chown UTILISATEUR1:UTILISATEUR1 /SFTP/UTILISATEUR1/DATA
  chmod 700 /SFTP/UTILISATEUR1/DATA
  
  chown root:UTILISATEUR2 /SFTP/UTILISATEUR2
  chmod 755 /SFTP/UTILISATEUR2
  chown UTILISATEUR2:UTILISATEUR2 /SFTP/UTILISATEUR2/DATA
  chmod 700 /SFTP/UTILISATEUR2/DATA
  
  chown root:UTILISATEUR3 /SFTP/UTILISATEUR3
  chmod 755 /SFTP/UTILISATEUR3
  chown UTILISATEUR3:UTILISATEUR3 /SFTP/UTILISATEUR3/DATA
  chmod 700 /SFTP/UTILISATEUR3/DATA
  
  chown root:UTILISATEUR4 /SFTP/UTILISATEUR4
  chmod 755 /SFTP/UTILISATEUR4
  chown UTILISATEUR4:UTILISATEUR4 /SFTP/UTILISATEUR4/DATA
  chmod 700 /SFTP/UTILISATEUR4/DATA
  

   

• Configuration de sshd_config : Modifier le fichier de configuration SSH pour activer le chroot et restreindre les utilisateurs.

  vi /etc/ssh/sshd_config
  

   

  Ajouter/modifier les lignes suivantes :

  Subsystem sftp internal-sftp
  
  Match Group UTILISATEUR1
      ChrootDirectory /SFTP/UTILISATEUR1
      ForceCommand internal-sftp
      AllowTcpForwarding no
      X11Forwarding no
  
  Match Group UTILISATEUR2
      ChrootDirectory /SFTP/UTILISATEUR2
      ForceCommand internal-sftp
      AllowTcpForwarding no
      X11Forwarding no
  
  Match Group UTILISATEUR3
      ChrootDirectory /SFTP/UTILISATEUR3
      ForceCommand internal-sftp
      AllowTcpForwarding no
      X11Forwarding no
  
  Match Group UTILISATEUR4
      ChrootDirectory /SFTP/UTILISATEUR4
      ForceCommand internal-sftp
      AllowTcpForwarding no
      X11Forwarding no
  

   

• Redémarrage du service SSH : Redémarrer le service SSH pour appliquer les modifications.

  service sshd restart

   ---------------------------------------------------------------------------------------------------------------------------------------

  Méthode 2 :

   

  On se met en root pour la suite !
  

  su -

   

  1) Créer le groupe dont les utilisateurs seront autorisés à se connecter en SFTP :
  

  groupadd sftpexclusive
  

  2) Créer un second groupe, qui lui, permettra de désactiver le compte d'un utilisateur :
  

  groupadd nosftp

  Vous l'aurez compris, le principe est très simple : si on veut désactiver le compte d'un utilisateur, il suffira de le rajouter au groupe nosftp avec la commande suivante : (le compte sera alors immédiatement désactivé)
  

  usermod -G nosftp marcel
  

  Peu importe qu'il soit aussi dans l'autre groupe, car l'instruction du groupe interdisant la connexion sera placée avant dans le fichier /etc/ssh/sshd_config (voir plus bas).
  Pour réactiver le compte, il faudra sortir l'utilisateur du groupe.
  

  3) Ajouter le shell /usr/bin/false à la liste des shells autorisés
  

  echo "/usr/bin/false" >> /etc/shells

  Par défaut, ce shell n'est pas autorisé.

  4) Créer l'utilisateur marcel, l'ajouter au groupe sftpexclusive, l'empêcher de se connecter en SSH, lui créer son répertoire d'accueil, lui attribuer un mot de passe et enfin s'occuper des permissions d'accès à son répertoire.
  

  useradd -G sftpexclusive -s /sbin/nologin -m -d /SFTP/marcel marcel

  /sbin/chown root:sftpexclusive /SFTP/marcel
  

  chmod 755 /SFTP/marcel

  Sur NetBSD, le raccourci de la commande chown ne fonctionne pas dans les scripts en shell standard, il faut indiquer le chemin complet (raison pour laquelle je le mets ici en entier).

  5) modifier le fichier de configuration d'OpenSSH, /etc/ssh/sshd_config
  - on va d'abord empêcher l'affichage des bannières d'accueil ainsi que du motd (je trouve ça drôlement emmerdant de voir que lorsqu'une connexion est refusée, openSSH vous présente qu'il s'agît d'un serveur NetBSD !! pas futefute ce truc !).
  La commande suivante modifie directement le fichier sshd_config (à condition que vous n'ayez pas déjà modifié ces éléments avant.. sinon voir plus bas !)
  

  sed -i "" "s/#Banner none/Banner no\nPrintMotd no/" /etc/ssh/sshd_config

  - on va modifier le serveur SFTP indiqué par défaut dans le fichier pour le passer sur le serveur SFTP interne
  - on va également faire en sorte que les utilisateurs n'ait qu'accès à SFTP, les enfermer, et empêcher tout type de forwarding.
  La commande suivante modifie directement le fichier sshd_config (à condition que vous n'ayez pas déjà modifié ces éléments avant.. sinon voir plus bas !)

  sed -i'' "s/\/usr\/libexec\/sftp-server/internal-sftp\n\nMatch Group nosftp\n     ForceCommand \/usr\/bin\/false\n\nMatch Group sftpexclusive\n     ChrootDirectory \/SFTP\/%u\n     ForceCommand internal-sftp\n     AllowTcpForwarding no\n     X11Forwarding no\n/" /etc/ssh/sshd_config

  Pour résumer le 5) :
  voici ce que donne les 2 commandes imbuvables au-dessus dans votre fichier /etc/ssh/sshd_config :

  # no default banner path
  Banner no
  PrintMotd no
  # override default of no subsystems
  
  Subsystem       sftp    internal-sftp
  
  Match Group nosftp
       ForceCommand /usr/bin/false
  
  Match Group sftpexclusive
       ChrootDirectory /SFTP/%u
       ForceCommand internal-sftp
       AllowTcpForwarding no
       X11Forwarding no

  
  6) On redémarre ssh :

  service sshd restart
  

   

1) Configurer NPF.
Fail2ban travaille de concert avec le pare-feu NPF.
Donc première chose : Configurez NPF !
Dans le fichier de règles par défaut founi dans l'article ci-dessus, une table fail2ban est présente ainsi qu'une règle de blocage.
Ils sont indispensables pour pouvoir faire fonctionner fail2ban.

2) Installer Fail2ban
(loguez vous en root avant de commencer)

pkgin -y in fail2ban

cp /usr/pkg/share/examples/rc.d/fail2ban /etc/rc.d/ && echo fail2ban=YES >>  /etc/rc.conf

mkdir /usr/pkg/etc/fail2ban/filter.d/ignorecommands && cp /usr/pkg/share/examples/fail2ban/filter.d/ignorecommands/apache-fakegooglebot /usr/pkg/etc/fail2ban/filter.d/ignorecommands/ && chmod 0644 /usr/pkg/etc/fail2ban/filter.d/ignorecommands/apache-fakegooglebot

3) Créer le fichier /usr/pkg/etc/fail2ban/jail.local contenant vos prisons
(servez-vous des exemples de prisons du fichier jail.conf, mais ne copiez QUE LES EXEMPLES.
Ne faîtes pas une copie du jail.conf en jail.local.

Voici un exemple de jail.local pour configurer un bannissement d'IP en cas de trop nombreuses tentatives de connexion avortées via SSH :

############
# GENERAL 

[DEFAULT]
# Ignorer les adresses IP listées dans cette section
ignoreip = 127.0.0.1/8

# Paramètres de bannissement généraux
bantime  = 3600
maxretry = 5

# Directive pour le bannissement via NPF
banaction = npf



############
# JAILS

[sshd]
enabled  = true
port     = ssh
logpath  = /var/log/authlog


# ... continuer d'ajouter les prisons ici

4) Démarrer fail2ban et faîtes des tests !

service fail2ban start

- Faîtes plus de 5 tentatives de connexion ratées via SSH tout en regardant le résultat du log fail2ban en direct :

tail -f /var/log/fail2ban.log

Lorsque fail2ban annonce qu'il bannit l'IP du contactant, regardez si l'IP est bien apparue dans la table NPF :

npfctl table "fail2ban" list

Enfin, tentez de vous connecter via SSH (pour de vrai), et vérifiez si vous ne parvenez plus à connecter.

Pour débannir avant la fin de l'échéance :

fail2ban-client unban --all

NPF est intégré à NetBSD.
La configuration la plus basique consiste à placer un fichier de règles : /etc/npf.conf

Voici un fichier exemple que j'ai rédigé  :
- Le serveur peut communiquer en stateful sur internet, sans restriction
- Toutes les connexions entrantes sont bloquées, à l'exception du port SSH
- Une table "fail2ban" est créée ainsi qu'une règle de blocage des IP contenues (au cas où vous installeriez fail2ban par la suite).

A vous d'adapter en fonction de vos besoins.
Faîtes attention, la syntaxe est redoutable sur NPF.

########################################################################
 
# 1 - Provide information about your network interface(s):
 
# WAN Interface :
$WAN_if = "wm0"
$WAN_addrs = ifaddrs(wm0)
 
alg "icmp"
 
########################################################################
 
# 2 - RFC1918 (is WAN_addrs public or private IP ?) 
 
# The RFC protects the server from private networks in case it is directly facing the internet.
# (Uncomment only if the WAN IP is a public IP address)
#$RFC1918 = { 10.0.0.0/8, 172.16.0.0/14, 192.168.0.0/16 }
 
########################################################################
 
# 3 - Create a procedure for logging connections:
 
procedure "log" {
        # Send all events to a log (see npfd))
        log: npflog0
}

########################################################################

# 4 - Create tables

# Create a table for fail2ban
table <fail2ban> type ipset
 
########################################################################
 
# 5 - Rule group for the WAN interface:
 
group "WAN" on $WAN_if {

	 # Block IP from fail2ban table
	 block in final from <fail2ban> apply "log"

        # Allow all stateful outgoing traffic by selecting the protocol:
        #pass stateful out final proto tcp all
        #pass stateful out final proto udp all
        #pass stateful out final proto icmp all
        #pass stateful out final proto ipv6-icmp all
 
        # Allow all stateful outgoing traffic (all protocols).
        pass stateful out final all
 
        # SSH: Allow SSH connections to the server
        pass stateful in on $WAN_if proto tcp to $WAN_addrs port ssh

        # Web Server: Allow HTTP and HTTPS connections to the server
        #pass in final proto tcp from any to $WAN_addrs port http
        #pass in final proto tcp from any to $WAN_addrs port https
 
        # DHCP: Allow incoming responses from the DHCP server.
        #pass in family inet4 proto udp from any port bootps to any port bootpc
        #pass in family inet6 proto udp from any to any port "dhcpv6-client"
 
        # Ping: Allow incoming ping requests
        #pass in family inet4 proto icmp icmp-type echo all
        #pass in final proto icmp icmp-type echo all
        #pass in final proto icmp icmp-type timxceed all
        #pass in final proto icmp icmp-type unreach all
        #pass in final proto icmp icmp-type echoreply all
        #pass in final proto icmp icmp-type sourcequench all
        #pass in final proto icmp icmp-type paramprob all
        #pass in final proto ipv6-icmp all
        #pass family inet6 proto ipv6-icmp all
 
        # Traceroute: Allow incoming traceroute.
        #pass in proto udp to any port 33434-33600
 
        # DNS: Allow incoming DNS requests
        #pass stateful out final proto udp to any port domain
 
        # mDNS: Allow local traffic
        #pass in proto udp to any port mdns
 
        # Block private networks:
        #block in final from $RFC1918 apply "log"
        #block out final to $RFC1918 apply "log"
 
        # Forbidden IPs: (separate configuration)
        # ruleset "blacklistd"
 
        # IP Spoofing: Protect yourself (be careful not to cut off SSH access!)
        #block in final from 127.0.0.1 apply "log"
 
        # L2TP/IPSEC-NAT-T Tunnels.
        #pass in final proto esp from any to inet4($WAN_if)
        #pass out final proto esp from inet4($WAN_if) to any
        #pass stateful in final from any to inet4($WAN_if) port "ipsec-nat-t"
        #pass stateful in final from any to inet4($WAN_if) port l2tp
        # IGMP on 224.0.0.1.
        #pass in final proto igmp all
        #pass in final from any to 224.0.0.0/4
 
        # VNC
        #pass in final proto tcp from any to any port 5900
 
 
}
 
 
########################################################################
 
# 6 - Default rule group:
 
group default {
 
       # Loopback : Allow traffic
       pass final on lo0 all
 
        # Close the firewall
       block all apply "log"
 
}
########################################################################

N'oubliez pas la directive dans /etc/rc.conf pour le démarrage du pare-feu au redémarrage du serveur :

echo npf=YES >> /etc/rc.conf

Activez le pare-feu :

service npf start

Voici les commandes principales pour connaître le matériel présent dans votre machine :

1) dmesg

dmesg | less

Cette commande affiche le tampon de messages du noyau, ce qui inclut des informations sur le matériel détecté au démarrage du système. Vous pouvez l'utiliser pour voir les détails des périphériques et des pilotes chargés. Pour faciliter la lecture, vous pouvez filtrer les résultats avec grep, par exemple : dmesg | grep cpu pour les informations sur le processeur.

2) sysctl

sysctl hw.model

sysctl hw.ncpu

sysctl hw.disknames

La commande sysctl permet de consulter et de modifier les paramètres du noyau à l'exécution. Pour obtenir des informations sur le matériel, vous pouvez utiliser sysctl hw. Par exemple (comme montré ci-dessus) sysctl hw.model et sysctl hw.ncpu fourniront respectivement le modèle de votre CPU et le nombre de cœurs. Enfin, sysctl hw.disknames affiche la liste de supports de stockage connectés au système.

3) pcictl

pcictl pci0 list

Commande spécifique pour lister les dispositifs PCI sur votre système. Vous pouvez l'utiliser avec l'option list pour afficher tous les dispositifs PCI. Par exemple, pcictl pci0 list (où pci0 est à adapter selon votre configuration) liste les dispositifs PCI disponibles

4) usbdevs

usbdevs

Liste les dispositifs USB connectés à votre système. Elle est particulièrement utile pour identifier les périphériques USB comme les claviers, les souris, les disques durs externes, etc.

5) lspci et scanpci
Pour les linuxiens, il est possible d'installer ces 2 commandes via le gestionnaire de paquets...

6) hw-probe

hw-probe -upload -all

Comme pour tous les autres BSD, hw-probe est une mine d'or.
Il faut installer le paquet via le gestionnaire de paquets (pkgin -y in hw-probe).
Cela permet également de publier automatiquement un rapport sur la compatibilité de votre matériel avec le système et de permettre aux autre utilisateurs de faire le bon choix.

1 paquet à installer :

pkgin -y in cdrtools

1) Brancher le graveur de CD et insérer un media vierge

2) Repérer l'emplacement du graveur : (se connecter en root d'abord)

cdrecord --scanbus

Vous devriez aisément reconnaître votre graveur.
Pour l'exemple, nous allons dire que notre graveur est sur l'emplacement "1,0,0"

3) Graver votre image .iso

cdrecord dev=1,0,0 speed=4 -v /chemin/du/fichier.iso

La gravure se lance.

Une fois la gravure terminée, comment s'assurer que tout s'est bien passé ?
Comment savoir si le fichier .iso gravé sur notre CD est bien exactement le même que l'original ?
cdrecord ne permet pas de le faire directement lors de la gravure, mais il propose 2 commandes dans son packagin pour nous y aider : readcd et cmp

4) Copier le contenu du CD gravé dans une image iso sur le système :

readcd dev=1,0,0 f=/tmp/disque_lu.iso

5) Effectuer la comparaison :

cmp /chemin/du/fichier.iso /tmp/disque_lu.iso

Là, le résultat est simple : si la commande ne vous retourne rien, c'est que les 2 fichiers sont identiques !

La configuration d'une connexion Wifi est basique sur NetBSD. Il faut tout faire à la main, à l'ancienne.
La page du manuel sur netbsd.org est bien faîte... mais elle oublie un paquet de trucs !


Pré-requis :
- Vous disposez d'une interface Wifi sur votre machine qui est reconnue par le système.
Lorsque vous tapez "ifconfig", vous voyez cette interface wifi (généralement iwm0). Si vous ne la voyez pas, c'est que votre système ne prend pas votre carte en compte, il vous manque des drivers... ça commence donc mal !

La connexion à un réseau wifi repose sur 2 étapes majeures :
1) L'activation des paramètres nécessaires : "Activer le Wifi"
- dhcpcd
- dhcpcd_flags
- pare-feu (!)
- démarrage de la carte wifi
- démarrage de wpa_supplicant

2) Configurer la connexion à un réseau wifi : "Se connecter à un réseau"
- Faire un scan des réseaux disponibles
- Créer la configuration dans /etc/wpa_supplicant.conf
- Recharger wpa_supplicant

Pour ceux qui ont installé l'environnement de bureau XFCE, le paquet 'wpa_gui' vous facilitera le travail de configuration dans /etc/wpa_supplicant.conf, mais il faut d'abord passer l'étape 1 !

Donc, sans plus tarder, voici les étapes

(je précise que toutes les étapes de configuration suivantes se font avec des droits root.
Mettez-vous en root directement !)

1) "Activer le Wifi"

- Le service dhcpcd
2 options. Si vous utilisez un service DHCP habituellement avec votre connexion ethernet, alors vous avez déjà certainement l'entrée suivante dans votre fichier /etc/rc.conf :

dhcpcd=YES

Si c'est le cas, alors votre service dhcpcd démarre donc en même temps que votre serveur.

Si ce n'est pas le cas, réfléchissez à votre besoin d'un service DHCP pour votre connexion Wifi.
Si vous comptez sur un serveur DHCP pour recevoir la configuration IP de votre machine une fois connecté au réseau wifi, alors il faudra démarrer le service au moins une fois (après avoir configuré les flags).
Si vous ne souhaitez pas utiliser de DHCP, alors il faudra faire une configuration IP statique dans /etc/rc.conf (je vous renvoie à l'article du blog concernant les configurations statiques)

Je continue en considérant que vous utiliserez un service DHCP pour votre connexion wifi.

- Indiquer votre carte wifi dans les flags afin que le service dhcpcd diffuse ses requêtes dessus (dans /etc/rc.conf) :

dhcpcd_flags="-qM wm0 iwm0"

wm0 est ma carte ethernet classique, je rajoute simplement ma carte wifi iwm0

Il faut à présent (Re)démarrer le service dhcpcd
Afin que le service dhcpcd diffuse ses requêtes sur la carte wifi, il faut relancer le service dhcpcd.
2 cas de figure : si vous avez placé dhcpcd=YES dans le fichier /etc/rc.conf, alors la commande est

service dhcpcd restart

si vous n'avez PAS placé dhcpcd=YES dans /etc/rc.conf :

service dhcpcd onestart

(rajoutez one devant)

- Le pare-feu !
Si vous avez mis en place un pare-feu sur votre machine (style NPF), il faut absolument que vous précisiez l'interface wifi dans le fichier de règles.. autrement vous ne pourrez rien faire !
Si vous avez suivi le fichier de règles NPF que j'ai rédigé sur le blog, alors vous devez impérativement remplacer wm0 par iwm0 au début du fichier :

# Interface WAN
$WAN_if = "iwm0"
$WAN_addrs = ifaddrs(iwm0)

Puis relancer NPF :

service npf restart

Une autre solution consiste à créer 2 nouvelles entrées $WAN_if2 et $WAN_addrs2 pour l'interface iwm0 et dupliquer les règles du groupe WAN... C'est beaucoup plus long, et vu que généralement je ne me connecte en wifi que de façon temporaire, je fais le remplacement, simplement.
 

- Démarrer l'interface Wifi
2 options là aussi.
Si vous utilisez le wifi de façon temporaire, alors un simple démarrage de l'interface suffit :

ifconfig iwm0 up

Mais si vous souhaitez activer le wifi dès le démarrage du serveur, vous pouvez configurer le démarrage de l'interface wifi automatique. Dans /etc/rc.conf, placez :

ifconfig_iwm0="up"

- Démarrage de wpa_supplicant
2 options là encore.
Si vous utilisez le wifi de façon temporaire, alors un simple démarrage suffit :

service wpa_supplicant onestart

Mais si vous souhaitez activer le wifi dès le démarrage du serveur, vous pouvez configurer le démarrage du service automatiquement. Dans /etc/rc.conf, placez :

wpa_supplicant=YES

Nous sommes prêts pour nous connecter à un réseau à présent.

2) "Se connecter à un réseau"

Pour ceux utilisent l'environnement de bureau XFCE (je n'ai pas testé avec CTWM, il manquera peut-être des paquets). Il est possible d'utiliser un petit logiciel graphique pour faire le reste de la configuration, car c'est la plus délicate et chiante !
Installez-le :

pkgin -y in wpa_gui

A savoir, vous ne pourrez pas démarrer le programme en tapant son nom dans un terminal, le lien ne fonctionne pas.
Il se trouve ici, et ne doit évidemment pas être lancé en tant que root. Il faut redevenir un utilisateur standard (qui doit être membre du groupe wheel !)

/usr/pkg/sbin/wpa_gui

Bon à savoir encore, ne vous avisez pas de quitter le programme, vous ne pourrez pas le relancer, il faudra redémarrer le serveur... ça, c'est un peu pénible !
Dans l'environnement XFCE, on peut simplement fermer la fenêtre et il se miniaturise alors dans la barre du haut.

Une fois le soft lancé, vous n'aurez pas de difficulté à comprendre qu'il faut scanner, double-cliquer sur le réseau qui vous intéresse, entrer son PSK (le secret partagé - le "mot de passe") et votre machine se connectera d'elle-même. un bloc de configuration pour se reconnecter ultérieurement au réseau apparaîtra alors directement dans /etc/wpa_supplicant.conf... Autant dire que c'est de loin la façon la plus rapide de se connecter à un réseau wifi !

-------

Maintenant, on va considérer que vous êtes un pur et dur et que vous bossez à l'ancienne, sans environnement de bureau (et donc vous n'utiliserez pas wpa_gui)

Il faut donc réaliser un scan des réseaux.
2 commandes pour cela :

wlanctl -a

Cette commande vous affichera tous les réseaux wifi disponibles en passant par toutes les cartes wifi disponibles et allumées sur votre serveur..
la sortie est imbuvable !
Le SSID des réseaux (quand il n'est pas caché) se trouve sur la ligne commençant par "ess".
La sécurité des réseaux se voit au paramètre "priva". Mais sans mention explicite de type "rsn", vous n'aurez aucun moyen de connaître le protocole de chiffrement utilisé (wep, wpa2 etc..). Ces réglages sont laissés à l'appréciation des administrateurs réseaux, qui lorsqu'ils sont bons, les cachent !
Cette commande recèle donc beaucoup d'information mais est difficilement utilisable pour nous.

Nous allons en utiliser une autre : wla_cli
Cette commande permet de configurer intégralement une connexion wifi temporaire (elle ne stockera pas la configuration dans /etc/wpa_supplicant.conf). Mais elle présente des désavantages, le plus important étant qu'il est plus difficile de scripter une configuration wifi automatique en l'utilisant.
L'usage classique préfère le bloc de configuration dans /etc/wpa_supplicant.conf, nous allons donc préférer cette méthode.
D'abord, nous réalisons un scan des réseaux :

wpa_cli scan

Ceci va lancer un scan des réseaux en arrière-plan... Sauf que cette commande prend du temps.
Attendez donc au moins 10 secondes avant d'afficher les résultats avec la commande suivante :

wpa_cli scan_results

Les réseaux vont alors apparaître sous une forme bien plus concise et lisible qu'avec wlanctl -a !
Le SSID, le chiffrement, tout y est !

Grâce à ces informations, nous pouvons à présent générer le bloc de configuration dans le fichier /etc/wpa_supplicant.conf.
Je vous donne un exemple de configuration standard pour un réseau classique avec chiffrement en WPA2 :

# ne touchez surtout pas aux 3 lignes ci-dessous du fichier !
ctrl_interface=/var/run/wpa_supplicant
ctrl_interface_group=wheel
update_config=1

# voici un blog de configuration wifi standard :
network={
    ssid="Livebox-trucmuche"
    psk="le-super-mot-de-passe-hypra-trop-long-du-wifi-de-la-box"
    proto=RSN
    key_mgmt=WPA-PSK
    pairwise=CCMP
    auth_alg=OPEN
}

Petite précision : ici, nous utilisons le ssid pour identifier le réseau wifi à rejoindre.
Ce n'est parfois pas pratique du tout, notamment dans le cas de répéteurs ! Plusieurs réseaux possédant le même ssid pourraient apparaître au scan. Certains de ces "réseaux" pourraient ne pas être bons ou ne pas fournir de configuration DHCP par exemple. Il n'y a pas 36 options hélas, vous devrez chercher manuellement lequel est le bon à taton ou utiliser directement l'application wpa_gui qui se chargera de discriminer les différents ssid identiques jusqu'à en trouver un qui délivre une IP.
Dans ce cas, après avoir identifié lequel est le bon, il sera préférable d'utiliser l'option bssid="ADRESSE-MAC" du réseau wifi en question et supprimer l'option ssid, ainsi, votre machine se connectera d'elle-même au bon réseau lors d'un prochain démarrage. C'est d'ailleurs du reste, une méthode un peu plus sûre.

Une fois cette configuration effectuée, il suffit de recharger wpa_supplicant :

service wpa_supplicant reload

Votre machine va alors se connecter au réseau toute seule.
Si vous avez activé les différents services au démarrage du serveur, la machine se reconnectera d'elle-même au redémarrage de l'ordinateur.

Une fois votre expérience Wifi terminée, il ne faudra pas oublier de défaire tout ce qui a été fait ici !

Quelques commandes qui peuvent être fort utiles :

- Tuer le processus wpa_supplicant en cours :

pkill wpa_supplicant

- Relancer l'interface wifi iwm0 :

ifconfig iwm0 down ; ifconfig iwm0 up

- Lancer la connexion en tâche de fond :

wpa_supplicant -B -i iwm0 -c /etc/wpa_supplicant.conf

(il faut être en root pour tout faire)

1) Installer le nécessaire :

pkgin -y in fuse fuse-ntfs fuse-ntfs-3g libntfs ntfsprogs

2) Brancher votre périphérique USB puis repérez-le

dmesg | tail -10

Il apparaîtra sous sdX où X est un chiffre, et il sera associé (ou pas encore) à un ou plusieurs volumes logiques dkY (où Y est un chiffre également).
Pour cet exemple, nous allons prendre sd0

3) Créer une table GPT (en détruisant une éventuelle précédente)

gpt destroy sd0

gpt create -f sd0

4) Créer une partition de type windows

gpt add -t windows sd0

A ce moment, une géométrie est créée (le fameux dkY).

5) Récupérer la géométrie créée :

dmesg | tail -10

Une géométrie va s'afficher, associée à sd0.
Pour cet exemple, nous allons prendre dk3

6) Formater la géométrie en NTFS (avec l'option -f, rapide.. autrement on y sera encore demain)

mkntfs -f /dev/dk3

7) Monter le volume

mkdir -p /media/dk3

env PERFUSE_BUFSIZE=135168 ntfs-3g /dev/dk3 /media/dk3

Il y a un petit problème avec la mise en mémoire tampon et perfuse. la partie "env PERFUSE..." dans la commande permet de contourner le problème.

Autoriser votre utilisateur à utiliser le point de montage et copier des fichiers :

chown marcel:wheel /media/dk3

(mettez l'utilisateur de votre choix !.. c'est pour permettre à un utilisateur d'accéder au contenu)

Prosody est basique mais vraiment très simple à configurer et à mettre en place.
Pour moi, c'est le plus simple de tous.

Nous allons configurer un serveur XMPP de test avec 2 utilisateurs (user1 et user2), la possibilité de créer un groupe ainsi que la possibilité pour les 2 utilisateurs de s'échanger des fichiers.
Pour les besoins du test, nous générerons un certificat SSL auto-signé (mais la mécanique d'incorporation d'un vrai certificat est la même).
Le serveur a l'adresse IP 192.168.95.31

C'est parti.

1) Installer Prosody :
(passer en root)

pkgin -y in prosody

cp /usr/pkg/share/examples/rc.d/prosody /etc/rc.d/

echo "prosody=YES" >> /etc/rc.conf

2) Configurer Prosody

- Générer le certificat SSL auto-signé :

prosodyctl cert generate 192.168.95.31

(par défaut, le certificat et la clef sont générés dans /var/db/prosody/, on va les déplacer et appliquer les droits)

mv /var/db/prosody/* /usr/pkg/etc/prosody/certs/

chmod -R 755 /usr/pkg/etc/prosody/certs

chown -R root:prosody /usr/pkg/etc/prosody/certs

- Faire une copie de sécurité du fichier de configuration de prosody avant de l'éditer

cp /usr/pkg/etc/prosody/prosody.cfg.lua /usr/pkg/etc/prosody/prosody.cfg.lua.BAK

- Ouvrir /usr/pkg/etc/prosody/prosody.cfg.lua et ajoutez l'encart suivant tout en bas du fichier :

-- CONFIGURATION
VirtualHost "192.168.95.31"                       -- domaine ou adresse IP
ssl = {
        certificate = "/usr/pkg/etc/prosody/certs/192.168.95.31.crt";
        key = "/usr/pkg/etc/prosody/certs/192.168.95.31.key";
}
Component "conference.192.168.95.31" "muc"        -- permet de créer un groupe
Component "share.192.168.95.31" "http_file_share" -- permet aux utilisateurs d'échanger des fichiers

- démarrer prosody

service prosody start

3) Créer des utilisateurs

prosodyctl register "user1" "192.168.95.31" "mot-de-passe-user1"

prosodyctl register "user2" "192.168.95.31" "mot-de-passe-user2"

On peut désormais configurer les logiciels clients avec les utilisateurs qu'on a créé (utiliser Psi plus par exemple).
Etant donné qu'il s'agît d'un certificat SSL auto-signé, de nombreux logiciels clients risquent de se braquer... mais on s'en sort quand même in fine.. !

Les commandes locate et glocate sont disponibles sur NetBSD.
Comme toujours, il faut mettre la base à jour : 

/usr/libexec/locate.updatedb

Puis utiliser locate comme on veut, pour localiser des fichiers.
C'est plus rapide que find


Le paquet findutils est également disponible avec pkgin.

pkgin -y in findutils

Il propose les commandes glocate (équivalent gnu de locate) et gupdatedb (équivalent de /usr/libexec/locate.updatedb) pour mettre à jour la base... Inutile d'installer les deux.

Snort est un Système de Détection d'Intrusion et de Prévention (IDS/IPS) largement déployé et reconnu.
Il offre des possibilités qui étendent de beaucoup les capacités du pare-feu classique, en repérant diverses tentatives d'intrusion sur un serveur ou sur un réseau local.

A la manière d'un pare-feu en CLI, Snort utilise une syntaxe pour la création de règles spécifiques de détection.
Un jeu de règles de la communauté est d'ailleurs librement téléchargeable depuis le site snort.org et divers abonnements ou liste de règles propriétaires plus actualisées et plus spécifiques peuvent être acquises chez divers fournisseurs sur internet.

Il se configure de plusieurs façons, en tant que plugin sur PFsense (et d'autres..) ou directement en CLI sur un serveur (ou un poste de travail).

Nous allons voir comment le manipuler en CLI.
Bien entendu, la doc officielle est exhaustive, et donc à consulter.

Ici nous nous contenterons du strict minimum (et comment régler quelques petits problèmes avec NetBSD)

Vous devez disposer a minima d'un système NetBSD 9.3 minimal avec pkgin, et une connexion SSH n'est pas superflue (surtout pour les copiers/collers ci-dessous).

La configuration se fait en root.

1) Installer Snort

pkgin -y in snort pulledpork libpcap daq

2) Permettre le démarrage au lancement du serveur :

cp /usr/pkg/share/examples/rc.d/snort /etc/rc.d/snort ; echo "snort=YES" >> /etc/rc.conf

3) Télécharger manuellement les règles communautaires :
https://www.snort.org/downloads/community/community-rules.tar.gz

Ce dossier compressé contient plusieurs fichiers dont un snort.conf, le fichier community.rules et divers autres.

Il ne faut pas utiliser ce fichier snort.conf mais celui fourni avec pkgin sur NetBSD car il y a trop de paramètres qui sont inadaptés à NetBSD dans le fichier snort.conf communautaire.

4) Configurer Snort
- Il vaut également mieux faire une copie de sécurité du fichier snort.conf fourni avec le paquet avant de commencer la configuration.

cp /usr/pkg/etc/snort/snort.conf /usr/pkg/etc/snort/snort.conf.BAK

- Indiquer les réseaux WAN et LAN dans le fichier /usr/pkg/etc/snort/snort.conf
Les règles sont conçues pour utiliser les variables HOME_NET et EXTERNAL_NET et agir tantôt sur ce qui arrive uniquement via EXTERNAL_NET (cas typique d'un serveur web) ou entre EXTERNAL_NET et HOME_NET (le cas du pare-feu).
Elles doivent donc être correctement configurées.

HOME_NET : C'est le réseau LAN.
Prenons l'exemple d'un 192.168.1.0/24
La commande va directement faire le changement dans le fichier snort.conf.
A vous d'adapter ou d'ouvrir le fichier snort.conf directement pour faire les modifications manuellement.

sed -i 's/ipvar HOME_NET any/ipvar HOME_NET 192\.168\.1\.0\/24/' /usr/pkg/etc/snort/snort.conf

EXTERNAL_NET : C'est le réseau WAN
Si votre serveur est en frontal, alors le WAN, c'est internet... donc on laisse "any" par défaut.
Tout ce qui n'est pas HOME_NET est donc EXTERNAL_NET (il faut entendre le "any" ainsi)
Dans le cas où vous feriez un test avec des VM, il faudra bien évidemment préciser le réseau WAN simulé (qui sera probablement un réseau 192.. ou autre)

- les ipvar
Il est essentiel de configurer les autres ipvar du fichier snort.conf pour aider Snort à mieux protéger le réseau en lui indiquant l'emplacement IP des serveurs "à risque" (Serveurs De Noms locaux, FTP, SSH etc..)

Exemple : 
Dans le cas où le réseau local abriterait un serveur SFTP, il faut renseigner l'ipvar correspondant : 

ipvar $SSH_SERVERS 192.168.1.5

- DAQ et pcap
Snort a besoin de DAQ et pcap pour écouter les segments, il est nécessaire d'indiquer à Snort où se trouvent les modules DAQ car il ne les trouve hélas pas tout seul sur NetBSD.
La commande suivante procède à la configuration directement dans snort.conf :

sed -i 's/# config daq_dir: <dir>/config daq_dir: \/usr\/pkg\/lib\/daq/' /usr/pkg/etc/snort/snort.conf

5) Charger les règles communautaires : 

- Créer un fichier /usr/pkg/etc/snort/rules/community.rules et y copier/coller tout le contenu du fichier du même nom téléchargé depuis https://www.snort.org/downloads/community/community-rules.tar.gz

nano /usr/pkg/etc/snort/rules/community.rules

- Puis, commenter (ou supprimer) toutes les lignes "include $RULE_PATH/XXXXXX" de /usr/pkg/etc/snort/snort.conf et écrire celle-ci (toutes les règles communautaires étant inclues dans un seul fichier, laisser d'autres include $RULE_PATH/XXXX fera planter le test de configuration futur)

include $RULE_PATH/community.rules

(cela indique à Snort de rechercher les règles uniquement dans le fichier community.rules créé précédemment)

6) Tester la configuration de Snort

Snort est configuré à présent, mais il faut tester tout cela avant d'essayer de le démarrer :

snort -T -c /usr/pkg/etc/snort/snort.conf

Bien lire les éventuels codes d'erreur ! Si c'est ok, alors Snort peut être démarré pour de vrai.

7) Démarrer Snort

Snort peut être démarré dans 2 modes différents : en sniffer (surveille simplement les segments) ou en IPS.
Dans les 2 cas, Snort se met en écoute sur une interface. Traditionnellement, c'est sur la WAN (wm0 ici) car la détection se fait ainsi AVANT le NATage vers une interface LAN.
Cependant, il est tout à fait possible de configurer Snort sur plusieurs interfaces en même temps (en fonction des ressources de votre serveur .. parceque à consomme !!)
La version 3 (qui n'est pas encore portée sur NetBSD) permet plus facilement de faire cela que la 2.X.. donc on y touche pas ici.

Le mode sniffer permet d'établir des règles plus précises en fonction du trafic de votre réseau.
On procède généralement à une première phase de sniffer sur plusieurs jours (voir semaines) avant de démarrer vraiment l'IPS, afin d'adapter les règles en fonction du trafic sur notre réseau (et pas foutre un bordel monumental dès le premier jour !).

Pour démarrer Snort en mode sniffer (affiche sur la console tout ce qui passe) :

snort -c /usr/pkg/etc/snort/snort.conf -v -b -i wm0 -l /var/log/snort

Pour démarrer Snort en mode IDS (détection d'intrusions) sur la WAN (wm0) en arrière-plan (nohup ... &)

nohup snort -c /usr/pkg/etc/snort/snort.conf -i wm0 -l /var/log/snort &

Dernière chose, la rédaction d'une règle de test n'est pas superflue (pour s'assurer que tout fonctionne) !

Les logs d'alerte se trouvent dans /var/log/snort/

Attention, ils peuvent TRES TRES vite saturer le serveur si la configuration des règles renvoie trop d'alertes !
L'utilisation d'un outil comme "logrotate" est fondamentale.
Egalement, l'envoi automatisé des alertes (par mail par exemple ou via un SIEM) est indispensable pour réagir au plus vite.

8) Configurer Pulledpork

Pulledpork sert à télécharger et mettre à jour les règles de Snort automatiquement.

Le fichier à configurer est /usr/pkg/etc/pulledpork/pulledpork.conf
Il faut un Oinkcode -> s'inscrire sur le site de Snort, avoir un abonnement etc...
Placer l'Oinkcode dans le fichier tel que : rule_url=https://www.snort.org/reg-rules/|snortrules-snapshot.tar.gz|<oinkcode>

Si on ne veut pas s'inscrire, il suffit de commenter la ligne rule_url=https://www.snort.org/reg-rules/|snortrules-snapshot.tar.gz|<oinkcode>, une autre ligne permet de télécharger un fichier de règles basiques.

- Charger les règles :

pulledpork -c /usr/pkg/etc/pulledpork/pulledpork.conf

En fonction de l'abonnement ou des règles téléchargées, il sera probablement nécessaire d'ajouter une ligne "include $RULE_PATH/NOM-DU-JEU-DE-REGLE" dans le snort.conf

Cette dernière commande peut être mise en tâche cron régulièrement pour obtenir la dernière mise-à-jour des règles.

L'idée est de créer un stockage répliqué simultanément sur 3 serveurs (3 noeuds) grâce à GlusterFS, minimisant ainsi le risque de voir les données perdues si jamais l'un des noeuds tombe.

Dans ce tuto, je reste très basique, je suis d'aussi près que possible le Quick Start de la page officielle de GlusterFS.
Néanmoins, il faut l'adapter à NetBSD... ce que nous allons faire.

Voici comment

Pré-requis : 
- NetBSD 9.3, installation minimale avec ntp et ntpd au démarrage (c'est obligatoire !), pkgin et SSH.
- Il est recommandé de créer une partition séparée pour /var/log a minima
- 3 serveurs a minima (noms d'hôtes NET-1, NET-2, NET-3), avec une IP configurée (par exemple NET-1 : 10.10.10.1, NET-2 : 10.10.10.2 et NET-3 : 10.10.10.3)
- 2 supports de stockage par serveur : l'un pour l'OS, le second pour le stockage distribué. Même taille pour chaque serveur. ça peut être du stockage SATA ou USB. Les brancher/connecter avant de configurer.

On se logue en root pour toutes les opérations : 

Les opérations suivantes sont à faire sur TOUS LES NOEUDS :

1) Installer GlusterFS :

pkgin -y in glusterfs

2) Configurer NetBSD pour GlusterFS :
(copiez/collez via SSH)

printf "\n" >> /etc/sysctl.conf ; echo "# GLUSTERFS" >> /etc/sysctl.conf ; echo "kern.sbmax=4194304" >> /etc/sysctl.conf ; echo "net.inet.tcp.sendbuf_max=1048576" >> /etc/sysctl.conf ; echo "net.inet.tcp.recvbuf_max=1048576" >> /etc/sysctl.conf ; echo "vfs.ffs.extattr_autocreate=1024" >> /etc/sysctl.conf ; ln -s /usr/pkg/sbin/mount_glusterfs /sbin/mount_glusterfs ; reboot 

La commande ci-dessus ajoute les lignes suivantes au fichier /etc/sysctl.conf  et créée un lien symbolique pour le montage de glusterfs, puis redémarre le serveur pour les changements prennent effet.

# GLUSTERFS
kern.sbmax=4194304
net.inet.tcp.sendbuf_max=1048576
net.inet.tcp.recvbuf_max=1048576
vfs.ffs.extattr_autocreate=1024

3) Activer glusterd au démarrage du serveur :

cp /usr/pkg/share/examples/rc.d/* /etc/rc.d/ ; echo "glusterd=YES" >> /etc/rc.conf

4) Préparer les disques pour gluster :
- On repère le disque de stockage ajouté sur le serveur : 

sysctl hw.disknames

On peut aussi repérer le disque et l'identifier grâce à des informations comme sa taille via

dmesg | less

(mon disque ajouté est sd1, nous allons donc manipuler rsd1)
(si mon dique ajouté avait été wd1, nous aurions manipulé rwd1)

- On crée une table GPT sur le disque en supprimant une éventuelle table MBR précédente puis une partition de type FFS

gpt create -f /dev/rsd1 ; gpt add -t ffs /dev/rsd1

A ce moment s'affiche un volume logique créé.. du type dkX (pour moi : dk2).
S'il ne s'affiche pas expressement, on peut le retrouver avec la commande suivante : 

dmesg | grep sd1

- Créer le système de fichiers FFSv1 (attention, il semblerait que la FFSv2 ne soit pas compatible avec GlusterFS sur NetBSD)

newfs -O1 /dev/dk2

5) Monter la partition :
- Créer un point de montage :

mkdir -p /data/brick1

- Monter la partition : 

mount -o extattr /dev/dk2 /data/brick1

A ce moment-là, une erreur survient sur NetBSD 9. Il semblerait qu'elle ait été corrigée sur NetBSD 10 puisqu'en refaisant la procédure, je n'ai pas eu d'erreur.
Pour celles et ceux qui rencontreraient une erreur, c'est normal, pas de panique !
La partition se monte, mais sans les attributs étendus.
Pour utiliser les extattr, il nous faut créer des dossiers supplémentaires désormais :

mkdir -p /data/brick1/.attribute/system ; mkdir -p /data/brick1/.attribute/user

- Démonter la partition : 

umount -f /data/brick1

- A présent, la remonter : 

mount -o extattr /dev/dk2 /data/brick1

Cette fois, il n'y a pas d'erreur au montage ! Les attributs étendus se créent.

6) Lancer le service glusterd

service glusterd start

7) Ajouter les autres noeuds au fichier /etc/hosts de chaque noeud : 
- Les correspondances suivantes entre les IP de chaque noeud et les hostname doivent se trouver dans les fichiers /etc/hosts de TOUS LES NOEUDS ! 

10.10.10.1	NET-1
10.10.10.2	NET-2
10.10.10.3	NET-3

L'opération suivante est à faire uniquement sur UN SEUL NOEUD (NET-1 par exemple) :

8) Ajouter les autres noeuds : 

gluster peer probe NET-2

gluster peer probe NET-3

L'opération suivante est à faire sur TOUS LES NOEUDS :

9) Créer le dossier de la partition glusterFS

mkdir /data/brick1/gv0

Les opérations suivantes sont à faire uniquement sur UN SEUL NOEUD (NET-1 par exemple) :

10) Créer le volume gv0 sur tous les noeuds simultanément.

gluster volume create gv0 replica 3 NET-1:/data/brick1/gv0 NET-2:/data/brick1/gv0 NET-3:/data/brick1/gv0

11) Démarrer le volume gv0 créé :

gluster volume start gv0

L'opération suivante est à faire sur TOUS LES NOEUDS :

12) Créer un point de montage et monter gv0 dessus

mkdir /SFTP

mount -t glusterfs NET-1:/gv0 /SFTP

Les opérations suivantes sont à faire uniquement sur UN SEUL NOEUD (NET-1 par exemple) :

13) Tester le volume GlusterFS depuis NET-1 :
Créer un simple fichier texte depuis NET-1 :

touch /SFTP/coucou.txt

Vérifier à présent s'il est présent sur les autres serveurs dans /SFTP