spip / SPIP

ecrire/src/Chiffrer/SpipCles.php

Indentation +165 added lines, -165 removed lines

@@ -13,169 +13,169 @@
 
 /** Gestion des clés d’authentification / chiffrement de SPIP */
 final class SpipCles {
-	private static array $instances = [];
-
-	private string $file = _DIR_ETC . 'cles.php';
-	private readonly Cles $cles;
-
-	public static function instance(string $file = ''): self {
-		if (empty(self::$instances[$file])) {
-			self::$instances[$file] = new self($file);
-		}
-		return self::$instances[$file];
-	}
-
-	/**
-	 * Retourne le secret du site (shorthand)
-	 * @uses self::getSecretSite()
-	 */
-	public static function secret_du_site(): ?string {
-		return (self::instance())->getSecretSite();
-	}
-
-	private function __construct(string $file = '') {
-		if ($file) {
-			$this->file = $file;
-		}
-		$this->cles = new Cles($this->read());
-	}
-
-	/**
-	 * Renvoyer le secret du site
-	 *
-	 * Le secret du site doit rester aussi secret que possible, et est eternel
-	 * On ne doit pas l'exporter
-	 *
-	 * Le secret est partagé entre une clé disque et une clé bdd
-	 *
-	 * @return string
-	 */
-	public function getSecretSite(bool $autoInit = true): ?string {
-		$key = $this->getKey('secret_du_site', $autoInit);
-		$meta = $this->getMetaKey('secret_du_site', $autoInit);
-		// conserve la même longeur.
-		return $key ^ $meta;
-	}
-
-	/** Renvoyer le secret des authentifications */
-	public function getSecretAuth(bool $autoInit = false): ?string {
-		return $this->getKey('secret_des_auth', $autoInit);
-	}
-	public function save(): bool {
-		return ecrire_fichier_securise($this->file, $this->cles->toJson());
-	}
-
-	/**
-	 * Fournir une sauvegarde chiffree des cles (a l'aide d'une autre clé, comme le pass d'un auteur)
-	 *
-	 * @param string $withKey Clé de chiffrage de la sauvegarde
-	 * @return string Contenu de la sauvegarde chiffrée générée
-	 */
-	public function backup(
-		#[\SensitiveParameter]
-		string $withKey
-	): string {
-		if (count($this->cles)) {
-			return Chiffrement::chiffrer($this->cles->toJson(), $withKey);
-		}
-		return '';
-	}
-
-	/**
-	 * Restaurer les cles manquantes depuis une sauvegarde chiffree des cles
-	 * (si la sauvegarde est bien valide)
-	 */
-	public function restore(
-		/** Sauvegarde chiffrée (générée par backup()) */
-		string $backup,
-		#[\SensitiveParameter]
-		string $password_clair,
-		#[\SensitiveParameter]
-		string $password_hash,
-		int $id_auteur
-	): bool {
-		if (empty($backup)) {
-			return false;
-		}
-
-		$sauvegarde = Chiffrement::dechiffrer($backup, $password_clair);
-		$json = json_decode($sauvegarde, true, 512, JSON_THROW_ON_ERROR);
-		if (!$json) {
-			return false;
-		}
-
-		// cela semble une sauvegarde valide
-		$cles_potentielles = array_map('base64_decode', $json);
-
-		// il faut faire une double verif sur secret_des_auth
-		// pour s'assurer qu'elle permet bien de decrypter le pass de l'auteur qui fournit la sauvegarde
-		// et par extension tous les passwords
-		if (
-			!empty($cles_potentielles['secret_des_auth'])
-			&& !Password::verifier($password_clair, $password_hash, $cles_potentielles['secret_des_auth'])
-		) {
-			spip_logger('chiffrer')->notice("Restauration de la cle `secret_des_auth` par id_auteur $id_auteur erronnee, on ignore");
-			unset($cles_potentielles['secret_des_auth']);
-		}
-
-		// on merge les cles pour recuperer les cles manquantes
-		$restauration = false;
-		foreach ($cles_potentielles as $name => $key) {
-			if (!$this->cles->has($name)) {
-				$this->cles->set($name, $key);
-				spip_logger('chiffrer')->notice("Restauration de la cle $name par id_auteur $id_auteur");
-				$restauration = true;
-			}
-		}
-		return $restauration;
-	}
-
-	private function getKey(string $name, bool $autoInit): ?string {
-		if ($this->cles->has($name)) {
-			return $this->cles->get($name);
-		}
-		if ($autoInit) {
-			$this->cles->generate($name);
-			// si l'ecriture de fichier a bien marche on peut utiliser la cle
-			if ($this->save()) {
-				return $this->cles->get($name);
-			}
-			// sinon loger et annule la cle generee car il ne faut pas l'utiliser
-			spip_logger('chiffrer')->error('Echec ecriture du fichier cle ' . $this->file . " ; impossible de generer une cle $name");
-			$this->cles->delete($name);
-		}
-		return null;
-	}
-
-	private function getMetaKey(string $name, bool $autoInit = true): ?string {
-		if (!isset($GLOBALS['meta'][$name])) {
-			include_spip('base/abstract_sql');
-			$GLOBALS['meta'][$name] = sql_getfetsel('valeur', 'spip_meta', 'nom = ' . sql_quote($name, '', 'string'));
-		}
-		$key = base64_decode($GLOBALS['meta'][$name] ?? '');
-		if (strlen($key) === \SODIUM_CRYPTO_SECRETBOX_KEYBYTES) {
-			return $key;
-		}
-		if (!$autoInit) {
-			return null;
-		}
-		$key = Chiffrement::keygen();
-		ecrire_meta($name, base64_encode($key), 'non');
-		lire_metas(); // au cas ou ecrire_meta() ne fonctionne pas
-
-		return $key;
-	}
-
-	private function read(): array {
-		$json = null;
-		lire_fichier_securise($this->file, $json);
-		if (
-			$json
-			&& ($json = \json_decode($json, true, 512, JSON_THROW_ON_ERROR))
-			&& is_array($json)
-		) {
-			return array_map('base64_decode', $json);
-		}
-		return [];
-	}
+    private static array $instances = [];
+
+    private string $file = _DIR_ETC . 'cles.php';
+    private readonly Cles $cles;
+
+    public static function instance(string $file = ''): self {
+        if (empty(self::$instances[$file])) {
+            self::$instances[$file] = new self($file);
+        }
+        return self::$instances[$file];
+    }
+
+    /**
+     * Retourne le secret du site (shorthand)
+     * @uses self::getSecretSite()
+     */
+    public static function secret_du_site(): ?string {
+        return (self::instance())->getSecretSite();
+    }
+
+    private function __construct(string $file = '') {
+        if ($file) {
+            $this->file = $file;
+        }
+        $this->cles = new Cles($this->read());
+    }
+
+    /**
+     * Renvoyer le secret du site
+     *
+     * Le secret du site doit rester aussi secret que possible, et est eternel
+     * On ne doit pas l'exporter
+     *
+     * Le secret est partagé entre une clé disque et une clé bdd
+     *
+     * @return string
+     */
+    public function getSecretSite(bool $autoInit = true): ?string {
+        $key = $this->getKey('secret_du_site', $autoInit);
+        $meta = $this->getMetaKey('secret_du_site', $autoInit);
+        // conserve la même longeur.
+        return $key ^ $meta;
+    }
+
+    /** Renvoyer le secret des authentifications */
+    public function getSecretAuth(bool $autoInit = false): ?string {
+        return $this->getKey('secret_des_auth', $autoInit);
+    }
+    public function save(): bool {
+        return ecrire_fichier_securise($this->file, $this->cles->toJson());
+    }
+
+    /**
+     * Fournir une sauvegarde chiffree des cles (a l'aide d'une autre clé, comme le pass d'un auteur)
+     *
+     * @param string $withKey Clé de chiffrage de la sauvegarde
+     * @return string Contenu de la sauvegarde chiffrée générée
+     */
+    public function backup(
+        #[\SensitiveParameter]
+        string $withKey
+    ): string {
+        if (count($this->cles)) {
+            return Chiffrement::chiffrer($this->cles->toJson(), $withKey);
+        }
+        return '';
+    }
+
+    /**
+     * Restaurer les cles manquantes depuis une sauvegarde chiffree des cles
+     * (si la sauvegarde est bien valide)
+     */
+    public function restore(
+        /** Sauvegarde chiffrée (générée par backup()) */
+        string $backup,
+        #[\SensitiveParameter]
+        string $password_clair,
+        #[\SensitiveParameter]
+        string $password_hash,
+        int $id_auteur
+    ): bool {
+        if (empty($backup)) {
+            return false;
+        }
+
+        $sauvegarde = Chiffrement::dechiffrer($backup, $password_clair);
+        $json = json_decode($sauvegarde, true, 512, JSON_THROW_ON_ERROR);
+        if (!$json) {
+            return false;
+        }
+
+        // cela semble une sauvegarde valide
+        $cles_potentielles = array_map('base64_decode', $json);
+
+        // il faut faire une double verif sur secret_des_auth
+        // pour s'assurer qu'elle permet bien de decrypter le pass de l'auteur qui fournit la sauvegarde
+        // et par extension tous les passwords
+        if (
+            !empty($cles_potentielles['secret_des_auth'])
+            && !Password::verifier($password_clair, $password_hash, $cles_potentielles['secret_des_auth'])
+        ) {
+            spip_logger('chiffrer')->notice("Restauration de la cle `secret_des_auth` par id_auteur $id_auteur erronnee, on ignore");
+            unset($cles_potentielles['secret_des_auth']);
+        }
+
+        // on merge les cles pour recuperer les cles manquantes
+        $restauration = false;
+        foreach ($cles_potentielles as $name => $key) {
+            if (!$this->cles->has($name)) {
+                $this->cles->set($name, $key);
+                spip_logger('chiffrer')->notice("Restauration de la cle $name par id_auteur $id_auteur");
+                $restauration = true;
+            }
+        }
+        return $restauration;
+    }
+
+    private function getKey(string $name, bool $autoInit): ?string {
+        if ($this->cles->has($name)) {
+            return $this->cles->get($name);
+        }
+        if ($autoInit) {
+            $this->cles->generate($name);
+            // si l'ecriture de fichier a bien marche on peut utiliser la cle
+            if ($this->save()) {
+                return $this->cles->get($name);
+            }
+            // sinon loger et annule la cle generee car il ne faut pas l'utiliser
+            spip_logger('chiffrer')->error('Echec ecriture du fichier cle ' . $this->file . " ; impossible de generer une cle $name");
+            $this->cles->delete($name);
+        }
+        return null;
+    }
+
+    private function getMetaKey(string $name, bool $autoInit = true): ?string {
+        if (!isset($GLOBALS['meta'][$name])) {
+            include_spip('base/abstract_sql');
+            $GLOBALS['meta'][$name] = sql_getfetsel('valeur', 'spip_meta', 'nom = ' . sql_quote($name, '', 'string'));
+        }
+        $key = base64_decode($GLOBALS['meta'][$name] ?? '');
+        if (strlen($key) === \SODIUM_CRYPTO_SECRETBOX_KEYBYTES) {
+            return $key;
+        }
+        if (!$autoInit) {
+            return null;
+        }
+        $key = Chiffrement::keygen();
+        ecrire_meta($name, base64_encode($key), 'non');
+        lire_metas(); // au cas ou ecrire_meta() ne fonctionne pas
+
+        return $key;
+    }
+
+    private function read(): array {
+        $json = null;
+        lire_fichier_securise($this->file, $json);
+        if (
+            $json
+            && ($json = \json_decode($json, true, 512, JSON_THROW_ON_ERROR))
+            && is_array($json)
+        ) {
+            return array_map('base64_decode', $json);
+        }
+        return [];
+    }
 }

