On pouvait entrer sans mot de passe, jamais en poser un neuf

  return (await sql.begin(async (tx) => {

    const { jeton, session } = await sessions.ouvrir(tx, compte.id, {

      agent: ctx.agent ?? null, ip: ctx.ip ?? null, secondFacteurFait: false,

      ouvertePar: moyen,

    });

    await tx`update compte set derniere_connexion_at = now() where id = ${compte.id}`;

    await journaliser(tx, {

 * volée dans la fenêtre d'installation suffirait à s'approprier le compte qui

 * va devenir root.

 */

/**

 * Changer son mot de passe, y compris quand on l'a oublié (EF-103).

 *

 * L'ancien est exigé — sauf dans deux cas où personne ne peut le connaître, et

 * où l'exiger ne protégerait rien.

 *

 *   Un compte amorcé par lien n'en a jamais reçu : sa session vient d'un jeton

 *   à usage unique envoyé à son adresse.

 *

 *   Un compte dont le titulaire a oublié le sien s'est reconnecté par ce même

 *   lien. C'était la boucle fermée du produit : on pouvait entrer sans mot de

 *   passe, et rien ne permettait d'en poser un neuf. La mire proposait bien

 *   « recevoir un lien », mais cela ne menait qu'à une session — pas à une

 *   sortie.

 *

 * Dans les deux cas la preuve est la même, et c'est celle de toute

 * réinitialisation : l'accès à la boîte. Le second facteur reste exigé quand il

 * est actif — un courriel ne prouve pas la possession du téléphone.

 */

export async function changerMotDePasse(

  sql: Sql, compteId: string, ancien: string | null, neuf: string,

  sessionId?: string,

): Promise<void> {

  const [compte] = await sql<{ mdp_hash: string | null; mdp_a_changer: boolean }[]>`

    select mdp_hash, mdp_a_changer from compte where id = ${compteId}`;

    throw new ErreurAuth("operation_refusee", "Douze caractères au moins.");

  }

  // L'ancien mot de passe est exigé — sauf quand il n'y en a pas à connaître.

  // Un compte amorcé par lien n'en a jamais reçu : sa session vient d'un jeton

  // à usage unique envoyé à son adresse, ce qui est la même preuve qu'une

  // réinitialisation. Exiger un secret que personne ne détient n'ajouterait pas

  // de sécurité, seulement une impasse.

  if (!compte.mdp_a_changer) {

  // La session vient-elle d'un lien reçu par courriel ? C'est la preuve d'une

  // réinitialisation, et elle vaut l'ancien mot de passe — que le titulaire ne

  // connaît, par hypothèse, pas.

  let parLien = false;

  if (sessionId) {

    const [s] = await sql<{ ouverte_par: string | null }[]>`

      select ouverte_par from session where id = ${sessionId}`;

    parLien = s?.ouverte_par === "lien_usage_unique";

  }

  // L'ancien est exigé — sauf quand il n'y en a pas à connaître. Exiger un

  // secret que personne ne détient n'ajouterait pas de sécurité, seulement une

  // impasse.

  if (!compte.mdp_a_changer && !parLien) {

    if (ancien === null || !await mdp.verifier(ancien, compte.mdp_hash ?? null)) {

      throw new ErreurAuth("identifiants_invalides", "Mot de passe actuel incorrect.");

    }

  expire_at: Date;

  dernier_acces_at: Date;

  agent: string | null;

  /** « mot_de_passe » ou « lien_usage_unique ». Nul avant que la colonne existe. */

  ouverte_par: string | null;

}

export interface Contexte {

  ip?: string | null;

  /** Vrai quand le moyen de connexion vaut à lui seul second facteur. */

  secondFacteurFait?: boolean;

  /**

   * Par quel moyen la session s'ouvre.

   *

   * Retenu sur la session et pas seulement au journal : c'est au moment de

   * changer de mot de passe qu'on en a besoin, et le journal ne se relit pas

   * pour décider d'une requête.

   */

  ouvertePar?: "mot_de_passe" | "lien_usage_unique" | null;

  /**

   * L'heure à laquelle le second facteur a réellement été présenté, quand elle

   * n'est pas maintenant.

  const maintenant = new Date();

  const [ligne] = await tx<Session[]>`

    insert into session (compte_id, empreinte, auth_at, second_facteur_at,

                         expire_at, dernier_acces_at, agent, ip, via_passage)

                         expire_at, dernier_acces_at, agent, ip, via_passage,

                         ouverte_par)

    values (${compteId}, ${empreinte(jeton)}, ${maintenant},

            ${ctx.secondFacteurAt ?? (ctx.secondFacteurFait ? maintenant : null)},

            ${new Date(maintenant.getTime() + ABSOLUE_MS)}, ${maintenant},

            ${ctx.agent ?? null}, ${ctx.ip ?? null}, ${ctx.viaPassage ?? false})

            ${ctx.agent ?? null}, ${ctx.ip ?? null}, ${ctx.viaPassage ?? false},

            ${ctx.ouvertePar ?? null})

    returning id, compte_id, auth_at, second_facteur_at, expire_at, dernier_acces_at, agent,

              via_passage`;

              via_passage, ouverte_par`;

  if (!ligne) throw new Error("Ouverture de session refusée.");

  return { jeton, session: ligne };

}

       and s.dernier_acces_at > now() - ${`${INACTIVITE_MS / 1000} seconds`}::interval

       and c.desactive_at is null

    returning s.id, s.compte_id, s.auth_at, s.second_facteur_at, s.expire_at,

              s.dernier_acces_at, s.agent, s.via_passage,

              s.dernier_acces_at, s.agent, s.via_passage, s.ouverte_par,

              c.email, c.nom, c.email_verifie, c.desactive_at, c.totp_actif_at`;

  if (!ligne) return null;

      id: ligne.id, compte_id: ligne.compte_id, auth_at: ligne.auth_at,

      second_facteur_at: ligne.second_facteur_at, expire_at: ligne.expire_at,

      dernier_acces_at: ligne.dernier_acces_at, agent: ligne.agent,

      via_passage: ligne.via_passage,

      via_passage: ligne.via_passage, ouverte_par: ligne.ouverte_par,

    },

    compte: {

      id: ligne.compte_id, email: ligne.email, nom: ligne.nom,

-- ═══════════════════════════════════════════════════════════════════════════

-- Par quel moyen une session a été ouverte (EF-103).

--

-- Le journal le retenait déjà — « compte.connecte » porte son moyen — mais la

-- session, non. Or c'est d'elle qu'on a besoin au moment de changer de mot de

-- passe : un compte dont le titulaire a oublié le sien n'avait aucun chemin.

--

--   Le lien à usage unique ouvre bien une session, et prouve l'accès à la

--   boîte — la preuve même sur laquelle repose toute réinitialisation.

--

--   Mais « changerMotDePasse » exige l'ancien, qu'on ne connaît précisément

--   pas. La boucle était fermée : on entrait, sans pouvoir rien changer.

--

-- Le second facteur reste exigé quand il est actif : un lien reçu par courriel

-- prouve l'accès à la boîte, pas la possession du téléphone.

-- ═══════════════════════════════════════════════════════════════════════════

alter table session add column if not exists ouverte_par text;

comment on column session.ouverte_par is

  'EF-103 : « mot_de_passe » ou « lien_usage_unique ». Nul pour les sessions '

  'ouvertes avant que la colonne existe.';

      ancien: z.string().min(1).nullish(), nouveau: z.string().min(12).max(200),

    }).parse(req.body);

    const auth = req.auth!;

    await comptes.changerMotDePasse(sql, auth.compte.id, c.ancien ?? null, c.nouveau);

    await comptes.changerMotDePasse(sql, auth.compte.id, c.ancien ?? null, c.nouveau,

      auth.session.id);

    // En production, le droit root est accordé à l'activation du second

    // facteur, et cet appel ne fait rien : l'amorce n'est pas encore achevée.

    // En mode test, où le second facteur n'est plus exigé, le remplacement du

        id: auth.session.id,

        complete: auth.complete,

        fraicheurAdmin: sessions.fraicheurAdmin(auth),

        // L'écran a besoin de savoir s'il doit demander l'ancien mot de passe :

        // qui vient d'un lien ne le connaît pas, et le champ serait une impasse.

        parLien: auth.session.ouverte_par === "lien_usage_unique",

      },

      organisations,

      amorce: etatAmorce,

    await r.refuse("EF-103", "le lien ne fonctionne pas une seconde fois",

      () => comptes.consommerLienConnexion(sql, jetonLien!), "jeton_invalide");

    // ── Le mot de passe oublié (EF-103) ──────────────────────────────────

    //

    // La boucle était fermée : la mire proposait bien un lien, il ouvrait bien

    // une session — et « changerMotDePasse » exigeait l'ancien, que le

    // titulaire ne connaît par hypothèse pas. On entrait sans pouvoir sortir,

    // et aucun écran ne portait même de formulaire.

    //

    // La preuve est celle de toute réinitialisation : l'accès à la boîte. Elle

    // vaut l'ancien mot de passe, et rien de plus — le second facteur reste

    // exigé, un courriel ne prouvant pas la possession du téléphone.

    const neufMdp = "phare-du-creach-1884";

    await r.refuse("EF-103", "sur une session ouverte au mot de passe, l'ancien reste exigé",

      () => comptes.changerMotDePasse(sql, inscription.compteId, null, neufMdp,

        ouverture.sessionId), "identifiants_invalides");

    await comptes.changerMotDePasse(sql, inscription.compteId, null, neufMdp,

      parLien.sessionId);

    r.verifie("EF-103", "sur une session ouverte par lien, il ne l'est plus",

      (await comptes.connecterParMotDePasse(sql,

        { email, motDePasse: neufMdp })).sessionId.length > 0);

    await r.refuse("EF-103", "et l'ancien mot de passe ne connecte plus",

      () => comptes.connecterParMotDePasse(sql,

        { email, motDePasse: "houle-atlantique-38" }),

      "identifiants_invalides");

    // La session retient son moyen : sans cela, rien ne distingue les deux cas.

    const [ouvertePar] = await sql<{ ouverte_par: string | null }[]>`

      select ouverte_par from session where id = ${parLien.sessionId}`;

    r.verifie("EF-103", "la session retient par quel moyen elle a été ouverte",

      ouvertePar?.ouverte_par === "lien_usage_unique");

    vider();

    await comptes.demanderLienConnexion(sql, adresse("fantome"), URL_TEST);

    r.verifie("EF-106", "aucun message n'est émis pour une adresse inconnue, sans le dire",