Les chercheurs de X41 D-Sec viennent de divulguer une faille critique baptisée BadHost (CVE-2026-48710) dans Starlette, le framework Python qui sert de fondation à FastAPI, vLLM , LiteLLM et une grande partie des serveurs MCP basés sur FastAPI.

325 millions de téléchargements par semaine, et il suffit d'injecter un seul caractère dans le header HTTP "Host" pour contourner les contrôles d'accès path-based qui lisent "request.url.path" dont autant dire que beaucoup de déploiements d'agents IA en production tournent en ce moment avec une porte d'entrée très mal verrouillée.

Le proof of concept publié par OSTIF donne ceci :

curl -i -H 'Host: foo' http://target/admin # 403, bloqué
curl -i -H 'Host: foo?' http://target/admin # 200, ça passe !!

Et c'est tout ! Un simple point d'interrogation collé au Host header, et l'endpoint "/admin" qui jusqu'alors filtrait les non-authentifiés s'ouvre alors aussi facilement que le claque-merde de mes haters ^^.

Donc si votre infra utilise FastAPI, vLLM ou LiteLLM exposés directement en ASGI (uvicorn, hypercorn, granian) sans reverse proxy strict devant, vous pouvez tester votre exposition immédiatement grâce au scanner de BadHost développé par Nemesis et X41 D-Sec.

Niveau mécanique, Starlette reconstruit l'objet "request.url" en concaténant la valeur du header "Host" avec le path de la requête, puis re-parse le tout. Sauf que la valeur de "Host" n'est jamais validée donc si vous y injectez un "/", un "?" ou un "#", vous décalez la frontière entre path, query et fragment au moment du re-parse.

Du coup, le routeur Starlette dispatche sur le vrai path de la requête HTTP (donc votre endpoint sensible s'exécute bien), mais les middlewares qui lisent "request.url.path" voient simplement un path empoisonné qui ne correspond plus à rien d'interdit.

Donc le contrôle d'accès saute et le code derrière tourne quand même. On est sur un score CVSS de 7/10 et la boite de sécu Secwest estime même que cette note est largement sous-estimée... En gros c'est super grave !

Car la portée réelle ce sont surtout les serveurs MCP qui peuvent stocker ou manipuler des tokens et identifiants pour accéder aux ressources externes auxquelles les agents IA se connectent : bases de données, comptes mail, calendriers, S3, webhooks...etc

Bref, le genre de "coffre-fort" que vous ne voulez pas voir ouvert via un header HTTP à la con malformé. Markus Vervier de X41 D-Sec a même publié un petit échantillon de ce que leurs scanners ont déjà trouvé en production : Des bases de données d'essais cliniques chez des biopharmas, des données de vérification d'identité avec PII en temps réel, des accès SSH à des équipements industriels via bastion, des boites mails complètes en lecture/écriture, des listes de souscripteurs CMS, des topologies AWS complètes avec metric queries.

Bref, l'écosystème agents IA vient de passer en mode naturiste !

Pour régler ce problème, vous devez donc mettre à jour vers Starlette 1.0.1 ou supérieur, dans tous vos déploiements LLM qui l'intègrent... Et là c'est le bordel parce qu'il y en a partout : Dans les images Docker, les virtualenvs et les artefacts "vendorisés" un peu partout... Donc faut tout rebuilder.

Et si vous avez du code custom, l'OSTIF recommande aussi de remplacer request.url.path par request.scope["path"] partout où une décision de sécurité est prise.

En gros, lire la valeur non reconstruite est le "fix" qui survivra aux prochaines versions du bug, parce que croyez-moi, ça reviendra à coup sûr !

Maintenant, côté infra, X41 D-Sec et OSTIF indiquent que nginx, Apache httpd et Cloudflare rejettent le PoC par défaut, mais ça ne doit pas vous empêcher de vérifier votre config. Donc ne traitez votre reverse proxy comme une mitigation qu'après l'avoir testé explicitement avec le scanner Nemesis.

Au-delà du correctif technique, BadHost rappelle une mécanique qu'on a déjà vue avec la faille RCE de llama-cpp-python à savoir que la chaîne d'approvisionnement de l'IA ne tient que sur quelques mainteneurs bénévoles qui prennent des risques personnels énormes pour patcher proprement.

Kludex, le mainteneur de Starlette, est actuellement sous une avalanche de reports depuis des mois. L'audit qui a permis de trouver le bug a par ailleurs été financé par OSTIF et AWS et sans ça, BadHost serait encore probablement dans la nature pour un an voire plus avant d'être découvert plus naturellement.

Donc si votre boîte fait tourner du LLM en prod via FastAPI, vLLM ou LiteLLM, vous avez aujourd'hui 2 choses urgentes à faire : 1/ passer votre infra dans le scanner Nemesis, et 2/ envoyer un petit don à Kludex pour le soutenir !

Sources : Ars Technica , OSTIF

J'sais pas si vous avez vu le film ou lu le livre mais Rocky, c'est l'araignée de roche extraterrestre de Projet Dernière Chance (Project Hail Mary) qui communique en chantant. Et Lahiru Maramba, un dev Firebase en poste chez Google, vient de le recréer en vrai avec un Raspberry Pi Zero 2W et un LLM local. Et voilà comme avoir un vrai pote Eridien posé sur votre bureau, qui vous répond en accords polyphoniques au lieu de parler.

L'architecture c'est ce que son concepteur appelle du "Voice Box & Brain". Le Pi Zero 2W tout seul est bien trop faiblard pour faire tourner un modèle de langage, du coup le Pi gère juste le hardware (micro, écran LCD, LED RGB, synthèse des accords) et balance l'audio brut à un Mac qui fait le gros du calcul. Le Mac transcrit ce que vous racontez avec mlx-whisper (un modèle Whisper-Tiny optimisé Apple Silicon), passe le texte à LM Studio qui fait tourner un Gemma 4 quantifié en local, et renvoie la réponse au Pi qui la joue en musique. Latence totale annoncée sur le repo, environ 2 secondes, soit, selon son propre benchmark, le même temps que via l'API Gemini dans le cloud, sauf que là, tout en local !

Le langage Eridien, lui, est fidèle au bouquin d'Andy Weir puisque chaque réponse est synthétisée en accords. Certains mots sont mappés sur des accords émotionnels précis, par exemple "amaze" sort en Mi majeur bien lumineux. Et pour les mots inconnus, ils sont hashés mathématiquement vers une signature de 3 fréquences, déterministe et permanente. Autrement dit, le même mot bizarre produira toujours exactement le même accord, comme un vrai vocabulaire qui se construit. C'est ce genre de petit détail qui fait la diff...

Côté matériel, il faut un Raspberry Pi Zero 2W et un PiSugar Whisplay HAT, un module tout-en-un qui apporte l'écran LCD, le bouton, la LED RGB et l'audio. De son côté, le repo propose 2 chemins d'install : la méthode "It Just Works" avec les drivers système précompilés (apt-get et c'est parti), ou la méthode isolée avec uv pour ceux qui veulent un environnement propre. Côté Mac, vous lancez LM Studio avec le modèle 4-bit quantifié sur le port 1234 et Y'a même un mode cloud avec une clé API Gemini si vous n'avez pas de Mac sous la main, ainsi qu'une fonctionnalité expérimentale planquée avec un générateur de sons façon R2-D2.

Pour la petite histoire, le film Projet Dernière Chance réalisé par Phil Lord et Christopher Miller est sorti en mars, avec Ryan Gosling en Ryland Grace et pour donner une voix à Rocky, les sound designers d'Hollywood ont tout simplement bossé avec un ocarina pour les aigus, une jarre pour les graves, et des chants de baleine, après avoir consulté Andy Weir sur l'anatomie du bestiau.

Je l'ai vu, et franchement, j'ai bien aimé. Je suis bien rentré dedans, même si j'aurais préféré que ce soit un peu plus "hard science" et un peu plus bidouille DIY comme l'était "Seul Sur Mars"... mais bon, il en faut pour tous les goûts.

Après si l'idée d'un compagnon IA DIY vous branche mais que vous voulez un truc plus généraliste et pas un Eridien qui chante, jetez un œil à Adeus , l'assistant IA personnel open source que j'avais couvert.

Quoiqu'il en soit, voici la vidéo complète où Lahiru montre tout le process, du câblage à Rocky qui prend vie :

Vous avez déjà passé des heures à éplucher des fichiers de logs de plusieurs millions de lignes pour trouver ce qui cloche ? Genre une pauvre erreur bizarre qui se produit une fois sur 100 000, noyée dans un océan de messages répétitifs et d'infos inutiles ? Moi, oui plein de fois !

Mais ça c'était avant de tomber sur Cordon !

Cordon est un outil en Python qui utilise des modèles de transformers et du scoring k-NN pour détecter les anomalies sémantiques dans vos logs. En gros, au lieu de chercher des mots-clés comme un bourrin avec grep, Cordon comprend le sens des messages et repère ce qui sort de l'ordinaire.

Les patterns répétitifs sont alors considérés comme du bruit de fond normal, même si ce sont des erreurs parce que si vous avez la même erreur FATALE qui se répète 10 000 fois, c'est probablement un problème connu. Et vous, ce que vous voulez trouver, c'est l'événement rare, celui qui se produit une seule fois et qui est sémantiquement différent du reste.

L'installation est simple comme bonjour. Un petit pip install cordon et c'est réglé. Pour l'utilisation de base, vous balancez juste votre fichier de logs en argument :

cordon system.log

