[Tuto à 4 mains] Discuter en P2P et sans serveur avec IPFS-Chat : Arch et debian/*buntu/Mint

[nam1962]

[Tuto] IPFS-Chat : La messagerie P2P sans serveur « comme dans les films »

Envie d’une communication 100% décentralisée, sans passer par un serveur central ou une entreprise ? IPFS-Chat est une expérience de discussion qui utilise le protocole P2P IPFS. Ici, pas de compte à créer, pas de Cloud : vos messages circulent directement entre les utilisateurs (Peer-to-Peer).

ATTENTION : Ne copiez-collez pas aveuglément !
Avant de lancer les commandes, vous devrez systématiquement remplacer deux éléments :

• VOTRE_PSEUDO : Le nom sous lequel vous apparaîtrez.
• NOM_DE_LA_SALLE : Le nom du salon de discussion. Vous ne verrez que les personnes ayant rejoint exactement le même nom de salle (attention à la casse !).

Note technique : Cet outil fonctionne en Terminal (interface texte avec tmux). C’est léger, souverain et sécurisé, mais tout se gère au clavier.

---

1. Pourquoi une approche « clientless » ?

Ce tutoriel propose une solution de chat IPFS basée uniquement sur des scripts bash et le daemon IPFS natif. Contrairement aux applications dédiées avec interface graphique, cette approche présente plusieurs avantages stratégiques :

Discrétion et sécurité opérationnelle

Pas d’installation d’application identifiable :

• Aucun paquet spécifique « ipfs-chat » ou équivalent dans la liste des logiciels installés
• Juste des outils standards (tmux, bash, ipfs) présents sur la plupart des systèmes Linux
• Un simple apt list --installed ou pacman -Q ne révèle rien de suspect

Empreinte disque minimale :

• Un seul script bash de quelques Ko dans le home directory
• Peut être renommé en quelque chose d’anodin (system-check.sh, backup-tools.sh)
• Facile à déplacer, cacher ou chiffrer dans un volume LUKS
• Logs optionnels et configurables (peuvent être désactivés ou redirigés)

Pas de traces dans les menus système :

• Contrairement à une application classique, aucune entrée .desktop obligatoire
• Le lanceur peut être créé ou supprimé à volonté
• Lance-toi depuis le terminal sans laisser de traces GUI

Difficile à détecter par analyse automatique :

• Pas de processus avec un nom révélateur type « ipfs-chat-gui »
• Les processus visibles sont: bash, tmux, ipfs daemon (outils légitimes)
• Le trafic réseau est du trafic IPFS standard, indiscernable d’un usage normal
• Pas de signature applicative spécifique

Flexibilité et contrôle total :

• Code source visible et modifiable (pas de binaire opaque)
• Personnalisation complète du comportement
• Facile à adapter, forker, améliorer
• Pas de dépendance à un mainteneur tiers

Cas d’usage

Cette approche est particulièrement adaptée pour :

• Les utilisateurs soucieux de discrétion numérique
• Les environnements où l’installation de logiciels est surveillée
• Les situations nécessitant une communication résistante à la censure
• L’apprentissage du fonctionnement réel d’IPFS (pédagogique)
• Les systèmes minimalistes où chaque paquet compte

Avertissement : Cette solution n’offre pas l’anonymat complet. Votre adresse IP reste exposée aux autres pairs IPFS. Pour un anonymat renforcé, combinez avec Tor ou I2P. La discrétion dont on parle ici concerne la détection locale sur votre machine, pas l’anonymat réseau.

---

2. La méthode « Flash » de Steeve (Spécial Debian / Ubuntu / Mint)

Pour un test immédiat entre deux machines sur base Debian, voici la procédure complète.

# Installation des dépendances
sudo apt install tmux ipfs dialog wget -y

# Initialisation d'un dépôt IPFS dédié
IPFS_PATH=~/.ipfs-chat ipfs init

# Configuration pour PubSub
IPFS_PATH=~/.ipfs-chat ipfs config --json Pubsub.Enabled true

# Migration du repo si nécessaire
IPFS_PATH=~/.ipfs-chat ipfs repo migrate

---

3. La méthode détaillée (Spécial Arch / EndeavourOS)

Sur Arch et ses dérivées, le paquet IPFS se nomme kubo. Les versions récentes (0.39+) nécessitent une configuration spécifique :

# 1. Installation des dépendances
sudo pacman -S tmux kubo dialog wget

# 2. Initialisation d'un dépôt IPFS dédié
IPFS_PATH=~/.ipfs-chat ipfs init

# 3. Configuration manuelle (pour Kubo 0.39+)
IPFS_PATH=~/.ipfs-chat ipfs config Provide.Strategy "all"
IPFS_PATH=~/.ipfs-chat ipfs config --json Provide.DHT.Interval '"12h"'
IPFS_PATH=~/.ipfs-chat ipfs config --json Reprovider null
IPFS_PATH=~/.ipfs-chat ipfs config --json Pubsub.Enabled true

# 4. Migration du repo (si message d'erreur au lancement)
IPFS_PATH=~/.ipfs-chat ipfs repo migrate

---

4. Simplifier l’usage : ajouter IPFS_PATH aux variables d’environnement

Pour éviter de taper IPFS_PATH=~/.ipfs-chat avant chaque commande ipfs, ajoutez cette variable à votre shell :

Pour Bash (Debian/Ubuntu) :

# Ajouter à ~/.bashrc
echo 'export IPFS_PATH=~/.ipfs-chat' >> ~/.bashrc
source ~/.bashrc

# Vous pouvez maintenant utiliser directement :
ipfs pubsub ls
ipfs swarm peers | wc -l

Pour Zsh (Arch/EndeavourOS) :

# Ajouter à ~/.zshrc
echo 'export IPFS_PATH=~/.ipfs-chat' >> ~/.zshrc
source ~/.zshrc

# Vous pouvez maintenant utiliser directement :
ipfs pubsub ls
ipfs swarm peers | wc -l

Note : Après avoir ajouté cette variable, redémarrez votre terminal ou tapez source ~/.bashrc (ou source ~/.zshrc) pour appliquer les changements. Dans le reste de ce tuto, nous supposerons que cette variable est configurée.

---

5. Créer le script de lancement (Méthode universelle)

Ce script fonctionne avec toutes les versions de Kubo/IPFS. Il offre une interface tmux avec 3 zones : messages, peers connectés, et champ de saisie. Copiez ce bloc complet et collez-le dans votre terminal :

cat << 'EOF' > ~/start-ipfs-chat.sh
#!/bin/bash
# IPFS Chat P2P – tmux + partage fichiers + notifications + son

# --- PARAMÈTRES À MODIFIER ---
PSEUDO="VOTRE_PSEUDO"
ROOM="NOM_DE_LA_SALLE"
# -----------------------------

SESSION="ipfs-chat"
IPFS_PATH="$HOME/.ipfs-chat"
LOG_DIR="$HOME/.ipfs-chat/logs"
NOTIF_SOUND="/usr/share/sounds/freedesktop/stereo/message.oga"
mkdir -p "$LOG_DIR"

command -v tmux >/dev/null || { echo "tmux manquant"; exit 1; }
command -v notify-send >/dev/null || echo "notify-send manquant, notifications désactivées"
command -v paplay >/dev/null || echo "paplay manquant, sons désactivés"

# Lancer daemon IPFS si nécessaire
if ! pgrep -f "IPFS_PATH=$IPFS_PATH ipfs daemon" >/dev/null; then
  IPFS_PATH=$IPFS_PATH ipfs daemon --enable-pubsub-experiment >/tmp/ipfs-daemon.log 2>&1 &
  sleep 5
fi

# Nettoyer ancienne session
tmux kill-session -t "$SESSION" 2>/dev/null

# Créer session vide
tmux new-session -d -s "$SESSION" -n chat

# Split panes: Messages (75%) | Peers (10%) | Input (15%)
tmux split-window -v -p 25
tmux select-pane -t 1
tmux split-window -v -p 40

# ---------- Messages (pane 0) ----------
tmux select-pane -t 0
tmux respawn-pane -t "$SESSION:0.0" -k bash -c "
clear
echo '📡 IPFS Chat – Room: $ROOM | Pseudo: $PSEUDO'
echo '══════════════════════════════════════════════'
LOGFILE=\"$LOG_DIR/$ROOM.log\"
IPFS_PATH=$IPFS_PATH ipfs pubsub sub \"$ROOM\" 2>/dev/null |
while read -r msg; do
  command -v paplay >/dev/null && paplay \"$NOTIF_SOUND\" 2>/dev/null &
  if [[ \"\$msg\" != $PSEUDO:* && \"\$msg\" != __typing__:* ]]; then
    command -v notify-send >/dev/null && notify-send \"IPFS Chat\" \"\$msg\"
  fi
  if [[ \"\$msg\" != __typing__:* ]]; then
    echo \"[\$(date +%H:%M:%S)] \$msg\"
    echo \"[\$(date +%H:%M:%S)] \$msg\" >> \"\$LOGFILE\"
  fi
done
"

# ---------- Peers (pane 1) ----------
tmux respawn-pane -t "$SESSION:0.1" -k bash -c "
while true; do
  clear
  PEERS=\$(IPFS_PATH=$IPFS_PATH ipfs pubsub peers \"$ROOM\" 2>/dev/null | wc -l)
  echo \"🔗 \$PEERS peer(s)\"
  TYPING=\$(IPFS_PATH=$IPFS_PATH ipfs pubsub sub \"$ROOM\" 2>/dev/null | grep -m1 '^__typing__:' | timeout 1 tail -n1)
  if [[ -n \"\$TYPING\" ]]; then
    TYPER=\${TYPING#__typing__:}
    echo \"✏️ \$TYPER est en train d'écrire...\"
  fi
  sleep 2
done
"

# ---------- Input (pane 2) ----------
tmux respawn-pane -t "$SESSION:0.2" -k bash -c "
PSEUDO=\"$PSEUDO\"
echo 'Commandes : /quit  /nick pseudo  /send fichier'
while true; do
  read -e -p '💬 ' msg
  echo \"__typing__:\$PSEUDO\" | IPFS_PATH=$IPFS_PATH ipfs pubsub pub \"$ROOM\" 2>/dev/null
  case \"\$msg\" in
    /quit)
      tmux kill-session -t \"$SESSION\"
      exit
      ;;
    /nick*)
      NEW=\${msg#/nick }
      [ -n \"\$NEW\" ] && PSEUDO=\"\$NEW\" && echo \"Pseudo → \$PSEUDO\"
      ;;
    /send*)
      FILE=\${msg#/send }
      if [ -f \"\$FILE\" ]; then
        HASH=\$(IPFS_PATH=$IPFS_PATH ipfs add -Q \"\$FILE\")
        MSG=\"\$PSEUDO a partagé le fichier \$FILE : \$HASH\"
        echo \"\$MSG\" | IPFS_PATH=$IPFS_PATH ipfs pubsub pub \"$ROOM\" 2>/dev/null
        echo \"Fichier ajouté à IPFS : \$HASH\"
      else
        echo \"Fichier introuvable : \$FILE\"
      fi
      ;;
    *)
      [ -n \"\$msg\" ] && echo \"\$PSEUDO: \$msg\" | IPFS_PATH=$IPFS_PATH ipfs pubsub pub \"$ROOM\" 2>/dev/null
      ;;
  esac
done
"

tmux select-pane -t "$SESSION:0.2"
tmux attach -t "$SESSION"
EOF

chmod +x ~/start-ipfs-chat.sh

N’oubliez pas d’éditer le script pour personnaliser VOTRE_PSEUDO et NOM_DE_LA_SALLE :

nano ~/start-ipfs-chat.sh

---

6. Intégration au menu des applications (optionnel)

Rappel discrétion : Créer un lanceur dans le menu rend l’outil plus visible. Si la discrétion est importante, lancez simplement le script depuis le terminal et renommez-le en quelque chose d’anodin.

Pour retrouver l’outil dans votre menu (catégorie Réseau/Internet) :

cat << EOF > ~/.local/share/applications/ipfs-chat.desktop
[Desktop Entry]
Name=IPFS Chat
Comment=Messagerie P2P souveraine
Exec=/home/\$USER/start-ipfs-chat.sh
Icon=utilities-terminal
Terminal=false
Type=Application
Categories=Network;Chat;
EOF

---

7. Partage de fichiers P2P – Guide complet

L’un des grands avantages d’IPFS est le partage de fichiers décentralisé. Voici comment utiliser cette fonctionnalité dans le chat.

7.1. Envoyer un fichier

Dans le chat IPFS, tapez :

/send /chemin/complet/vers/fichier.pdf

Exemples concrets :

# Partager un document depuis le Bureau
/send ~/Bureau/presentation.pdf

# Partager une image
/send ~/Téléchargements/photo.jpg

# Partager un script
/send ~/start-ipfs-chat.sh

Le fichier est ajouté au réseau IPFS, un hash unique est généré, et ce hash est partagé dans le chat.

7.2. Visualiser un fichier sans le télécharger

Ouvrir un nouveau terminal et taper :

# Afficher le contenu (texte)
ipfs cat QmbYHRCPmyXRfG4qZparHdPB4GDPcwPnFe8M4pgW2yAPkf

# Avec pagination
ipfs cat HASH | less

# Ouvrir une image
ipfs cat HASH > /tmp/temp.jpg && xdg-open /tmp/temp.jpg

# Ouvrir un PDF
ipfs cat HASH | zathura -

7.3. Télécharger et sauvegarder un fichier

# Méthode recommandée
ipfs cat HASH > presentation.pdf

# Dans un dossier spécifique
ipfs cat HASH > ~/Documents/presentation.pdf

7.4. Script pratique pour récupération

cat << 'EOF' > ~/ipfs-get-file.sh
#!/bin/bash
if [ -z "$1" ]; then
  echo "Usage: $0 HASH [nom-fichier]"
  exit 1
fi

HASH="$1"
OUTPUT="${2:-fichier-$(date +%s)}"

echo "Téléchargement depuis IPFS..."
ipfs cat "$HASH" > "$OUTPUT"

if [ $? -eq 0 ]; then
  echo "✓ Fichier téléchargé : $OUTPUT ($(du -h "$OUTPUT" | cut -f1))"
else
  echo "✗ Erreur"
fi
EOF

chmod +x ~/ipfs-get-file.sh

Usage :

~/ipfs-get-file.sh QmbYHRCPmyXRfG4qZparHdPB4GDPcwPnFe8M4pgW2yAPkf doc.pdf

---

8. Utilisation et astuces

• Lancement : ~/start-ipfs-chat.sh dans un terminal
• Interface tmux : Messages (75%), peers (10%), input (15%)
• Commandes : /quit, /nick PSEUDO, /send fichier
• Logs : ~/.ipfs-chat/logs/NOM_DE_LA_SALLE.log
• Vérifier présence : ipfs pubsub peers SALLE
• Dépannage : cat /tmp/ipfs-daemon.log

---

9. Diagnostic et commandes utiles

# Daemon actif
ps aux | grep "ipfs daemon"

# Peers réseau global
ipfs swarm peers | wc -l

# Topics actifs
ipfs pubsub ls

# Peers dans une room
ipfs pubsub peers SALLE

# Message test manuel
echo "test" | ipfs pubsub pub SALLE

Redémarrage propre :

pkill -f ipfs
tmux kill-session -t ipfs-chat
rm ~/.ipfs-chat/repo.lock ~/.ipfs-chat/datastore/LOCK 2>/dev/null
~/start-ipfs-chat.sh

Migration repo :

pkill -f "ipfs daemon"
ipfs repo migrate
IPFS_PATH=~/.ipfs-chat ipfs daemon --enable-pubsub-experiment &

---

10. Problèmes fréquents

Peers à 0 mais messages passent :

• Normal. IPFS utilise des relay nodes pour contourner NAT/pare-feu
• Pour connexion directe : ouvrir port 4001 TCP/UDP sur votre box

Erreur « repo needs migration » :

ipfs repo migrate

Daemon ne démarre pas (Kubo 0.39+) :

ipfs config --json Reprovider null
cat /tmp/ipfs-daemon.log

---

11. Écosystème IPFS et extensions

Projets notables utilisant IPFS

Médias et contenus :

• Audius : Plateforme musicale décentralisée (millions d’utilisateurs actifs)
• Odysee/LBRY : Alternative décentralisée à YouTube
• DTube : Plateforme vidéo sur IPFS (actif mais avec limitations techniques récentes)
• NFT.Storage : Stockage gratuit IPFS pour NFTs

Infrastructure :

• FileCoin : Réseau de stockage coopératif blockchain, complémentaire IPFS
• Fleek : Déploiement sites web sur IPFS
• Pinata : Service de pinning IPFS professionnel
• Brave Browser : Intègre IPFS nativement

Bases de données et collaboration :

• OrbitDB : Base de données distribuée P2P
• Ceramic Network : Réseau de données décentralisées
• PeerPad : Éditeur collaboratif P2P (toujours accessible à peerpad.net)

Extension navigateur IPFS Companion

Pour accéder facilement aux contenus IPFS via votre navigateur :

Installation :

• Firefox : https://addons.mozilla.org/firefox/addon/ipfs-companion/
• Chrome/Brave : Chrome Web Store, chercher « IPFS Companion »

Fonctionnalités :

• Accès direct aux adresses ipfs:// dans le navigateur
• Détection automatique des liens IPFS
• Intégration avec votre nœud local
• Partage fichiers par glisser-déposer
• Épinglage de contenus

Configuration :

# L'extension se connecte automatiquement au daemon local
# Settings > IPFS API : http://127.0.0.1:5001
# Si daemon actif, status "Connected"

Usage pratique :

• Cliquer sur hash IPFS (QmXXX…) pour ouverture directe navigateur
• URLs ipfs://HASH automatiquement résolues
• Glisser-déposer fichiers dans l’extension pour ajout IPFS

Astuce : Avec IPFS Companion, cliquez sur ipfs://HASH dans votre navigateur pour visualiser un fichier partagé sans ligne de commande.

---

Une solution élégante, discrète et souveraine pour communiquer en P2P sans serveurs centraux.

Bon chat décentralisé !

Un jeune site que j'aime bien, la ferrari du T-shirt ...bio en plus : GoudronBlanc

[Auteur]

Articles