slidge-whatsapp 0.2.2__cp311-cp311-manylinux_2_36_aarch64.whl → 0.2.7__cp311-cp311-manylinux_2_36_aarch64.whl

slidge_whatsapp/vendor/go.mau.fi/libsignal/cipher/Cbc.go

@@ -0,0 +1,101 @@
+/*
+CBC describes a block cipher mode. In cryptography, a block cipher mode of operation is an algorithm that uses a
+block cipher to provide an information service such as confidentiality or authenticity. A block cipher by itself
+is only suitable for the secure cryptographic transformation (encryption or decryption) of one fixed-length group of
+bits called a block. A mode of operation describes how to repeatedly apply a cipher's single-block operation to
+securely transform amounts of data larger than a block.
+
+This package simplifies the usage of AES-256-CBC.
+*/
+package cipher
+
+/*
+Some code is provided by the GitHub user locked (github.com/locked):
+https://gist.github.com/locked/b066aa1ddeb2b28e855e
+Thanks!
+*/
+import (
+	"bytes"
+	"crypto/aes"
+	"crypto/cipher"
+	"crypto/rand"
+	"fmt"
+	"io"
+)
+
+/*
+Decrypt is a function that decrypts a given cipher text with a provided key and initialization vector(iv).
+*/
+func DecryptCbc(iv, key, ciphertext []byte) ([]byte, error) {
+	block, err := aes.NewCipher(key)
+
+	if err != nil {
+		return nil, err
+	}
+
+	if len(ciphertext) < aes.BlockSize {
+		return nil, fmt.Errorf("ciphertext is shorter then block size: %d / %d", len(ciphertext), aes.BlockSize)
+	}
+
+	if iv == nil {
+		iv = ciphertext[:aes.BlockSize]
+		ciphertext = ciphertext[aes.BlockSize:]
+	}
+
+	cbc := cipher.NewCBCDecrypter(block, iv)
+	cbc.CryptBlocks(ciphertext, ciphertext)
+
+	return unpad(ciphertext)
+}
+
+/*
+Encrypt is a function that encrypts plaintext with a given key and an optional initialization vector(iv).
+*/
+func EncryptCbc(iv, key, plaintext []byte) ([]byte, error) {
+	plaintext = pad(plaintext, aes.BlockSize)
+
+	if len(plaintext)%aes.BlockSize != 0 {
+		return nil, fmt.Errorf("plaintext is not a multiple of the block size: %d / %d", len(plaintext), aes.BlockSize)
+	}
+
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		return nil, err
+	}
+
+	var ciphertext []byte
+	if iv == nil {
+		ciphertext = make([]byte, aes.BlockSize+len(plaintext))
+		iv := ciphertext[:aes.BlockSize]
+		if _, err := io.ReadFull(rand.Reader, iv); err != nil {
+			return nil, err
+		}
+
+		cbc := cipher.NewCBCEncrypter(block, iv)
+		cbc.CryptBlocks(ciphertext[aes.BlockSize:], plaintext)
+	} else {
+		ciphertext = make([]byte, len(plaintext))
+
+		cbc := cipher.NewCBCEncrypter(block, iv)
+		cbc.CryptBlocks(ciphertext, plaintext)
+	}
+
+	return ciphertext, nil
+}
+
+func pad(ciphertext []byte, blockSize int) []byte {
+	padding := blockSize - len(ciphertext)%blockSize
+	padtext := bytes.Repeat([]byte{byte(padding)}, padding)
+	return append(ciphertext, padtext...)
+}
+
+func unpad(src []byte) ([]byte, error) {
+	length := len(src)
+	padLen := int(src[length-1])
+
+	if padLen > length {
+		return nil, fmt.Errorf("padding is greater then the length: %d / %d", padLen, length)
+	}
+
+	return src[:(length - padLen)], nil
+}

slidge_whatsapp/vendor/go.mau.fi/libsignal/cipher/Cipher.go

