Seald: documentation

Français

English

Français

English

Proxy Sessions ​

Les Proxy Sessions sont une fonctionnalité du SDK Seald qui est une alternative aux groupes.

Le principe des Proxy Sessions est d'avoir une certaine EncryptionSession (la session Proxy), qui est elle-même destinataire d'une autre session (la session proxifiée, ou proxied). Un utilisateur qui veut alors accéder à la session proxifiée, et n'en est pas un destinataire direct, mais est destinataire de la session Proxy, peut accéder à la session proxifiée.

Pour permettre à un utilisateur d'accéder à toutes les sessions qui ont pour destinataire la session Proxy, il suffit d'ajouter cet utilisateur comme destinataire à la session Proxy.

Accès direct à des sessions:

uml diagram

Accès via Proxy Session:

uml diagram

Cette fonctionnalité est, dans ce qu'elle permet, assez similaire aux Groupes, mais elle possède des différences importantes :

  • contairement aux groupes, il est nécessaire d'être soi-même dans la Proxy Session pour pouvoir ajouter la Proxy Session comme destinataire d'une autre session ;
  • à l'usage, les Proxy Session sont plus "légères" que les groupes, les opérations peuvent être un peu plus rapides ;
  • la clé de la Proxy Session ne peut pas être renouvelée, donc après révocation d'un membre de la proxy session, la garantie que cette personne ne puisse plus accéder aux données chiffrées après pour cette proxy session est un peu plus faible ;
  • la Proxy Session est une session comme une autre, il est donc possible d'utiliser une SymEncKey pour s'y auto-ajouter.

WARNING

Il n'est pas possible d'utiliser plusieurs niveaux de Proxy Sessions.

Par exemple, si un utilisateur est destinataire de Session1, que Session1 est désignée comme ProxySession pour Session2, et que Session2 est ProxySession pour Session3, l'utilisateur ne pourra pas récupérer Session3.

Création d'une Proxy Session ​

Une Proxy Session est une session comme une autre. Pour créer une Proxy Session, il suffit de créer une session avec comme destinataires les membres voulus.

javascript
const proxySession = await sealdSdk.createEncryptionSession(
  {
    sealdIds: [ // Liste des membres de la Proxy Session, qui pourront déchiffrer tout ce qui est chiffré pour la Proxy Session.
      { id: sealdId1 },
      { id: sealdId2 },
      { id: sealdId3 }
    ]
  }
)
const proxySession = await sealdSdk.createEncryptionSession(
  {
    sealdIds: [ // Liste des membres de la Proxy Session, qui pourront déchiffrer tout ce qui est chiffré pour la Proxy Session.
      { id: sealdId1 },
      { id: sealdId2 },
      { id: sealdId3 }
    ]
  }
)
swift
let proxySession = try await sealdSdk.createEncryptionSessionAsync(
    withRecipients: [ // Liste des membres de la Proxy Session, qui pourront déchiffrer tout ce qui est chiffré pour la Proxy Session.
    SealdRecipientWithRights(recipientId: sealdId1, rights: SealdRecipientRights(read: true, forward: true, revoke: true)),
    SealdRecipientWithRights(recipientId: sealdId2, rights: SealdRecipientRights(read: true, forward: true, revoke: true)),
    SealdRecipientWithRights(recipientId: sealdId3, rights: SealdRecipientRights(read: true, forward: true, revoke: true))
],
    useCache: true
)
let proxySession = try await sealdSdk.createEncryptionSessionAsync(
    withRecipients: [ // Liste des membres de la Proxy Session, qui pourront déchiffrer tout ce qui est chiffré pour la Proxy Session.
    SealdRecipientWithRights(recipientId: sealdId1, rights: SealdRecipientRights(read: true, forward: true, revoke: true)),
    SealdRecipientWithRights(recipientId: sealdId2, rights: SealdRecipientRights(read: true, forward: true, revoke: true)),
    SealdRecipientWithRights(recipientId: sealdId3, rights: SealdRecipientRights(read: true, forward: true, revoke: true))
],
    useCache: true
)
objective-c
SealdRecipientRights* allRights = [[SealdRecipientRights alloc] initWithRead:YES forward:YES revoke:YES];

