L'authentification Secrecy

Secrecy auth est le service qui fournit à votre application un client Secrecy authentifié. L'utilisateur se connecte via le SSO Secrecy, et votre application récupère un SecrecyClient prêt à l'emploi. Vous ne stockez jamais de mot de passe et vous ne voyez jamais la clé maître de l'utilisateur : la page de connexion Secrecy déverrouille les clés d'identité de l'utilisateur, et seules ces clés sont chargées sur l'appareil de l'utilisateur à la connexion, tout ce qui suit peut donc chiffrer et déchiffrer localement.

Comment fonctionne Secrecy auth ?

L'authentification a lieu sur la page d'authentification hébergée par Secrecy. La fonction login y envoie l'utilisateur par une redirection de la page entière, et rapporte une session, un JWT et les paires de clés de l'utilisateur.

Secrecy étant un fournisseur d'authentification unique, l'utilisateur s'authentifie une seule fois avec une identité de confiance unique et aucun nouveau mot de passe n'a à être stocké par votre application.

Gérer l'authentification

Une fois l'utilisateur connecté, la session est conservée dans le navigateur. Un rechargement de page ne nécessite pas une nouvelle connexion : getSecrecyClient reconstruit le client à partir des identifiants stockés. La session peut être terminée à tout moment avec la méthode logout, qui efface également les clés stockées localement.

Tout dans le SDK Secrecy commence par un client authentifié. Cette page montre comment en obtenir un, et les options acceptées par les deux points d'entrée.

Connecter l'utilisateur

La fonction login ouvre le SSO Secrecy, persiste la session et les clés retournées, et résout un client prêt à l'emploi. La page est quittée avant que la promesse ne soit résolue.

import {
  getSecrecyClient,
  login,
  type SecrecyClient,
  setup,
} from '@secrecy/lib';
 
const loginUser = async (): Promise<SecrecyClient | null> => {
  try {
    const client = await login({
      appId: '<YOUR_APP_ID>',
      // champs optionnels :
      scopes: { email: true },
      path: window.location.pathname,
      backPath: document.referrer,
      redirect: true,
    });
 
    return client;
  } catch (error) {
    console.error(error);
    return null;
  }
};

Réutiliser le client stocké

Une fois les identifiants stockés par une première connexion, getSecrecyClient restitue le client sans redemander à l'utilisateur de se connecter. La fonction est synchrone, mais la bibliothèque de cryptographie doit d'abord être initialisée avec setup.

const getSecrecyClientFromStorage = async (): Promise<SecrecyClient | null> => {
  // Initialiser la bibliothèque de cryptographie avant d'utiliser les clés stockées
  await setup();
 
  // Retourne null tant qu'aucune session n'a été stockée
  return getSecrecyClient();
};

Options du client

getSecrecyClient et login prennent tous les deux un objet d'options.

// Retrieve a client already stored by a previous login
getSecrecyClient(opts?: {
  // Read the credentials from sessionStorage instead of localStorage
  session?: boolean;
  // Override the Secrecy urls (auth, account, api, data)
  secrecyUrls?: Partial<SecrecyUrls>;
}): SecrecyClient | null;
 
// Start an authentication flow
login(params: {
  appId?: string;
  // Expected user / organization. A mismatch forces a new login
  context?: { userId?: string; orgId?: string };
  // Full page navigation to the Secrecy authentication page
  redirect?: boolean;
  path?: string | null;
  backPath?: string;
  scopes?: { email: boolean };
  // Store the credentials in sessionStorage instead of localStorage
  session?: boolean;
  secrecyUrls?: Partial<SecrecyUrls>;
  // Ignore any cached client and always start a new login
  forceLogin?: boolean;
}): Promise<SecrecyClient | null>;

Lorsque redirect vaut true, login renvoie null au premier appel, car le navigateur est redirigé vers la page d'authentification Secrecy. Il renvoie un SecrecyClient lorsque l'utilisateur revient.