Flavien PERIER - Environnement Manjaro

Cet article traite de la mise en place d'un poste de développeur sous Manjaro. L'objectif consiste à avoir un système d'exploitation stable et sécurisé qui réponde à un maximum d'usages.

Desktop

Desktop Neofetch

Installation du système

Pour ma part, je me base sur la version minimale de la distribution Manjaro avec l'environnement XFCE. Cet environnement est plus léger que Gnome ou KDE, mais présente néanmoins tous les avantages d'un véritable gestionnaire de bureau. Malgré sa légèreté, il n'y a pas de compromis sur les fonctionnalités.

Quant au choix de Manjaro, il s'agit d'une distribution de type rolling, c'est-à-dire qu'elle est constamment mise à jour et qu'on n’aura donc pas de réinstallation complète du système à faire toutes les quelques années pour le passage à la version majeure suivante. Ce type de distribution est assez adapté à des configurations desktop, mais complètement inadapté à des configurations serveurs, car les paquets et le noyau du système d'exploitation étant constamment mis à jour vers les dernières versions, des instabilités peuvent fréquemment survenir. Inacceptable pour un système de production, mais rarement vraiment bloquant (du moins pas longtemps, jusqu’à la mise à jour suivante) sur un pc personnel.

L'autre avantage de Manjaro est qu'elle est basée sur la distribution Arch Linux. Cette dernière disposant d'une communauté très importante mettant à jour un wiki réputé comme étant très complet. Cette source de documentation peut donc servir à se débloquer dans de très nombreuses situations. L'avantage de Manjaro par rapport à Arch, repose essentiellement sur le fait que les paquets sont un minimum testés avant d'être publiés. Manjaro est donc de manière générale un peu plus stable que Arch.

Le live cd de Manjaro permet d'installer très simplement la distribution à travers une interface. Cependant, elle ne gère pas bien un aspect qui me semble essentiel pour un pc portable : le chiffrement du disque avec LUKS. C'est pourquoi j'ai développé un script qui permet d'installer soit un Arch Linux (en exécutant le script sur le livecd de Arch Linux), soit un Manjaro (en exécutant le script sur le live cd de Manjaro) avec la prise en charge de LUKS intégré. Ce script réalisera une installation avec uniquement les paquets minimaux.

bash

sudo su
curl https://sh.flavien.io/arch.sh | bash

Si l'installation est faite sur un Arch Linux, il peut être nécessaire de se connecter à internet via la WiFi. Voici la procédure :

bash

systemctl start iwd
iwctl
device list # liste les interfaces wifi détectées

station wlan0 scan
station wlan0 get-networks

station wlan0 connect "SSID_NAME"

Mise à jour de Manjaro

Maintenant que Manjaro est installé, nous allons le mettre à jour grâce à l'un des gestionnaires de paquets intégrés de la distribution. Pour ma part, j'utilise pacman, qui est le gestionnaire de paquets de la distribution Arch. Il est relativement difficile à utiliser et très peu intuitif, c'est pour cette raison que les développeurs de la distribution Manjaro ont rajouté un outil permettant de simplifier son utilisation pamac. Pour les utilisateurs venant d'une distribution basée sur Debian, ou RedHat, il semblera sans aucun doute plus intuitif.

La raison pour laquelle j'utilise néanmoins pacman est qu'il offre beaucoup plus de possibilités que sa surcouche. Ce wiki peut néanmoins être suivi en recopiant les commandes pacman et par la suite utiliser à titre personnel pamac. Ce dernier étant simplement une surcouche, cela ne devrait pas poser de problème de compatibilité.

Quelques commandes Pacman

Mise à jour de tous les paquets système :

bash

sudo pacman -Syyu

Installation d'un paquet :

bash

sudo pacman -S <package_name>

Suppression d'un paquet :

bash

sudo pacman -Rsn <package_name>

Recherche de paquet dans les dépôts :

bash

sudo pacman -Ss <package_name>

Recherche de paquets installés :

bash

pacman -Qs <package_name>

Recherche de paquets orphelins :

bash

sudo pacman -Qdt

Nettoyage du cache pacman :

bash

sudo pacman -Scc

Gestionnaires de paquets

La plupart des outils disposant d'une interface qui vont être installés dans ce wiki sont installés grâce à Flatpak. Il s'agit d'un gestionnaire de paquets qui permet d'installer des applications avec un système d'isolation. Cela va permettre de garantir un certain niveau de sécurité pour des applications possédant une GUI.

bash

sudo pacman -S flatpak
flatpak remote-add --user flathub https://flathub.org/repo/flathub.flatpakrepo

Pour ceux qui voudraient utiliser leur système pour faire du pentest, il est possible d'installer les repos de BlackArch. Grâce à ces derniers, il sera possible d'installer la plupart des outils disponibles sur d'autres distributions orientées sécurités telles que KaliLinux.

bash

curl -s https://blackarch.org/strap.sh | sudo bash -

