libsignalgo.mau.fi/libsignal/state/record Index | Files

package record

import "go.mau.fi/libsignal/state/record"

Package record provides the state and record of an ongoing double ratchet session.

Index

Types

type Chain

type Chain struct {
	// contains filtered or unexported fields
}

Chain is a structure used inside the SessionState that keeps track of an ongoing ratcheting chain for a session.

func NewChain

func NewChain(senderRatchetKeyPair *ecc.ECKeyPair, chainKey *chain.Key,
	messageKeys []*message.Keys) *Chain

NewChain returns a new Chain structure for SessionState.

func NewChainFromStructure

func NewChainFromStructure(structure *ChainStructure) (*Chain, error)

NewChainFromStructure will return a new Chain with the given chain structure.

func (*Chain) AddMessageKeys

func (c *Chain) AddMessageKeys(keys *message.Keys)

AddMessageKeys will append the chain state with the given message keys.

func (*Chain) ChainKey

func (c *Chain) ChainKey() *chain.Key

ChainKey will return the chain key in the chain state.

func (*Chain) MessageKeys

func (c *Chain) MessageKeys() []*message.Keys

MessageKeys will return the message keys associated with the chain state.

func (*Chain) PopFirstMessageKeys

func (c *Chain) PopFirstMessageKeys() *message.Keys

PopFirstMessageKeys will remove the first message key from the chain's list of message keys.

func (*Chain) SenderRatchetKey

func (c *Chain) SenderRatchetKey() *ecc.ECKeyPair

SenderRatchetKey returns the sender's EC keypair.

func (*Chain) SetChainKey

func (c *Chain) SetChainKey(key *chain.Key)

SetChainKey will set the chain state's chain key.

func (*Chain) SetMessageKeys

func (c *Chain) SetMessageKeys(keys []*message.Keys)

SetMessageKeys will set the chain state with the given message keys.

func (*Chain) SetSenderRatchetKey

func (c *Chain) SetSenderRatchetKey(key *ecc.ECKeyPair)

SetSenderRatchetKey will set the chain state with the given EC key pair.

type ChainStructure

type ChainStructure struct {
	SenderRatchetKeyPublic  []byte
	SenderRatchetKeyPrivate []byte
	ChainKey                *chain.KeyStructure
	MessageKeys             []*message.KeysStructure
}

ChainStructure is a serializeable structure for chain states.

type PendingKeyExchange

type PendingKeyExchange struct {
	// contains filtered or unexported fields
}

PendingKeyExchange is a structure for storing a pending key exchange for a session state.

func NewPendingKeyExchange

func NewPendingKeyExchange(sequence uint32, localBaseKeyPair, localRatchetKeyPair *ecc.ECKeyPair,
	localIdentityKeyPair *identity.KeyPair) *PendingKeyExchange

NewPendingKeyExchange will return a new PendingKeyExchange object.

func NewPendingKeyExchangeFromStruct

func NewPendingKeyExchangeFromStruct(structure *PendingKeyExchangeStructure) *PendingKeyExchange

NewPendingKeyExchangeFromStruct will return a PendingKeyExchange object from the given structure. This is used to get a deserialized pending prekey exchange fetched from persistent storage.

type PendingKeyExchangeStructure

type PendingKeyExchangeStructure struct {
	Sequence                uint32
	LocalBaseKeyPublic      []byte
	LocalBaseKeyPrivate     []byte
	LocalRatchetKeyPublic   []byte
	LocalRatchetKeyPrivate  []byte
	LocalIdentityKeyPublic  []byte
	LocalIdentityKeyPrivate []byte
}

PendingKeyExchangeStructure is a serializable structure for pending key exchanges. This structure is used for persistent storage of the key exchange state.

type PendingPreKey

type PendingPreKey struct {
	// contains filtered or unexported fields
}

PendingPreKey is a structure for pending pre keys for a session state.

func NewPendingPreKey

