Linux
- Firewall / Pare-feu
- Hetzner Cloud - IPv6 Setup on Ubuntu 22.04
- Runcloud + Iptable + redirection + proxypass
- comment créer des alias de commandes temporaires et persistants ?
Firewall / Pare-feu
Installation d'un pare-feu
Installation de iptables
apt install iptables
Création du process et des règles
Je créer un fichier firewall qui va être exécuter au démarrage et gérer par systemctl.
Son but et d'indiquer quoi faire quand on start le process et quand on le stop et la gestion du status.
nano /etc/init.d/firewall
#! /bin/sh
### BEGIN INIT INFO
# Provides: Firewall
# Required-Start: $remote_fs $syslog
# Required-Stop: $remote_fs $syslog
# Default-Start: 2 3 4 5
# Default-Stop: 0 1 6
# Short-Description: Firewall
# Description: Firewall1
### END INIT INFO
IPT=/sbin/iptables
IP6T=/sbin/ip6tables
do_start() {
# Efface toutes les regles en cours. -F toutes. -X utilisateurs
$IPT -t filter -F
$IPT -t filter -X
$IPT -t nat -F
$IPT -t nat -X
$IPT -t mangle -F
$IPT -t mangle -X
$IP6T -t filter -F
$IP6T -t filter -X
$IP6T -t mangle -F
$IP6T -t mangle -X
# strategie (-P) par defaut : bloc tout l'entrant le forward et autorise le sortant
$IPT -t filter -P INPUT DROP
$IPT -t filter -P FORWARD DROP
$IPT -t filter -P OUTPUT ACCEPT
$IP6T -t filter -P INPUT DROP
$IP6T -t filter -P FORWARD DROP
$IP6T -t filter -P OUTPUT ACCEPT
# Loopback
$IPT -t filter -A INPUT -i lo -j ACCEPT
$IPT -t filter -A OUTPUT -o lo -j ACCEPT
$IP6T -t filter -A INPUT -i lo -j ACCEPT
$IP6T -t filter -A OUTPUT -o lo -j ACCEPT
# Permettre a une connexion ouverte de recevoir du trafic en entree
$IPT -t filter -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
$IP6T -t filter -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
echo "firewall started [OK]"
}
# fonction qui arrete le firewall
do_stop() {
# Efface toutes les regles
$IPT -t filter -F
$IPT -t filter -X
$IPT -t nat -F
$IPT -t nat -X
$IPT -t mangle -F
$IPT -t mangle -X
$IP6T -t filter -F
$IP6T -t filter -X
$IP6T -t mangle -F
$IP6T -t mangle -X
# remet la strategie
$IPT -t filter -P INPUT ACCEPT
$IPT -t filter -P OUTPUT ACCEPT
$IPT -t filter -P FORWARD ACCEPT
$IP6T -t filter -P INPUT ACCEPT
$IP6T -t filter -P OUTPUT ACCEPT
$IP6T -t filter -P FORWARD ACCEPT
#
echo "firewall stopped [OK]"
}
# fonction status firewall
do_status() {
# affiche les regles en cours
clear
echo Status IPV4
echo -----------------------------------------------
$IPT -L -n -v
echo
echo -----------------------------------------------
echo
echo status IPV6
echo -----------------------------------------------
$IP6T -L -n -v
echo
}
case "$1" in
start)
do_start
exit 0
;;
stop)
do_stop
exit 0
;;
restart)
do_stop
do_start
exit 0
;;
status)
do_status
exit 0
;;
*)
echo "Usage: /etc/init.d/firewall {start|stop|restart|status}"
exit 1
;;
esac
Nous avons ici la configuration la plus bloquante (trafic sortant uniquement): Uniquement le trafic local et les connexion établie vers l'extérieur en IPv4 et IPv6.
Pour ajouter des autorisation, par exemple l'ICMP (ping), dans do_start()
ajouter:
# ICMP
$IPT -t filter -A INPUT -p icmp -j ACCEPT
$IP6T -t filter -A INPUT -p ipv6-icmp -j ACCEPT
Votre do_start()
ressemble à ça:
do_start() {
# Efface toutes les regles en cours. -F toutes. -X utilisateurs
$IPT -t filter -F
$IPT -t filter -X
$IPT -t nat -F
$IPT -t nat -X
$IPT -t mangle -F
$IPT -t mangle -X
$IP6T -t filter -F
$IP6T -t filter -X
$IP6T -t mangle -F
$IP6T -t mangle -X
# strategie (-P) par defaut : bloc tout l'entrant le forward et autorise le sortant
$IPT -t filter -P INPUT DROP
$IPT -t filter -P FORWARD DROP
$IPT -t filter -P OUTPUT ACCEPT
$IP6T -t filter -P INPUT DROP
$IP6T -t filter -P FORWARD DROP
$IP6T -t filter -P OUTPUT ACCEPT
# Loopback
$IPT -t filter -A INPUT -i lo -j ACCEPT
$IPT -t filter -A OUTPUT -o lo -j ACCEPT
$IP6T -t filter -A INPUT -i lo -j ACCEPT
$IP6T -t filter -A OUTPUT -o lo -j ACCEPT
# Permettre a une connexion ouverte de recevoir du trafic en entree
$IPT -t filter -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
$IP6T -t filter -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
# ICMP
$IPT -t filter -A INPUT -p icmp -j ACCEPT
$IP6T -t filter -A INPUT -p ipv6-icmp -j ACCEPT
echo "firewall started [OK]"
}
Voici une liste de règles souvent utile
# ICMP
$IPT -t filter -A INPUT -p icmp -j ACCEPT
$IP6T -t filter -A INPUT -p ipv6-icmp -j ACCEPT
# DNS:53
$IPT -t filter -A INPUT -p tcp --dport 53 -j ACCEPT
$IPT -t filter -A INPUT -p udp --dport 53 -j ACCEPT
$IP6T -t filter -A INPUT -p tcp --dport 53 -j ACCEPT
$IP6T -t filter -A INPUT -p udp --dport 53 -j ACCEPT
#FTP:20+21 - FTP pasv: 10 090 - 10 100
$IPT -t filter -A INPUT -p tcp --dport 20 -j ACCEPT
$IP6T -t filter -A INPUT -p tcp --dport 20 -j ACCEPT
$IPT -t filter -A INPUT -p tcp --dport 21 -j ACCEPT
$IP6T -t filter -A INPUT -p tcp --dport 21 -j ACCEPT
$IPT -t filter -A INPUT -p tcp --dport 10090:10100 -j ACCEPT
$IP6T -t filter -A INPUT -p tcp --dport 10090:10100 -j ACCEPT
# SSH:22
# ATTENTION, indiques bien ton port personnalisé si tu l'as changé
$IPT -t filter -A INPUT -p tcp --dport 22 -j ACCEPT
$IP6T -t filter -A INPUT -p tcp --dport 22 -j ACCEPT
# HTTP:80 (Serveur Web)
$IPT -t filter -A INPUT -p tcp --dport 80 -j ACCEPT
$IP6T -t filter -A INPUT -p tcp --dport 80 -j ACCEPT
# HTTPS:443 (Serveur Web)
$IPT -t filter -A INPUT -p tcp --dport 443 -j ACCEPT
$IP6T -t filter -A INPUT -p tcp --dport 443 -j ACCEPT
# SNMP:161 (Monitoring)
$IPT -t filter -A INPUT -p udp --dport 161 -j ACCEPT
$IP6T -t filter -A INPUT -p udp --dport 161 -j ACCEPT
# SMTP:25 (Mail)
$IPT -t filter -A INPUT -p tcp --dport 25 -j ACCEPT
$IP6T -t filter -A INPUT -p tcp --dport 25 -j ACCEPT
# POP3:110 (Mail)
$IPT -t filter -A INPUT -p tcp --dport 110 -j ACCEPT
$IP6T -t filter -A INPUT -p tcp --dport 110 -j ACCEPT
# IMAP:143 (Mail)
$IPT -t filter -A INPUT -p tcp --dport 143 -j ACCEPT
$IP6T -t filter -A INPUT -p tcp --dport 143 -j ACCEPT
Il faut maintenant rendre exécutable de fichier
chmod +x /etc/init.d/firewall
Les prochaines étapes vont rendre actif le pare-feu. Si vous êtes en SSH et que une règle n'autorise pas le SSH vous risquer de vous auto bloqué a la prochaine connexion. Assurez-vous d'avoir un accès directe à la machine pour gérer le cas ou vous seriez dans l'incapacité de vous reconnecter.
Premier démarrage du pare-feu
/etc/init.d/firewall start
Gestion par systemctl
update-rc.d firewall defaults
systemctl enable firewall
systemctl start firewall
systemctl status firewall
Cela devrais vous indiquer quelque chose du genre:
● firewall.service - LSB: Firewall
Loaded: loaded (/etc/init.d/firewall; generated)
Active: active (exited) since *** ****-**-** **:**:** ****; * ago
Docs: man:systemd-sysv-generator(8)
Process: ***** ExecStart=/etc/init.d/firewall start (code=exited, status=0/SUCCESS)
***. ** **:**:** monitor systemd[1]: Starting LSB: Firewall...
***. ** **:**:** monitor firewall[30462]: firewall started [OK]
***. ** **:**:** monitor systemd[1]: Started LSB: Firewall.
Hetzner Cloud - IPv6 Setup on Ubuntu 22.04
Hello,
I ordered a VPS Cloud from Hetzner, and it's true that once delivered, you need to configure IPv6.
For my setup, I'm using a CX22 - Cloud, running Ubuntu 22.04.
Start by updating your Cloud server:
apt update && apt upgrade -y
nano /etc/netplan/50-cloud-init.yaml
Here is the default configuration:
# This file is generated from information provided by the datasource. Changes
# to it will not persist across an instance reboot. To disable cloud-init's
# network configuration capabilities, write a file
# /etc/cloud/cloud.cfg.d/99-disable-network-config.cfg with the following:
# network: {config: disabled}
network:
version: 2
ethernets:
eth0:
addresses:
- 2a01:XXX:XXX:XXX::1/64
dhcp4: true
match:
macaddress: 96:XX:XX:XX:XX:XX
nameservers:
addresses:
- 2a01:XXX:XXXX::add:1
- 2a01:XXX:XXXX::add:2
routes:
- on-link: true
to: default
via: fe80::1
set-name: eth0
You can make a backup copy:
cp /etc/netplan/50-cloud-init.yaml /etc/netplan/50-cloud-init.yaml.bck
Now, on line 11, change 2a01:XXX:XXX:XXX::1/64
to 2a01:XXX:XXX:XXX::24/64
. For this example, I changed it to ::24
.
# This file is generated from information provided by the datasource. Changes
# to it will not persist across an instance reboot. To disable cloud-init's
# network configuration capabilities, write a file
# /etc/cloud/cloud.cfg.d/99-disable-network-config.cfg with the following:
# network: {config: disabled}
network:
version: 2
ethernets:
eth0:
addresses:
- 2a01:XXX:XXX:XXX::24/64 # change ::1 to ::24 here
dhcp4: true
match:
macaddress: 96:XX:XX:XX:XX:XX
nameservers:
addresses:
- 2a01:XXX:XXXX::add:1
- 2a01:XXX:XXXX::add:2
routes:
- on-link: true
to: default
via: fe80::1
set-name: eth0
Save the changes and run the following command:
netplan try
If you see this message:
** (process:16923): WARNING **: 02:56:51.010: Permissions for /etc/netplan/50-cloud-init.yaml are too open. Netplan configuration should NOT be accessible by others.
Press Enter, then run this command to fix the permissions issue:
sudo chmod 600 /etc/netplan/50-cloud-init.yaml
Then, rerun the command:
netplan try
Finally, apply the changes with the following command:
netplan apply
To verify everything is working, try these commands:
curl -6 https://ip.hetzner.com
ping -6 google.com
ip a
Runcloud + Iptable + redirection + proxypass
il faut desactiver firewalld de runcloud pour minimiser les soucis
Quand on met ce script
#!/bin/bash
sleep 2
echo "FIREWALL OK";
#Install iptables if you haven't already
#Alternatively use packet manager of your choice
#apt-get install iptables
#Allow all incoming traffic to begin with
sudo iptables -P INPUT ACCEPT
#Clean out any existing input rules. You may also remove the "INPUT" argument and run only "iptables -F" to clear all chains. When doing so, make sure there are no rules in other chains that you still need (list via "iptables -L"), for example Oracle cloud servers will have preset rules, which should not be removed.
sudo iptables -F INPUT
#Allow all internal connections
sudo iptables -A INPUT -i lo -j ACCEPT
#Allow continuing setup connections
sudo iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
#Allow ssh, adjust port if you run it on non-default
sudo iptables -A INPUT -p tcp --dport 22 -j ACCEPT #SSH
sudo iptables -A INPUT -p tcp --dport 80 -j ACCEPT
sudo iptables -A INPUT -p tcp --dport 443 -j ACCEPT
sudo iptables -A INPUT -p tcp --dport 34210 -j ACCEPT
sudo iptables -A INPUT -p udp --dport 22 -j ACCEPT #SSH
sudo iptables -A INPUT -p udp --dport 443 -j ACCEPT
sudo iptables -A INPUT -p udp --dport 34210 -j ACCEPT
# Ajouter les r�gles de redirection
sudo iptables -t nat -A PREROUTING -p udp --dport 50120 -j DNAT --to-destination 176.9.63.27:40120
sudo iptables -t nat -A PREROUTING -p tcp --dport 50120 -j DNAT --to-destination 176.9.63.27:40120
# Ajouter la r�gle de masquage
sudo iptables -t nat -A POSTROUTING -j MASQUERADE
# Activer l'IP forwarding temporairement
sudo sysctl -w net.ipv4.ip_forward=1
sudo iptables -P INPUT DROP
#Block all forwarding
#sudo iptables -P FORWARD DROP
#Allow all outgoing
sudo iptables -P OUTPUT ACCEPT
sudo iptables -A INPUT -p icmp --icmp-type echo-request -j DROP
sudo iptables -A OUTPUT -p icmp --icmp-type echo-request -j DROP
Nous ne pouvons plus ping alors il faut modifier le resolv.conf pour mettre des nameserver autre que celui present mais apres un reboot ça disparait.
Pour ajouter des lignes permanentes dans /etc/resolv.conf
vous pourriez installer le resolvconf
ligne de commande:
sudo apt install resolvconf
alors tu dois éditer /etc/resolvconf/resolv.conf.d/head
et ajoutez les lignes permanentes dont vous avez besoin. Par exemple:
nameserver 8.8.8.8
nameserver 1.1.1.1
et enfin exécutez ces commandes :
sudo resolvconf --enable-updates
sudo resolvconf -u
Un petit script pour reset l'iptables au cas ou
#!/bin/bash
# Vider toutes les règles
sudo iptables -F
sudo iptables -t nat -F
sudo iptables -t mangle -F
sudo iptables -t raw -F
# Supprimer toutes les chaînes personnalisées
sudo iptables -X
sudo iptables -t nat -X
sudo iptables -t mangle -X
sudo iptables -t raw -X
# Réinitialiser toutes les politiques par défaut à ACCEPT
sudo iptables -P INPUT ACCEPT
sudo iptables -P FORWARD ACCEPT
sudo iptables -P OUTPUT ACCEPT
# Vérifier les règles
sudo iptables -L -v -n
sudo iptables -t nat -L -v -n
Et ça devrait etre bon vérifié si ping google.com focntionne bien et que rundcloud agent fonctionne bien et est détecter par le panel rundcloud.
comment créer des alias de commandes temporaires et persistants ?
Lister les alias sous Linux
Pour lister les alias actuellement présents sur une machine Linux, ce n'est pas bien compliqué ! À partir du prompt du Terminal, il suffit d'exécuter cette commande :
alias
Comment créer un alias ?
Avant de créer un alias, vous devez savoir qu'il y a deux types d'alias :
- Les alias temporaires (valident dans la session en cours uniquement)
- Les alias permanents (qui seront toujours présents après redémarrage de la machine)
A. Créer un alias temporaire
Commençons par aborder la création d'un alias temporaire. La syntaxe pour créer un alias temporaire est la suivante :
alias <nom de l'alias>="<commande associée à l'alias>"
Prenons pour exemple la commande ci-dessous dont l'objectif est de lire en temps réel les dernières lignes du fichier de log "/var/log/auth.log" (lié à l'authentification sous Linux) :
sudo tail -f /var/log/auth.log
On pourrait associer cette commande à l'alias suivant :
authlog
Dans ce cas, l'alias suivant doit être créé :
alias authlog="sudo tail -f /var/log/auth.log"
Ensuite, il suffit d'exécuter la nouvelle commande pour appeler la commande complète :
authlog
Ce qui est cool, c'est que l'on peut profiter de l'autocomplétion lors de la saisie d'un alias, comme avec une commande classique, pour gagner encore plus de temps !
Le problème de cet alias temporaire, c'est qu'il est valide uniquement pour la session en cours...
B. Créer un alias persistant
Pour conserver un alias après redémarrage du système, ou après une déconnexion puis un reconnexion à une session Linux, il convient de créer des alias persistants. Pour cela, l'alias doit être ajouté au fichier de configuration de votre profil shell. Par défaut, Debian utilise Bash donc ce sera au sein du fichier "~/.bashrc.
Désormais, à partir d'un éditeur de texte tel que nano ou vim, il va falloir éditer ce fichier pour ajouter l'alias :
SRV-DEB-1: nano ~/.bashrc
Dans ce fichier, l'alias doit être ajouté en respectant la même syntaxe que pour créer un alias temporaire. La seule différence c'est que la commande est ajoutée dans un fichier plutôt que de l'exécuter dans le Terminal. On ajoute tout simplement le contenu à la fin du fichier. On peut ajouter autant d'alias que l'on souhaite (un par ligne).
# Alias pour lire le contenu du fichier auth.log alias authlog="sudo tail -f /var/log/auth.log"
On enregistre et on ferme le fichier : le tour est joué !
on check nos alias
source ~/.bashrc
L'occasion de lister les alias avec la commande évoquée précédemment afin de voir qu'il est bien présent dans la liste !