spip / SPIP

ecrire/auth/spip.php

Indentation +413 added lines, -413 removed lines

@@ -19,7 +19,7 @@ 
 use Spip\Chiffrer\SpipCles;
 
 if (!defined('_ECRIRE_INC_VERSION')) {
-	return;
+    return;
 }
 
 /**
@@ -34,171 +34,171 @@ 
  */
 function auth_spip_dist($login, $pass, $serveur = '', $phpauth = false) {
 
-	// retrouver le login
-	$login = auth_spip_retrouver_login($login);
-	// login inconnu, n'allons pas plus loin
-	if (!$login) {
-		return [];
-	}
-
-	$md5pass = '';
-	$shapass = $shanext = '';
-	$auteur_peut_sauver_cles = false;
-
-	if ($pass) {
-		$row = sql_fetsel(
-			'*',
-			'spip_auteurs',
-			'login=' . sql_quote($login, $serveur, 'text') . " AND statut<>'5poubelle'",
-			'',
-			'',
-			'',
-			'',
-			$serveur
-		);
-
-		// lever un flag si cet auteur peut sauver les cles
-		if ($row['statut'] === '0minirezo' and $row['webmestre'] === 'oui' and isset($row['backup_cles'])) {
-			$auteur_peut_sauver_cles = true;
-		}
-	}
-
-	// login inexistant ou mot de passe vide
-	if (!$pass or !$row) {
-		return [];
-	}
-
-	include_spip('inc/chiffrer');
-	$cles = SpipCles::instance();
-	$secret = $cles->getSecretAuth();
-
-	$hash = null;
-	switch (strlen($row['pass'])) {
-
-		// legacy = md5 ou sha256
-		case 32:
-			// tres anciens mots de passe encodes en md5(alea.pass)
-			$hash = md5($row['alea_actuel'] . $pass);
-			$methode = 'md5';
-		case 64:
-			if (empty($hash)) {
-				// anciens mots de passe encodes en sha256(alea.pass)
-				include_spip('auth/sha256.inc');
-				$hash = spip_sha256($row['alea_actuel'] . $pass);
-				$methode = 'sha256';
-			}
-			if ($row['pass'] === $hash) {
-				spip_log("validation du mot de passe pour l'auteur #".$row['id_auteur']." $login via $methode", 'auth' . _LOG_DEBUG);
-				// ce n'est pas cense arriver, mais si jamais c'est un backup inutilisable, il faut le nettoyer pour ne pas bloquer la creation d'une nouvelle cle d'auth
-				if (!empty($row['backup_cles'])) {
-					sql_updateq('spip_auteurs', ['backup_cles' => ''], 'id_auteur=' . intval($row['id_auteur']));
-				}
-				break;
-			}
-
-		// on teste la methode par defaut, au cas ou ce serait un pass moderne qui a la malchance d'etre en 64char de long
-
-		case 60:
-		case 98:
-		default:
-			// doit-on restaurer un backup des cles ?
-			// si on a le bon pass on peut decoder le backup, retrouver la cle, et du coup valider le pass
-			if (
-				!$secret
-				and $auteur_peut_sauver_cles
-				and !empty($row['backup_cles'])
-			) {
-				if ($cles->restore($row['backup_cles'], $pass, $row['pass'], $row['id_auteur'])) {
-					spip_log('Les cles secretes ont ete restaurées avec le backup du webmestre #' . $row['id_auteur'], 'auth' . _LOG_INFO_IMPORTANTE);
-					if ($cles->save()) {
-						$secret = $cles->getSecretAuth();
-					}
-					else {
-						spip_log("Echec restauration des cles : verifier les droits d'ecriture ?", 'auth' . _LOG_ERREUR);
-						// et on echoue car on ne veut pas que la situation reste telle quelle
-						raler_fichier(_DIR_ETC . 'cles.php');
-					}
-				}
-				else {
-					spip_log('Pas de cle secrete disponible (fichier config/cle.php absent ?) mais le backup du webmestre #' . $row['id_auteur'] . " n'est pas valide", 'auth' . _LOG_ERREUR);
-					sql_updateq('spip_auteurs', ['backup_cles' => ''], 'id_auteur=' . intval($row['id_auteur']));
-				}
-			}
-
-			if (!$secret or !Password::verifier($pass, $row['pass'], $secret)) {
-				unset($row);
-			}
-			else {
-				spip_log("validation du mot de passe pour l'auteur #".$row['id_auteur']." $login via Password::verifier", 'auth' . _LOG_DEBUG);
-			}
-			break;
-	}
-
-	// Migration depuis ancienne version : si on a pas encore de cle
-	// ET si c'est le login d'un auteur qui peut sauver la cle
-	// créer la clé (en s'assurant bien que personne n'a de backup d'un precedent fichier cle.php)
-	// si c'est un auteur normal, on ne fait rien, il garde son ancien pass hashé en sha256 en attendant le login d'un webmestre
-	if (!$secret and $auteur_peut_sauver_cles) {
-		if (auth_spip_initialiser_secret()) {
-			$secret = $cles->getSecretAuth();
-		}
-	}
-
-	// login/mot de passe incorrect
-	if (empty($row)) {
-		return [];
-	}
-
-	// fait tourner le codage du pass dans la base
-	// sauf si phpauth : cela reviendrait a changer l'alea a chaque hit, et aucune action verifiable par securiser_action()
-	if (!$phpauth and $secret) {
-		include_spip('inc/acces'); // pour creer_uniqid et verifier_htaccess
-		$pass_hash_next = Password::hacher($pass, $secret);
-		if ($pass_hash_next) {
-			$set = [
-				'alea_actuel' => 'alea_futur', // @deprecated 4.1
-				'alea_futur' => sql_quote(creer_uniqid(), $serveur, 'text'), // @deprecated 4.1
-				'pass' => sql_quote($pass_hash_next, $serveur, 'text'),
-			];
-
-			// regenerer un htpass si on a active/desactive le plugin htpasswd
-			// et/ou que l'algo a change - pour etre certain de toujours utiliser le bon algo
-			$htpass = generer_htpass($pass);
-			if (strlen($htpass) !== strlen($row['htpass'])) {
-				$set['htpass'] = sql_quote($htpass, $serveur, 'text');
-			}
-
-			// a chaque login de webmestre : sauvegarde chiffree des clés du site (avec les pass du webmestre)
-			if ($auteur_peut_sauver_cles) {
-				$set['backup_cles'] = sql_quote($cles->backup($pass), $serveur, 'text');
-			}
-
-			@sql_update(
-				'spip_auteurs',
-				$set,
-				'id_auteur=' . intval($row['id_auteur']) . ' AND pass=' . sql_quote(
-					$row['pass'],
-					$serveur,
-					'text'
-				),
-				[],
-				$serveur
-			);
-
-			// si on a change le htpass car changement d'algo, regenerer les fichiers htpasswd
-			if (isset($set['htpass'])) {
-				ecrire_acces();
-			}
-		}
-
-		// En profiter pour verifier la securite de tmp/
-		// Si elle ne fonctionne pas a l'installation, prevenir
-		if (!verifier_htaccess(_DIR_TMP) and defined('_ECRIRE_INSTALL')) {
-			return false;
-		}
-	}
-
-	return $row;
+    // retrouver le login
+    $login = auth_spip_retrouver_login($login);
+    // login inconnu, n'allons pas plus loin
+    if (!$login) {
+        return [];
+    }
+
+    $md5pass = '';
+    $shapass = $shanext = '';
+    $auteur_peut_sauver_cles = false;
+
+    if ($pass) {
+        $row = sql_fetsel(
+            '*',
+            'spip_auteurs',
+            'login=' . sql_quote($login, $serveur, 'text') . " AND statut<>'5poubelle'",
+            '',
+            '',
+            '',
+            '',
+            $serveur
+        );
+
+        // lever un flag si cet auteur peut sauver les cles
+        if ($row['statut'] === '0minirezo' and $row['webmestre'] === 'oui' and isset($row['backup_cles'])) {
+            $auteur_peut_sauver_cles = true;
+        }
+    }
+
+    // login inexistant ou mot de passe vide
+    if (!$pass or !$row) {
+        return [];
+    }
+
+    include_spip('inc/chiffrer');
+    $cles = SpipCles::instance();
+    $secret = $cles->getSecretAuth();
+
+    $hash = null;
+    switch (strlen($row['pass'])) {
+
+        // legacy = md5 ou sha256
+        case 32:
+            // tres anciens mots de passe encodes en md5(alea.pass)
+            $hash = md5($row['alea_actuel'] . $pass);
+            $methode = 'md5';
+        case 64:
+            if (empty($hash)) {
+                // anciens mots de passe encodes en sha256(alea.pass)
+                include_spip('auth/sha256.inc');
+                $hash = spip_sha256($row['alea_actuel'] . $pass);
+                $methode = 'sha256';
+            }
+            if ($row['pass'] === $hash) {
+                spip_log("validation du mot de passe pour l'auteur #".$row['id_auteur']." $login via $methode", 'auth' . _LOG_DEBUG);
+                // ce n'est pas cense arriver, mais si jamais c'est un backup inutilisable, il faut le nettoyer pour ne pas bloquer la creation d'une nouvelle cle d'auth
+                if (!empty($row['backup_cles'])) {
+                    sql_updateq('spip_auteurs', ['backup_cles' => ''], 'id_auteur=' . intval($row['id_auteur']));
+                }
+                break;
+            }
+
+        // on teste la methode par defaut, au cas ou ce serait un pass moderne qui a la malchance d'etre en 64char de long
+
+        case 60:
+        case 98:
+        default:
+            // doit-on restaurer un backup des cles ?
+            // si on a le bon pass on peut decoder le backup, retrouver la cle, et du coup valider le pass
+            if (
+                !$secret
+                and $auteur_peut_sauver_cles
+                and !empty($row['backup_cles'])
+            ) {
+                if ($cles->restore($row['backup_cles'], $pass, $row['pass'], $row['id_auteur'])) {
+                    spip_log('Les cles secretes ont ete restaurées avec le backup du webmestre #' . $row['id_auteur'], 'auth' . _LOG_INFO_IMPORTANTE);
+                    if ($cles->save()) {
+                        $secret = $cles->getSecretAuth();
+                    }
+                    else {
+                        spip_log("Echec restauration des cles : verifier les droits d'ecriture ?", 'auth' . _LOG_ERREUR);
+                        // et on echoue car on ne veut pas que la situation reste telle quelle
+                        raler_fichier(_DIR_ETC . 'cles.php');
+                    }
+                }
+                else {
+                    spip_log('Pas de cle secrete disponible (fichier config/cle.php absent ?) mais le backup du webmestre #' . $row['id_auteur'] . " n'est pas valide", 'auth' . _LOG_ERREUR);
+                    sql_updateq('spip_auteurs', ['backup_cles' => ''], 'id_auteur=' . intval($row['id_auteur']));
+                }
+            }
+
+            if (!$secret or !Password::verifier($pass, $row['pass'], $secret)) {
+                unset($row);
+            }
+            else {
+                spip_log("validation du mot de passe pour l'auteur #".$row['id_auteur']." $login via Password::verifier", 'auth' . _LOG_DEBUG);
+            }
+            break;
+    }
+
+    // Migration depuis ancienne version : si on a pas encore de cle
+    // ET si c'est le login d'un auteur qui peut sauver la cle
+    // créer la clé (en s'assurant bien que personne n'a de backup d'un precedent fichier cle.php)
+    // si c'est un auteur normal, on ne fait rien, il garde son ancien pass hashé en sha256 en attendant le login d'un webmestre
+    if (!$secret and $auteur_peut_sauver_cles) {
+        if (auth_spip_initialiser_secret()) {
+            $secret = $cles->getSecretAuth();
+        }
+    }
+
+    // login/mot de passe incorrect
+    if (empty($row)) {
+        return [];
+    }
+
+    // fait tourner le codage du pass dans la base
+    // sauf si phpauth : cela reviendrait a changer l'alea a chaque hit, et aucune action verifiable par securiser_action()
+    if (!$phpauth and $secret) {
+        include_spip('inc/acces'); // pour creer_uniqid et verifier_htaccess
+        $pass_hash_next = Password::hacher($pass, $secret);
+        if ($pass_hash_next) {
+            $set = [
+                'alea_actuel' => 'alea_futur', // @deprecated 4.1
+                'alea_futur' => sql_quote(creer_uniqid(), $serveur, 'text'), // @deprecated 4.1
+                'pass' => sql_quote($pass_hash_next, $serveur, 'text'),
+            ];
+
+            // regenerer un htpass si on a active/desactive le plugin htpasswd
+            // et/ou que l'algo a change - pour etre certain de toujours utiliser le bon algo
+            $htpass = generer_htpass($pass);
+            if (strlen($htpass) !== strlen($row['htpass'])) {
+                $set['htpass'] = sql_quote($htpass, $serveur, 'text');
+            }
+
+            // a chaque login de webmestre : sauvegarde chiffree des clés du site (avec les pass du webmestre)
+            if ($auteur_peut_sauver_cles) {
+                $set['backup_cles'] = sql_quote($cles->backup($pass), $serveur, 'text');
+            }
+
+            @sql_update(
+                'spip_auteurs',
+                $set,
+                'id_auteur=' . intval($row['id_auteur']) . ' AND pass=' . sql_quote(
+                    $row['pass'],
+                    $serveur,
+                    'text'
+                ),
+                [],
+                $serveur
+            );
+
+            // si on a change le htpass car changement d'algo, regenerer les fichiers htpasswd
+            if (isset($set['htpass'])) {
+                ecrire_acces();
+            }
+        }
+
+        // En profiter pour verifier la securite de tmp/
+        // Si elle ne fonctionne pas a l'installation, prevenir
+        if (!verifier_htaccess(_DIR_TMP) and defined('_ECRIRE_INSTALL')) {
+            return false;
+        }
+    }
+
+    return $row;
 }
 
 /**
@@ -213,37 +213,37 @@ 
  * @return bool
  */
 function auth_spip_initialiser_secret(bool $force = false): bool {
-	include_spip('inc/chiffrer');
-	$cles = SpipCles::instance();
-	$secret = $cles->getSecretAuth();
-
-	// on ne fait rien si on a un secret dispo
-	if ($secret) {
-		return false;
-	}
-
-	// si force, on ne verifie pas la presence d'un backup chez un webmestre
-	if ($force) {
-		spip_log('Pas de cle secrete disponible, on regenere une nouvelle cle forcee - tous les mots de passe sont invalides', 'auth' . _LOG_INFO_IMPORTANTE);
-		$secret = $cles->getSecretAuth(true);
-		return true;
-	}
-
-	$has_backup = sql_allfetsel('id_auteur', 'spip_auteurs', 'statut=' . sql_quote('0minirezo') . ' AND webmestre=' . sql_quote('oui') . " AND backup_cles!=''");
-	$has_backup = array_column($has_backup, 'id_auteur');
-	if (empty($has_backup)) {
-		spip_log("Pas de cle secrete disponible, et aucun webmestre n'a de backup, on regenere une nouvelle cle - tous les mots de passe sont invalides", 'auth' . _LOG_INFO_IMPORTANTE);
-		if ($secret = $cles->getSecretAuth(true)) {
-			return true;
-		}
-		spip_log("Echec generation d'une nouvelle cle : verifier les droits d'ecriture ?", 'auth' . _LOG_ERREUR);
-		// et on echoue car on ne veut pas que la situation reste telle quelle
-		raler_fichier(_DIR_ETC . 'cles.php');
-	}
-	else {
-		spip_log('Pas de cle secrete disponible (fichier config/cle.php absent ?) un des webmestres #' . implode(', #', $has_backup) . ' doit se connecter pour restaurer son backup des cles', 'auth' . _LOG_ERREUR);
-	}
-	return false;
+    include_spip('inc/chiffrer');
+    $cles = SpipCles::instance();
+    $secret = $cles->getSecretAuth();
+
+    // on ne fait rien si on a un secret dispo
+    if ($secret) {
+        return false;
+    }
+
+    // si force, on ne verifie pas la presence d'un backup chez un webmestre
+    if ($force) {
+        spip_log('Pas de cle secrete disponible, on regenere une nouvelle cle forcee - tous les mots de passe sont invalides', 'auth' . _LOG_INFO_IMPORTANTE);
+        $secret = $cles->getSecretAuth(true);
+        return true;
+    }
+
+    $has_backup = sql_allfetsel('id_auteur', 'spip_auteurs', 'statut=' . sql_quote('0minirezo') . ' AND webmestre=' . sql_quote('oui') . " AND backup_cles!=''");
+    $has_backup = array_column($has_backup, 'id_auteur');
+    if (empty($has_backup)) {
+        spip_log("Pas de cle secrete disponible, et aucun webmestre n'a de backup, on regenere une nouvelle cle - tous les mots de passe sont invalides", 'auth' . _LOG_INFO_IMPORTANTE);
+        if ($secret = $cles->getSecretAuth(true)) {
+            return true;
+        }
+        spip_log("Echec generation d'une nouvelle cle : verifier les droits d'ecriture ?", 'auth' . _LOG_ERREUR);
+        // et on echoue car on ne veut pas que la situation reste telle quelle
+        raler_fichier(_DIR_ETC . 'cles.php');
+    }
+    else {
+        spip_log('Pas de cle secrete disponible (fichier config/cle.php absent ?) un des webmestres #' . implode(', #', $has_backup) . ' doit se connecter pour restaurer son backup des cles', 'auth' . _LOG_ERREUR);
+    }
+    return false;
 }
 
 /**
@@ -253,19 +253,19 @@ 
  * @return array
  */
 function auth_spip_formulaire_login($flux) {
-	// javascript qui gere la securite du login en evitant de faire circuler le pass en clair
-	$js = file_get_contents(find_in_path('prive/javascript/login.js'));
-	$flux['data'] .=
-		  '<script type="text/javascript">/*<![CDATA[*/'
-		. "$js\n"
-		. "var login_info={'login':'" . $flux['args']['contexte']['var_login'] . "',"
-		. "'page_auteur': '" . generer_url_public('informer_auteur') . "',"
-		. "'informe_auteur_en_cours':false,"
-		. "'attente_informe':0};"
-		. "jQuery(function(){jQuery('#var_login').change(actualise_auteur);});"
-		. '/*]]>*/</script>';
-
-	return $flux;
+    // javascript qui gere la securite du login en evitant de faire circuler le pass en clair
+    $js = file_get_contents(find_in_path('prive/javascript/login.js'));
+    $flux['data'] .=
+            '<script type="text/javascript">/*<![CDATA[*/'
+        . "$js\n"
+        . "var login_info={'login':'" . $flux['args']['contexte']['var_login'] . "',"
+        . "'page_auteur': '" . generer_url_public('informer_auteur') . "',"
+        . "'informe_auteur_en_cours':false,"
+        . "'attente_informe':0};"
+        . "jQuery(function(){jQuery('#var_login').change(actualise_auteur);});"
+        . '/*]]>*/</script>';
+
+    return $flux;
 }
 
 
