slidge-whatsapp 0.2.2__cp312-cp312-manylinux_2_36_aarch64.whl → 0.2.5__cp312-cp312-manylinux_2_36_aarch64.whl

slidge_whatsapp/vendor/go.mau.fi/libsignal/state/record/ChainState.go

@@ -0,0 +1,157 @@
+package record
+
+import (
+	"go.mau.fi/libsignal/ecc"
+	"go.mau.fi/libsignal/kdf"
+	"go.mau.fi/libsignal/keys/chain"
+	"go.mau.fi/libsignal/keys/message"
+	"go.mau.fi/libsignal/util/bytehelper"
+)
+
+// NewReceiverChainPair will return a new ReceiverChainPair object.
+func NewReceiverChainPair(receiverChain *Chain, index int) *ReceiverChainPair {
+	return &ReceiverChainPair{
+		ReceiverChain: receiverChain,
+		Index:         index,
+	}
+}
+
+// ReceiverChainPair is a structure for a receiver chain key and index number.
+type ReceiverChainPair struct {
+	ReceiverChain *Chain
+	Index         int
+}
+
+// NewChain returns a new Chain structure for SessionState.
+func NewChain(senderRatchetKeyPair *ecc.ECKeyPair, chainKey *chain.Key,
+	messageKeys []*message.Keys) *Chain {
+
+	return &Chain{
+		senderRatchetKeyPair: senderRatchetKeyPair,
+		chainKey:             chainKey,
+		messageKeys:          messageKeys,
+	}
+}
+
+// NewChainFromStructure will return a new Chain with the given
+// chain structure.
+func NewChainFromStructure(structure *ChainStructure) (*Chain, error) {
+	// Alias to SliceToArray
+	getArray := bytehelper.SliceToArray
+
+	// Build the sender ratchet key from bytes.
+	senderRatchetKeyPublic, err := ecc.DecodePoint(structure.SenderRatchetKeyPublic, 0)
+	if err != nil {
+		return nil, err
+	}
+	var senderRatchetKeyPrivate ecc.ECPrivateKeyable
+	if len(structure.SenderRatchetKeyPrivate) == 32 {
+		senderRatchetKeyPrivate = ecc.NewDjbECPrivateKey(getArray(structure.SenderRatchetKeyPrivate))
+	}
+	senderRatchetKeyPair := ecc.NewECKeyPair(senderRatchetKeyPublic, senderRatchetKeyPrivate)
+
+	// Build our message keys from the message key structures.
+	messageKeys := make([]*message.Keys, len(structure.MessageKeys))
+	for i := range structure.MessageKeys {
+		messageKeys[i] = message.NewKeysFromStruct(structure.MessageKeys[i])
+	}
+
+	// Build our new chain state.
+	chainState := NewChain(
+		senderRatchetKeyPair,
+		chain.NewKeyFromStruct(structure.ChainKey, kdf.DeriveSecrets),
+		messageKeys,
+	)
+
+	return chainState, nil
+}
+
+// ChainStructure is a serializeable structure for chain states.
+type ChainStructure struct {
+	SenderRatchetKeyPublic  []byte
+	SenderRatchetKeyPrivate []byte
+	ChainKey                *chain.KeyStructure
+	MessageKeys             []*message.KeysStructure
+}
+
+// Chain is a structure used inside the SessionState that keeps
+// track of an ongoing ratcheting chain for a session.
+type Chain struct {
+	senderRatchetKeyPair *ecc.ECKeyPair
+	chainKey             *chain.Key
+	messageKeys          []*message.Keys
+}
+
+// SenderRatchetKey returns the sender's EC keypair.
+func (c *Chain) SenderRatchetKey() *ecc.ECKeyPair {
+	return c.senderRatchetKeyPair
+}
+
+// SetSenderRatchetKey will set the chain state with the given EC
+// key pair.
+func (c *Chain) SetSenderRatchetKey(key *ecc.ECKeyPair) {
+	c.senderRatchetKeyPair = key
+}
+
+// ChainKey will return the chain key in the chain state.
+func (c *Chain) ChainKey() *chain.Key {
+	return c.chainKey
+}
+
+// SetChainKey will set the chain state's chain key.
+func (c *Chain) SetChainKey(key *chain.Key) {
+	c.chainKey = key
+}
+
+// MessageKeys will return the message keys associated with the
+// chain state.
+func (c *Chain) MessageKeys() []*message.Keys {
+	return c.messageKeys
+}
+
+// SetMessageKeys will set the chain state with the given message
+// keys.
+func (c *Chain) SetMessageKeys(keys []*message.Keys) {
+	c.messageKeys = keys
+}
+
+// AddMessageKeys will append the chain state with the given
+// message keys.
+func (c *Chain) AddMessageKeys(keys *message.Keys) {
+	c.messageKeys = append(c.messageKeys, keys)
+}
+
+// PopFirstMessageKeys will remove the first message key from
+// the chain's list of message keys.
+func (c *Chain) PopFirstMessageKeys() *message.Keys {
+	removed := c.messageKeys[0]
+	c.messageKeys = c.messageKeys[1:]
+
+	return removed
+}
+
+// structure returns a serializeable structure of the chain state.
+func (c *Chain) structure() *ChainStructure {
+	// Alias to ArrayToSlice
+	getSlice := bytehelper.ArrayToSlice
+
+	// Convert our message keys into a serializeable structure.
+	messageKeys := make([]*message.KeysStructure, len(c.messageKeys))
+	for i := range c.messageKeys {
+		messageKeys[i] = message.NewStructFromKeys(c.messageKeys[i])
+	}
+
+	// Convert our sender ratchet key private
+	var senderRatchetKeyPrivate []byte
+	if c.senderRatchetKeyPair.PrivateKey() != nil {
+		senderRatchetKeyPrivate = getSlice(c.senderRatchetKeyPair.PrivateKey().Serialize())
+	}
+
+	// Build the chain structure.
+	return &ChainStructure{
+		SenderRatchetKeyPublic:  c.senderRatchetKeyPair.PublicKey().Serialize(),
+		SenderRatchetKeyPrivate: senderRatchetKeyPrivate,
+		ChainKey:                chain.NewStructFromKey(c.chainKey),
+		MessageKeys:             messageKeys,
+	}
+}

