Np1sec/Specification - learn.equalit.ie

Procedures

Chat setup

Chatroom setup

Procedure Chatroom Init
Input:  $newRoomName$ , $participantNick$ 
  global  $myId:=1$ 
  global  $Nick_{{myId}}:=participantNick$ 
  global  $roomName:=newRoomName$ 
  global  $x_{{myId}},y_{{myId}}:=$  Generate Initial Paramters( $myId$ )
  global  $signatureKey_{{myId}}:=(x_{{myId}},y_{{myId}})$ 
   $participantList:=[Nick_{{myId}}]$ 
   $ephemeralPublicPointList:=[y_{{myId}},y_{{other}}]$

Joining

Join

Procedure Join
Input:  $newRoomName$ ,  $Nickname_{{myId}}$ ,  $participantId$ 
  global  $myId:=participantId$ 
  global  $roomName:=newRoomName$ 
   $x_{{myId}},y_{{myId}}:=$ Generate Initial Paramters( $myId$ )
  global  $signatureKey_{{myId}}:=(x_{{myId}},y_{{myId}})$ 
  Broadcast(":3mpCAT:3Join:3",  $myId$ ,  $Nickname_{{myId}}$ ,  $y_{{myId}}$ )
  global  $participantList,ephemeralPublicPointList:=$  Receive()
  global  $sessionId:=$  Compute Session Id( $roomName$ ,  $participantList$ ,  $ephemeralPublicPointList$ )
  Sign and Send Key Confirmation and Shares()
  Wait On Receive(":3mpCAT:3KeyConfirmationShare:3")
  global  $keyShareList,keyConfirmationList,signatureList:=$  Receive()
  Verify Key Confirmations and Signatures( $keyConfirmationList$ ,  $signatureList$ )
  Update Session Key()

Procedure Receive Session Digest
Input:  $currentSessionHistoryDigest$ 
  global  $sessionDigest:=currentSessionHistoryDigest$

Protocol for other participants already in the chat to accept the newcomer

Procedure Accept
Input:  $newParticipant$ 
  Broadcast(":3mpCAT:3Join:3",  $myId$ ,  $Nickname_{{myId}}$ ,  $y_{{myId}}$ )
  Wait On Receive(":3mpCAT:3Join:3")
  global  $nick_{{NewParticipant}}$ ,  $ephemeralPublicPoint_{{NewParticipant}}:=$  Receive()
  Update Lists( $nick_{{NewParticipant}}$ ,  $ephemeralPublicPoint_{{NewParticipant}}$ )
  global  $sessionId:=$  Compute Session Id( $roomName$ ,  $participantList$ ,  $ephemeralPublicPointList$ )
  Sign and Send Key Confirmation and Shares()
  Wait On Receive(":3mpCAT:3KeyConfirmationShare:3")
  global  $keyShareList,keyConfirmationList,signatureList:=$  Receive()
  Verify Key Confirmations and Signatures( $keyConfirmationList$ ,  $signatureList$ )
  Update Session Key()
  Send( $sessionDigest$ )

Leave

Farewell

Procedure Shrink on Leave
Input:  $leaverId$ 
  remove  $leaverId$  from  $participantIdList$ 
  global  $sessionId:=$  Compute Session Id()
  if  $|participantList|>1$ , then
    Sign and Send Key Shares()
    Wait On Receive(":3mpCAT:3KeyShare:3")
     $keyShareList$  := Receive()
    Update Session Key( $keyShareList$ )

Procedure Sign and Send Key Shares
Input: 
  global  $z_{{myId-1,myId}}:=Hash(k_{{myId,myId-1}},sessionId)$ 
  global  $z_{{myId,myId+1}}:=Hash(k_{{myId,myId+1}},sessionId)$ 
   $keyShare_{{myId}}:=z_{{myId-1,myId}}\oplus z_{{myId,myId+1}}$ 
   $originAuthSignature:=$  ED25519Sign( $SignatureKey$ ,  $sessionId$  ||  $z_{{myId}}$ )
  Broadcast(":3mpCAT:3KeyShare:3",  $myId$ ,  $keyShare_{{myId}}$ ,  $originAuthSignature$ )  # we can send this encrypted but leaving person can read it, hence theoretically it is the same as sending it unencrypted.

Send

Procedure Send

Input:  $metaMessage$ ,  $message$ 
   $keyShareMessage$  = NewKeyShareMessage( $metaMessage$ )
   $cryptMessage$  := AES CTR Encrypt( $sessionKey$ , $message|keyShareMessage$ )
   $originAuthSignature$  := ED25519Sign( $SignatureKey$ ,  $sessionId$  ||  $cryptMetatMessage$ )
   $sessionDigest$  := Compute Session Digest( $lastMessage$ )
  Broadcast(":3mpCAT:3",  $sessionId$ ,  $cryptMessage$ ,  $sessionDigest$ ,  $originAuthSignature$ ,":3")

Receive

Procedure Receive