@@ -277,11 +277,11 @@ 
  *   toujours true pour un auteur cree dans SPIP
  */
 function auth_spip_autoriser_modifier_login(string $serveur = ''): bool {
-	// les fonctions d'ecriture sur base distante sont encore incompletes
-	if (strlen($serveur)) {
-		return false;
-	}
-	return true;
+    // les fonctions d'ecriture sur base distante sont encore incompletes
+    if (strlen($serveur)) {
+        return false;
+    }
+    return true;
 }
 
 /**
@@ -295,25 +295,25 @@ 
  *  message d'erreur si login non valide, chaine vide sinon
  */
 function auth_spip_verifier_login($new_login, $id_auteur = 0, $serveur = '') {
-	// login et mot de passe
-	if (strlen($new_login)) {
-		if (strlen($new_login) < _LOGIN_TROP_COURT) {
-			return _T('info_login_trop_court_car_pluriel', ['nb' => _LOGIN_TROP_COURT]);
-		} else {
-			$n = sql_countsel(
-				'spip_auteurs',
-				'login=' . sql_quote($new_login) . ' AND id_auteur!=' . intval($id_auteur) . " AND statut!='5poubelle'",
-				'',
-				'',
-				$serveur
-			);
-			if ($n) {
-				return _T('info_login_existant');
-			}
-		}
-	}
-
-	return '';
+    // login et mot de passe
+    if (strlen($new_login)) {
+        if (strlen($new_login) < _LOGIN_TROP_COURT) {
+            return _T('info_login_trop_court_car_pluriel', ['nb' => _LOGIN_TROP_COURT]);
+        } else {
+            $n = sql_countsel(
+                'spip_auteurs',
+                'login=' . sql_quote($new_login) . ' AND id_auteur!=' . intval($id_auteur) . " AND statut!='5poubelle'",
+                '',
+                '',
+                $serveur
+            );
+            if ($n) {
+                return _T('info_login_existant');
+            }
+        }
+    }
+
+    return '';
 }
 
 /**
@@ -325,41 +325,41 @@ 
  * @return bool
  */
 function auth_spip_modifier_login($new_login, $id_auteur, $serveur = '') {
-	if (is_null($new_login) or auth_spip_verifier_login($new_login, $id_auteur, $serveur) != '') {
-		return false;
-	}
-	if (
-		!$id_auteur = intval($id_auteur)
-		or !$auteur = sql_fetsel('login', 'spip_auteurs', 'id_auteur=' . intval($id_auteur), '', '', '', '', $serveur)
-	) {
-		return false;
-	}
-	if ($new_login == $auteur['login']) {
-		return true;
-	} // on a rien fait mais c'est bon !
-
-	include_spip('action/editer_auteur');
-
-	// vider le login des auteurs a la poubelle qui avaient ce meme login
-	if (strlen($new_login)) {
-		$anciens = sql_allfetsel(
-			'id_auteur',
-			'spip_auteurs',
-			'login=' . sql_quote($new_login, $serveur, 'text') . " AND statut='5poubelle'",
-			'',
-			'',
-			'',
-			'',
-			$serveur
-		);
-		while ($row = array_pop($anciens)) {
-			auteur_modifier($row['id_auteur'], ['login' => ''], true); // manque la gestion de $serveur
-		}
-	}
-
-	auteur_modifier($id_auteur, ['login' => $new_login], true); // manque la gestion de $serveur
-
-	return true;
+    if (is_null($new_login) or auth_spip_verifier_login($new_login, $id_auteur, $serveur) != '') {
+        return false;
+    }
+    if (
+        !$id_auteur = intval($id_auteur)
+        or !$auteur = sql_fetsel('login', 'spip_auteurs', 'id_auteur=' . intval($id_auteur), '', '', '', '', $serveur)
+    ) {
+        return false;
+    }
+    if ($new_login == $auteur['login']) {
+        return true;
+    } // on a rien fait mais c'est bon !
+
+    include_spip('action/editer_auteur');
+
+    // vider le login des auteurs a la poubelle qui avaient ce meme login
+    if (strlen($new_login)) {
+        $anciens = sql_allfetsel(
+            'id_auteur',
+            'spip_auteurs',
+            'login=' . sql_quote($new_login, $serveur, 'text') . " AND statut='5poubelle'",
+            '',
+            '',
+            '',
+            '',
+            $serveur
+        );
+        while ($row = array_pop($anciens)) {
+            auteur_modifier($row['id_auteur'], ['login' => ''], true); // manque la gestion de $serveur
+        }
+    }
+
+    auteur_modifier($id_auteur, ['login' => $new_login], true); // manque la gestion de $serveur
+
+    return true;
 }
 
 /**
@@ -371,44 +371,44 @@ 
  * @return string
  */
 function auth_spip_retrouver_login($login, $serveur = '') {
-	if (!strlen($login)) {
-		return null;
-	} // pas la peine de requeter
-	$l = sql_quote($login, $serveur, 'text');
-	if (
-		$r = sql_getfetsel(
-			'login',
-			'spip_auteurs',
-			"statut<>'5poubelle'" .
-			' AND (length(pass)>0)' .
-			" AND (login=$l)",
-			'',
-			'',
-			'',
-			'',
-			$serveur
-		)
-	) {
-		return $r;
-	}
-	// Si pas d'auteur avec ce login
-	// regarder s'il a saisi son nom ou son mail.
-	// Ne pas fusionner avec la requete precedente
-	// car un nom peut etre homonyme d'un autre login
-	else {
-		return sql_getfetsel(
-			'login',
-			'spip_auteurs',
-			"statut<>'5poubelle'" .
-			' AND (length(pass)>0)' .
-			" AND (login<>'' AND (nom=$l OR email=$l))",
-			'',
-			'',
-			'',
-			'',
-			$serveur
-		);
-	}
+    if (!strlen($login)) {
+        return null;
+    } // pas la peine de requeter
+    $l = sql_quote($login, $serveur, 'text');
+    if (
+        $r = sql_getfetsel(
+            'login',
+            'spip_auteurs',
+            "statut<>'5poubelle'" .
+            ' AND (length(pass)>0)' .
+            " AND (login=$l)",
+            '',
+            '',
+            '',
+            '',
+            $serveur
+        )
+    ) {
+        return $r;
+    }
+    // Si pas d'auteur avec ce login
+    // regarder s'il a saisi son nom ou son mail.
+    // Ne pas fusionner avec la requete precedente
+    // car un nom peut etre homonyme d'un autre login
+    else {
+        return sql_getfetsel(
+            'login',
+            'spip_auteurs',
+            "statut<>'5poubelle'" .
+            ' AND (length(pass)>0)' .
+            " AND (login<>'' AND (nom=$l OR email=$l))",
+            '',
+            '',
+            '',
+            '',
+            $serveur
+        );
+    }
 }
 
 /**
@@ -419,11 +419,11 @@ 
  *  toujours true pour un auteur cree dans SPIP
  */
 function auth_spip_autoriser_modifier_pass(string $serveur = ''): bool {
-	// les fonctions d'ecriture sur base distante sont encore incompletes
-	if (strlen($serveur)) {
-		return false;
-	}
-	return true;
+    // les fonctions d'ecriture sur base distante sont encore incompletes
+    if (strlen($serveur)) {
+        return false;
+    }
+    return true;
 }
 
 