@@ -0,0 +1,105 @@
+// Package cipher is a package for common encrypt/decrypt of symmetric key messages.
+package cipher
+
+import (
+	"bytes"
+	"crypto/aes"
+	"crypto/cipher"
+	"errors"
+)
+
+// Decrypt will use the given key, iv, and ciphertext and return
+// the plaintext bytes.
+func Decrypt(iv, key, ciphertext []byte) ([]byte, error) {
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		return nil, err
+	}
+	if len(ciphertext) < aes.BlockSize {
+		return nil, errors.New("ciphertext too short")
+	}
+	cbc := cipher.NewCBCDecrypter(block, iv)
+	cbc.CryptBlocks(ciphertext, ciphertext)
+
+	unpaddedText, err := pkcs7Unpad(ciphertext, aes.BlockSize)
+	if err != nil {
+		return nil, err
+	}
+
+	return unpaddedText, nil
+}
+
+// Encrypt will use the given iv, key, and plaintext bytes
+// and return ciphertext bytes.
+func Encrypt(iv, key, plaintext []byte) ([]byte, error) {
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		return nil, err
+	}
+	paddedText, err := pkcs7Pad(plaintext, block.BlockSize())
+	if err != nil {
+		return nil, err
+	}
+	ciphertext := make([]byte, len(paddedText))
+	mode := cipher.NewCBCEncrypter(block, iv)
+	mode.CryptBlocks(ciphertext, paddedText)
+
+	return ciphertext, nil
+}
+
+// PKCS7 padding.
+
+// PKCS7 errors.
+var (
+	// ErrInvalidBlockSize indicates hash blocksize <= 0.
+	ErrInvalidBlockSize = errors.New("invalid blocksize")
+
+	// ErrInvalidPKCS7Data indicates bad input to PKCS7 pad or unpad.
+	ErrInvalidPKCS7Data = errors.New("invalid PKCS7 data (empty or not padded)")
+
+	// ErrInvalidPKCS7Padding indicates PKCS7 unpad fails to bad input.
+	ErrInvalidPKCS7Padding = errors.New("invalid padding on input")
+)
+
+// pkcs7Pad right-pads the given byte slice with 1 to n bytes, where
+// n is the block size. The size of the result is x times n, where x
+// is at least 1.
+func pkcs7Pad(b []byte, blocksize int) ([]byte, error) {
+	if blocksize <= 0 {
+		return nil, ErrInvalidBlockSize
+	}
+	if b == nil || len(b) == 0 {
+		return nil, ErrInvalidPKCS7Data
+	}
+	n := blocksize - (len(b) % blocksize)
+	pb := make([]byte, len(b)+n)
+	copy(pb, b)
+	copy(pb[len(b):], bytes.Repeat([]byte{byte(n)}, n))
+	return pb, nil
+}
+
+// pkcs7Unpad validates and unpads data from the given bytes slice.
+// The returned value will be 1 to n bytes smaller depending on the
+// amount of padding, where n is the block size.
+func pkcs7Unpad(b []byte, blocksize int) ([]byte, error) {
+	if blocksize <= 0 {
+		return nil, ErrInvalidBlockSize
+	}
+	if b == nil || len(b) == 0 {
+		return nil, ErrInvalidPKCS7Data
+	}
+	if len(b)%blocksize != 0 {
+		return nil, ErrInvalidPKCS7Padding
+	}
+	c := b[len(b)-1]
+	n := int(c)
+	if n == 0 || n > len(b) {
+		return nil, ErrInvalidPKCS7Padding
+	}
+	for i := 0; i < n; i++ {
+		if b[len(b)-n+i] != c {
+			return nil, ErrInvalidPKCS7Padding
+		}
+	}
+	return b[:len(b)-n], nil
+}

slidge_whatsapp/vendor/go.mau.fi/libsignal/ecc/Curve.go

