Québec, Canada

403-1381 1re Avenue

+1 581.849.27.96

bdgouthiere@gmail.com

Données perdues chez Yandex Cloud : une sauvegarde se juge à sa restauration

Ou : Le seul test de sauvegarde que personne ne lance, parce qu’il pourrait échouer

Le 10 novembre 2026, Yandex a publié le bilan de la restauration de son cloud, un mois après des frappes de drones attribuées à l’Ukraine sur trois de ses centres de données, à Sasovo, Kalouga et Vladimir, entre le 8 et le 11 octobre. Ses équipes ont rendu l’accès à 97,16 % des données des clients de Yandex Cloud. Les 2,84 % restants sont perdus, « à cause de dommages critiques au matériel et de l’absence, chez les clients, de sauvegardes sur la plateforme ». La phrase suivante est la plus intéressante du billet : les utilisateurs qui se servaient des outils de sauvegarde de Yandex Cloud n’ont rien perdu. Depuis, la sauvegarde est activée par défaut pour chaque nouvelle machine virtuelle1.

Je n’ai rien à ajouter sur la guerre, qui n’est pas le sujet de ce blog. La phrase sur les sauvegardes, elle, concerne tous ceux qui hébergent quelque chose quelque part. Elle range les clients en deux groupes, ceux qui avaient une copie et ceux qui n’en avaient pas, et elle oublie le troisième, qui ne figure dans aucune statistique : ceux qui croient en avoir une. Ce groupe-là ne le sait qu’au moment de restaurer. Autant le savoir un mardi matin ordinaire, avec un petit outil en Go qui restaure l’archive dans un dossier jetable et vérifie chaque fichier.

Tester la restauration d’une sauvegarde : un outil Go qui extrait l’archive et compare les SHA-256

Ce que dit le bilan de Yandex, et ce qu’il laisse ouvert

La chronologie, reconstituée à partir du billet de Yandex, de l’agence Interfax2 et de Numerama3 :

DateÉvénement
Nuit du 7 au 8 octobre 2026le centre de données de Sasovo, dans la région de Riazan, est touché et cesse de fonctionner
9 octobre 2026 au matinle site de Kalouga est frappé ; plusieurs modules sont hors service
Nuit du 11 octobre 2026le site de Vladimir est mis à l’arrêt
10 novembre 2026Yandex publie son bilan : 97,16 % des données rendues, 2,84 % perdues
11 novembre 2026ouverture d’une nouvelle zone de disponibilité, ru-central1-f, dans un lieu que le billet ne précise pas

Le billet laisse une question ouverte : le pourcentage porte-t-il sur toutes les données des clients de Yandex Cloud, ou seulement sur celles des centres touchés ? Le texte russe parle des « données des clients » sans autre précision ; heise, qui a lu le même billet, comprend qu’il s’agit des centres de données touchés, et relève au passage que la formule laisse penser que Yandex ne gardait pas de copie à lui4. La différence compte pour mesurer la perte, pas pour la leçon. Un pourcentage est une statistique pour le fournisseur ; pour chaque client, la question est binaire : ses données sont-elles revenues ?

Le reste du billet est un mode d’emploi : qui a des copies (stockage objet, service Cloud Backup, instantanés de disques, sauvegardes des bases gérées) peut les restaurer dans une zone qui fonctionne. Tout le reste dépendait de l’état du matériel.

Le même fournisseur, le même contrat, le même risque

Il serait tentant d’en conclure qu’une sauvegarde chez son fournisseur suffit, puisqu’elle a suffi aux clients de Yandex qui en avaient une. Elle a suffi parce que Yandex a perdu des bâtiments, pas son existence. La copie rangée chez le même fournisseur partage avec l’original le compte client, le mot de passe de ce compte, la facture, le contrat, souvent la région, et toutes les décisions que ce fournisseur peut prendre. Une suspension pour impayé, un compte compromis dont l’intrus efface aussi les instantanés, une faillite : aucun de ces événements ne s’arrête poliment à la frontière entre la machine et sa sauvegarde.