@@ -444,12 +444,12 @@ 
  *  message d'erreur si login non valide, chaine vide sinon
  */
 function auth_spip_verifier_pass($login, $new_pass, $id_auteur = 0, $serveur = '') {
-	// login et mot de passe
-	if (strlen($new_pass) < _PASS_LONGUEUR_MINI) {
-		return _T('info_passe_trop_court_car_pluriel', ['nb' => _PASS_LONGUEUR_MINI]);
-	}
+    // login et mot de passe
+    if (strlen($new_pass) < _PASS_LONGUEUR_MINI) {
+        return _T('info_passe_trop_court_car_pluriel', ['nb' => _PASS_LONGUEUR_MINI]);
+    }
 
-	return '';
+    return '';
 }
 
 /**
@@ -463,48 +463,48 @@ 
  * @return bool
  */
 function auth_spip_modifier_pass($login, $new_pass, $id_auteur, $serveur = '') {
-	if (is_null($new_pass) or auth_spip_verifier_pass($login, $new_pass, $id_auteur, $serveur) != '') {
-		return false;
-	}
-
-	if (
-		!$id_auteur = intval($id_auteur)
-		or !$auteur = sql_fetsel('login, statut, webmestre', 'spip_auteurs', 'id_auteur=' . intval($id_auteur), '', '', '', '', $serveur)
-	) {
-		return false;
-	}
-
-	include_spip('inc/chiffrer');
-	$cles = SpipCles::instance();
-	$secret = $cles->getSecretAuth();
-	if (!$secret) {
-		if (auth_spip_initialiser_secret()) {
-			$secret = $cles->getSecretAuth();
-		}
-		else {
-			return false;
-		}
-	}
-
-
-	include_spip('inc/acces');
-	$set = [
-		'pass' => Password::hacher($new_pass, $secret),
-		'htpass' => generer_htpass($new_pass),
-		'alea_actuel' => creer_uniqid(), // @deprecated 4.1
-		'alea_futur' => creer_uniqid(), // @deprecated 4.1
-		'low_sec' => '',
-	];
-
-	// si c'est un webmestre, on met a jour son backup des cles
-	if ($auteur['statut'] === '0minirezo' and $auteur['webmestre'] === 'oui') {
-		$set['backup_cles'] = $cles->backup($new_pass);
-	}
-
-	include_spip('action/editer_auteur');
-	auteur_modifier($id_auteur, $set, true); // manque la gestion de $serveur
-
-	return true; // on a bien modifie le pass
+    if (is_null($new_pass) or auth_spip_verifier_pass($login, $new_pass, $id_auteur, $serveur) != '') {
+        return false;
+    }
+
+    if (
+        !$id_auteur = intval($id_auteur)
+        or !$auteur = sql_fetsel('login, statut, webmestre', 'spip_auteurs', 'id_auteur=' . intval($id_auteur), '', '', '', '', $serveur)
+    ) {
+        return false;
+    }
+
+    include_spip('inc/chiffrer');
+    $cles = SpipCles::instance();
+    $secret = $cles->getSecretAuth();
+    if (!$secret) {
+        if (auth_spip_initialiser_secret()) {
+            $secret = $cles->getSecretAuth();
+        }
+        else {
+            return false;
+        }
+    }
+
+
+    include_spip('inc/acces');
+    $set = [
+        'pass' => Password::hacher($new_pass, $secret),
+        'htpass' => generer_htpass($new_pass),
+        'alea_actuel' => creer_uniqid(), // @deprecated 4.1
+        'alea_futur' => creer_uniqid(), // @deprecated 4.1
+        'low_sec' => '',
+    ];
+
+    // si c'est un webmestre, on met a jour son backup des cles
+    if ($auteur['statut'] === '0minirezo' and $auteur['webmestre'] === 'oui') {
+        $set['backup_cles'] = $cles->backup($new_pass);
+    }
+
+    include_spip('action/editer_auteur');
+    auteur_modifier($id_auteur, $set, true); // manque la gestion de $serveur
+
+    return true; // on a bien modifie le pass
 }
 
 /**
@@ -518,58 +518,58 @@ 
  * @return void
  */
 function auth_spip_synchroniser_distant($id_auteur, $champs, $options = [], string $serveur = ''): void {
-	// ne rien faire pour une base distante : on ne sait pas regenerer les htaccess
-	if (strlen($serveur)) {
-		return;
-	}
-	// si un login, pass ou statut a ete modifie
-	// regenerer les fichier htpass
-	if (
-		isset($champs['login'])
-		or isset($champs['pass'])
-		or isset($champs['statut'])
-		or (isset($options['all']) and $options['all'])
-	) {
-		$htaccess = _DIR_RESTREINT . _ACCESS_FILE_NAME;
-		$htpasswd = _DIR_TMP . _AUTH_USER_FILE;
-
-		// Cette variable de configuration peut etre posee par un plugin
-		// par exemple acces_restreint ;
-		// si .htaccess existe, outrepasser spip_meta
-		if (
-			(!isset($GLOBALS['meta']['creer_htpasswd']) or ($GLOBALS['meta']['creer_htpasswd'] != 'oui'))
-			and !@file_exists($htaccess)
-		) {
-			spip_unlink($htpasswd);
-			spip_unlink($htpasswd . '-admin');
-
-			return;
-		}
-
-		# remarque : ici on laisse passer les "nouveau" de maniere a leur permettre
-		# de devenir redacteur le cas echeant (auth http)... a nettoyer
-		// attention, il faut au prealable se connecter a la base (necessaire car utilise par install)
-
-		$p1 = ''; // login:htpass pour tous
-		$p2 = ''; // login:htpass pour les admins
-		$s = sql_select(
-			'login, htpass, statut',
-			'spip_auteurs',
-			sql_in('statut', ['1comite', '0minirezo', 'nouveau'])
-		);
-		while ($t = sql_fetch($s)) {
-			if (strlen($t['login']) and strlen($t['htpass'])) {
-				$p1 .= $t['login'] . ':' . $t['htpass'] . "\n";
-				if ($t['statut'] == '0minirezo') {
-					$p2 .= $t['login'] . ':' . $t['htpass'] . "\n";
-				}
-			}
-		}
-		sql_free($s);
-		if ($p1) {
-			ecrire_fichier($htpasswd, $p1);
-			ecrire_fichier($htpasswd . '-admin', $p2);
-			spip_log("Ecriture de $htpasswd et $htpasswd-admin");
-		}
-	}
+    // ne rien faire pour une base distante : on ne sait pas regenerer les htaccess
+    if (strlen($serveur)) {
+        return;
+    }
+    // si un login, pass ou statut a ete modifie
+    // regenerer les fichier htpass
+    if (
+        isset($champs['login'])
+        or isset($champs['pass'])
+        or isset($champs['statut'])
+        or (isset($options['all']) and $options['all'])
+    ) {
+        $htaccess = _DIR_RESTREINT . _ACCESS_FILE_NAME;
+        $htpasswd = _DIR_TMP . _AUTH_USER_FILE;
+
+        // Cette variable de configuration peut etre posee par un plugin
+        // par exemple acces_restreint ;
+        // si .htaccess existe, outrepasser spip_meta
+        if (
+            (!isset($GLOBALS['meta']['creer_htpasswd']) or ($GLOBALS['meta']['creer_htpasswd'] != 'oui'))
+            and !@file_exists($htaccess)
+        ) {
+            spip_unlink($htpasswd);
+            spip_unlink($htpasswd . '-admin');
+
+            return;
+        }
+
+        # remarque : ici on laisse passer les "nouveau" de maniere a leur permettre
+        # de devenir redacteur le cas echeant (auth http)... a nettoyer
+        // attention, il faut au prealable se connecter a la base (necessaire car utilise par install)
+
+        $p1 = ''; // login:htpass pour tous
+        $p2 = ''; // login:htpass pour les admins
+        $s = sql_select(
+            'login, htpass, statut',
+            'spip_auteurs',
+            sql_in('statut', ['1comite', '0minirezo', 'nouveau'])
+        );
+        while ($t = sql_fetch($s)) {
+            if (strlen($t['login']) and strlen($t['htpass'])) {
+                $p1 .= $t['login'] . ':' . $t['htpass'] . "\n";
+                if ($t['statut'] == '0minirezo') {
+                    $p2 .= $t['login'] . ':' . $t['htpass'] . "\n";
+                }
+            }
+        }
+        sql_free($s);
+        if ($p1) {
+            ecrire_fichier($htpasswd, $p1);
+            ecrire_fichier($htpasswd . '-admin', $p2);
+            spip_log("Ecriture de $htpasswd et $htpasswd-admin");
+        }
+    }
 }