slidge_whatsapp/vendor/go.mau.fi/libsignal/state/record/Doc.go

@@ -0,0 +1,3 @@
+// Package record provides the state and record of an ongoing double
+// ratchet session.
+package record

slidge_whatsapp/vendor/go.mau.fi/libsignal/state/record/PendingKeyExchangeState.go

@@ -0,0 +1,91 @@
+package record
+
+import (
+	"go.mau.fi/libsignal/ecc"
+	"go.mau.fi/libsignal/keys/identity"
+	"go.mau.fi/libsignal/util/bytehelper"
+)
+
+// NewPendingKeyExchange will return a new PendingKeyExchange object.
+func NewPendingKeyExchange(sequence uint32, localBaseKeyPair, localRatchetKeyPair *ecc.ECKeyPair,
+	localIdentityKeyPair *identity.KeyPair) *PendingKeyExchange {
+
+	return &PendingKeyExchange{
+		sequence:             sequence,
+		localBaseKeyPair:     localBaseKeyPair,
+		localRatchetKeyPair:  localRatchetKeyPair,
+		localIdentityKeyPair: localIdentityKeyPair,
+	}
+}
+
+// NewPendingKeyExchangeFromStruct will return a PendingKeyExchange object from
+// the given structure. This is used to get a deserialized pending prekey exchange
+// fetched from persistent storage.
+func NewPendingKeyExchangeFromStruct(structure *PendingKeyExchangeStructure) *PendingKeyExchange {
+	// Return nil if no structure was provided.
+	if structure == nil {
+		return nil
+	}
+
+	// Alias the SliceToArray method.
+	getArray := bytehelper.SliceToArray
+
+	// Convert the bytes in the given structure to ECC objects.
+	localBaseKeyPair := ecc.NewECKeyPair(
+		ecc.NewDjbECPublicKey(getArray(structure.LocalBaseKeyPublic)),
+		ecc.NewDjbECPrivateKey(getArray(structure.LocalBaseKeyPrivate)),
+	)
+	localRatchetKeyPair := ecc.NewECKeyPair(
+		ecc.NewDjbECPublicKey(getArray(structure.LocalRatchetKeyPublic)),
+		ecc.NewDjbECPrivateKey(getArray(structure.LocalRatchetKeyPrivate)),
+	)
+	localIdentityKeyPair := identity.NewKeyPair(
+		identity.NewKey(ecc.NewDjbECPublicKey(getArray(structure.LocalIdentityKeyPublic))),
+		ecc.NewDjbECPrivateKey(getArray(structure.LocalIdentityKeyPrivate)),
+	)
+
+	// Return the PendingKeyExchange with the deserialized keys.
+	return &PendingKeyExchange{
+		sequence:             structure.Sequence,
+		localBaseKeyPair:     localBaseKeyPair,
+		localRatchetKeyPair:  localRatchetKeyPair,
+		localIdentityKeyPair: localIdentityKeyPair,
+	}
+}
+
+// PendingKeyExchangeStructure is a serializable structure for pending
+// key exchanges. This structure is used for persistent storage of the
+// key exchange state.
+type PendingKeyExchangeStructure struct {
+	Sequence                uint32
+	LocalBaseKeyPublic      []byte
+	LocalBaseKeyPrivate     []byte
+	LocalRatchetKeyPublic   []byte
+	LocalRatchetKeyPrivate  []byte
+	LocalIdentityKeyPublic  []byte
+	LocalIdentityKeyPrivate []byte
+}
+
+// PendingKeyExchange is a structure for storing a pending
+// key exchange for a session state.
+type PendingKeyExchange struct {
+	sequence             uint32
+	localBaseKeyPair     *ecc.ECKeyPair
+	localRatchetKeyPair  *ecc.ECKeyPair
+	localIdentityKeyPair *identity.KeyPair
+}
+
+// structre will return a serializable structure of a pending key exchange
+// so it can be persistently stored.
+func (p *PendingKeyExchange) structure() *PendingKeyExchangeStructure {
+	getSlice := bytehelper.ArrayToSlice
+	return &PendingKeyExchangeStructure{
+		Sequence:                p.sequence,
+		LocalBaseKeyPublic:      getSlice(p.localBaseKeyPair.PublicKey().PublicKey()),
+		LocalBaseKeyPrivate:     getSlice(p.localBaseKeyPair.PrivateKey().Serialize()),
+		LocalRatchetKeyPublic:   getSlice(p.localRatchetKeyPair.PublicKey().PublicKey()),
+		LocalRatchetKeyPrivate:  getSlice(p.localRatchetKeyPair.PrivateKey().Serialize()),
+		LocalIdentityKeyPublic:  getSlice(p.localIdentityKeyPair.PublicKey().PublicKey().PublicKey()),
+		LocalIdentityKeyPrivate: getSlice(p.localIdentityKeyPair.PrivateKey().Serialize()),
+	}
+}