NSArray<SealdRecipientWithRights*>* proxyRecipients = [NSArray arrayWithObjects: // Liste des membres de la Proxy Session, qui pourront déchiffrer tout ce qui est chiffré pour la Proxy Session.
                                                       [[SealdRecipientWithRights alloc] initWithRecipientId:sealdId1 rights:allRights],
                                                       [[SealdRecipientWithRights alloc] initWithRecipientId:sealdId2 rights:allRights],
                                                       [[SealdRecipientWithRights alloc] initWithRecipientId:sealdId3 rights:allRights],
                                                       nil];

SealdEncryptionSession* proxySession = [sealdSdk createEncryptionSessionWithRecipients:proxyRecipients
                                                                              useCache:YES
                                                                                 error:&error
                                       ];
/* [Handle error] */
SealdRecipientRights* allRights = [[SealdRecipientRights alloc] initWithRead:YES forward:YES revoke:YES];

NSArray<SealdRecipientWithRights*>* proxyRecipients = [NSArray arrayWithObjects: // Liste des membres de la Proxy Session, qui pourront déchiffrer tout ce qui est chiffré pour la Proxy Session.
                                                       [[SealdRecipientWithRights alloc] initWithRecipientId:sealdId1 rights:allRights],
                                                       [[SealdRecipientWithRights alloc] initWithRecipientId:sealdId2 rights:allRights],
                                                       [[SealdRecipientWithRights alloc] initWithRecipientId:sealdId3 rights:allRights],
                                                       nil];

SealdEncryptionSession* proxySession = [sealdSdk createEncryptionSessionWithRecipients:proxyRecipients
                                                                              useCache:YES
                                                                                 error:&error
                                       ];
/* [Handle error] */
kotlin
val proxySession =
    sealdSdk.createEncryptionSessionAsync(
        arrayOf( // Liste des membres de la Proxy Session, qui pourront déchiffrer tout ce qui est chiffré pour la Proxy Session.
            RecipientWithRights(sealdId1, RecipientRights(read = true, forward = true, revoke = true)),
            RecipientWithRights(sealdId2, RecipientRights(read = true, forward = true, revoke = true)),
            RecipientWithRights(sealdId3, RecipientRights(read = true, forward = true, revoke = true)),
        ),
    )
val proxySession =
    sealdSdk.createEncryptionSessionAsync(
        arrayOf( // Liste des membres de la Proxy Session, qui pourront déchiffrer tout ce qui est chiffré pour la Proxy Session.
            RecipientWithRights(sealdId1, RecipientRights(read = true, forward = true, revoke = true)),
            RecipientWithRights(sealdId2, RecipientRights(read = true, forward = true, revoke = true)),
            RecipientWithRights(sealdId3, RecipientRights(read = true, forward = true, revoke = true)),
        ),
    )
dart
final SealdEncryptionSession proxySession =
    await sealdSdk.createEncryptionSessionAsync([
  // Liste des membres de la Proxy Session, qui pourront déchiffrer tout ce qui est chiffré pour la Proxy Session.
  SealdRecipientWithRights(
    id: sealdId1,
    rights: SealdRecipientRights(read: true, forward: true, revoke: true),
  ),
  SealdRecipientWithRights(
    id: sealdId2,
    rights: SealdRecipientRights(read: true, forward: true, revoke: true),
  ),
  SealdRecipientWithRights(
    id: sealdId3,
    rights: SealdRecipientRights(read: true, forward: true, revoke: true),
  )
]);
final SealdEncryptionSession proxySession =
    await sealdSdk.createEncryptionSessionAsync([
  // Liste des membres de la Proxy Session, qui pourront déchiffrer tout ce qui est chiffré pour la Proxy Session.
  SealdRecipientWithRights(
    id: sealdId1,
    rights: SealdRecipientRights(read: true, forward: true, revoke: true),
  ),
  SealdRecipientWithRights(
    id: sealdId2,
    rights: SealdRecipientRights(read: true, forward: true, revoke: true),
  ),
  SealdRecipientWithRights(
    id: sealdId3,
    rights: SealdRecipientRights(read: true, forward: true, revoke: true),
  )
]);

À noter, l'utilisateur actuel doit absolument être destinataire de la session en question afin de pouvoir l'utiliser comme Proxy Session.

Ajout d'une Proxy Session comme destinataire d'une session ​