C’est l’histoire du double des clés de la maison rangé dans la boîte à gants de la voiture, garée dans le garage de la maison. Contre la perte des clés, c’est parfait. Contre le cambrioleur qui vole la voiture, il a désormais les deux jeux. Contre l’incendie, la maison, le garage, la voiture et les deux jeux brûlent ensemble, et le dossier d’assurance est dans le tiroir de la cuisine. L’Europe a eu sa version de l’incendie en mars 2021, quand un bâtiment d’OVHcloud a brûlé à Strasbourg avec des sauvegardes de clients rangées sous le même toit ; la suite judiciaire est retracée dans les leçons de l’incendie de Strasbourg pour vos sauvegardes.

La règle qui répond à tout cela a un nom et une source. En 2012, un document rédigé pour l’US-CERT, l’équipe de réponse aux incidents du gouvernement américain, par Paul Ruggiero et Matthew A. Heckathorn de l’université Carnegie Mellon, la résume en trois chiffres5 :

ChiffreCe que dit la règleCe que cela donne pour un site hébergé
3trois copies de chaque fichier important : l’original et deux sauvegardesle site en production, la copie de l’hébergeur, une copie à vous
2deux types de supports, contre des dangers différentsun autre système de stockage, pas un deuxième dossier sur le même disque
1une copie hors siteun autre fournisseur, un autre compte, idéalement un autre pays

Le document parlait de disques externes et de bandes ; la traduction pour un site hébergé est la mienne, et elle tient en une phrase : la troisième copie ne doit dépendre d’aucun identifiant qui donne aussi accès aux deux premières.

Présente, datée, et pourtant inutilisable

Un contrôle de sauvegarde ordinaire vérifie trois choses : l’archive existe, elle a une taille plausible, elle porte la date du jour. Ce sont des contrôles de présence. Ils laissent passer l’archive tronquée par un envoi interrompu, l’export de base de données vide parce que le mot de passe a changé, le dossier exclu par un motif d’exclusion trop large, le fichier qui a changé pendant la copie. Les copies des hébergeurs n’échappent pas à la question : leur conservation va de sept jours chez Infomaniak à quatre-vingt-dix jours chez o2switch selon la formule, d’après le relevé réuni dans la sécurité et les sauvegardes d’un site hébergé, et aucune de ces durées ne dit si la copie se restaure.

L’agence américaine de cybersécurité, la CISA, formule la consigne sans détour dans son guide contre les rançongiciels : garder des sauvegardes hors ligne et chiffrées, et « tester régulièrement leur disponibilité et leur intégrité » dans un scénario de reprise après sinistre6. Disponibilité : on peut la récupérer. Intégrité : ce qu’on récupère est bien ce qu’on avait mis dedans.

DevOps Dave : La sauvegarde tourne toutes les nuits depuis deux ans. Le fichier fait 4 Go, comme d’habitude.

Security Sarah : Tu l’as déjà restaurée ?

DevOps Dave : Pas besoin. Le script répond zéro chaque nuit.

Security Sarah : Le script répond zéro quand tar a fini d’écrire. Il ne te dit pas que le dossier des fichiers envoyés par les clients est exclu depuis la migration de mars.

DevOps Dave : Il fait 4 Go, l’archive.

Security Sarah : Le cache aussi.

Restaurer, donc. Et comparer ce qui sort à ce qui devait sortir.

Le manifeste : une empreinte par fichier, au moment de la copie

Pour savoir ce qui devait sortir, il faut l’avoir noté au moment de la sauvegarde. Le format le plus simple est celui de sha256sum, présent sur toutes les distributions Linux : une ligne par fichier, l’empreinte SHA-256 en hexadécimal, deux espaces, le nom. Deux commandes produisent le manifeste puis l’archive, depuis le dossier parent du site :

1
2
3
# Une empreinte par fichier, dans un ordre stable, puis l'archive du même dossier.
(cd site && find . -type f -print0 | sort -z | xargs -0 sha256sum) > sauvegarde.sha256
tar -czf sauvegarde.tar.gz -C site .