Et hop, Cordon va analyser tout ça et vous sortir uniquement les trucs intéressants. Par défaut, il garde les 10% les plus "anormaux" sémantiquement. Vous pouvez ajuster ce pourcentage avec --anomaly-percentile 0.05 pour être plus sélectif (top 5%).

Sous le capot, ça utilise le modèle all-MiniLM-L6-v2 de sentence-transformers pour vectoriser les logs. Le fichier est découpé en fenêtres de N lignes (4 par défaut), chaque fenêtre est transformée en vecteur, puis un score de densité k-NN est calculé. Les fenêtres qui ont des vecteurs très différents du reste sont marquées comme anomalies.

Et si vous avez un GPU, Cordon peut l'utiliser automatiquement avec l'option --device cuda. D'après les benchmarks, ça donne un speedup de 5 à 15x sur le scoring pour les gros datasets. Sur des logs HDFS de 1 à 5 millions de lignes, l'outil arrive à réduire le volume de 98%. Autant dire que ça filtre sévère.

Y'a aussi un mode "range" qui est pratique pour explorer par tranches. Genre si vous voulez exclure le top 5% (trop bizarre, probablement du garbage) mais garder le top 5-15%, vous faites :

cordon --anomaly-range 0.05 0.15 app.log

Ça permet d'affiner l'investigation de manière itérative.

Pour les environnements conteneurisés, Cordon propose également une image Docker avec un backend llama.cpp au lieu de sentence-transformers. Pratique si vous voulez utiliser des modèles GGUF ou si vous êtes dans un contexte où les dépendances PyTorch posent problème.

L'outil peut aussi s'utiliser comme bibliothèque Python si vous voulez l'intégrer dans vos propres scripts :

analyzer = SemanticLogAnalyzer()
output = analyzer.analyze_file(Path("system.log"))

Vous vous souvenez quand je vous avais parlé de la formation gratuite de Microsoft sur GitHub Copilot ? Hé bien ils remettent le couvert, mais cette fois c’est pour nous apprendre la science du Machine Learning from scratch ! Et c’est pas un petit tuto de 2h fait à l’arrache comme sur ma chaine Youtube… Non, c’est un bon gros programme complet en 12 semaines avec 26 leçons et tout ça dans la langue Gims.

Le repo s’appelle ML-For-Beginners et le truc cool c’est que Microsoft a choisi de se concentrer sur le Machine Learning “classique” avec Scikit-learn et pas du deep learning de richou qui demande des GPU à 3000 balles. Du coup c’est accessible à n’importe qui avec un laptop normal !

Leur programme couvre à peu près tout ce qu’il faut savoir pour débuter : Régression, classification, clustering, traitement du langage naturel, séries temporelles, et même un peu d’apprentissage par renforcement. Chaque leçon démarre par un quiz pour voir où vous en êtes, suivi de contenu avec des explications pas à pas, des challenges à faire, et un autre quiz de fin pour vérifier que vous avez bien tout capté.

Y’a même des “sketchnotes” (c’est à dire des résumés visuels) et des vidéos si vous êtes plus du genre à apprendre en regardant qu’en lisant . Et pour ceux qui préfèrent R à Python, y’a des versions alternatives des exercices en R Markdown .

La version française du README est dispo sur le repo et tout est traduit dans plus de 50 langues, du chinois à l’arabe en passant par le croate… Microsoft a automatisé la traduction via GitHub Actions, donc soyez souple d’esprit si vous croisez quelques phôtes…

L’approche pédagogique de cette formation est basée sur des projets concrets du genre prédire le prix des citrouilles, classifier des cuisines du monde (forcement, la française arrivera en premier ^^), analyser de la musique pour du clustering…etc. Bref, c’est un peu original !

Voilà si vous êtes en vacances ou en reconversion IA, pour commencer, il suffit de forker le repo et de le cloner sur votre machine.

Voilà, si vous avez toujours voulu comprendre comment fonctionne le Machine Learning sans vous taper des formules de maths pendant 6 mois ou vendre un rein pour un abonnement à un cours en ligne, c’est le bon moment je pense !

Merci Microsoft !

L’accessibilité web c’est comme le tri sélectif… tout le monde dit que c’est génial mais azy, j’ai pas le temps. Et pourtant, c’est super important car près de 80% des pages web ont des problèmes de contraste de texte.

C’est le souci noumber ouane détecté sur le million de sites analysés chaque année par WebAIM . En gros, si vous avez un site, y’a de fortes chances que certains visiteurs galèrent à lire votre contenu, et je ne vous parle pas uniquement des personnes malvoyantes, hein… y’a aussi le daltonisme qui touche environ 8% des hommes et 0,5% des femmes. Rajoutez à ça les gens qui lisent leur téléphone en plein soleil, ceux qui ont une dalle de laptop toute pourrie, et vous comprendrez vite que le problème concerne pas mal de monde.

Alors est ce que vous connaissez les normes WCAG ?

Hé bien c’est le standard international pour l’accessibilité web. Ainsi pour être conforme au niveau AA (le minimum recommandé), votre texte doit avoir un ratio de contraste d’au moins 4,5:1 avec son arrière-plan. Pour le niveau AAA (l’idéal), c’est 7:1. Et là vous vous dites “super, je vais calculer ça à la main pour mes 47 couleurs de palette, mais va bien te faire cuire le cul, Korben”. (Oui, c’est comme ça que je vous imagine quand vous lisez mes articles).

Heureusement, y’a un outil qui vient de sortir et qui va vous changer la vie : CM-Colors . Vous lui donnez vos couleurs, et il les ajuste automatiquement pour qu’elles soient accessibles, le tout en modifiant les teintes le moins possible pour garder votre design intact.

L’installation est super fastoche…. C’est du Python donc un petit pip install cm-colors et hop c’est réglé. Ensuite, vous pouvez l’utiliser soit en ligne de commande directement sur vos fichiers CSS, soit via l’API dans votre code. Par exemple, vous avez un gris #5f7887 sur un fond #e6f0f5 qui passe pas les tests, hop, CM-Colors le transforme automatiquement en #5c6f7b et maintenant c’est conforme AA. Et la différence à l’œil nu est quasi invisible. Bref, c’est nickel pour l’accessibilité !

from cm_colors import ColorPair

# Your colors
pair = ColorPair("#999999", "#ffffff")

# Fix them and preview in the terminal
fixed_color, success = pair.make_readable(show=True)

print(f"Use {fixed_color} instead of #999999")
# Output: Use #8e8e8e instead of #999999

Le truc vraiment cool, c’est que l’outil gère plusieurs niveaux de lisibilité. Y’a “Readable” qui correspond au AA, “Very Readable” pour le AAA, et même une option large_text=True pour les gros titres qui ont des exigences moins strictes. Vous pouvez donc adapter selon vos besoins et pour les devs qui bossent sur de gros projets, y’a aussi une fonction make_readable_bulk qui permet de corriger plusieurs paires de couleurs d’un coup.

from cm_colors import make_readable_bulk

my_colors = [
 ("#777", "#fff"),
 ("#888", "#000"),
]

results = make_readable_bulk(my_colors)

for color, status in results:
 print(f"{color} is {status}")

Vous lui balancez une liste de tuples (texte, fond) et il vous retourne tout ça au propre. Et si vous voulez traiter directement vos fichiers CSS, la commande cm-colors styles.css génère un nouveau fichier styles_cm.css avec toutes les couleurs corrigées. L’outil peut même générer des rapports HTML pour visualiser les changements avant/après.

Alors oui, je sais, se taper de l’accessibilité c’est un peu relou car on a toujours l’impression que c’est du temps perdu sur des détails. Mais dites vous que ça impacte vraiment l’expérience de millions d’utilisateurs, donc ça vaut le coup d’y passer 5 minutes, surtout avec un outil automatisé !

Bref, CM-Colors c’est gratuit, c’est open source sous licence GPL-3, et ça peut vous éviter pas mal de galères. Toute la documentation est ici et y’a même une démo interactive sur leur site si vous voulez tester avant d’installer.

Si vous bidouiller un peu de machine learning et que vous avez la flemme de coder une interface web from scratch pour montrer vos jolis modèles, vous connaissez probablement Gradio , cette librairie Python qui permet de créer des démos interactives en quelques lignes de code.

Hé bien, excellente nouvelle, la version 6 vient de sortir et elle apporte pas mal de nouveautés intéressantes.

La grosse news de cette mise à jour , c’est d’abord la refonte complète de l’architecture avec le passage à Svelte 5 . Pour ceux qui s’en fichent du frontend, ça veut dire concrètement que vos apps seront plus légères et plus rapides à charger. L’équipe a aussi bossé sur l’optimisation des files d’attentes (quand y’a du monde sur votre démo), surtout pour les serveurs MCP (Model Context Protocol), donc si vous hébergez des trucs sur Hugging Face Spaces, vous devriez sentir la différence.

Côté fonctionnalités, y’a aussi quelques ajouts sympas comme le support natif des sous-titres pour les vidéos et l’audio, une nouvelle interface “MultimodalTextbox” améliorée pour le mobile (qui était franchement pas terrible avant), et pour ceux qui font des apps multipages, y’a maintenant un composant “Navbar” dédié à ça !

Le truc qui va plaire aux devs aussi, c’est qu’on peut désormais écrire des composants web personnalisés directement en HTML/JavaScript inline dans le code Python. Comme ça, plus besoin de sortir l’artillerie lourde avec des outils de build externes. Vous collez juste votre HTML, votre JS, et c’est parti mon kiki.

