whisperfish/presage

A high-level Rust library to help write clients for the Signal Messenger.

Whisperfish

Whisperfish is a native Signal client for Sailfish OS. The user interface is heavily based on the jolla-messages application written by Jolla Ltd.

Whisperfish has plenty of features these days and is in a mostly usable state. Join our development channel on Matrix (#whisperfish:rubdos.be) or Libera.Chat (#whisperfish) to get in touch, and check our wiki to see whether Whisperfish would work for you.

To install, you have two options:

• Releases from OpenRepos
• "Nightly" builds from the Gitlab Package Registry.

In most cases, there should be no need to install from Git directly. We push regular updates to OpenRepos, when they make sense.

Please mind that Whisperfish in still in beta condition, which means that certain things do not work, other things make the application crash, and I've heard reports that beta software can be a cause for dogs eating homework. You've been warned. On the other hand, we have many people happily using Whisperfish as daily driver, and we make up for lacking features in our community support in the aforementioned Matrix and IRC room. Please come say hello! We don't bite (we may byte), and we don't eat homework.

Project Status

This project started from a now outdated Go-based SailfishOS client for Signal. This version, 0.6 and onwards, is a complete rewrite, and uses libsignal-client instead. This means we aim for better maintainability. It also means the whole SailfishOS app had to be rewritten, and you may want to make a back-up of your current files if you still come from 0.5. Specifically:

• .local/share/harbour-whisperfish contains all your data.
• .config/harbour-whisperfish contains the apps configuration.

In current releases the paths have changed:

• .local/share/be.rubdos/harbour-whisperfish
• .config/be.rubdos/harbour-whisperfish

Features

• Registration
• Contact Discovery
• Direct messages
• Group messages
• Sealed sending
• Storing conversations
• Sending attachments
• Taking a photo as an attachment
• Taking a video as an attachment
• Encrypted identity and session store
• Encrypted message store
• Advanced user settings
• Multi-Device support (links with Signal Desktop)
• Encrypted local attachment store
• Archiving conversations
• Muting conversations

Please search the issue tracker before filing any bug report or feature request. Please upvote issues that are important to you. We use the vote counter for determining a feature's priority.

Performance Tips

Whisperfish connects to Signal using Websockets. For a better user experience try adjusting the power settings on your Jolla to disable late suspend. This should keep the network interfaces up and allow Whisperfish to maintain websocket connections even when the device is in "sleep". This could potentially impact your battery life depending on your usage. Otherwise every time your device goes into deep sleep, the Websocket connection is broken and you may not receive messages until the next time the OS wakes up and Whisperfish reconnects.

To disable late suspend and enable "early suspend" run:

mcetool --set-suspend-policy=early

See here for more information.

1. https://together.jolla.com/question/55056/dynamic-pm-in-jolla/
2. http://talk.maemo.org/showpost.php?p=1401956&postcount=29
3. https://sailfishos.org/wiki/Sailfish_OS_Cheat_Sheet#Blocking_Device_Suspend

Building from source

Whisperfish is written in Rust (and QML), and Rust is a bit of a special entity in Sailfish OS. Luckily, Jolla has provided a more or less decent Rust compiler since Sailfish OS 3.4, but it had some issues, which were https://github.com/sailfishos/rust/pull/14 only in Sailfish OS 4.5. Using the corresponding Sailfish SDK 3.10.4 is practically a requirement. Older versions may still work, but are not supported. Using an older version should not be needed, since the binary works all the way down to Sailfish OS 3.4 (at least).

Note: Only the Docker build engine supports Rust compiling. VirtualBox build engine will not work.

Since early January 2024, building Whisperfish (again) requires installing Rust (and its dependencies) from Ruben's repository. This is needed until the Sailfish SDK Jolla releases provides Rust 1.75.0 - at the time of writing the version is 1.52 (with 1.61 upstreamed).

Please see Rust 1.75 build instructions for details.

Once you have the SDK up and running and the Whisperfish sources fetched, it compiles just like any other native Sailfish OS application.

Set the build target 4.5.0.18 and architecture of your choice (builds for target 4.5.0.18 should also work for a few Sailfish OS versions back, too):

sfdk config target=SailfishOS-4.5.0.18-aarch64 build

Then just build it:

sfdk build

If you want to also build the sharing plugin for SFOS 4.3+, use this command (note the double double dashes):

sfdk build -- --with shareplugin_v2

For Sailfish 4.2 and older, use --with shareplugin_v1 instead.

Because of a bug in sb2, it is currently not possible to (reliably) build Whisperfish (or any other Rust project) using more than a single thread. This means your compilation is going to take a while, especially the first time. Get yourself some coffee!

If you get errors (command not found or status 126) at linking stage, make sure that you are not using ~/.cargo/config to override linkers or compilers.

Database

Whisperfish uses SQLCipher to store its data. SQLCipher is essentially SQLite with encryption features. Entering a password when registering Whisperfish makes the database encrypted, without password it's just a plain SQLite database.

During development it's often handy to have a database or schema at hand. If you don't want to mess with your Whisperfish database, or even a copy of it, you can create a plain SQLite database with create-database.sh.

Development environment tips, tricks and hacks

See doc: Cool hacks for development

i18n Translations (help wanted)

Whisperfish supports i18n translations and uses Text ID Based Translations. For an easy way to help translating, you can join on Weblate.

License

Before Whisperfish 0.6.0-alpha.1, "the Rust port", Whisperfish was licensed under the GNU General Public License. Since Whisperfish 0.6.0-alpha.1, Whisperfish links to AGPLv3 code, and as such is a combined work as meant under clause 13 of the GPLv3.

The original GPLv3 licensed code that is still contained in this repository, still falls under GPLv3, as per the copyright of Andrew E. Bruno. This is the original license statement:

Copyright (C) 2016-2018 Andrew E. Bruno

Whisperfish is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see <http://www.gnu.org/licenses/>.

This is the license statement since 2019, since Whisperfish 0.6.0-alpha.1.

Copyright (C) 2019-2020 Ruben De Smet, Markus Törnqvist

Whisperfish is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

Whisperfish is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details.

You should have received a copy of the GNU Affero General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.

presage's Issues

Contacts storage

presage (when linked as secondary device) should intercept the synchronization message containing the contacts attachment blob, and will store them in its local database.

This means we also need a nice API to be able to query contacts, at the very minimum something that returns Vec<Contact> but preferably either helper methods like find_contact_by_phone_number(phone_number: PhoneNumber) or contacts_iter() -> impl Iterator<Item = Contact> such that users can filter it themselves.

Error opening envelope: InvalidFrameError

When receiving messages, mostly from others but also (rarely) from oneself sent on another device, I get:

[2022-07-04T08:18:17Z ERROR presage::manager] Error opening envelope: InvalidFrameError { reason: "Envelope has unknown type UnidentifiedSender." }, message will be skipped!

This also happens on the cli-example, so this must either be a bug on presage or libsignal-service. Note that this bug must have been introduced somewhere between now and the commit 8fcfb6510c3a3ae4aeb9bafb535091d5b6ef1824 as I got another program running on this commit and it is receiving all messages fine.

Update: I have checked a little more and it seems to be from libsignal-service-rs cipher. Inserting a log, I found that both the source id and device from here are None. Maybe something with signal changed?

Local Encryption / Filesystem Sync

Hey there,

first of all, thank you for working on this awesome project!

I am want to use presage as part of my terra-rust-bot to send notifications and to reply to messages.
The only thing I am concerned about is that in case the system is compromised the signal account is not protected. (Encrypted storage #23)
I want to prevent someone else to use the linked device / account and optimally protect the chat history as well.

I would like not to store anything on the filesystem and have the bot save all the information it needs in working memory.
Using:

• https://github.com/unrelentingtech/secstr
• https://github.com/anvie/litcrypt.rs

It looks like the config_store saves everything to the file system.
let config_store = SledConfigStore::new(db_path)?;

Can you point me to the parts of the code I need to change so that the config_store is only used in memory? (from what I read about Sled it fsyncs every 500 ms.)
If you have any other insights I am happy to hear them as well.

Best regards,
Philipp

Secondary device linking is broken

The recent refactoring of the websocket code in libsignal-service-rs enabled keep-alive requests for all websockets, which is incorrect and leads to failure when trying to link as secondary device.

Example cli send broken

cargo run --example=cli -- send --message "ok bob" --phone-number +<countrycode><actualphonenumber without leading 0>

Error: libsignal-service sending error: Unexpected response: HTTP 404

Caused by:
    0: Unexpected response: HTTP 404
    1: Unexpected response: HTTP 404

I would assume that this issue is not necessarily limited to the example cli.

Lots of InvalidSignedPreKeyId errors

Sorry for not understanding the guts of the Signal protocol, but I just want to finally launch my bot on a "production" Signal account in order to do some useful work, but can't get it going. Things worked fine on my little test account.

After several failed attempts, I was able to "link" my presage as a new device. I am now trying to receive some messages, and getting tons of these:

[2023-02-23T14:27:03Z WARN  presage::store::sled] trusting new identity ProtocolAddress { name: "2ad6d5f5-f75a-484e-9539-804235bda596", device_id: DeviceId(1) }
[2023-02-23T14:27:03Z ERROR presage::manager] Error opening envelope: SignalProtocolError(InvalidSignedPreKeyId), message will be skipped!

Things don't improve over time, e.g. trusting that is mentioned in the warning doesn't make a difference. What should I do?

Example cli usage of captcha unclear

I tried registering a new device, unfortunately I am not sure what exactly is expected for the --captcha flag. I went to https://signalcaptchas.org/registration/generate.html, and solved the captcha, I then looked at the devconsole and saw something like this:

I assumed that the address is the captcha, however when I use it in one of the variations below (with signalcaptcha:// protokoll and without), I always get the error "Error: this client is already registered with Signal".

cargo run --example=cli -- register --phone-number +49<XXX> --use-voice-call --captcha 'signalcaptcha://03AGdBq26_isUvEyO8j-UR2treKfupr7j9RB1ZZqTwoPcA....na-GXbhBw'
cargo run --example=cli -- register --phone-number +49<XXX> --use-voice-call --captcha '03AGdBq26_isUvEyO8j-UR2treKfupr7j9RB1ZZqTwoPcA....na-GXbhBw'

Am I doing something wrong (what am I supposed to pass to --captcha), or is this a bug?

Add examples

To make it easier to get started.

Crate does not compile without adjusting Cargo.toml

Due to the following lines at the end of Cargo.toml, this crate will not compile, as the specified directories are nonexistent:

[patch."https://github.com/Michael-F-Bryan/libsignal-protocol-rs.git"]
libsignal-protocol = { path = "../libsignal-protocol-rs/libsignal-protocol" }

[patch."https://github.com/Michael-F-Bryan/libsignal-service-rs.git"]
libsignal-service = {path = "../libsignal-service-rs/libsignal-service" }
libsignal-service-actix = {path = "../libsignal-service-rs/libsignal-service-actix" }

Removing them, and uncommenting the surrounding lines, fixes this issue.

Example cli device-name flag broken

Running the following command links an "Unknown Device". I would have expected the device to be named "hunter".

cargo run --example=cli -- link-device --device-name hunter

List messages should be inside the manager

Currently we fetch the messages directly from the sled store (let iter = config_store.messages(&thread, None)?;). This should be changed to the manager because it's a common task.

Start versioning using tags

Since we can't publish our crates' ecosystem on crates.io because we have a few git dependencies (mostly libsignal-client) we should at least try to version presage with tags that are known to be working.

Remove deleted account from group

From testing in the Whisperfish room, one gets a 404 when sending a message to a room with a group member that disappeared. As @rubdos mentioned, presage should maybe handle that 404 and delete that user from the group.

Push support via UnifiedPush

Would this library be the right place to implement push support via UnifiedPush specification (for Whisperfish, Axolotl, ...)?

Blocked by UnifiedPush/wishlist#8

CLI send-to-group does not work

Currently the send-to-group of the CLI does not work. It seems that sending using PhoneNumbers is deprecated and one should send using the UUID. For more information, see the Whisperfish Signal group chat.

I may try to fix that myself and make a PR as I need this to try to replicate another bug I am having.

Send read receipts

Re-exports relevant portions of libsignal_*

To make this crate useful without adding transitive dependencies in Cargo.toml.

Things that come to mind, libsignal_protocol::Context and libsignal_protocol::Crypto.

Don't save every message to the store.

Currently, every sync message is saved to the store. But that's not necessary, can we make a list for what is relevant and what not?

Add message storage

Move the message storage from https://github.com/boxdot/gurk-rs/ to presage, which should make it more useful. This will also make implementing encryption easier, since it'll be in a single place. Pinging @boxdot to fill in the details.

Sending messages broke

After intializing manager and starting listening to it, sending does not work:

2023-01-20T08:41:46.470559Z ERROR gurk::signal::r#impl: Failed to send message to 779a6c6b-0985-479a-86fc-ce435a3db130: message pipe not started, you need to start receiving messages before you can send anything back

I see in the logs, that there is a connection to the websocket though. Maybe cloning the manager does not share the state?

Add basic store tests

Just to make sure we never break fetching messages from store, and can retain the expectations from the public API.

The GroupIter should return the [u8,32] instead of a GroupMasterKey

The GroupMasterKey can't be transformed back to an array. That makes it difficult to save a group received by a GroupIter.

presage/src/store/mod.rs

Line 66 in 16c7d93

type GroupsIter: Iterator<Item = Result<(GroupMasterKey, Group), Error>>;

"Rate limit exceeded" when sending a single message

When using the Manager's send_message method, I will always run into the following error:

[INFO  libsignal_service::sender] establishing new session with ProtocolAddress { name: "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX", device_id: 1 }
[WARN  presage::config::sled] trusting new identity ProtocolAddress { name: "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX", device_id: 1 }
[INFO  libsignal_protocol::session] set_unacknowledged_pre_key_message for: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX.1 with preKeyId: XXXXXXXX
[INFO  libsignal_protocol::state::session] Skipping archive, current session state is fresh
[INFO  libsignal_protocol::session] set_unacknowledged_pre_key_message for: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX.2 with preKeyId: XXX
[INFO  libsignal_protocol::session_cipher] Building PreKeyWhisperMessage for: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX.1 with preKeyId: XXXXXXXX
[INFO  libsignal_protocol::session] set_unacknowledged_pre_key_message for: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX.2 with preKeyId: XXX
[INFO  libsignal_protocol::session_cipher] Building PreKeyWhisperMessage for: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX.1 with preKeyId: XXXXXXXX
[INFO  libsignal_protocol::session] set_unacknowledged_pre_key_message for: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX.2 with preKeyId: XXX
[INFO  libsignal_protocol::session_cipher] Building PreKeyWhisperMessage for: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX.1 with preKeyId: XXXXXXXX
[INFO  libsignal_protocol::session] set_unacknowledged_pre_key_message for: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX.2 with preKeyId: XXX
[INFO  libsignal_protocol::session_cipher] Building PreKeyWhisperMessage for: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX.1 with preKeyId: XXXXXXXX
Error: libsignal-service sending error: Rate limit exceeded

Caused by:
    0: Rate limit exceeded
    1: Rate limit exceeded

This occurs whenever I try to send only one message to another Signal account. I've tried many variations of the code, but always with the same result.

Here is the relevant code:

let number = phonenumber::parse(None, "[phone]")?;

let timestamp = std::time::SystemTime::now()
    .duration_since(UNIX_EPOCH)
    .expect("negative time")
    .as_millis() as u64;

let message = ContentBody::DataMessage(DataMessage {
    body: Some("test"),
    timestamp: Some(timestamp),
    ..Default::default()
});

manager.send_message(number, message, timestamp).await?;

failed to select a version for the requirement `curve25519-dalek = "^2.0.0"`

With this simple Cargo.toml

[package]
edition = "2021"
name = "project"
version = "0.1.0"

[dependencies]
presage = {git = "https://github.com/whisperfish/presage"}

when I run cargo update I have this error :

error: failed to select a version for the requirement `curve25519-dalek = "^2.0.0"`
candidate versions found which didn't match: 3.2.1
location searched: Git repository https://github.com/signalapp/curve25519-dalek.git?branch=lizard2
required by package `zkgroup v0.7.3 (https://github.com/signalapp/zkgroup?tag=v0.7.3#197c382e)`
    ... which satisfies git dependency `zkgroup` of package `libsignal-service v0.1.0 (https://github.com/whisperfish/libsignal-service-rs?rev=efd4ea86f57520d99141bb9c1c4b38a2ac646d6a#efd4ea86)`
    ... which satisfies git dependency `libsignal-service` of package `presage v0.2.0 (https://github.com/whisperfish/presage#8fcfb651)`
    ... which satisfies git dependency `presage` of package `project v0.1.0 (/tmp/project)`

Thank you !

Updating from sled store prior to 55772b

Hi! First of all, thank you for this software. I've been running commit f9ae9b2 in an application of mine since February without any problems.

Since the root CA changed in whisperfish/libsignal-service-rs#168 and my application stopped working, I figured it would be a good time to update presage too.

However, when I now invoke presage it tells me that my phone number is not yet registered. I root-caused it to the sled store having changed: in 55772b7 a sled key changed from state to registration. I've not been keeping up with updates to the project, so perhaps other changes to sled store usage have been made since February. Is the sled store format used by presage documented somewhere?

Is it possible to update my sled store to the new format? I can't start afresh by creating the sled store in the new format because the phone number is already registered with Signal, and it appears Signal won't let me re-register it.

Panic after resetting session mid conversation

I am using the presage library in a very similar manner to the CLI "receive" command, and while actively receiving messages, if I hit "Reset session" in Signal Desktop, the following will occur:

[INFO  libsignal_protocol::state::session] Skipping archive, current session state is fresh
[INFO  libsignal_protocol::session_cipher] XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX.2 creating new chains.
thread 'main' panicked at 'tx channel error: SendError { kind: Disconnected }', /home/user/.cargo/git/checkouts/presage-6024bc59a812fbaf/8c6476f/src/manager.rs:630:62
stack backtrace:
   0: rust_begin_unwind
             at /rustc/2fd73fabe469357a12c2c974c140f67e7cdd76d0/library/std/src/panicking.rs:493:5
   1: core::panicking::panic_fmt
             at /rustc/2fd73fabe469357a12c2c974c140f67e7cdd76d0/library/core/src/panicking.rs:92:14
   2: core::option::expect_none_failed
             at /rustc/2fd73fabe469357a12c2c974c140f67e7cdd76d0/library/core/src/option.rs:1300:5
   3: core::result::Result<T,E>::expect
             at /rustc/2fd73fabe469357a12c2c974c140f67e7cdd76d0/library/core/src/result.rs:997:23
   4: presage::manager::Manager<C,R>::receive_messages::{{closure}}
             at /home/user/.cargo/git/checkouts/presage-6024bc59a812fbaf/8c6476f/src/manager.rs:630:30
   5: <core::future::from_generator::GenFuture<T> as core::future::future::Future>::poll
             at /rustc/2fd73fabe469357a12c2c974c140f67e7cdd76d0/library/core/src/future/mod.rs:80:19
   6: <futures_util::future::maybe_done::MaybeDone<Fut> as core::future::future::Future>::poll
             at /home/user/.cargo/registry/src/github.com-1ecc6299db9ec823/futures-util-0.3.14/src/future/maybe_done.rs:95:38
   7: <futures_util::future::join::Join<Fut1,Fut2> as core::future::future::Future>::poll
             at /home/user/.cargo/registry/src/github.com-1ecc6299db9ec823/futures-util-0.3.14/src/future/join.rs:55:33
   8: test2::on_message::{{closure}}
             at ./src/main.rs:54:9
   9: <core::future::from_generator::GenFuture<T> as core::future::future::Future>::poll
             at /rustc/2fd73fabe469357a12c2c974c140f67e7cdd76d0/library/core/src/future/mod.rs:80:19
  10: test2::main::{{closure}}
             at ./src/main.rs:30:5
  11: <core::future::from_generator::GenFuture<T> as core::future::future::Future>::poll
             at /rustc/2fd73fabe469357a12c2c974c140f67e7cdd76d0/library/core/src/future/mod.rs:80:19
  12: <core::pin::Pin<P> as core::future::future::Future>::poll
             at /rustc/2fd73fabe469357a12c2c974c140f67e7cdd76d0/library/core/src/future/future.rs:119:9
  13: tokio::runtime::basic_scheduler::Inner<P>::block_on::{{closure}}::{{closure}}
             at /home/user/.cargo/registry/src/github.com-1ecc6299db9ec823/tokio-1.5.0/src/runtime/basic_scheduler.rs:213:62
  14: tokio::coop::with_budget::{{closure}}
             at /home/user/.cargo/registry/src/github.com-1ecc6299db9ec823/tokio-1.5.0/src/coop.rs:106:9
  15: std::thread::local::LocalKey<T>::try_with
             at /rustc/2fd73fabe469357a12c2c974c140f67e7cdd76d0/library/std/src/thread/local.rs:272:16
  16: std::thread::local::LocalKey<T>::with
             at /rustc/2fd73fabe469357a12c2c974c140f67e7cdd76d0/library/std/src/thread/local.rs:248:9
  17: tokio::coop::with_budget
             at /home/user/.cargo/registry/src/github.com-1ecc6299db9ec823/tokio-1.5.0/src/coop.rs:99:5
  18: tokio::coop::budget
             at /home/user/.cargo/registry/src/github.com-1ecc6299db9ec823/tokio-1.5.0/src/coop.rs:76:5
  19: tokio::runtime::basic_scheduler::Inner<P>::block_on::{{closure}}
             at /home/user/.cargo/registry/src/github.com-1ecc6299db9ec823/tokio-1.5.0/src/runtime/basic_scheduler.rs:213:39
  20: tokio::runtime::basic_scheduler::enter::{{closure}}
             at /home/user/.cargo/registry/src/github.com-1ecc6299db9ec823/tokio-1.5.0/src/runtime/basic_scheduler.rs:323:29
  21: tokio::macros::scoped_tls::ScopedKey<T>::set
             at /home/user/.cargo/registry/src/github.com-1ecc6299db9ec823/tokio-1.5.0/src/macros/scoped_tls.rs:61:9
  22: tokio::runtime::basic_scheduler::enter
             at /home/user/.cargo/registry/src/github.com-1ecc6299db9ec823/tokio-1.5.0/src/runtime/basic_scheduler.rs:323:5
  23: tokio::runtime::basic_scheduler::Inner<P>::block_on
             at /home/user/.cargo/registry/src/github.com-1ecc6299db9ec823/tokio-1.5.0/src/runtime/basic_scheduler.rs:202:9
  24: tokio::runtime::basic_scheduler::InnerGuard<P>::block_on
             at /home/user/.cargo/registry/src/github.com-1ecc6299db9ec823/tokio-1.5.0/src/runtime/basic_scheduler.rs:481:9
  25: tokio::runtime::basic_scheduler::BasicScheduler<P>::block_on
             at /home/user/.cargo/registry/src/github.com-1ecc6299db9ec823/tokio-1.5.0/src/runtime/basic_scheduler.rs:162:24
  26: tokio::runtime::Runtime::block_on
             at /home/user/.cargo/registry/src/github.com-1ecc6299db9ec823/tokio-1.5.0/src/runtime/mod.rs:450:46
  27: test2::main
             at ./src/main.rs:11:1
  28: core::ops::function::FnOnce::call_once
             at /rustc/2fd73fabe469357a12c2c974c140f67e7cdd76d0/library/core/src/ops/function.rs:227:5

request_contact_sync can't work without uid

When registering a new device and calling request_contact_sync, the send_message function is called with the user phone number as first argument.

However, this can't work since the store saves user information by uuid and not by phone number. If the keys aren't found in the store, then no encrypted message is given to the server and then, the request fails (http 404 error). It isn't critical but the register process partially fails.

I think that the let phone_number = ... line and the last line should be replaced by something about uuid so it is possible to find the corresponding keys.

Below is my modified function (manager.rs) :

pub async fn request_contacts_sync(&self) -> Result<(), Error> {
    let uuid = match &self.state {
        State::Registered { uuid, .. } => uuid,
        _ => return Err(Error::NotYetRegisteredError),
    };

    let sync_message = SyncMessage {
        request: Some(sync_message::Request {
            r#type: Some(sync_message::request::Type::Contacts as i32),
        }),
        ..Default::default()
    };

    let timestamp = std::time::SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .expect("Time went backwards")
        .as_millis() as u64;

    self.send_message(uuid.clone(), sync_message, timestamp).await?;

    Ok(())
}

Handler::register should be use a a password generator that implements Send

In order to register in a thread, the all functions should implement the Send trait.

We could change -> https://github.com/whisperfish/presage/blob/main/src/manager.rs#L189

        // generate a random 24 bytes password
        let rng = rand::thread_rng();
        let password: String = rng.sample_iter(&Alphanumeric).take(24).collect();

to

        // generate a send safe random 24 bytes password
        let mut rng = StdRng::from_entropy();

        // Generate a 24-byte password as a vector of bytes.
        let password_vec: Vec<u8> = (0..24).map(|_| rng.gen()).collect();
        let password = hex::encode(password_vec);

CI builds for macOS and Windows

Investigate what kind of builds we can get for the presage-cli

DB migrations

It's rather annoying that the DB schema keeps breaking without any way forward for existing users, slowing down adoption or upgrades from downstream users.

#73 is a good example of a change that should happen transparently.

Notes:

• Introduce schema versioning stored in the db
• Add a Rust file for each version bump
• Test it

Add changelog

Sometimes methods block indefinitly

I do not really know where but occasionally (mainly after many requests), some methods just block indefinitely, never return and use one full CPU-thread. I have seen this e.g. for

• Querying groups
• Sending messages
• Receiving messages (the never-returns is obvious here, but it still blocks indefinitely, crashes my application and uses a full core).
• Attachments

Note that it may also be a misuse of presage on my part, but I doubt it as it works fine most of the time.
Regarding logs, I have some but they do not really seem useful. Here is e.g. a log comparing successful message sending vs unsuccessful sending:

Successful sending

[2022-07-29T11:10:39Z TRACE flare::backend::manager] `Manager::send_message`start
[2022-07-29T11:10:39Z INFO  flare::storage::encrypted_sled] get_sub_device_sessions: session_prefix=CENSORED
[2022-07-29T11:10:39Z INFO  flare::storage::encrypted_sled] get_sub_device_sessions: session_prefix=CENSORED
[2022-07-29T11:10:39Z TRACE libsignal_service::sender] sending message to device 1
[2022-07-29T11:10:39Z TRACE flare::storage::encrypted_sled] loading session from CENSORED
[2022-07-29T11:10:39Z TRACE flare::storage::encrypted_sled] loading session from CENSORED
[2022-07-29T11:10:39Z TRACE flare::storage::encrypted_sled] loading session from CENSORED
[2022-07-29T11:10:39Z TRACE libsignal_service::sender] encrypting message for ProtocolAddress { name: "CENSORED", device_id: 1 }
[2022-07-29T11:10:39Z TRACE flare::storage::encrypted_sled] loading session from CENSORED
[2022-07-29T11:10:39Z TRACE flare::storage::encrypted_sled] loading session from CENSORED
[2022-07-29T11:10:39Z TRACE flare::storage::encrypted_sled] loading session from CENSORED
[2022-07-29T11:10:39Z TRACE flare::storage::encrypted_sled] get identity-remote-CENSORED
[2022-07-29T11:10:39Z TRACE flare::storage::encrypted_sled] saving identity
[2022-07-29T11:10:39Z TRACE flare::storage::encrypted_sled] inserting identity-remote-CENSORED
[2022-07-29T11:10:39Z TRACE flare::storage::encrypted_sled] saved identity
[2022-07-29T11:10:39Z TRACE flare::storage::encrypted_sled] storing session for ProtocolAddress { name: "CENSORED", device_id: 1 } at "CENSORED
[2022-07-29T11:10:39Z TRACE libsignal_service::sender] sending message to device 2
[2022-07-29T11:10:39Z TRACE flare::storage::encrypted_sled] loading session from CENSORED
[2022-07-29T11:10:39Z TRACE flare::storage::encrypted_sled] loading session from CENSORED
[2022-07-29T11:10:39Z TRACE flare::storage::encrypted_sled] loading session from CENSORED
[2022-07-29T11:10:39Z TRACE libsignal_service::sender] encrypting message for ProtocolAddress { name: "CENSORED", device_id: 2 }
[2022-07-29T11:10:39Z TRACE flare::storage::encrypted_sled] loading session from CENSORED
[2022-07-29T11:10:39Z TRACE flare::storage::encrypted_sled] loading session from CENSORED
[2022-07-29T11:10:39Z TRACE flare::storage::encrypted_sled] loading session from CENSORED
[2022-07-29T11:10:39Z TRACE flare::storage::encrypted_sled] get identity-remote-CENSORED
[2022-07-29T11:10:39Z TRACE flare::storage::encrypted_sled] saving identity
[2022-07-29T11:10:39Z TRACE flare::storage::encrypted_sled] inserting identity-remote-CENSORED
[2022-07-29T11:10:39Z TRACE flare::storage::encrypted_sled] saved identity
[2022-07-29T11:10:39Z TRACE flare::storage::encrypted_sled] storing session for ProtocolAddress { name: "CENSORED", device_id: 2 } at "CENSORED
[2022-07-29T11:10:39Z TRACE libsignal_service::sender] sending message to device 3
[2022-07-29T11:10:39Z TRACE flare::storage::encrypted_sled] loading session from CENSORED
[2022-07-29T11:10:39Z TRACE flare::storage::encrypted_sled] loading session from CENSORED
[2022-07-29T11:10:39Z TRACE flare::storage::encrypted_sled] loading session from CENSORED
[2022-07-29T11:10:39Z TRACE libsignal_service::sender] encrypting message for ProtocolAddress { name: "CENSORED", device_id: 3 }
[2022-07-29T11:10:39Z TRACE flare::storage::encrypted_sled] loading session from CENSORED
[2022-07-29T11:10:39Z TRACE flare::storage::encrypted_sled] loading session from CENSORED
[2022-07-29T11:10:39Z TRACE flare::storage::encrypted_sled] loading session from CENSORED
[2022-07-29T11:10:39Z TRACE flare::storage::encrypted_sled] get identity-remote-CENSORED
[2022-07-29T11:10:39Z TRACE flare::storage::encrypted_sled] saving identity
[2022-07-29T11:10:39Z TRACE flare::storage::encrypted_sled] inserting identity-remote-CENSORED
[2022-07-29T11:10:39Z TRACE flare::storage::encrypted_sled] saved identity
[2022-07-29T11:10:39Z TRACE flare::storage::encrypted_sled] storing session for ProtocolAddress { name: "CENSORED", device_id: 3 } at "CENSORED
[2022-07-29T11:10:39Z TRACE libsignal_service::sender] sending message to device 5
[2022-07-29T11:10:39Z TRACE flare::storage::encrypted_sled] loading session from CENSORED
[2022-07-29T11:10:39Z TRACE flare::storage::encrypted_sled] loading session from CENSORED
[2022-07-29T11:10:39Z TRACE flare::storage::encrypted_sled] loading session from CENSORED
[2022-07-29T11:10:39Z TRACE libsignal_service::sender] encrypting message for ProtocolAddress { name: "CENSORED", device_id: 5 }
[2022-07-29T11:10:39Z TRACE flare::storage::encrypted_sled] loading session from CENSORED
[2022-07-29T11:10:39Z TRACE flare::storage::encrypted_sled] loading session from CENSORED
[2022-07-29T11:10:39Z TRACE flare::storage::encrypted_sled] loading session from CENSORED
[2022-07-29T11:10:39Z TRACE flare::storage::encrypted_sled] get identity-remote-CENSORED
[2022-07-29T11:10:39Z TRACE flare::storage::encrypted_sled] saving identity
[2022-07-29T11:10:39Z TRACE flare::storage::encrypted_sled] inserting identity-remote-CENSORED
[2022-07-29T11:10:39Z TRACE flare::storage::encrypted_sled] saved identity
[2022-07-29T11:10:39Z TRACE flare::storage::encrypted_sled] storing session for ProtocolAddress { name: "CENSORED", device_id: 5 } at "CENSORED
[2022-07-29T11:10:39Z DEBUG libsignal_service_hyper::push_service] HTTP request PUT https://chat.signal.org/v1/messages/CENSORED
[2022-07-29T11:10:39Z TRACE mio::poll] registering event source with poller: token=Token(CENSORED), interests=READABLE | WRITABLE
[2022-07-29T11:10:39Z DEBUG rustls::client::hs] No cached session for DnsName(DnsName(DnsName("chat.signal.org")))
[2022-07-29T11:10:39Z DEBUG rustls::client::hs] Not resuming any session
[2022-07-29T11:10:39Z TRACE rustls::client::hs] Sending ClientHello Message {
        version: TLSv1_0,
        payload: Handshake {
            parsed: HandshakeMessagePayload {
                typ: ClientHello,
                payload: ClientHello(
                    ClientHelloPayload {
                        client_version: TLSv1_2,
                        random: CENSORED,
                        session_id: CENSORED,
                        cipher_suites: [
                            TLS13_AES_256_GCM_SHA384,
                            TLS13_AES_128_GCM_SHA256,
                            TLS13_CHACHA20_POLY1305_SHA256,
                            TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
                            TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
                            TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256,
                            TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
                            TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
                            TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256,
                            TLS_EMPTY_RENEGOTIATION_INFO_SCSV,
                        ],
                        compression_methods: [
                            Null,
                        ],
                        extensions: [
                            SupportedVersions(
                                [
                                    TLSv1_3,
                                    TLSv1_2,
                                ],
                            ),
                            ECPointFormats(
                                [
                                    Uncompressed,
                                ],
                            ),
                            NamedGroups(
                                [
                                    X25519,
                                    secp256r1,
                                    secp384r1,
                                ],
                            ),
                            SignatureAlgorithms(
                                [
                                    ECDSA_NISTP384_SHA384,
                                    ECDSA_NISTP256_SHA256,
                                    ED25519,
                                    RSA_PSS_SHA512,
                                    RSA_PSS_SHA384,
                                    RSA_PSS_SHA256,
                                    RSA_PKCS1_SHA512,
                                    RSA_PKCS1_SHA384,
                                    RSA_PKCS1_SHA256,
                                ],
                            ),
                            ExtendedMasterSecretRequest,
                            CertificateStatusRequest(
                                OCSP(
                                    OCSPCertificateStatusRequest {
                                        responder_ids: [],
                                        extensions: ,
                                    },
                                ),
                            ),
                            ServerName(
                                [
                                    ServerName {
                                        typ: HostName,
                                        payload: HostName(
                                            (
                                                CENSORED,
                                                DnsName(
                                                    "chat.signal.org",
                                                ),
                                            ),
                                        ),
                                    },
                                ],
                            ),
                            SignedCertificateTimestampRequest,
                            KeyShare(
                                [
                                    KeyShareEntry {
                                        group: X25519,
                                        payload: CENSORED,
                                    },
                                ],
                            ),
                            PresharedKeyModes(
                                [
                                    PSK_DHE_KE,
                                ],
                            ),
                            Protocols(
                                [
                                    CENSORED,
                                ],
                            ),
                            SessionTicket(
                                Request,
                            ),
                        ],
                    },
                ),
            },
            encoded: CENSORED,
        },
    }
[2022-07-29T11:10:40Z TRACE rustls::client::hs] We got ServerHello ServerHelloPayload {
        legacy_version: TLSv1_2,
        random: CENSORED,
        session_id: ,
        cipher_suite: TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
        compression_method: Null,
        extensions: [
            ServerNameAck,
            RenegotiationInfo(
                ,
            ),
            ECPointFormats(
                [
                    Uncompressed,
                    ANSIX962CompressedPrime,
                    ANSIX962CompressedChar2,
                ],
            ),
            Protocols(
                [
                    687474702f312e31,
                ],
            ),
        ],
    }
[2022-07-29T11:10:40Z DEBUG rustls::client::hs] ALPN protocol is Some(b"http/1.1")
[2022-07-29T11:10:40Z DEBUG rustls::client::hs] Using ciphersuite TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256
[2022-07-29T11:10:40Z DEBUG rustls::client::tls12] ECDHE curve is ECParameters { curve_type: NamedCurve, named_group: secp256r1 }
[2022-07-29T11:10:40Z TRACE rustls::client::tls12] Server cert is [Certificate(b"CENSORED"), Certificate(b"CENSORED")]
[2022-07-29T11:10:40Z DEBUG rustls::client::tls12] Server DNS name is DnsName(DnsName(DnsName("chat.signal.org")))
[2022-07-29T11:10:40Z DEBUG rustls::client::tls12] Session not saved: server didn't allocate id or ticket
[2022-07-29T11:10:40Z TRACE want] signal: Want
[2022-07-29T11:10:40Z TRACE want] signal found waiting giver, notifying
[2022-07-29T11:10:40Z TRACE want] poll_want: taker wants!
[2022-07-29T11:10:40Z TRACE want] signal: Want
[2022-07-29T11:10:40Z TRACE want] signal found waiting giver, notifying
[2022-07-29T11:10:40Z TRACE want] signal: Want
[2022-07-29T11:10:40Z TRACE want] poll_want: taker wants!
[2022-07-29T11:10:40Z DEBUG libsignal_service::sender] message sent!
[2022-07-29T11:10:40Z TRACE want] signal: Want
[2022-07-29T11:10:40Z TRACE flare::backend::manager] `Manager::send_message`finished

Not successful sending

... (Equivalent up to here)
[2022-07-29T11:10:42Z DEBUG rustls::client::hs] ALPN protocol is Some(b"http/1.1")
[2022-07-29T11:10:42Z DEBUG rustls::client::hs] Using ciphersuite TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256
[2022-07-29T11:10:42Z DEBUG rustls::client::tls12] ECDHE curve is ECParameters { curve_type: NamedCurve, named_group: secp256r1 }
[2022-07-29T11:10:42Z TRACE rustls::client::tls12] Server cert is [Certificate(b"CENSORED"), Certificate(b"CENSORED")]
[2022-07-29T11:10:42Z DEBUG rustls::client::tls12] Server DNS name is DnsName(DnsName(DnsName("chat.signal.org")))
[2022-07-29T11:10:42Z DEBUG rustls::client::tls12] Session not saved: server didn't allocate id or ticket
[2022-07-29T11:10:42Z TRACE want] signal: Want
[2022-07-29T11:10:42Z TRACE want] signal found waiting giver, notifying
[2022-07-29T11:10:42Z TRACE want] poll_want: taker wants!
[2022-07-29T11:10:42Z TRACE libsignal_service_hyper::websocket] Triggering keep-alive
[2022-07-29T11:10:42Z TRACE libsignal_service::messagepipe] Sending request WebSocketRequestMessage { verb: Some("GET"), path: Some("/v1/keepalive"), body: None, headers: [], id: Some(CENSORED) }
[2022-07-29T11:10:42Z TRACE libsignal_service::messagepipe] request on route.
[2022-07-29T11:10:42Z TRACE want] signal: Want
[2022-07-29T11:10:42Z TRACE want] signal: Want
[2022-07-29T11:10:42Z TRACE libsignal_service::messagepipe] Decoded WebSocketMessage { r#type: Some(Response), request: None, response: Some(WebSocketResponseMessage { id: Some(CENSORED), status: Some(200), message: Some("OK"), headers: ["Content-Length:0"], body: None }) }

I also have one where it fails to receive messages, but there it is not really clear where the interesting parts begin and end.

I do not yet know if/how I could reproduce it without Flare, but this crash for example happened when sending 7 messages to "Note to self", the last one failed.

Update: I also just now got a ClientHello message that is not answered by the server. Maybe some messages get lost during transfer, but as (as far as I see) TLS is used, this should not be a issue.

Encrypted storage

We use sled as the main implementation of the ConfigStore trait. We need to figure out a way to encrypt the data stored on disk.

• whisperfish uses sqlite and diesel, with an extension called sqlcipher to encrypt data on the fly.
• This is not possible with sled, so we probably want to either:
  a. decrypt the database on startup in some shared memory file with very restricted permissions and store the secret in the native OS keyring (e.g. gnome-keyring or the one on macOS). This is very error prone since we have to make sure we re-encrypt the data every time something changes
  b. encrypt/decrypt the bytes that sled returns on the fly

See spacejam/sled#1196

Handle UntrustedIdentity

As discussed in the Whisperfish Matrix room, presage should probably catch that error and send a identity-reset message.

Related error in Flare: https://gitlab.com/Schmiddiii/flare/-/issues/43.

Unknown contact handling

If i receive a message from an unknown contact it should create a new contact and fetch the profile for the username.

Making the future returned by get_attachment Send?

Hi, I was just wondering if there was any possible way to make the future returned by Manager::get_attachment Send, so that attachments can be downloaded in separate threads to avoid blocking.

saving contacts panics.

When I use the example to receive messages sometimes the thread panics.

For some reason there are empty contacts.

Contact { address: ServiceAddress { uuid: None, phonenumber: None, relay: None }, name: "", color: None, verified: Verified { destination_e164: None, destination_uuid: None, identity_key: None, state: None, null_message: None }, profile_key: [], blocked: false, expire_timer: 0, inbox_position: 0, archived: false, avatar: None }

I modified sled.rs:

fn save_contacts(&mut self, contacts: impl Iterator<Item = Contact>) -> Result<(), Error> {
        let tree = self
            .db
            .write()
            .expect("poisoned mutex")
            .open_tree(SLED_KEY_CONTACTS)?;
        for contact in contacts {
            if let Some(uuid) = contact.address.uuid {
                tree.insert(
                    uuid.to_string(),
                    serde_json::to_vec(&contact)?,
                )?;
            }else{
                println!("Error serializing contact: {:?}", contact);
            }
        }
        debug!("saved contacts");
        Ok(())
    }

cargo build failing

Adding this dependency in cargo.toml:

...

[dependencies]
presage = { git = "https://github.com/whisperfish/presage" }

...

and then doing cargo build, I get the following error:

...

Caused by:
Unable to update https://github.com/whisperfish/libsignal-service-rs?rev=bfc293000e058924771c0651c16bb19fb778c4ef

Caused by:
revspec 'bfc293000e058924771c0651c16bb19fb778c4ef' not found; class=Reference (4); code=NotFound (-3)

Feature Requests

Here is a list of feature requests that might fit good into presage as most clients building upon that may want such features. I will not be able to work on any of those features in the next few months, and do not expect any of you to work on it if you don' t want to:

• Clearing messages without clearing other data
• Group Storage similar to request_contacts_sync and get_contacts
• Encrypted attachment storage
• Last-read/received message by Thread and Contact
• Query reactions by message
• Handle delete-messages
• Wrapper for stores: When implementing all of those above options, some clients may want to turn some things off. I would therefore make a light wrapper around any generic store that has a builder to en- or disable features and depending on if those features are en- or disabled, either proxy the method to the underlying store or return defaults.

Registration fails, when pin start with a 0

confirm_verification_code https://github.com/whisperfish/presage/blob/main/src/manager.rs#L373 should use a string instead of a u32 because when the code is 001234 then the first 2 digits are dropped.

The bug is inherited from libsignal-service-rs
https://github.com/whisperfish/libsignal-service-rs/blob/main/libsignal-service/src/provisioning/manager.rs#L173

Sent messages to groups are sometimes received twice

When sending a message to a group (as a secondary device), one can see in the main device that the message was sent (right side) but also that the same message was received from the own contact (left side). Additionally, other people in the chat also sometimes receive the message twice (see e.g. the Whisperfish Signal group).

This can be reproduced in the cli in the PR I made.

Also no need to hurry, just wanted to make sure it will not be forgotten.

Log (Censored, UUIDs replaced by UUID1 - UUID7)

[2022-08-04T15:56:15Z DEBUG cli] opening config database from CENSORED
[2022-08-04T15:56:15Z DEBUG libsignal_service_hyper::push_service] HTTP request GET https://chat.signal.org/v1/certificate/group/CENSORED/CENSORED
[2022-08-04T15:56:15Z TRACE mio::poll] registering event source with poller: token=Token(0), interests=READABLE | WRITABLE
[2022-08-04T15:56:15Z DEBUG rustls::client::hs] No cached session for DnsName(DnsName(DnsName("chat.signal.org")))
[2022-08-04T15:56:15Z DEBUG rustls::client::hs] Not resuming any session
[2022-08-04T15:56:15Z TRACE rustls::client::hs] Sending ClientHello Message {
        version: TLSv1_0,
        payload: Handshake {
            parsed: HandshakeMessagePayload {
                typ: ClientHello,
                payload: ClientHello(
                    ClientHelloPayload {
                        client_version: TLSv1_2,
                        random: CENSORED,
                        session_id: CENSORED,
                        cipher_suites: [
                            TLS13_AES_256_GCM_SHA384,
                            TLS13_AES_128_GCM_SHA256,
                            TLS13_CHACHA20_POLY1305_SHA256,
                            TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
                            TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
                            TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256,
                            TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
                            TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
                            TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256,
                            TLS_EMPTY_RENEGOTIATION_INFO_SCSV,
                        ],
                        compression_methods: [
                            Null,
                        ],
                        extensions: [
                            SupportedVersions(
                                [
                                    TLSv1_3,
                                    TLSv1_2,
                                ],
                            ),
                            ECPointFormats(
                                [
                                    Uncompressed,
                                ],
                            ),
                            NamedGroups(
                                [
                                    X25519,
                                    secp256r1,
                                    secp384r1,
                                ],
                            ),
                            SignatureAlgorithms(
                                [
                                    ECDSA_NISTP384_SHA384,
                                    ECDSA_NISTP256_SHA256,
                                    ED25519,
                                    RSA_PSS_SHA512,
                                    RSA_PSS_SHA384,
                                    RSA_PSS_SHA256,
                                    RSA_PKCS1_SHA512,
                                    RSA_PKCS1_SHA384,
                                    RSA_PKCS1_SHA256,
                                ],
                            ),
                            ExtendedMasterSecretRequest,
                            CertificateStatusRequest(
                                OCSP(
                                    OCSPCertificateStatusRequest {
                                        responder_ids: [],
                                        extensions: ,
                                    },
                                ),
                            ),
                            ServerName(
                                [
                                    ServerName {
                                        typ: HostName,
                                        payload: HostName(
                                            (
                                                CENSORED,
                                                DnsName(
                                                    "chat.signal.org",
                                                ),
                                            ),
                                        ),
                                    },
                                ],
                            ),
                            SignedCertificateTimestampRequest,
                            KeyShare(
                                [
                                    KeyShareEntry {
                                        group: X25519,
                                        payload: CENSORED,
                                    },
                                ],
                            ),
                            PresharedKeyModes(
                                [
                                    PSK_DHE_KE,
                                ],
                            ),
                            Protocols(
                                [
                                    687474702f312e31,
                                ],
                            ),
                            SessionTicket(
                                Request,
                            ),
                        ],
                    },
                ),
            },
            encoded: CENSORED,
        },
    }
[2022-08-04T15:56:15Z TRACE rustls::client::hs] We got ServerHello ServerHelloPayload {
        legacy_version: TLSv1_2,
        random: CENSORED,
        session_id: ,
        cipher_suite: TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
        compression_method: Null,
        extensions: [
            ServerNameAck,
            RenegotiationInfo(
                ,
            ),
            ECPointFormats(
                [
                    Uncompressed,
                    ANSIX962CompressedPrime,
                    ANSIX962CompressedChar2,
                ],
            ),
            Protocols(
                [
                    687474702f312e31,
                ],
            ),
        ],
    }
[2022-08-04T15:56:15Z DEBUG rustls::client::hs] ALPN protocol is Some(b"http/1.1")
[2022-08-04T15:56:15Z DEBUG rustls::client::hs] Using ciphersuite TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256
[2022-08-04T15:56:15Z DEBUG rustls::client::tls12] ECDHE curve is ECParameters { curve_type: NamedCurve, named_group: secp256r1 }
[2022-08-04T15:56:15Z TRACE rustls::client::tls12] Server cert is [Certificate(b"CENSORED"), Certificate(b"CENSORED")]
[2022-08-04T15:56:15Z DEBUG rustls::client::tls12] Server DNS name is DnsName(DnsName(DnsName("chat.signal.org")))
[2022-08-04T15:56:15Z DEBUG rustls::client::tls12] Session not saved: server didn't allocate id or ticket
[2022-08-04T15:56:15Z TRACE want] signal: Want
[2022-08-04T15:56:15Z TRACE want] signal found waiting giver, notifying
[2022-08-04T15:56:15Z TRACE want] poll_want: taker wants!
[2022-08-04T15:56:16Z TRACE want] signal: Want
[2022-08-04T15:56:16Z TRACE want] signal: Want
[2022-08-04T15:56:16Z DEBUG libsignal_service_hyper::push_service] HTTP request GET https://storage.signal.org/v1/groups/
[2022-08-04T15:56:16Z TRACE want] signal: Want
[2022-08-04T15:56:16Z TRACE mio::poll] registering event source with poller: token=Token(1), interests=READABLE | WRITABLE
[2022-08-04T15:56:16Z DEBUG rustls::client::hs] No cached session for DnsName(DnsName(DnsName("storage.signal.org")))
[2022-08-04T15:56:16Z DEBUG rustls::client::hs] Not resuming any session
[2022-08-04T15:56:16Z TRACE rustls::client::hs] Sending ClientHello Message {
        version: TLSv1_0,
        payload: Handshake {
            parsed: HandshakeMessagePayload {
                typ: ClientHello,
                payload: ClientHello(
                    ClientHelloPayload {
                        client_version: TLSv1_2,
                        random: CENSORED,
                        session_id: CENSORED,
                        cipher_suites: [
                            TLS13_AES_256_GCM_SHA384,
                            TLS13_AES_128_GCM_SHA256,
                            TLS13_CHACHA20_POLY1305_SHA256,
                            TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
                            TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
                            TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256,
                            TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
                            TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
                            TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256,
                            TLS_EMPTY_RENEGOTIATION_INFO_SCSV,
                        ],
                        compression_methods: [
                            Null,
                        ],
                        extensions: [
                            SupportedVersions(
                                [
                                    TLSv1_3,
                                    TLSv1_2,
                                ],
                            ),
                            ECPointFormats(
                                [
                                    Uncompressed,
                                ],
                            ),
                            NamedGroups(
                                [
                                    X25519,
                                    secp256r1,
                                    secp384r1,
                                ],
                            ),
                            SignatureAlgorithms(
                                [
                                    ECDSA_NISTP384_SHA384,
                                    ECDSA_NISTP256_SHA256,
                                    ED25519,
                                    RSA_PSS_SHA512,
                                    RSA_PSS_SHA384,
                                    RSA_PSS_SHA256,
                                    RSA_PKCS1_SHA512,
                                    RSA_PKCS1_SHA384,
                                    RSA_PKCS1_SHA256,
                                ],
                            ),
                            ExtendedMasterSecretRequest,
                            CertificateStatusRequest(
                                OCSP(
                                    OCSPCertificateStatusRequest {
                                        responder_ids: [],
                                        extensions: ,
                                    },
                                ),
                            ),
                            ServerName(
                                [
                                    ServerName {
                                        typ: HostName,
                                        payload: HostName(
                                            (
                                                CENSORED,
                                                DnsName(
                                                    "storage.signal.org",
                                                ),
                                            ),
                                        ),
                                    },
                                ],
                            ),
                            SignedCertificateTimestampRequest,
                            KeyShare(
                                [
                                    KeyShareEntry {
                                        group: X25519,
                                        payload: CENSORED,
                                    },
                                ],
                            ),
                            PresharedKeyModes(
                                [
                                    PSK_DHE_KE,
                                ],
                            ),
                            Protocols(
                                [
                                    687474702f312e31,
                                ],
                            ),
                            SessionTicket(
                                Request,
                            ),
                        ],
                    },
                ),
            },
            encoded: CENSORED,
        },
    }
[2022-08-04T15:56:16Z TRACE rustls::client::hs] We got ServerHello ServerHelloPayload {
        legacy_version: TLSv1_2,
        random: CENSORED,
        session_id: CENSORED,
        cipher_suite: TLS13_AES_256_GCM_SHA384,
        compression_method: Null,
        extensions: [
            KeyShare(
                KeyShareEntry {
                    group: X25519,
                    payload: CENSORED,
                },
            ),
            SupportedVersions(
                TLSv1_3,
            ),
        ],
    }
[2022-08-04T15:56:16Z DEBUG rustls::client::hs] Using ciphersuite TLS13_AES_256_GCM_SHA384
[2022-08-04T15:56:16Z DEBUG rustls::client::tls13] Not resuming
[2022-08-04T15:56:16Z TRACE rustls::client::client_conn] EarlyData rejected
[2022-08-04T15:56:16Z TRACE rustls::conn] Dropping CCS
[2022-08-04T15:56:16Z DEBUG rustls::client::tls13] TLS1.3 encrypted extensions: [Protocols([687474702f312e31])]
[2022-08-04T15:56:16Z DEBUG rustls::client::hs] ALPN protocol is Some(b"http/1.1")
[2022-08-04T15:56:16Z TRACE rustls::client::tls13] Server cert is [Certificate(b"CENSORED")]
[2022-08-04T15:56:16Z TRACE want] signal: Want
[2022-08-04T15:56:16Z TRACE want] signal found waiting giver, notifying
[2022-08-04T15:56:16Z TRACE want] poll_want: taker wants!
[2022-08-04T15:56:16Z TRACE want] signal: Want
[2022-08-04T15:56:16Z TRACE want] signal: Want
[2022-08-04T15:56:16Z TRACE cli] Sending group message to UUID1
[2022-08-04T15:56:16Z TRACE cli] Sending group message to UUID2
[2022-08-04T15:56:16Z TRACE cli] Sending group message to UUID3
[2022-08-04T15:56:16Z TRACE cli] Sending group message to UUID4
[2022-08-04T15:56:16Z TRACE cli] Sending group message to UUID5
[2022-08-04T15:56:16Z TRACE cli] Sending group message to UUID6
[2022-08-04T15:56:16Z TRACE cli] Sending group message to UUID7
[2022-08-04T15:56:16Z TRACE libsignal_service::sender] sending message to default device
[2022-08-04T15:56:16Z TRACE presage::config::sled] loading session from session-UUID1.1
[2022-08-04T15:56:16Z TRACE libsignal_service::sender] encrypting message for ProtocolAddress { name: "UUID1", device_id: 1 }
[2022-08-04T15:56:16Z TRACE presage::config::sled] loading session from session-UUID1.1
[2022-08-04T15:56:16Z TRACE presage::config::sled] loading session from session-UUID1.1
[2022-08-04T15:56:16Z TRACE presage::config::sled] loading session from session-UUID1.1
[2022-08-04T15:56:16Z TRACE presage::config::sled] get identity-remote-UUID1.1
[2022-08-04T15:56:16Z TRACE presage::config::sled] saving identity
[2022-08-04T15:56:16Z TRACE presage::config::sled] inserting identity-remote-UUID1.1
[2022-08-04T15:56:16Z TRACE presage::config::sled] saved identity
[2022-08-04T15:56:16Z TRACE presage::config::sled] storing session for ProtocolAddress { name: "UUID1.1"
[2022-08-04T15:56:16Z INFO  presage::config::sled] get_sub_device_sessions: session_prefix=session-UUID1.
[2022-08-04T15:56:16Z TRACE libsignal_service::sender] sending message to device 1
[2022-08-04T15:56:16Z TRACE presage::config::sled] loading session from session-UUID1.1
[2022-08-04T15:56:16Z TRACE presage::config::sled] loading session from session-UUID1.1
[2022-08-04T15:56:16Z TRACE presage::config::sled] loading session from session-UUID1.1
[2022-08-04T15:56:16Z TRACE libsignal_service::sender] encrypting message for ProtocolAddress { name: "UUID1", device_id: 1 }
[2022-08-04T15:56:16Z TRACE presage::config::sled] loading session from session-UUID1.1
[2022-08-04T15:56:16Z TRACE presage::config::sled] loading session from session-UUID1.1
[2022-08-04T15:56:16Z TRACE presage::config::sled] loading session from session-UUID1.1
[2022-08-04T15:56:16Z TRACE presage::config::sled] get identity-remote-UUID1.1
[2022-08-04T15:56:16Z TRACE presage::config::sled] saving identity
[2022-08-04T15:56:16Z TRACE presage::config::sled] inserting identity-remote-UUID1.1
[2022-08-04T15:56:16Z TRACE presage::config::sled] saved identity
[2022-08-04T15:56:16Z TRACE presage::config::sled] storing session for ProtocolAddress { name: "UUID1.1"
[2022-08-04T15:56:16Z TRACE libsignal_service::sender] sending message to device 2
[2022-08-04T15:56:16Z TRACE presage::config::sled] loading session from session-UUID1.2
[2022-08-04T15:56:16Z TRACE presage::config::sled] loading session from session-UUID1.2
[2022-08-04T15:56:16Z TRACE presage::config::sled] loading session from session-UUID1.2
[2022-08-04T15:56:16Z TRACE libsignal_service::sender] encrypting message for ProtocolAddress { name: "UUID1", device_id: 2 }
[2022-08-04T15:56:16Z TRACE presage::config::sled] loading session from session-UUID1.2
[2022-08-04T15:56:16Z TRACE presage::config::sled] loading session from session-UUID1.2
[2022-08-04T15:56:16Z TRACE presage::config::sled] loading session from session-UUID1.2
[2022-08-04T15:56:16Z INFO  libsignal_protocol::session_cipher] Building PreKeyWhisperMessage for: UUID1.2 with preKeyId: <none>
[2022-08-04T15:56:16Z TRACE presage::config::sled] get identity-remote-UUID1.2
[2022-08-04T15:56:16Z TRACE presage::config::sled] saving identity
[2022-08-04T15:56:16Z TRACE presage::config::sled] inserting identity-remote-UUID1.2
[2022-08-04T15:56:16Z TRACE presage::config::sled] saved identity
[2022-08-04T15:56:16Z TRACE presage::config::sled] storing session for ProtocolAddress { name: "UUID1.2"
[2022-08-04T15:56:16Z DEBUG libsignal_service_hyper::push_service] HTTP request PUT https://chat.signal.org/v1/messages/UUID1
[2022-08-04T15:56:16Z TRACE want] signal: Want
[2022-08-04T15:56:17Z TRACE want] signal: Want
[2022-08-04T15:56:17Z TRACE want] signal: Want
[2022-08-04T15:56:17Z DEBUG libsignal_service::sender] message sent!
[2022-08-04T15:56:17Z TRACE libsignal_service::sender] sending message to default device
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID2.1
[2022-08-04T15:56:17Z TRACE libsignal_service::sender] encrypting message for ProtocolAddress { name: "UUID2", device_id: 1 }
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID2.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID2.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID2.1
[2022-08-04T15:56:17Z INFO  libsignal_protocol::session_cipher] Building PreKeyWhisperMessage for: UUID2.1 with preKeyId: <none>
[2022-08-04T15:56:17Z TRACE presage::config::sled] get identity-remote-UUID2.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] saving identity
[2022-08-04T15:56:17Z TRACE presage::config::sled] inserting identity-remote-UUID2.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] saved identity
[2022-08-04T15:56:17Z TRACE presage::config::sled] storing session for ProtocolAddress { name: "UUID2.1"
[2022-08-04T15:56:17Z INFO  presage::config::sled] get_sub_device_sessions: session_prefix=session-UUID2.
[2022-08-04T15:56:17Z TRACE libsignal_service::sender] sending message to device 1
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID2.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID2.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID2.1
[2022-08-04T15:56:17Z TRACE libsignal_service::sender] encrypting message for ProtocolAddress { name: "UUID2", device_id: 1 }
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID2.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID2.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID2.1
[2022-08-04T15:56:17Z INFO  libsignal_protocol::session_cipher] Building PreKeyWhisperMessage for: UUID2.1 with preKeyId: <none>
[2022-08-04T15:56:17Z TRACE presage::config::sled] get identity-remote-UUID2.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] saving identity
[2022-08-04T15:56:17Z TRACE presage::config::sled] inserting identity-remote-UUID2.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] saved identity
[2022-08-04T15:56:17Z TRACE presage::config::sled] storing session for ProtocolAddress { name: "UUID2.1"
[2022-08-04T15:56:17Z DEBUG libsignal_service_hyper::push_service] HTTP request PUT https://chat.signal.org/v1/messages/UUID2
[2022-08-04T15:56:17Z TRACE want] signal: Want
[2022-08-04T15:56:17Z TRACE want] signal: Want
[2022-08-04T15:56:17Z DEBUG libsignal_service::sender] message sent!
[2022-08-04T15:56:17Z TRACE libsignal_service::sender] sending message to default device
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID3.1
[2022-08-04T15:56:17Z TRACE libsignal_service::sender] encrypting message for ProtocolAddress { name: "UUID3", device_id: 1 }
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID3.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID3.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID3.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] get identity-remote-UUID3.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] saving identity
[2022-08-04T15:56:17Z TRACE presage::config::sled] inserting identity-remote-UUID3.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] saved identity
[2022-08-04T15:56:17Z TRACE presage::config::sled] storing session for ProtocolAddress { name: "UUID3.1"
[2022-08-04T15:56:17Z INFO  presage::config::sled] get_sub_device_sessions: session_prefix=session-UUID3.
[2022-08-04T15:56:17Z TRACE libsignal_service::sender] sending message to device 1
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID3.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID3.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID3.1
[2022-08-04T15:56:17Z TRACE libsignal_service::sender] encrypting message for ProtocolAddress { name: "UUID3", device_id: 1 }
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID3.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID3.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID3.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] get identity-remote-UUID3.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] saving identity
[2022-08-04T15:56:17Z TRACE presage::config::sled] inserting identity-remote-UUID3.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] saved identity
[2022-08-04T15:56:17Z TRACE presage::config::sled] storing session for ProtocolAddress { name: "UUID3.1"
[2022-08-04T15:56:17Z TRACE libsignal_service::sender] sending message to device 2
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID3.2
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID3.2
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID3.2
[2022-08-04T15:56:17Z TRACE libsignal_service::sender] encrypting message for ProtocolAddress { name: "UUID3", device_id: 2 }
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID3.2
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID3.2
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID3.2
[2022-08-04T15:56:17Z INFO  libsignal_protocol::session_cipher] Building PreKeyWhisperMessage for: UUID3.2 with preKeyId: 29
[2022-08-04T15:56:17Z TRACE presage::config::sled] get identity-remote-UUID3.2
[2022-08-04T15:56:17Z TRACE presage::config::sled] saving identity
[2022-08-04T15:56:17Z TRACE presage::config::sled] inserting identity-remote-UUID3.2
[2022-08-04T15:56:17Z TRACE presage::config::sled] saved identity
[2022-08-04T15:56:17Z TRACE presage::config::sled] storing session for ProtocolAddress { name: "UUID3.2"
[2022-08-04T15:56:17Z DEBUG libsignal_service_hyper::push_service] HTTP request PUT https://chat.signal.org/v1/messages/UUID3
[2022-08-04T15:56:17Z TRACE want] signal: Want
[2022-08-04T15:56:17Z TRACE want] signal: Want
[2022-08-04T15:56:17Z DEBUG libsignal_service::sender] message sent!
[2022-08-04T15:56:17Z TRACE libsignal_service::sender] sending message to default device
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID4.1
[2022-08-04T15:56:17Z TRACE libsignal_service::sender] encrypting message for ProtocolAddress { name: "UUID4", device_id: 1 }
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID4.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID4.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID4.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] get identity-remote-UUID4.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] saving identity
[2022-08-04T15:56:17Z TRACE presage::config::sled] inserting identity-remote-UUID4.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] saved identity
[2022-08-04T15:56:17Z TRACE presage::config::sled] storing session for ProtocolAddress { name: "UUID4.1"
[2022-08-04T15:56:17Z INFO  presage::config::sled] get_sub_device_sessions: session_prefix=session-UUID4.
[2022-08-04T15:56:17Z TRACE libsignal_service::sender] sending message to device 1
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID4.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID4.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID4.1
[2022-08-04T15:56:17Z TRACE libsignal_service::sender] encrypting message for ProtocolAddress { name: "UUID4", device_id: 1 }
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID4.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID4.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID4.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] get identity-remote-UUID4.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] saving identity
[2022-08-04T15:56:17Z TRACE presage::config::sled] inserting identity-remote-UUID4.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] saved identity
[2022-08-04T15:56:17Z TRACE presage::config::sled] storing session for ProtocolAddress { name: "UUID4.1"
[2022-08-04T15:56:17Z TRACE libsignal_service::sender] sending message to device 2
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID4.2
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID4.2
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID4.2
[2022-08-04T15:56:17Z TRACE libsignal_service::sender] encrypting message for ProtocolAddress { name: "UUID4", device_id: 2 }
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID4.2
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID4.2
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID4.2
[2022-08-04T15:56:17Z TRACE presage::config::sled] get identity-remote-UUID4.2
[2022-08-04T15:56:17Z TRACE presage::config::sled] saving identity
[2022-08-04T15:56:17Z TRACE presage::config::sled] inserting identity-remote-UUID4.2
[2022-08-04T15:56:17Z TRACE presage::config::sled] saved identity
[2022-08-04T15:56:17Z TRACE presage::config::sled] storing session for ProtocolAddress { name: "UUID4.2"
[2022-08-04T15:56:17Z DEBUG libsignal_service_hyper::push_service] HTTP request PUT https://chat.signal.org/v1/messages/UUID4
[2022-08-04T15:56:17Z TRACE want] signal: Want
[2022-08-04T15:56:17Z TRACE want] signal: Want
[2022-08-04T15:56:17Z DEBUG libsignal_service::sender] message sent!
[2022-08-04T15:56:17Z TRACE libsignal_service::sender] sending message to default device
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID5.1
[2022-08-04T15:56:17Z TRACE libsignal_service::sender] encrypting message for ProtocolAddress { name: "UUID5", device_id: 1 }
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID5.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID5.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID5.1
[2022-08-04T15:56:17Z INFO  libsignal_protocol::session_cipher] Building PreKeyWhisperMessage for: UUID5.1 with preKeyId: 7
[2022-08-04T15:56:17Z TRACE presage::config::sled] get identity-remote-UUID5.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] saving identity
[2022-08-04T15:56:17Z TRACE presage::config::sled] inserting identity-remote-UUID5.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] saved identity
[2022-08-04T15:56:17Z TRACE presage::config::sled] storing session for ProtocolAddress { name: "UUID5.1"
[2022-08-04T15:56:17Z INFO  presage::config::sled] get_sub_device_sessions: session_prefix=session-UUID5.
[2022-08-04T15:56:17Z TRACE libsignal_service::sender] sending message to device 1
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID5.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID5.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID5.1
[2022-08-04T15:56:17Z TRACE libsignal_service::sender] encrypting message for ProtocolAddress { name: "UUID5", device_id: 1 }
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID5.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID5.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID5.1
[2022-08-04T15:56:17Z INFO  libsignal_protocol::session_cipher] Building PreKeyWhisperMessage for: UUID5.1 with preKeyId: 7
[2022-08-04T15:56:17Z TRACE presage::config::sled] get identity-remote-UUID5.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] saving identity
[2022-08-04T15:56:17Z TRACE presage::config::sled] inserting identity-remote-UUID5.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] saved identity
[2022-08-04T15:56:17Z TRACE presage::config::sled] storing session for ProtocolAddress { name: "UUID5.1"
[2022-08-04T15:56:17Z TRACE libsignal_service::sender] sending message to device 2
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID5.2
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID5.2
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID5.2
[2022-08-04T15:56:17Z TRACE libsignal_service::sender] encrypting message for ProtocolAddress { name: "UUID5", device_id: 2 }
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID5.2
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID5.2
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID5.2
[2022-08-04T15:56:17Z INFO  libsignal_protocol::session_cipher] Building PreKeyWhisperMessage for: UUID5.2 with preKeyId: 145
[2022-08-04T15:56:17Z TRACE presage::config::sled] get identity-remote-UUID5.2
[2022-08-04T15:56:17Z TRACE presage::config::sled] saving identity
[2022-08-04T15:56:17Z TRACE presage::config::sled] inserting identity-remote-UUID5.2
[2022-08-04T15:56:17Z TRACE presage::config::sled] saved identity
[2022-08-04T15:56:17Z TRACE presage::config::sled] storing session for ProtocolAddress { name: "UUID5.2"
[2022-08-04T15:56:17Z TRACE libsignal_service::sender] sending message to device 3
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID5.3
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID5.3
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID5.3
[2022-08-04T15:56:17Z TRACE libsignal_service::sender] encrypting message for ProtocolAddress { name: "UUID5", device_id: 3 }
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID5.3
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID5.3
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID5.3
[2022-08-04T15:56:17Z INFO  libsignal_protocol::session_cipher] Building PreKeyWhisperMessage for: UUID5.3 with preKeyId: 143
[2022-08-04T15:56:17Z TRACE presage::config::sled] get identity-remote-UUID5.3
[2022-08-04T15:56:17Z TRACE presage::config::sled] saving identity
[2022-08-04T15:56:17Z TRACE presage::config::sled] inserting identity-remote-UUID5.3
[2022-08-04T15:56:17Z TRACE presage::config::sled] saved identity
[2022-08-04T15:56:17Z TRACE presage::config::sled] storing session for ProtocolAddress { name: "UUID5.3"
[2022-08-04T15:56:17Z DEBUG libsignal_service_hyper::push_service] HTTP request PUT https://chat.signal.org/v1/messages/UUID5
[2022-08-04T15:56:17Z TRACE want] signal: Want
[2022-08-04T15:56:17Z TRACE want] signal: Want
[2022-08-04T15:56:17Z DEBUG libsignal_service::sender] message sent!
[2022-08-04T15:56:17Z TRACE libsignal_service::sender] sending message to default device
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID6.1
[2022-08-04T15:56:17Z TRACE libsignal_service::sender] encrypting message for ProtocolAddress { name: "UUID6", device_id: 1 }
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID6.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID6.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID6.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] get identity-remote-UUID6.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] saving identity
[2022-08-04T15:56:17Z TRACE presage::config::sled] inserting identity-remote-UUID6.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] saved identity
[2022-08-04T15:56:17Z TRACE presage::config::sled] storing session for ProtocolAddress { name: "UUID6.1"
[2022-08-04T15:56:17Z INFO  presage::config::sled] get_sub_device_sessions: session_prefix=session-UUID6.
[2022-08-04T15:56:17Z TRACE libsignal_service::sender] sending message to device 1
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID6.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID6.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID6.1
[2022-08-04T15:56:17Z TRACE libsignal_service::sender] encrypting message for ProtocolAddress { name: "UUID6", device_id: 1 }
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID6.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID6.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID6.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] get identity-remote-UUID6.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] saving identity
[2022-08-04T15:56:17Z TRACE presage::config::sled] inserting identity-remote-UUID6.1
[2022-08-04T15:56:17Z TRACE presage::config::sled] saved identity
[2022-08-04T15:56:17Z TRACE presage::config::sled] storing session for ProtocolAddress { name: "UUID6.1"
[2022-08-04T15:56:17Z TRACE libsignal_service::sender] sending message to device 2
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID6.2
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID6.2
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID6.2
[2022-08-04T15:56:17Z TRACE libsignal_service::sender] encrypting message for ProtocolAddress { name: "UUID6", device_id: 2 }
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID6.2
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID6.2
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID6.2
[2022-08-04T15:56:17Z TRACE presage::config::sled] get identity-remote-UUID6.2
[2022-08-04T15:56:17Z TRACE presage::config::sled] saving identity
[2022-08-04T15:56:17Z TRACE presage::config::sled] inserting identity-remote-UUID6.2
[2022-08-04T15:56:17Z TRACE presage::config::sled] saved identity
[2022-08-04T15:56:17Z TRACE presage::config::sled] storing session for ProtocolAddress { name: "UUID6.2"
[2022-08-04T15:56:17Z TRACE libsignal_service::sender] sending message to device 3
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID6.3
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID6.3
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID6.3
[2022-08-04T15:56:17Z TRACE libsignal_service::sender] encrypting message for ProtocolAddress { name: "UUID6", device_id: 3 }
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID6.3
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID6.3
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID6.3
[2022-08-04T15:56:17Z TRACE presage::config::sled] get identity-remote-UUID6.3
[2022-08-04T15:56:17Z TRACE presage::config::sled] saving identity
[2022-08-04T15:56:17Z TRACE presage::config::sled] inserting identity-remote-UUID6.3
[2022-08-04T15:56:17Z TRACE presage::config::sled] saved identity
[2022-08-04T15:56:17Z TRACE presage::config::sled] storing session for ProtocolAddress { name: "UUID6.3"
[2022-08-04T15:56:17Z TRACE libsignal_service::sender] sending message to device 4
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID6.4
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID6.4
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID6.4
[2022-08-04T15:56:17Z TRACE libsignal_service::sender] encrypting message for ProtocolAddress { name: "UUID6", device_id: 4 }
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID6.4
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID6.4
[2022-08-04T15:56:17Z TRACE presage::config::sled] loading session from session-UUID6.4
[2022-08-04T15:56:17Z INFO  libsignal_protocol::session_cipher] Building PreKeyWhisperMessage for: UUID6.4 with preKeyId: 34
[2022-08-04T15:56:17Z TRACE presage::config::sled] get identity-remote-UUID6.4
[2022-08-04T15:56:17Z TRACE presage::config::sled] saving identity
[2022-08-04T15:56:17Z TRACE presage::config::sled] inserting identity-remote-UUID6.4
[2022-08-04T15:56:17Z TRACE presage::config::sled] saved identity
[2022-08-04T15:56:17Z TRACE presage::config::sled] storing session for ProtocolAddress { name: "UUID6.4"
[2022-08-04T15:56:17Z DEBUG libsignal_service_hyper::push_service] HTTP request PUT https://chat.signal.org/v1/messages/UUID6
[2022-08-04T15:56:18Z TRACE want] signal: Want
[2022-08-04T15:56:18Z TRACE want] signal: Want
[2022-08-04T15:56:18Z DEBUG libsignal_service::sender] message sent!
[2022-08-04T15:56:18Z INFO  presage::config::sled] get_sub_device_sessions: session_prefix=session-UUID7.
[2022-08-04T15:56:18Z TRACE libsignal_service::sender] sending message to device 1
[2022-08-04T15:56:18Z TRACE presage::config::sled] loading session from session-UUID7.1
[2022-08-04T15:56:18Z TRACE presage::config::sled] loading session from session-UUID7.1
[2022-08-04T15:56:18Z TRACE presage::config::sled] loading session from session-UUID7.1
[2022-08-04T15:56:18Z TRACE libsignal_service::sender] encrypting message for ProtocolAddress { name: "UUID7", device_id: 1 }
[2022-08-04T15:56:18Z TRACE presage::config::sled] loading session from session-UUID7.1
[2022-08-04T15:56:18Z TRACE presage::config::sled] loading session from session-UUID7.1
[2022-08-04T15:56:18Z TRACE presage::config::sled] loading session from session-UUID7.1
[2022-08-04T15:56:18Z TRACE presage::config::sled] get identity-remote-UUID7.1
[2022-08-04T15:56:18Z TRACE presage::config::sled] saving identity
[2022-08-04T15:56:18Z TRACE presage::config::sled] inserting identity-remote-UUID7.1
[2022-08-04T15:56:18Z TRACE presage::config::sled] saved identity
[2022-08-04T15:56:18Z TRACE presage::config::sled] storing session for ProtocolAddress { name: "UUID7.1"
[2022-08-04T15:56:18Z TRACE libsignal_service::sender] sending message to device 2
[2022-08-04T15:56:18Z TRACE presage::config::sled] loading session from session-UUID7.2
[2022-08-04T15:56:18Z TRACE presage::config::sled] loading session from session-UUID7.2
[2022-08-04T15:56:18Z TRACE presage::config::sled] loading session from session-UUID7.2
[2022-08-04T15:56:18Z TRACE libsignal_service::sender] encrypting message for ProtocolAddress { name: "UUID7", device_id: 2 }
[2022-08-04T15:56:18Z TRACE presage::config::sled] loading session from session-UUID7.2
[2022-08-04T15:56:18Z TRACE presage::config::sled] loading session from session-UUID7.2
[2022-08-04T15:56:18Z TRACE presage::config::sled] loading session from session-UUID7.2
[2022-08-04T15:56:18Z TRACE presage::config::sled] get identity-remote-UUID7.2
[2022-08-04T15:56:18Z TRACE presage::config::sled] saving identity
[2022-08-04T15:56:18Z TRACE presage::config::sled] inserting identity-remote-UUID7.2
[2022-08-04T15:56:18Z TRACE presage::config::sled] saved identity
[2022-08-04T15:56:18Z TRACE presage::config::sled] storing session for ProtocolAddress { name: "UUID7.2"
[2022-08-04T15:56:18Z TRACE libsignal_service::sender] sending message to device 3
[2022-08-04T15:56:18Z TRACE presage::config::sled] loading session from session-UUID7.3
[2022-08-04T15:56:18Z TRACE presage::config::sled] loading session from session-UUID7.3
[2022-08-04T15:56:18Z TRACE presage::config::sled] loading session from session-UUID7.3
[2022-08-04T15:56:18Z TRACE libsignal_service::sender] encrypting message for ProtocolAddress { name: "UUID7", device_id: 3 }
[2022-08-04T15:56:18Z TRACE presage::config::sled] loading session from session-UUID7.3
[2022-08-04T15:56:18Z TRACE presage::config::sled] loading session from session-UUID7.3
[2022-08-04T15:56:18Z TRACE presage::config::sled] loading session from session-UUID7.3
[2022-08-04T15:56:18Z INFO  libsignal_protocol::session_cipher] Building PreKeyWhisperMessage for: UUID7.3 with preKeyId: 15
[2022-08-04T15:56:18Z TRACE presage::config::sled] get identity-remote-UUID7.3
[2022-08-04T15:56:18Z TRACE presage::config::sled] saving identity
[2022-08-04T15:56:18Z TRACE presage::config::sled] inserting identity-remote-UUID7.3
[2022-08-04T15:56:18Z TRACE presage::config::sled] saved identity
[2022-08-04T15:56:18Z TRACE presage::config::sled] storing session for ProtocolAddress { name: "UUID7.3"
[2022-08-04T15:56:18Z TRACE libsignal_service::sender] sending message to device 4
[2022-08-04T15:56:18Z TRACE presage::config::sled] loading session from session-UUID7.4
[2022-08-04T15:56:18Z TRACE presage::config::sled] loading session from session-UUID7.4
[2022-08-04T15:56:18Z TRACE presage::config::sled] loading session from session-UUID7.4
[2022-08-04T15:56:18Z TRACE libsignal_service::sender] encrypting message for ProtocolAddress { name: "UUID7", device_id: 4 }
[2022-08-04T15:56:18Z TRACE presage::config::sled] loading session from session-UUID7.4
[2022-08-04T15:56:18Z TRACE presage::config::sled] loading session from session-UUID7.4
[2022-08-04T15:56:18Z TRACE presage::config::sled] loading session from session-UUID7.4
[2022-08-04T15:56:18Z TRACE presage::config::sled] get identity-remote-UUID7.4
[2022-08-04T15:56:18Z TRACE presage::config::sled] saving identity
[2022-08-04T15:56:18Z TRACE presage::config::sled] inserting identity-remote-UUID7.4
[2022-08-04T15:56:18Z TRACE presage::config::sled] saved identity
[2022-08-04T15:56:18Z TRACE presage::config::sled] storing session for ProtocolAddress { name: "UUID7.4"
[2022-08-04T15:56:18Z TRACE libsignal_service::sender] sending message to device 5
[2022-08-04T15:56:18Z TRACE presage::config::sled] loading session from session-UUID7.5
[2022-08-04T15:56:18Z TRACE presage::config::sled] loading session from session-UUID7.5
[2022-08-04T15:56:18Z TRACE presage::config::sled] loading session from session-UUID7.5
[2022-08-04T15:56:18Z TRACE libsignal_service::sender] encrypting message for ProtocolAddress { name: "UUID7", device_id: 5 }
[2022-08-04T15:56:18Z TRACE presage::config::sled] loading session from session-UUID7.5
[2022-08-04T15:56:18Z TRACE presage::config::sled] loading session from session-UUID7.5
[2022-08-04T15:56:18Z TRACE presage::config::sled] loading session from session-UUID7.5
[2022-08-04T15:56:18Z TRACE presage::config::sled] get identity-remote-UUID7.5
[2022-08-04T15:56:18Z TRACE presage::config::sled] saving identity
[2022-08-04T15:56:18Z TRACE presage::config::sled] inserting identity-remote-UUID7.5
[2022-08-04T15:56:18Z TRACE presage::config::sled] saved identity
[2022-08-04T15:56:18Z TRACE presage::config::sled] storing session for ProtocolAddress { name: "UUID7.5"
[2022-08-04T15:56:18Z DEBUG libsignal_service_hyper::push_service] HTTP request PUT https://chat.signal.org/v1/messages/UUID7
[2022-08-04T15:56:18Z TRACE want] signal: Want
[2022-08-04T15:56:18Z TRACE want] signal: Want
[2022-08-04T15:56:18Z DEBUG libsignal_service::sender] message sent!
[2022-08-04T15:56:18Z INFO  presage::config::sled] get_sub_device_sessions: session_prefix=session-UUID7.
[2022-08-04T15:56:20Z INFO  presage::config::sled] get_sub_device_sessions: session_prefix=session-[phone].
[2022-08-04T15:56:20Z TRACE libsignal_service::sender] sending message to device 1
[2022-08-04T15:56:20Z TRACE presage::config::sled] loading session from session-UUID7.1
[2022-08-04T15:56:20Z TRACE presage::config::sled] loading session from session-UUID7.1
[2022-08-04T15:56:20Z TRACE presage::config::sled] loading session from session-UUID7.1
[2022-08-04T15:56:20Z TRACE libsignal_service::sender] encrypting message for ProtocolAddress { name: "UUID7", device_id: 1 }
[2022-08-04T15:56:20Z TRACE presage::config::sled] loading session from session-UUID7.1
[2022-08-04T15:56:20Z TRACE presage::config::sled] loading session from session-UUID7.1
[2022-08-04T15:56:20Z TRACE presage::config::sled] loading session from session-UUID7.1
[2022-08-04T15:56:20Z TRACE presage::config::sled] get identity-remote-UUID7.1
[2022-08-04T15:56:20Z TRACE presage::config::sled] saving identity
[2022-08-04T15:56:20Z TRACE presage::config::sled] inserting identity-remote-UUID7.1
[2022-08-04T15:56:20Z TRACE presage::config::sled] saved identity
[2022-08-04T15:56:20Z TRACE presage::config::sled] storing session for ProtocolAddress { name: "UUID7.1"
[2022-08-04T15:56:20Z TRACE libsignal_service::sender] sending message to device 2
[2022-08-04T15:56:20Z TRACE presage::config::sled] loading session from session-UUID7.2
[2022-08-04T15:56:20Z TRACE presage::config::sled] loading session from session-UUID7.2
[2022-08-04T15:56:20Z TRACE presage::config::sled] loading session from session-UUID7.2
[2022-08-04T15:56:20Z TRACE libsignal_service::sender] encrypting message for ProtocolAddress { name: "UUID7", device_id: 2 }
[2022-08-04T15:56:20Z TRACE presage::config::sled] loading session from session-UUID7.2
[2022-08-04T15:56:20Z TRACE presage::config::sled] loading session from session-UUID7.2
[2022-08-04T15:56:20Z TRACE presage::config::sled] loading session from session-UUID7.2
[2022-08-04T15:56:20Z TRACE presage::config::sled] get identity-remote-UUID7.2
[2022-08-04T15:56:20Z TRACE presage::config::sled] saving identity
[2022-08-04T15:56:20Z TRACE presage::config::sled] inserting identity-remote-UUID7.2
[2022-08-04T15:56:20Z TRACE presage::config::sled] saved identity
[2022-08-04T15:56:20Z TRACE presage::config::sled] storing session for ProtocolAddress { name: "UUID7.2"
[2022-08-04T15:56:20Z TRACE libsignal_service::sender] sending message to device 3
[2022-08-04T15:56:20Z TRACE presage::config::sled] loading session from session-UUID7.3
[2022-08-04T15:56:20Z TRACE presage::config::sled] loading session from session-UUID7.3
[2022-08-04T15:56:20Z TRACE presage::config::sled] loading session from session-UUID7.3
[2022-08-04T15:56:20Z TRACE libsignal_service::sender] encrypting message for ProtocolAddress { name: "UUID7", device_id: 3 }
[2022-08-04T15:56:20Z TRACE presage::config::sled] loading session from session-UUID7.3
[2022-08-04T15:56:20Z TRACE presage::config::sled] loading session from session-UUID7.3
[2022-08-04T15:56:20Z TRACE presage::config::sled] loading session from session-UUID7.3
[2022-08-04T15:56:20Z INFO  libsignal_protocol::session_cipher] Building PreKeyWhisperMessage for: UUID7.3 with preKeyId: 15
[2022-08-04T15:56:20Z TRACE presage::config::sled] get identity-remote-UUID7.3
[2022-08-04T15:56:20Z TRACE presage::config::sled] saving identity
[2022-08-04T15:56:20Z TRACE presage::config::sled] inserting identity-remote-UUID7.3
[2022-08-04T15:56:20Z TRACE presage::config::sled] saved identity
[2022-08-04T15:56:20Z TRACE presage::config::sled] storing session for ProtocolAddress { name: "UUID7.3"
[2022-08-04T15:56:20Z TRACE libsignal_service::sender] sending message to device 4
[2022-08-04T15:56:20Z TRACE presage::config::sled] loading session from session-UUID7.4
[2022-08-04T15:56:20Z TRACE presage::config::sled] loading session from session-UUID7.4
[2022-08-04T15:56:20Z TRACE presage::config::sled] loading session from session-UUID7.4
[2022-08-04T15:56:20Z TRACE libsignal_service::sender] encrypting message for ProtocolAddress { name: "UUID7", device_id: 4 }
[2022-08-04T15:56:20Z TRACE presage::config::sled] loading session from session-UUID7.4
[2022-08-04T15:56:20Z TRACE presage::config::sled] loading session from session-UUID7.4
[2022-08-04T15:56:20Z TRACE presage::config::sled] loading session from session-UUID7.4
[2022-08-04T15:56:20Z TRACE presage::config::sled] get identity-remote-UUID7.4
[2022-08-04T15:56:20Z TRACE presage::config::sled] saving identity
[2022-08-04T15:56:20Z TRACE presage::config::sled] inserting identity-remote-UUID7.4
[2022-08-04T15:56:20Z TRACE presage::config::sled] saved identity
[2022-08-04T15:56:20Z TRACE presage::config::sled] storing session for ProtocolAddress { name: "UUID7.4"
[2022-08-04T15:56:20Z TRACE libsignal_service::sender] sending message to device 5
[2022-08-04T15:56:20Z TRACE presage::config::sled] loading session from session-UUID7.5
[2022-08-04T15:56:20Z TRACE presage::config::sled] loading session from session-UUID7.5
[2022-08-04T15:56:20Z TRACE presage::config::sled] loading session from session-UUID7.5
[2022-08-04T15:56:20Z TRACE libsignal_service::sender] encrypting message for ProtocolAddress { name: "UUID7", device_id: 5 }
[2022-08-04T15:56:20Z TRACE presage::config::sled] loading session from session-UUID7.5
[2022-08-04T15:56:20Z TRACE presage::config::sled] loading session from session-UUID7.5
[2022-08-04T15:56:20Z TRACE presage::config::sled] loading session from session-UUID7.5
[2022-08-04T15:56:20Z TRACE presage::config::sled] get identity-remote-UUID7.5
[2022-08-04T15:56:20Z TRACE presage::config::sled] saving identity
[2022-08-04T15:56:20Z TRACE presage::config::sled] inserting identity-remote-UUID7.5
[2022-08-04T15:56:20Z TRACE presage::config::sled] saved identity
[2022-08-04T15:56:20Z TRACE presage::config::sled] storing session for ProtocolAddress { name: "UUID7.5"
[2022-08-04T15:56:20Z DEBUG libsignal_service_hyper::push_service] HTTP request PUT https://chat.signal.org/v1/messages/UUID7
[2022-08-04T15:56:20Z TRACE want] signal: Want
[2022-08-04T15:56:20Z TRACE want] signal: Want
[2022-08-04T15:56:20Z DEBUG libsignal_service::sender] message sent!
[2022-08-04T15:56:20Z TRACE mio::poll] deregistering event source from poller
[2022-08-04T15:56:20Z TRACE want] signal: Closed
[2022-08-04T15:56:20Z TRACE mio::poll] deregistering event source from poller
[2022-08-04T15:56:20Z TRACE want] signal: Closed

Save decrypted groups

Since the sled store can optionally be encrypted, it's a good idea to store the decrypted version of groups to save on resources when using them (they're currently decrypted whenever you fetch them). This is especially an issue on mobile devices.

cc @nanu-c

Unread message counter per registered user.

It should be possible to get a sessions list with Name/username/groupname as title, a unread counter and last message, how would you do that?

Lost messages

Usually, I see this in group chats:

2022-11-01T20:29:20.068435Z ERROR presage::manager: Error opening envelope: SignalProtocolError(InvalidMessage(SenderKey, "unexpected message type for sealed_sender_decrypt")), message will be skipped!

Other clients (signal desktop and android app) get the message.

re-export curve25519-dalek features

I recently opened an issue/request for libsignal-client to re-export curve25519-dalek features

Assuming this request is successful I hope that presage/Cargo.toml might also re-export curve25519-dalek features?

nightly = [libsignal-service-rs/nightly]
default = [libsignal-service-rs/default]
std = [libsignal-service-rs/std]
alloc = [libsignal-service-rs/alloc]
u32_backend = [libsignal-service-rs/u32_backend]
u64_backend = [libsignal-service-rs/u64_backend]
simd_backend = [libsignal-service-rs/simd_backend]

In particular I am seeking std and u32_backend - and include the others for sake of completeness.

SledStore possible improvement

#[derive(Debug, Clone)]
pub struct SledStore {
    db: Arc<RwLock<sled::Db>>,
}

https://github.com/whisperfish/presage/blob/main/src/store/sled.rs

Is there a reason for the use of std::sync::Arc; and std::sync::RwLock; ?

If it is just to implement the Clone trait, Sled has clone functionality. https://docs.rs/sled/latest/sled/struct.Db.html#method.clone
Am I missing something?

[feature request] Release on crates.io

Could you please release this crate on crates.io? I intend to package it for debian; for this it has to be on crates.io

Cheers

Improve/publish rust doc

Expose downloading attachment

We have all the facilities in libsignal-service-rs but there's no high-level function in presage right now.

Timed Messages

Currently, sending a message in a channel with timed messages turns off timed messages (see here). Instead, the DataMessage.expire_timer has to be set to the current length of timed messages (as discussed with @nanu-c on Matrix).