Chez Apple, les développeurs peuvent proposer leurs applications en version bêta avant de les mettre sur l’AppStore. Pour y accéder, outre avoir TestFlight sur son périphérique et un code d’invitation, il faut surtout que la limite de bêta-testeurs ne soit pas atteinte.

Si jamais on arrive trop tard, EloneMusk (… ouais… je sais…) a créé Test-Flight-Subscription pour être alerté par email de l’ouverture d’accès à des bêtas.

L’email et le mot de passe à renseigner dans la configuration ne sont PAS ceux de votre compte Apple mais bien ceux d’un compte GMAIL (hardcodé avec Gmail dans app.py).
Il faudra utiliser un compte Gmail avec un mot de passe d’application (chercher app password dans les paramètres Gmail), accessible une fois le 2FA activé sur le dit compte si ce n’est pas encore fait.

services:
  testflight-checker:
    build:
      context: https://github.com/EloneMusk/Test-Flight-Subscription.git
      dockerfile: Dockerfile
    container_name: testflight-checker
    restart: always
    ports:
      - 7654:8000
    environment:
      EMAIL_USER: moi@gmail.com
      EMAIL_PASSWORD: ent iur henf ued

Pratique.
Pour découvrir des applications en bêta, on peut par exemple parcourir le SubReddit dédié ou le dépôt GitHub Awesome Testflight App List.

Il a trouvé sa place dans tout mon petit bordel ^^

Et… j’y ajoute mon workflow de mise à jour automatique si le dépôt GitHub évoluait, ce qui donne :