Spacing +34 added lines, -34 removed lines

@@ -49,7 +49,7 @@ 
 		$row = sql_fetsel(
 			'*',
 			'spip_auteurs',
-			'login=' . sql_quote($login, $serveur, 'text') . " AND statut<>'5poubelle'",
+			'login='.sql_quote($login, $serveur, 'text')." AND statut<>'5poubelle'",
 			'',
 			'',
 			'',
@@ -78,20 +78,20 @@ 
 		// legacy = md5 ou sha256
 		case 32:
 			// tres anciens mots de passe encodes en md5(alea.pass)
-			$hash = md5($row['alea_actuel'] . $pass);
+			$hash = md5($row['alea_actuel'].$pass);
 			$methode = 'md5';
 		case 64:
 			if (empty($hash)) {
 				// anciens mots de passe encodes en sha256(alea.pass)
 				include_spip('auth/sha256.inc');
-				$hash = spip_sha256($row['alea_actuel'] . $pass);
+				$hash = spip_sha256($row['alea_actuel'].$pass);
 				$methode = 'sha256';
 			}
 			if ($row['pass'] === $hash) {
-				spip_log("validation du mot de passe pour l'auteur #".$row['id_auteur']." $login via $methode", 'auth' . _LOG_DEBUG);
+				spip_log("validation du mot de passe pour l'auteur #".$row['id_auteur']." $login via $methode", 'auth'._LOG_DEBUG);
 				// ce n'est pas cense arriver, mais si jamais c'est un backup inutilisable, il faut le nettoyer pour ne pas bloquer la creation d'une nouvelle cle d'auth
 				if (!empty($row['backup_cles'])) {
-					sql_updateq('spip_auteurs', ['backup_cles' => ''], 'id_auteur=' . intval($row['id_auteur']));
+					sql_updateq('spip_auteurs', ['backup_cles' => ''], 'id_auteur='.intval($row['id_auteur']));
 				}
 				break;
 			}
@@ -109,19 +109,19 @@ 
 				and !empty($row['backup_cles'])
 			) {
 				if ($cles->restore($row['backup_cles'], $pass, $row['pass'], $row['id_auteur'])) {
-					spip_log('Les cles secretes ont ete restaurées avec le backup du webmestre #' . $row['id_auteur'], 'auth' . _LOG_INFO_IMPORTANTE);
+					spip_log('Les cles secretes ont ete restaurées avec le backup du webmestre #'.$row['id_auteur'], 'auth'._LOG_INFO_IMPORTANTE);
 					if ($cles->save()) {
 						$secret = $cles->getSecretAuth();
 					}
 					else {
-						spip_log("Echec restauration des cles : verifier les droits d'ecriture ?", 'auth' . _LOG_ERREUR);
+						spip_log("Echec restauration des cles : verifier les droits d'ecriture ?", 'auth'._LOG_ERREUR);
 						// et on echoue car on ne veut pas que la situation reste telle quelle
-						raler_fichier(_DIR_ETC . 'cles.php');
+						raler_fichier(_DIR_ETC.'cles.php');
 					}
 				}
 				else {
-					spip_log('Pas de cle secrete disponible (fichier config/cle.php absent ?) mais le backup du webmestre #' . $row['id_auteur'] . " n'est pas valide", 'auth' . _LOG_ERREUR);
-					sql_updateq('spip_auteurs', ['backup_cles' => ''], 'id_auteur=' . intval($row['id_auteur']));
+					spip_log('Pas de cle secrete disponible (fichier config/cle.php absent ?) mais le backup du webmestre #'.$row['id_auteur']." n'est pas valide", 'auth'._LOG_ERREUR);
+					sql_updateq('spip_auteurs', ['backup_cles' => ''], 'id_auteur='.intval($row['id_auteur']));
 				}
 			}
 