Par contre, attention si vous avez des projets existants… Y’a des changements qui vont casser des trucs. Par exemple, le format tuple dans le Chatbot a été supprimé, le composant Sketch est déprécié, et pas mal de paramètres ont bougé dans les composants graphiques natifs. L’équipe a quand même prévu un guide de migration avec des warnings de dépréciation pour vous aider à faire la transition.

A partir de maintenant, seule la branche 6.x sera maintenue, donc si vous êtes encore sur une vieille version, c’est le moment de migrer. La mise à jour se fait classiquement avec un

pip install --upgrade gradio

Notez que Gradio 6 nécessite Python 3.10 minimum et le support de Python 3.14 a été ajouté pour vous, les early adopters ^^.

Voilà, si vous faites du ML ou autre et que vous voulez montrer vos démos sans vous prendre la tête avec du React ou du Vue, Gradio reste une valeur sûre, et avec cette version 6 qui arrive, ce sera encore plus fluide et rapide !

Source

Vous naviguez sur le web en mode pépouze comme tous les jours… Et comme tous les jours, votre navigateur charge des scripts, des CSS, des cookies, des images, parfois des iframes. Et malheureusement, certains de ces trucs viennent de domaines qui n’existent plus. Vous ne vous en rendez pas compte et votre navigateur non plus. Mais Dead Domain Discovery DNS le sait, lui. Et il va vous le dire.

Dead Domain Discovery DNS , c’est un outil créé par Lauritz Holtmann , un chercheur en sécurité allemand et c’est un DNS forwarder UDP super léger codé en Python qui écoute sur le port 53 de votre ordinateur et note tous les domaines qui ne répondent plus. Ce n’est donc pas un scanner actif mais plutôt un observateur passif qui regarde passer les requêtes DNS et repère les morts.

Vous configurez Dead Domain Discovery comme votre serveur DNS primaire comme ça, toutes vos requêtes DNS passent par lui. Il forward ensuite ça vers un resolver upstream, genre Google DNS ou Cloudflare. Si un domaine ne résout pas, il réessaye sur un resolver secondaire mais si le secondaire échoue aussi, il marque alors le domaine comme “potentiellement mort” puis toutes les 15 secondes, il vous envoie un message contenant les nouveaux domaines HS découverts.

Les notifications partent sur Telegram, par email, ou via un webhook selon ce que vous voulez. Rassurez-vous, y’aura pas de fausse alerte à répétition puisqu’un domaine notifié une fois ne l’est plus pendant un certain temps.

L’intérêt pour les chercheurs en sécurité, c’est que les domaines morts sont une surface d’attaque intéressante. Un domaine expire, quelqu’un d’autre le réenregistre mais comme les enregistrements DNS qui pointaient vers l’ancien propriétaire existent toujours, ça ouvre des portes pour mettre en place des sous-domaines, des CNAME, charger des scripts externes autorisés…etc car tout continue de pointer vers le domaine mort. Ça permet de contrôler une partie du trafic autorisé.

Cette attaque est connue et s’appelle le subdomain takeover ou domain hijacking. Par exemple en 2024, l’attaque Sitting Ducks a mis plus d’un million de domaines à risque , exploitée par des cybercriminels russes. Et début 2025, des domaines expirés ont permis de contrôler plus de 4000 backdoors sur des systèmes gouvernementaux, académiques et privés. La campagne SubdoMailing a même utilisé plus de 8000 domaines légitimes pour envoyer des emails de phishing, en exploitant leur réputation pour contourner les filtres anti-spam. Donc autant vous dire que c’est un vrai problème…

Dead Domain Discovery vous aide donc à trouver ces domaines avant qu’un attaquant ne le fasse. Ensuite, si le domaine est réenregistrable, vous avez 2 options. Soit vous le réenregistrez vous-même pour sécuriser votre infrastructure, soit vous signalez le problème au propriétaire du site qui référence ce domaine HS.

L’infra recommandée par Lauritz pour faire tourner Dead Domain Discovery est un Raspberry Pi configuré comme DNS primaire de votre réseau. Faible conso, c’est toujours allumé, et ça permet de tout surveiller en continu. Mais vous pouvez aussi le déployer sur un VPS si vous voulez monitorer un réseau distant.

Notez que les notifications Telegram nécessitent un bot API token et un chat ID. L’email passe par du SMTP classique et les webhooks acceptent des headers personnalisés, ce qui est pratique si vous voulez intégrer ça dans votre système de monitoring existant.

L’outil dispose aussi d’une extension Chrome qui fais la même chose et scanne les pages web pour iframes, scripts et autres styles externes, puis vérifie si leurs domaines résolvent. Même auteur, même principe, mais côté navigateur. L’extension utilise l’API Google DNS pour vérifier les domaines et ne communique aucune donnée à son auteur. Vous scannez, vous voyez les morts au combat, et ensuite, vous pouvez agir.

Bref, vous l’aurez compris, Dead Domain Discovery ne vous protègera pas directement mais vous dira juste quels cadavres traînent dans votre réseau.

À vous ensuite de les enterrer comme il se doit.

Vous connaissez l’Article 175 du Code Pénal japonais ?

Non ? Hé bien croyez le ou non, mais c’est une loi de 1907 qui interdit les représentations explicites d’appareils reproducteurs. Les japonais sont des anges, ils n’ont ni zézette, ni pépette ^^. Du coup, tous les films adultes japonais sont pixelisés depuis plus d’un siècle. 118 ans que ça pixelise à tout va mais LADA vient de sortir et va changer cela ! En fait c’est une IA open source qui retire la pixelisation sur les vidéos.

Mais avant, revenons un peu sur cette loi bizarre. L’Article 175 date de la période Meiji, et il classe comme obscènes les représentations explicites d’organes génitaux. Cette définition légale de l’obscénité, c’est donc du contenu qui excite sexuellement, offense la pudeur, et viole les concepts moraux. Et les sanctions sont assez élevées : 2 ans de prison et 2,5 millions de yens d’amende. Du coup, tous les studios auto-censurent leurs productions à base de pixelisation, floutage, barres de censure et j’en passe. Leur traditionnelle mosaïque, n’est donc pas une coutume, mais un moyen de contourner cette loi centenaire.

C’est pour cela qu’ un dev anonyme a sorti LADA , un outil Python open source qui retire la pixelisation des vidéos. Vous prenez une vidéo JAV censurée (Japanese Adult Video), vous la passez dans LADA, et l’IA détecte alors les zones pixelisées et les restaure. Et tout cela en temps réel si vous avez un bon GPU ou via un export si vous êtes plus patient.

Techniquement, LADA utilise deux types de modèles IA . Le premier pour la détection et le second pour la restauration. Plusieurs déclinaisons des modèles sont dispo si vous voulez plus de précision ou de qualité… Et pour les faire tourner, vous avez besoin d’un GPU Nvidia CUDA, idéalement une RTX 20xx ou plus récent, avec 4 à 6GB de VRAM pour du 1080p. Et pour les fans de 4K, comptez 6 à 8GB de RAM.

Après au niveau des résultats, c’est assez aléatoire. Parfois ce sera bien, parfois ce ne sera pas foufou(ne).

Et sinon comme ça s’installe ? Et bien ce sera via Flatpak pour Linux via Flathub , Docker en CLI si vous aimez les conteneurs, ou en décompressant l’archive .7z standalone sur Windows.

Y’a une interface CLI pour les puristes, une GUI pour les autres puis vous chargez votre vidéo, vous choisissez vos modèles de détection et restauration, vous lancez, et ça traite. Vous pouvez regarder ensuite le résultat (en temps réel si votre GPU suit).

Maintenant, concernant la légalité de la dé-censure, j’imagine que c’est OK si c’est pour une utilisation personnelle hors du Japon. Par contre, si vous êtes au japon, interdiction d’utiliser ce truc évidemment !

Merci à ce coquin de Lorenper pour la découverte 🙏

Ce serait cool si on pouvait réunir les Avengers des LLMs pour les faire bosser ensemble sur de la recherche de faille de sécurité ? OpenAI, Anthropic, X.AI et Meta ensemble contre les forces du mal, c’est maintenant possible avec Deep Eye , un super scanner de vulnérabilités qui transforme les quatre IA rivales en équipe de pentesteurs. Vous allez voir, c’est assez génial !

Deep Eye, c’est donc un outil Python open source qui scanne les sites web et les API pour trouver des vulnérabilités. SQL injection, XSS, command injection, SSRF, path traversal, authentication bypass, au total y’a plus de 45 méthodes d’attaque automatisées. Vous lui indiquez une URL, et il teste tout en switchant entre les services d’IA selon le contexte.

Dans le contexte d’un pentest légitime, Deep Eye a même trouvé comment parler aux IA pour qu’elles acceptent de pondre du code un peu sensible. Et ça tombe bien car chaque IA a ses forces et ses faiblesses. GPT-4 par exemple excelle sur les payloads créatifs et les contournements de filtres. Claude lui est plus méthodique, et capable de mieux analyser le contexte et de génèrer des attaques adaptées au framework détecté. LLAMA en local quand à lui est rapide et ne coûte rien en appels API. Et Grok ? Bah il a le mérite d’être dispo même s’il est loin d’être le meilleur.

Deep Eye en tout cas est capable des les utiliser toutes selon la situation. Pour l’installer, ça se passe en 3 commandes :

Vous installez ça comme ceci :

git clone https://github.com/zakirkun/deep-eye.git
cd deep-eye