services:
  testflight-checker:
    build:
      context: https://github.com/EloneMusk/Test-Flight-Subscription.git
      dockerfile: Dockerfile
    container_name: testflight-checker
    restart: always
    ports:
      - 7654:8000
    environment:
    environment:
      EMAIL_USER: moi@gmail.com
      EMAIL_PASSWORD: ent iur henf ued
  testflight-autoupdate:
    image: alpine:latest
    container_name: testflight-autoupdate
    restart: always
    environment:
      GITHUB_REPO: https://github.com/EloneMusk/Test-Flight-Subscription.git
      DISCORD_WEBHOOK: https://canary.discord.com/api/webhooks/xxx/xxx
      POLL_INTERVAL: 172800 # secondes
      SERVICE_NAME: testflight-checker
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - /tmp:/repo
    command: >
      sh -c "
        apk add --no-cache git bash curl docker-cli jq &&
        mkdir -p /repo &&
        cd /repo &&
        git clone --depth 1 \$GITHUB_REPO . || true &&
        REPO_NAME=\$(basename -s .git \$GITHUB_REPO) &&
        DEFAULT_BRANCH=\$(curl -s https://api.github.com/repos/\$(echo \$GITHUB_REPO | sed 's|.*/||;s|.git||') | jq -r .default_branch) &&
        git fetch origin \$DEFAULT_BRANCH &&
        git checkout \$DEFAULT_BRANCH &&
        LAST_COMMIT=\$(git rev-parse HEAD) &&
        while true; do
          git fetch origin \$DEFAULT_BRANCH &&
          NEW_COMMIT=\$(git rev-parse origin/\$DEFAULT_BRANCH) &&
          if [ \"\$NEW_COMMIT\" != \"\$LAST_COMMIT\" ]; then
            echo \"[$(date)] Nouveau commit détecté sur \$DEFAULT_BRANCH, rebuild...\"
            git reset --hard origin/\$DEFAULT_BRANCH &&
            docker compose -f /repo/docker-compose.yml build \$SERVICE_NAME &&
            docker compose -f /repo/docker-compose.yml up -d \$SERVICE_NAME &&
            REPO_LINK=\$GITHUB_REPO &&
            COMMIT_LINK=\"\$GITHUB_REPO/commit/\$NEW_COMMIT\" &&
            curl -H 'Content-Type: application/json' -X POST -d '{\"content\": \"\$REPO_NAME mis à jour automatiquement !\nBranche : \$DEFAULT_BRANCH\nCommit : \$NEW_COMMIT\nDépôt : <\$REPO_LINK|\$REPO_NAME>\nLien du commit : <\$COMMIT_LINK|voir commit>\"}' \$DISCORD_WEBHOOK &&
            LAST_COMMIT=\$NEW_COMMIT
          else
            echo \"[$(date)] Aucun changement sur \$DEFAULT_BRANCH.\"
          fi
          sleep \$POLL_INTERVAL
        done
      "
networks: {}

Pendant une semaine, c'est à dire du 23 au 30 octobre 2025, le jeu Fear the Spotlight est offert sur l'Epic Games Store.

The post Le jeu Fear the Spotlight est gratuit sur l’Epic Games Store pendant une semaine first appeared on Bhmag.

Il aura fallu beaucoup trop de temps pour que ça se produise, et je l’aurai travaillé au corps une paire de fois le gaillard, mais voilà, ceci est le premier billet invité de l’unique, l’irremplaçable Pierre-Marie ! Parce que c’était à la fois trop con comme cible de jeu, mais surtout trop rigolo vu le mix de technos abordées, parce qu’on va parler de Pokemon, de Sunshine/Moonlight (le titre ne ment pas), de wakeonlan, de Kubernetes, de Fission. Oui, tout ça en même temps. Vous comprenez mon enthousiasme ?

La puissance des algorithmes de ciblage

Au détour de mon scrolling sur X, je suis tombé sur un post parlant de jeux vidéos (l’algorithme est bien foutu) et sur une injonction à s’inscrire sur PokeMMO.
Pas fan hardcore de Pokémon, j’ai quand même bien poncé les deux premières gen et me suis tenté à la troisième.
Je fais partie des gens qui n’attendent plus grand chose de Game Freak qui, selon moi, ressort en boucle les mêmes jeux sans vraiment d’innovation.
Au contraire, côté développement non officiel, on retrouve des jeux dérivés comme Pokémon Showdown, qui malgré que ce ne soit pas mon style de jeu, attire une grande communauté et qui aurait pu donner des idées à Nintendo pour renouveler la licence.
J’ai, par exemple, plus apprécié le rom hack Pokémon Adventures Red Chapter basé sur l’excellent manga Pokémon La Grande Aventure que le remake Let’s Go Evoli.
Bref, je suis donc allé voir ce qu’était ce PokeMMO, et me suis motivé pour me lancer dessus. Ça tombe bien, je pars 2 semaines en vacances et il faudra bien occuper mes soirées au coin de la clim. (article commencé au mois de Juillet). PokeMMO propose un installer pour Windows, Linux, iOS, Android et même un package pour OS alternatif (j’ai vu pas mal de gens qui installaient ça sur une console portable de type Retroid).
Personnellement, j’ai à ma disposition une PsVita et une Switch, toutes deux libérées et qui me servent lors de mes sessions retrogaming. L’option téléphone/tablette est pour moi rédhibitoire ne possédant pas de manette compatible et aimant beaucoup trop les boutons physiques pour jouer au tactile.
Installer Android sur Switch me semblant trop fastidieux, j’ai décidé de partir sur une autre voie. Étant obligé d’être connecté pour jouer quoi qu’il arrive (le O de MMO, hein), je me penche sur Moonlight, que j’avais déjà testé il y presque 10 ans. Il y a des clients pour Switch et PsVita (et pour beaucoup d’autres OS/appareils) donc ça pourrait correspondre à mes besoins.

Installation de Sunshine/Moonlight

Moonlight, pour vulgariser, c’est un client non-officiel pour le protocole Nvidia Gamestream qui vient se connecter à un ordinateur distant pour le contrôler à distance. Il a la force de supporter les contrôleurs locaux et de transmettre au PC distant à la manière d’un Steam Link. Pour pouvoir streamer vers un client Moonlight, il faut un serveur sur la machine cible. Le logiciel Nvidia GeForce Experience permet cela mais la « nouveauté » par rapport à mon essai d’il y a 10 ans, c’est le serveur Sunshine qui permet de s’affranchir du logiciel de Nvidia.

L’installation de Sunshine se fait via l’installateur dédié à la distribution cible en quelques secondes. Une fois installé, Sushine se configure via une interface web accessible en local. Elle permet de gérer les différents clients (appairage, suppression…), les différentes applications et les options de streaming (encodage, bitrate…).

Le première étape est de créer un couple utilisateur/motdepasse pour protéger l’accès à cette interface.

Par défaut, Sunshine propose deux applications: Bureau et Steam Big Picture (même si Steam n’est pas installé sur le système)

J’installe donc PokeMMO et le configure comme Application dans Sunshine. Je reprends simplement les valeurs trouvées dans le raccourci Bureau qui a été crée lors de l’installation. Il détecte même la miniature automatiquement.

J’installe le client Moonlight sur les deux appareils. Le client détecte automatiquement le PC supportant Sunshine et affiche un code d’appairage à entrer dans Sunshine.

L’appairage se déroule sans problème et je peux tester le stream en local.

Je lance l’application Bureau et ça me permet de confirmer qu’il est bien possible d’ouvrir une session Windows à distance.

Pour le stream distant, il faut juste s’assurer que Upnp est activé sur le routeur et cocher une case dans la configuration de Sunshine.

(ndr: sinon il faut définir les ports et ouvrir manuellement/créer les redirections de port; l’IP fixe pour le PC de jeu est fortement recommandée dans ce cas)

Fini ?

On aurait pu s’arrêter là, mais bon, je suis pas fan de laisser tourner le PC H24 pendant 2 semaines juste pour l’utiliser quelques heures. Moonlight propose une fonctionnalité bien pratique de Wake On LAN pour démarrer un ordinateur à distance, mais voilà, ça ne fonctionne qu’en réseau local (en même temps c’est dans le nom).
Il faut donc trouver le moyen de le faire fonctionner à distance. J’ai plusieurs dispositifs à ma disposition.
Mon routeur PfSense permet de d’envoyer des paquets WoL mais uniquement via l’interface, pas d’API disponible. Il faudrait se connecter à l’interface via VPN pour lancer la commande. C’est trop lourd et pas assez flexible.
Solution suivante, utiliser le cluster k3s qui tourne à la maison.

Utilisation de k3s

On teste la faisabilité du process en lançant un pod temporaire contenant la commande wakeonlan mais ça ne fonctionne pas car l’appareil ciblé n’est pas sur le LAN du cluster k3s comme l’est le pod.
En cherchant un peu, on trouve qu’il faut configurer le pod pour qu’il tourne dans le réseau hôte, le réseau des nœuds.

kubectl run tmp --rm -it --image nixery.dev/shell/wakeonlan -it --overrides='{"kind":"Pod", "apiVersion":"v1", "spec": {"hostNetwork":\ntrue}}' -- wakeonlan a1:b2:c3:d4:e5:f6

Et ça marche !!

Reste à trouver le moyen de lancer ça simplement, via un appel HTTP par exemple. Je viens justement de déployer un système de micro-services : Fission.
Fission permet de déployer des fonctions de micro-services à la manière d’un système Serverless comme Lambda. Ça me permettrait de recevoir une requête HTTP avec en paramètre l’adresse MAC cible et d’envoyer la requête WoL avec un simple code python.

Installation de Fission

L’installation de Fission est simple si on passe par leur chart Helm. On a juste à surcharger quelques valeurs grâce au fichier values.yml suivant.

## Fission chart configuration
##

## routerServiceType to consider while creating Fission Router service.
## For minikube, set this to NodePort, elsewhere use LoadBalancer or ClusterIP.
##
routerServiceType: ClusterIP

## defaultNamespace represents the namespace in which Fission custom resources will be created by the Fission user.
## This is different from the release namespace.
## Please consider setting `additionalFissionNamespaces` if you want more than one namespace to be used for Fission custom resources.
##
defaultNamespace: fission

# Add Fission helm repo
helm repo add fission-charts https://fission.github.io/fission-charts
# Install CRDs 
kubectl create -k "github.com/fission/fission/crds/v1?ref=v1.21.0"
# Install Fission
helm install fission fission-charts/fission-all -f values.yml -n fission --create-namespace
# Install Fission CLI binary
curl -Lo fission https://github.com/fission/fission/releases/download/v1.21.0/fission-v1.21.0-linux-amd64 && chmod +x fission && sudo mv fission /usr/local/bin/

Configuration de Fission

La documentation fission nous apprend qu’on peut modifier les spécifications des pods. Il y a même un tutoriel pour déployer un exemple.

# On créé un dossier dédié
mkdir wol-fn
cd wol-fn
# On initialise le dossier specs
fission spec init
# On créé l'environnement qui fera touner le code python
fission -n fission env create --spec --name python-wol --image ghcr.io/fission/python-env --builder ghcr.io/fission/python-builder
# On créé le dossier de la fonction
mkdir wol
# On créé un fichier requirements.txt avec le module python dont nous avons besoin
echo "wakeonlan" > wol/requirements.txt
# On créé le fichier contenant le code python à exécuter
touch wol/wol.py

from flask import request
from wakeonlan import send_magic_packet
import re

def main():
    mac = request.args.get('mac')
    if mac is None:
        return "Please send a MAC address"
    else:
        if re.match("[0-9a-f]{2}([-:]?)[0-9a-f]{2}(\\1[0-9a-f]{2}){4}$", mac.lower()):
            send_magic_packet(mac)
            return "Sending magic packet to 255.255.255.255 with broadcast 255.255.255.255 MAC %s port 9" % (mac)
        else:
            return "%s is not a valid MAC format" % (mac)

On créé la spécification pour la fonction qui décrit quel code doit être exécuté et le trigger HTTP qui détermine quelle URL déclenche son exécution.

# On créé la spécification pour la fonction
fission -n fission function create --spec --name wol-fn --env python-wol --src "wol/*" --entrypoint wol.main
# On créé la spécification pour la route.
# Avec les annotations permettant de créer l'ingress rule sur Traefik
fission -n fission route create --spec --name wol-fn-get --method GET --url /wake --function wol-fn --createingress --ingressrule "test.domain.tld=/wake" --ingressannotation "kubernetes.io/ingress.class=traefik" --ingressannotation "traefik.ingress.kubernetes.io/router.entrypoints=websecure" --ingressannotation 'traefik.ingress.kubernetes.io/router.tls="true"' --ingressannotation "traefik.ingress.kubernetes.io/router.tls.certresolver=letsencrypt"

On a maintenant un dossier contenant la fonction et son environnement standard.

wol-fn
├── specs
│   ├── README
│   ├── env-python-wol.yaml
│   ├── fission-deployment-config.yaml
│   ├── function-wol-fn.yaml
│   └── route-wol-fn-get.yaml
└── wol
    ├── requirements.txt
    └── wol.py

On va modifier le fichier env-python-wol.yaml pour ajouter notre configuration spécifique.

---
apiVersion: fission.io/v1
kind: Environment
metadata:
  creationTimestamp: null
  name: python-wol
spec:
  builder:
    command: build
    container:
      name: builder
      resources: {}
    image: ghcr.io/fission/python-builder
    podspec:
      containers:
      - name: builder
        resources: {}
  imagepullsecret: ""
  keeparchive: false
  poolsize: 3
  resources: {}
  runtime:
    container:
      name: python-wol
      resources: {}
    image: ghcr.io/fission/python-env
    podspec:
      containers:
      - name: python-wol
        resources: {}
+     hostNetwork: true
+     dnsPolicy: ClusterFirstWithHostNet
  version: 3

La directive hostNetwork permet comme vu plus haut de faire tourner le pod sur le réseau hôte.
Avec juste cette modification, on a une erreur à l’exécution du code parce que le pod n’arrive pas à aller chercher l’archive contenant le code de la fonction sur le stockage partagé de Fission.

{
    "level": "error",
    "ts": "2025-08-22T15:55:03.884Z",
    "logger": "generic_pool_manager.generic_pool.fetcher_client",
    "caller": "client/client.go:114",
    "msg": "error specializing/fetching/uploading package, retrying",
    "error": "Internal error - error fetching deploy package: failed to download url : Get \"http://storagesvc.fission/v1/archive?id=%2Ffission%2Ffission-functions%2Ffc6798a9-95c3-47cb-8797-28f842162f83\": dial tcp: lookup storagesvc.fission on 9.9.9.9:53: no such host",
    "url": "http://X.X.X.X:8000/specialize",
    "stacktrace": "github.com/fission/fission/pkg/fetcher/client.sendRequest\n\tpkg/fetcher/client/client.go:114\ngithub.com/fission/fission/pkg/fetcher/client.(*client).Specialize\n\tpkg/fetcher/client/client.go:56\ngithub.com/fission/fission/pkg/executor/executortype/poolmgr.(*GenericPool).specializePod\n\tpkg/executor/executortype/poolmgr/gp.go:467\ngithub.com/fission/fission/pkg/executor/executortype/poolmgr.(*GenericPool).getFuncSvc\n\tpkg/executor/executortype/poolmgr/gp.go:553\ngithub.com/fission/fission/pkg/executor/executortype/poolmgr.(*GenericPoolManager).GetFuncSvc\n\tpkg/executor/executortype/poolmgr/gpm.go:242\ngithub.com/fission/fission/pkg/executor.(*Executor).createServiceForFunction\n\tpkg/executor/executor.go:239\ngithub.com/fission/fission/pkg/executor.(*Executor).serveCreateFuncServices.func1\n\tpkg/executor/executor.go:143"
}

On voit qu’il cherche à contacter storagesvc.fission et qu’il n’arrive pas à résoudre ce hostname, ce qui est normal étant donné qu’il s’agit d’un nom interne au cluster et que le pod tourne désormais sur le hostNetwork. La directive dnsPolicy: ClusterFirstWithHostNet permet de forcer d’essayer la résolution en interne au cluster avant de tenter en externe sur le hostNetwork et résout ce problème.

Il ne reste qu’à déployer.

# On vérifie la syntaxe
fission spec validate
# On déploie
fission spec apply --wait
# On test via Fission CLI
fission -n fission function test --name wol-fn --method GET -q "mac=a1:b2:c3:d4:e5:f6"
# On test via HTTP depuis l'extérieur
curl "https://test/domain.tld/wake?mac=a1:b2:c3:d4:e5:f6"

Pour faire simple, ajouter l’URL en raccourci sur le téléphone et en un clic, le PC est démarré. Personnellement, je l’ai intégré dans mon Home Assistant avec un bouton dédié.

Finalisation de la configuration

Celui qu’on adore détester

Il reste deux ou trois détails à régler. Par défaut, depuis Windows 10, quand on arrête le système, il se place en réalité dans un mode de veille prolongée pour permettre un démarrage plus rapide. Hors le *Wake On LAN* ne fonctionne pas sur ce mode de sommeil. Microsoft documente ça très bien ici. Il y est également expliqué comment désactiver ce mode pour pouvoir rétablir un mode d’extinction « normal ».

Je vous les remets à l’identique:

• Dans Panneau de configuration, ouvrez l’élément Options d’alimentation
• Sélectionnez le lien Choisir ce que les boutons d’alimentation font
• Désactivez la case à cocher Activer le démarrage rapide (recommandé)
• Sélectionnez Enregistrez les paramètres.

Une fois cette modification effectuée, le Wake On LAN est complètement fonctionnel.

La fin

Et donc, puisqu’on a abordé le sujet, comment se passe l’extinction ? Vous vous rappelez ? le but de tout ce foutoir, c’était d’éviter de garder le PC allumé pendant deux semaines. On a parlé du démarrage, mais quid de l’arrêt ?

Le plus simple est de lancer une session Bureau dans Moonlight et d’aller cliquer sur le menu Démarrer puis le bouton Arrêter comme à la maison. Mais on peut aussi déclarer des applications dans Sunshine et il exécutera la commande associée à cette application.

J’ai donc créer une application nommée Shutdown qui lance la commande suivante shutdown /s /f /t 0.

Quand elle est lancée depuis le client Moonlight, elle éteint le PC distant.

Feedback et Conclusion

Puisque je suis rentré depuis, je peux débriefer ces 2 semaines d’utilisation, ça fonctionne super, le seul défaut que j’ai eu est qu’une fois le Shutdown n’a pas fonctionné et je ne l’ai pas vu tout de suite. Les fois suivantes, j’ai juste eu à bien vérifier le status dans le menu.

À part ça, super expérience ! Bien sur je n’ai pas cherché à jouer à des jeux très performants, mais ça a suffi à mes besoins, même en 4G. Je n’ai pas non plus poussé jusqu’à tenter de jouer sur la 4G en voiture, mais je pense que ça aurait pu marcher.
Je continue à l’utiliser, même à la maison, pour jouer dans le canapé plutôt que devant le PC.

---

Alors, avouez que c’est pas mal en termes de bricolages inutiles donc indispensables, il était donc nécessaire de partager ça avec le plus grand nombre ? (enfin au moins les lecteurs de ce blog)

Si vous êtes sous Mac, je pense que comme moi, vous passez votre temps à chercher des fichiers ou lancer des applications avec Spotlight… Si vous ne connaissez pas cet outil, c’est un truc super pratique d’Apple qui indexe tout votre disque dur pour vous faire gagner du temps. Command+Espace, trois lettres tapées, et hop, votre document apparaît. Pratique, non ?

Sauf que voilà, depuis presque 10 ans maintenant, ce même Spotlight peut servir de cheval de Troie pour siphonner vos données les plus privées. Et le pire, c’est qu’Apple le sait et n’arrive toujours pas à vraiment colmater la brèche.

Patrick Wardle, le chercheur en sécurité derrière plusieurs outils populaires comme LuLu , vient d’expliquer sur son blog Objective-See une technique ahurissante qui permet à un plugin Spotlight malveillant de contourner toutes les protections TCC de macOS. Pour info, TCC (Transparency, Consent and Control), c’est le système qui vous demande si telle application peut accéder à vos photos, vos contacts, votre micro… Bref, c’est censé être le garde du corps de votre vie privée sous Mac.

Alors comment ça marche ?

Hé bien au lieu d’essayer de forcer les portes blindées du système, le plugin malveillant utilise les notifications Darwin comme une sorte de morse numérique. Chaque byte du fichier à voler est encodé dans le nom d’une notification (de 0 à 255), et un processus externe n’a qu’à écouter ces notifications pour reconstruire le fichier original, octet par octet. C’est du génie dans sa simplicité !

Ce qui rend cette histoire encore plus dingue, c'est que cette vulnérabilité a été présentée pour la première fois par Wardle lui-même lors de sa conférence #OBTS v1.0 en 2018. Il avait déjà montré comment les notifications pouvaient permettre aux applications sandboxées d'espionner le système.

Plus récemment, Microsoft a “redécouvert” une variante de cette technique cette année et l’a baptisée “ Sploitlight ”. Ils ont même obtenu un joli CVE tout neuf (CVE-2025-31199) pour leur méthode qui consistait à logger les données dans les journaux système. Apple a corrigé cette variante dans macOS Sequoia 15.4… mais la méthode originale de Wardle fonctionne toujours, même sur macOS 26 (Tahoe) !

Et sinon, savez-vous ce que ces plugins peuvent voler exactement ?

Il y a notamment un fichier bien particulier sur votre Mac, caché dans les profondeurs du système, qui s’appelle knowledgeC.db. Cette base de données SQLite est littéralement le journal intime de votre Mac. Elle contient tout :

• Quelles applications vous utilisez et pendant combien de temps
• Vos habitudes de navigation web avec Safari (historique détaillé, fréquence des visites, interactions)
• Quand vous branchez votre téléphone
• Quand vous verrouillez votre écran
• Vos trajets en voiture avec CarPlay
• Vos routines quotidiennes et patterns comportementaux

C’est le genre de données qui raconte votre vie mieux que vous ne pourriez le faire vous-même. Et avec les nouvelles fonctionnalités d’Apple Intelligence dans macOS Tahoe, cette base de données alimente directement l’IA d’Apple pour personnaliser votre expérience.

Avec ce fichier, quelqu’un pourrait non seulement voir ce que vous faites maintenant sur votre Mac, mais aussi reconstituer vos habitudes des 30 derniers jours. À quelle heure vous commencez votre journée, quelles apps vous lancez en premier, combien de temps vous passez sur tel ou tel site… C’est le rêve de n’importe quel espion ou publicitaire, et c’est accessible via une simple vulnérabilité Spotlight.

Apple a bien sûr essayé de corriger le tir. Dans macOS 15.4, ils ont ajouté de nouveaux événements TCC au framework Endpoint Security pour mieux surveiller qui accède à quoi. Ils ont aussi corrigé la variante découverte par Microsoft (CVE-2025-31199).

Mais… la vulnérabilité de base présentée par Wardle fonctionne toujours sur macOS 26 (Tahoe), même en version Release Candidate avec SIP activé ! C’est comme ajouter une serrure supplémentaire sur la porte alors que tout le monde passe par la fenêtre depuis 10 ans.

Wardle a une idée toute simple pour régler définitivement le problème : Apple pourrait exiger une notarisation pour les plugins Spotlight, ou au minimum demander l’authentification et l’approbation explicite de l’utilisateur avant leur installation. Actuellement, n’importe quel plugin peut s’installer tranquillement dans ~/Library/Spotlight/ et commencer à espionner vos données, sans même nécessiter de privilèges administrateur.

Alors bien sûr, avant que vous ne couriez partout comme une poule sans tête, il faut relativiser :

1. Cette attaque nécessite un accès local à votre système - on ne parle pas d’une vulnérabilité exploitable à distance
2. Il faut qu’un malware ou un attaquant installe d’abord le plugin malveillant sur votre Mac
3. La “bande passante” est limitée - transmettre octet par octet n’est pas très efficace pour de gros fichiers
4. macOS affiche une notification quand un nouveau plugin Spotlight est installé (même si cette alerte peut être contournée)

Ça fait quand même quelques conditions… mais le fait que cette faille existe depuis près de 10 ans et fonctionne toujours sur la dernière version de macOS reste préoccupant.

Cette histoire nous rappelle que les outils les plus dangereux sont souvent ceux auxquels on fait le plus confiance… Wardle fournit même un proof-of-concept complet sur son site pour que la communauté puisse tester et comprendre le problème. Espérons qu’Apple prendra enfin cette vulnérabilité au sérieux et implémentera les mesures de sécurité suggérées.

En attendant, restez vigilants sur les applications que vous installez et gardez un œil sur les notifications système concernant l’installation de nouveaux plugins Spotlight !