func NewPendingPreKey(preKeyID *optional.Uint32, signedPreKeyID uint32,
	baseKey ecc.ECPublicKeyable) *PendingPreKey

NewPendingPreKey will return a new pending pre key object.

func NewPendingPreKeyFromStruct

func NewPendingPreKeyFromStruct(preKey *PendingPreKeyStructure) (*PendingPreKey, error)

NewPendingPreKeyFromStruct will return a new pending prekey object from the given structure.

type PendingPreKeyStructure

type PendingPreKeyStructure struct {
	PreKeyID       *optional.Uint32
	SignedPreKeyID uint32
	BaseKey        []byte
}

PendingPreKeyStructure is a serializeable structure for pending prekeys.

type PreKey

type PreKey struct {
	// contains filtered or unexported fields
}

PreKey record is a structure for storing pre keys inside a PreKeyStore.

func NewPreKey

func NewPreKey(id uint32, keyPair *ecc.ECKeyPair, serializer PreKeySerializer) *PreKey

NewPreKey record returns a new pre key record that can be stored in a PreKeyStore.

func NewPreKeyFromBytes

func NewPreKeyFromBytes(serialized []byte, serializer PreKeySerializer) (*PreKey, error)

NewPreKeyFromBytes will return a prekey record from the given bytes using the given serializer.

func NewPreKeyFromStruct

func NewPreKeyFromStruct(structure *PreKeyStructure, serializer PreKeySerializer) (*PreKey, error)

NewPreKeyFromStruct returns a PreKey record using the given serializable structure.

func (*PreKey) ID

func (p *PreKey) ID() *optional.Uint32

ID returns the pre key record's id.

func (*PreKey) KeyPair

func (p *PreKey) KeyPair() *ecc.ECKeyPair

KeyPair returns the pre key record's key pair.

func (*PreKey) Serialize

func (p *PreKey) Serialize() []byte

Serialize uses the PreKey serializer to return the PreKey as serialized bytes.

type PreKeySerializer

type PreKeySerializer interface {
	Serialize(preKey *PreKeyStructure) []byte
	Deserialize(serialized []byte) (*PreKeyStructure, error)
}

PreKeySerializer is an interface for serializing and deserializing PreKey objects into bytes. An implementation of this interface should be used to encode/decode the object into JSON, Protobuffers, etc.

type PreKeyStructure

type PreKeyStructure struct {
	ID         uint32
	PublicKey  []byte
	PrivateKey []byte
}

PreKeyStructure is a structure for serializing PreKey records.

type ReceiverChainPair

type ReceiverChainPair struct {
	ReceiverChain *Chain
	Index         int
}

ReceiverChainPair is a structure for a receiver chain key and index number.

func NewReceiverChainPair

func NewReceiverChainPair(receiverChain *Chain, index int) *ReceiverChainPair

NewReceiverChainPair will return a new ReceiverChainPair object.

type Session

type Session struct {
	// contains filtered or unexported fields
}

Session encapsulates the state of an ongoing session.

func NewSession

func NewSession(serializer SessionSerializer, stateSerializer StateSerializer) *Session

NewSession creates a new session record and uses the given session and state serializers to convert the object into storeable bytes.

func NewSessionFromBytes

func NewSessionFromBytes(serialized []byte, serializer SessionSerializer, stateSerializer StateSerializer) (*Session, error)

NewSessionFromBytes will return a Signal Session from the given bytes using the given serializer.

func NewSessionFromState

func NewSessionFromState(sessionState *State, serializer SessionSerializer) *Session

NewSessionFromState creates a new session record from the given session state.

func NewSessionFromStructure

func NewSessionFromStructure(structure *SessionStructure, serializer SessionSerializer,
	stateSerializer StateSerializer) (*Session, error)

NewSessionFromStructure will return a new Signal Session from the given session structure and serializer.

func (*Session) ArchiveCurrentState

func (r *Session) ArchiveCurrentState()