@@ -0,0 +1,109 @@
+package ecc
+
+import (
+	"crypto/rand"
+	"errors"
+	"fmt"
+	"io"
+
+	"golang.org/x/crypto/curve25519"
+
+	"go.mau.fi/libsignal/logger"
+)
+
+// DjbType is the Diffie-Hellman curve type (curve25519) created by D. J. Bernstein.
+const DjbType = 0x05
+
+var ErrBadKeyType = errors.New("bad key type")
+
+// DecodePoint will take the given bytes and offset and return an ECPublicKeyable object.
+// This is used to check the byte at the given offset in the byte array for a special
+// "type" byte that will determine the key type. Currently only DJB EC keys are supported.
+func DecodePoint(bytes []byte, offset int) (ECPublicKeyable, error) {
+	keyType := bytes[offset] & 0xFF
+
+	switch keyType {
+	case DjbType:
+		keyBytes := [32]byte{}
+		copy(keyBytes[:], bytes[offset+1:])
+		return NewDjbECPublicKey(keyBytes), nil
+	default:
+		return nil, fmt.Errorf("%w %d", ErrBadKeyType, keyType)
+	}
+}
+
+func CreateKeyPair(privateKey []byte) *ECKeyPair {
+	var private, public [32]byte
+	copy(private[:], privateKey)
+
+	private[0] &= 248
+	private[31] &= 127
+	private[31] |= 64
+
+	curve25519.ScalarBaseMult(&public, &private)
+
+	// Put data into our keypair struct
+	djbECPub := NewDjbECPublicKey(public)
+	djbECPriv := NewDjbECPrivateKey(private)
+	keypair := NewECKeyPair(djbECPub, djbECPriv)
+
+	logger.Debug("Returning keypair: ", keypair)
+	return keypair
+}
+
+// GenerateKeyPair returns an EC Key Pair.
+func GenerateKeyPair() (*ECKeyPair, error) {
+	// logger.Debug("Generating EC Key Pair...")
+	// Get cryptographically secure random numbers.
+	random := rand.Reader
+
+	// Create a byte array for our public and private keys.
+	var private, public [32]byte
+
+	// Generate some random data
+	_, err := io.ReadFull(random, private[:])
+	if err != nil {
+		return nil, err
+	}
+
+	// Documented at: http://cr.yp.to/ecdh.html
+	private[0] &= 248
+	private[31] &= 127
+	private[31] |= 64
+
+	curve25519.ScalarBaseMult(&public, &private)
+
+	// Put data into our keypair struct
+	djbECPub := NewDjbECPublicKey(public)
+	djbECPriv := NewDjbECPrivateKey(private)
+	keypair := NewECKeyPair(djbECPub, djbECPriv)
+
+	// logger.Debug("Returning keypair: ", keypair)
+
+	return keypair, nil
+}
+
+// VerifySignature verifies that the message was signed with the given key.
+func VerifySignature(signingKey ECPublicKeyable, message []byte, signature [64]byte) bool {
+	logger.Debug("Verifying signature of bytes: ", message)
+	publicKey := signingKey.PublicKey()
+	valid := verify(publicKey, message, &signature)
+	logger.Debug("Signature valid: ", valid)
+	return valid
+}
+
+// CalculateSignature signs a message with the given private key.
+func CalculateSignature(signingKey ECPrivateKeyable, message []byte) [64]byte {
+	logger.Debug("Signing bytes with signing key")
+	// Get cryptographically secure random numbers.
+	var random [64]byte
+	r := rand.Reader
+	io.ReadFull(r, random[:])
+
+	// Get the private key.
+	privateKey := signingKey.Serialize()
+
+	// Sign the message.
+	signature := sign(&privateKey, message, random)
+	return *signature
+}

slidge_whatsapp/vendor/go.mau.fi/libsignal/ecc/DjbECPublicKey.go

@@ -0,0 +1,29 @@
+package ecc
+
+// NewDjbECPublicKey creates a new Curve25519 public key with the given bytes.
+func NewDjbECPublicKey(publicKey [32]byte) *DjbECPublicKey {
+	key := DjbECPublicKey{
+		publicKey: publicKey,
+	}
+	return &key
+}
+
+// DjbECPublicKey implements the ECPublicKey interface and uses Curve25519.
+type DjbECPublicKey struct {
+	publicKey [32]byte
+}
+
+// PublicKey returns the EC public key as a byte array.
+func (d *DjbECPublicKey) PublicKey() [32]byte {
+	return d.publicKey
+}
+
+// Serialize returns the public key prepended by the DjbType value.
+func (d *DjbECPublicKey) Serialize() []byte {
+	return append([]byte{DjbType}, d.publicKey[:]...)
+}
+
+// Type returns the DjbType value.
+func (d *DjbECPublicKey) Type() int {
+	return DjbType
+}

slidge_whatsapp/vendor/go.mau.fi/libsignal/ecc/DkbECPrivateKey.go