À d'autres moments, il sera nécessaire d'utiliser des paquets provenant de la communauté (les AUR d'Arch Linux). Pour ce faire, il faut installer yay qui est un gestionnaire de paquets qui prend la succession de yaourt. Il est cependant important de noter que les AUR sont optimisés pour Arch Linux et peuvent venir avec certaines instabilités sur une distribution comme Manjaro.

YAY n'est pas directement disponible sur les repos de Manjaro, mais on peut le trouver sur ceux de BlackArch. L'alternative est de compiler directement le projet.

bash

sudo pacman -S blackarch/yay

yay -Syyu

Installation des headers

Parfois, certains logiciels vont avoir besoin des headers Linux afin d'être compilés. Il est donc bon d'avoir la dernière version de ces derniers installés sur sa machine.

bash

sudo pacman -S linux$(uname -r | cut -f1,2 -d. | tr -d ".")-headers

Configuration du réseau

À l'installation, Manjaro utilise NetworkManager qui permet de gérer le réseau de manière automatique. Cependant, le DNS inscrit dans le fichier resolve.conf sera automatiquement remplacé par celui fourni par le DHCP.

Avec le code suivant, nous allons forcer l'utilisation des DNS Cloudflare, Mullvad et OpenNIC.

bash

mkdir -p /etc/NetworkManager/conf.d
cat << EOL > /etc/NetworkManager/conf.d/90-dns.conf
[main]
dns=systemd-resolved
EOL

cat << EOL > /etc/systemd/resolved.conf
[Resolve]
DNS=1.1.1.1 194.242.2.2 94.247.43.254
FallbackDNS=1.0.0.1 152.53.15.127
EOL

rm -f /etc/resolv.conf
ln -s /run/systemd/resolve/stub-resolv.conf /etc/resolv.conf

systemctl enable --now systemd-resolved
systemctl enable --now NetworkManager

Configuration du Shell

Pour configurer mon shell, j'ai développé un script que je maintiens sur github : linux-shell-configuration.

Ce dernier introduit plusieurs raccourcis ainsi que des configurations pour les Shells bash, fish et zsh.

Pour l'installer, il suffit de taper la ligne de commande :

bash

curl -s https://sh.flavien.io/shell.sh | sudo bash -

Apparence

Sans plus entrer dans les détails, j'utilise personnellement le thème Sweet Dark avec le pack d'icônes Sweet Rainbow ainsi que les polices de caractères de JetBrains qui ont été pensées pour être optimisées pour le développement.

Pour mettre en place ma configuration, il suffit d'exécuter le script :

bash

curl -s https://sh.flavien.io/desktop.sh | bash -

Le thème Sweet Dark étant un thème GTK, les applications développées avec QT ne sont pas compatibles. Étant donné que les applications QT que j'utilise passent toutes par flatpak, j'installe simplement le thème Adwaita sur cet environnement.

bash

flatpak install --user org.kde.KStyle.Adwaita

Pour rendre accessible les thèmes, icons et polices pour les applications flatpak il suffit de taper les commandes :

bash

flatpak override --user --reset

flatpak override --user --filesystem=$HOME/.themes
flatpak override --user --filesystem=$HOME/.icons
flatpak override --user --filesystem=$HOME/.fonts

flatpak override --user --env=GTK_THEME="Sweet-Dark-v40"
flatpak override --user --env=ICON_THEME="Sweet-Rainbow"

Nommage des dossiers

Pour des questions d'habitude, il est souvent plus simple d'utiliser la convention de nommage des dossiers en anglais. Pour les renommer dans XFCE, il est possible d'utiliser les commandes suivantes :

bash

echo "en_US" > ~/.config/user-dirs.locale

mv ~/Bureau ~/Desktop
mv ~/Documents ~/Documents
mv ~/Téléchargements ~/Downloads
mv ~/Musique ~/Music
mv ~/Images ~/Pictures
mv ~/Vidéos ~/Videos
mv ~/Public ~/Public
mv ~/Modèles ~/Templates

echo 'XDG_DESKTOP_DIR="$HOME/Desktop"
XDG_DOCUMENTS_DIR="$HOME/Documents"
XDG_DOWNLOAD_DIR="$HOME/Downloads"
XDG_MUSIC_DIR="$HOME/Music"
XDG_PICTURES_DIR="$HOME/Pictures"
XDG_VIDEOS_DIR="$HOME/Videos"
XDG_PUBLICSHARE_DIR="$HOME/Public"
XDG_TEMPLATES_DIR="$HOME/Templates"' | tee ~/.config/user-dirs.dirs

Installation de l'antivirus

Pour garantir un niveau de sécurité minimal, la présence d'un antivirus est nécessaire (même sous Linux). Clamav n'est pas forcément le plus performant du marché, mais il est très léger, configurable et très utilisé par la communauté Linux :

bash

sudo pacman -S clamav

sudo freshclam 

sudo systemctl enable --now clamav-daemon

Mise en place d'un pare-feu

Autre composante importante de la politique de sécurité, le pare-feu. L'objectif va être ici de limiter au strict minimum les interactions avec le réseau. Malheureusement, certains logiciels tels que Discord nécessitent de grandes plages d'ouverture de port, ce qui réduit la sécurité du système. Un compromis est de n'autoriser les connexions à ces plages de port qu'à l'utilisateur principal. Il ne faut donc pas hésiter à supprimer ces règles si les programmes auxquels elles se rapportent ne sont pas installés.

Pour faire cela, nous allons utiliser le proxy iptables intégré à la plupart des distributions Linux.

bash

sudo su

# Reset parameters
iptables -t filter -F
ip6tables -t filter -F
iptables -t filter -X
ip6tables -t filter -X

# Traffic Blocking
iptables -t filter -P INPUT DROP
ip6tables -t filter -P INPUT DROP
iptables -t filter -P FORWARD DROP
ip6tables -t filter -P FORWARD DROP
iptables -t filter -P OUTPUT DROP
ip6tables -t filter -P OUTPUT DROP

# Authorization of already established connections
iptables -A INPUT -m state --state RELATED,ESTABLISHED -j ACCEPT
ip6tables -A INPUT -m state --state RELATED,ESTABLISHED -j ACCEPT
iptables -A OUTPUT -m state --state RELATED,ESTABLISHED -j ACCEPT
ip6tables -A OUTPUT -m state --state RELATED,ESTABLISHED -j ACCEPT

# Loopback authorization
iptables -t filter -A INPUT -i lo -j ACCEPT
ip6tables -t filter -A INPUT -i lo -j ACCEPT
iptables -t filter -A OUTPUT -o lo -j ACCEPT
ip6tables -t filter -A OUTPUT -o lo -j ACCEPT

# Allow PING to user
iptables -t filter -A OUTPUT -p icmp --icmp-type 8 -j ACCEPT -m owner --uid-owner 1000

# Authorization to open port

## dns
iptables -t filter -A OUTPUT -p udp --dport 53 -d 1.1.1.1 -j ACCEPT
iptables -t filter -A OUTPUT -p udp --dport 53 -d 1.0.0.1 -j ACCEPT
iptables -t filter -A OUTPUT -p udp --dport 53 -d 194.242.2.2 -j ACCEPT
iptables -t filter -A OUTPUT -p udp --dport 53 -d 94.247.43.254 -j ACCEPT
iptables -t filter -A OUTPUT -p udp --dport 53 -d 152.53.15.127 -j ACCEPT

## dhcp
iptables -A OUTPUT -p udp --dport 67:68 --sport 67:68 -d 10.0.0.0/8 -j ACCEPT
iptables -A INPUT -p udp --dport 67:68 --sport 67:68 -d 10.0.0.0/8 -j ACCEPT

iptables -A OUTPUT -p udp --dport 67:68 --sport 67:68 -d 172.16.0.0/12 -j ACCEPT
iptables -A INPUT -p udp --dport 67:68 --sport 67:68 -d 172.16.0.0/12 -j ACCEPT

iptables -A OUTPUT -p udp --dport 67:68 --sport 67:68 -d 192.168.0.0/16 -j ACCEPT
iptables -A INPUT -p udp --dport 67:68 --sport 67:68 -d 192.168.0.0/16 -j ACCEPT

## ntp
iptables -t filter -A OUTPUT -p udp --dport 123 -j ACCEPT

## http/s
iptables -t filter -A OUTPUT -p tcp --dport 80 -j ACCEPT
ip6tables -t filter -A OUTPUT -p tcp --dport 80 -j ACCEPT
iptables -t filter -A OUTPUT -p tcp --dport 443 -j ACCEPT
ip6tables -t filter -A OUTPUT -p tcp --dport 443 -j ACCEPT

## quic
iptables -t filter -A OUTPUT -p udp --dport 80 -j ACCEPT
ip6tables -t filter -A OUTPUT -p udp --dport 80 -j ACCEPT
iptables -t filter -A OUTPUT -p udp --dport 443 -j ACCEPT
ip6tables -t filter -A OUTPUT -p udp --dport 443 -j ACCEPT

## ssh
iptables -t filter -A OUTPUT -p tcp --dport 22 -j ACCEPT -m owner --uid-owner 1000
ip6tables -t filter -A OUTPUT -p tcp --dport 22 -j ACCEPT -m owner --uid-owner 1000

## ftp
iptables -t filter -A OUTPUT -p tcp --dport 21 -j ACCEPT -m owner --uid-owner 1000

# wol
iptables -t filter -A OUTPUT -p udp --dport 7 -j ACCEPT -m owner --uid-owner 1000

## whoIs
iptables -t filter -A OUTPUT -p tcp --dport 43 -j ACCEPT -m owner --uid-owner 1000

## mail (Outlook)
iptables -t filter -A OUTPUT -p tcp --dport 587 -j ACCEPT -m owner --uid-owner 1000
iptables -t filter -A OUTPUT -p tcp --dport 993 -j ACCEPT -m owner --uid-owner 1000

## vpn
iptables -A OUTPUT -o tun+ -j ACCEPT
iptables -A OUTPUT -o wg+ -j ACCEPT
iptables -A OUTPUT -o proton+ -j ACCEPT
### OpenVPN
iptables -t filter -A OUTPUT -p tcp --dport 1194 -j ACCEPT
iptables -t filter -A OUTPUT -p udp --dport 1194 -j ACCEPT
### WireGuard
iptables -t filter -A OUTPUT -p udp --dport 51820 -j ACCEPT
### IKEv2
iptables -t filter -A OUTPUT -p udp --dport 500 -j ACCEPT
iptables -t filter -A OUTPUT -p udp --dport 4500 -j ACCEPT

## Discord
iptables -t filter -A OUTPUT -p tcp --dport 2053 -j ACCEPT -m owner --uid-owner 1000
iptables -t filter -A OUTPUT -p tcp --dport 2083 -j ACCEPT -m owner --uid-owner 1000
iptables -t filter -A OUTPUT -p tcp --dport 2087 -j ACCEPT -m owner --uid-owner 1000
iptables -t filter -A OUTPUT -p tcp --dport 2096 -j ACCEPT -m owner --uid-owner 1000
iptables -t filter -A OUTPUT -p tcp --dport 8443 -j ACCEPT -m owner --uid-owner 1000

iptables -t filter -A OUTPUT -p udp --dport 19294:19344 -j ACCEPT -m owner --uid-owner 1000
iptables -t filter -A OUTPUT -p udp --dport 50000:50032 -j ACCEPT -m owner --uid-owner 1000

## Steam (Remote Play)
iptables -t filter -A INPUT -p udp --dport 27031:27036 -j ACCEPT
iptables -t filter -A INPUT -p tcp --dport 27036 -j ACCEPT
iptables -t filter -A OUTPUT -p udp --dport 27000:27100 -j ACCEPT -m owner --uid-owner 1000

## Moonlight
iptables -t filter -A OUTPUT -p tcp --dport 47984 -j ACCEPT -m owner --uid-owner 1000
iptables -t filter -A OUTPUT -p tcp --dport 47989 -j ACCEPT -m owner --uid-owner 1000
iptables -t filter -A OUTPUT -p tcp --dport 48010 -j ACCEPT -m owner --uid-owner 1000
iptables -t filter -A OUTPUT -p udp --dport 47998 -j ACCEPT -m owner --uid-owner 1000
iptables -t filter -A OUTPUT -p udp --dport 47999 -j ACCEPT -m owner --uid-owner 1000
iptables -t filter -A OUTPUT -p udp --dport 48000 -j ACCEPT -m owner --uid-owner 1000
iptables -t filter -A OUTPUT -p udp --dport 48002 -j ACCEPT -m owner --uid-owner 1000
iptables -t filter -A OUTPUT -p udp --dport 48010 -j ACCEPT -m owner --uid-owner 1000

## Ollama
iptables -t filter -A OUTPUT -p tcp --dport 11434 -j ACCEPT -m owner --uid-owner 1000

## Synergy
iptables -t filter -A INPUT -p tcp --dport 24800 -d 10.0.0.0/8 -j ACCEPT
iptables -t filter -A OUTPUT -p tcp --dport 24800 -d 10.0.0.0/8 -j ACCEPT -m owner --uid-owner 1000

iptables -t filter -A INPUT -p tcp --dport 24800 -d 172.16.0.0/12 -j ACCEPT
iptables -t filter -A OUTPUT -p tcp --dport 24800 -d 172.16.0.0/12 -j ACCEPT -m owner --uid-owner 1000

iptables -t filter -A INPUT -p tcp --dport 24800 -d 192.168.0.0/16 -j ACCEPT
iptables -t filter -A OUTPUT -p tcp --dport 24800 -d 192.168.0.0/16 -j ACCEPT -m owner --uid-owner 1000

# Protections

## DDos (https://javapipe.com/blog/iptables-ddos-protection/)

### Drop invalid packets
iptables -t mangle -A PREROUTING -m conntrack --ctstate INVALID -j DROP
ip6tables -t mangle -A PREROUTING -m conntrack --ctstate INVALID -j DROP

### Drop TCP packets that are new and are not SYN
iptables -t mangle -A PREROUTING -p tcp ! --syn -m conntrack --ctstate NEW -j DROP
ip6tables -t mangle -A PREROUTING -p tcp ! --syn -m conntrack --ctstate NEW -j DROP

### Drop SYN packets with suspicious MSS value
iptables -t mangle -A PREROUTING -p tcp -m conntrack --ctstate NEW -m tcpmss ! --mss 536:65535 -j DROP
ip6tables -t mangle -A PREROUTING -p tcp -m conntrack --ctstate NEW -m tcpmss ! --mss 536:65535 -j DROP

### Block packets with bogus TCP flags
iptables -t mangle -A PREROUTING -p tcp --tcp-flags FIN,SYN,RST,PSH,ACK,URG NONE -j DROP
ip6tables -t mangle -A PREROUTING -p tcp --tcp-flags FIN,SYN,RST,PSH,ACK,URG NONE -j DROP
iptables -t mangle -A PREROUTING -p tcp --tcp-flags FIN,SYN FIN,SYN -j DROP
ip6tables -t mangle -A PREROUTING -p tcp --tcp-flags FIN,SYN FIN,SYN -j DROP
iptables -t mangle -A PREROUTING -p tcp --tcp-flags SYN,RST SYN,RST -j DROP
ip6tables -t mangle -A PREROUTING -p tcp --tcp-flags SYN,RST SYN,RST -j DROP
iptables -t mangle -A PREROUTING -p tcp --tcp-flags FIN,RST FIN,RST -j DROP
ip6tables -t mangle -A PREROUTING -p tcp --tcp-flags FIN,RST FIN,RST -j DROP
iptables -t mangle -A PREROUTING -p tcp --tcp-flags FIN,ACK FIN -j DROP
ip6tables -t mangle -A PREROUTING -p tcp --tcp-flags FIN,ACK FIN -j DROP
iptables -t mangle -A PREROUTING -p tcp --tcp-flags ACK,URG URG -j DROP
ip6tables -t mangle -A PREROUTING -p tcp --tcp-flags ACK,URG URG -j DROP
iptables -t mangle -A PREROUTING -p tcp --tcp-flags ACK,FIN FIN -j DROP
ip6tables -t mangle -A PREROUTING -p tcp --tcp-flags ACK,FIN FIN -j DROP
iptables -t mangle -A PREROUTING -p tcp --tcp-flags ACK,PSH PSH -j DROP
ip6tables -t mangle -A PREROUTING -p tcp --tcp-flags ACK,PSH PSH -j DROP
iptables -t mangle -A PREROUTING -p tcp --tcp-flags ALL ALL -j DROP
ip6tables -t mangle -A PREROUTING -p tcp --tcp-flags ALL ALL -j DROP
iptables -t mangle -A PREROUTING -p tcp --tcp-flags ALL NONE -j DROP
ip6tables -t mangle -A PREROUTING -p tcp --tcp-flags ALL NONE -j DROP
iptables -t mangle -A PREROUTING -p tcp --tcp-flags ALL FIN,PSH,URG -j DROP
ip6tables -t mangle -A PREROUTING -p tcp --tcp-flags ALL FIN,PSH,URG -j DROP
iptables -t mangle -A PREROUTING -p tcp --tcp-flags ALL SYN,FIN,PSH,URG -j DROP
ip6tables -t mangle -A PREROUTING -p tcp --tcp-flags ALL SYN,FIN,PSH,URG -j DROP
iptables -t mangle -A PREROUTING -p tcp --tcp-flags ALL SYN,RST,ACK,FIN,URG -j DROP
ip6tables -t mangle -A PREROUTING -p tcp --tcp-flags ALL SYN,RST,ACK,FIN,URG -j DROP

### Drop fragments in all chains
iptables -t mangle -A PREROUTING -f -j DROP

### Limit connections per source IP
iptables -A INPUT -p tcp -m connlimit --connlimit-above 111 -j REJECT --reject-with tcp-reset
ip6tables -A INPUT -p tcp -m connlimit --connlimit-above 111 -j REJECT --reject-with tcp-reset

### Limit RST packets
iptables -A INPUT -p tcp --tcp-flags RST RST -m limit --limit 2/s --limit-burst 2 -j ACCEPT
ip6tables -A INPUT -p tcp --tcp-flags RST RST -m limit --limit 2/s --limit-burst 2 -j ACCEPT
iptables -A INPUT -p tcp --tcp-flags RST RST -j DROP
ip6tables -A INPUT -p tcp --tcp-flags RST RST -j DROP

### Limit new TCP connections per second per source IP
iptables -A INPUT -p tcp -m conntrack --ctstate NEW -m limit --limit 60/s --limit-burst 20 -j ACCEPT
ip6tables -A INPUT -p tcp -m conntrack --ctstate NEW -m limit --limit 60/s --limit-burst 20 -j ACCEPT
iptables -A INPUT -p tcp -m conntrack --ctstate NEW -j DROP
ip6tables -A INPUT -p tcp -m conntrack --ctstate NEW -j DROP

## Port scan
iptables -N port-scanning
ip6tables -N port-scanning
iptables -A port-scanning -p tcp --tcp-flags SYN,ACK,FIN,RST RST -m limit --limit 1/s --limit-burst 2 -j RETURN
ip6tables -A port-scanning -p tcp --tcp-flags SYN,ACK,FIN,RST RST -m limit --limit 1/s --limit-burst 2 -j RETURN
iptables -A port-scanning -j DROP
ip6tables -A port-scanning -j DROP

# Save table
iptables-save > /etc/iptables.v4.rules
ip6tables-save > /etc/iptables.v6.rules

cat << EOL > /etc/systemd/system/custom-firewall-v4.service
[Unit]
Description=Custom firewall IPv4
After=network.target
Before=docker.service
Before=libvirtd.service

[Service]
ExecStart=iptables-restore /etc/iptables.v4.rules
Type=oneshot

[Install]
WantedBy=multi-user.target
EOL

cat << EOL > /etc/systemd/system/custom-firewall-v6.service
[Unit]
Description=Custom firewall IPv6
After=network.target
Before=docker.service
Before=libvirtd.service

[Service]
ExecStart=ip6tables-restore /etc/iptables.v6.rules
Type=oneshot

[Install]
WantedBy=multi-user.target
EOL

systemctl daemon-reload
systemctl enable --now custom-firewall-v4
systemctl enable --now custom-firewall-v6

Enfin, nous allons ajouter quelques commandes :

firewall stop: Pour désactiver la protection.
firewall start: Pour réactiver la protection.
firewall input-stop: Pour désactiver la protection pour le trafic entrant.
firewall output-stop: Pour désactiver la protection pour le trafic sortant.

bash

chmod 700 ~/bin

echo '#!/bin/bash

USER_ID=$(id -u)

case $1 in
start)
  sudo iptables -t filter -P INPUT DROP
  sudo ip6tables -t filter -P INPUT DROP
  sudo iptables -t filter -P FORWARD DROP
  sudo ip6tables -t filter -P FORWARD DROP
  sudo iptables -t filter -P OUTPUT DROP
  sudo ip6tables -t filter -P OUTPUT DROP