ecrire/src/Chiffrer/Chiffrement.php

Indentation +68 added lines, -68 removed lines

@@ -18,76 +18,76 @@
  * @link https://www.php.net/manual/fr/book.sodium.php
  */
 class Chiffrement {
-	/** Chiffre un message en utilisant une clé ou un mot de passe */
-	public static function chiffrer(
-		string $message,
-		#[\SensitiveParameter]
-		string $key
-	): ?string {
-		// create a random salt for key derivation
-		$salt = random_bytes(SODIUM_CRYPTO_PWHASH_SALTBYTES);
-		$key = self::deriveKeyFromPassword($key, $salt);
-		$nonce = random_bytes(\SODIUM_CRYPTO_SECRETBOX_NONCEBYTES);
-		$padded_message = sodium_pad($message, 16);
-		$encrypted = sodium_crypto_secretbox($padded_message, $nonce, $key);
-		$encoded = base64_encode($salt . $nonce . $encrypted);
-		sodium_memzero($key);
-		sodium_memzero($nonce);
-		sodium_memzero($salt);
-		#spip_logger('chiffrer')->debug("chiffrer($message)=$encoded");
-		return $encoded;
-	}
+    /** Chiffre un message en utilisant une clé ou un mot de passe */
+    public static function chiffrer(
+        string $message,
+        #[\SensitiveParameter]
+        string $key
+    ): ?string {
+        // create a random salt for key derivation
+        $salt = random_bytes(SODIUM_CRYPTO_PWHASH_SALTBYTES);
+        $key = self::deriveKeyFromPassword($key, $salt);
+        $nonce = random_bytes(\SODIUM_CRYPTO_SECRETBOX_NONCEBYTES);
+        $padded_message = sodium_pad($message, 16);
+        $encrypted = sodium_crypto_secretbox($padded_message, $nonce, $key);
+        $encoded = base64_encode($salt . $nonce . $encrypted);
+        sodium_memzero($key);
+        sodium_memzero($nonce);
+        sodium_memzero($salt);
+        #spip_logger('chiffrer')->debug("chiffrer($message)=$encoded");
+        return $encoded;
+    }
 
-	/** Déchiffre un message en utilisant une clé ou un mot de passe */
-	public static function dechiffrer(
-		string $encoded,
-		#[\SensitiveParameter]
-		string $key
-	): ?string {
-		$decoded = base64_decode($encoded);
-		$salt = substr($decoded, 0, \SODIUM_CRYPTO_PWHASH_SALTBYTES);
-		$nonce = substr($decoded, \SODIUM_CRYPTO_PWHASH_SALTBYTES, \SODIUM_CRYPTO_SECRETBOX_NONCEBYTES);
-		$encrypted = substr($decoded, \SODIUM_CRYPTO_PWHASH_SALTBYTES + \SODIUM_CRYPTO_SECRETBOX_NONCEBYTES);
-		$key = self::deriveKeyFromPassword($key, $salt);
-		$padded_message = sodium_crypto_secretbox_open($encrypted, $nonce, $key);
-		sodium_memzero($key);
-		sodium_memzero($nonce);
-		sodium_memzero($salt);
-		if ($padded_message === false) {
-			spip_logger('chiffrer')->debug("dechiffrer() chiffre corrompu `$encoded`");
-			return null;
-		}
-		return sodium_unpad($padded_message, 16);
-	}
+    /** Déchiffre un message en utilisant une clé ou un mot de passe */
+    public static function dechiffrer(
+        string $encoded,
+        #[\SensitiveParameter]
+        string $key
+    ): ?string {
+        $decoded = base64_decode($encoded);
+        $salt = substr($decoded, 0, \SODIUM_CRYPTO_PWHASH_SALTBYTES);
+        $nonce = substr($decoded, \SODIUM_CRYPTO_PWHASH_SALTBYTES, \SODIUM_CRYPTO_SECRETBOX_NONCEBYTES);
+        $encrypted = substr($decoded, \SODIUM_CRYPTO_PWHASH_SALTBYTES + \SODIUM_CRYPTO_SECRETBOX_NONCEBYTES);
+        $key = self::deriveKeyFromPassword($key, $salt);
+        $padded_message = sodium_crypto_secretbox_open($encrypted, $nonce, $key);
+        sodium_memzero($key);
+        sodium_memzero($nonce);
+        sodium_memzero($salt);
+        if ($padded_message === false) {
+            spip_logger('chiffrer')->debug("dechiffrer() chiffre corrompu `$encoded`");
+            return null;
+        }
+        return sodium_unpad($padded_message, 16);
+    }
 
-	/** Génère une clé de la taille attendue pour le chiffrement */
-	public static function keygen(): string {
-		return sodium_crypto_secretbox_keygen();
-	}
+    /** Génère une clé de la taille attendue pour le chiffrement */
+    public static function keygen(): string {
+        return sodium_crypto_secretbox_keygen();
+    }
 
-	/**
-	 * Retourne une clé de la taille attendue pour le chiffrement
-	 *
-	 * Notamment si on utilise un mot de passe comme clé, il faut le hacher
-	 * pour servir de clé à la taille correspondante.
-	 */
-	private static function deriveKeyFromPassword(
-		#[\SensitiveParameter]
-		string $password,
-		string $salt
-	): string {
-		if (strlen($password) === \SODIUM_CRYPTO_SECRETBOX_KEYBYTES) {
-			return $password;
-		}
-		$key = sodium_crypto_pwhash(
-			\SODIUM_CRYPTO_SECRETBOX_KEYBYTES,
-			$password,
-			$salt,
-			\SODIUM_CRYPTO_PWHASH_OPSLIMIT_INTERACTIVE,
-			\SODIUM_CRYPTO_PWHASH_MEMLIMIT_INTERACTIVE
-		);
-		sodium_memzero($password);
+    /**
+     * Retourne une clé de la taille attendue pour le chiffrement
+     *
+     * Notamment si on utilise un mot de passe comme clé, il faut le hacher
+     * pour servir de clé à la taille correspondante.
+     */
+    private static function deriveKeyFromPassword(
+        #[\SensitiveParameter]
+        string $password,
+        string $salt
+    ): string {
+        if (strlen($password) === \SODIUM_CRYPTO_SECRETBOX_KEYBYTES) {
+            return $password;
+        }
+        $key = sodium_crypto_pwhash(
+            \SODIUM_CRYPTO_SECRETBOX_KEYBYTES,
+            $password,
+            $salt,
+            \SODIUM_CRYPTO_PWHASH_OPSLIMIT_INTERACTIVE,
+            \SODIUM_CRYPTO_PWHASH_MEMLIMIT_INTERACTIVE
+        );
+        sodium_memzero($password);
 
-		return $key;
-	}
+        return $key;
+    }
 }