@@ -129,7 +129,7 @@ 
 				unset($row);
 			}
 			else {
-				spip_log("validation du mot de passe pour l'auteur #".$row['id_auteur']." $login via Password::verifier", 'auth' . _LOG_DEBUG);
+				spip_log("validation du mot de passe pour l'auteur #".$row['id_auteur']." $login via Password::verifier", 'auth'._LOG_DEBUG);
 			}
 			break;
 	}
@@ -176,7 +176,7 @@ 
 			@sql_update(
 				'spip_auteurs',
 				$set,
-				'id_auteur=' . intval($row['id_auteur']) . ' AND pass=' . sql_quote(
+				'id_auteur='.intval($row['id_auteur']).' AND pass='.sql_quote(
 					$row['pass'],
 					$serveur,
 					'text'
@@ -224,24 +224,24 @@ 
 
 	// si force, on ne verifie pas la presence d'un backup chez un webmestre
 	if ($force) {
-		spip_log('Pas de cle secrete disponible, on regenere une nouvelle cle forcee - tous les mots de passe sont invalides', 'auth' . _LOG_INFO_IMPORTANTE);
+		spip_log('Pas de cle secrete disponible, on regenere une nouvelle cle forcee - tous les mots de passe sont invalides', 'auth'._LOG_INFO_IMPORTANTE);
 		$secret = $cles->getSecretAuth(true);
 		return true;
 	}
 
-	$has_backup = sql_allfetsel('id_auteur', 'spip_auteurs', 'statut=' . sql_quote('0minirezo') . ' AND webmestre=' . sql_quote('oui') . " AND backup_cles!=''");
+	$has_backup = sql_allfetsel('id_auteur', 'spip_auteurs', 'statut='.sql_quote('0minirezo').' AND webmestre='.sql_quote('oui')." AND backup_cles!=''");
 	$has_backup = array_column($has_backup, 'id_auteur');
 	if (empty($has_backup)) {
-		spip_log("Pas de cle secrete disponible, et aucun webmestre n'a de backup, on regenere une nouvelle cle - tous les mots de passe sont invalides", 'auth' . _LOG_INFO_IMPORTANTE);
+		spip_log("Pas de cle secrete disponible, et aucun webmestre n'a de backup, on regenere une nouvelle cle - tous les mots de passe sont invalides", 'auth'._LOG_INFO_IMPORTANTE);
 		if ($secret = $cles->getSecretAuth(true)) {
 			return true;
 		}
-		spip_log("Echec generation d'une nouvelle cle : verifier les droits d'ecriture ?", 'auth' . _LOG_ERREUR);
+		spip_log("Echec generation d'une nouvelle cle : verifier les droits d'ecriture ?", 'auth'._LOG_ERREUR);
 		// et on echoue car on ne veut pas que la situation reste telle quelle
-		raler_fichier(_DIR_ETC . 'cles.php');
+		raler_fichier(_DIR_ETC.'cles.php');
 	}
 	else {
-		spip_log('Pas de cle secrete disponible (fichier config/cle.php absent ?) un des webmestres #' . implode(', #', $has_backup) . ' doit se connecter pour restaurer son backup des cles', 'auth' . _LOG_ERREUR);
+		spip_log('Pas de cle secrete disponible (fichier config/cle.php absent ?) un des webmestres #'.implode(', #', $has_backup).' doit se connecter pour restaurer son backup des cles', 'auth'._LOG_ERREUR);
 	}
 	return false;
 }
@@ -258,8 +258,8 @@ 
 	$flux['data'] .=
 		  '<script type="text/javascript">/*<![CDATA[*/'
 		. "$js\n"
-		. "var login_info={'login':'" . $flux['args']['contexte']['var_login'] . "',"
-		. "'page_auteur': '" . generer_url_public('informer_auteur') . "',"
+		. "var login_info={'login':'".$flux['args']['contexte']['var_login']."',"
+		. "'page_auteur': '".generer_url_public('informer_auteur')."',"
 		. "'informe_auteur_en_cours':false,"
 		. "'attente_informe':0};"
 		. "jQuery(function(){jQuery('#var_login').change(actualise_auteur);});"
@@ -302,7 +302,7 @@ 
 		} else {
 			$n = sql_countsel(
 				'spip_auteurs',
-				'login=' . sql_quote($new_login) . ' AND id_auteur!=' . intval($id_auteur) . " AND statut!='5poubelle'",
+				'login='.sql_quote($new_login).' AND id_auteur!='.intval($id_auteur)." AND statut!='5poubelle'",
 				'',
 				'',
 				$serveur
@@ -330,7 +330,7 @@ 
 	}
 	if (
 		!$id_auteur = intval($id_auteur)
-		or !$auteur = sql_fetsel('login', 'spip_auteurs', 'id_auteur=' . intval($id_auteur), '', '', '', '', $serveur)
+		or !$auteur = sql_fetsel('login', 'spip_auteurs', 'id_auteur='.intval($id_auteur), '', '', '', '', $serveur)
 	) {
 		return false;
 	}
@@ -345,7 +345,7 @@ 
 		$anciens = sql_allfetsel(
 			'id_auteur',
 			'spip_auteurs',
-			'login=' . sql_quote($new_login, $serveur, 'text') . " AND statut='5poubelle'",
+			'login='.sql_quote($new_login, $serveur, 'text')." AND statut='5poubelle'",
 			'',
 			'',
 			'',
@@ -379,8 +379,8 @@ 
 		$r = sql_getfetsel(
 			'login',
 			'spip_auteurs',
-			"statut<>'5poubelle'" .
-			' AND (length(pass)>0)' .
+			"statut<>'5poubelle'".
+			' AND (length(pass)>0)'.
 			" AND (login=$l)",
 			'',
 			'',
@@ -399,8 +399,8 @@ 
 		return sql_getfetsel(
 			'login',
 			'spip_auteurs',
-			"statut<>'5poubelle'" .
-			' AND (length(pass)>0)' .
+			"statut<>'5poubelle'".
+			' AND (length(pass)>0)'.
 			" AND (login<>'' AND (nom=$l OR email=$l))",
 			'',
 			'',
@@ -469,7 +469,7 @@ 
 
 	if (
 		!$id_auteur = intval($id_auteur)
-		or !$auteur = sql_fetsel('login, statut, webmestre', 'spip_auteurs', 'id_auteur=' . intval($id_auteur), '', '', '', '', $serveur)
+		or !$auteur = sql_fetsel('login, statut, webmestre', 'spip_auteurs', 'id_auteur='.intval($id_auteur), '', '', '', '', $serveur)
 	) {
 		return false;
 	}
@@ -530,8 +530,8 @@ 
 		or isset($champs['statut'])
 		or (isset($options['all']) and $options['all'])
 	) {
-		$htaccess = _DIR_RESTREINT . _ACCESS_FILE_NAME;
-		$htpasswd = _DIR_TMP . _AUTH_USER_FILE;
+		$htaccess = _DIR_RESTREINT._ACCESS_FILE_NAME;
+		$htpasswd = _DIR_TMP._AUTH_USER_FILE;
 
 		// Cette variable de configuration peut etre posee par un plugin
 		// par exemple acces_restreint ;
@@ -541,7 +541,7 @@ 
 			and !@file_exists($htaccess)
 		) {
 			spip_unlink($htpasswd);
-			spip_unlink($htpasswd . '-admin');
+			spip_unlink($htpasswd.'-admin');
 
 			return;
 		}
@@ -559,16 +559,16 @@ 
 		);
 		while ($t = sql_fetch($s)) {
 			if (strlen($t['login']) and strlen($t['htpass'])) {
-				$p1 .= $t['login'] . ':' . $t['htpass'] . "\n";
+				$p1 .= $t['login'].':'.$t['htpass']."\n";
 				if ($t['statut'] == '0minirezo') {
-					$p2 .= $t['login'] . ':' . $t['htpass'] . "\n";
+					$p2 .= $t['login'].':'.$t['htpass']."\n";
 				}
 			}
 		}
 		sql_free($s);
 		if ($p1) {
 			ecrire_fichier($htpasswd, $p1);
-			ecrire_fichier($htpasswd . '-admin', $p2);
+			ecrire_fichier($htpasswd.'-admin', $p2);
 			spip_log("Ecriture de $htpasswd et $htpasswd-admin");
 		}
 	}

Braces +5 added lines, -10 removed lines

@@ -112,14 +112,12 @@ 
 					spip_log('Les cles secretes ont ete restaurées avec le backup du webmestre #' . $row['id_auteur'], 'auth' . _LOG_INFO_IMPORTANTE);
 					if ($cles->save()) {
 						$secret = $cles->getSecretAuth();
-					}
-					else {
+					} else {
 						spip_log("Echec restauration des cles : verifier les droits d'ecriture ?", 'auth' . _LOG_ERREUR);
 						// et on echoue car on ne veut pas que la situation reste telle quelle
 						raler_fichier(_DIR_ETC . 'cles.php');
 					}
-				}
-				else {
+				} else {
 					spip_log('Pas de cle secrete disponible (fichier config/cle.php absent ?) mais le backup du webmestre #' . $row['id_auteur'] . " n'est pas valide", 'auth' . _LOG_ERREUR);
 					sql_updateq('spip_auteurs', ['backup_cles' => ''], 'id_auteur=' . intval($row['id_auteur']));
 				}
@@ -127,8 +125,7 @@ 
 
 			if (!$secret or !Password::verifier($pass, $row['pass'], $secret)) {
 				unset($row);
-			}
-			else {
+			} else {
 				spip_log("validation du mot de passe pour l'auteur #".$row['id_auteur']." $login via Password::verifier", 'auth' . _LOG_DEBUG);
 			}
 			break;
@@ -239,8 +236,7 @@ 
 		spip_log("Echec generation d'une nouvelle cle : verifier les droits d'ecriture ?", 'auth' . _LOG_ERREUR);
 		// et on echoue car on ne veut pas que la situation reste telle quelle
 		raler_fichier(_DIR_ETC . 'cles.php');
-	}
-	else {
+	} else {
 		spip_log('Pas de cle secrete disponible (fichier config/cle.php absent ?) un des webmestres #' . implode(', #', $has_backup) . ' doit se connecter pour restaurer son backup des cles', 'auth' . _LOG_ERREUR);
 	}
 	return false;