;;
stop)
  sudo iptables -t filter -P INPUT ACCEPT
  sudo ip6tables -t filter -P INPUT ACCEPT
  sudo iptables -t filter -P FORWARD ACCEPT
  sudo ip6tables -t filter -P FORWARD ACCEPT
  sudo iptables -t filter -P OUTPUT ACCEPT
  sudo ip6tables -t filter -P OUTPUT ACCEPT
;;
input-stop)
  sudo iptables -t filter -P INPUT ACCEPT
  sudo ip6tables -t filter -P INPUT ACCEPT
;;
output-stop)
  sudo iptables -t filter -P OUTPUT ACCEPT
  sudo ip6tables -t filter -P OUTPUT ACCEPT
;;
full-start)
  sudo iptables-restore /etc/iptables.v4.rules
  sudo ip6tables-restore /etc/iptables.v6.rules
;;
full-stop)
  sudo iptables -t filter -F
  sudo ip6tables -t filter -F
  sudo iptables -t filter -X
  sudo ip6tables -t filter -X
  sudo iptables -t filter -P INPUT ACCEPT
  sudo ip6tables -t filter -P INPUT ACCEPT
  sudo iptables -t filter -P FORWARD ACCEPT
  sudo ip6tables -t filter -P FORWARD ACCEPT
  sudo iptables -t filter -P OUTPUT ACCEPT
  sudo ip6tables -t filter -P OUTPUT ACCEPT
;;
allow-local)
  sudo iptables -t filter -A OUTPUT -p tcp -d 10.0.0.0/8 -j ACCEPT -m owner --uid-owner $USER_ID
  sudo iptables -t filter -A OUTPUT -p udp -d 10.0.0.0/8 -j ACCEPT -m owner --uid-owner $USER_ID
  sudo iptables -t filter -A OUTPUT -p tcp -d 192.168.0.0/16 -j ACCEPT -m owner --uid-owner $USER_ID
  sudo iptables -t filter -A OUTPUT -p udp -d 192.168.0.0/16 -j ACCEPT -m owner --uid-owner $USER_ID
  sudo iptables -t filter -A OUTPUT -p tcp -d 172.16.0.0/12 -j ACCEPT -m owner --uid-owner $USER_ID
  sudo iptables -t filter -A OUTPUT -p udp -d 172.16.0.0/12 -j ACCEPT -m owner --uid-owner $USER_ID
;;
*)
  echo "Usage: firewall (start|stop|input-stop|output-stop|full-start|full-stop|allow-local)"
  exit -1
;;
esac' | tee ~/bin/firewall

chmod 500 ~/bin/firewall
chmod 500 ~/bin

Outils de développement

Je fais personnellement le choix d'installer mes différents outils directement au niveau de mon système et non pas dans des conteneurs Flatpak. S'agissant de mes outils de travail, je fais cela afin de réduire au maximum les désagréments que pourrait causer la non-accessibilité d'une ressource du système depuis un conteneur. Il est cependant possible d'installer la plupart de ces outils à travers Flatpak.

Environnement Java/Kotlin

De la même façon que NVM gère les versions de Node.js, il est possible d'utiliser SdkMan afin de gérer les versions d'Open JDK, GraalVM ou encore Maven nécessaires au fonctionnement de nos projets.

bash

curl -s "https://get.sdkman.io" | bash
source "$HOME/.sdkman/bin/sdkman-init.sh"

chmod u+w ~/.bashrc
echo 'source "$HOME/.sdkman/bin/sdkman-init.sh"' >> ~/.bashrc
chmod u-w ~/.bashrc

chmod u+w ~/.zshrc
echo 'source "$HOME/.sdkman/bin/sdkman-init.sh"' >> ~/.zshrc
chmod u-w ~/.zshrc

# Fish compatibility
echo '#!/usr/bin/fish

function sdk
  bash -c "source $HOME/.sdkman/bin/sdkman-init.sh && sdk $argv"
end