cd scripts
./install.ps1

chmod +x scripts/install.sh
cd scripts
./install.sh

python deep_eye.py -u https://example.com

Vous avez déjà passé plus de temps à configurer Sphinx qu’à coder votre projet Python ? Bienvenue au club !

Et oui, paradoxalement, parfois documenter son code devient plus compliqué que d’écrire le code… Vous voulez juste afficher vos docstrings joliment, mais avant ça il faut vous taper 200 pages de doc, choisir parmi 47 thèmes, configurer des dizaines d’extensions et comprendre la syntaxe reStructuredText. Breeeef, la flemme !

Heureusement, il existe une alternative qui va vous réconcilier avec la documentation : pdoc.

pdoc, c’est un outil de documentation Python qui ne nécessite pas de documentation. Vous tapez simple pdoc votre_module et c’est tout. Pas de fichier de config interminable, pas de choix existentiels entre différents builders, pas de migration depuis votre version de Sphinx de 2018 qui refuse de compiler.

Ça génère directement une belle doc à partir de votre code existant !!

Si vous avez déjà écrit des docstrings propres et utilisé les type annotations de Python, vous avez déjà fait 100% du boulot car pdoc se contente de prendre ce qui existe et de l’afficher élégamment. Pas de traduction, pas de réécriture, pas de fichiers .rst à maintenir en parallèle de votre code.

Votre code EST la documentation et ça c’est beau !

L’outil comprend les docstrings au format numpydoc et Google-style, fait des liens automatiques entre les identifiants, respecte votre variable __all__ et génère du HTML standalone que vous pouvez héberger n’importe où. Il y a même un serveur web intégré avec live reload pour développer votre doc en temps réel.

Pour mettre ça en place, faut installer pdoc avec

pip install pdoc

Puis vous lancez

pdoc ./votre_projet.py

ou

pdoc nom_de_votre_module

Et c’est tout !

Bien sûr si vous bossez sur un gros projet avec des besoins spécifiques, des guides utilisateurs complexes, des dizaines de pages de tutoriels et une doc multilingue, Sphinx reste le roi, mais pour la grande majorité des projets Python, ceux qui ont juste besoin d’une doc API claire et lisible, pdoc fait ça comme un chef, sans que vous ayez besoin d’un doctorat en outil de documentation.

Bref, si vous en avez marre de passer plus de temps sur votre documentation que sur votre code, pdoc mérite le détour car documenter son code devrait être aussi simple que de le coder, non ?

Pour tester pdoc, direction pdoc.dev ou directement le repo GitHub .

Pour en avoir testé quelques uns, je trouve que les lecteurs de livres audio, c’est jamais très pratique à utiliser. Heureusement, je viens de découvrir Lue , un lecteur d’e󠄳󠅕󠄐󠅤󠅕󠅨󠅤󠅕󠄐󠅕󠅣󠅤󠄐󠅣󠅟󠅥󠅣󠄐󠅓󠅟󠅠󠅩󠅢󠅙󠅗󠅘󠅤󠄐󠅔󠅕󠄐󠄻󠅟󠅢󠅒󠅕󠅞󠄞󠅙󠅞󠅖󠅟books qui lit vos livres à voix haute directement dans le terminal.

Bah oui, moi j’adore mon terminal.. Pas besoin de cliquer, pas d’interface laggy, pas de pub ni d’abonnement premium… On lance juste une commande et hop, la lecture du livre se lance. C’est ça que j’aime, quand la tech me fout la paix et fonctionne bien !

Le truc cool avec Lue, c’est que l’outil utilise Edge TTS de Microsoft par défaut. Oui, Microsoft qui fait un truc bien et gratuit, c’est foufou, mais en gros, ça permet de récupérer les voix ultra réalistes utilisées dans Edge sans payer un centime et sans même avoir Windows. Après si vous êtes un parano de la vie privée, vous pouvez aussi utiliser Kokoro TTS qui tournera à 100% en local sur votre machine.

Pour installer Lue, il vous faut d’abord FFmpeg, espeak et Antiword. Sous Mac c’est donc brew install ffmpeg espeak antiword``, et sous Linux sudo apt install ffmpeg espeak antiword, et sous Windows… bah vous allez sur le site de FFmpeg, espeak et antiword et vous galérez un peu comme d’hab.

Et après, c’est tout simple :

pip install git+https://github.com/superstarryeyes/lue.git

lue votre-livre.epub

lue --voice "fr-CH-ArianeNeural" livre.epub

Y’a pas une semaine qui passe sans que je code un petit peu de Python, alors quand je suis tombé sur ce documentaire que Cult.Repo vient de sortir , je me suis dit que c’était l’occasion d’en apprendre un peu plus sur ce langage qui fait tourner l’IA chez Google, Meta et OpenAI, et qui (je viens de l’apprendre) a commencé comme un projet de vacances. Guido van Rossum son créateur cherchait juste un truc pour s’occuper pendant les vacances de Noël en 1989. Son bureau était fermé, il s’ennuyait, alors il a pondu les bases d’un nouveau langage en deux semaines. Pour le fun.

Le documentaire montre vraiment bien comment ce petit projet perso est devenu un monstre. Au départ, van Rossum bossait au CWI à Amsterdam sur un langage appelé ABC, sauf qu’ABC avait plein de défauts et surtout, impossible de l’étendre. Python, c’était donc sa revanche… prendre le meilleur d’ABC (comme l’indentation pour structurer le code) et virer tout ce qui l’énervait.

Le nom Python, d’ailleurs, ça n’a rien à voir avec le serpent. Van Rossum était fan des Monty Python. Il cherchait un nom court, mystérieux, et il lisait les scripts de la série à ce moment-là. Voilà donc comment le langage le plus utilisé au monde a hérité du nom d’une troupe de comiques britanniques.

Vous saviez qu’Animal Crossing sur GameCube cache 21 jeux NES complets dans ses fichiers ? Perso, j’en avais AUCUNE IDÉE et visiblement, ce ne sont pas des versions au rabais ou de démos, mais bien des jeux complets ! Animal Crossing était vraiment un jeu en avance sur son temps et l’une des fonctionnalités les plus adorées des joueurs, c’était ces petits meubles NES que vous pouviez collectionner et qui lançaient de vrais jeux quand vous interagissiez avec.

Balloon Fight, Super Mario Bros, The Legend of Zelda, Punch-Out !!… Nintendo avait carrément inclus un émulateur NES complet et les ROMs sur le disque GameCube. Le truc fou, c’est que cet émulateur est souvent cité comme étant plus précis que celui de la NES Classic ou même celui de la Switch.

Selon les versions du jeu (Doubutsu no Mori, Animal Crossing, etc.), il ya entre 19 et 21 jeux disponibles. La version américaine par exemple en contient 19, et certains jeux comme Donkey Kong Jr. Math valent aujourd’hui 151 dollars en seconde main. D’autres comme Clu Clu Land D ou Gomoku Narabe Renju étaient également des exclusivités Famicom Disk System introuvables plus tard sur Nintendo Switch Online.

Mais bon, passons au vif du sujet. Comment extraire ces ROMs ?

Et bien le passionné Seth Larson a développé une méthode géniale qui exploite la compression Yaz0 utilisée par Nintendo. Cette compression, reconnaissable par son header “Yaz0” en ASCII, est utilisée partout dans les jeux Nintendo depuis les années 2000. The Wind Waker, Mario Kart Wii, Super Mario Sunshine… tous utilisent Yaz0 pour compresser leurs assets.

D’abord, il vous faut une copie de votre ISO Animal Crossing que vous pouvez extraire légalement avec CleanRip sur votre Wii ou avec le nouvel outil FlippyDrive qui permet de sauvegarder vos jeux GameCube directement depuis la console. Une fois que vous avez votre ISO, le script Python de Seth fera tout le boulot.

Comme je vous le disais, le script parcourt toute l’ISO à la recherche des headers “Yaz0”, décompresse chaque blob trouvé, puis cherche les signatures des ROMs NES (qui commencent par “NES\x1a”) ou Famicom Disk System (avec leur signature spécifique). Une fois trouvées, les ROMs sont extraites et comparées à une base de données de checksums MD5 pour identifier exactement quel jeu c’est.

Voici le script complet disponible en Gist sur GitHub.

Pour l’utiliser, c’est ultra simple :

python animal-crossing-nes-roms.py ./AnimalCrossing.iso

Et hop, vous vous retrouvez avec tous les jeux NES dans votre dossier. Ces ROMs fonctionnent avec n’importe quel émulateur NES, par exemple sur PC, vous pouvez utiliser Pinky (un émulateur WASM qui tourne dans le navigateur), sur mobile je vous recommande Delta qui est aussi excellent.

Un petit détail technique sympa au passage, le jeu Clu Clu Land D est stocké au format .qd (QuickDisk). Il faudra donc le convertir en .fds pour l’utiliser avec un émulateur. Un script Python existe également sur le GitHub pour faire cette conversion facilement.

Ce qui est vraiment dingue dans cette histoire, c’est qu’après deux ans et demi de travail, la communauté a presque complètement décompilé cette version d’Animal Crossing. Ça ouvre la porte à des mods incroyables et ils ont même réussi à faire tourner Linux dans l’émulateur NES d’Animal Crossing en patchant la mémoire. Bon, ça tourne à 1/64ème de la vitesse normale, mais techniquement ça marche !