@@ -480,8 +476,7 @@ 
 	if (!$secret) {
 		if (auth_spip_initialiser_secret()) {
 			$secret = $cles->getSecretAuth();
-		}
-		else {
+		} else {
 			return false;
 		}
 	}

ecrire/src/Chiffrer/Chiffrement.php

Indentation +70 added lines, -70 removed lines

@@ -19,78 +19,78 @@
  * @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_log("chiffrer($message)=$encoded", 'chiffrer' . _LOG_DEBUG);
-		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_log("chiffrer($message)=$encoded", 'chiffrer' . _LOG_DEBUG);
+        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_log("dechiffrer() chiffre corrompu `$encoded`", 'chiffrer' . _LOG_DEBUG);
-			return null;
-		}
-		$message = sodium_unpad($padded_message, 16);
-		#spip_log("dechiffrer($encoded)=$message", 'chiffrer' . _LOG_DEBUG);
-		return $message;
-	}
+    /** 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_log("dechiffrer() chiffre corrompu `$encoded`", 'chiffrer' . _LOG_DEBUG);
+            return null;
+        }
+        $message = sodium_unpad($padded_message, 16);
+        #spip_log("dechiffrer($encoded)=$message", 'chiffrer' . _LOG_DEBUG);
+        return $message;
+    }
 
-	/** 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;
+    }
 }

Spacing +3 added lines, -3 removed lines

@@ -31,7 +31,7 @@ 
 		$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);
+		$encoded = base64_encode($salt.$nonce.$encrypted);
 		sodium_memzero($key);
 		sodium_memzero($nonce);
 		sodium_memzero($salt);
@@ -48,14 +48,14 @@ 
 		$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);
+		$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_log("dechiffrer() chiffre corrompu `$encoded`", 'chiffrer' . _LOG_DEBUG);
+			spip_log("dechiffrer() chiffre corrompu `$encoded`", 'chiffrer'._LOG_DEBUG);
 			return null;
 		}
 		$message = sodium_unpad($padded_message, 16);

ecrire/src/Chiffrer/SpipCles.php

Indentation +167 added lines, -167 removed lines

@@ -14,171 +14,171 @@
 
 /** Gestion des clés d’authentification / chiffrement de SPIP */
 final class SpipCles {
-	private static array $instances = [];
-
-	private string $file = _DIR_ETC . 'cles.php';
-	private 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)
-	 *
-	 * @param string $backup Sauvegarde chiffrée (générée par backup())
-	 * @param int $id_auteur
-	 * @param string $pass
-	 * @return void
-	 */
-	public function restore(
-		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);
-		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'])) {
-			if (!Password::verifier($password_clair, $password_hash, $cles_potentielles['secret_des_auth'])) {
-				spip_log("Restauration de la cle `secret_des_auth` par id_auteur $id_auteur erronnee, on ignore", 'chiffrer' . _LOG_INFO_IMPORTANTE);
-				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_log("Restauration de la cle $name par id_auteur $id_auteur", 'chiffrer' . _LOG_INFO_IMPORTANTE);
-				$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_log("Echec ecriture du fichier cle ".$this->file." ; impossible de generer une cle $name", 'chiffrer' . _LOG_ERREUR);
-			$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 {
-		lire_fichier_securise($this->file, $json);
-		if (
-			$json
-			and $json = \json_decode($json, true)
-			and is_array($json)
-		) {
-			return array_map('base64_decode', $json);
-		}
-		return [];
-	}
+    private static array $instances = [];
+
+    private string $file = _DIR_ETC . 'cles.php';
+    private 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)
+     *
+     * @param string $backup Sauvegarde chiffrée (générée par backup())
+     * @param int $id_auteur
+     * @param string $pass
+     * @return void
+     */
+    public function restore(
+        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);
+        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'])) {
+            if (!Password::verifier($password_clair, $password_hash, $cles_potentielles['secret_des_auth'])) {
+                spip_log("Restauration de la cle `secret_des_auth` par id_auteur $id_auteur erronnee, on ignore", 'chiffrer' . _LOG_INFO_IMPORTANTE);
+                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_log("Restauration de la cle $name par id_auteur $id_auteur", 'chiffrer' . _LOG_INFO_IMPORTANTE);
+                $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_log("Echec ecriture du fichier cle ".$this->file." ; impossible de generer une cle $name", 'chiffrer' . _LOG_ERREUR);
+            $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 {
+        lire_fichier_securise($this->file, $json);
+        if (
+            $json
+            and $json = \json_decode($json, true)
+            and is_array($json)
+        ) {
+            return array_map('base64_decode', $json);
+        }
+        return [];
+    }
 }

