👇

🌍 Archipel — Repenser la communication sans Internet 🚀 Inspiration

Dans un monde hyperconnecté, nous dépendons presque entièrement d’Internet et d’infrastructures centralisées pour communiquer. Mais que se passe-t-il lorsque :

L’accès à Internet est coupé ?

Les infrastructures sont censurées ?

Les réseaux deviennent indisponibles en situation de crise ?

C’est de cette réflexion qu’est né Archipel.

Nous voulions concevoir un système capable de fonctionner sans Internet, sans serveur central, tout en garantissant :

🔐 Sécurité

🌐 Décentralisation

⚡ Résilience

🤝 Confiance distribuée

L’idée était simple mais ambitieuse : permettre à des machines de communiquer directement entre elles, en pair à pair, avec chiffrement intégré et logique autonome.

🧠 Ce que nous avons appris

Ce projet nous a poussés à approfondir plusieurs domaines clés :

1️⃣ Réseaux & Protocoles

Nous avons étudié :

La communication TCP/UDP

Le peer discovery

Les mécanismes de handshake

La gestion des connexions persistantes

Nous avons compris qu’un protocole réseau doit être :

𝑅 𝑜 𝑏 𝑢 𝑠 𝑡 𝑒 + 𝑃 𝑟 𝑒 ˊ 𝑣 𝑖 𝑠 𝑖 𝑏 𝑙 𝑒 + 𝑆 𝑒 ˊ 𝑐 𝑢 𝑟 𝑖 𝑠 𝑒 ˊ Robuste+Pr e ˊ visible+S e ˊ curis e ˊ 2️⃣ Cryptographie appliquée

Nous avons intégré :

Génération de clés

Chiffrement symétrique (AES)

Gestion d’ACK sécurisés

Nous avons appris que la sécurité ne se résume pas au chiffrement, mais inclut :

Validation des entrées

Gestion des erreurs

Protection contre les comportements malveillants

3️⃣ Architecture logicielle

Nous avons conçu une séparation claire :

Backend → gestion réseau & logique protocolaire

Frontend → visualisation & interaction utilisateur

L’objectif était d’éviter le couplage fort :

𝑈 𝐼 ≠ 𝐿 𝑜 𝑔 𝑖 𝑞 𝑢 𝑒

𝑀 𝑒 ˊ 𝑡 𝑖 𝑒 𝑟 UI  =Logique M e ˊ tier 🛠️ Comment nous avons construit Archipel 🧱 1. Architecture

Le projet repose sur :

Un moteur réseau P2P

Un système de découverte automatique des pairs

Un protocole d’échange structuré

Un système de transfert de fichiers par chunks

Une interface utilisateur moderne

Chaque nœud du réseau est autonome et peut :

Découvrir d’autres nœuds

Établir une connexion

Échanger des messages chiffrés

Transférer des fichiers

Vérifier l’intégrité des données

🔄 2. Fonctionnement simplifié

Le nœud démarre

Il annonce sa présence sur le réseau

Il détecte d’autres pairs

Un handshake est établi

Les échanges chiffrés commencent

Les fichiers sont découpés en chunks

Les ACK valident la réception

Le transfert suit une logique similaire à :

𝐹 𝑖 𝑐 ℎ 𝑖 𝑒

𝑟

∑

𝑖

1 𝑛 𝐶 ℎ 𝑢 𝑛 𝑘 𝑖 Fichier= i=1 ∑ n ​

Chunk i ​

Chaque chunk est validé individuellement avant reconstruction.

🎨 3. Interface utilisateur

Nous avons développé une UI :

Fluide

Minimaliste

Mode clair / sombre

Feedback en temps réel

Visualisation des peers connectés

Indicateurs de sécurité

L’objectif UX :

Comprendre l’état du réseau en 3 secondes

Envoyer un message en moins de 3 clics

Voir clairement les statuts

⚔️ Les défis rencontrés 🔥 1. Gestion des connexions

Maintenir des connexions stables sans serveur central a été complexe :

Détection des peers inactifs

Synchronisation des états

Gestion des erreurs réseau

🔐 2. Sécurité cohérente

Chiffrer les messages ne suffisait pas.

Nous avons dû :

Sécuriser le handshake

Empêcher les injections

Gérer les erreurs proprement

Assurer la cohérence des données

📦 3. Transfert de fichiers

Découper un fichier en morceaux introduit :

Gestion des pertes de chunks

Réassemblage correct

Validation d’intégrité

Un simple échec pouvait corrompre l’ensemble :

𝑆 𝑖

𝐶 ℎ 𝑢 𝑛 𝑘 𝑘

𝑒 𝑠 𝑡

𝑖 𝑛 𝑣 𝑎 𝑙 𝑖 𝑑 𝑒 ⇒ 𝐹 𝑖 𝑐 ℎ 𝑖 𝑒 𝑟

𝑖 𝑛 𝑣 𝑎 𝑙 𝑖 𝑑 𝑒 Si Chunk k ​

est invalide⇒Fichier invalide 🧠 4. Cohérence Frontend ↔ Backend

L’un des plus grands défis fut de garantir que :

L’interface ne casse jamais la logique protocolaire

Les flux réseau soient correctement représentés visuellement

Les erreurs backend soient compréhensibles côté utilisateur

🏆 Ce que représente Archipel

Archipel n’est pas seulement un projet technique.

C’est une démonstration que :

La communication peut exister sans dépendance globale

La décentralisation est viable

La sécurité peut être intégrée dès la conception

L’autonomie réseau est possible

C’est une exploration de la souveraineté numérique.

🌟 Conclusion

Archipel nous a appris que construire un protocole distribué demande :

Rigueur

Vision architecturale

Discipline technique

Compréhension profonde des réseaux

Ce projet nous a permis de passer d’une simple idée à une implémentation concrète d’un système distribué sécurisé.

Et surtout, il nous a montré que l’innovation naît souvent des contraintes.

Built With

• nextjs
• node.js