Sur un petit site d’essai, le manifeste ressemble à ceci (empreintes coupées pour la lisibilité) :

1
2
3
9844f3630c1726c74539...  ./conf/app.ini
20f00a89e4eb4d020116...  ./index.html
f5fa8b0f06e074154820...  ./uploads/photo.jpg

Le manifeste se calcule sur la source : calculé sur l’archive, il prouverait seulement qu’elle n’a pas changé depuis. Et sur un site vivant, un fichier peut changer entre les deux commandes. Le test le signalera comme modifié, et c’est une information : si cela arrive chaque nuit, la sauvegarde capture un site en mouvement. Un instantané du système de fichiers, ou une sauvegarde lancée au calme, règle la question.

Le manifeste voyage avec l’archive, mais pas forcément au même endroit. Rangé à côté d’elle, il détecte les accidents : un octet abîmé, un envoi coupé. Rangé ailleurs, il détecte aussi une archive remplacée par quelqu’un qui aurait pu recalculer le manifeste voisin.

L’outil, que j’ai appelé verifarchive, lit ce format avec ses deux variantes, l’espace du mode texte et l’astérisque du mode binaire, et les noms que sha256sum échappe quand ils contiennent une barre oblique inverse ou un saut de ligne. Chaque nom passe ensuite par la même fonction que les entrées de l’archive, qui retire le ./ du début et refuse tout ce qui remonte : un manifeste qui annonce ../secret est une erreur, pas une ligne à ignorer.

Restaurer sans se faire restaurer par l’archive

Extraire une archive, c’est laisser un fichier venu d’ailleurs choisir où l’on écrit. Une entrée nommée ../../.bashrc demande à être écrite deux dossiers au-dessus du dossier de restauration. En juin 2018, l’entreprise de sécurité Snyk a baptisé ce problème « Zip Slip » et l’a trouvé dans des bibliothèques de nombreux langages, pour les formats zip, tar, jar et quelques autres7.

Le paquet archive/tar de Go renvoie les noms tels qu’ils sont écrits dans l’archive. Sa documentation prévoit une option, GODEBUG=tarinsecurepath=0, qui fait renvoyer une erreur ErrInsecurePath pour les noms qui ne sont pas locaux, et précise qu’une future version pourrait le faire par défaut ; elle précise aussi que seuls les noms sont contrôlés, pas les cibles des liens8. Un outil qui restaure doit donc faire le tri lui-même. filepath.IsLocal, arrivé avec Go 1.20, répond à la première moitié de la question : un chemin vide, absolu, ou qui remonte au-dessus de son point de départ n’est pas local.

1
2
3
4
5
6
7
8
9
// nomLocal refuse un nom d'entrée absolu, vide, ou qui remonte avec « .. »
// au-dessus du dossier de restauration, et renvoie sa forme nettoyée.
func nomLocal(nom string) (string, error) {
	local := filepath.FromSlash(strings.TrimSuffix(nom, "/"))
	if !filepath.IsLocal(local) {
		return "", fmt.Errorf("chemin refusé : %q sort du dossier de restauration", nom)
	}
	return filepath.Clean(local), nil
}

La boucle d’extraction s’arrête à la première entrée suspecte, au lieu de la sauter. Une archive piégée n’est pas une sauvegarde à moitié bonne. La boucle refuse aussi les types d’entrées qu’une sauvegarde de site n’a aucune raison de contenir, comme les fichiers de périphériques, et plafonne la taille totale restaurée, pour ne pas remplir le disque du serveur qui teste.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
	// Toutes les écritures passent par os.Root : même un lien symbolique
	// accepté ne permet pas d'écrire hors de dest.
	racine, err := os.OpenRoot(dest)
	if err != nil {
		return 0, err
	}
	defer racine.Close()

	tr := tar.NewReader(zr)
	var total int64
	n := 0
	for {
		h, err := tr.Next()
		// ... fin de l'archive, erreurs de lecture, en-tête pax global
		nom, err := nomLocal(h.Name)
		if err != nil {
			return n, err
		}
		switch h.Typeflag {
		case tar.TypeDir:
			err = racine.MkdirAll(nom, 0o700)
		case tar.TypeReg:
			total += h.Size
			if total > limite {
				return n, fmt.Errorf("%s : plus de %d octets à restaurer", h.Name, limite)
			}
			err = ecrireFichier(racine, nom, tr, h.Size)
		case tar.TypeSymlink:
			err = creerLien(racine, nom, h.Linkname)
		case tar.TypeLink:
			err = creerLienPhysique(racine, nom, h.Linkname)
		default:
			return n, fmt.Errorf("%s : type d'entrée %q non pris en charge", h.Name, h.Typeflag)
		}
		if err != nil {
			return n, fmt.Errorf("%s : %w", h.Name, err)
		}
		n++
	}