for VERSION in $HOME/.sdkman/candidates/* ;
  set -gx PATH $PATH $VERSION/current/bin
end' | tee ~/.config/fish/conf.d/sdkman.fish

# Install GraalVM 25
sdk install java 25-graal
sdk install maven
sdk install gradle
sdk use java 25-graal

Environnement Node.js

Quand on travaille sur différents projets JavaScript, on peut être amené à utiliser différentes versions de Node.js en fonction des projets. Il est alors possible de passer par NVM (Node Version Manager), qui va permettre de changer de version de Node.js en seulement quelques commandes.

bash

sudo pacman -S nvm

chmod u+w ~/.bashrc
echo "source /usr/share/nvm/init-nvm.sh" >> ~/.bashrc
chmod u-w ~/.bashrc

chmod u+w ~/.zshrc
echo "source /usr/share/nvm/init-nvm.sh" >> ~/.zshrc
chmod u-w ~/.zshrc

nvm install --lts
nvm use stable

Autres langages

Même si je ne code pas directement dans ces technologies, le GO de Google et le Rust de Mozilla, sont deux langages de programmation de bas niveau qui sont en train de s'imposer. Je les installe afin d'avoir la possibilité de compiler différents projets quand c'est nécessaire.

bash

sudo pacman -S go rustup
rustup default stable

Outils JetBrains

Disposant d'un pack JetBrains complet, il m'est possible d'installer les différents IDEs de l'entreprise à partir de la JetBrains toolbox. C'est à travers cette interface qu'il est par la suite possible d'installer Intellij, Clion, PyCharm, DataGrip... et de les maintenir à jour.

bash

sudo pacman -S gnome-keyring fakeroot
yay -S jetbrains-toolbox

Il est également possible d'utiliser GraalVM pour lancer ces différentes IDEs, ce qui aura un impact extrêmement positif sur leurs performances.

NeoVim

NeoVim est une version améliorée de l'IDE en ligne de commande Vim qui est lui-même une version évoluée de VI.

Tout comme Vim, NeoVim offre la possibilité d'être enrichi grâce à une mécanique de plugins.

Cependant, il peut être long et fastidieux de mettre en place un environnement et de trouver les plugins qui vont réellement nous faciliter la vie.

C'est pourquoi j'utilise personnellement un ensemble de plugins nommé LazyVim, qui permet d'ajouter à NeoVim de nombreuses fonctionnalités, de quoi en faire un véritable IDE.

bash

sudo pacman -S neovim gcc

rm -Rf ~/.config/nvim
git clone -q --depth 1 -- https://github.com/LazyVim/starter ~/.config/nvim

VisualStudio code

Sur les dépôts pacman, il n'y a pas de trace de Microsoft VisualStudio Code. En revanche, on peut trouver un fork nommé Code OSS sur lequel les traceurs Microsoft ont été enlevés et les composants propriétaires remplacés (le logo par exemple). Ce fork est également compatible avec la plupart des extensions de l'IDE de base.

bash

sudo pacman -S code

code --install-extension ms-azuretools.vscode-docker
code --install-extension ms-kubernetes-tools.vscode-kubernetes-tools

code --install-extension ms-vscode.hexeditor
code --install-extension ms-python.python
code --install-extension ms-toolsai.jupyter
code --install-extension redhat.vscode-xml
code --install-extension redhat.vscode-yaml
code --install-extension efoerster.texlab

code --install-extension arjun.swagger-viewer
code --install-extension janisdd.vscode-edit-csv
code --install-extension naumovs.color-highlight

code --install-extension k--kato.intellij-idea-keybindings

Claude Code

Claude Code est l'agent d'aide au développement développé par Anthropic. Il a l'avantage de fonctionner en ligne de commande et donc d'être indépendant d'un IDE. De plus il est possible de payer au token et non au mois. Ce qui peut s'avérer intéressant pour ne pas se retrouver frustré les mois où on utilise beaucoup l'IA et payer pour rien les mois où on ne l'utilise pas.

bash

sudo pacman -S debugedit
yay -S claude-code
claude install

sudo pacman -S socat
npm install -g @anthropic-ai/sandbox-runtime

Pour améliorer son usage de Claude Code, il peut être intéressant de rajouter différents plugins. Il existe différents types d'extensions pour cet outil :

Les LSP (Language Server Protocol) : Il s'agit d'un type de module habituellement utilisé par les IDEs pour interpréter un langage. Utilisé dans Claude cela permet d'avoir une vérification syntaxique plus formelle :

bash

claude plugin install kotlin-lsp@claude-plugins-official
claude plugin install jdtls-lsp@claude-plugins-official
claude plugin install typescript-lsp@claude-plugins-official

Les MCP (Model Context Protocol) : Il s'agit d'un standard défini par Anthropic permettant à un agent IA de piloter un outil. Dans une entreprise, il peut par exemple être intéressant de laisser la possibilité à un agent de contrôler son serveur GitLab :

bash

sudo pacman -S glab
claude mcp add --transport stdio gitlab -- glab mcp serve

claude plugin install playwright@claude-plugins-official
claude plugin install atlassian@claude-plugins-official
claude plugin install figma@claude-plugins-official

Les Skills : Il s'agit d'un autre standard du monde de l'IA permettant de préenregistrer un context avec des prompts, des agents, des outils...

bash

claude plugin install superpowers@claude-plugins-official
claude plugin install code-simplifier@claude-plugins-official
claude plugin install code-review@claude-plugins-official
claude plugin install frontend-design@claude-plugins-official

Dans la liste des outils on peut rajouter Playwright. Il s'agit initialement d'un framework de test front, mais grâce à son MCP, claude va pouvoir contrôler un navigateur. Malheureusement ça va être compliqué à faire fonctionner avec un navigateur sandboxé par flatpak. On va donc installer un navigateur chromium directement sur l'OS pour que claude puisse facilement y accéder.

bash

sudo pacman -S chromium
npm install -g playwright
npx playwright install chromium
npx @playwright/mcp install-browser chrome-for-testing

Pour finir Claude peut supporter de nombreux paramètres. Voici un exemple de configuration pour activer le sandboxing, réduire la télémétrie et limiter les interactions inutiles avec l'utilisateur :

bash

echo '{
  "companyAnnouncements": [
    "flavien.io configuration"
  ],

  "sandbox": {
    "enabled": true,
    "autoAllowBashIfSandboxed": true,
    "excludedCommands": ["git", "docker", "podman"],
    "network": {
      "allowUnixSockets": [
        "/var/run/docker.sock"
      ],
      "allowLocalBinding": true
    }
  },

  "env": {
    "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1",
    "DISABLE_NON_ESSENTIAL_MODEL_CALLS": "1"
  },

  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|MultiEdit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "if [[ -n \"$CLAUDE_TOOL_FILE_PATH\" ]] && git rev-parse --git-dir >/dev/null 2>&1; then git add \"$CLAUDE_TOOL_FILE_PATH\" 2>/dev/null || true; fi"
          }
        ]
      }
    ]
  },

  "permissions": {
    "allow": [
      "Read",
      "Write",
      "Update",
      "Bash(git:*)",
      "Bash(tree:*)",
      "Bash(find:*)",
      "Bash(grep:*)",
      "Bash(head:*)",
      "Bash(tail:*)",
      "Bash(mkdir:*)",
      "Bash(rmdir:*)",
      "Bash(touch:*)",
      "Bash(docker compose up:*)",
      "Bash(docker compose down:*)",
      "Bash(docker compose build:*)",
      "Bash(docker compose logs:*)",
      "Bash(docker run:*)",
      "Bash(docker exec:*)",
      "Bash(docker build:*)",
      "Bash(docker buildx:*)",
      "Bash(docker logs:*)",
      "Bash(podman run:*)",
      "Bash(podman exec:*)",
      "Bash(podman build:*)",
      "Bash(podman logs:*)",
      "Bash(java:*)",
      "Bash(mvn:*)",
      "Bash(node:*)",
      "Bash(npm:*)",
      "Bash(python:*)",
      "Bash(python3:*)",
      "Bash(cargo:*)"
    ],
    "ask": [
      "Bash(curl:*)",
      "Bash(wget:*)"
    ],
    "deny": [
      "Read(./.env)",
      "Bash(cat:*)",
      "Bash(sudo:*)",
      "Bash(pacman:*)",
      "Bash(yay:*)",
      "Bash(dnf:*)",
      "Bash(yum:*)",
      "Bash(apk:*)",
      "Bash(apt:*)",
      "Bash(apt-get:*)",
      "Bash(dpkg:*)",
      "Bash(flatpak:*)",
      "Bash(docker-compose:*)"
    ]
  }
}' | tee ~/.claude/settings.json

Il est possible de démarrer Claude dirrectement en auto-mode : claude --permission-mode auto

Open Code

Un client open source permettant d'utiliser n'importe quel backend d'IA (ChatGPT, Gemini, Claude, Ollama...) pour effectuer des tâches de code. C'est un équivalent de Claude Code relativement compatible avec ce dernier dans l'ensemble (il interprète les fichiers Claude.md et utilise les agents de ce dernier).

bash

yay -S opencode-bin

Pour utiliser OpenCode avec un serveur Ollama local, il suffit de rajouter la configuartion suivante :

bash

mkdir -p ~/.config/opencode

echo '{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "ollama": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Ollama",
      "options": {
        "baseURL": "http://192.168.1.XXX:11434/v1"
      },
      "models": {
        "llama4": {
          "name": "llama4:16x17b"
        },
        "qwen3-coder-next": {
          "name": "qwen3-coder-next:latest"
        }
      }
    }
  }
}' > ~/.config/opencode/opencode.json

RTK

RTK est une lib permettant de compresser les requêtes envoyées par ClaudeCode ou OpenCode.

Pour fonctionner ce système modifie les outputs des commandes shell pour récupérer uniquement les informations essentielles. De cette façon, rtk permet d'économiser beaucoup de token.

bash

yay -S rtk-bin

rtk init --global # Install on ClaudeCode
rtk init --global --opencode # Install on OpenCode

Android ADB

Pour ceux qui travaillent de près ou de loin avec Android, l'outil ADB est indispensable.

bash

sudo pacman -S android-tools android-udev

Installation de Docker et Podman

Pour installer Docker :

bash

sudo pacman -S docker docker-buildx docker-compose

sudo mkdir -p /etc/docker
echo '{
  "features": {
    "buildkit" : true
  }
}' | sudo tee /etc/docker/daemon.json

sudo systemctl enable --now docker

sudo groupadd docker

echo 'alias docker="sudo docker"' >> $HOME/.alias

Pour installer Podman :

bash

sudo pacman -S podman

sudo usermod --add-subuids 100000-165535 --add-subgids 100000-165535 $USER

podman system migrate

Installation de K3s

K3s est une implémentation légère de Kubernetes. Elle va permettre d'effectuer des tests directement depuis un environnement de développement.

bash

curl -sfL https://get.k3s.io | sh -

sudo systemctl disable k3s

Utilisation de KVM

Avant de commencer, il est indispensable de vérifier au préalable que la virtualisation est activée au niveau du BIOS de la machine hôte. Si ce n'est pas le cas, il sera impossible d'utiliser KVM (Kernel-based Virtual Machine).

Il existe dans l'univers Linux de nombreuses solutions de virtualisation. Cependant, le choix de KVM plutôt qu'une autre repose sur le fait qu'il s'agisse d'un hyperviseur de niveau 1, ce qui signifie qu'il est directement intégré au niveau du noyau du système d'exploitation. Cette solution est donc particulièrement efficace dans un environnement Linux.

bash

sudo pacman -S virt-manager pipewire-jack qemu-full vde2 ebtables dnsmasq openbsd-netcat x11-ssh-askpass

sudo systemctl enable --now libvirtd.service

sudo usermod -a -G libvirt $USER
sudo usermod -a -G kvm $USER

Par la suite pour récupérer une image Windows, il faut se rendre sur le site officiel de Microsoft et télécharger l'image ISO du système d'exploitation.

L'outil virt-manager va permettre de manager les différentes machines virtuelles à travers une interface. Il fournit également un certain nombre de profils déjà configurés pour faciliter la mise en place de Machines virtuelles avec des configurations complexes (comme c'est le cas d'un Windows 11 avec son TPM).

Pour installer facilement des Machines virtuelles en ligne de commande, il est aussi possible d'utiliser le script Quickemu avec la commande suivante :

bash

yay -S quickemu

Par la suite pour créer une machine virtuelle MacOsX, il suffira de taper la commande :

bash

quickget macos big-sur
quickemu --fullscreen --display spice --vm macos-big-sur.conf

Partage de dossier

SMB avec son implémentation Samba est une solution qui peut s'avérer indispensable quand il s'agit de transférer des fichiers d'une machine à l'autre. Cependant, ce protocole très utilisé est très prisé par les hackers. Installer un serveur Samba directement sur sa machine hôte afin de partager des fichiers avec une machine virtuelle ne semble donc pas être une bonne solution. Une alternative plus sécurisée consiste simplement à utiliser une implémentation de Samba pour Docker. De cette façon, en cas de vulnérabilité, le système hôte n'est pas exposé, son arborescence non plus et pas même les utilisateurs.

Le script suivant permet d'exposer facilement le dossier ~/Public sur un lecteur Samba :

bash

chmod 700 ~/bin
echo '#!/bin/bash

case $1 in
start)
    sudo iptables -t filter -A OUTPUT -p udp --dport 137 -j ACCEPT
    sudo iptables -t filter -A OUTPUT -p udp --dport 138 -j ACCEPT
    sudo iptables -t filter -A OUTPUT -p tcp --dport 139 -j ACCEPT
    sudo iptables -t filter -A OUTPUT -p tcp --dport 445 -j ACCEPT
    sudo iptables -t filter -A OUTPUT -p udp --dport 445 -j ACCEPT

    sudo docker run --rm -d --name smb -p 137:137/udp -p 138:138/udp -p 139:139 -p 445:445 -p 445:445/udp -v $HOME/Public:/share/folder elswork/samba -u "1000:1000:$USER:$USER:password" -s "Public:/share/folder:rw:$USER"
    sudo docker logs smb
;;
stop)
    sudo iptables -t filter -A OUTPUT -p udp --dport 137 -j DROP
    sudo iptables -t filter -A OUTPUT -p udp --dport 138 -j DROP
    sudo iptables -t filter -A OUTPUT -p tcp --dport 139 -j DROP
    sudo iptables -t filter -A OUTPUT -p tcp --dport 445 -j DROP
    sudo iptables -t filter -A OUTPUT -p udp --dport 445 -j DROP

    sudo docker rm -f smb
;;
*)
    echo "Usage: smb (start|stop)"
    exit -1
;;
esac' | tee ~/bin/smb

chmod 500 ~/bin/smb
chmod 500 ~/bin

Avec ce script, il suffit de taper les commandes smb start ou smb stop afin d'activer ou désactiver le partage de fichier. De plus, le script va se charger d'ouvrir ou fermer dynamiquement les ports utilisés au niveau du firewall.

Copie de disque

Les disques utilisés par Qemu sont par défaut au format qcow2, ce format a l'avantage d'adapter sa taille sur disque en fonction de ce qu'il va contenir. Cependant, dans le cas où on supprime des fichiers volumineux dans le disque virtuel, sa taille réservée sur le disque physique ne diminue pas. Il peut alors être bon de réécrire le disque afin de réoptimiser sa structure. Pour ce faire, il suffit d'utiliser la commande :

bash

qemu-img convert -O qcow2 old.qcow2 new.qcow2

Logiciels

KeePassXC

KeePassXC est pour moi un composant central dans mon architecture de sécurité. Non seulement il stocke la totalité des mots de passe de mes comptes, mais il contient aussi mes différentes clés pour mes connexions SSH (GitHub et GitLab comprises). Le lien de démarrage que je propose permet donc de rajouter au logiciel l'autorisation d'accéder aux clés SSH du système.

bash

flatpak install --user org.keepassxc.KeePassXC

cat << EOL > ~/.local/share/applications/org.keepassxc.KeePassXC.desktop
[Desktop Entry]
Name=KeePassXC
GenericName=Password Manager
GenericName[fr]=Gestionnaire de mot de passe
Comment=Community-driven port of the Windows application “KeePass Password Safe”
Exec=/usr/bin/flatpak run --socket=ssh-auth --branch=stable --arch=x86_64 --command=keepassxc --file-forwarding org.keepassxc.KeePassXC @@ %f @@
Icon=keepassxc
StartupWMClass=keepassxc
StartupNotify=true
Terminal=false
Type=Application
Categories=Utility;Security;Qt;
MimeType=application/x-keepass2;
X-Flatpak=org.keepassxc.KeePassXC
EOL

Firefox

Par défaut, Manjaro utilise une version de Firefox installée directement sur l'os. Cela n'est pas réellement recommandé. C'est pourquoi nous allons la remplacer par une version Flatpak.

bash

sudo pacman -Rsn firefox manjaro-browser-settings
flatpak install --user org.mozilla.firefox

Brave Browser

Brave Browser est un énième navigateur basé sur Chromium. Cependant, contrairement à la plupart des alternatives, il est orienté vie privée. Malheureusement, certains sites (très rares) ne fonctionnent pas sur Firefox, il est donc toujours pertinent d'avoir un navigateur de la famille Chrome sous la main pour ce type de situation.

bash

flatpak install --user com.brave.Browser

TorBrowser

Pour accéder au réseau Tor.

bash

flatpak install --user org.torproject.torbrowser-launcher

W3m

Parfois, il peut être pratique de disposer d'un navigateur en ligne de commande. Pour du scripting, ou tout simplement pour rechercher : "comment réparer ses drivers Nvidia sous Linux".

bash

sudo pacman -S w3m

ProtonMail

Quand on utilise Linux, les notions de sécurité et de vie privée sont importantes. Donc, utiliser une boîte e-mail sécurisée ça l'est tout autant. Le ProtonMailBridge permet de se connecter de manière sécurisée à son compte ProtonMail avec un client lourd de messagerie telle que Thunderbird.

bash

sudo pacman -S libfido2 gnome-keyring
flatpak install --user ch.protonmail.protonmail-bridge

Il est à noter que le ProtonMail Bridge peut démarrer en réduit. Pour ce faire, utilisez cette commande :

bash

flatpak run --branch=stable --arch=x86_64 --command=protonmail-bridge ch.protonmail.protonmail-bridge  --no-window

ProtonVPN

Durant longtemps, il était possible d'utiliser un client ProtonVPN en ligne de commande. Malheureusement, cela n'est plus possible maintenant qu'il existe une interface. Cette dernière est néanmoins relativement pratique et disponible sur flathub.

bash

sudo pacman -S openvpn openresolv libnatpmp
sudo wget "https://raw.githubusercontent.com/ProtonVPN/scripts/master/update-resolv-conf.sh" -O "/etc/openvpn/update-resolv-conf"
sudo chmod +x "/etc/openvpn/update-resolv-conf"
flatpak install --user com.protonvpn.www

Par défaut, le p2p ne va pas fonctionner en upload. La commande suivante va permettre de créer un mapping de port avec le serveur VPN. Il n'y aura plus qu'à donner le port dans la configuration de transmission pour pouvoir uploader.

bash

while true ; do date ; natpmpc -a 1 0 udp 60 -g 10.2.0.1 && natpmpc -a 1 0 tcp 60 -g 10.2.0.1 || { echo -e "ERROR with natpmpc command \a" ; break ; } ; sleep 45 ; done

Thunderbird

Pour les utilisateurs du ProtonMailBridge, il faut penser à désactiver la sécurité pour le SMTP entre Thunderbird et le bridge. Il semblerait que Thunderbird n'autorise plus du tout les certificats autosignés générés par le Bridge pour les messages sortants.

bash

flatpak install --user org.mozilla.thunderbird_esr

Discord

Discord est sûrement l'application de communication la plus populaire du moment. Elle est cependant développée en JavaScript dans un conteneur Electron et ne se soucie pas vraiment des utilisateurs Linux. Un patch du nom de Vencord a donc été développé par la communauté afin d'améliorer la performance de l'application et enlever plusieurs options de tracking.

bash

flatpak install --user dev.vencord.Vesktop

Pour lancer Discord en mode réduit il est possible d'utiliser la ligne de commande suivante :

bash

flatpak run --branch=stable --arch=x86_64 --command=startvesktop dev.vencord.Vesktop --start-minimized

Matrix

Matrix est un protocole de communication ouvert qui supporte aussi bien les conversations écrites qu'en audio/vidéo. Il existe plusieurs implémentations, mais la plus populaire est nommée Matrix (Il s'agit de l'implémentation officielle).

bash

flatpak install --user im.riot.Riot

Eye of GNOME

La visionneuse d'image de Gnome. Elle est plutôt simple à utiliser et affiche les métadonnées des images (heure, position GPS si disponible...).

bash

flatpak install --user org.gnome.eog

Gimp

Le célèbre éditeur d'images bitmap très complet et très adapté pour la retouche de photo. Mon seul problème avec ce logiciel est son ergonomie.

bash

flatpak install --user org.gimp.GIMP

Upscayl

Logiciel permettant d'agrandir des images grâce à un modèle d'intelligence artificielle. Il a l'avantage de s'exécuter sur la carte graphique locale et non sur un serveur distant.

bash

flatpak install --user org.upscayl.Upscayl

Krita

Tout comme GIMP, Krita est un éditeur d'image au format bitmap. Ce logiciel est cependant plus adapté pour le dessin.

bash

flatpak install --user org.kde.krita

Inkscape

Un éditeur d'images vectorielles.

bash

flatpak install --user org.inkscape.Inkscape

Blender

Rien de tel que Blender pour créer de magnifiques modèles 3D.

bash

flatpak install --user org.blender.Blender

VLC

Le célèbre lecteur de fichiers multimédias français.

bash

flatpak install --user org.videolan.VLC

Audacity

Un logiciel simple et efficace pour enregistrer et éditer du son.

bash

flatpak install --user org.audacityteam.Audacity

Soundux

Soundux est un simple logiciel pour jouer des sons lors de conversations audio.

bash

flatpak install --user io.github.Soundux

NextCloud

Pour ceux qui veulent déployer leur propre solution de stockage de fichier qui ne serait pas hébergée chez Google, Microsoft ou Amazon.

bash

flatpak install --user com.nextcloud.desktopclient.nextcloud

LibreOffice

Pack Office gratuit pour Linux... Pour les gros utilisateurs des outils Microsoft Word, Excel et PowerPoint, je ne peux cependant pas en toute bonne foi prétendre que LibreOffice égale Microsoft 365. Si ces logiciels sont vos outils de travail principaux, ne passez pas sous Linux et continuez d'utiliser Microsoft 365 sur votre Windows ou sur votre Mac.

bash

flatpak install --user org.libreoffice.LibreOffice

Papers

Un autre logiciel Gnome. Celui-ci permet simplement d'afficher des fichiers PDF. Il embarque notamment de la reconnaissance de caractères au sein des images. Ce qui permet de faire des copier-coller de documents photocopiés.

bash

flatpak install --user org.gnome.Papers

Scribus

Scribus est un éditeur de PDF.

bash

flatpak install --user net.scribus.Scribus

Calibre

Personnellement, je dispose d'une liseuse Bookeen Diva HD (produit d'excellente qualité et française au demeurant). Afin de centraliser mon catalogue de livre acquis sur différentes plateformes, je les stocke au format epub sans DRM. Pour cela, j'utilise Calibre avec l'extension DeDRM_tools.

bash

flatpak install --user com.calibre_ebook.calibre

FontForge

Un éditeur de police de caractères.

bash

flatpak install --user org.fontforge.FontForge

LanguageTool

Étant dyslexique, il m'est assez difficile de pousser directement un texte sur internet sans l'avoir fait relire au préalable par un correcteur... Après de nombreuses années d'utilisation du logiciel Antidote, j'ai dû me résoudre à utiliser d'autres solutions en raison de l'absence complète de support pour Linux.

LanguageTool est une solution comportant un backend en Java et des plugins à intégrer dans des applications.

Dans un premier temps, il va falloir télécharger le backend en Java et lui associer un utilisateur système :

bash

export LANGUAGE_TOOL_DIR=/opt/LanguageTool
export LANGUAGE_TOOL_VERSION=20260127

sudo rm -Rf $LANGUAGE_TOOL_DIR

sudo mkdir -p $LANGUAGE_TOOL_DIR
wget https://internal1.languagetool.org/snapshots/LanguageTool-$LANGUAGE_TOOL_VERSION-snapshot.zip -O /tmp/LanguageTool.zip
sudo unzip -d $LANGUAGE_TOOL_DIR /tmp/LanguageTool.zip
sudo mv $LANGUAGE_TOOL_DIR/LanguageTool-*/* $LANGUAGE_TOOL_DIR
sudo rmdir $LANGUAGE_TOOL_DIR/LanguageTool-*
rm -f /tmp/LanguageTool.zip

