Transfert Secrecy

Un transfert Secrecy envoie un fichier à une personne qui n'est pas utilisatrice de Secrecy. Contrairement au partage de fichiers et de dossiers, qui lie la donnée à la clé publique d'un utilisateur Secrecy existant, un transfert produit un lien public que toute personne disposant de l'URL peut ouvrir — le destinataire n'a besoin d'aucun compte.

Public ne veut pas dire lisible. La donnée derrière un transfert est toujours chiffrée dans le navigateur avant d'être envoyée, et la clé ne quitte jamais l'appareil en clair. Le serveur ne stocke qu'un blob chiffré qu'il ne peut pas lire. Pour ouvrir le lien, le destinataire a besoin de l'URL et du mot de passe, que vous transmettez par un autre canal — Secrecy ne le transmet jamais à votre place.

Comment fonctionne un transfert ?

Un transfert est composé de deux objets. La donnée est la charge chiffrée, créée par secrecyClient.cloud.uploadData, qui renvoie l'id de la donnée ainsi qu'un objet sharing contenant le mot de passe et la clé de donnée chiffrée. Le lien est ensuite créé à partir de cet id avec secrecyClient.cloud.createPublicDataLink, et porte un slug — la partie publique de l'URL — un name et une date expireAt optionnelle.

Le côté réception ne nécessite ni client ni compte : la fonction autonome downloadDataFromLink prend le slug, la clé et le mot de passe, télécharge le blob et le déchiffre localement.

Gérer les transferts

Un transfert est révocable. Définir une date expireAt fait expirer son lien de lui-même, et cette date peut être modifiée à tout moment avec secrecyClient.cloud.updatePublicDataLink. Pour couper l'accès immédiatement, secrecyClient.cloud.deletePublicDataLink détruit le lien sans toucher à la donnée sous-jacente. Plusieurs liens peuvent pointer vers la même donnée, et secrecyClient.cloud.getPublicDataLinks permet de les lister.

D'un fichier à un lien de transfert

Créer un lien se fait en deux étapes. D'abord le fichier est chiffré et envoyé avec secrecyClient.cloud.uploadData, qui renvoie l'id de la donnée et ses identifiants de partage sharing. Ensuite un lien public est créé à partir de cet id avec secrecyClient.cloud.createPublicDataLink.
Ce que vous transmettez au destinataire, c'est le slug du lien, la clé de donnée chiffrée et le mot de passe.

const createLinkForFile = async (file: File) => {
  // First we need to check if the secrecyClient is available
  if (!secrecyClient) {
    return null;
  }
 
  try {
    // 1 - the file is encrypted on the device before being uploaded
    const data = await secrecyClient.cloud.uploadData({
      data: file,
      storageType: 's3',
      encrypted: true,
    });
 
    // 2 - the public link is created from the uploaded data
    const link = await secrecyClient.cloud.createPublicDataLink({
      dataId: data.id,
      name: file.name,
      // null means the link never expires
      expireAt: null,
    });
 
    // the slug is the public part of the url, the sharing part is the secret
    return { slug: link.slug, sharing: data.sharing };
  } catch (error) {
    console.error(error);
    return null;
  }
};

Seuls les deux appels nécessaires au flux sont montrés ici — chaque paramètre de la création du lien, y compris le slug optionnel et les règles sur expireAt, est décrit sur créer un lien public.

Obtenir un lien

La méthode secrecyClient.cloud.getPublicDataLink récupère un lien à partir de son id — et non de son slug. Elle renvoie le lien avec ses propriétés name, slug, expireAt et le dataId vers lequel il pointe.

const getLink = async (id: string) => {
  // First we need to check if the secrecyClient is available
  if (!secrecyClient) {
    return null;
  }
 
  try {
    // Get the link by id
    const link = await secrecyClient.cloud.getPublicDataLink({ id });
 
    return link;
  } catch (error) {
    console.error(error);
    return null;
  }
};

Lister les liens d'une donnée

La méthode secrecyClient.cloud.getPublicDataLinks renvoie tous les liens créés par l'utilisateur courant. Passez un tableau dataIds pour limiter le résultat aux liens pointant vers ces données — utile car plusieurs liens peuvent viser la même donnée.

const getLinksOfData = async (dataIds?: string[]) => {
  // First we need to check if the secrecyClient is available
  if (!secrecyClient) {
    return null;
  }
 
  try {
    // Without dataIds, all the links of the user are returned
    const links = await secrecyClient.cloud.getPublicDataLinks({ dataIds });
 
    return links;
  } catch (error) {
    console.error(error);
    return null;
  }
};

Modifier un lien

La méthode secrecyClient.cloud.updatePublicDataLink modifie un lien existant. Seul l'id est requis, toutes les autres propriétés sont optionnelles : name pour le renommer, slug pour changer son URL publique, et expireAt pour programmer — ou annuler, en passant null — son expiration.

const updateLink = async ({
  id,
  name,
  expireAt,
}: {
  id: string;
  name?: string;
  expireAt?: Date | null;
}) => {
  // First we need to check if the secrecyClient is available
  if (!secrecyClient) {
    return null;
  }
 
  try {
    // Only the id is required, the other properties are optional
    const link = await secrecyClient.cloud.updatePublicDataLink({
      id,
      name,
      expireAt,
    });
 
    return link;
  } catch (error) {
    console.error(error);
    return null;
  }
};

Modifier le slug casse les URL déjà partagées : l'ancien slug cesse de fonctionner dès que la mise à jour est effectuée.