slidge_whatsapp/vendor/go.mau.fi/libsignal/state/record/PendingPreKeyState.go

@@ -0,0 +1,62 @@
+package record
+
+import (
+	"go.mau.fi/libsignal/ecc"
+	"go.mau.fi/libsignal/util/optional"
+)
+
+// NewPendingPreKey will return a new pending pre key object.
+func NewPendingPreKey(preKeyID *optional.Uint32, signedPreKeyID uint32,
+	baseKey ecc.ECPublicKeyable) *PendingPreKey {
+
+	return &PendingPreKey{
+		preKeyID:       preKeyID,
+		signedPreKeyID: signedPreKeyID,
+		baseKey:        baseKey,
+	}
+}
+
+// NewPendingPreKeyFromStruct will return a new pending prekey object from the
+// given structure.
+func NewPendingPreKeyFromStruct(preKey *PendingPreKeyStructure) (*PendingPreKey, error) {
+	baseKey, err := ecc.DecodePoint(preKey.BaseKey, 0)
+	if err != nil {
+		return nil, err
+	}
+
+	pendingPreKey := NewPendingPreKey(
+		preKey.PreKeyID,
+		preKey.SignedPreKeyID,
+		baseKey,
+	)
+
+	return pendingPreKey, nil
+}
+
+// PendingPreKeyStructure is a serializeable structure for pending
+// prekeys.
+type PendingPreKeyStructure struct {
+	PreKeyID       *optional.Uint32
+	SignedPreKeyID uint32
+	BaseKey        []byte
+}
+
+// PendingPreKey is a structure for pending pre keys
+// for a session state.
+type PendingPreKey struct {
+	preKeyID       *optional.Uint32
+	signedPreKeyID uint32
+	baseKey        ecc.ECPublicKeyable
+}
+
+// structure will return a serializeable structure of the pending prekey.
+func (p *PendingPreKey) structure() *PendingPreKeyStructure {
+	if p != nil {
+		return &PendingPreKeyStructure{
+			PreKeyID:       p.preKeyID,
+			SignedPreKeyID: p.signedPreKeyID,
+			BaseKey:        p.baseKey.Serialize(),
+		}
+	}
+	return nil
+}

slidge_whatsapp/vendor/go.mau.fi/libsignal/state/record/PreKeyRecord.go