ArchiveCurrentState moves the current session state into the list of "previous" session states, and replaces the current session state with a fresh reset instance.

func (*Session) HasSessionState

func (r *Session) HasSessionState(version int, senderBaseKey []byte) bool

HasSessionState will check this record to see if the sender's base key exists in the current and previous states.

func (*Session) IsFresh

func (r *Session) IsFresh() bool

IsFresh is used to determine if this is a brand new session or if a session record has already existed.

func (*Session) PreviousSessionStates

func (r *Session) PreviousSessionStates() []*State

PreviousSessionStates returns a list of all currently maintained "previous" session states.

func (*Session) PromoteState

func (r *Session) PromoteState(promotedState *State)

PromoteState takes the given session state and replaces it with the current state, pushing the previous current state to "previousStates".

func (*Session) Serialize

func (r *Session) Serialize() []byte

Serialize will return the session as serialized bytes so it can be persistently stored.

func (*Session) SessionState

func (r *Session) SessionState() *State

SessionState returns the session state object of the current session record.

func (*Session) SetState

func (r *Session) SetState(sessionState *State)

SetState sets the session record's current state to the given one.

func (*Session) Structure

func (r *Session) Structure() *SessionStructure

Structure will return a simple serializable session structure from the given structure. This is used for serialization to persistently store a session record.

type SessionSerializer

type SessionSerializer interface {
	Serialize(state *SessionStructure) []byte
	Deserialize(serialized []byte) (*SessionStructure, error)
}

SessionSerializer is an interface for serializing and deserializing a Signal Session into bytes. An implementation of this interface should be used to encode/decode the object into JSON, Protobuffers, etc.

type SessionStructure

type SessionStructure struct {
	SessionState   *StateStructure
	PreviousStates []*StateStructure
}

SessionStructure is a public, serializeable structure for Signal Sessions. The states defined in the session are immuteable, as they should not be changed by anyone but the serializer.

type SignedPreKey

type SignedPreKey struct {
	// contains filtered or unexported fields
}

SignedPreKey record is a structure for storing a signed pre key in a SignedPreKey store.

func NewSignedPreKey

func NewSignedPreKey(id uint32, timestamp int64, keyPair *ecc.ECKeyPair,
	sig [64]byte, serializer SignedPreKeySerializer) *SignedPreKey

NewSignedPreKey record creates a new signed pre key record with the given properties.

func NewSignedPreKeyFromBytes

func NewSignedPreKeyFromBytes(serialized []byte, serializer SignedPreKeySerializer) (*SignedPreKey, error)

NewSignedPreKeyFromBytes will return a signed prekey record from the given bytes using the given serializer.

func NewSignedPreKeyFromStruct

func NewSignedPreKeyFromStruct(structure *SignedPreKeyStructure,
	serializer SignedPreKeySerializer) (*SignedPreKey, error)

NewSignedPreKeyFromStruct returns a SignedPreKey record using the given serializable structure.

func (*SignedPreKey) ID

func (s *SignedPreKey) ID() uint32

ID returns the record's id.

func (*SignedPreKey) KeyPair

func (s *SignedPreKey) KeyPair() *ecc.ECKeyPair

KeyPair returns the signed pre key record's key pair.

func (*SignedPreKey) Serialize

func (s *SignedPreKey) Serialize() []byte

Serialize uses the SignedPreKey serializer to return the SignedPreKey as serialized bytes.

func (*SignedPreKey) Signature

func (s *SignedPreKey) Signature() [64]byte

Signature returns the record's signed prekey signature.

func (*SignedPreKey) Timestamp

func (s *SignedPreKey) Timestamp() int64

Timestamp returns the record's timestamp

type SignedPreKeySerializer

type SignedPreKeySerializer interface {
	Serialize(signedPreKey *SignedPreKeyStructure) []byte
	Deserialize(serialized []byte) (*SignedPreKeyStructure, error)
}

