Fix registration

Cargo.toml

@@ -4,6 +4,6 @@ members = ["presage", "presage-cli", "presage-store-sled"]
 [patch.crates-io]
 "curve25519-dalek" = { git = 'https://github.com/signalapp/curve25519-dalek', branch = 'lizard2' }
 
-# [patch."https://github.com/whisperfish/libsignal-service-rs.git"]
-# libsignal-service = { path = "../libsignal-service-rs/libsignal-service" }
-# libsignal-service-hyper = { path = "../libsignal-service-rs/libsignal-service-hyper" }
+[patch."https://github.com/whisperfish/libsignal-service-rs.git"]
+libsignal-service = { path = "../libsignal-service-rs/libsignal-service" }
+libsignal-service-hyper = { path = "../libsignal-service-rs/libsignal-service-hyper" }

presage-cli/src/main.rs

@@ -460,6 +460,7 @@ async fn run<C: Store + 'static>(subcommand: Cmd, config_store: C) -> anyhow::Re
             .await?;
 
             // ask for confirmation code here
+            println!("input confirmation code (followed by RETURN): ");
             let stdin = io::stdin();
             let reader = BufReader::new(stdin);
             if let Some(confirmation_code) = reader.lines().next_line().await? {

presage-store-sled/src/error.rs

@@ -1,4 +1,4 @@
-use presage::{libsignal_service::prelude::protocol::SignalProtocolError, StoreError};
+use presage::{libsignal_service::protocol::SignalProtocolError, StoreError};
 
 #[derive(Debug, thiserror::Error)]
 pub enum SledStoreError {

presage-store-sled/src/lib.rs

@@ -13,18 +13,16 @@ use presage::libsignal_service::{
     self,
     groups_v2::Group,
     models::Contact,
-    prelude::{
-        protocol::{
-            Context, Direction, GenericSignedPreKey, IdentityKey, IdentityKeyPair,
-            IdentityKeyStore, KyberPreKeyId, KyberPreKeyRecord, KyberPreKeyStore, PreKeyId,
-            PreKeyRecord, PreKeyStore, ProtocolAddress, ProtocolStore, SenderKeyRecord,
-            SenderKeyStore, SessionRecord, SessionStore, SessionStoreExt, SignalProtocolError,
-            SignedPreKeyId, SignedPreKeyRecord, SignedPreKeyStore,
-        },
-        Content, ProfileKey, Uuid,
+    prelude::{Content, ProfileKey, Uuid},
+    protocol::{
+        Context, Direction, GenericSignedPreKey, IdentityKey, IdentityKeyPair, IdentityKeyStore,
+        KyberPreKeyId, KyberPreKeyRecord, KyberPreKeyStore, PreKeyId, PreKeyRecord, PreKeyStore,
+        ProtocolAddress, ProtocolStore, SenderKeyRecord, SenderKeyStore, SessionRecord,
+        SessionStore, SignalProtocolError, SignedPreKeyId, SignedPreKeyRecord,
+        SignedPreKeyStore,
     },
     push_service::DEFAULT_DEVICE_ID,
-    Profile, ServiceAddress,
+    Profile, ServiceAddress, session_store::SessionStoreExt,
 };
 use prost::Message;
 use protobuf::ContentProto;

presage/Cargo.toml

@@ -6,8 +6,8 @@ authors = ["Gabriel Féron <g@leirbag.net>"]
 edition = "2021"
 
 [dependencies]
-libsignal-service = { git = "https://github.com/whisperfish/libsignal-service-rs", rev = "3c65765" }
-libsignal-service-hyper = { git = "https://github.com/whisperfish/libsignal-service-rs", rev = "3c65765" }
+libsignal-service = { git = "https://github.com/whisperfish/libsignal-service-rs", rev = "8789920" }
+libsignal-service-hyper = { git = "https://github.com/whisperfish/libsignal-service-rs", rev = "8789920" }
 
 base64 = "0.12"
 futures = "0.3"

presage/src/errors.rs

@@ -1,7 +1,7 @@
 use std::borrow::Cow;
 
 use libsignal_service::{
-    models::ParseContactError, prelude::protocol::SignalProtocolError, ParseServiceAddressError,
+    models::ParseContactError, protocol::SignalProtocolError, ParseServiceAddressError,
 };
 
 use crate::store::StoreError;
@@ -60,6 +60,12 @@ pub enum Error<S: std::error::Error> {
     Timeout(#[from] tokio::time::error::Elapsed),
     #[error("store error: {0}")]
     Store(S),
+    #[error("push challenge required (not implemented)")]
+    PushChallengeRequired,
+    #[error("Not allowed to request verification code, reason unknown: {0:?}")]
+    RequestingCodeForbidden(libsignal_service::push_service::RegistrationSessionMetadataResponse),
+    #[error("Unverified registration session (i.e. wrong verification code)")]
+    UnverifiedRegistrationSession,
 }
 
 impl<S: StoreError> From<S> for Error<S> {

presage/src/manager.rs

@@ -20,22 +20,18 @@ use libsignal_service::{
     groups_v2::{decrypt_group, Group, GroupsManager, InMemoryCredentialsCache},
     messagepipe::ServiceCredentials,
     models::Contact,
-    prelude::{
-        phonenumber::PhoneNumber,
-        protocol::{KeyPair, PrivateKey, PublicKey, SenderCertificate},
-        Content, ProfileKey, PushService, Uuid,
-    },
+    prelude::{phonenumber::PhoneNumber, Content, ProfileKey, PushService, Uuid},
     proto::{
         data_message::Delete, sync_message, AttachmentPointer, Envelope, GroupContextV2,
         NullMessage,
     },
+    protocol::{KeyPair, PrivateKey, PublicKey, SenderCertificate},
     provisioning::{
-        generate_registration_id, LinkingManager, ProvisioningManager, SecondaryDeviceProvisioning,
-        VerificationCodeResponse,
+        generate_registration_id, LinkingManager, SecondaryDeviceProvisioning,
     },
     push_service::{
-        AccountAttributes, DeviceCapabilities, DeviceId, ServiceError, ServiceIds, WhoAmIResponse,
-        DEFAULT_DEVICE_ID,
+        AccountAttributes, DeviceCapabilities, DeviceId, RegistrationMethod, ServiceError,
+        ServiceIds, VerificationTransport, WhoAmIResponse, DEFAULT_DEVICE_ID,
     },
     receiver::MessageReceiver,
     sender::{AttachmentSpec, AttachmentUploadError},
@@ -89,6 +85,7 @@ pub struct Confirmation {
     signal_servers: SignalServers,
     phone_number: PhoneNumber,
     password: String,
+    session_id: String,
 }
 
 #[derive(Clone, Serialize, Deserialize)]
@@ -201,29 +198,54 @@ impl<C: Store> Manager<C, Registration> {
         let mut push_service =
             HyperPushService::new(service_configuration, None, crate::USER_AGENT.to_string());
 
-        let mut provisioning_manager: ProvisioningManager<HyperPushService> =
-            ProvisioningManager::new(&mut push_service, phone_number.clone(), password.clone());
+        trace!("creating registration verification session");
 
-        let verification_code_response = if use_voice_call {
-            provisioning_manager
-                .request_voice_verification_code(captcha, None)
-                .await?
-        } else {
-            provisioning_manager
-                .request_sms_verification_code(captcha, None)
-                .await?
-        };
+        let mut session = push_service
+            .create_verification_session(&phone_number, None)
+            .await?;
+
+        if session.captcha_required() {
+            trace!("captcha required");
+            session = push_service
+                .patch_verification_session(
+                    &phone_number,
+                    &session.id,
+                    None,
+                    captcha.as_deref(),
+                    None,
+                )
+                .await?;
+        }
 
-        if let VerificationCodeResponse::CaptchaRequired = verification_code_response {
-            return Err(Error::CaptchaRequired);
+        if session.push_challenge_required() {
+            return Err(Error::PushChallengeRequired);
         }
 
+        if !session.allowed_to_request_code {
+            return Err(Error::RequestingCodeForbidden(session));
+        }
+
+        trace!("requesting verification code");
+
+        session = push_service
+            .request_verification_code(
+                &session.id,
+                crate::USER_AGENT,
+                if use_voice_call {
+                    VerificationTransport::Voice
+                } else {
+                    VerificationTransport::Sms
+                },
+            )
+            .await?;
+
         let manager = Manager {
             config_store,
             state: Confirmation {
                 signal_servers,
                 phone_number,
                 password,
+                session_id: session.id,
             },
             rng,
         };
@@ -384,34 +406,44 @@ impl<C: Store> Manager<C, Confirmation> {
     /// to send and receive messages.
     pub async fn confirm_verification_code(
         self,
-        confirm_code: impl AsRef<str>,
+        confirmation_code: impl AsRef<str>,
     ) -> Result<Manager<C, Registered>, Error<C::Error>> {
         trace!("confirming verification code");
 
         let registration_id = generate_registration_id(&mut StdRng::from_entropy());
         let pni_registration_id = generate_registration_id(&mut StdRng::from_entropy());
 
+        let Confirmation {
+            signal_servers,
+            phone_number,
+            password,
+            session_id,
+        } = self.state;
+
         let credentials = ServiceCredentials {
             uuid: None,
-            phonenumber: self.state.phone_number.clone(),
-            password: Some(self.state.password.clone()),
+            phonenumber: phone_number.clone(),
+            password: Some(password.clone()),
             signaling_key: None,
             device_id: None,
         };
 
-        let service_configuration: ServiceConfiguration = self.state.signal_servers.into();
+        let service_configuration: ServiceConfiguration = signal_servers.into();
         let mut push_service = HyperPushService::new(
             service_configuration,
             Some(credentials),
             crate::USER_AGENT.to_string(),
         );
 
-        let mut provisioning_manager: ProvisioningManager<HyperPushService> =
-            ProvisioningManager::new(
-                &mut push_service,
-                self.state.phone_number.clone(),
-                self.state.password.to_string(),
-            );
+        let session = push_service
+            .submit_verification_code(&session_id, confirmation_code.as_ref())
+            .await?;
+
+        trace!("verification code submitted");
+
+        if !session.verified {
+            return Err(Error::UnverifiedRegistrationSession);
+        }
 
         let mut rng = StdRng::from_entropy();
 
@@ -424,11 +456,11 @@ impl<C: Store> Manager<C, Confirmation> {
 
         let profile_key = ProfileKey::generate(profile_key);
 
-        let registered = provisioning_manager
-            .confirm_verification_code(
-                confirm_code,
+        let skip_device_transfer = false;
+        let registered = push_service
+            .submit_registration_request(
+                RegistrationMethod::SessionId(&session_id),
                 AccountAttributes {
-                    name: None,
                     signaling_key: Some(signaling_key.to_vec()),
                     registration_id,
                     pni_registration_id,
@@ -440,21 +472,16 @@ impl<C: Store> Manager<C, Confirmation> {
                     unidentified_access_key: Some(profile_key.derive_access_key().to_vec()),
                     unrestricted_unidentified_access: false, // TODO: make this configurable?
                     discoverable_by_phone_number: true,
-                    capabilities: DeviceCapabilities {
-                        gv2: true,
-                        gv1_migration: true,
-                        ..Default::default()
-                    },
+                    name: Some("libsignal-service-hyper test".into()),
+                    capabilities: DeviceCapabilities::default(),
                 },
+                skip_device_transfer,
             )
             .await?;
 
         let aci_identity_key_pair = KeyPair::generate(&mut rng);
         let pni_identity_key_pair = KeyPair::generate(&mut rng);
 
-        let phone_number = self.state.phone_number.clone();
-        let password = self.state.password.clone();
-
         trace!("confirmed! (and registered)");
 
         let mut manager = Manager {

presage/src/store.rs

@@ -5,12 +5,12 @@ use libsignal_service::{
     content::ContentBody,
     groups_v2::Group,
     models::Contact,
+    protocol::{ProtocolStore, SenderKeyStore},
     prelude::{
-        protocol::{ProtocolStore, SenderKeyStore, SessionStoreExt},
         Content, ProfileKey, Uuid, UuidError,
     },
     proto::{sync_message::Sent, DataMessage, GroupContextV2, SyncMessage},
-    Profile,
+    Profile, session_store::SessionStoreExt,
 };
 use serde::{Deserialize, Serialize};