Le dossier de destination, lui, vient de os.MkdirTemp, qui crée un dossier au nom aléatoire, accessible à son seul propriétaire, sous le dossier temporaire du système. Il est supprimé à la fin, sauf avec l’option -garder, qui le laisse en place pour l’inspecter. Rien n’est jamais écrit à l’emplacement d’origine du site : on teste la restauration, on ne la fait pas.

Pour être juste envers les outils existants, GNU tar se défend déjà contre le cas simple. Sur une archive d’essai qui contient index.html et ../evasion.txt, la version 1.35 extrait le premier, refuse le second et sort en erreur :

1
2
3
4
$ tar -xzf piege.tar.gz -C gnu/dest
tar: Removing leading `../' from member names
tar: ../evasion.txt: Member name contains '..'
tar: Exiting with failure status due to previous errors

verifarchive fait de même, en plus strict, puisqu’il n’extrait rien du tout après l’entrée fautive :

1
2
$ verifarchive -manifeste piege.sha256 piege.tar.gz
restauration refusée : chemin refusé : "../evasion.txt" sort du dossier de restauration

Les liens symboliques, ou pourquoi le contrôle lexical ne suffit pas

Les noms ne sont que la moitié du problème. Une archive peut contenir un lien symbolique sortie qui pointe vers /etc, puis un fichier sortie/cron.d/tache : le nom du fichier est parfaitement local, et c’est le lien qui fait le voyage. L’outil refuse donc les liens absolus et ceux dont la cible, lue depuis le dossier du lien, remonte au-dessus de la racine :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
// creerLien n'accepte qu'un lien relatif dont la cible, lue depuis le
// dossier du lien, reste sous la racine. Ce contrôle est lexical : os.Root
// rattrape les chaînes de liens qui le contourneraient.
func creerLien(racine *os.Root, nom, cible string) error {
	if cible == "" || filepath.IsAbs(cible) {
		return fmt.Errorf("lien refusé : cible absolue ou vide %q", cible)
	}
	if !filepath.IsLocal(filepath.Join(filepath.Dir(nom), cible)) {
		return fmt.Errorf("lien refusé : %q sort du dossier de restauration", cible)
	}
	if err := racine.MkdirAll(filepath.Dir(nom), 0o700); err != nil {
		return err
	}
	return racine.Symlink(cible, nom)
}

Le commentaire avoue la limite. Un contrôle lexical lit des chaînes de caractères, pas le système de fichiers. Prenez deux liens : y pointe vers ., la racine elle-même, et x pointe vers y/... Pour un lecteur de chaînes, y/.. vaut ., donc x reste chez lui. Pour le système de fichiers, y est la racine, donc y/.. est son parent, donc x est une porte vers l’extérieur. Les deux liens passent le contrôle, et un fichier x/evasion.txt atterrirait à côté du dossier de restauration.

C’est là qu’intervient os.Root, arrivé avec Go 1.24 et présenté en mars 2025 sur le blog du langage sous le titre « Traversal-resistant file APIs »9. Une Root s’ouvre sur un dossier, et chacune de ses méthodes refuse de suivre un chemin ou un lien qui en sort, en résolvant les liens au moment de l’opération plutôt qu’avant, ce qui ferme aussi la fenêtre entre la vérification et l’écriture, à quelques exceptions près que sa documentation énumère, comme le changement de droits sous Unix. Toutes les écritures de l’outil passent par elle, et sur l’archive aux deux liens, c’est elle qui refuse :

1
x/evasion.txt : mkdirat x: statat x: path escapes from parent

Laquelle des deux protections travaille vraiment ? En désactivant filepath.IsLocal dans nomLocal, la traversée par ../ et le chemin absolu ne passent pas davantage : os.Root les arrête aussi, avec un message moins lisible (mkdirat ..: path escapes from parent). Le contrôle lexical reste utile pour trois raisons : il donne un message qu’un humain comprend à 4 h du matin, il protège le manifeste, qui ne passe pas par os.Root, et il refuse les liens douteux au lieu de les laisser dormir dans le dossier restauré, prêts pour le jour où quelqu’un l’ouvrira avec -garder.

Dernier détail, l’ouverture du fichier se fait avec O_EXCL :

1
2
3
	// O_EXCL : une entrée en double, ou un lien posé plus tôt sous le même
	// nom pour détourner l'écriture, fait échouer la création.
	f, err := racine.OpenFile(nom, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0o600)

Avec O_CREATE et O_EXCL, le système refuse de créer un fichier là où un nom existe déjà, lien symbolique compris, sans le suivre. Une archive qui pose un lien index.html puis écrit un fichier index.html échoue avec file exists. Une archive qui contient deux fois le même fichier aussi.

La somme de contrôle que personne ne lisait

Pendant mes essais, j’ai abîmé une archive exprès : un seul octet inversé au milieu du fichier, dans les données d’une photo. Le flux compressé est resté lisible, l’extraction est allée au bout, et c’est le manifeste qui a vu le problème :

1
2
MODIFIÉ     uploads/photo.jpg
bilan       conformes 2, modifiés 1, manquants 0, inattendus 0

Le format gzip porte pourtant une somme de contrôle CRC-32 des données décompressées, à la fin du flux10. gzip -t la vérifie, et tar -tzf aussi, puisqu’il passe par gzip. Le lecteur tar de Go, lui, s’arrête aux blocs de fin de l’archive tar et ne lit pas la queue du flux gzip. La somme de contrôle n’est jamais calculée, et donc jamais comparée. Trois lignes, après la boucle, la font lire :

1
2
3
4
5
	// Le lecteur tar s'arrête aux blocs de fin et laisse la queue du flux
	// gzip, où se trouve sa somme de contrôle : on la lit pour la vérifier.
	if _, err := io.Copy(io.Discard, zr); err != nil {
		return n, fmt.Errorf("archive abîmée : %w", err)
	}

Sur la même archive, l’outil s’arrête désormais avec un message qui désigne la bonne coupable :

1
2
$ verifarchive -manifeste sauvegarde.sha256 abimee.tar.gz
restauration refusée : archive abîmée : gzip: invalid checksum

Le manifeste aurait suffi à signaler l’écart, mais deux contrôles disent qui est en tort : fichier modifié et archive intacte, le site a changé pendant la copie ; somme de contrôle fausse, le stockage abîme ce qu’on lui confie. Ce ne sont pas les mêmes coups de téléphone.

Modifié, manquant, inattendu

La comparaison parcourt le dossier restauré, toujours à travers os.Root, calcule l’empreinte de chaque fichier ordinaire et range chacun dans une seule case :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
	err = fs.WalkDir(racine.FS(), ".", func(nom string, d fs.DirEntry, err error) error {
		if err != nil {
			return err
		}
		if !d.Type().IsRegular() {
			return nil // dossiers et liens symboliques
		}
		vus[nom] = true
		empreinte, err := hacher(racine, nom)
		if err != nil {
			return err
		}
		voulue, connu := attendu[nom]
		switch {
		case !connu:
			b.Inattendus = append(b.Inattendus, nom)
		case voulue != empreinte:
			b.Modifies = append(b.Modifies, nom)
		default:
			b.Conformes++
		}
		return nil
	})
	// ... puis chaque nom du manifeste jamais vu devient un fichier manquant

On pourrait se contenter de tar -xzf suivi de sha256sum -c, et pour une vérification à la main c’est un bon début. Voici ce que donne sha256sum -c sur une archive prise à un autre moment que le manifeste, où un réglage a changé, une photo a disparu et un fichier de cache est apparu :

1
2
3
4
5
6
7
$ sha256sum -c ../sauvegarde.sha256
./conf/app.ini: FAILED
./index.html: OK
sha256sum: ./uploads/photo.jpg: No such file or directory
./uploads/photo.jpg: FAILED open or read
sha256sum: WARNING: 1 listed file could not be read
sha256sum: WARNING: 1 computed checksum did NOT match

Le fichier modifié et le fichier manquant sont là. Le fichier de cache, non : sha256sum -c vérifie la liste qu’on lui donne et ne regarde pas ce qui n’y figure pas. Un fichier inattendu n’est pas forcément grave, mais il dit toujours quelque chose : un manifeste et une archive d’âges différents, un cache qui gonfle les copies, ou un fichier qu’un intrus a déposé sur le site et que la sauvegarde conserve fidèlement. Sur la même archive, l’outil range les trois écarts :

1
2
3
4
5
6
7
$ verifarchive -manifeste sauvegarde.sha256 decalee.tar.gz
archive     decalee.tar.gz
restaurée   7 entrées, 3 fichiers attendus
MODIFIÉ     conf/app.ini
MANQUANT    uploads/photo.jpg
INATTENDU   cache/session.tmp
bilan       conformes 1, modifiés 1, manquants 1, inattendus 1

Le code de sortie fait le reste. Zéro quand tout est conforme, un au moindre écart, deux quand la vérification n’a pas pu aller au bout : archive illisible, tronquée, piégée, manifeste malformé. Une archive coupée en plein envoi, par exemple, s’arrête sur le fichier où le flux s’interrompt :

1
2
$ verifarchive -manifeste sauvegarde.sha256 tronquee.tar.gz
restauration refusée : ./uploads/photo.jpg : unexpected EOF

Les tests de table, archive piégée comprise

Un outil qui juge des sauvegardes doit lui-même être jugé, et une archive se fabrique très bien en mémoire avec archive/tar et compress/gzip. Chaque cas de test décrit une liste d’entrées, l’erreur attendue, et les fichiers qui doivent exister après coup, à la manière des tests de table en Go :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
		{
			nom:     "traversée de chemin",
			entrees: []entree{fichier("site/index.html", "ok"), fichier("site/../../evasion.txt", "piège")},
			erreur:  "chemin refusé",
		},
		{
			nom: "chaîne de liens, puis écriture à travers",
			// y vaut la racine, donc x vaut son parent : le contrôle lexical
			// laisse passer x, os.Root refuse l'écriture.
			entrees: []entree{lien("y", "."), lien("x", "y/.."), fichier("x/evasion.txt", "piège")},
			erreur:  "x/evasion.txt",
		},
		{
			nom:     "fichier écrit par-dessus un lien",
			entrees: []entree{lien("index.html", "autre.html"), fichier("index.html", "piège")},
			erreur:  "file exists",
		},

Chaque cas restaure dans un sous-dossier d’un dossier temporaire du test, puis vérifie que ce dossier parent ne contient rien d’autre. Une évasion réussie ferait échouer le test même si l’outil avait renvoyé la bonne erreur, ce qui est exactement le genre de mensonge qu’un test doit attraper.

Les tests de bout en bout appellent la fonction run, celle que main enveloppe, avec une vraie archive et un vrai manifeste écrits sur disque. Ils vérifient le code de sortie, la sortie, et un dernier point : la variable TMPDIR est redirigée vers un dossier du test, que os.MkdirTemp utilise, et qui doit être vide après chaque appel. Un outil de vérification qui laisse une copie complète du site dans /tmp à chaque passage ne vérifie pas une fuite, il en crée une. Les six cas couvrent l’archive conforme, le fichier corrompu, le fichier manquant, le fichier inattendu, l’archive avec traversée de chemin et le manifeste illisible, avec les codes 0, 1 et 2 attendus.

Le dernier test fabrique une archive sans compression, inverse un octet dans les données et exige l’erreur « archive abîmée ». En retirant les trois lignes qui lisent la queue du flux gzip, il échoue, ce qui prouve au moins qu’il teste quelque chose. Au total, quatre fonctions de test et 34 cas, dont 15 pour le manifeste et 12 pour l’extraction. La sortie, avec Go 1.27.4 sous Linux, le 16 novembre 2026 :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
$ go vet ./...
$ go test -count=1 ./...
ok  	verifarchive	0.020s

$ go test -count=1 -v -run TestExtraire ./...
--- PASS: TestExtraire (0.01s)
    --- PASS: TestExtraire/archive_saine (0.00s)
    --- PASS: TestExtraire/lien_interne_accepté (0.00s)
    --- PASS: TestExtraire/traversée_de_chemin (0.00s)
    --- PASS: TestExtraire/chemin_absolu (0.00s)
    --- PASS: TestExtraire/lien_symbolique_absolu (0.00s)
    --- PASS: TestExtraire/lien_symbolique_qui_remonte (0.00s)
    --- PASS: TestExtraire/chaîne_de_liens,_puis_écriture_à_travers (0.00s)
    --- PASS: TestExtraire/fichier_écrit_par-dessus_un_lien (0.00s)
    --- PASS: TestExtraire/entrée_en_double (0.00s)
    --- PASS: TestExtraire/lien_physique_vers_l'extérieur (0.00s)
    --- PASS: TestExtraire/périphérique (0.00s)
    --- PASS: TestExtraire/limite_de_taille (0.00s)
PASS
ok  	verifarchive	0.023s

L’outil n’utilise que la bibliothèque standard. C’est le même principe que le vérificateur SPF, DKIM et DMARC en Go : un petit binaire, sans dépendance, qui se copie sur n’importe quel serveur et répond par un code de sortie.

Planifier le test, et le lancer sur la bonne copie

Un test de restauration lancé une fois rassure le jour même. Lancé chaque semaine, il dit quelque chose de la sauvegarde de cette semaine-là. cron suffit :

MAILTO=admin@example.com
# Chaque lundi à 4 h 30 : vérifier la dernière copie, et n'écrire que s'il y a un écart.
30 4 * * 1  sortie=$(/usr/local/bin/verifarchive -manifeste /chemin/vers/copie/sauvegarde.sha256 /chemin/vers/copie/sauvegarde.tar.gz 2>&1) || echo "$sortie"

cron envoie à l’adresse de MAILTO tout ce qu’une tâche écrit. La ligne n’écrit que si l’outil sort en erreur, donc le courriel n’arrive qu’en cas de problème. C’est aussi sa faiblesse : une tâche qui ne tourne plus ressemble exactement à une semaine sans problème, d’où l’intérêt d’un service de surveillance qui s’inquiète quand un signal de réussite ne vient pas.

Reste à choisir la copie testée. La plus facile est celle qui se trouve sur le serveur, juste après sa création, et c’est la moins utile : le jour où il faudra restaurer, ce serveur ne sera peut-être plus là. La copie à tester est celle dont vous vous servirez, la troisième de la règle 3-2-1, rapatriée depuis son stockage externe avec l’outil que vous utilisez déjà pour l’y envoyer. Le test vérifie alors en une fois que la copie existe ailleurs, qu’on sait la récupérer, et qu’elle contient le site.

Ce que l’outil ne vérifie pas

Une empreinte conforme prouve que les octets sont les bons. Elle ne prouve pas que le site redémarre avec. L’outil ne compare ni les droits des fichiers, ni leurs propriétaires, ni les cibles des liens symboliques, qu’il ne suit pas. Il vérifie un export de base de données comme n’importe quel fichier : le fichier SQL est intact, ce qui ne dit pas qu’il s’importe, ni que l’export n’était pas déjà vide au départ. Pour cela, il faut l’importer dans une base jetable et compter quelques lignes dans les tables qui comptent. Il ne mesure pas non plus la durée d’une restauration complète : Yandex a eu besoin d’un mois pour son bilan.

L’outil répond à une question précise : si je devais restaurer cette archive maintenant, est-ce que j’obtiendrais exactement le site que j’ai sauvegardé, sans que l’archive puisse écrire ailleurs ? C’est la question qu’aucun contrôle de présence ne pose.

Le billet de Yandex dit que les clients qui avaient une sauvegarde n’ont rien perdu. Il ne dit pas combien d’entre eux l’avaient déjà restaurée une fois avant octobre, et je soupçonne que beaucoup l’ont fait pour la première fois en octobre, au pire moment pour découvrir qu’un dossier manquait. La règle 3-2-1 dit combien de copies garder. Elle ne dit pas qu’une copie compte seulement le jour où elle a été restaurée, et c’est pourtant la seule façon de savoir si on en a vraiment trois.



  1. Le billet de Yandex Cloud sur la restauration, publié le 10 novembre 2026, en russe. Il donne les chiffres de 97,16 % et 2,84 %, attribue la perte à des « dommages critiques au matériel » et à l’absence de sauvegardes des clients sur la plateforme, La sauvegarde par défaut des nouvelles machines virtuelles reste désactivable depuis la console. Le billet parle de dommages à l’infrastructure des centres de données en octobre, sans en nommer la cause. ↩︎

  2. La dépêche d’Interfax du 10 novembre 2026, qui situe les attaques de drones entre le 8 et le 11 octobre 2026 : arrêt complet à Sasovo et à Vladimir, plusieurs modules hors service à Kalouga. La dépêche n’attribue pas les attaques ; Numerama et le média russe indépendant Meduza parlent de drones ukrainiens, Meduza précisant qu’il s’agit de trois des six centres de données de Yandex. ↩︎

  3. L’article de Numerama d’Amine Baba Aissa, publié le 12 novembre 2026, qui note que Yandex fait porter une partie de la responsabilité à ses clients, tout en reconnaissant en creux que la sauvegarde n’était pas activée par défaut. ↩︎

  4. L’article de heise, publié le 12 novembre 2026. ↩︎

  5. « Data Backup Options », de Paul Ruggiero et Matthew A. Heckathorn, université Carnegie Mellon, rédigé pour l’US-CERT en 2012 et toujours publié par la CISA. Pour la règle elle-même, le document renvoie à The DAM Book du photographe Peter Krogh (O’Reilly, 2009), un livre sur la gestion des archives de photos numériques : la règle des informaticiens a été écrite par quelqu’un qui avait des milliers d’images à ne pas perdre. ↩︎

  6. Le guide #StopRansomware de la CISA, dans sa version de septembre 2023, partie consacrée à la prévention : la consigne renvoie à l’objectif 2.R des objectifs de performance en cybersécurité (CPG) de l’agence. ↩︎

  7. La page de recherche de Snyk sur Zip Slip, publiée le 5 juin 2018, qui liste les bibliothèques touchées et les formats concernés, dont tar, jar, war, cpio, apk, rar et 7z. ↩︎

  8. La documentation de Reader.Next dans le paquet archive/tar de Go, et celle de filepath.IsLocal, qui précise que l’analyse est purement lexicale et ne tient pas compte des liens symboliques. ↩︎

  9. « Traversal-resistant file APIs », de Damien Neil, publié le 12 mars 2025 sur le blog de Go. Il prend justement l’exemple d’un outil de désarchivage poussé à extraire un lien symbolique, puis un fichier qui passe par ce lien. ↩︎

  10. La RFC 1952, qui décrit le format gzip : chaque membre se termine par le CRC-32 des données décompressées et par leur taille, modulo 2³². C’est le lecteur qui décide de les vérifier, et il ne peut le faire qu’en lisant le flux jusqu’au bout. ↩︎