1360 lines
48 KiB
Rust
1360 lines
48 KiB
Rust
use std::cell::Cell;
|
|
use std::collections::{HashSet, VecDeque};
|
|
use std::path::PathBuf;
|
|
use std::rc::Rc;
|
|
use std::sync::Arc;
|
|
use std::sync::atomic::{AtomicBool, Ordering};
|
|
use std::time::Duration;
|
|
|
|
use anyhow::{Context as AnyhowContext, Error, anyhow};
|
|
use gpui::{
|
|
App, AppContext, Context, Entity, EventEmitter, Global, IntoElement, ParentElement,
|
|
SharedString, Styled, Subscription, Task, Window, div, relative,
|
|
};
|
|
use gpui_kit::base::StyledExt as _;
|
|
use gpui_kit::component::button::Button;
|
|
use gpui_kit::component::notification::{Notification, NotificationType};
|
|
use gpui_kit::component::{ActiveTheme, Disableable, Sizable, WindowExt, h_flex, v_flex};
|
|
use nostr_sdk::prelude::*;
|
|
use person::Directory;
|
|
use settings::{AppSettings, NIP4E_ROTATION_MAX_DAYS, NIP4E_ROTATION_MIN_DAYS};
|
|
use smallvec::{SmallVec, smallvec};
|
|
use state::{Announcement, NostrRegistry, UniversalSigner, credentials};
|
|
use storage::{SECONDS_PER_DAY, archive_key, get_keys, load_device_keys, set_keys};
|
|
use ui::Avatar;
|
|
|
|
mod storage;
|
|
|
|
/// Keep the durable processed-request log bounded
|
|
const PROCESSED_REQUESTS_LIMIT: usize = 256;
|
|
/// Ignore key requests older than a day so stale events on relays cannot resurface
|
|
const REQUEST_MAX_AGE: u64 = SECONDS_PER_DAY;
|
|
|
|
pub fn init(cx: &mut App) {
|
|
DeviceRegistry::set_global(cx.new(DeviceRegistry::new), cx);
|
|
}
|
|
|
|
struct DeviceNotification;
|
|
|
|
/// A key request awaiting user approval on this device
|
|
#[derive(Debug)]
|
|
struct PendingRequest {
|
|
event: Event,
|
|
client_key: PublicKey,
|
|
}
|
|
|
|
struct GlobalDeviceRegistry(Entity<DeviceRegistry>);
|
|
|
|
impl Global for GlobalDeviceRegistry {}
|
|
|
|
/// Device event.
|
|
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
|
|
pub enum DeviceEvent {
|
|
/// A new encryption signer has been set
|
|
Set,
|
|
/// User have not setup encryption key
|
|
NotSet,
|
|
/// The device is requesting an encryption key
|
|
Requesting(SharedString),
|
|
/// An error occurred
|
|
Error(SharedString),
|
|
}
|
|
|
|
impl DeviceEvent {
|
|
pub(crate) fn error<T>(error: T) -> Self
|
|
where
|
|
T: Into<SharedString>,
|
|
{
|
|
Self::Error(error.into())
|
|
}
|
|
}
|
|
|
|
/// Device Registry
|
|
///
|
|
/// NIP-4e: https://github.com/nostr-protocol/nips/blob/per-device-keys/4e.md
|
|
#[derive(Debug)]
|
|
pub struct DeviceRegistry {
|
|
signer: Entity<Option<UniversalSigner>>,
|
|
/// Ephemeral client key for the in-flight key request; never persisted
|
|
app_keys: Option<Keys>,
|
|
/// The key request currently awaiting user approval on this device
|
|
pending_request: Option<PendingRequest>,
|
|
/// Handled key-sync request ids, bounded and persisted
|
|
processed_requests: VecDeque<EventId>,
|
|
/// Whether an announcement has been made for this device
|
|
pub(crate) announcement_existed: Arc<AtomicBool>,
|
|
/// Whether the local key is stale against the current announcement.
|
|
resync: Arc<AtomicBool>,
|
|
/// Whether a key rotation is in flight, to coalesce overlapping requests
|
|
rotating: bool,
|
|
/// Person directory for requesters shown in the approval dialog
|
|
directory: Entity<Directory>,
|
|
/// Relay notification listener
|
|
notification_listener: Option<Task<Result<(), Error>>>,
|
|
tasks: Vec<Task<Result<(), Error>>>,
|
|
_subscriptions: SmallVec<[Subscription; 2]>,
|
|
}
|
|
|
|
impl EventEmitter<DeviceEvent> for DeviceRegistry {}
|
|
|
|
impl DeviceRegistry {
|
|
/// Retrieve the global device registry state
|
|
pub fn global(cx: &App) -> Entity<Self> {
|
|
cx.global::<GlobalDeviceRegistry>().0.clone()
|
|
}
|
|
|
|
/// Set the global device registry instance
|
|
fn set_global(state: Entity<Self>, cx: &mut App) {
|
|
cx.set_global(GlobalDeviceRegistry(state));
|
|
}
|
|
|
|
/// Create a new device registry instance
|
|
fn new(cx: &mut Context<Self>) -> Self {
|
|
let entity = cx.entity().downgrade();
|
|
let nostr = NostrRegistry::global(cx);
|
|
let settings = AppSettings::global(cx);
|
|
|
|
let signer = cx.new(|_| None);
|
|
let mut subscriptions = smallvec![];
|
|
|
|
subscriptions.push(
|
|
// Subscribe to nostr state events
|
|
cx.observe(&settings, move |this, settings, cx| {
|
|
if settings.read(cx).is_nip4e_enabled(cx) {
|
|
this.init_encryption(cx);
|
|
};
|
|
}),
|
|
);
|
|
|
|
subscriptions.push(
|
|
// Observe the user signer
|
|
cx.subscribe(&nostr, move |this, _nostr, event, cx| {
|
|
if event.signer_changed() && settings.read(cx).is_nip4e_enabled(cx) {
|
|
// The old account's state must not leak into the new one
|
|
this.announcement_existed.store(false, Ordering::Relaxed);
|
|
this.resync.store(false, Ordering::Relaxed);
|
|
// The in-flight request and client key belong to the old account
|
|
this.app_keys = None;
|
|
// The encryption signer belongs to the old account
|
|
this.signer.update(cx, |signer, cx| {
|
|
*signer = None;
|
|
cx.notify();
|
|
});
|
|
|
|
if this.pending_request.take().is_some() {
|
|
// The old approval must not target the new account's signer
|
|
if let Some(window) = cx.windows().first().copied() {
|
|
window
|
|
.update(cx, |_view, window, cx| {
|
|
window.remove_notification::<DeviceNotification>(cx);
|
|
})
|
|
.ok();
|
|
}
|
|
}
|
|
|
|
this.handle_notifications(cx);
|
|
this.init_encryption(cx);
|
|
}
|
|
}),
|
|
);
|
|
|
|
cx.defer(move |cx| {
|
|
let _ = entity.update(cx, |this, cx| {
|
|
this.handle_notifications(cx);
|
|
});
|
|
});
|
|
|
|
Self {
|
|
signer,
|
|
app_keys: None,
|
|
pending_request: None,
|
|
processed_requests: VecDeque::new(),
|
|
announcement_existed: Arc::new(AtomicBool::new(false)),
|
|
resync: Arc::new(AtomicBool::new(false)),
|
|
rotating: false,
|
|
directory: Directory::new(cx),
|
|
notification_listener: None,
|
|
tasks: vec![],
|
|
_subscriptions: subscriptions,
|
|
}
|
|
}
|
|
|
|
fn handle_notifications(&mut self, cx: &mut Context<Self>) {
|
|
self.notification_listener = None;
|
|
|
|
let nostr = NostrRegistry::global(cx);
|
|
let client = nostr.read(cx).client();
|
|
let signer = nostr.read(cx).signer();
|
|
|
|
let announcement_existed = self.announcement_existed.clone();
|
|
let (tx, rx) = flume::bounded::<Event>(100);
|
|
|
|
let read = credentials::read_processed_requests(cx);
|
|
|
|
self.notification_listener = Some(cx.background_spawn(async move {
|
|
let mut notifications = client.notifications();
|
|
let mut processed_events = HashSet::new();
|
|
let current_user = signer.get_public_key_async().await.ok();
|
|
|
|
while let Some(notification) = notifications.next().await {
|
|
if let ClientNotification::Message { message, .. } = notification
|
|
&& let RelayMessage::Event { event, .. } = *message
|
|
{
|
|
if !processed_events.insert(event.id) {
|
|
// Skip if the event has already been processed
|
|
continue;
|
|
}
|
|
|
|
match event.kind {
|
|
Kind::Custom(10044) if current_user == Some(event.pubkey) => {
|
|
announcement_existed.store(true, Ordering::Relaxed);
|
|
tx.send_async(event.into_owned()).await?;
|
|
}
|
|
Kind::Custom(4454) if current_user == Some(event.pubkey) => {
|
|
tx.send_async(event.into_owned()).await?;
|
|
}
|
|
Kind::Custom(4455) if current_user == Some(event.pubkey) => {
|
|
tx.send_async(event.into_owned()).await?;
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}));
|
|
|
|
self.tasks.push(cx.spawn(async move |this, cx| {
|
|
// Hydrate the processed-request log before routing any events
|
|
match read.await {
|
|
Ok(bytes) => {
|
|
let processed = bytes
|
|
.map(|bytes| parse_processed_requests(&bytes))
|
|
.unwrap_or_default();
|
|
|
|
this.update(cx, |this, _cx| {
|
|
this.processed_requests = processed;
|
|
})
|
|
.ok();
|
|
}
|
|
Err(e) => log::error!("Failed to read processed key-sync requests: {e}"),
|
|
}
|
|
|
|
while let Ok(event) = rx.recv_async().await {
|
|
match event.kind {
|
|
Kind::Custom(10044) => {
|
|
this.update(cx, |this, cx| {
|
|
this.set_encryption(&event, cx);
|
|
})?;
|
|
}
|
|
// New request event from other device
|
|
Kind::Custom(4454) => {
|
|
this.update(cx, |this, cx| {
|
|
this.ask_for_approval(event, cx);
|
|
})?;
|
|
}
|
|
// New response event from the master device
|
|
Kind::Custom(4455) => {
|
|
this.update(cx, |this, cx| {
|
|
this.handle_transfer(event, cx);
|
|
})?;
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
Ok(())
|
|
}));
|
|
}
|
|
|
|
/// Record a handled key-sync request id, persisting a bounded log
|
|
fn mark_request_processed(&mut self, event_id: EventId, cx: &mut Context<Self>) {
|
|
if self.processed_requests.contains(&event_id) {
|
|
return;
|
|
}
|
|
self.processed_requests.push_back(event_id);
|
|
while self.processed_requests.len() > PROCESSED_REQUESTS_LIMIT {
|
|
self.processed_requests.pop_front();
|
|
}
|
|
|
|
let bytes: Vec<u8> = self
|
|
.processed_requests
|
|
.iter()
|
|
.flat_map(|id| id.to_hex().into_bytes())
|
|
.collect();
|
|
let write = credentials::write_processed_requests(cx, &bytes);
|
|
cx.background_spawn(async move {
|
|
if let Err(e) = write.await {
|
|
log::error!("Failed to persist processed key-sync requests: {e}");
|
|
}
|
|
})
|
|
.detach();
|
|
}
|
|
|
|
/// Withdraw the pending approval.
|
|
fn resolve_pending_request(&mut self, cx: &mut Context<Self>) {
|
|
let Some(pending) = self.pending_request.take() else {
|
|
return;
|
|
};
|
|
self.mark_request_processed(pending.event.id, cx);
|
|
|
|
if let Some(window) = cx.windows().first().copied() {
|
|
window
|
|
.update(cx, |_view, window, cx| {
|
|
window.remove_notification::<DeviceNotification>(cx);
|
|
})
|
|
.ok();
|
|
}
|
|
cx.notify();
|
|
}
|
|
|
|
/// Route a key transfer.
|
|
fn handle_transfer(&mut self, event: Event, cx: &mut Context<Self>) {
|
|
let resolved = self
|
|
.pending_request
|
|
.as_ref()
|
|
.is_some_and(|pending| transfer_addresses(&event, pending.client_key));
|
|
|
|
if resolved {
|
|
self.resolve_pending_request(cx);
|
|
return;
|
|
}
|
|
|
|
self.extract_encryption(event, cx);
|
|
}
|
|
|
|
/// Get the signer
|
|
pub fn signer(&self, cx: &App) -> Option<UniversalSigner> {
|
|
self.signer.read(cx).clone()
|
|
}
|
|
|
|
/// Set the decoupled encryption key for the current user
|
|
fn set_signer(&mut self, new_signer: Keys, cx: &mut Context<Self>) {
|
|
self.signer.update(cx, |this, cx| {
|
|
*this = Some(UniversalSigner::new(new_signer));
|
|
cx.notify();
|
|
});
|
|
// The local key is now consistent with the announcement
|
|
self.resync.store(false, Ordering::Release);
|
|
cx.emit(DeviceEvent::Set);
|
|
}
|
|
|
|
/// Whether the local encryption key is stale against the current announcement.
|
|
pub fn is_resyncing(&self) -> bool {
|
|
self.resync.load(Ordering::Acquire)
|
|
}
|
|
|
|
/// Backup the encryption's secret key, returning the `nsec1...` content
|
|
pub fn backup_bytes(&self, cx: &App) -> Task<Result<String, Error>> {
|
|
let nostr = NostrRegistry::global(cx);
|
|
let client = nostr.read(cx).client();
|
|
let signer = nostr.read(cx).signer();
|
|
|
|
cx.background_spawn(async move {
|
|
let keys = get_keys(&client, &signer).await?;
|
|
Ok(keys.secret_key().to_bech32()?)
|
|
})
|
|
}
|
|
|
|
/// Backup the encryption's secret key to a file
|
|
pub fn backup(&self, path: PathBuf, cx: &App) -> Task<Result<(), Error>> {
|
|
let backup = self.backup_bytes(cx);
|
|
|
|
#[cfg(not(target_arch = "wasm32"))]
|
|
return cx.background_spawn(async move {
|
|
let content = backup.await?;
|
|
smol::fs::write(path, &content).await?;
|
|
|
|
Ok(())
|
|
});
|
|
|
|
#[cfg(target_arch = "wasm32")]
|
|
{
|
|
let _ = path;
|
|
cx.background_spawn(async move {
|
|
backup.await?;
|
|
Err(anyhow!("File backups are not supported on web; copy the key from the backup panel instead."))
|
|
})
|
|
}
|
|
}
|
|
|
|
/// Initialize encryption from the local database before reconciling with relays
|
|
fn init_encryption(&mut self, cx: &mut Context<Self>) {
|
|
let nostr = NostrRegistry::global(cx);
|
|
let client = nostr.read(cx).client();
|
|
let signer = nostr.read(cx).signer();
|
|
|
|
self.tasks.push(cx.spawn(async move |this, cx| {
|
|
let Ok(keys) = get_keys(&client, &signer).await else {
|
|
// No local keys; the announcement reconciliation will guide setup
|
|
this.update(cx, |this, cx| this.get_announcement(cx))?;
|
|
return Ok(());
|
|
};
|
|
|
|
this.update(cx, |this, cx| {
|
|
// Relay reconciliation may have set the signer already
|
|
if this.signer.read(cx).is_none() {
|
|
this.set_signer(keys, cx);
|
|
this.wait_for_request(cx);
|
|
}
|
|
|
|
this.get_announcement(cx);
|
|
})?;
|
|
|
|
Ok(())
|
|
}));
|
|
}
|
|
|
|
/// Get device announcement for current user
|
|
pub fn get_announcement(&mut self, cx: &mut Context<Self>) {
|
|
let nostr = NostrRegistry::global(cx);
|
|
let client = nostr.read(cx).client();
|
|
let signer = nostr.read(cx).signer();
|
|
|
|
let announcement_existed = self.announcement_existed.clone();
|
|
|
|
self.tasks.push(cx.spawn(async move |this, cx| {
|
|
let task: Task<Result<(), Error>> = cx.background_spawn(async move {
|
|
let opts =
|
|
SubscribeAutoCloseOptions::default().exit_policy(ReqExitPolicy::ExitOnEOSE);
|
|
let current_user = signer.get_public_key_async().await?;
|
|
|
|
// Construct the filter for the device announcement event
|
|
let filter = Filter::new()
|
|
.kind(Kind::Custom(10044))
|
|
.author(current_user)
|
|
.limit(1);
|
|
|
|
client
|
|
.subscribe(filter)
|
|
.close_on(opts)
|
|
.with_id(SubscriptionId::new("nip4e"))
|
|
.await?;
|
|
|
|
Ok(())
|
|
});
|
|
|
|
if let Err(e) = task.await {
|
|
this.update(cx, |_this, cx| {
|
|
cx.emit(DeviceEvent::error(e.to_string()));
|
|
})?;
|
|
return Ok(());
|
|
}
|
|
|
|
if !announcement_existed.load(Ordering::Acquire) {
|
|
this.update(cx, |this, cx| {
|
|
// The device already initialized encryption from the local database
|
|
if this.signer.read(cx).is_none() {
|
|
cx.emit(DeviceEvent::NotSet);
|
|
}
|
|
})?;
|
|
}
|
|
|
|
Ok(())
|
|
}));
|
|
}
|
|
|
|
/// Create a new device signer and announce it to user's relay list
|
|
pub fn set_announcement(&mut self, keys: Keys, cx: &mut Context<Self>) {
|
|
let task = self.create_encryption(keys, cx);
|
|
|
|
self.tasks.push(cx.spawn(async move |this, cx| {
|
|
match task.await {
|
|
Ok(keys) => {
|
|
this.update(cx, |this, cx| {
|
|
this.set_signer(keys, cx);
|
|
this.wait_for_request(cx);
|
|
})?;
|
|
}
|
|
Err(e) => {
|
|
this.update(cx, |_this, cx| {
|
|
cx.emit(DeviceEvent::error(e.to_string()));
|
|
})?;
|
|
}
|
|
}
|
|
Ok(())
|
|
}));
|
|
}
|
|
|
|
/// Replace the encryption key with a new one, archiving the old key.
|
|
pub fn rotate(&mut self, cx: &mut Context<Self>) {
|
|
if self.rotating {
|
|
return;
|
|
}
|
|
self.rotating = true;
|
|
|
|
let nostr = NostrRegistry::global(cx);
|
|
let client = nostr.read(cx).client();
|
|
let signer = nostr.read(cx).signer();
|
|
|
|
self.tasks.push(cx.spawn(async move |this, cx| {
|
|
let result: Result<Keys, Error> = async {
|
|
// Archive the current key before replacing it
|
|
if let Ok(old) = get_keys(&client, &signer).await {
|
|
archive_key(&client, &signer, &old.secret_key().to_secret_hex()).await?;
|
|
}
|
|
|
|
let created = this
|
|
.update(cx, |this, cx| this.create_encryption(Keys::generate(), cx))?
|
|
.await?;
|
|
|
|
this.update(cx, |this, cx| {
|
|
this.set_signer(created.clone(), cx);
|
|
this.wait_for_request(cx);
|
|
})?;
|
|
|
|
Ok(created)
|
|
}
|
|
.await;
|
|
|
|
this.update(cx, |this, cx| {
|
|
this.rotating = false;
|
|
if let Err(e) = result {
|
|
cx.emit(DeviceEvent::error(e.to_string()));
|
|
}
|
|
})
|
|
.ok();
|
|
|
|
Ok(())
|
|
}));
|
|
}
|
|
|
|
/// Rotate the encryption key when the configured interval has elapsed.
|
|
///
|
|
/// Runs after the announcement reconciled, outside the blocking boot path.
|
|
pub fn rotate_if_due(&mut self, cx: &mut Context<Self>) {
|
|
let Some(interval_days) = AppSettings::get_nip4e_rotation_days(cx) else {
|
|
return;
|
|
};
|
|
let interval_days = interval_days.clamp(NIP4E_ROTATION_MIN_DAYS, NIP4E_ROTATION_MAX_DAYS);
|
|
|
|
let nostr = NostrRegistry::global(cx);
|
|
let client = nostr.read(cx).client();
|
|
let signer = nostr.read(cx).signer();
|
|
|
|
self.tasks.push(cx.spawn(async move |this, cx| {
|
|
let Ok(keys) = load_device_keys(&client, &signer).await else {
|
|
return Ok(());
|
|
};
|
|
|
|
let elapsed = Timestamp::now()
|
|
.as_secs()
|
|
.saturating_sub(keys.created_at.as_secs());
|
|
if elapsed < u64::from(interval_days) * SECONDS_PER_DAY {
|
|
return Ok(());
|
|
}
|
|
|
|
this.update(cx, |this, cx| this.rotate(cx)).ok();
|
|
|
|
Ok(())
|
|
}));
|
|
}
|
|
|
|
/// Load encryption keys retired by a rotation from the local database.
|
|
pub async fn archived_keys<S>(client: &Client, signer: &S) -> Result<Vec<Keys>, Error>
|
|
where
|
|
S: AsyncGetPublicKey + AsyncNip44 + ?Sized,
|
|
{
|
|
storage::archived_keys(client, signer).await
|
|
}
|
|
|
|
/// Create new encryption key and announce it to user's relay list
|
|
fn create_encryption(&self, keys: Keys, cx: &App) -> Task<Result<Keys, Error>> {
|
|
let nostr = NostrRegistry::global(cx);
|
|
let client = nostr.read(cx).client();
|
|
let signer = nostr.read(cx).signer();
|
|
|
|
let secret = keys.secret_key().to_secret_hex();
|
|
let n = keys.public_key();
|
|
let created_at = Timestamp::now();
|
|
|
|
cx.background_spawn(async move {
|
|
// Construct an announcement event
|
|
let event = EventBuilder::new(Kind::Custom(10044), "")
|
|
.tag(Tag::custom("n", vec![n]))
|
|
.finalize_async(&signer)
|
|
.await?;
|
|
|
|
// Persist the key locally before announcing it
|
|
set_keys(&client, &signer, &secret, created_at).await?;
|
|
|
|
// Publish announcement
|
|
client
|
|
.send_event(&event)
|
|
.to_nip65()
|
|
.ack_policy(AckPolicy::none())
|
|
.await?;
|
|
|
|
Ok(keys)
|
|
})
|
|
}
|
|
|
|
/// Set encryption key from the announcement event
|
|
fn set_encryption(&mut self, event: &Event, cx: &mut Context<Self>) {
|
|
let Some(announcement) = Announcement::from_event(event) else {
|
|
log::warn!("Ignoring malformed encryption announcement");
|
|
return;
|
|
};
|
|
|
|
let nostr = NostrRegistry::global(cx);
|
|
let client = nostr.read(cx).client();
|
|
let signer = nostr.read(cx).signer();
|
|
|
|
let device_pubkey = announcement.public_key();
|
|
|
|
// Get encryption key from the database and compare with the announcement
|
|
let task: Task<Result<Keys, Error>> = cx.background_spawn(async move {
|
|
let keys = get_keys(&client, &signer).await?;
|
|
|
|
// Compare the public key from the announcement with the one from the database
|
|
if keys.public_key() != device_pubkey {
|
|
return Err(anyhow!("Encryption Key doesn't match the announcement"));
|
|
};
|
|
|
|
Ok(keys)
|
|
});
|
|
|
|
self.tasks.push(cx.spawn(async move |this, cx| {
|
|
if let Ok(keys) = task.await {
|
|
this.update(cx, |this, cx| {
|
|
// The local database may have initialized this device already
|
|
if this.signer.read(cx).is_none() {
|
|
this.set_signer(keys, cx);
|
|
this.wait_for_request(cx);
|
|
}
|
|
this.rotate_if_due(cx);
|
|
})?;
|
|
} else {
|
|
this.update(cx, |this, cx| {
|
|
this.resync.store(true, Ordering::Release);
|
|
this.request(Some(device_pubkey), cx);
|
|
})?;
|
|
}
|
|
Ok(())
|
|
}));
|
|
}
|
|
|
|
/// Wait for encryption key requests from now on
|
|
fn wait_for_request(&mut self, cx: &mut Context<Self>) {
|
|
let nostr = NostrRegistry::global(cx);
|
|
let client = nostr.read(cx).client();
|
|
let signer = nostr.read(cx).signer();
|
|
|
|
self.tasks.push(cx.background_spawn(async move {
|
|
let public_key = signer.get_public_key_async().await?;
|
|
|
|
let id = SubscriptionId::new("dekey-requests");
|
|
let since = Timestamp::now().as_secs().saturating_sub(REQUEST_MAX_AGE);
|
|
let filter = Filter::new()
|
|
.kind(Kind::Custom(4454))
|
|
.author(public_key)
|
|
.since(Timestamp::from_secs(since));
|
|
|
|
// Subscribe to the device key requests on user's write relays
|
|
client.subscribe(vec![filter]).with_id(id).await?;
|
|
|
|
Ok(())
|
|
}));
|
|
}
|
|
|
|
/// Request encryption keys from other device
|
|
pub(crate) fn request(
|
|
&mut self,
|
|
expected_encryption: Option<PublicKey>,
|
|
cx: &mut Context<Self>,
|
|
) {
|
|
let nostr = NostrRegistry::global(cx);
|
|
let client = nostr.read(cx).client();
|
|
let signer = nostr.read(cx).signer();
|
|
let app_keys = self.app_keys.get_or_insert_with(Keys::generate).clone();
|
|
|
|
let task: Task<Result<Option<Event>, Error>> = cx.background_spawn(async move {
|
|
let app_pubkey = app_keys.public_key();
|
|
let public_key = signer.get_public_key_async().await?;
|
|
|
|
// Construct a filter to get the latest approval event
|
|
let filter = Filter::new()
|
|
.kind(Kind::Custom(4455))
|
|
.author(public_key)
|
|
.pubkey(app_pubkey)
|
|
.limit(1);
|
|
|
|
if let Some(event) = client.database().query(filter).await?.into_iter().next() {
|
|
// Only reuse the stored approval if its key is still valid
|
|
if decrypt_approval(&client, &app_keys, public_key, &event)
|
|
.await
|
|
.is_ok()
|
|
{
|
|
return Ok(Some(event));
|
|
}
|
|
}
|
|
|
|
// No usable approval event found, construct a request event.
|
|
//
|
|
// The `pubkey` tag is a compatibility alias for the draft's `P`,
|
|
// `relay` hints tell other devices where the response is accepted,
|
|
// `n` names the exact key this device expects to be transferred
|
|
let mut tags = vec![
|
|
Tag::custom("P", vec![app_pubkey]),
|
|
Tag::custom("pubkey", vec![app_pubkey]),
|
|
];
|
|
|
|
for url in write_relay_hints(&client, public_key).await? {
|
|
tags.push(Tag::custom("relay", vec![url.to_string()]));
|
|
}
|
|
|
|
if let Some(expected) = expected_encryption {
|
|
tags.push(Tag::custom("n", vec![expected]));
|
|
}
|
|
|
|
let event = EventBuilder::new(Kind::Custom(4454), "")
|
|
.tags(tags)
|
|
.finalize_async(&signer)
|
|
.await?;
|
|
|
|
// Send the event to write relays
|
|
client.send_event(&event).to_nip65().await?;
|
|
|
|
Ok(None)
|
|
});
|
|
|
|
self.tasks.push(cx.spawn(async move |this, cx| {
|
|
match task.await {
|
|
Ok(Some(event)) => {
|
|
this.update(cx, |this, cx| {
|
|
this.extract_encryption(event, cx);
|
|
})?;
|
|
}
|
|
Ok(None) => {
|
|
this.update(cx, |this, cx| {
|
|
this.wait_for_approval(cx);
|
|
})?;
|
|
}
|
|
Err(e) => {
|
|
this.update(cx, |_this, cx| {
|
|
cx.emit(DeviceEvent::error(e.to_string()));
|
|
})?;
|
|
}
|
|
};
|
|
Ok(())
|
|
}));
|
|
}
|
|
|
|
/// Wait for encryption key approvals
|
|
fn wait_for_approval(&mut self, cx: &mut Context<Self>) {
|
|
let nostr = NostrRegistry::global(cx);
|
|
let client = nostr.read(cx).client();
|
|
let signer = nostr.read(cx).signer();
|
|
|
|
let Some(app_keys) = self.app_keys.clone() else {
|
|
log::warn!("Cannot wait for approval without a client key");
|
|
return;
|
|
};
|
|
|
|
self.tasks.push(cx.spawn(async move |this, cx| {
|
|
this.update(cx, |_this, cx| {
|
|
cx.emit(DeviceEvent::Requesting(authorization_code(
|
|
&app_keys.public_key(),
|
|
)));
|
|
})?;
|
|
|
|
let task: Task<Result<(), Error>> = cx.background_spawn(async move {
|
|
let public_key = signer.get_public_key_async().await?;
|
|
|
|
// Only approvals addressed to this device's client key matter
|
|
let filter = Filter::new()
|
|
.kind(Kind::Custom(4455))
|
|
.author(public_key)
|
|
.pubkey(app_keys.public_key());
|
|
|
|
// Subscribe to the device key approvals on user's write relays
|
|
client.subscribe(filter).await?;
|
|
|
|
Ok(())
|
|
});
|
|
|
|
if let Err(e) = task.await {
|
|
this.update(cx, |_this, cx| {
|
|
cx.emit(DeviceEvent::error(e.to_string()));
|
|
})?;
|
|
}
|
|
|
|
Ok(())
|
|
}));
|
|
}
|
|
|
|
/// Parse the approval event to get encryption key then set it
|
|
fn extract_encryption(&mut self, event: Event, cx: &mut Context<Self>) {
|
|
let nostr = NostrRegistry::global(cx);
|
|
let client = nostr.read(cx).client();
|
|
let signer = nostr.read(cx).signer();
|
|
|
|
let Some(app_keys) = self.app_keys.clone() else {
|
|
log::warn!("Ignoring key transfer addressed to another device");
|
|
return;
|
|
};
|
|
|
|
let approval_id = event.id;
|
|
|
|
let task: Task<Result<Keys, Error>> = cx.background_spawn(async move {
|
|
let identity = signer.get_public_key_async().await?;
|
|
let keys = decrypt_approval(&client, &app_keys, identity, &event).await?;
|
|
|
|
// Persist the transferred key so restarts initialize from the local database
|
|
if let Err(e) = set_keys(
|
|
&client,
|
|
&signer,
|
|
&keys.secret_key().to_secret_hex(),
|
|
Timestamp::now(),
|
|
)
|
|
.await
|
|
{
|
|
log::error!("Failed to persist the transferred encryption key: {e}");
|
|
}
|
|
|
|
Ok(keys)
|
|
});
|
|
|
|
self.tasks.push(cx.spawn(async move |this, cx| {
|
|
match task.await {
|
|
Ok(keys) => {
|
|
this.update(cx, |this, cx| {
|
|
this.set_signer(keys, cx);
|
|
// The client key was consumed; start fresh on the next request
|
|
this.app_keys = None;
|
|
// Clean up our request and the approval event from relays
|
|
this.cleanup_sync_events(approval_id, cx);
|
|
})?;
|
|
}
|
|
Err(e) => {
|
|
log::warn!("Ignoring key transfer: {e}");
|
|
}
|
|
}
|
|
Ok(())
|
|
}));
|
|
}
|
|
|
|
/// Delete our key request and the consumed approval event from relays
|
|
fn cleanup_sync_events(&mut self, approval_id: EventId, cx: &mut Context<Self>) {
|
|
let nostr = NostrRegistry::global(cx);
|
|
let client = nostr.read(cx).client();
|
|
let signer = nostr.read(cx).signer();
|
|
|
|
self.tasks.push(cx.background_spawn(async move {
|
|
let result: Result<(), Error> = async {
|
|
let public_key = signer.get_public_key_async().await?;
|
|
|
|
// Collect our key request events
|
|
let filter = Filter::new().kind(Kind::Custom(4454)).author(public_key);
|
|
|
|
let mut ids: Vec<EventId> = client
|
|
.database()
|
|
.query(filter)
|
|
.await?
|
|
.into_iter()
|
|
.map(|event| event.id)
|
|
.collect();
|
|
ids.push(approval_id);
|
|
|
|
let deletion = EventBuilder::new(Kind::EventDeletion, "")
|
|
.tags(Tags::from_list(ids.into_iter().map(Tag::event).collect()))
|
|
.finalize_async(&signer)
|
|
.await?;
|
|
|
|
client.send_event(&deletion).to_nip65().await?;
|
|
|
|
Ok(())
|
|
}
|
|
.await;
|
|
|
|
if let Err(e) = result {
|
|
log::error!("Failed to delete sync events: {e}");
|
|
}
|
|
|
|
Ok(())
|
|
}));
|
|
}
|
|
|
|
/// Approve requests for device keys from other devices
|
|
fn approve(&mut self, event: &Event, window: &mut Window, cx: &mut Context<Self>) {
|
|
let nostr = NostrRegistry::global(cx);
|
|
let client = nostr.read(cx).client();
|
|
let signer = nostr.read(cx).signer();
|
|
|
|
let event = event.clone();
|
|
let request_id = event.id;
|
|
|
|
let task: Task<Result<(), Error>> = cx.background_spawn(async move {
|
|
// Get device keys
|
|
let keys = get_keys(&client, &signer).await?;
|
|
let secret = keys.secret_key().to_secret_hex();
|
|
let identity = signer.get_public_key_async().await?;
|
|
|
|
// Extract the target public key from the event tags
|
|
let target =
|
|
client_pubkey_from_event(&event).context("Target is not a valid public key")?;
|
|
|
|
// The requester may pin the exact key it expects
|
|
if let Some(requested) = requested_encryption_key(&event)
|
|
&& requested != keys.public_key()
|
|
{
|
|
return Err(anyhow!(
|
|
"The requesting device expects an encryption key this device no longer holds"
|
|
));
|
|
}
|
|
|
|
// Encrypt to a fresh one-time keypair so the transfer event
|
|
// can never be decrypted with the long-lived encryption key.
|
|
let sender = Keys::generate();
|
|
let payload = sender.nip44_encrypt_async(&target, &secret).await?;
|
|
|
|
// Construct the response event
|
|
//
|
|
// P tag: the one-time sender key used for the encryption
|
|
// p tag: the account identity, for inbox routing
|
|
// p tag: the requester's client key
|
|
let response = EventBuilder::new(Kind::Custom(4455), payload)
|
|
.tags(vec![
|
|
Tag::custom("P", vec![sender.public_key().to_hex()]),
|
|
Tag::public_key(identity),
|
|
Tag::public_key(target),
|
|
])
|
|
.finalize_async(&signer)
|
|
.await?;
|
|
|
|
let relays = merge_relays(
|
|
write_relay_hints(&client, identity).await?,
|
|
request_relay_hints(&event),
|
|
);
|
|
|
|
let send = client.send_event(&response);
|
|
if relays.is_empty() {
|
|
send.to_nip65().await?;
|
|
} else {
|
|
send.to(relays).await?;
|
|
}
|
|
|
|
Ok(())
|
|
});
|
|
|
|
self.tasks.push(cx.spawn_in(window, async move |this, cx| {
|
|
match task.await {
|
|
Ok(_) => {
|
|
this.update(cx, |this, cx| {
|
|
// Record the request as handled so it cannot resurface
|
|
this.mark_request_processed(request_id, cx);
|
|
// Allow future requests to surface again
|
|
this.pending_request = None;
|
|
cx.notify();
|
|
})?;
|
|
|
|
cx.update(|window, cx| {
|
|
window.remove_notification::<DeviceNotification>(cx);
|
|
})
|
|
.ok();
|
|
}
|
|
Err(e) => {
|
|
cx.update(|window, cx| {
|
|
window.push_notification(
|
|
Notification::error(e.to_string()).autohide(false),
|
|
cx,
|
|
);
|
|
})
|
|
.ok();
|
|
}
|
|
};
|
|
|
|
Ok(())
|
|
}));
|
|
}
|
|
|
|
/// Handle encryption request
|
|
fn ask_for_approval(&mut self, event: Event, cx: &mut Context<Self>) {
|
|
let expires_at = Timestamp::now()
|
|
.as_secs()
|
|
.saturating_sub(event.created_at.as_secs());
|
|
|
|
if expires_at > REQUEST_MAX_AGE {
|
|
log::warn!("Ignoring expired encryption key request");
|
|
return;
|
|
}
|
|
|
|
let Some(client_key) = client_pubkey_from_event(&event) else {
|
|
log::warn!("Ignoring invalid encryption key request: no valid requester key");
|
|
return;
|
|
};
|
|
|
|
let read = credentials::read_processed_requests(cx);
|
|
|
|
cx.spawn(async move |this, cx| {
|
|
let processed = match read.await {
|
|
Ok(bytes) => bytes
|
|
.map(|bytes| parse_processed_requests(&bytes).contains(&event.id))
|
|
.unwrap_or(false),
|
|
Err(e) => {
|
|
log::error!("Failed to read processed key-sync requests: {e}");
|
|
false
|
|
}
|
|
};
|
|
|
|
this.update(cx, |this, cx| {
|
|
if processed || this.processed_requests.contains(&event.id) {
|
|
return;
|
|
}
|
|
|
|
match this.pending_request.take() {
|
|
// A retry signs a new request id but keeps the same client key
|
|
Some(mut pending) if pending.client_key == client_key => {
|
|
this.mark_request_processed(event.id, cx);
|
|
pending.event = event;
|
|
this.pending_request = Some(pending);
|
|
}
|
|
|
|
// A different client key is a remounted requester
|
|
other => {
|
|
if let Some(pending) = other {
|
|
this.mark_request_processed(pending.event.id, cx);
|
|
if let Some(window) = cx.windows().first().copied() {
|
|
window
|
|
.update(cx, |_view, window, cx| {
|
|
window.remove_notification::<DeviceNotification>(cx);
|
|
})
|
|
.ok();
|
|
}
|
|
}
|
|
this.show_approval(event, client_key, cx);
|
|
}
|
|
}
|
|
})
|
|
.ok();
|
|
})
|
|
.detach();
|
|
}
|
|
|
|
/// Build and surface the approval notification for a key request
|
|
fn show_approval(&mut self, event: Event, client_key: PublicKey, cx: &mut Context<Self>) {
|
|
let notification = match self.notification(event.clone(), cx) {
|
|
Ok(notification) => notification,
|
|
Err(e) => {
|
|
log::warn!("Ignoring invalid encryption key request: {e}");
|
|
return;
|
|
}
|
|
};
|
|
|
|
self.pending_request = Some(PendingRequest { event, client_key });
|
|
cx.notify();
|
|
|
|
if let Some(window) = cx.windows().first().copied() {
|
|
if let Err(error) = window.update(cx, |_view, window, cx| {
|
|
window.push_notification(notification, cx);
|
|
}) {
|
|
log::warn!("Failed to show encryption key request: {error}");
|
|
}
|
|
} else {
|
|
log::warn!("Failed to show encryption key request: no open window");
|
|
}
|
|
}
|
|
|
|
/// Build a notification for the encryption request.
|
|
fn notification(
|
|
&mut self,
|
|
event: Event,
|
|
cx: &mut Context<Self>,
|
|
) -> Result<Notification, Error> {
|
|
const MSG: &str = "You've requested an encryption key from another device. \
|
|
Approve to allow Coop to share with it. Before approving, \
|
|
compare the code with the one shown on the requesting \
|
|
device.";
|
|
|
|
let requester =
|
|
client_pubkey_from_event(&event).context("Request has no valid requester key")?;
|
|
|
|
let code = authorization_code(&requester);
|
|
let code_label = code.clone();
|
|
|
|
let directory = self.directory.clone();
|
|
directory.update(cx, |directory, cx| {
|
|
directory.track([requester], cx);
|
|
});
|
|
|
|
let entity = cx.entity().downgrade();
|
|
let loading = Rc::new(Cell::new(false));
|
|
|
|
Ok(Notification::new()
|
|
.id::<DeviceNotification>()
|
|
.autohide(false)
|
|
.with_type(NotificationType::Info)
|
|
.title("Encryption Key Request")
|
|
.content(move |_this, _window, cx| {
|
|
let profile = directory.read(cx).person(&requester, cx);
|
|
|
|
v_flex()
|
|
.gap_2()
|
|
.text_xs()
|
|
.child(
|
|
div()
|
|
.text_xs()
|
|
.line_height(relative(1.25))
|
|
.child(SharedString::from(MSG)),
|
|
)
|
|
.child(
|
|
v_flex()
|
|
.gap_2()
|
|
.child(
|
|
v_flex()
|
|
.gap_1()
|
|
.text_xs()
|
|
.child(
|
|
div()
|
|
.font_semibold()
|
|
.text_xs()
|
|
.text_color(cx.theme().muted_foreground)
|
|
.child(SharedString::from("From:")),
|
|
)
|
|
.child(
|
|
div()
|
|
.h_8()
|
|
.w_full()
|
|
.px_2()
|
|
.rounded(cx.theme().radius)
|
|
.bg(cx.theme().muted)
|
|
.child(
|
|
h_flex()
|
|
.gap_2()
|
|
.child(
|
|
Avatar::new(profile.avatar())
|
|
.seed(profile.avatar_seed())
|
|
.xsmall(),
|
|
)
|
|
.child(profile.name()),
|
|
),
|
|
),
|
|
)
|
|
.child(
|
|
v_flex()
|
|
.gap_1()
|
|
.text_xs()
|
|
.child(
|
|
div()
|
|
.font_semibold()
|
|
.text_xs()
|
|
.text_color(cx.theme().muted_foreground)
|
|
.child(SharedString::from("Code:")),
|
|
)
|
|
.child(
|
|
div()
|
|
.h_8()
|
|
.w_full()
|
|
.px_2()
|
|
.rounded(cx.theme().radius)
|
|
.bg(cx.theme().muted)
|
|
.child(code_label.clone()),
|
|
),
|
|
),
|
|
)
|
|
.into_any_element()
|
|
})
|
|
.on_close({
|
|
let entity = entity.clone();
|
|
let request_id = event.id;
|
|
|
|
move |_window, cx| {
|
|
// Closing without approving rejects the request, so it must not resurface
|
|
entity
|
|
.update(cx, |this, cx| {
|
|
this.mark_request_processed(request_id, cx);
|
|
})
|
|
.ok();
|
|
}
|
|
})
|
|
.action(move |_this, _window, _cx| {
|
|
let view = entity.clone();
|
|
let event = event.clone();
|
|
|
|
Button::new("approve")
|
|
.label("Approve")
|
|
.loading(loading.get())
|
|
.disabled(loading.get())
|
|
.on_click({
|
|
let loading = Rc::clone(&loading);
|
|
move |_ev, window, cx| {
|
|
// Set loading state to true
|
|
loading.set(true);
|
|
// Process to approve the request
|
|
view.update(cx, |this, cx| {
|
|
this.approve(&event, window, cx);
|
|
})
|
|
.ok();
|
|
}
|
|
})
|
|
}))
|
|
}
|
|
}
|
|
|
|
/// Parse concatenated hex event ids
|
|
fn parse_processed_requests(bytes: &[u8]) -> VecDeque<EventId> {
|
|
let Ok(hex) = std::str::from_utf8(bytes) else {
|
|
return VecDeque::new();
|
|
};
|
|
|
|
hex.as_bytes()
|
|
.as_chunks::<64>()
|
|
.0
|
|
.iter()
|
|
.filter_map(|chunk| EventId::from_hex(std::str::from_utf8(chunk).ok()?).ok())
|
|
.collect()
|
|
}
|
|
|
|
/// Extract the client public key from an event.
|
|
fn client_pubkey_from_event(event: &Event) -> Option<PublicKey> {
|
|
let key = event
|
|
.tags
|
|
.iter()
|
|
.find(|tag| tag.kind() == "P")
|
|
.and_then(|tag| tag.content())
|
|
.and_then(|content| PublicKey::parse(content).ok());
|
|
|
|
key.or_else(|| {
|
|
event
|
|
.tags
|
|
.iter()
|
|
.find(|tag| tag.kind() == "pubkey")
|
|
.and_then(|tag| tag.content())
|
|
.and_then(|content| PublicKey::parse(content).ok())
|
|
})
|
|
}
|
|
|
|
/// Whether the transfer event is p-tagged to the given client key
|
|
fn transfer_addresses(event: &Event, client_key: PublicKey) -> bool {
|
|
event.tags.iter().any(|tag| {
|
|
tag.kind() == "p"
|
|
&& tag
|
|
.content()
|
|
.and_then(|content| PublicKey::parse(content).ok())
|
|
.is_some_and(|key| key == client_key)
|
|
})
|
|
}
|
|
|
|
/// Parse the `relay` hints attached to a key request.
|
|
fn request_relay_hints(event: &Event) -> Vec<RelayUrl> {
|
|
event
|
|
.tags
|
|
.iter()
|
|
.filter(|tag| tag.kind() == "relay")
|
|
.filter_map(|tag| {
|
|
tag.content()
|
|
.and_then(|content| RelayUrl::parse(content).ok())
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
/// Parse the optional `n` tag of a key request.
|
|
fn requested_encryption_key(event: &Event) -> Option<PublicKey> {
|
|
event
|
|
.tags
|
|
.iter()
|
|
.find(|tag| tag.kind() == "n")
|
|
.and_then(|tag| tag.content())
|
|
.and_then(|content| PublicKey::parse(content).ok())
|
|
}
|
|
|
|
/// Collect the user's NIP-65 write relays.
|
|
async fn write_relay_hints(client: &Client, identity: PublicKey) -> Result<Vec<RelayUrl>, Error> {
|
|
let filter = Filter::new()
|
|
.kind(Kind::RelayList)
|
|
.author(identity)
|
|
.limit(1);
|
|
|
|
let Some(event) = client.database().query(filter).await?.into_iter().next() else {
|
|
return Ok(vec![]);
|
|
};
|
|
|
|
// Unmarked relays serve both reads and writes
|
|
Ok(nip65::extract_relay_list(&event)
|
|
.filter(|(_, metadata)| *metadata != Some(RelayMetadata::Read))
|
|
.map(|(url, _)| url)
|
|
.collect())
|
|
}
|
|
|
|
/// Merge relay lists, dropping duplicates
|
|
fn merge_relays(first: Vec<RelayUrl>, second: Vec<RelayUrl>) -> Vec<RelayUrl> {
|
|
first
|
|
.into_iter()
|
|
.chain(second)
|
|
.collect::<HashSet<_>>()
|
|
.into_iter()
|
|
.collect()
|
|
}
|
|
|
|
/// The first eight hexadecimal characters of the client public key.
|
|
fn authorization_code(public_key: &PublicKey) -> SharedString {
|
|
let hex = public_key.to_hex();
|
|
let code = hex[..8].to_uppercase();
|
|
SharedString::from(format!("{} {}", &code[..4], &code[4..]))
|
|
}
|
|
|
|
/// Decrypt and validate an approval event against the current announcement.
|
|
async fn decrypt_approval(
|
|
client: &Client,
|
|
app_keys: &Keys,
|
|
identity: PublicKey,
|
|
event: &Event,
|
|
) -> Result<Keys, Error> {
|
|
let master = client_pubkey_from_event(event).context("Invalid event's tags")?;
|
|
|
|
let decrypted = app_keys
|
|
.nip44_decrypt_async(&master, event.content.as_str())
|
|
.await?;
|
|
|
|
let secret = SecretKey::from_hex(&decrypted)?;
|
|
let keys = Keys::new(secret);
|
|
|
|
// Reject approvals carrying a key that no longer matches the published announcement
|
|
let filter = Filter::new()
|
|
.kind(Kind::Custom(10044))
|
|
.author(identity)
|
|
.limit(1);
|
|
|
|
let announcement = client
|
|
.database()
|
|
.query(filter.clone())
|
|
.await?
|
|
.into_iter()
|
|
.next();
|
|
|
|
let announcement = match announcement {
|
|
Some(announcement) => Some(announcement),
|
|
None => {
|
|
let mut stream = client
|
|
.stream_events(filter)
|
|
.timeout(Duration::from_secs(3))
|
|
.await?;
|
|
|
|
stream
|
|
.next()
|
|
.await
|
|
.map(|(_url, result)| result)
|
|
.transpose()?
|
|
}
|
|
};
|
|
|
|
let Some(announcement) = announcement else {
|
|
return Err(anyhow!(
|
|
"No encryption announcement available to validate the approval"
|
|
));
|
|
};
|
|
|
|
let announced = announcement
|
|
.tags
|
|
.iter()
|
|
.find(|tag| tag.kind() == "n")
|
|
.and_then(|tag| tag.content())
|
|
.and_then(|content| PublicKey::parse(content).ok())
|
|
.context("Announcement has no valid encryption key")?;
|
|
|
|
if keys.public_key() != announced {
|
|
return Err(anyhow!("Approval key doesn't match the announcement"));
|
|
}
|
|
|
|
Ok(keys)
|
|
}
|