Sur le SDK Seald JavaScript, pour ajouter une Proxy Session comme destinataire d'une session, il faut mettre la clé proxySessions dans l'objet de destinataires, soit lors de la création de la session, soit lors d'un appel à session.addRecipients. À noter, puisque l'utilisateur actuel aura accès à la session via la Proxy Session, il peut être voulu de définir encryptForSelf: false, afin qu'il n'ait pas en plus un accès direct à la session.

Sur les SDK Seald mobiles, pour ajouter une Proxy Session comme destinataire d'une session, il faut d'abord créer la session, puis appeler session.addProxySession.

javascript
// Ajout de la proxySession dès la création
const session = await sealdSdk.createEncryptionSession(
  {
    sealdIds: [],
    proxySessions: [ // La proxySession est destinataire de session
      { id: proxySession.sessionId }
    ]
  },
  { encryptForSelf: false } // Pour que l'utilisateur actuel n'ait accès que via la proxySession
)

// Ou alors, ajout de la proxySession après la création
const session = await sealdSdk.createEncryptionSession( // Création de la session
  {},
  { encryptForSelf: false } // Pour que l'utilisateur actuel n'ait accès que via la proxySession
)
await session.addRecipients({ proxySessions: [{ id: proxySession.sessionId }] }) // Ajout de la proxySession comme destinataire de session
// Ajout de la proxySession dès la création
const session = await sealdSdk.createEncryptionSession(
  {
    sealdIds: [],
    proxySessions: [ // La proxySession est destinataire de session
      { id: proxySession.sessionId }
    ]
  },
  { encryptForSelf: false } // Pour que l'utilisateur actuel n'ait accès que via la proxySession
)

// Ou alors, ajout de la proxySession après la création
const session = await sealdSdk.createEncryptionSession( // Création de la session
  {},
  { encryptForSelf: false } // Pour que l'utilisateur actuel n'ait accès que via la proxySession
)
await session.addRecipients({ proxySessions: [{ id: proxySession.sessionId }] }) // Ajout de la proxySession comme destinataire de session
swift
// Création de la session
let session = try await sealdSdk.createEncryptionSessionAsync(
    withRecipients: [],
    useCache: true
)
// Ajout de la proxySession comme destinataire de session
try await session.addProxySessionAsync(
    proxySession.sessionId,
    rights: SealdRecipientRights(read: true, forward: true, revoke: true)
)
// Création de la session
let session = try await sealdSdk.createEncryptionSessionAsync(
    withRecipients: [],
    useCache: true
)
// Ajout de la proxySession comme destinataire de session
try await session.addProxySessionAsync(
    proxySession.sessionId,
    rights: SealdRecipientRights(read: true, forward: true, revoke: true)
)
objective-c
SealdRecipientRights* allRights = [[SealdRecipientRights alloc] initWithRead:YES forward:YES revoke:YES];

// Création de la session
SealdEncryptionSession* session = [sealdSdk createEncryptionSessionWithRecipients:[NSArray arrayWithObjects:nil]
                                                                         useCache:YES
                                                                            error:&error
                                  ];
/* [Handle error] */

// Ajout de la proxySession comme destinataire de session
[session addProxySession:proxySession.sessionId rights:allRights error:&error];
/* [Handle error] */
SealdRecipientRights* allRights = [[SealdRecipientRights alloc] initWithRead:YES forward:YES revoke:YES];

// Création de la session
SealdEncryptionSession* session = [sealdSdk createEncryptionSessionWithRecipients:[NSArray arrayWithObjects:nil]
                                                                         useCache:YES
                                                                            error:&error
                                  ];
/* [Handle error] */

// Ajout de la proxySession comme destinataire de session
[session addProxySession:proxySession.sessionId rights:allRights error:&error];
/* [Handle error] */
kotlin
// Création de la session
val session = sealdSdk.createEncryptionSessionAsync(arrayOf())

// Ajout de la proxySession comme destinataire de session
session.addProxySession(proxySession.sessionId, RecipientRights(read = true, forward = true, revoke = true))
// Création de la session
val session = sealdSdk.createEncryptionSessionAsync(arrayOf())

// Ajout de la proxySession comme destinataire de session
session.addProxySession(proxySession.sessionId, RecipientRights(read = true, forward = true, revoke = true))
dart
// Création de la session
final SealdEncryptionSession session =
    await sealdSdk.createEncryptionSessionAsync([]);

// Ajout de la proxySession comme destinataire de session
await session.addProxySessionAsync(
    proxySession.id,
    SealdRecipientRights(read: true, forward: true, revoke: true),
);
// Création de la session
final SealdEncryptionSession session =
    await sealdSdk.createEncryptionSessionAsync([]);