SignedPreKeySerializer is an interface for serializing and deserializing SignedPreKey objects into bytes. An implementation of this interface should be used to encode/decode the object into JSON, Protobuffers, etc.

type SignedPreKeyStructure

type SignedPreKeyStructure struct {
	ID         uint32
	PublicKey  []byte
	PrivateKey []byte
	Signature  []byte
	Timestamp  int64
}

SignedPreKeyStructure is a flat structure of a signed pre key, used for serialization and deserialization.

type State

type State struct {
	// contains filtered or unexported fields
}

State is a session state that contains the structure for all sessions. Session states are contained inside session records. The session state is implemented as a struct rather than protobuffers to allow other serialization methods.

func NewState

func NewState(serializer StateSerializer) *State

NewState returns a new session state.

func NewStateFromBytes

func NewStateFromBytes(serialized []byte, serializer StateSerializer) (*State, error)

NewStateFromBytes will return a Signal State from the given bytes using the given serializer.

func NewStateFromStructure

func NewStateFromStructure(structure *StateStructure, serializer StateSerializer) (*State, error)

NewStateFromStructure will return a new session state with the given state structure.

func (*State) AddReceiverChain

func (s *State) AddReceiverChain(senderRatchetKey ecc.ECPublicKeyable, chainKey session.ChainKeyable)

AddReceiverChain will add the given ratchet key and chain key to the session state.

func (*State) ClearUnackPreKeyMessage

func (s *State) ClearUnackPreKeyMessage()

ClearUnackPreKeyMessage will clear the session's pending pre key.

func (*State) HasMessageKeys

func (s *State) HasMessageKeys(senderEphemeral ecc.ECPublicKeyable, counter uint32) bool

HasMessageKeys returns true if we have message keys associated with the given sender key and counter.

func (*State) HasPendingKeyExchange

func (s *State) HasPendingKeyExchange() bool

HasPendingKeyExchange will return true if there is a valid pending key exchange waiting.

func (*State) HasReceiverChain

func (s *State) HasReceiverChain(senderEphemeral ecc.ECPublicKeyable) bool

HasReceiverChain will check to see if the session state has the given ephemeral key.

func (*State) HasSenderChain

func (s *State) HasSenderChain() bool

HasSenderChain will check to see if the session state has a sender chain.

func (*State) HasUnacknowledgedPreKeyMessage

func (s *State) HasUnacknowledgedPreKeyMessage() bool

HasUnacknowledgedPreKeyMessage will return true if this session has an unacknowledged pre key message.

func (*State) LocalIdentityKey

func (s *State) LocalIdentityKey() *identity.Key

LocalIdentityKey returns the session's identity key for the local user.

func (*State) LocalRegistrationID

func (s *State) LocalRegistrationID() uint32

LocalRegistrationID returns the local user's registration id.

func (*State) PendingKeyExchangeBaseKeyPair

func (s *State) PendingKeyExchangeBaseKeyPair() *ecc.ECKeyPair

PendingKeyExchangeBaseKeyPair will return the session's pending key exchange base keypair.

func (*State) PendingKeyExchangeIdentityKeyPair

func (s *State) PendingKeyExchangeIdentityKeyPair() *identity.KeyPair

PendingKeyExchangeIdentityKeyPair will return the session's pending key exchange identity keypair.

func (*State) PendingKeyExchangeRatchetKeyPair

func (s *State) PendingKeyExchangeRatchetKeyPair() *ecc.ECKeyPair

PendingKeyExchangeRatchetKeyPair will return the session's pending key exchange ratchet keypair.

func (*State) PendingKeyExchangeSequence

func (s *State) PendingKeyExchangeSequence() uint32

PendingKeyExchangeSequence will return the session's pending key exchange sequence number.

func (*State) PreviousCounter

func (s *State) PreviousCounter() uint32

PreviousCounter returns the counter of the previous message.

func (*State) ReceiverChainKey