D’ailleurs, l’émulateur NES générique du jeu peut lire n’importe quelle ROM depuis la carte mémoire si elle est formatée correctement. Il cherche des fichiers avec la string “GAFE01” (le nom interne d’Animal Crossing) et le préfixe “DobutsunomoriPF”. Et un outil appelé ACNESCreator permet ensuite de créer ces fichiers .gci automatiquement pour charger vos propres ROMs.

Si vous cherchez d’autres méthodes légales pour récupérer des ROMs, consultez le RED Project sur GitHub, qui contient une documentation complète de méthodes d’extraction similaires depuis des collections officielles et autres mini-consoles. Parce que oui, extraire des ROMs de jeux que vous possédez légalement, c’est parfaitement légal pour un usage personnel.

Je trouve quand même que jouer à Wario’s Woods extrait de votre propre copie d’Animal Crossing sur votre iPhone avec Delta, ça a quand même quelque chose de magique. Maintenant, si vous avez une vieille copie d’Animal Crossing qui traîne, vous savez maintenant qu’elle vaut bien plus que ce que vous pensez !

Si ça vous intéresse, l’article original de Seth Larson contient encore plus de détails techniques !

Vous en avez assez d’attendre des heures pour installer vos dépendances Python ? Et la nuit, dans vos draps humides, vous rêvez d’un outil qui rendrait ce processus ultra-rapide et indolore ?

Ne cherchez plus, uv est là pour vous !

Écrit en Rust par les mêmes qui ont fait Ruff, uv est un installateur Python et un résolveur de dépendances d’une rapidité époustouflante. Conçu comme une alternative à pip et pip-tools, il offre des performances jusqu’à 100 fois supérieures et il est aussi facile à utiliser que pip. Vous pouvez l’installer en un clin d’œil avec curl, pip, pipx ou même Homebrew. Une fois en place, créez votre environnement virtuel avec uv venv, activez-le, et vous voilà prêt à installer des packages en un temps record grâce à des commandes intuitives comme

uv pip install flask

uv gère également la génération de fichiers de dépendances verrouillés, pour garantir la reproductibilité de votre environnement sur n’importe quelle plateforme.

Avec

uv pip compile

vous pouvez générer un fichier requirements.txt à partir de diverses sources : requirements.in, pyproject.toml, setup.py ou même l’entrée standard. Et pour synchroniser votre environnement avec ce fichier, rien de plus simple :

uv pip sync requirements.txt

Mais ce n’est pas tout. uv regorge de fonctionnalités avancées pour répondre à tous vos besoins. Vous pouvez définir des overrides de versions de dépendances, choisir entre différentes stratégies de résolution, gérer les dépendances Git avec une authentification simplifiée, et même installer dans des environnements Python arbitraires grâce à l’option --python.

Côté performances, le secret d’uv réside dans son utilisation intelligente du cache. Les dépendances déjà téléchargées sont stockées de manière optimisée, et uv se base sur des informations comme les en-têtes de cache HTTP ou les hachages Git pour déterminer si une dépendance doit être retéléchargée. Vous pouvez contrôler finement le comportement du cache avec des options comme --refresh ou --no-cache.

Autre avantage indéniable d’uv : sa gestion avancée de l’authentification. Que ce soit pour les dépôts Git privés ou les registres de packages, uv vous permet de vous authentifier de multiples façons : SSH, HTTPS avec nom d’utilisateur et mot de passe ou token, fichier netrc, et même le keyring de votre système !

C’est également un outil multi-plateforme qui fonctionne de manière optimale sur macOS, Linux et Windows, avec un support de premier ordre pour les architectures x86_64. Et si vous utilisez une plateforme plus exotique, il y a de grandes chances qu’uv soit également disponible grâce à une compatibilité étendue.

C’est vraiment à tester si vous faites du python.

A découvrir ici : https://github.com/astral-sh/uv

Vous en aviez marre des analyseurs de code Python plus lents qu’un escargot sous Xanax ? Et bien dites bonjour à pylyzer, la nouvelle star de l’analyse statique ! 🚀

Ce p’tit truc est écrit en Rust, ce qui lui permet d’être en moyenne 100 fois plus rapide que ses concurrents comme pytype ou pyright. En plus de la vitesse, pylyzer se distingue par son analyse ultra détaillée. On parle pas juste de type checking basique là, pylyzer est capable de détecter les accès hors limites à des listes ou les accès à des clés inexistantes dans des dictionnaires.

D’ailleurs, contrairement à ce qu’on pourrait penser, pylyzer n’est pas qu’un simple type checker. C’est un véritable couteau suisse de l’analyse statique ! Il fait aussi office de linter pour vous aider à garder un code propre et consistant.

Bon après, faut pas se leurrer, pylyzer a ses limites. Déjà, il suppose que votre code est potentiellement statiquement typé, donc oubliez les exec, setattr et compagnie. Ah et le typage de l’API standard de Python n’est pas complet donc vous risquez de voir des erreurs du genre « cette API n’existe pas », soyez prévenus ! Enfin, vu que le type checking de pylyzer est conservatif dans son approche, vous risquez de voir pas mal de faux positifs. Si ça vous saoule, désactivez les diagnostics, on ne vous en voudra pas (mais je vous le déconseille quand même) ! 😅

En parlant d’accès, vous n’aurez aucun mal à accéder aux rapports d’erreur de pylyzer car contrairement à certains, ils sont clairs comme de l’eau de roche ! Fini le charabia illisible, on vous montre exactement où se situe l’erreur et on vous explique le problème sans prise de tête. Et côté fonctionnalités, pylyzer ne fait pas les choses à moitié. Le support LSP est hyper riche, de la complétion au renommage en passant par plein d’autres features bien cool. Tout ça grâce à l’adaptation du serveur de langage de Erg. Et si vous voulez en profiter directement dans VSCode, pas de souci ! L’extension est dispo sur le Marketplace et hop, c’est réglé ! 😎

Maintenant vous allez me dire « OK c’est bien beau tout ça, mais pylyzer il sert à quoi comparé à Ruff par exemple ?« . Alors oui, Ruff est aussi un outil d’analyse statique pour Python écrit en Rust, mais lui se concentre uniquement sur le linting tandis que pylyzer fait du type checking et sert de serveur de langage. En gros, on ne mélange pas les torchons et les serviettes !

Si vous voulez savoir comment ça marche dans le détail, sachez que pylyzer utilise le type checker de Erg en interne, en plus de ses propres capacités de vérification de type. Il convertit l’AST Python en AST Erg avant de le passer au type checker, puis il adapte les résultats pour Python. Malin ! 😏 Par contre, Erg n’est pas un langage transpilé en Python comme on pourrait le croire, il peut tourner directement sur la machine cible.

Malgré ces petits défauts, pylyzer gère quand même un paquet de trucs : type checking sur les variables, opérateurs, fonctions, méthodes et classes, inférence de type, résolution des modules et packages, les types des collections (list, dict, tuple), une bonne partie de typing, les types génériques et variance, les type guards, le type narrowing (qui peut se faire avec is et isinstance mais pas que), les assertions de type (via typing.cast par exemple)… Bref, ça en fait des belles jambes dis donc ! 🦿

Alors vous attendez quoi pour tester ce petit bijou ?

Si vous faites un peu de code Python, vous connaissez peut-être Ruff, un outil de contrôle pour la qualité de code pour Python >= 3.7 qu’on appelle aussi un linter.

Je l’utilise depuis le début de l’année dans mon Visual Studio Code et il est capable de faire le même job que tout un tas d’autres outils, comme Flake8, isort et même Black. Du coup, vous pouvez remplacer tous ces outils par Ruff, ça fait toujours ça en moins.

Une des fonctionnalités que je préfère dans Ruff, c’est l’autofix. En gros, quand il trouve une erreur dans votre code, il peut la corriger tout seul, comme un grand. Et quand il ne peut pas, il vous mets des explications super claires pour que vous puissiez comprendre ce qui se passe.

Puis faut dire que c’est hyper rapide aussi. Normal, les dev ont utilisé Rust, un langage de programmation connu pour ça afin qu’il analyse votre code en un temps record. On parle de 10 à 100 fois plus rapide que les autres linters du marché. Autant vous dire que ça dépote !

L’outil check plus de 500 règles différentes pour s’assurer que votre code il est au top et vous pouvez le configurer comme vous voulez, activer ou désactiver des règles, changer des paramètres… etc. Bref il s’adapte au plus près de votre façon de coder.

Y’a pas à hésiter et pour l’installer, c’est simple. Il suffit d’allez sur le site de Ruff ou sur la marketplace de Visual Studio Code pour le télécharger ou tout simplement avec cette commande pour ceux qui aiment la ligne de commande :

pip install ruff

Votre code vous dira merci et vous, c’est sûr, vous allez adorer !

Un interpréteur Python 3 flambant neuf, entièrement réécrit en Rust, ça claque, non ? Pour ceux qui hibernent, Rust, c’est le langage de programmation qui monte, qui monte et qui cartonne notamment grâce à sa rapidité légendaire et son bon niveau de sécurité.

Et en fusionnant avec Python, on obtient le meilleur des deux mondes, puisque ça permet d’utiliser Python comme un langage de script dans vos applications Rust. Vous pourrez ainsi, grâce à RustPython, profiter de la simplicité et de l’expressivité de Python, tout en bénéficiant des performances et de la robustesse de Rust.

RustPython peut aussi être compilé en WebAssembly, ce qui permet d’avoir du Python directement dans votre navigateur, sans installer quoi que ce soit et ainsi, votre code s’exécutera à la vitesse de la lumière. Évidemment ce projet est open-source et libre comme l’air et pour l’utiliser, c’est simple comme bonjour.