wget https://download.oracle.com/graalvm/21/latest/graalvm-jdk-21_linux-x64_bin.tar.gz -O /tmp/graalvm.tar.gz
sudo tar xf /tmp/graalvm.tar.gz -C $LANGUAGE_TOOL_DIR
sudo mv $LANGUAGE_TOOL_DIR/graalvm-jdk* $LANGUAGE_TOOL_DIR/java
rm -f /tmp/graalvm.tar.gz

sudo groupadd LanguageTool
sudo useradd -g LanguageTool -M -d $LANGUAGE_TOOL_DIR LanguageTool

sudo chown -R LanguageTool: $LANGUAGE_TOOL_DIR
sudo chmod -R go-rwx $LANGUAGE_TOOL_DIR

Dans un second temps, il va falloir créer le service LanguageTool pour qu'il puisse être managé par systemd :

bash

echo '[Unit]
Description=LanguageTool Service
After=network-online.target

[Service]
ExecStart=/opt/LanguageTool/java/bin/java -cp /opt/LanguageTool/languagetool-server.jar org.languagetool.server.HTTPServer --port 8081 --allow-origin "*"
User=LanguageTool
Group=LanguageTool
Restart=always
RestartSec=3

[Install]
WantedBy=default.target
' | sudo tee /etc/systemd/system/LanguageTool.service

