From b06bbb48e6c6c7f81a9592ab9562bb8e3042b2b6 Mon Sep 17 00:00:00 2001 From: Adam Soltys Date: Sun, 27 Sep 2026 08:29:00 -0700 Subject: Amber (NIP-55) signs you in on Android: one intent per request, the answer read off the clipboard or pasted. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Closes #7. A "Sign in with Amber" door on Android opens nostrsigner: intents for get_public_key, sign_event and nip44 encrypt/decrypt, with a waiting card that reads the clipboard when the tab returns (or takes a paste). Requests queue one at a time — a sign-in fires the backup, relay list and follows together — and each answer is checked for its type so a stale clipboard is never mistaken for one. An interactive signer is not asked to decrypt DMs or private lists that arrive on their own; each trip through Amber is a deliberate one. Co-Authored-By: Claude Fable 5.1 Claude-Session: https://claude.ai/code/session_01VhUKyXKtsJ67QAFfb7QR9D --- src/features/messages.js | 8 +-- src/features/nostrlogin.js | 32 ++++++++++- src/i18n.js | 6 +++ src/nostr-login.js | 130 +++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 171 insertions(+), 5 deletions(-) (limited to 'src') diff --git a/src/features/messages.js b/src/features/messages.js index 16bc052..06cb6dd 100644 --- a/src/features/messages.js +++ b/src/features/messages.js @@ -2141,7 +2141,7 @@ export function messagesFeature(ctx) { dec: async (ct) => nip44.decrypt(ct, wallet.nostr.ck), }); const login = hook('nostrLoginIdentity'); - if (login && login.signer && login.signer.encryptSelf) out.push({ + if (login && login.signer && login.signer.encryptSelf && !login.signer.interactive) out.push({ pk: login.pubkey, sign: (e) => login.signer.signEvent(e), enc: (txt) => login.signer.encryptSelf(txt), @@ -2506,7 +2506,9 @@ export function messagesFeature(ctx) { const out = []; if (wallet.nostr && wallet.nostr.sk) out.push(wallet.nostr.sk); const login = hook('nostrLoginIdentity'); - if (login && login.signer && login.signer.decryptFrom) out.push(login.signer); + // an interactive signer (Amber by intent) is a trip through another app + // per call: never for a wrap that arrives on its own + if (login && login.signer && login.signer.decryptFrom && !login.signer.interactive) out.push(login.signer); return out; } // A "full-strength" attempt has every key this wallet expects: retries @@ -2515,7 +2517,7 @@ export function messagesFeature(ctx) { // sealed to the login npub. function decryptorsComplete() { const login = hook('nostrLoginIdentity'); - return !login || !!(login.signer && login.signer.decryptFrom); + return !login || !login.signer || !!login.signer.interactive || !!login.signer.decryptFrom; } // Raw-key unwraps (seed-derived / pasted nsec — the common case) run in diff --git a/src/features/nostrlogin.js b/src/features/nostrlogin.js index fef054b..306a12f 100644 --- a/src/features/nostrlogin.js +++ b/src/features/nostrlogin.js @@ -15,7 +15,8 @@ import { t } from '../i18n.js'; import { qrSvg } from '../qr.js'; import { extensionSigner, bunkerSigner, keySigner, parseNostrSecret, - walletForSigner, publishWalletBackup, fetchWalletBackup, nostrConnect, nostrConnectPending, resumeBunker } from '../nostr-login.js'; + walletForSigner, publishWalletBackup, fetchWalletBackup, nostrConnect, nostrConnectPending, resumeBunker, + amberAvailable, amberSigner, amberPending, amberDeliver, amberCancel, onAmberChange } from '../nostr-login.js'; // The nostr ostrich, in the brand's monochrome. const OSTRICH = ''; @@ -126,6 +127,7 @@ export function nostrLoginFeature(ctx) { ? ui.nostrLoginVia : signer && signer.kind === 'bunker' ? 'bunker' : signer && signer.kind === 'extension' ? 'extension' + : signer && signer.kind === 'amber' ? 'amber' : 'key'; const busy = (v) => { ui.nostrLoginBusy = v; render(); }; @@ -382,6 +384,22 @@ export function nostrLoginFeature(ctx) { // is a lazy chunk, so the two strings live here too). const GOOGLE_CENTRAL = 'https://auth.njump.me'; // flip to auth.coinos.io with pomegranate.js DEFAULT_CENTRAL const GOOGLE_LEGACY = 'https://auth.njump.me'; + // While a request is out with the signer app: what to do, and a way in for + // the answer when the browser won't read the clipboard for us. + onAmberChange(() => render()); + function amberWaitCard() { + const p = amberPending(); + if (!p) return null; + const e = ui.amberPaste || (ui.amberPaste = { text: '' }); + return h('div', { class: 'card col amber-wait', style: 'gap:8px' }, + h('div', { class: 'row gap6', style: 'align-items:center' }, h('span', { class: 'spinner sm' }), h('span', { class: 'small' }, t('nlAmberWait'))), + h('div', { class: 'small muted' }, t('nlAmberPasteHint')), + h('div', { class: 'row gap6' }, + h('input', { type: 'text', class: 'grow amber-paste', placeholder: t('nlAmberPastePh'), value: e.text, autocapitalize: 'none', autocomplete: 'off', spellcheck: 'false', + onInput: (ev) => { e.text = ev.target.value; } }), + h('button', { class: 'btn-sm', type: 'button', onClick: () => { if (amberDeliver(e.text)) e.text = ''; else { ui.nostrLoginError = t('nlAmberBadPaste'); render(); } } }, t('nlAmberPasteBtn'))), + h('button', { class: 'btn-ghost btn-sm', type: 'button', onClick: () => amberCancel() }, t('cancel'))); + } function externalButtons(run, big = false) { const hasPasskey = typeof window !== 'undefined' && !!window.PublicKeyCredential && !!navigator.credentials; const pad = big ? 'padding:14px' : ''; @@ -423,6 +441,13 @@ export function nostrLoginFeature(ctx) { onClick: () => run(() => extensionSigner()) }, t('nlExtension')) : null, nostrConnectSection(run), + // On Android, the signer app straight through an intent (NIP-55): works + // with Amber offline, no bunker, no relay — one trip through the app + // per signature. + amberAvailable() + ? h('button', { class: 'btn-block', disabled: ui.nostrLoginBusy, onClick: () => run(() => amberSigner()) }, t('nlAmber')) + : null, + amberWaitCard(), // These are alternatives, not steps: without the divider the field under // the button reads as something you also have to fill in. h('div', { class: 'or-split' }, h('span', {}, t('or'))), @@ -585,6 +610,9 @@ export function nostrLoginFeature(ctx) { if (s.pubkey === st.pubkey) return (live = s); } catch {} } + // an Android signer app: the stored pubkey is the whole session, and + // coming back needs no round trip (the first signature will be one) + if (st.session && st.session.amber === st.pubkey) return (live = await amberSigner({ pubkey: st.pubkey })); if (st.session) { try { const s = await resumeBunker(st.session, { onAuth: (url) => { ui.nostrLoginAuthUrl = url; render(); } }); @@ -604,7 +632,7 @@ export function nostrLoginFeature(ctx) { // Which door this account came through, for the reconnect surfaces. State // saved before `via` existed: a stored session means a bunker; without one // it could be extension, key, or passkey — offer everything. - const reconnectViaOf = (st) => st.via || (st.session ? 'bunker' : 'legacy'); + const reconnectViaOf = (st) => st.via || (st.session && st.session.amber ? 'amber' : st.session ? 'bunker' : 'legacy'); // Fire-and-forget resume for render paths: heal the badge without anyone // tapping, repaint when it lands. resumeLogin's own gating keeps this from diff --git a/src/i18n.js b/src/i18n.js index bab913d..165dc6c 100644 --- a/src/i18n.js +++ b/src/i18n.js @@ -985,6 +985,12 @@ const STR = { nlSignInNostr: 'Sign in with Nostr', nlDesc: 'Use your Nostr account to open your wallet — on any device, with the same account.', nlExtension: 'Use browser extension', + nlAmber: 'Sign in with Amber (Android)', + nlAmberWait: 'Waiting for your signer app… approve there, then come back here.', + nlAmberPasteHint: 'The answer is read from the clipboard when you return. If nothing happens, paste it here:', + nlAmberPastePh: 'Paste the signer’s answer', + nlAmberPasteBtn: 'Use it', + nlAmberBadPaste: 'That doesn’t look like the answer to this request.', nlGoogle: 'Sign in with Google', nlPasskey: 'Sign in with a passkey', nlKeyOrBunker: 'nsec, private key, or bunker://…', diff --git a/src/nostr-login.js b/src/nostr-login.js index 6666ed7..085d985 100644 --- a/src/nostr-login.js +++ b/src/nostr-login.js @@ -39,6 +39,7 @@ import { wordlist } from '@scure/bip39/wordlists/english'; import { getPublicKey, finalizeEvent, nip44 } from './nostr.js'; import { SimplePool } from 'nostr-tools/pool'; import { generateSecretKey } from 'nostr-tools/pure'; +import { decode as nip19decode } from 'nostr-tools/nip19'; // NIP-46 loads lazily from dist/nip46.js (same pattern as the QR decoder): // bunker logins are rare, and the module is heavy. Tests running outside a @@ -304,6 +305,135 @@ export async function nostrConnect({ relays = ['wss://relay.coinos.io', 'wss://n } // A pasted key: signing happens locally, and the key is never persisted. +// ---- NIP-55: an Android signer app (Amber), by intent -------------------- +// Amber without a bunker (offline, no relays) can still sign for a web +// page: the page opens a `nostrsigner:` URL and the app answers. A web page +// cannot receive an intent result, so the answer comes back one of two +// ways — appended to a callback URL, which NAVIGATES the tab (our TWA would +// reload, losing the promise that asked), or copied to the clipboard when +// no callback is given. We take the clipboard: the tab stays alive, every +// caller's await survives, and when the user comes back here the answer is +// read off the clipboard. If the browser won't hand the clipboard over, +// the login card offers a box to paste it into (amberDeliver). Each request +// is a round trip through the app — NIP-55 is honest that this means a +// popup per signature, which is why it is a login door, not the default. +export const amberAvailable = () => typeof navigator !== 'undefined' && /Android/i.test(navigator.userAgent || ''); +let amberReq = null; // { type, ts, resolve, reject, timer } +let amberWatch = null; +const amberListeners = new Set(); +export const onAmberChange = (fn) => { amberListeners.add(fn); return () => amberListeners.delete(fn); }; +const amberChanged = () => { for (const fn of amberListeners) { try { fn(); } catch {} } }; +export const amberPending = () => (amberReq ? { type: amberReq.type, since: amberReq.ts } : null); +const HEX64 = /^[0-9a-f]{64}$/i; +// What an answer of this type looks like — anything else on the clipboard +// is somebody's grocery list, not a signature. +function amberParse(type, text, payload) { + const v = String(text || '').trim(); + if (!v || v === payload) return null; + if (type === 'get_public_key') { + if (HEX64.test(v)) return v.toLowerCase(); + if (/^npub1[023456789acdefghjklmnpqrstuvwxyz]+$/.test(v)) { try { const d = nip19decode(v); if (d.type === 'npub') return d.data; } catch {} } + try { const j = JSON.parse(v); if (j && HEX64.test(j.pubkey || '')) return j.pubkey.toLowerCase(); } catch {} + return null; + } + if (type === 'sign_event') { + try { const ev = JSON.parse(v); return ev && ev.sig && ev.id && HEX64.test(ev.pubkey || '') ? ev : null; } catch { return null; } + } + // the clipboard still holds the LAST answer (an npub, say) when the next + // request goes out: an answer must look like its own kind, and never + // repeat the one before + if (v === amberLastAnswer) return null; + if (type === 'nip44_encrypt') return /^Ag[A-Za-z0-9+/]{100,}={0,2}$/.test(v) ? v : null; // version byte 2, nonce, body, mac + if (type === 'nip04_encrypt') return /^[A-Za-z0-9+/=]+\?iv=[A-Za-z0-9+/=]+$/.test(v) ? v : null; + if (/^npub1[023456789acdefghjklmnpqrstuvwxyz]+$/.test(v) || HEX64.test(v)) return null; // a key is never a plaintext + return v; // a decrypt: the caller knows what it expects and will say if this isn't it +} +let amberLastAnswer = null; +// Resolve the waiting request with an answer, however it arrived. +export function amberDeliver(text) { + if (!amberReq) return false; + const got = amberParse(amberReq.type, text, amberReq.payload); + if (got == null) return false; + amberLastAnswer = String(text || '').trim(); + const r = amberReq; + amberStop(); + r.resolve(got); + return true; +} +export function amberCancel(reason = 'signer request cancelled') { + if (!amberReq) return; + const r = amberReq; + amberStop(); + r.reject(new Error(reason)); +} +function amberStop() { + if (amberReq) clearTimeout(amberReq.timer); + amberReq = null; + if (amberWatch) { amberWatch(); amberWatch = null; } + amberChanged(); +} +// Read the clipboard whenever the tab comes back to the front, and every +// so often while it is — Amber copies its answer just before the user +// switches back here. +function amberWatchClipboard() { + const read = async () => { + if (!amberReq || typeof navigator === 'undefined' || !navigator.clipboard) return; + try { // a hidden or unfocused page is simply refused by the browser + const txt = await navigator.clipboard.readText(); + if (amberReq && amberDeliver(txt)) return; + } catch {} // no permission: the paste box is the way in + }; + const onVis = () => { if (document.visibilityState === 'visible') setTimeout(read, 250); }; + document.addEventListener('visibilitychange', onVis); + window.addEventListener('focus', onVis); + const iv = setInterval(read, 800); + setTimeout(read, 300); + return () => { document.removeEventListener('visibilitychange', onVis); window.removeEventListener('focus', onVis); clearInterval(iv); }; +} +function amberLaunch(url) { + if (typeof window !== 'undefined' && typeof window.__coinosAmberLaunch === 'function') { window.__coinosAmberLaunch(url); return; } // tests + window.location.href = url; +} +// One trip at a time: the app fires several signatures at once right after a +// sign-in (the backup, the relay list, the follows), and Amber can only be +// asked for one; the rest wait their turn in this chain. +let amberQueue = Promise.resolve(); +function amberRequest(type, payload, params = {}, { timeoutMs = 180_000 } = {}) { + const q = new URLSearchParams({ type, compressionType: 'none', returnType: 'event' }); + if (params.pubkey) q.set('pubkey', params.pubkey); + const url = 'nostrsigner:' + encodeURIComponent(payload || '') + '?' + q.toString(); + const run = () => new Promise((resolve, reject) => { + amberReq = { type, payload: payload || '', ts: Date.now(), resolve, reject, + timer: setTimeout(() => amberCancel('signer did not answer'), timeoutMs) }; + amberWatch = amberWatchClipboard(); + amberChanged(); + amberLaunch(url); + }); + const p = amberQueue.then(run, run); + amberQueue = p.catch(() => {}); + return p; +} +export async function amberSigner({ pubkey = null } = {}) { + if (!pubkey) pubkey = await amberRequest('get_public_key', ''); + return amberAdapter(pubkey); +} +function amberAdapter(pubkey) { + return { + kind: 'amber', pubkey, label: 'Amber', interactive: true, // every call is a trip through the app: nothing in the background may use it + session: { amber: pubkey }, // the pubkey is all a later boot needs; no round trip to come back + signEvent: async (e) => { + const ev = await amberRequest('sign_event', JSON.stringify({ ...e, pubkey }), { pubkey }); + if (ev.pubkey !== pubkey) throw new Error('the signer answered with a different account'); + return ev; + }, + encryptSelf: (txt) => amberRequest('nip44_encrypt', txt, { pubkey }), + decryptSelf: (ct) => amberRequest('nip44_decrypt', ct, { pubkey }), + encryptTo: (peer, txt) => amberRequest('nip44_encrypt', txt, { pubkey: peer }), + decryptFrom: (peer, ct) => amberRequest('nip44_decrypt', ct, { pubkey: peer }), + ping: async () => true, + }; +} + export function keySigner(sk) { const pubkey = getPublicKey(sk); const conv = nip44.getConversationKey(sk, pubkey); -- cgit v1.2.3