func (s *State) ReceiverChainKey(senderEphemeral ecc.ECPublicKeyable) *chain.Key

ReceiverChainKey will use the given ephemeral key to generate a new chain key.

func (*State) RemoteIdentityKey

func (s *State) RemoteIdentityKey() *identity.Key

RemoteIdentityKey returns the identity key of the remote user.

func (*State) RemoteRegistrationID

func (s *State) RemoteRegistrationID() uint32

RemoteRegistrationID returns the remote user's registration id.

func (*State) RemoveMessageKeys

func (s *State) RemoveMessageKeys(senderEphemeral ecc.ECPublicKeyable, counter uint32) *message.Keys

RemoveMessageKeys removes the message key with the given sender key and counter. It will return the removed message key.

func (*State) RootKey

func (s *State) RootKey() session.RootKeyable

RootKey returns the root key for the session.

func (*State) SenderBaseKey

func (s *State) SenderBaseKey() []byte

SenderBaseKey returns the sender's base key in bytes.

func (*State) SenderChainKey

func (s *State) SenderChainKey() session.ChainKeyable

SenderChainKey will return the chain key of the session state.

func (*State) SenderRatchetKey

func (s *State) SenderRatchetKey() ecc.ECPublicKeyable

SenderRatchetKey returns the public ratchet key of the sender.

func (*State) SenderRatchetKeyPair

func (s *State) SenderRatchetKeyPair() *ecc.ECKeyPair

SenderRatchetKeyPair returns the public/private ratchet key pair of the sender.

func (*State) Serialize

func (s *State) Serialize() []byte

Serialize will return the state as bytes using the given serializer.

func (*State) SetLocalIdentityKey

func (s *State) SetLocalIdentityKey(identityKey *identity.Key)

SetLocalIdentityKey sets the session's identity key for the local user.

func (*State) SetLocalRegistrationID

func (s *State) SetLocalRegistrationID(registrationID uint32)

SetLocalRegistrationID sets the local user's registration id.

func (*State) SetMessageKeys

func (s *State) SetMessageKeys(senderEphemeral ecc.ECPublicKeyable, messageKeys *message.Keys)

SetMessageKeys will update the chain associated with the given sender key with the given message keys.

func (*State) SetPendingKeyExchange

func (s *State) SetPendingKeyExchange(sequence uint32, ourBaseKey, ourRatchetKey *ecc.ECKeyPair,
	ourIdentityKey *identity.KeyPair)

SetPendingKeyExchange will set the session's pending key exchange state to the given sequence and key pairs.

func (*State) SetPreviousCounter

func (s *State) SetPreviousCounter(previousCounter uint32)

SetPreviousCounter sets the counter for the previous message.

func (*State) SetReceiverChainKey

func (s *State) SetReceiverChainKey(senderEphemeral ecc.ECPublicKeyable, chainKey session.ChainKeyable)

SetReceiverChainKey sets the session's receiver chain key with the given chain key associated with the given senderEphemeral key.

func (*State) SetRemoteIdentityKey

func (s *State) SetRemoteIdentityKey(identityKey *identity.Key)

SetRemoteIdentityKey sets this session's identity key for the remote user.

func (*State) SetRemoteRegistrationID

func (s *State) SetRemoteRegistrationID(registrationID uint32)

SetRemoteRegistrationID sets the remote user's registration id.

func (*State) SetRootKey

func (s *State) SetRootKey(rootKey session.RootKeyable)

SetRootKey sets the root key for the session.

func (*State) SetSenderBaseKey

func (s *State) SetSenderBaseKey(senderBaseKey []byte)

SetSenderBaseKey sets the sender's base key with the given bytes.

func (*State) SetSenderChain

func (s *State) SetSenderChain(senderRatchetKeyPair *ecc.ECKeyPair, chainKey session.ChainKeyable)

SetSenderChain will set the given ratchet key pair and chain key for this session state.

func (*State) SetSenderChainKey

