learn.equalit.ie

Proposal for concurrent join

One can have the following protocol to handle concurrent join.

Each occupant can mark each session with one of the 5 statuses: {current, in-limbo, dead} current: User messages are being encrypted and decrypted in the current session. The join request will be processed by this session. in-limbo: A session which is receiving shares and confirmations, this session can potentially become the next session if it receives session confirmation from all users. dead: The session is abandoned and not going to become the current session.

The protocol joins one user at a time but is greedy and non-blocking in respect to several concurrent joiners and eventually results in joins of all new users (as long as current users in the session cooperate with the join process). The global order of messages is essential for the protocol to succeed, which is a transport assumption for $n+1sec$ protocol.

Session picking protocol for new user joining the room

New user starts a join process by sending $(U_{{joiner}},y_{{joiner}})$. In respose, it receives messages of the format

$sid,(U_{1},y_{1},...,U_{{joiner}},y_{{joiner}},...),kc_{{i}},z_{{i}}$

From each user $i$. The joiner makes a session for each $sid$ which contains them as a participant, the user initiates a session and gathers shares. When a session receives all shares, it computes the session key and becomes the current session. All other sessions can remain in limbo or get discarded based on the memory capacity of the implementation and security requirement.

Session picking protocol for current occupant of the current session

Suppose user $U_{i}$ is in Session $S$. When a new user $U_{j}$ sends a join request, the user $U_{i}$ starts a session in limbo $S_{j}$ with the list of users in the current session plus the joining user. As part of initiation of each session $S_{j}$ the current user sends a message of type:

$sid,(U_{1},y_{1},...,U_{{joiner}},y_{{joiner}},...),kc_{{i}},z_{{i}}$

If $m$ users are joining that session concurrently, there are $S_{1},...,S_{m}$ sessions in-limbo which are receiving shares and authentication messages.

If $U_{l}$, currently in the session, signals to leave the room, a new session $S_{l}$ is created. Furthermore, each session $S_{j}$ in-limbo which has $U_{l}$ as participants, results in the creation of new session $S_{{j'}}$ with user $U_{l}$ omitted and $S_{j}$ is marked as dead.

The user $U_{i}$ sends the shares and authentication token necessary for each session. The first session which receives all confirmations will become the main session, and the joiner user of that session becomes the current session. All other $S_{j}$ result in new sessions $S_{{j''}}$ to which $U_{{joiner}}$ is added. Previous active (current) session of the room becomes in-limbo.

in-limbo -> {in-limbo, dead, current} current -> in-limbo