sudo systemctl daemon-reload
sudo systemctl enable --now LanguageTool

Enfin, il est possible de rajouter des extensions dans différents logiciels :

Pandoc

Pandoc est un outil très puissant permettant de convertir de nombreux formats de fichier texte dans d'autres formats de fichier texte. Il est par exemple possible de transformer un fichier Markdown en document PDF en lui appliquant une feuille de style au format LaTeX. Il est donc possible de rédiger des documents de qualité professionnelle simplement en Markdown et de les convertir plus tard dans le format que nous souhaitons exporter : pdf, doc, html, LaTeX, epub...

Je vois plusieurs avantages à cette solution par rapport au traditionnel Microsoft Word, mais le plus important à mon sens est le découpage du flux de travail. En effet, je considère que lors de la rédaction d'un document nous avons 3 grandes phases de travail : l'écriture du contenu, une phase de relecture durant laquelle nous pouvons corriger fautes d'orthographe et mauvaises tournures de phrases, et enfin la mise en page. Le problème avec Microsoft Word est que nous devons gérer ces 3 phases simultanément, ce qui a pour inconvénient de nous rendre moins efficaces sur chacune d'entre elles et résulte sur des documents de moindre qualité. La plupart des universitaires se sont donc tournés vers le format LaTeX, mais le problème reste similaire, avec ses nombreuses annotations ce format reste lourd et nous devons donc gérer la rédaction et une partie de la mise en page simultanément. Le meilleur compromis à mon sens est le Markdown qui est très léger en écriture et surtout très intuitif.

Ainsi avec les différents logiciels que j'utilise, je peux garantir un flux de travail efficace sur ces trois axes. Je commence par rédiger en Markdown le contenu de mon document dans un simple IDE (généralement Visual Studio Code ou VIM), puis je corrige les fautes en utilisant un logiciel de correction et enfin, j'utilise Pandoc pour la mise en page. J'ai créé un projet GitHub qui me sert de base pour les documents que je rédige. Il utilise la feuille de style LaTeX Eisvogel afin de mettre en forme mes documents Markdown dans le format PDF.

bash

sudo pacman -Syyu pandoc pandoc-citeproc
sudo pacman -Syyu `pacman -Ss texlive | cut -f 1 -d " " | grep -v "^$"`

NewsFlash

NewsFlash est un simple lecteur de flux RSS.

bash

flatpak install --user com.gitlab.newsflash

OBS

Étant donné que les fonctionnalités de Stream de Discord ne fonctionnent qu'à moitié sous Linux (on a l'image, mais pas le son), il faut passer par de tierces solutions afin de pouvoir partager son écran.

OBS présente l'avantage de permettre de streamer sur de nombreuses plateformes tel que Twitch, YouTube ou PeerTube.

bash

flatpak install --user com.obsproject.Studio

Steam