@@ -0,0 +1,90 @@
+package record
+
+import (
+	"go.mau.fi/libsignal/ecc"
+	"go.mau.fi/libsignal/util/bytehelper"
+	"go.mau.fi/libsignal/util/optional"
+)
+
+// 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 PreKeySerializer interface {
+	Serialize(preKey *PreKeyStructure) []byte
+	Deserialize(serialized []byte) (*PreKeyStructure, error)
+}
+
+// NewPreKeyFromBytes will return a prekey record from the given bytes using the given serializer.
+func NewPreKeyFromBytes(serialized []byte, serializer PreKeySerializer) (*PreKey, error) {
+	// Use the given serializer to decode the signal message.
+	preKeyStructure, err := serializer.Deserialize(serialized)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewPreKeyFromStruct(preKeyStructure, serializer)
+}
+
+// NewPreKeyFromStruct returns a PreKey record using the given serializable structure.
+func NewPreKeyFromStruct(structure *PreKeyStructure, serializer PreKeySerializer) (*PreKey, error) {
+	// Create the prekey record from the structure.
+	preKey := &PreKey{
+		structure:  *structure,
+		serializer: serializer,
+	}
+
+	// Generate the ECC key from bytes.
+	publicKey := ecc.NewDjbECPublicKey(bytehelper.SliceToArray(structure.PublicKey))
+	privateKey := ecc.NewDjbECPrivateKey(bytehelper.SliceToArray(structure.PrivateKey))
+	keyPair := ecc.NewECKeyPair(publicKey, privateKey)
+	preKey.keyPair = keyPair
+
+	return preKey, nil
+}
+
+// NewPreKey record returns a new pre key record that can
+// be stored in a PreKeyStore.
+func NewPreKey(id uint32, keyPair *ecc.ECKeyPair, serializer PreKeySerializer) *PreKey {
+	return &PreKey{
+		structure: PreKeyStructure{
+			ID:         id,
+			PublicKey:  keyPair.PublicKey().Serialize(),
+			PrivateKey: bytehelper.ArrayToSlice(keyPair.PrivateKey().Serialize()),
+		},
+		keyPair:    keyPair,
+		serializer: serializer,
+	}
+}
+
+// PreKeyStructure is a structure for serializing PreKey records.
+type PreKeyStructure struct {
+	ID         uint32
+	PublicKey  []byte
+	PrivateKey []byte
+}
+
+// PreKey record is a structure for storing pre keys inside
+// a PreKeyStore.
+type PreKey struct {
+	structure  PreKeyStructure
+	keyPair    *ecc.ECKeyPair
+	serializer PreKeySerializer
+}
+
+// ID returns the pre key record's id.
+func (p *PreKey) ID() *optional.Uint32 {
+	// TODO: manually set this to empty if empty
+	return optional.NewOptionalUint32(p.structure.ID)
+}
+
+// KeyPair returns the pre key record's key pair.
+func (p *PreKey) KeyPair() *ecc.ECKeyPair {
+	return p.keyPair
+}
+
+// Serialize uses the PreKey serializer to return the PreKey
+// as serialized bytes.
+func (p *PreKey) Serialize() []byte {
+	structure := p.structure
+	return p.serializer.Serialize(&structure)
+}

slidge_whatsapp/vendor/go.mau.fi/libsignal/state/record/SessionRecord.go