@@ -0,0 +1,29 @@
+package ecc
+
+// NewDjbECPrivateKey returns a new EC private key with the given bytes.
+func NewDjbECPrivateKey(key [32]byte) *DjbECPrivateKey {
+	private := DjbECPrivateKey{
+		privateKey: key,
+	}
+	return &private
+}
+
+// DjbECPrivateKey implements the ECPrivateKey interface and uses Curve25519.
+type DjbECPrivateKey struct {
+	privateKey [32]byte
+}
+
+// PrivateKey returns the private key as a byte-array.
+func (d *DjbECPrivateKey) PrivateKey() [32]byte {
+	return d.privateKey
+}
+
+// Serialize returns the private key as a byte-array.
+func (d *DjbECPrivateKey) Serialize() [32]byte {
+	return d.privateKey
+}
+
+// Type returns the EC type value.
+func (d *DjbECPrivateKey) Type() int {
+	return DjbType
+}

slidge_whatsapp/vendor/go.mau.fi/libsignal/ecc/Doc.go

@@ -0,0 +1,3 @@
+// Package ecc provides a way to generate, sign, and use Elliptic-Curve
+// X25519 Cryptography keys.
+package ecc

slidge_whatsapp/vendor/go.mau.fi/libsignal/ecc/ECKeyPair.go

@@ -0,0 +1,27 @@
+package ecc
+
+// NewECKeyPair returns a new elliptic curve keypair given the specified public and private keys.
+func NewECKeyPair(publicKey ECPublicKeyable, privateKey ECPrivateKeyable) *ECKeyPair {
+	keypair := ECKeyPair{
+		publicKey:  publicKey,
+		privateKey: privateKey,
+	}
+
+	return &keypair
+}
+
+// ECKeyPair is a combination of both public and private elliptic curve keys.
+type ECKeyPair struct {
+	publicKey  ECPublicKeyable
+	privateKey ECPrivateKeyable
+}
+
+// PublicKey returns the public key from the key pair.
+func (e *ECKeyPair) PublicKey() ECPublicKeyable {
+	return e.publicKey
+}
+
+// PrivateKey returns the private key from the key pair.
+func (e *ECKeyPair) PrivateKey() ECPrivateKeyable {
+	return e.privateKey
+}

slidge_whatsapp/vendor/go.mau.fi/libsignal/ecc/ECPrivateKey.go

@@ -0,0 +1,7 @@
+package ecc
+
+// ECPrivateKeyable is an interface for all elliptic curve private keys.
+type ECPrivateKeyable interface {
+	Serialize() [32]byte
+	Type() int
+}

slidge_whatsapp/vendor/go.mau.fi/libsignal/ecc/ECPublicKey.go

@@ -0,0 +1,11 @@
+package ecc
+
+// KeySize is the size of EC keys (32) with the EC type byte prepended to it.
+const KeySize int = 33
+
+// ECPublicKeyable is an interface for all elliptic curve public keys.
+type ECPublicKeyable interface {
+	Serialize() []byte
+	Type() int
+	PublicKey() [32]byte
+}

slidge_whatsapp/vendor/go.mau.fi/libsignal/ecc/SignCurve25519.go