Tout d’abord, assurez-vous d’avoir installé Rust sur votre machine. Si ce n’est pas le cas, filez sur rustup.rs dare-dare ! Ensuite, clonez le dépôt GitHub de RustPython :

git clone https://github.com/RustPython/RustPython

Placez-vous dans le répertoire RustPython fraîchement cloné, puis lancez la démo :

cd RustPython
cargo run --release demo_closures.py

Et voilà, vous venez d’exécuter du code Python à la vitesse du son grâce à RustPython ! Notez que cet outil dispose également d’un compilateur JIT expérimental qui compile les fonctions python en code rust natif.

Si vous avez envie d’en savoir plus, rendez-vous sur https://rustpython.github.io.

Source

Imaginez télécharger un modèle d’IA apparemment inoffensif sur une plateforme de confiance comme Hugging Face et découvrir qu’il ouvre en fait une porte dérobée permettant à des attaquants de prendre le contrôle de votre système ! C’est le risque que pose la faille critique CVE-2024-34359, découverte récemment dans le célèbre package Python llama-cpp-python.

Ce package très utilisé permet d’intégrer facilement des modèles d’IA écrits en C++ dans des projets Python. Pour cela, il utilise la bibliothèque de templates Jinja2 qui est capable de faire un rendu dynamique du HTML à partir des données. Une lib surpuissante mais potentiellement risquée si c’est mal configuré !

Et c’est justement là que le bât blesse. Le package llama-cpp-python utilise Jinja2 pour traiter les métadonnées des modèles au format .gguf, mais sans activer les protections nécessaires comme le bac à sable. Du coup, en injectant un template malicieux dans les métadonnées d’un modèle, un pirate peut exécuter du code arbitraire sur le système hôte !

Les dégâts potentiels sont énormes : vol de données, prise de contrôle totale, interruption de services… Surtout que les systèmes IA manipulent souvent des données ultra sensibles. Et vu la popularité de llama-cpp-python, l’impact est massif : plus de 6000 modèles vulnérables rien que sur Hugging Face ! Selon un article détaillé de Checkmarx, cette faille permet des attaques de la chaîne d’approvisionnement, où un acteur malveillant peut injecter du code dans un modèle téléchargé et redistribuer ce modèle compromis pour attaquer les développeurs d’IA.

Découverte par Patrick Peng (alias retro0reg), cette vulnérabilité repose comme je vous l’expliquait sur une mauvaise implémentation du moteur de templates. Cette faille de score CVSS critique de 9.7, permet l’injection de template côté serveur, conduisant à une exécution de code à distance (RCE). Un proof-of-concept a même été publié sur Hugging Face, démontrant comment un modèle compromis peut exécuter du code arbitraire lorsqu’il est chargé ou lors d’une session de chat.

Cela met en lumière un problème plus large : la sécurité des systèmes d’IA est intimement liée à celle de leur chaîne logicielle. Une vulnérabilité dans une dépendance tierce peut compromettre tout un système. Il faut donc redoubler de vigilance à tous les niveaux. Les modèles d’IA étant souvent utilisés au sein de projets critiques et manipulant des volumes importants de données sensibles, la moindre faille peut avoir des conséquences catastrophiques.

Mais rassurez-vous, une solution existe ! La version 0.2.72 de llama-cpp-python corrige le tir en ajoutant une validation des entrées et un bac à sable robuste autour de Jinja2. Si vous utilisez une version antérieure, la mise à jour est plus que recommandée.

Comment savoir si vos modèles sont touchés ? Regardez s’ils utilisent :

• Le package llama-cpp-python en version < 0.2.72
• Le format de fichier .gguf
• Des templates Jinja2 dans les métadonnées

Si c’est le cas, passez immédiatement à la 0.2.72 ! Vous pouvez aussi auditer le code de vos modèles et regarder les permissions avec vos yeux de lynx.

Bref, comme d’hab, une petite faille peut vite tourner au désastre

Source

Les livres électroniques ont vraiment modifié mon rapport à la lecture… Je peux emporter toute une bibliothèque dans ma poche, acheter des livres directement depuis le kindle, prendre des notes, lire dans le noir…etc. Mais est ce que vous saviez qu’il est également possible d’optimiser encore plus votre expérience de lecture numérique grâce à la bionification ? Oui terme chelou mais je crois que c’est comme ça qu’on dit.

Je vous en ai déjà parlé y’a quelques années mais cette technique nouvelle, inspirée de recherches en sciences cognitives, consiste à mettre en gras les premières lettres des mots pour faciliter leur reconnaissance visuelle et accélérer la vitesse de lecture. Des études ont ainsi montré que notre cerveau ne lit pas lettre par lettre mais plutôt mot par mot, en se basant sur sa forme globale. Ainsi, en accentuant le début des mots, la bionification guide l’œil pour une lecture plus fluide et efficace.

Évidemment, bionifier manuellement chaque livre de votre bibliothèque serait un travail titanesque. C’est là qu’intervient Zippy, un outil en ligne de commande développé en Python qui automatise le processus pour les ebooks au format ePub. Avec juste quelques lignes de code, vous pouvez transformer n’importe quel livre en version bionique, prête à être transférée sur votre liseuse Kindle ou autre.

Pour en profiter, la première étape est de cloner le dépôt de Zippy sur GitHub :

git clone https://github.com/nimish-ks/zippy.git cd zippy

Pour éviter tout conflit intergalactique entre les dépendances Python, on va ensuite créer un environnement virtuel et y installer les bibliothèques requises via pip :

python -m venv venv source venv/bin/activate # Sous Windows, utilisez plutôt `venv\Scripts\activate` pip install -r requirements.txt

Voilà, votre laboratoire secret est fin prêt pour lancer la bionification à grande échelle ! La formule magique est la suivante :

python zippy.py <fichier_entrée> <fichier_sortie> [--algorithm <algorithme>]

Remplacez <fichier_entrée> par le chemin vers le livre ePub original et <fichier_sortie> par le nom du fichier bionifié à générer. Par exemple :

python zippy.py "Hypérion.epub" "Hypérion_Bionique.epub"

Et hop, quelques nanosecondes plus tard, vous obtenez une version dopée aux hormones de croissance de votre bouquin préféré de science-fiction ! L’algorithme de bionification par défaut, noté "- 0 1 1 2 0.4", détermine le nombre de lettres à mettre en gras en fonction de la longueur des mots et d’autres critères. Mais tel un savant fou, vous pouvez concocter votre propre formule en passant le paramètre --algorithm.

Maintenant que vous maîtrisez le pouvoir de la bionification, vous allez pouvoir dévorer « Hypérion » et tous les autres tomes du cycle d’Endymion à une vitesse supraluminique ! Fini les voyages interstellaires qui durent des plombes, les bouquins bioniques vous téléporteront en un éclair dans des univers extraordinaires.

Comme Zippy s’intègre dans votre flux de travail, vous pouvez adapter les ebooks à vos préférences avant de les transférer sur votre liseuse. Vos yeux vous diront merci !

Évidemment, en bon cyberrebelle, vous pouvez bionifier tous les ebooks qui vous passent sous la main, même ceux protégés par des DRM abusifs. Un petit coup de Calibre et de DeDRM pour les libérer, et hop, à vous la lecture augmentée !

En bidouillant un peu le code de Zippy, vous pourriez même imaginer plein d’autres optimisations à appliquer à vos bouquins voire en faire un plugin pour Calibre. Si c’est le cas, dites le moi, ça m’intéresse.

A vous de jouer !

Source

Aujourd’hui on va parler d’un outil de ouf pour trouver des buckets S3 ouverts : FestIn !

C’est le genre d’outil dont raffolent les chercheurs en sécurité puisqu’il qui explore tous les recoins du web pour dénicher des trucs que vous n’auriez jamais trouvé.

FestIn c’est la grosse artillerie de l’énumération de buckets S3 puisqu’il a tellement d’options que les autres outils à côté c’est de la gnognotte. Attention, c’est bien sûr à utiliser uniquement sur vos propres noms de domaines ou dans le cadre de missions d’audit pour lesquelles vous avez toutes les autorisations.

Avec lui, vous allez pouvoir :

• Utiliser différentes techniques pour trouver des buckets : crawling du DNS et des pages web, analyse des réponses S3
• Faire vos requêtes en passant par un proxy, no stress 🕶
• Vous passer des credentials AWS, puisque ça marche avec n’importe quel provider compatible S3
• Configurer vos propres serveurs DNS, parce que vous êtes trop beau gosse.
• Profiter d’un crawler HTTP de compétition qui va retourner le web pour vous
• Faire des recherches récursives et avoir du feedback entre les différents modules pour un max d’efficacité
• Faire tourner le schmilblick en mode « watch » pour choper les nouveaux domaines en temps réel, ce qui est assez ouf quand on y pense.
• Sauvegarder tous les domaines découverts dans un fichier, pour faire joujou avec plus tard
• Indexer direct le contenu des objets des buckets pour faire des recherches full text de la mort, mieux que Google ! 😎
• Cibler votre recherche sur des domaines spécifiques si vous voulez pas vous éparpiller

Pour l’installer c’est fastoche, au choix :

pip install festin

Ou en mode Docker :

docker run --rm -it cr0hn/festin -h

C’est du brut, du bourrin, puisqu’on va envoyer des requêtes en masse et gratter un max d’infos. Attention cependant, on reste fair-play, on ne veut pas faire planter le serveur non plus.