Spacing +5 added lines, -5 removed lines

@@ -16,7 +16,7 @@ 
 final class SpipCles {
 	private static array $instances = [];
 
-	private string $file = _DIR_ETC . 'cles.php';
+	private string $file = _DIR_ETC.'cles.php';
 	private Cles $cles;
 
 	public static function instance(string $file = ''): self {
@@ -117,7 +117,7 @@ 
 		// et par extension tous les passwords
 		if (!empty($cles_potentielles['secret_des_auth'])) {
 			if (!Password::verifier($password_clair, $password_hash, $cles_potentielles['secret_des_auth'])) {
-				spip_log("Restauration de la cle `secret_des_auth` par id_auteur $id_auteur erronnee, on ignore", 'chiffrer' . _LOG_INFO_IMPORTANTE);
+				spip_log("Restauration de la cle `secret_des_auth` par id_auteur $id_auteur erronnee, on ignore", 'chiffrer'._LOG_INFO_IMPORTANTE);
 				unset($cles_potentielles['secret_des_auth']);
 			}
 		}
@@ -127,7 +127,7 @@ 
 		foreach ($cles_potentielles as $name => $key) {
 			if (!$this->cles->has($name)) {
 				$this->cles->set($name, $key);
-				spip_log("Restauration de la cle $name par id_auteur $id_auteur", 'chiffrer' . _LOG_INFO_IMPORTANTE);
+				spip_log("Restauration de la cle $name par id_auteur $id_auteur", 'chiffrer'._LOG_INFO_IMPORTANTE);
 				$restauration = true;
 			}
 		}
@@ -145,7 +145,7 @@ 
 				return $this->cles->get($name);
 			}
 			// sinon loger et annule la cle generee car il ne faut pas l'utiliser
-			spip_log("Echec ecriture du fichier cle ".$this->file." ; impossible de generer une cle $name", 'chiffrer' . _LOG_ERREUR);
+			spip_log("Echec ecriture du fichier cle ".$this->file." ; impossible de generer une cle $name", 'chiffrer'._LOG_ERREUR);
 			$this->cles->delete($name);
 		}
 		return null;