ecrire/src/Chiffrer/Password.php

Indentation +43 added lines, -43 removed lines

@@ -13,49 +13,49 @@
 
 /** Vérification et hachage de mot de passe */
 class Password {
-	/**
-	 * verifier qu'un mot de passe en clair est correct a l'aide de son hash
-	 *
-	 * Le mot de passe est poivre via la cle secret_des_auth
-	 */
-	public static function verifier(
-		#[\SensitiveParameter]
-		string $password_clair,
-		#[\SensitiveParameter]
-		string $password_hash,
-		#[\SensitiveParameter]
-		?string $key = null
-	): bool {
-		$key ??= self::getDefaultKey();
-		if ($key) {
-			$pass_poivre = hash_hmac('sha256', $password_clair, $key);
-			return password_verify($pass_poivre, $password_hash);
-		}
-		spip_logger('chiffrer')->notice('Aucune clé pour vérifier le mot de passe');
-		return false;
-	}
+    /**
+     * verifier qu'un mot de passe en clair est correct a l'aide de son hash
+     *
+     * Le mot de passe est poivre via la cle secret_des_auth
+     */
+    public static function verifier(
+        #[\SensitiveParameter]
+        string $password_clair,
+        #[\SensitiveParameter]
+        string $password_hash,
+        #[\SensitiveParameter]
+        ?string $key = null
+    ): bool {
+        $key ??= self::getDefaultKey();
+        if ($key) {
+            $pass_poivre = hash_hmac('sha256', $password_clair, $key);
+            return password_verify($pass_poivre, $password_hash);
+        }
+        spip_logger('chiffrer')->notice('Aucune clé pour vérifier le mot de passe');
+        return false;
+    }
 
-	/**
-	 * Calculer un hash salé du mot de passe
-	 */
-	public static function hacher(
-		#[\SensitiveParameter]
-		string $password_clair,
-		#[\SensitiveParameter]
-		?string $key = null
-	): ?string {
-		$key ??= self::getDefaultKey();
-		// ne pas fournir un hash errone si la cle nous manque
-		if ($key) {
-			$pass_poivre = hash_hmac('sha256', $password_clair, $key);
-			return password_hash($pass_poivre, PASSWORD_DEFAULT);
-		}
-		spip_logger('chiffrer')->notice('Aucune clé pour chiffrer le mot de passe');
-		return null;
-	}
+    /**
+     * Calculer un hash salé du mot de passe
+     */
+    public static function hacher(
+        #[\SensitiveParameter]
+        string $password_clair,
+        #[\SensitiveParameter]
+        ?string $key = null
+    ): ?string {
+        $key ??= self::getDefaultKey();
+        // ne pas fournir un hash errone si la cle nous manque
+        if ($key) {
+            $pass_poivre = hash_hmac('sha256', $password_clair, $key);
+            return password_hash($pass_poivre, PASSWORD_DEFAULT);
+        }
+        spip_logger('chiffrer')->notice('Aucune clé pour chiffrer le mot de passe');
+        return null;
+    }
 
-	private static function getDefaultKey(): ?string {
-		$keys = SpipCles::instance();
-		return $keys->getSecretAuth();
-	}
+    private static function getDefaultKey(): ?string {
+        $keys = SpipCles::instance();
+        return $keys->getSecretAuth();
+    }
 }