Input: $sender$ , $encryptedMessage$ , $originAuthSignature$ , $sessionDigest$

   $v:=$  ED25519VerifySignature( $ephemeralPublicKeyList[Sender]$ ,  $sessionId||encryptedMessage$ ,  $originAuthSignature$ )
  Assert( $v$ ) or return Reject
   $message,keyShareMessage:=$  AES CTR Decrypt( $sessionKey$ ,  $encryptedMessage$ ){}
   $isMetaMessage=$ UpdateNewKeyStatus( $keyShareMessage$ )
  Verify Digests( $sessionDiges$ )
  return{ $isMetaMessage,message$ }  # isMetaMessage is true if the message is purely meta message and there is nothing to display

Common functions

Common functions used by other procedures in different stages

Procedure Generate Initial Paramters
Input:  $myId$ 
   $signaturePrivateKey:=$  RandomBits(256)
   $x_{{myId}}:=$  Ed25519 Scalar( $signaturePrivateKey$ )) #{This is both Diffie-Hellman secret and ephemeral signature private key}
   $y_{{myId}}:=x_{{myId}}P$ 
  return  $x,y$

Procedure Verify Key Confirmation and Signatures
Input:  $signatureList$ ,  $keyConfirmationList$ 
  for each  $participant\in participantList$ , do
    if  $keyConfirmationList[participant][myId]\neq Hash(k_{{myId,participant}},U_{{myId}})$ , then
      Halt()
    else if ED25519VerifySignature( $ephemeralPublicKeyList[particicpant]$ ,  $sessionId|keyShares[myId]$ ,  $originAuthSignature$ ) = Fail , then
      Halt()

Procedure Compute Session Id
Input:  $participantList$ ,  $ephemeralPublicPointList$ 
  return  $Hash(roomName,zip(participantList,ephemeralPublicPointList))$   #  $zip([a,b],[c,d]):=[(a,c),(b,d)]$

Procedure Verify Signatures
Input:  $longPublicList$ , $schnorrRandomPointList$ , 
# standard signature verification

Procedure Sign and Send Key Confirmation and Share
Input:  $schnorrRandomPointList$ 
  for each  $participant\in participantList$ , do
     $k_{{myId,participant}}:=Hash(x_{{myId}}LP_{{participant}}|lp_{{myId}}y_{{participant}}|x_{{myId}}y_{{participant}})$   # Triple DH
     $kc_{{myId}}:=kc_{{myId}}|Hash(k_{{myId,participant}},U_{{participant}})$ 
  global  $z_{{myId-1,myId}}:=Hash(k_{{myId,myId-1}},sessionId)$ 
  global  $z_{{myId,myId+1}}:=Hash(k_{{myId,myId+1}},sessionId)$ 
   $keyShare_{{myId}}:=z_{{myId-1,myId}}\oplus z_{{myId,myId+1}}$ 
   $originAuthSignature:=$  ED25519Sign( $SignatureKey$ ,  $sessionId$  ||  $z_{{myId}}$ )
  Broadcast(":3mpCAT:3KeyConfirmationAndShare:3",  $myId$ ,  $keyShare_{{myId}}$ ,  $originAuthSignature$ ,  $kc_{{myId}}$ )

Procedure Update Session Key
Input:  $keyShareList$ 
   $i:=myId$ 
  for each  ${j\in [i,...,i+n-1]}$ , do
      $z_{{j,j+1}}:=z_{{j-1,j}}\oplus keyShareListe[j+1]$ 
    # recovered  $z_{{i-1,i}}$  should be equal to its original value
   global  $sessionKey:=Hash(z_{{j,j+1}}|j\in [1...n])$

Procedure Sign Params Update Session Key
Input:  $toBeSigned$ ,  $signatureList$ , $keyShareList$ 
  Update Session Key()
   $toBeSigned:=Hash(sessionId,||Hash(verifierList,ephemeralPublicPointList,keyShareList)))$ 
   $signature_{{myId}}:=$ Sign Session and Send( $toBeSigned$ )
  Broadcast(":3mpCAT:3SignedSessionParameters:3", $signature_{{myId}}$ )

Procedure ComputeSessionDigest
Input:  $lastMessage$ 
  for each  $message$  in Messages Received from  $lastDigestedMessage$ +1 till  $lastMessage$ , do
      $sesionDigest:=Hash(sessionDigest,message)$  
     LRU Cache Store Digest( $sessionDigest$ ,  $message$ )
  return  $sessionDigest$ , $lastMessageId$

Procedure NewKeyShareMessage
Input:  $metaMessage$ 
# Based on metaMessage Determines what type of keyshare needs to be send (Ephemeral point or Group key share) and returen it.

Procedure UpdateNewKeyStatus
Input:  $keyShareMessage$ 
# Update the table of which participant has sent its new ephemeral point or its new group key share

Procedure Hash
Input:  $message$ 
   return SHA-256( $message$ )

Last modified 11 years ago