@@ -154,7 +154,7 @@ 
 	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'));
+			$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) {

ecrire/src/Chiffrer/Cles.php

Indentation +44 added lines, -44 removed lines

@@ -14,48 +14,48 @@
 
 /** Conteneur de clés (chiffrement, authentification) */
 class Cles implements \Countable /* , ContainerInterface */ {
-	private array $keys;
-	public function __construct(array $keys) {
-		$this->keys = $keys;
-	}
-
-	public function has(string $name): bool {
-		return array_key_exists($name, $this->keys);
-	}
-
-	public function get(string $name): ?string {
-		return $this->keys[$name] ?? null;
-	}
-
-	public function generate(string $name): string {
-		$key = Chiffrement::keygen();
-		$this->keys[$name] = $key;
-		spip_log("Création de la cle $name", 'chiffrer' . _LOG_INFO_IMPORTANTE);
-		return $key;
-	}
-
-	public function set(
-		string $name,
-		#[\SensitiveParameter]
-		string $key
-	): void {
-		$this->keys[$name] = $key;
-	}
-
-	public function delete(string $name): bool {
-		if (isset($this->keys[$name])) {
-			unset($this->keys[$name]);
-			return true;
-		};
-		return false;
-	}
-
-	public function count(): int {
-		return count($this->keys);
-	}
-
-	public function toJson(): string {
-		$json = array_map('base64_encode', $this->keys);
-		return \json_encode($json);
-	}
+    private array $keys;
+    public function __construct(array $keys) {
+        $this->keys = $keys;
+    }
+
+    public function has(string $name): bool {
+        return array_key_exists($name, $this->keys);
+    }
+
+    public function get(string $name): ?string {
+        return $this->keys[$name] ?? null;
+    }
+
+    public function generate(string $name): string {
+        $key = Chiffrement::keygen();
+        $this->keys[$name] = $key;
+        spip_log("Création de la cle $name", 'chiffrer' . _LOG_INFO_IMPORTANTE);
+        return $key;
+    }
+
+    public function set(
+        string $name,
+        #[\SensitiveParameter]
+        string $key
+    ): void {
+        $this->keys[$name] = $key;
+    }
+
+    public function delete(string $name): bool {
+        if (isset($this->keys[$name])) {
+            unset($this->keys[$name]);
+            return true;
+        };
+        return false;
+    }
+
+    public function count(): int {
+        return count($this->keys);
+    }
+
+    public function toJson(): string {
+        $json = array_map('base64_encode', $this->keys);
+        return \json_encode($json);
+    }
 }