Par défaut, FestIn prend un unique domaine en argument :

festin mon-super-site.com

Mais on peut aussi lui filer un fichier texte contenant une liste de domaines, histoire d’être plus productif :

1. Crée un fichier domaines.txt avec tes domaines, un par ligne.
2. Lance la commande :

cat domaines.txt | festin -f -

FestIn balance plusieurs tests en même temps pour aller plus vite. Par défaut, il en lance 5. Si vous êtes pressé et que votre machine encaisse, vous pouvez augmenter ce nombre avec l’option -c :

festin -c 10 mon-super-site.com

Attention cependant, ne balancez pas un truc de fou, ça risque de faire bugger le site ciblé. On est là pour glaner des infos, pas pour casser du serveur.

L’outil dispose également d’un petit bot intégré qui va scanner le site à la recherche de liens pouvant mener à des buckets S3. On peut le configurer avec plusieurs options :

• Timeout (-T ou –http-timeout) : Si le site est lent, on augmente le timeout pour pas que le scan plante. Par défaut, c’est 5 secondes.
• Récursion max (-H ou –http-max-recursion) : On limite la profondeur du scan pour éviter de partir en vadrouille sur tout le net. Par défaut, c’est 3 niveaux, genre site.com -> lien -> site2.com -> lien -> site3.com.
• Limite de domaine (-dr ou –domain-regex) : On peut dire au robot de se focaliser uniquement sur les sous-domaines qui correspondent à une expression régulière.
• Liste noire (-B) : Fich un fichier texte contenant des mots clés. Si un domaine contient un de ces mots, on l’ignore.
• Liste blanche (-W) : Même principe, mais à l’envers. On scanne uniquement les domaines contenant des mots clés de la liste blanche.

Pour cela, vous devez créer un fichier blacklist.txt contenant « cdn » et « photos » (on ignore les liens vers des CDN et des images) puis lancer la commande :

festin -T 20 -M 8 -B blacklist.txt -dr .mondomaine\.com mon-super-site.com

Attention : l’option -dr attend une expression régulière valide au format POSIX. Par exemple, mondomaine.com est invalide, alors que \.mondomaine\.com est correct.

FestIn crache un paquet d’infos intéressantes, pas seulement sur les buckets S3, mais aussi sur d’autres éléments identifiés. Ces infos peuvent ensuite être utilisées avec d’autres outils comme nmap.

Pour récupérer les résultats, FestIn propose trois modes qu’on peut combiner :

• Fichier de résultats FestIn (-rr ou –result-file) : Ce fichier contient une ligne JSON par bucket trouvé, avec le nom de domaine d’origine, le nom du bucket et la liste des objets qu’il contient.
• Fichier de domaines découverts filtrés (-rd ou –discovered-domains) : Celui-là liste un domaine par ligne. Ce sont des domaines trouvés par le crawler, le DNS ou les tests S3, mais qui ont été filtrés selon les options définies.
• Fichier brut de tous les domaines découverts (-ra ou –raw-discovered-domains) : Comme son nom l’indique, c’est la liste brute de tous les domaines identifiés par FestIn, sans aucun filtre. Idéal pour du post-traitement et de l’analyse.

récupérer les résultats dans trois fichiers distincts et enchaîner avec nmap :

festin -rr festin.results -rd domaines_filtres.txt -ra domaines_bruts.txt mon-super-site.com

festin -rd domaines_filtres.txt && nmap -Pn -A -iL domaines_filtres.txt -oN nmap-resultats.txt

FestIn peut utiliser Tor pour plus de discrétion. Il faut juste avoir un proxy Tor lancé en local sur le port 9050 (configuration par défaut). Activez-le avec l’option --tor :

tor & festin --tor mon-super-site.com

Et il peut aussi effectuer des recherches DNS. Voici les options dispo :

• Désactiver la découverte DNS (-dn ou –no-dnsdiscover) : Si on a pas besoin de ce type de recherche.
• Serveur DNS personnalisé (-ds ou –dns-resolver) : Pratique si on veut utiliser un serveur DNS différent de celui par défaut.

Comme ceci :

festin -ds 8.8.8.8 mon-super-site.com

Ce script ne se contente pas de dénicher les buckets S3 ouverts, il peut aussi télécharger leur contenu et l’indexer dans un moteur de recherche plein texte. Ça permet ensuite de lancer des recherches directement sur le contenu des buckets ! Pour activer l’indexation, FestIn utilise Redis Search, un projet Open Source.

Il faut deux options :

• Activer l’indexation (–index) : Indispensable pour que le contenu soit stocké dans le moteur de recherche.
• Configuration du serveur Redis Search (–index-server) : Uniquement si votre serveur Redis Search est sur une IP/port différent de localhost:6379 par défaut.

Lancez d’abord Redis Search en tâche de fond :

docker run --rm -p 6700:6379 redislabs/redisearch:latest -d

Puis lancez FestIn avec l’indexation et le serveur distant :

festin --index --index-server redis://127.0.0.1:6700 mon-super-site.com

Attention : l’option --index-server doit obligatoirement commencer par le préfixe redis://.

Bien sûr, on a pas forcément envie de relancer FestIn à chaque nouveau domaine à analyser. C’est pour ça qu’il existe le mode surveillance. FestIn se lance et attend l’ajout de nouveaux domaines dans un fichier qu’il surveille. Pratique pour l’utiliser avec d’autres outils comme dnsrecon.

Lancez FestIn en mode surveillance avec le fichier domaines.txt :

festin --watch -f domaines.txt

Dans un autre terminal, ajoutez des domaines à domaines.txt :

echo "encore-un-autre-site.com" >> domaines.txt

Dès qu’un nouveau domaine est ajouté au fichier, FestIn le scanne automatiquement à la recherche de buckets S3 ouverts. Pour aller plus loin, on peut combiner FestIn avec un outil de reconnaissance DNS comme DnsRecon. L’idée est de récupérer des sous-domaines potentiels liés au domaine principal et de les balancer ensuite à FestIn pour scanner d’éventuels buckets S3 cachés.

Etape 1 : Scruter le domaine cible avec DnsRecon

On va utiliser DnsRecon pour trouver des sous-domaines associés à cible.com. Sauvegardez la sortie dans un fichier CSV :

dnsrecon -d cible.com -t crt -c cible.com.csv

Etape 2 : Préparer le fichier pour FestIn

On isole les sous-domaines du fichier CSV pour les injecter dans FestIn (un domaine par ligne) :

tail -n +2 cible.com.csv | sort -u | cut -d "," -f 2 >> cible.com.domaines

Etape 3 : Lancer FestIn et récupérer les résultats

On balance le fichier de sous-domaines à FestIn en activant la recherche Tor, la concurrence à 5, un serveur DNS personnalisé et en sauvegardant les résultats dans des fichiers distincts :

festin -f cible.com.domaines -

Et pour automatiser tout ça sur plein de domaines à la chaîne, on a même un petit script loop.sh bien pratique dans les examples du repo GitHub.

Voilà les amis, vous avez toutes les clés pour utiliser FestIn comme un pro et aller secouer les buckets S3 qui traînent ! C’est quand même un outil hyper complet et puissant, pensez à l’utiliser avec un proxy ou Tor pour pas vous faire bloquer, et amusez vous bien mais toujours de manière éthique et responsable hein !

Si vous codez avec vos gros doigts boudinés toute la journée, notamment en Python, il se peut que comme 99% des codeurs, vous ne vous encombriez pas avec le formatage de votre code. Pas le temps, et l’IDE fait le minimum syndical donc ça vaaaaa.

C’est pourquoi aujourd’hui, je vous propose d’aller plus loin grâce à Black, un outil qui automatise la mise en forme de votre code Python pour qu’il soit cohérent, lisible et conforme aux normes établies notamment de PEP 8.

Pour l’installer :

pip install git+https://github.com/psf/black

Il nettoie vos merdes, mets des retours à la ligne dans vos tableaux, les fonctions, les définitions…etc., vous permet de gérer la longueur de vos lignes de code, enlève les retours à la ligne ou les points-virgules en trop, ou encore remplace les single quotes (‘) par des double quotes (« )… Et il y a encore plein d’autres petites améliorations dont vous pourrez consulter la liste ici.

black script.py

Un mode expérimental est également dispo, ce qui vous permettra de voir comment votre code sera formaté dans les prochaines versions.

black --preview script.py

Parmi les prochaines améliorations notables, on peut citer la gestion améliorée des chaînes multilignes dans les appels de fonction, où Black est désormais plus « intelligent » pour éviter d’introduire des sauts de ligne supplémentaires. En effet, avec cette nouvelle fonctionnalité, Black examine le contexte autour de la chaîne multiligne pour décider si elle doit être en ligne ou divisée en plusieurs lignes. Par exemple, lorsqu’une chaîne multiligne est passée à une fonction, Black ne divise la chaîne multiligne que si une ligne est trop longue ou si plusieurs arguments sont passés.

Il est également intéressant de noter les améliorations apportées à la gestion des parenthèses dans les dictionnaires. Désormais, pour dictionnaires avec de longues valeurs, elles sont enveloppées de parenthèses, et les parenthèses inutiles sont supprimées.