func (s *State) SetSenderChainKey(nextChainKey session.ChainKeyable)

SetSenderChainKey will set the chain key in the chain state for this session to the given chain key.

func (*State) SetUnacknowledgedPreKeyMessage

func (s *State) SetUnacknowledgedPreKeyMessage(preKeyID *optional.Uint32, signedPreKeyID uint32, baseKey ecc.ECPublicKeyable)

SetUnacknowledgedPreKeyMessage will return unacknowledged pre key message with the given key ids and base key.

func (*State) SetVersion

func (s *State) SetVersion(version int)

SetVersion sets the session state's version number.

func (*State) UnackPreKeyMessageItems

func (s *State) UnackPreKeyMessageItems() (*UnackPreKeyMessageItems, error)

UnackPreKeyMessageItems will return the session's unacknowledged pre key messages.

func (*State) Version

func (s *State) Version() int

Version returns the session's version.

type StateSerializer

type StateSerializer interface {
	Serialize(state *StateStructure) []byte
	Deserialize(serialized []byte) (*StateStructure, error)
}

StateSerializer is an interface for serializing and deserializing a Signal State into bytes. An implementation of this interface should be used to encode/decode the object into JSON, Protobuffers, etc.

type StateStructure

type StateStructure struct {
	LocalIdentityPublic  []byte
	LocalRegistrationID  uint32
	NeedsRefresh         bool
	PendingKeyExchange   *PendingKeyExchangeStructure
	PendingPreKey        *PendingPreKeyStructure
	PreviousCounter      uint32
	ReceiverChains       []*ChainStructure
	RemoteIdentityPublic []byte
	RemoteRegistrationID uint32
	RootKey              []byte
	SenderBaseKey        []byte
	SenderChain          *ChainStructure
	SessionVersion       int
}

StateStructure is the structure of a session state. Fields are public to be used for serialization and deserialization.

type UnackPreKeyMessageItems

type UnackPreKeyMessageItems struct {
	// contains filtered or unexported fields
}

UnackPreKeyMessageItems is a structure for messages that have not been acknowledged.

func NewUnackPreKeyMessageItems

func NewUnackPreKeyMessageItems(preKeyID *optional.Uint32, signedPreKeyID uint32,
	baseKey ecc.ECPublicKeyable) *UnackPreKeyMessageItems

NewUnackPreKeyMessageItems returns message items that are unacknowledged.

func NewUnackPreKeyMessageItemsFromStruct

func NewUnackPreKeyMessageItemsFromStruct(structure *UnackPreKeyMessageItemsStructure) *UnackPreKeyMessageItems

NewUnackPreKeyMessageItemsFromStruct will return a new unacknowledged prekey message items object from the given structure.

func (*UnackPreKeyMessageItems) BaseKey

BaseKey returns the ECC public key of the unacknowledged message.

func (*UnackPreKeyMessageItems) PreKeyID

func (u *UnackPreKeyMessageItems) PreKeyID() *optional.Uint32

PreKeyID returns the prekey id of the unacknowledged message.

func (*UnackPreKeyMessageItems) SignedPreKeyID

func (u *UnackPreKeyMessageItems) SignedPreKeyID() uint32

SignedPreKeyID returns the signed prekey id of the unacknowledged message.

type UnackPreKeyMessageItemsStructure

type UnackPreKeyMessageItemsStructure struct {
	PreKeyID       *optional.Uint32
	SignedPreKeyID uint32
	BaseKey        []byte
}

UnackPreKeyMessageItemsStructure is a serializable structure for unackowledged prekey message items.

Source Files

ChainState.go Doc.go PendingKeyExchangeState.go PendingPreKeyState.go PreKeyRecord.go SessionRecord.go SessionState.go SignedPreKeyRecord.go UnacknowledgedPreKey.go

Version
v0.1.2 (latest)
Published
Feb 12, 2025
Platform
linux/amd64
Imports
12 packages
Last checked
6 days ago

Tools for package owners.