La célèbre plateforme de jeux. Actuellement, Valve (la société à l'origine de Steam) travaille afin de rendre les jeux vidéos plus accessibles sur les systèmes d'exploitation Linux. Ils ont actuellement leur propre distribution SteamOS basée sur Arch, qui utilise leur technologie ProtonDB (basée sur Wine) afin de lancer des jeux Windows sur Linux.

bash

flatpak install --user com.valvesoftware.Steam

Par la suite pour activer ProtonDb, il suffit de se rendre dans l'application puis: Steam > Paramètres > Steam Play > Activer Steam Play pour tous les autres titres > Proton 6.3-8.

Xpadneo

Par défaut, les manettes de Xbox ne fonctionnent pas en Bluetooth sur Manjaro (ainsi que sur de nombreuses autres distributions). Il est toujours possible de les faire fonctionner en filaire, mais ce n'est pas toujours d'un confort absolu. Le logiciel Xpadneo va simplement être là pour patcher ce problème et permettre d'utiliser une manette sans avoir besoin de la brancher.

bash

sudo pacman -S dkms
yay -S xpadneo-dkms

Moonlight

Moonlight est un logiciel de streaming pour pouvoir récupérer le flux vidéo de la technologie de streaming Nvidia.

bash

sudo pacman -S vulkan-validation-layers vulkan-tools vulkan-intel gamemode libde265
flatpak install --user com.moonlight_stream.Moonlight

Au niveau du serveur, il est possible d'utiliser la technologie de streaming du Nvidia Shield. Mais il semblerait que l'option la plus viable soit Sunshine qui est une réimplémentation open source du protocole.

AntiMicroX

Logiciel permettant de faire le mapping des touches d'une manette de Xbox sur les touches d'un clavier.

bash

flatpak install --user io.github.antimicrox.antimicrox

Synergy

Synergy est un logiciel permettant d'utiliser différents ordinateurs comme s'il s'agissait d'écrans. L'ordinateur principal (celui disposant d'un clavier et d'une souris) sera le serveur et tous les autres les clients.

Il s'agit d'une application payante, mais open source. Un fork populaire est Barrier. Cependant, ce dernier ne supporte pas Wayland et n'est plus maintenu. La meilleure solution est donc à mon sens de payer.

bash

wget "https://api-functions.stage.a.symless.com/download-log?synergyVersion=3.0.79.1-rc3&operatingSystem=Linux&architecture=flatpak&downloadUrl=https%3A%2F%2Frc.symless.com%2Fsynergy3%2Fv3.0.79.1-rc3%2Fsynergy-linux_x64-libssl3-v3.0.79.1-rc3.flatpak&userId=1452232" -O /tmp/synerg.flatpak

flatpak install --user /tmp/synerg.flatpak

Solaar

Un logiciel permettant de gérer les claviers et souris Logitech (personnellement, j'utilise un clavier MX Mechanical Mini avec une souris MX Master 3).

bash

sudo pacman -S solaar

Rio

Rio est un émulateur de terminal développé en Rust, GPU-accéléré et compatible Wayland/X11, offrant toutes les fonctionnalités que l'on attend d'un terminal moderne (split, affichage d'images, etc.). Il est léger et surtout très configurable via un fichier ~/.config/rio/config.toml.

bash

sudo pacman -S rio

Tmux

Tmux est un multiplexeur de terminaux bas niveau : il permet de gérer des onglets et des splits au sein d'un terminal. Le logiciel étant lui-même un démon, il est possible de fermer son émulateur de terminal et de retrouver sa session plus tard. Clairement l'un des meilleurs logiciels pour améliorer sa productivité en ligne de commande.

bash

sudo pacman -S tmux

TLPUI

Sur Linux TLP est un démon permettant de gérer au mieux l'autonomie de sa machine. Sur Manjaro cet outil est préinstallé dans le système d'exploitation. TLPUI est tout simplement une interface pour cet outil.

bash

sudo pacman -S tlp tlpui
sudo systemctl enable --now tlp

fwupd

Fwupd est un démon permettant de maintenir à jour les firmwares des composants d'un pc.

bash

sudo pacman -S fwupd
sudo systemctl enable --now fwupd

Pour rechercher les mises à jour, on utilise la commande :

bash

fwupdmgr get-updates

Et pour effectuer la mise à jour :

bash

fwupdmgr update

Kleopatra

Une petite interface pour la gestion de nos clés privées OpenPGP.

bash

flatpak install --user org.kde.kleopatra

Ghidra

Le puissant outil de reverse engineering de la NSA pour faire de l'analyse approfondie sur du code compilé.

bash

flatpak install --user org.ghidra_sre.Ghidra

WireShark

Un excellent analyseur de réseau pour ceux qui, comme moi, ne maîtrisent pas toute la puissance de tcpdump.

bash

flatpak install --user org.wireshark.Wireshark

BurpSuite

BurpSuite est un logiciel essentiel pour le pentesting. Il permet de créer un proxy http à travers lequel il sera possible d'intercepter les requêtes entre une application et son backend.

bash

sudo pacman -S blackarch/burpsuite

MacChanger

Un simple script permettant de changer d'adresse mac. Cela peut être relativement utile dans les lieux publics où une limite de temps d'utilisation est imposée.

bash

sudo pacman -S macchanger

Par exemple pour obtenir une nouvelle adresse mac sur la carte eth0 on peut taper :

bash

macchanger -a eth0

Pour revenir à l'adresse de base :

bash

macchanger -p eth0

Enfin dans certains cas (en général des scénarios d'attaque) il peut être utile de prendre une adresse mac spécifique :

bash

macchanger --mac=XX:XX:XX:XX:XX:XX eth0

Nmap

Un outil permettant de scanner un réseau et de déterminer pour chaque machine trouvée quels sont les services exposés.

bash

sudo pacman -S nmap

Magika

Magika est un outil développé par Google permettant d'identifier le type d'un fichier. Cet outil est bien plus puissant dans sa capacité d'identification que la commande file intégrée à la plupart des systèmes.

bash

yay -S python-magika

Bruno

Pour permettre aux développeurs back-end de tester les APIs REST qu'ils développent. Le logiciel est assez similaire à Postman, mais offre en plus la possibilité de source-controller ses fichiers.

bash

flatpak install --user com.usebruno.Bruno

Transmission

Un client torrent complet.

bash

flatpak install --user com.transmissionbt.Transmission

7zip

Le 7z est l'un, si ce n'est pas le format qui offre le meilleur taux de compression du moment, le rendant particulièrement efficace pour tout ce qui touche à l'archivage.

bash

sudo pacman -S 7zip

Par la suite, pour créer une archive avec un taux de compression maximal utilisez la commande :

bash

7z a -mx=9 archive.7z file1 file2

Et pour la décompresser, utilisez la commande :

bash

7z x archive.7z

JQ

JQ est un outil permettant de traiter des fichiers json en ligne de commande.

bash

sudo pacman -S jq

Voici un exemple simple visant à extraire les valeurs "a", "b" et "c" au sein du fichier JSON.

bash

echo '{"values": [{"name": "a"}, {"name": "b"}, {"name": "c"}]}' | jq -cM ".values[].name"

BorgBackup

Il s'agit d'une puissante solution de backup pour Linux. Bien qu'il existe des interfaces, l'utilitaire en ligne de commande est largement suffisant pour faire simplement des sauvegardes hors site à travers le protocole SSH.

bash

sudo pacman -S borg

Pour initialiser un backup sur un serveur en remote voici la commande :

bash

borg init --encryption=repokey ssh://mon-server/~/backup

Il est à noter que pour que borg pilote le remote il faut aussi l'installer sur le serveur en remote. Dans le cas présent il s'agit d'un serveur Fedora :

bash

sudo dnf install borgbackup

Pour faire son script de backup personnalisé le plus simple est encore de se référer à la documentation officielle.

Smartmontools

Smartmontools est un outil permettant de récupérer les données SMART concernant l'état de santé d'un disque dur ou SSD : Vitesse d'écriture, lecture si des secteurs ont été détectés comme défaillants... Faire des analyses de temps à autre peut s'avérer pertinent afin d'éventuellement faire passer un disque dur ou SSD interne en simple support de sauvegarde externe.

bash

sudo pacman -S smartmontools

Pour faire une analyse, il suffit de taper la commande (en remplaçant sda par le disque à analyser) :

bash

sudo smartctl -H /dev/sda

Si tout va bien, le résultat du test devrait être PASSED.

Pour avoir le rapport complet, il suffit de rajouter l'argument -a :

bash

sudo smartctl -H /dev/sda -a

WhoIs

Permet de donner un certain nombre d'informations concernant une adresse IP (localisation, FAI...).

bash

sudo pacman -S whois

Fastfetch

L'outil Neofetch était une vraie religion chez les utilisateurs de Linux. Cependant, son créateur a malheureusement décidé d'arrêter sa maintenance.

Le projet Fastfetch a donc pris le relais.

Il s'agit sans aucun doute de l'outil le plus inutile de la sélection... Il permet d'afficher un certain nombre de caractéristiques de sa machine sous un format coloré. Un vrai Linuxien se doit de toujours laisser un Neofetch/Fastfetch en cours d'exécution dans un coin de terminal sur chaque capture d'écran qu'il envoie. Cela permet de prouver au reste de la communauté la supériorité de sa distribution.

bash

sudo pacman -S fastfetch

Conky

Conky est un outil permettant de rajouter des informations personnalisées sur le bureau. On peut par exemple l'utiliser pour afficher son IP, la fréquence des différents cœurs du processeur, la consommation de RAM, la température de tel ou tel composant...

bash

sudo pacman -S conky
mkdir -p ~/.config/conky

echo 'conky.config = {
    alignment = "bottom_right",
    background = false,
    border_width = 1,
    cpu_avg_samples = 2,
    default_color = "white",
    default_outline_color = "white",
    default_shade_color = "white",
    double_buffer = true,
    draw_borders = false,
    draw_graph_borders = true,
    draw_outline = false,
    draw_shades = false,
    extra_newline = false,
    font = "JetBrainsMonoNerdFont-Medium:size=15",
    gap_x = 60,
    gap_y = 60,
    minimum_height = 5,
    minimum_width = 500,
    net_avg_samples = 2,
    no_buffers = true,
    out_to_console = false,
    out_to_ncurses = false,
    out_to_stderr = false,
    out_to_x = true,
    own_window = true,
    own_window_class = "Conky",
    own_window_transparent = false,
    own_window_type = "desktop",
    own_window_hints = "undecorated,below,sticky,skip_taskbar,skip_pager",
    own_window_argb_visual = true,
    own_window_argb_value = 0,
    show_graph_range = false,
    show_graph_scale = false,
    stippled_borders = 0,
    update_interval = 3.0,
    uppercase = false,
    use_spacer = "none",
    use_xft = true,
    xinerama_head = 1,
}

conky.text = [[
${color grey}CPU:
${color}${exec sensors | awk "/Core 0/ {print int(\$3)}"}°C${goto 85}0: ${cpubar cpu0 6,100} ${cpu cpu0}%${goto 300}1: ${cpubar cpu1 6,100} ${cpu cpu1}%
${color}${exec sensors | awk "/Core 1/ {print int(\$3)}"}°C${goto 85}2: ${cpubar cpu2 6,100} ${cpu cpu2}%${goto 300}3: ${cpubar cpu3 6,100} ${cpu cpu3}%
${color}${exec sensors | awk "/Core 2/ {print int(\$3)}"}°C${goto 85}4: ${cpubar cpu4 6,100} ${cpu cpu4}%${goto 300}5: ${cpubar cpu5 6,100} ${cpu cpu5}%
${color}${exec sensors | awk "/Core 3/ {print int(\$3)}"}°C${goto 85}6: ${cpubar cpu6 6,100} ${cpu cpu6}%${goto 300}7: ${cpubar cpu7 6,100} ${cpu cpu7}%

${color grey}Memory:
${color}RAM${goto 120}${membar 6,100} ${memperc}%${goto 300}(${mem})
${color}SWAP${goto 120}${swapbar 6,100} ${swapperc}%${goto 300}(${swap})

${color grey}Storage:
${color}/${color}${goto 120}${fs_bar 6,100 /} ${fs_used_perc /}%${goto 300}(${fs_used /})

${color grey}System:
${color}Kernel${goto 120}${kernel}
${color}Uptime${goto 120}${uptime}
${color}Process${goto 120}${processes}
${color}Podman${goto 120}${exec podman ps -q 2>/dev/null | wc -l}
${color}Docker${goto 120}${exec docker ps -q 2>/dev/null | wc -l}
${color}KVM${goto 120}${exec pgrep -f -c "qemu-system-x86_64"}

${color grey}Network:
${if_existing /proc/net/route wlo1}${color}Local${goto 120}${addr wlo1}
${color}Public${goto 120}${texeci 7200 curl -s https://ipinfo.io/ip}
${color}Download${goto 120}${downspeedf wlo1}k/s
${color}Upload${goto 120}${upspeedf wlo1}k/s${else}${color}Local${goto 120}-
${color}Public${goto 120}-
${color}Download${goto 120}- k/s
${color}Upload${goto 120}- k/s${endif}
$hr

${color grey}Name${goto 215}CPU${goto 305}MEM
${color}${top name 1}${goto 190}${top cpu 1}%${goto 280}${top mem 1}%
${color}${top name 2}${goto 190}${top cpu 2}%${goto 280}${top mem 2}%
${color}${top name 3}${goto 190}${top cpu 3}%${goto 280}${top mem 3}%
${color}${top name 4}${goto 190}${top cpu 4}%${goto 280}${top mem 4}%
${color}${top name 5}${goto 190}${top cpu 5}%${goto 280}${top mem 5}%
]]' > ~/.config/conky/conky.conf

echo '[Desktop Entry]
Type=Application
Exec=sh -c "sleep 10; conky;"
Name=Conky
Comment=Autostart conky at login' > ~/.config/autostart/conky.desktop

Configuration de l'environnement applicatif

Réparer les liens cliquables Flatpak

Il arrive que les liens cliquables ne mènent plus au navigateur pour les applications Flatpak. Ceci est lié à un problème de configuration de xdg-desktop-portal. Ce composant permet de faire la passerelle entre la machine hôte de Flatpak pour un certain nombre de tâches.

La première chose à faire est de vérifier que xdg-desktop-portal-gtk soit bien installé sur le système (si l'environnement de bureau est XFCE) :

bash

sudo pacman -S xdg-desktop-portal-gtk

Par la suite, il faut changer la configuration pour l'utilisateur :

bash

systemctl --user import-environment XDG_CURRENT_DESKTOP
mkdir -p ~/.config/xdg-desktop-portal/
cat << EOL > ~/.config/xdg-desktop-portal/xfce-portals.conf
[preferred]
default=gtk;
EOL
echo 'XDG_CURRENT_DESKTOP=XFCE' | tee -a /etc/environment
systemctl --user restart xdg-desktop-portal.service xdg-desktop-portal-gtk.service

Une fois ces actions effectuées, les liens devraient être de nouveau cliquables dans les applications XFCE.

Partage de dossier avec Flatpak

Chaque application Flatpak a ses propres paramètres, mais certaines d'entre elles ne peuvent pas du tout accéder aux fichiers de notre utilisateur.

C'est un très bon point en terme de sécurité, mais nettement moins bon en terme d'usage.

Un compromis est d'autoriser toutes les applications à accéder aux dossiers ~/Download et ~/Public. Ces dossiers ne doivent rien contenir d'important et ce n'est normalement pas problématique que toutes les applications puissent y accéder.

bash

flatpak override --user --filesystem=$HOME/Public
flatpak override --user --filesystem=$HOME/Downloads

Faire fonctionner un écran tactile

Certains ordinateurs sont équipés d'écran tactile. Pour un support complètement optimal, il est nécessaire d'installer le driver wacom :

bash

sudo pacman -S xf86-input-wacom xf86-input-libinput

Activation des programmes par défaut

Sur Linux, il ne suffit pas forcément qu'un programme soit installé pour qu'il soit utilisé par défaut pour ouvrir certains types de fichiers depuis l'explorateur de fichier (thunar) ou avec la commande exo-open. Pour utiliser la plupart des programmes précédemment installés comme programme par défaut il suffit de mettre à jour le fichier ~/.config/mimeapps.list :

bash

cat << EOL > ~/.config/mimeapps.list
[Default Applications]

application/octet-stream=code-oss.desktop;
application/x-gettext-translation=code-oss.desktop;
application/xml=code-oss.desktop;
application/x-wine-extension-ini=code-oss.desktop;
application/pdf=org.gnome.Papers.desktop;
application/vnd.oasis.opendocument.text=org.libreoffice.LibreOffice.desktop;
application/vnd.oasis.opendocument.spreadsheet=org.libreoffice.LibreOffice.desktop;
application/vnd.oasis.opendocument.presentation=org.libreoffice.LibreOffice.desktop;
application/vnd.oasis.opendocument.graphics=org.libreoffice.LibreOffice.desktop;
application/vnd.ms-excel=org.libreoffice.LibreOffice.desktop;
application/vnd.ms-powerpoint=org.libreoffice.LibreOffice.desktop;
application/msword=org.libreoffice.LibreOffice.desktop;
application/vnd.openxmlformats-officedocument.spreadsheetml.sheet=org.libreoffice.LibreOffice.desktop;
application/vnd.openxmlformats-officedocument.presentationml.presentation=org.libreoffice.LibreOffice.desktop;
application/vnd.openxmlformats-officedocument.wordprocessingml.document=org.libreoffice.LibreOffice.desktop;

text/plain=code-oss.desktop;

x-scheme-handler/jetbrains=jetbrains-toolbox.desktop;

image/jpeg=org.gnome.eog.desktop;
image/png=org.gnome.eog.desktop;
image/webp=org.gnome.eog.desktop;
image/gif=org.gnome.eog.desktop;
image/bmp=org.gnome.eog.desktop;
image/svg+xml=org.gnome.eog.desktop;

video/mpeg=org.videolan.VLC.desktop;
video/mp4=org.videolan.VLC.desktop;

audio/mpeg=org.videolan.VLC.desktop;

x-scheme-handler/http=xfce4-web-browser.desktop
x-scheme-handler/https=xfce4-web-browser.desktop
x-scheme-handler/mailto=xfce4-mail-reader.desktop
inode/directory=xfce4-file-manager.desktop
x-scheme-handler/trash=xfce4-file-manager.desktop

[Added Associations]
x-scheme-handler/http=xfce4-web-browser.desktop;
x-scheme-handler/https=xfce4-web-browser.desktop;
x-scheme-handler/mailto=xfce4-mail-reader.desktop;
inode/directory=xfce4-file-manager.desktop;
x-scheme-handler/trash=xfce4-file-manager.desktop;
EOL
xdg-settings set default-web-browser org.mozilla.firefox

Ajout de modèles de fichiers

Les utilisateurs de Windows connaissent tous l'option "clic droit + créer un document + nouveau document Word" très pratique quand on a besoin de manipuler beaucoup de fichiers sans passer nécessairement par les logiciels. Heureusement, XFCE propose une option assez similaire, il est donc possible directement depuis thunar de créer des templates de fichier à instancier avec un simple "clic droit + créer un document".

Dans l'exemple suivant, les templates vont servir à instancier différentes bases de code dans plusieurs langages :

bash

cat << EOL > ~/Templates/bash.sh
#!/bin/bash

echo Hello world !

exit 0
EOL

cat << EOL > ~/Templates/c.c
#include <stdlib.h>
#include <stdio.h>

int main(int arcc, char *argv[]) {
  printf("Hello world!\n");
  return 0;
}
EOL

cat << EOL > ~/Templates/c++.cpp
#include <iostream>

using namespace std;

int main(int arcc, char *argv[]) {
  cout << "Hello world !" << endl;
  return 0;
}
EOL

cat << EOL > ~/Templates/html.html
<!DOCTYPE html>
<html lang="fr">
<head>
  <meta charset="utf-8" />
  <title>Title</title>
  <link href="./style.css" />
</head>
<body>
  <nav>
  </nav>

  <header>
  </header>

  <section>
    <h1>Section</h1>

    <article>
      Hello world!
    </article>
  </section>

  <footer>
  </footer>

  <script src="./script.js"></script>
</body>
</html>
EOL

cat << EOL > ~/Templates/markdown.md
---
title: Title
description: Description
author: Flavien PERIER <perier@flavien.io>
date: 2020-09-27 18:00
---

## Title

Content
EOL

chmod 440 ~/Templates/*
chmod 550 ~/Templates

Quelques scripts

Voici quelques scripts à rajouter dans ~/bin qui peuvent s'avérer utiles.

update

Un petit script qui met à jour toutes nos applications avec les différents gestionnaires de paquets installés sur l'OS et qui injecte les thèmes dans les différentes plateformes Flatpak :

bash

#!/bin/bash

set -e

source "$HOME/.sdkman/bin/sdkman-init.sh"

echo "Update pacman"
sudo pacman --noconfirm -q -Syyu
sudo pacman --noconfirm -q -S "linux$(uname -r | cut -f1,2 -d. | tr -d ".")-headers"

echo "Update yay"
yay --noconfirm -q -Syyu

echo "Update clamav"
sudo freshclam

echo "Update Docker"
sudo docker images --format "{{.Repository}}:{{.Tag}}" | xargs -r -L1 sudo docker pull -q &

echo "Update Podman"
podman images --format "{{.Repository}}:{{.Tag}}" | xargs -r -L1 podman pull -q &

echo "Update SDK"
sdk update &

echo "Update Flatpak"
flatpak update --noninteractive -y &

echo "Update Claude code"
claude update &

wait

echo "End of update"

clean

Comme son nom l'indique, ce script permet de nettoyer différents éléments du système d'exploitation :

bash

#!/bin/bash

PROTECTED_FOLDER=(".ssh" ".themes" ".icons" ".fonts" "Templates" "Pictures" "Videos" "Music")
PROTECTED_FILETYPE=("pdf" "zip" "tar" "gz" "7z" "wav" "mp3" "mp4" "mkv" "mov")
HISTORY_PREFIX_TO_CLEAN=("pacman" "yay" "flatpak" "clear" "ls" "ll" "rm" "mv" "mkdir" "rmdir" "touch" "tar" "7z" "zip" "unzip" "unrar")

get-used-space() {
   df | tr -s " " | cut -f3 -d " " | tail -n +2 | sed -z 's/\n/+/g;s/+$/\n/' | bc
}

root-clean() {
  CLEAN_CACHE="$1"
  USER_NAME="$2"
  USER_HOME="$3"

  echo "Clean pacman"
  pamac remove --orphans --no-confirm
  pacman -Scc --noconfirm

  if [ $CLEAN_CACHE -eq 1 ]
  then
    echo "Clean root cache"
    rm -Rf /var/cache/*
    rm -Rf /root/.cache/*
  fi

  echo "Clean Docker"
  docker container prune -f
  docker volume prune -f
  docker network prune -f
  docker system prune -f

  echo "Chown user home"
  find $USER_HOME ! -user $USER_NAME | xargs -r -d "\n" -P4 -L10 chown $USER_NAME &
  find $USER_HOME ! -group $USER_NAME | xargs -r -d "\n" -P4 -L10 chgrp $USER_NAME &
  setfacl -R --remove-all $USER_HOME &
  wait

  echo "Adds access rights to vms for Qemu"
  mkdir -p $USER_HOME/Vms
  setfacl -m g:libvirt-qemu:rx $USER_HOME
  chgrp -R libvirt-qemu $USER_HOME/Vms

  echo "Delete old /etc configuration"
  find /etc -iname "*.old" -delete &
  find /etc -iname "*-" -delete &
  find /etc -iname "*~" -delete &
  wait

  echo "Delete unused logs"
  journalctl --vacuum-time=1d
  find $USER_HOME -type f -iname "*.log" -delete &
  find $USER_HOME -type f -iname "*.log.[0-9]" -delete &
  find /var/log -type f -iname "*.[0-9]" -delete &
  find /var/log -type f -iname "*.[0-9].log" -delete &
  find /var/log -type f -iname "*.old" -delete &
  rm -f /var/log/optimus-manager/daemon/*.log &
  rm -f /var/log/optimus-manager/switch/*.log &
  wait

  echo "Clean root history"
  rm -f /root/.*_history
}

user-clean() {
  CLEAN_CACHE="$1"

  echo "Clean yay"
  yay -Scc --noconfirm

  echo "Clean flatpak"
  flatpak uninstall --unused --delete-data -y
  rm -Rf $HOME/.local/share/flatpak/.removed/

  if [ $CLEAN_CACHE -eq 1 ]
  then
    echo "Clean user cache"
    rm -Rf $HOME/.cache/*
    find $HOME/.var/app/ -type d -name "cache" | xargs -r -d "\n" -P4 -L10 rm -Rf
  fi

  echo "Clean Podman"
  podman container prune -f
  podman volume prune -f
  podman network prune -f
  podman system prune -f

  echo "Remove user files"
  rm -f $HOME/.xsession-errors* &
  rm -Rf $HOME/Downloads/* &
  rm -Rf $HOME/.local/share/Trash &
  rm -Rf $HOME/.local/share/RecentDocuments &
  rm -f $HOME/.local/share/recently-used.xbel* &
  find $HOME -type f -iname "*.old" -delete &
  wait

  echo "Chmod user files"
  chmod -R go-rwx $HOME

  for FOLDER in ${PROTECTED_FOLDER[@]}
  do
    find $HOME/$FOLDER -type d ! -perm 500 | xargs -r -d "\n" -P4 -L10 chmod 500 &
    find $HOME/$FOLDER -type f ! -perm 400 | xargs -r -d "\n" -P4 -L10 chmod 400 &
  done
  wait

  for FILETYPE in ${PROTECTED_FILETYPE[@]}
  do
    find $HOME -type f -name "*.$FILETYPE" | xargs -r -d "\n" -P4 -L10 chmod ugo-wx &
  done
  wait

  find $HOME/Vms -type d ! -perm 550 | xargs -r -d "\n" -P4 -L10 chmod 550
  find $HOME/Vms -type f ! -perm 770 | xargs -r -d "\n" -P4 -L10 chmod 770
  chmod 750 $HOME
  chmod 777 $HOME/Public
  chmod 700 $HOME/.ssh/agent

  echo "Clean history"
  rm -f $HOME/.*_history
  rm -f $HOME/.wget-hsts
  rm -f $HOME/.lesshst
  for COMMAND in ${HISTORY_PREFIX_TO_CLEAN[@]}
  do
    yes all | fish -c "history delete --prefix '$COMMAND '"
  done
}

main() {
  CLEAN_CACHE=0

  if [[ $* == "-c" ]] || [[ $* == "--cache" ]]
  then
    CLEAN_CACHE=1
  elif [[ $* == "-h" ]] || [[ $* == "--help" ]]
  then
    echo "-c, --cache           Clean cache"
    exit 0
  fi

  USED_SPACE_BEFORE=$(get-used-space)

  ROOT_CLEAN_DEC=$(declare -f root-clean)
  sudo bash -c "$ROOT_CLEAN_DEC; root-clean $CLEAN_CACHE $USER $HOME"

  user-clean $CLEAN_CACHE

  USED_SPACE_AFTER=$(get-used-space)
  RECOVERED_SPACE=$(echo "scale=3; ($USED_SPACE_BEFORE - $USED_SPACE_AFTER) / 1000000" | bc)
  echo "Recovered space: $RECOVERED_SPACE Go"
}

main $*

update-hosts

Un petit script à exécuter dans une crontab pour mettre à jour le fichier hosts.

bash

#!/bin/bash

set -e

HOSTS_PATH="/etc/hosts"
NEW_HOSTS_PATH="/etc/hosts.new"
BACKUP_HOSTS_PATH="/etc/hosts~"

echo "127.0.0.1  localhost" > $NEW_HOSTS_PATH

cat << EOF | tee $NEW_HOSTS_PATH
127.0.0.1  localhost
::1        localhost ip6-localhost ip6-loopback
ff02::1    ip6-allnodes
ff02::2    ip6-allrouters
127.0.1.1  pc-flavien
EOF

curl -s https://raw.githubusercontent.com/StevenBlack/hosts/refs/heads/master/hosts | grep -v "^#" | tee -ap $NEW_HOSTS_PATH

curl -s https://dl.red.flag.domains/pihole/red.flag.domains.txt | grep -v "^#" | tee -ap $NEW_HOSTS_PATH

rm -f $BACKUP_HOSTS_PATH
mv $HOSTS_PATH $BACKUP_HOSTS_PATH
mv $NEW_HOSTS_PATH $HOSTS_PATH

Conclusion

Je pense que la principale différence entre un utilisateur de Windows ou de Mac par rapport à un utilisateur de Linux est que l'un adapte son usage à ce que lui propose son système et l'autre adapte son système à son besoin. L'installation que je propose dans cet article n'est pas une installation orientée légèreté, beaucoup de logiciels sont installés, mais ils répondent tous à un besoin et aucun d'entre eux n'est superflu (sauf peut-être neofetch). Libre à vous à présent de vous inspirer (ou non) de mon installation et de construire la vôtre, qui répondra à vos besoins.

Il est à noter que cette page est régulièrement mise à jour et que par extension, des paragraphes peuvent être incomplets à un instant donné.

Si vous rencontrez des problèmes, n'hésitez pas à me contacter par mail sur perier@flavien.io.

Environnement Manjaro

Table of contents

information

Installation du système

Mise à jour de Manjaro

Quelques commandes Pacman

Gestionnaires de paquets

Installation des headers

Configuration du réseau

Configuration du Shell

Apparence

Nommage des dossiers

Installation de l'antivirus

Mise en place d'un pare-feu

Outils de développement

Environnement Java/Kotlin

Environnement Node.js

Autres langages

Outils JetBrains

Android ADB

Installation de Docker et Podman

Installation de K3s

Utilisation de KVM

Partage de dossier

Copie de disque

Logiciels

Configuration de l'environnement applicatif

Réparer les liens cliquables Flatpak

Partage de dossier avec Flatpak

Faire fonctionner un écran tactile

Activation des programmes par défaut

Ajout de modèles de fichiers

Quelques scripts

update

clean

update-hosts

Conclusion

Sources