@@ -0,0 +1,197 @@
+package record
+
+import (
+	"bytes"
+)
+
+// archivedStatesMaxLength describes how many previous session
+// states we should keep track of.
+const archivedStatesMaxLength int = 40
+
+// 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 SessionSerializer interface {
+	Serialize(state *SessionStructure) []byte
+	Deserialize(serialized []byte) (*SessionStructure, error)
+}
+
+// NewSessionFromBytes will return a Signal Session from the given
+// bytes using the given serializer.
+func NewSessionFromBytes(serialized []byte, serializer SessionSerializer, stateSerializer StateSerializer) (*Session, error) {
+	// Use the given serializer to decode the session.
+	sessionStructure, err := serializer.Deserialize(serialized)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewSessionFromStructure(sessionStructure, serializer, stateSerializer)
+}
+
+// NewSession creates a new session record and uses the given session and state
+// serializers to convert the object into storeable bytes.
+func NewSession(serializer SessionSerializer, stateSerializer StateSerializer) *Session {
+	record := Session{
+		sessionState:   NewState(stateSerializer),
+		previousStates: []*State{},
+		fresh:          true,
+		serializer:     serializer,
+	}
+
+	return &record
+}
+
+// NewSessionFromStructure will return a new Signal Session from the given
+// session structure and serializer.
+func NewSessionFromStructure(structure *SessionStructure, serializer SessionSerializer,
+	stateSerializer StateSerializer) (*Session, error) {
+
+	// Build our previous states from structure.
+	previousStates := make([]*State, len(structure.PreviousStates))
+	for i := range structure.PreviousStates {
+		var err error
+		previousStates[i], err = NewStateFromStructure(structure.PreviousStates[i], stateSerializer)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	// Build our current state from structure.
+	sessionState, err := NewStateFromStructure(structure.SessionState, stateSerializer)
+	if err != nil {
+		return nil, err
+	}
+
+	// Build and return our session.
+	session := &Session{
+		previousStates: previousStates,
+		sessionState:   sessionState,
+		serializer:     serializer,
+		fresh:          false,
+	}
+
+	return session, nil
+}
+
+// NewSessionFromState creates a new session record from the given
+// session state.
+func NewSessionFromState(sessionState *State, serializer SessionSerializer) *Session {
+	record := Session{
+		sessionState:   sessionState,
+		previousStates: []*State{},
+		fresh:          false,
+		serializer:     serializer,
+	}
+
+	return &record
+}
+
+// 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 SessionStructure struct {
+	SessionState   *StateStructure
+	PreviousStates []*StateStructure
+}
+
+// Session encapsulates the state of an ongoing session.
+type Session struct {
+	serializer     SessionSerializer
+	sessionState   *State
+	previousStates []*State
+	fresh          bool
+}
+
+// SetState sets the session record's current state to the given
+// one.
+func (r *Session) SetState(sessionState *State) {
+	r.sessionState = sessionState
+}
+
+// IsFresh is used to determine if this is a brand new session
+// or if a session record has already existed.
+func (r *Session) IsFresh() bool {
+	return r.fresh
+}
+
+// SessionState returns the session state object of the current
+// session record.
+func (r *Session) SessionState() *State {
+	return r.sessionState
+}
+
+// PreviousSessionStates returns a list of all currently maintained
+// "previous" session states.
+func (r *Session) PreviousSessionStates() []*State {
+	return r.previousStates
+}
+
+// HasSessionState will check this record to see if the sender's
+// base key exists in the current and previous states.
+func (r *Session) HasSessionState(version int, senderBaseKey []byte) bool {
+	// Ensure the session state version is identical to this one.
+	if r.sessionState.Version() == version && (bytes.Compare(senderBaseKey, r.sessionState.SenderBaseKey()) == 0) {
+		return true
+	}
+
+	// Loop through all of our previous states and see if this
+	// exists in our state.
+	for i := range r.previousStates {
+		if r.previousStates[i].Version() == version && bytes.Compare(senderBaseKey, r.previousStates[i].SenderBaseKey()) == 0 {
+			return true
+		}
+	}
+
+	return false
+}
+
+// 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 (r *Session) ArchiveCurrentState() {
+	r.PromoteState(NewState(r.sessionState.serializer))
+}
+
+// PromoteState takes the given session state and replaces it with the
+// current state, pushing the previous current state to "previousStates".
+func (r *Session) PromoteState(promotedState *State) {
+	r.previousStates = r.prependStates(r.previousStates, r.sessionState)
+	r.sessionState = promotedState
+
+	// Remove the last state if it has reached our maximum length
+	if len(r.previousStates) > archivedStatesMaxLength {
+		r.previousStates = r.removeLastState(r.previousStates)
+	}
+}
+
+// Serialize will return the session as serialized bytes so it can be
+// persistently stored.
+func (r *Session) Serialize() []byte {
+	return r.serializer.Serialize(r.Structure())
+}
+
+// prependStates takes an array/slice of states and prepends it with
+// the given session state.
+func (r *Session) prependStates(states []*State, sessionState *State) []*State {
+	return append([]*State{sessionState}, states...)
+}
+
+// removeLastState takes an array/slice of states and removes the
+// last element from it.
+func (r *Session) removeLastState(states []*State) []*State {
+	return states[:len(states)-1]
+}
+
+// Structure will return a simple serializable session structure
+// from the given structure. This is used for serialization to persistently
+// store a session record.
+func (r *Session) Structure() *SessionStructure {
+	previousStates := make([]*StateStructure, len(r.previousStates))
+	for i := range r.previousStates {
+		previousStates[i] = r.previousStates[i].structure()
+	}
+	return &SessionStructure{
+		SessionState:   r.sessionState.structure(),
+		PreviousStates: previousStates,
+	}
+}