Chiffrer des données anonymement

Chiffrer vers une clé publique, sans compte

La fonction encryptAnonymous chiffre des données avec la clé publique du destinataire, avant leur transmission ou leur stockage. Il s'agit d'une fonction autonome exportée par @secrecy/lib, et non d'une méthode du client : le visiteur qui soumet les données n'a ni compte ni secrecyClient, ce qui est précisément l'objet de ce flux.

Ce que vous devez fournir de votre côté, c'est la clé publique vers laquelle chiffrer. Obtenez votre identifiant utilisateur avec secrecyClient.me, puis convertissez-le en clé publique avec secrecyClient.app.userPublicKey — voir démarrer avec l'authentification pour obtenir un client authentifié. Les données elles-mêmes sont converties en octets avec un TextEncoder avant d'être chiffrées.

formAnonymous.ts

import { encryptAnonymous } from '@secrecy/lib';
 
const encryptAnonymouslyFormData = async (
  formValues: unknown
): Promise<Uint8Array | null> => {
  // First we need to check if the secrecyClient is available
  if (!secrecyClient) {
    return null;
  }
 
  try {
    // Second we need to get the user public key
    const me = await secrecyClient.me();
    const userPublicKey = await secrecyClient.app.userPublicKey(me.id);
 
    // Third we need to encrypt the form values
    const encoder = new TextEncoder();
    const encoded = encoder.encode(JSON.stringify(formValues));
    const encrypted = encryptAnonymous(encoded, userPublicKey);
 
    // Finally we can return the encrypted form values and store it in the database
    return encrypted;
  } catch (error) {
    console.error(error);
    return null;
  }
};

La fonction est synchrone et renvoie un Uint8Array. Le texte chiffré n'est que des octets : stockez-le dans votre propre base de données, en base64 par exemple, exactement comme n'importe quelle autre colonne.

Déchiffrer les données d'un formulaire anonyme

La méthode secrecyClient.decryptAnonymous ouvre un texte chiffré produit de cette manière. Elle prend les octets comme unique argument et réutilise la paire de clés de l'identité courante : rien d'autre n'a besoin de lui être transmis. Les octets déchiffrés sont ensuite décodés vers la structure d'origine.

decryptedAnonymousData.ts

const decryptAnonymousFormData = ({ data }: { data: Uint8Array }) => {
  // First we need to check if the secrecyClient is available
  if (!secrecyClient) {
    return null;
  }
 
  try {
    // Second we need to decrypt the form values
    const decrypted = secrecyClient.decryptAnonymous(data);
    const decoder = new TextDecoder();
    const decoded = decoder.decode(decrypted);
 
    // Finally we can return the decrypted form values
    return JSON.parse(decoded);
  } catch (error) {
    console.error(error);
    return null;
  }
};

Cette méthode est synchrone également. Une fonction autonome decryptAnonymous est aussi exportée par @secrecy/lib ; elle prend la paire de clés en second argument, sous la forme { publicKey, privateKey }, et c'est celle que vous utilisez en dehors d'un client authentifié.

Le déchiffrement échoue lorsque le texte chiffré a été scellé vers une autre clé publique que celle de l'identité courante. Notez que l'expéditeur ne peut pas déchiffrer ce qu'il a envoyé : la paire de clés utilisée pour sceller les données est générée à la volée puis immédiatement jetée.

Chiffrement anonyme Erreurs