Black s’utilise donc en ligne de commande, peut aussi tourner dans un Docker et peut surtout être intégré dans vos process CI/CD pour « corriger » et formater automatiquement tout ce que vous récupérez dans les push sur le Git. Notez qu’une mesure de sécurité ralentit un peu le traitement, puisque Black vérifiera que le code reformaté produit toujours un AST (Abstract Syntax Tree) valide qui est effectivement équivalent à l’original. Si vous vous sentez en mode grosse confiance, vous pouvez utiliser le paramètre --fast pour aller encore plus vite.

Bref, c’est un excellent formateur de code qui s’intègre aussi bien dans Vim que dans Visual Studio Code ou utilisable en ligne de commande à l’ancienne comme on aime.

À découvrir ici.

Merci à Lorenper

Bonne nouvelle, Ollama vient tout juste d’annoncer un truc qui devrait vous faire plaisir : le support des cartes graphiques AMD en preview ! Cela signifie que toutes les fonctionnalités d’Ollama peuvent maintenant être accélérées par les cartes graphiques AMD, que ce soit sur Linux ou Windows.

Mais au fait, c’est quoi Ollama ? Pour les deux du fond qui suivent pas, je vous refais un topo vite fait. Ollama, c’est un outil hyper pratique qui permet de faire tourner des grands modèles de langage open-source directement sur votre machine locale. Genre Mistral, Llama 2 et toute la clique.

Alors, quelles sont les cartes AMD compatibles ?

Pas de panique, je vous ai préparé une petite liste bien détaillée. Dans la famille des Radeon RX, on retrouve les monstres comme les 7900 XTX, 7900 XT, 7800 XT, 6900 XT et compagnie. Pour les pros, la gamme Radeon PRO est aussi de la partie avec les W7900, W6800X Duo, Vega II… Bref, y a du beau monde au rendez-vous. Et si vous êtes un fan des cartes Instinct, pas de jaloux, les MI300X, MI250, MI100 et autres sont aussi supportées.

Ollama promet également que d’autres modèles de cartes graphiques suivront. Alors on croise les doigts et on surveille les annonces comme le lait sur le feu. En attendant, si vous voulez vous lancer dans l’aventure Ollama avec votre carte AMD, c’est simple comme bonjour.

Téléchargez Ollama pour Linux ou Windows, installez le bouzin et hop, vous voilà parés pour faire chauffer votre GPU AMD ! C’est pas beau la vie ? Je vous ai même fait un tutoriel ici !

Allez, je vous laisse, j’ai un rendez-vous urgent avec mon Llama2 uncensored qui me fait de l’œil.

Source

A tous les fondus d’analyse de code, aujourd’hui, j’aimerais vous présenter De4Py, un déobfuscateur Python avancé qui s’est donné pour mission de révolutionner le domaine pour les analystes de malwares et les experts en reverse engineering.

Développé par le duo Fadi002 et AdvDebug, cet outil se distingue non seulement par son interface conviviale, mais aussi par un ensemble de fonctionnalités avancées conçues pour, entre autres, déchiffrer les fichiers Python.

Ce toolkit prend en charge toute une gamme d’obfuscateurs populaires, incluant Jawbreaker, BlankOBF, PlusOBF, Wodx, Hyperion et l’obfuscateur de pyobfuscate.com. Cette polyvalence vous assure de pouvoir décoder un large éventail de fichiers obfusqués avec une grande facilité.

L’une des fonctionnalités phares de l’outil est sa capacité d’exécution de code. Cela permet aux utilisateurs d’exécuter du code Python au sein de l’outil. Par exemple, ils expliquent sur le Github, que grâce à ça, si un programme demande une licence pour fonctionner dans son intégralité, De4py permet d’accéder directement aux fonctionnalités principales de l’outil, et par conséquent de contourner les restrictions liées à la licence.

La fonction de Dump de chaînes de caractères est un autre atout crucial. Elle facilite l’extraction de textes du processus Python et les sauvegarde dans un fichier, rendant plus aisée l’extraction de données de la mémoire, y compris des informations sensibles comme les webhooks. Il est capable également d’identifier les chaines de caractères « interessantes » comme les IP, les sites web et les mots-clés liés à des informations sensibles.

De4py aborde également le défi que représentent ces programmes Python qui tentent de s’auto-terminer lorsqu’ils détectent un débogueur ou une machine virtuelle. En supprimant la fonction de sortie, il vous permettra de ne plus galérer avec des sorties de programme surprises. De4py dispose aussi d’une fonctionnalité qui permet de récupérer et d’accéder à toutes les fonctions se trouvant dans le processus, ce qui est pratique si on veut modifier certaines fonctions en mémoire de manière plus précise.

Il y a également un analyseur de fichiers pour détecter si un programme Python est « packé ». Il tente alors d’extraire les programmes qui s’y trouvent en utilisant pyinstaller. Enfin, De4Py est capable de surveiller le comportement du programme sur votre système à savoir tout ce qui est manipulations de fichiers, activités de processus, interactions avec la mémoire, et même les communications via socket, avec détail de la taille des données transmises / reçues et des adresses IP. Cette fonctionnalité permet également l’extraction du contenu des sockets et le déchiffrement du contenu chiffré OpenSSL directement dans un fichier.

Bref, que ce soit via son interface graphique ou en mode terminal, De4Py est un super outil pour tous les amateurs de reverse engineering qui font notamment de l’analyse de malware.

Vous en saurez plus ici sur leur Github et le site officiel est ici.

J’aime bien faire un peu de Python de temps en temps et il m’arrive parfois de vouloir jouer un son dans mes scripts pour signaler qu’un traitement est fini ou tout simplement mettre un peu de fun. Jusqu’à présent j’utilisais des libs comme Pygame, Playsound ou encore Pydub mais ces trucs-là ne sont pas forcément bien supportés par tous les OS, ou nécessitent des dépendances comme FFMpeg.

Toutefois, une lib baptisée Nava vient de faire son apparition et c’est la simplicité même. Elle fonctionne sur tous les OS (Linux, macOS, Windows), et n’utilise aucune dépendance ou logiciel tiers. Vous pouvez lui faire lire du WAV et du MP3 et la lecture se lance immédiatement.

Pour l’installer, rien de plus simple :

pip install nava

Et ensuite, il suffit de l’appeler dans votre code et de lui indiquer le morceau à jouer.

from nava import play
play("son.mp3")

Vous pouvez même lancer une lecture en asynchrone pour ne pas bloquer votre script. Dans l’exemple ci-dessous, on lance un time sleep qui peut donc couper la lecture du son au bout de 4 secondes et qui comme vous le voyez, n’est pas bloqué puisque nava est lancé en mode asynchrone avec le paramètre async_mode=True :

import time
from nava import play, stop
sound_id = play("son.wav", async_mode=True)
time.sleep(4)
stop(sound_id)

Voilà, j’espère que ça vous sera utile 🙂

Si vous codez en Python autour d’API de LLM comme celle d’OpenAI, d’Anthropic ou encore de Huggingface…etc., je vous présente LiteLLM qui risque de vous faire gagner pas mal de temps.

Il s’agit d’une lib Python capable d’interagir avec tout un tas d’API en utilisant le format de celle d’OpenAI. Elle fournit une interface simple et uniformisée pour appeler ces modèles , ce qui va vous faciliter leur utilisation pour des choses comme de la génération de texte, de la traduction ou encore du chat…

Pour l’installer, rien de plus simple :

pip install litellm

Ensuite, y’a plus qu’à créer un objet LiteLLM dans votre code, en lui fournissant l’ID et le nom du modèle à utiliser. Par exemple pour vous connecter à OpenAI, le code sera le suivant :

from litellm import completion
import os

## set ENV variables
os.environ["OPENAI_API_KEY"] = "your-api-key"

response = completion(
  model="gpt-3.5-turbo", 
  messages=[{ "content": "Hello, how are you?","role": "user"}]
)

Pour Claude 2, ça sera ça :

from litellm import completion
import os

## set ENV variables
os.environ["ANTHROPIC_API_KEY"] = "your-api-key"

response = completion(
  model="claude-2", 
  messages=[{ "content": "Hello, how are you?","role": "user"}]
)

Pour utiliser Ollama, ça donnerait également ça :

from litellm import completion

response = completion(
            model="ollama/llama2", 
            messages = [{ "content": "Hello, how are you?","role": "user"}], 
            api_base="http://localhost:11434"
)

Donc pas grand-chose qui change.

Vous l’aurez donc compris, LiteLLM permet de pondre un seul et unique code, mais pour discuter avec tous les fournisseurs d’IA du moment (et les logiciels libres existants)

Y’a la possibilité d’avoir du stream sur les réponses (c’est à dire, le texte qui s’affiche au fur et à mesure), de la gestion des exceptions, du log, sans oublier du calcul de coût et l’usage que vous pouvez avoir de ces API afin de ne pas éclater votre compte en banque.

LiteLLM intègre également un proxy OpenAI pour rediriger vos requêtes vers le modèle de votre choix. Pour l’installer :

pip install 'litellm[proxy]'

Lancez ensuite le proxy avec le modèle de votre choix :

litellm --model huggingface/bigcode/starcoder

Et lui passer vos requêtes dans le code python directement :

import openai # openai v1.0.0+
client = openai.OpenAI(api_key="anything",base_url="http://0.0.0.0:8000") # set proxy to base_url
# request sent to model set on litellm proxy, `litellm --model`
response = client.chat.completions.create(model="gpt-3.5-turbo", messages = [
    {
        "role": "user",
        "content": "this is a test request, write a short poem"
    }
])

print(response)

Si LiteLLM vous intéresse, vous trouverez toutes les infos sur la page Github ainsi que les endpoints ici.