@@ -0,0 +1,97 @@
+package ecc
+
+// Package curve25519sign implements a signature scheme based on Curve25519 keys.
+// See https://moderncrypto.org/mail-archive/curves/2014/000205.html for details.
+
+import (
+	"crypto/ed25519"
+	"crypto/sha512"
+
+	"filippo.io/edwards25519"
+	"filippo.io/edwards25519/field"
+)
+
+// sign signs the message with privateKey and returns a signature as a byte slice.
+func sign(privateKey *[32]byte, message []byte, random [64]byte) *[64]byte {
+
+	// Calculate Ed25519 public key from Curve25519 private key
+	var A edwards25519.Point
+	privateKeyScalar, _ := edwards25519.NewScalar().SetBytesWithClamping(privateKey[:])
+	A.ScalarBaseMult(privateKeyScalar)
+	publicKey := *(*[32]byte)(A.Bytes())
+
+	// Calculate r
+	diversifier := [32]byte{
+		0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+		0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+		0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+		0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}
+
+	var r [64]byte
+	hash := sha512.New()
+	hash.Write(diversifier[:])
+	hash.Write(privateKey[:])
+	hash.Write(message)
+	hash.Write(random[:])
+	hash.Sum(r[:0])
+
+	// Calculate R
+	var rReduced *edwards25519.Scalar
+	rReduced, _ = edwards25519.NewScalar().SetUniformBytes(r[:])
+	var R edwards25519.Point
+	R.ScalarBaseMult(rReduced)
+
+	var encodedR [32]byte
+	encodedR = *(*[32]byte)(R.Bytes())
+
+	// Calculate S = r + SHA2-512(R || A_ed || msg) * a  (mod L)
+	var hramDigest [64]byte
+	hash.Reset()
+	hash.Write(encodedR[:])
+	hash.Write(publicKey[:])
+	hash.Write(message)
+	hash.Sum(hramDigest[:0])
+	hramDigestReduced, _ := edwards25519.NewScalar().SetUniformBytes(hramDigest[:])
+
+	sScalar := edwards25519.NewScalar().MultiplyAdd(hramDigestReduced, privateKeyScalar, rReduced)
+	s := *(*[32]byte)(sScalar.Bytes())
+
+	signature := new([64]byte)
+	copy(signature[:], encodedR[:])
+	copy(signature[32:], s[:])
+	signature[63] |= publicKey[31] & 0x80
+
+	return signature
+}
+
+// verify checks whether the message has a valid signature.
+func verify(publicKey [32]byte, message []byte, signature *[64]byte) bool {
+
+	publicKey[31] &= 0x7F
+
+	/* Convert the Curve25519 public key into an Ed25519 public key.  In
+	particular, convert Curve25519's "montgomery" x-coordinate into an
+	Ed25519 "edwards" y-coordinate:
+
+	ed_y = (mont_x - 1) / (mont_x + 1)
+
+	NOTE: mont_x=-1 is converted to ed_y=0 since fe_invert is mod-exp
+
+	Then move the sign bit into the pubkey from the signature.
+	*/
+
+	var edY, one, montX, montXMinusOne, montXPlusOne field.Element
+	_, _ = montX.SetBytes(publicKey[:])
+	_ = one.One()
+	montXMinusOne.Subtract(&montX, &one)
+	montXPlusOne.Add(&montX, &one)
+	montXPlusOne.Invert(&montXPlusOne)
+	edY.Multiply(&montXMinusOne, &montXPlusOne)
+
+	A_ed := *(*[32]byte)(edY.Bytes())
+
+	A_ed[31] |= signature[63] & 0x80
+	signature[63] &= 0x7F
+
+	return ed25519.Verify(A_ed[:], message, signature[:])
+}

slidge_whatsapp/vendor/go.mau.fi/libsignal/groups/GroupCipher.go