// Ajout de la proxySession comme destinataire de session
await session.addProxySessionAsync(
    proxySession.id,
    SealdRecipientRights(read: true, forward: true, revoke: true),
);

Récupération d'une session via une Proxy Session ​

Pour récupérer une session à laquelle on a accès via une Proxy Session, il suffit de récupérer la session avec retrieveEncryptionSession, en mettant lookupProxyKey à true.

javascript
// Récupération d'une session via proxy
const retrievedSession = await sealdSdk.retrieveEncryptionSession({
  sessionId: session.sessionId,
  lookupProxyKey: true // cherche si la session est accessible via un proxy
})
// Récupération d'une session via proxy
const retrievedSession = await sealdSdk.retrieveEncryptionSession({
  sessionId: session.sessionId,
  lookupProxyKey: true // cherche si la session est accessible via un proxy
})
swift
// Récupération d'une session via proxy
let retrievedSession = try await sealdSdk.retrieveEncryptionSessionAsync(
    withSessionId: session.sessionId,
    useCache: true,
    lookupProxyKey: true, // cherche si la session est accessible via un proxy
    lookupGroupKey: false)
// Récupération d'une session via proxy
let retrievedSession = try await sealdSdk.retrieveEncryptionSessionAsync(
    withSessionId: session.sessionId,
    useCache: true,
    lookupProxyKey: true, // cherche si la session est accessible via un proxy
    lookupGroupKey: false)
objective-c
// Récupération d'une session via proxy
SealdEncryptionSession* retrievedSession = [sealdSdk retrieveEncryptionSessionWithSessionId:session.sessionId
                                                                                   useCache:YES
                                                                             lookupProxyKey:YES // cherche si la session est accessible via un proxy
                                                                              ookupGroupKey:NO
                                                                                      error:&error
                                           ];
/* [Handle error] */
// Récupération d'une session via proxy
SealdEncryptionSession* retrievedSession = [sealdSdk retrieveEncryptionSessionWithSessionId:session.sessionId
                                                                                   useCache:YES
                                                                             lookupProxyKey:YES // cherche si la session est accessible via un proxy
                                                                              ookupGroupKey:NO
                                                                                      error:&error
                                           ];
/* [Handle error] */
kotlin
// Récupération d'une session via proxy
val retrievedSession = sealdSdk.retrieveEncryptionSessionAsync(
    session.sessionId,
    true,
    lookupProxyKey = true, // cherche si la session est accessible via un proxy
)
// Récupération d'une session via proxy
val retrievedSession = sealdSdk.retrieveEncryptionSessionAsync(
    session.sessionId,
    true,
    lookupProxyKey = true, // cherche si la session est accessible via un proxy
)
dart
// Récupération d'une session via proxy
final SealdEncryptionSession retrievedSession = await sealdSdk
    .retrieveEncryptionSessionAsync(
        sessionId: session.id,
        useCache: true,
        lookupProxyKey: true); // cherche si la session est accessible via un proxy
// Récupération d'une session via proxy
final SealdEncryptionSession retrievedSession = await sealdSdk
    .retrieveEncryptionSessionAsync(
        sessionId: session.id,
        useCache: true,
        lookupProxyKey: true); // cherche si la session est accessible via un proxy

Droits ​

Lors de l'utilisation d'une Proxy Session, il y a deux jeux de droits :

  • les droits de l'utilisateur, en tant que destinataire de la Proxy Session
  • les droits de la Proxy Session, en tant que destinataire de la session

Les droits de l'utilisateur en tant que destinataire de la Proxy Session lui donnent seulement des droits sur la Proxy Session elle-même. C'est à dire que si il a le droit 'forward' ou 'revoke', cela lui permettra d'ajouter / révoquer des membres à la Proxy Session elle-même, et non pas directement sur les sessions auquel il a accès via la Proxy Session. Il peut néanmoins donner accès à quelqu'un en l'ajoutant à la Proxy Session.

Les droits de la Proxy Session en tant que destinataire de la session correspondent à ce qui est permis pour toute personne qui a accès à la session via cette Proxy Session. C'est à dire que si la Proxy Session a le droit 'forward' sur une session, toute personne qui est membre de la Proxy Session pourra rajouter des destinataires à la session.