@@ -0,0 +1,152 @@
+package groups
+
+import (
+	"context"
+	"fmt"
+
+	"go.mau.fi/libsignal/cipher"
+	"go.mau.fi/libsignal/ecc"
+	"go.mau.fi/libsignal/groups/ratchet"
+	"go.mau.fi/libsignal/groups/state/record"
+	"go.mau.fi/libsignal/groups/state/store"
+	"go.mau.fi/libsignal/protocol"
+	"go.mau.fi/libsignal/signalerror"
+)
+
+// NewGroupCipher will return a new group message cipher that can be used for
+// encrypt/decrypt operations.
+func NewGroupCipher(builder *SessionBuilder, senderKeyID *protocol.SenderKeyName,
+	senderKeyStore store.SenderKey) *GroupCipher {
+
+	return &GroupCipher{
+		senderKeyID:    senderKeyID,
+		senderKeyStore: senderKeyStore,
+		sessionBuilder: builder,
+	}
+}
+
+// GroupCipher is the main entry point for group encrypt/decrypt operations.
+// Once a session has been established, this can be used for
+// all encrypt/decrypt operations within that session.
+type GroupCipher struct {
+	senderKeyID    *protocol.SenderKeyName
+	senderKeyStore store.SenderKey
+	sessionBuilder *SessionBuilder
+}
+
+// Encrypt will take the given message in bytes and return encrypted bytes.
+func (c *GroupCipher) Encrypt(ctx context.Context, plaintext []byte) (protocol.GroupCiphertextMessage, error) {
+	// Load the sender key based on id from our store.
+	keyRecord, err := c.senderKeyStore.LoadSenderKey(ctx, c.senderKeyID)
+	if err != nil {
+		return nil, err
+	}
+	senderKeyState, err := keyRecord.SenderKeyState()
+	if err != nil {
+		return nil, err
+	}
+
+	// Get the message key from the senderkey state.
+	senderKey, err := senderKeyState.SenderChainKey().SenderMessageKey()
+	if err != nil {
+		return nil, err
+	}
+
+	// Encrypt the plaintext.
+	ciphertext, err := cipher.EncryptCbc(senderKey.Iv(), senderKey.CipherKey(), plaintext)
+	if err != nil {
+		return nil, err
+	}
+
+	senderKeyMessage := protocol.NewSenderKeyMessage(
+		senderKeyState.KeyID(),
+		senderKey.Iteration(),
+		ciphertext,
+		senderKeyState.SigningKey().PrivateKey(),
+		c.sessionBuilder.serializer.SenderKeyMessage,
+	)
+
+	senderKeyState.SetSenderChainKey(senderKeyState.SenderChainKey().Next())
+	if err := c.senderKeyStore.StoreSenderKey(ctx, c.senderKeyID, keyRecord); err != nil {
+		return nil, err
+	}
+
+	return senderKeyMessage, nil
+}
+
+// Decrypt decrypts the given message using an existing session that
+// is stored in the senderKey store.
+func (c *GroupCipher) Decrypt(ctx context.Context, senderKeyMessage *protocol.SenderKeyMessage) ([]byte, error) {
+	keyRecord, err := c.senderKeyStore.LoadSenderKey(ctx, c.senderKeyID)
+	if err != nil {
+		return nil, err
+	}
+
+	if keyRecord.IsEmpty() {
+		return nil, fmt.Errorf("%w for %s in %s", signalerror.ErrNoSenderKeyForUser, c.senderKeyID.Sender().String(), c.senderKeyID.GroupID())
+	}
+
+	// Get the senderkey state by id.
+	senderKeyState, err := keyRecord.GetSenderKeyStateByID(senderKeyMessage.KeyID())
+	if err != nil {
+		return nil, err
+	}
+
+	// Verify the signature of the senderkey message.
+	verified := c.verifySignature(senderKeyState.SigningKey().PublicKey(), senderKeyMessage)
+	if !verified {
+		return nil, signalerror.ErrSenderKeyStateVerificationFailed
+	}
+
+	senderKey, err := c.getSenderKey(senderKeyState, senderKeyMessage.Iteration())
+	if err != nil {
+		return nil, err
+	}
+
+	// Decrypt the message ciphertext.
+	plaintext, err := cipher.DecryptCbc(senderKey.Iv(), senderKey.CipherKey(), senderKeyMessage.Ciphertext())
+	if err != nil {
+		return nil, err
+	}
+
+	// Store the sender key by id.
+	if err := c.senderKeyStore.StoreSenderKey(ctx, c.senderKeyID, keyRecord); err != nil {
+		return nil, err
+	}
+
+	return plaintext, nil
+}
+
+// verifySignature will verify the signature of the senderkey message with
+// the given public key.
+func (c *GroupCipher) verifySignature(signingPubKey ecc.ECPublicKeyable,
+	senderKeyMessage *protocol.SenderKeyMessage) bool {
+
+	return ecc.VerifySignature(signingPubKey, senderKeyMessage.Serialize(), senderKeyMessage.Signature())
+}
+
+func (c *GroupCipher) getSenderKey(senderKeyState *record.SenderKeyState, iteration uint32) (*ratchet.SenderMessageKey, error) {
+	senderChainKey := senderKeyState.SenderChainKey()
+	if senderChainKey.Iteration() > iteration {
+		if senderKeyState.HasSenderMessageKey(iteration) {
+			return senderKeyState.RemoveSenderMessageKey(iteration), nil
+		}
+		return nil, fmt.Errorf("%w (current: %d, received: %d)", signalerror.ErrOldCounter, senderChainKey.Iteration(), iteration)
+	}
+
+	if iteration-senderChainKey.Iteration() > 2000 {
+		return nil, signalerror.ErrTooFarIntoFuture
+	}
+
+	for senderChainKey.Iteration() < iteration {
+		senderMessageKey, err := senderChainKey.SenderMessageKey()
+		if err != nil {
+			return nil, err
+		}
+		senderKeyState.AddSenderMessageKey(senderMessageKey)
+		senderChainKey = senderChainKey.Next()
+	}
+
+	senderKeyState.SetSenderChainKey(senderChainKey.Next())
+	return senderChainKey.SenderMessageKey()
+}