gsdf

2026-09-12 10:10:34 +02:00
parent 217f1be72d
commit 53055ea5c6
35 changed files with 2261 additions and 138 deletions
@@ -0,0 +1,776 @@
+/**
+ * f0ckm Anonymous OpenSSH Ed25519 Identity Manager
+ * Provides client-side Ed25519 key generation, OpenSSH key formatting,
+ * signing, and authentication without login.
+ */
+
+(function () {
+  'use strict';
+
+  const PKCS8_HEADER = new Uint8Array([
+    0x30, 0x2e, 0x02, 0x01, 0x00, 0x30, 0x05, 0x06, 0x03, 0x2b, 0x65, 0x70, 0x04, 0x22, 0x04, 0x20
+  ]);
+
+  const STORAGE_KEY_PRIV = 'f0ck_anon_ssh_priv';
+  const STORAGE_KEY_PUB = 'f0ck_anon_ssh_pub';
+  const STORAGE_KEY_FP = 'f0ck_anon_ssh_fp';
+
+  function bytesToBase64(bytes) {
+    let binary = '';
+    const len = bytes.byteLength;
+    for (let i = 0; i < len; i++) {
+      binary += String.fromCharCode(bytes[i]);
+    }
+    return window.btoa(binary);
+  }
+
+  function base64ToBytes(base64) {
+    const binary = window.atob(base64.replace(/\s+/g, ''));
+    const len = binary.length;
+    const bytes = new Uint8Array(len);
+    for (let i = 0; i < len; i++) {
+      bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+  }
+
+  function bytesToHex(bytes) {
+    return Array.from(bytes).map(b => b.toString(16).padStart(2, '0')).join('');
+  }
+
+  function hexToBytes(hex) {
+    const clean = hex.replace(/[^0-9a-fA-F]/g, '');
+    const bytes = new Uint8Array(clean.length / 2);
+    for (let i = 0; i < bytes.length; i++) {
+      bytes[i] = parseInt(clean.substring(i * 2, i * 2 + 2), 16);
+    }
+    return bytes;
+  }
+
+  function writeUInt32BE(buf, value, offset) {
+    buf[offset] = (value >>> 24) & 0xff;
+    buf[offset + 1] = (value >>> 16) & 0xff;
+    buf[offset + 2] = (value >>> 8) & 0xff;
+    buf[offset + 3] = value & 0xff;
+  }
+
+  function readUInt32BE(buf, offset) {
+    return (
+      (buf[offset] << 24) |
+      (buf[offset + 1] << 16) |
+      (buf[offset + 2] << 8) |
+      buf[offset + 3]
+    ) >>> 0;
+  }
+
+  function concatUint8Arrays(arrays) {
+    const totalLen = arrays.reduce((acc, a) => acc + a.length, 0);
+    const result = new Uint8Array(totalLen);
+    let offset = 0;
+    for (const arr of arrays) {
+      result.set(arr, offset);
+      offset += arr.length;
+    }
+    return result;
+  }
+
+  class AnonSSH {
+    constructor() {
+      this.cryptoKey = null;
+      this.pubkey = null;
+      this.fingerprint = null;
+      this.shortFingerprint = null;
+      this.rawPub = null;
+      this.rawSeed = null;
+      this.isSessionReady = false;
+    }
+
+    getDomain() {
+      return window.f0ckDomain || window.location.hostname || 'f0ck.dev';
+    }
+
+    /**
+     * Encode raw 32-byte Ed25519 public key into OpenSSH wire format
+     */
+    encodeOpenSSHPublicKey(rawPub, comment) {
+      const comm = comment || `anonymous@${this.getDomain()}`;
+      const keyType = new TextEncoder().encode('ssh-ed25519');
+
+      const wirePub = new Uint8Array(4 + keyType.length + 4 + rawPub.length);
+      writeUInt32BE(wirePub, keyType.length, 0);
+      wirePub.set(keyType, 4);
+      writeUInt32BE(wirePub, rawPub.length, 4 + keyType.length);
+      wirePub.set(rawPub, 4 + keyType.length + 4);
+
+      const b64 = bytesToBase64(wirePub);
+      return `ssh-ed25519 ${b64} ${comm}`;
+    }
+
+    /**
+     * Compute standard OpenSSH SHA256 fingerprint from raw public key
+     */
+    async computeFingerprint(rawPub) {
+      const keyType = new TextEncoder().encode('ssh-ed25519');
+      const wirePub = new Uint8Array(4 + keyType.length + 4 + rawPub.length);
+      writeUInt32BE(wirePub, keyType.length, 0);
+      wirePub.set(keyType, 4);
+      writeUInt32BE(wirePub, rawPub.length, 4 + keyType.length);
+      wirePub.set(rawPub, 4 + keyType.length + 4);
+
+      const hashBuffer = await window.crypto.subtle.digest('SHA-256', wirePub);
+      const hashBytes = new Uint8Array(hashBuffer);
+      const b64 = bytesToBase64(hashBytes).replace(/=+$/, '');
+      return `SHA256:${b64}`;
+    }
+
+    /**
+     * Encode raw seed + pubkey into a valid OpenSSH private key PEM file
+     */
+    encodeOpenSSHPrivateKey(rawSeed, rawPub, comment) {
+      const comm = new TextEncoder().encode(comment || `anonymous@${this.getDomain()}`);
+      const keyType = new TextEncoder().encode('ssh-ed25519');
+      const none = new TextEncoder().encode('none');
+      const magic = new TextEncoder().encode('openssh-key-v1\0');
+
+      // 64-byte private key is seed + pubkey
+      const privKeyRaw = concatUint8Arrays([rawSeed, rawPub]);
+
+      // Random 32-bit checkInt
+      const checkArray = new Uint8Array(4);
+      window.crypto.getRandomValues(checkArray);
+      const checkInt = readUInt32BE(checkArray, 0);
+
+      // Construct private key block parts
+      const parts = [
+        new Uint8Array(8), // check1 + check2
+        new Uint8Array(4), keyType,
+        new Uint8Array(4), rawPub,
+        new Uint8Array(4), privKeyRaw,
+        new Uint8Array(4), comm
+      ];
+      writeUInt32BE(parts[0], checkInt, 0);
+      writeUInt32BE(parts[0], checkInt, 4);
+      writeUInt32BE(parts[1], keyType.length, 0);
+      writeUInt32BE(parts[3], rawPub.length, 0);
+      writeUInt32BE(parts[5], privKeyRaw.length, 0);
+      writeUInt32BE(parts[7], comm.length, 0);
+
+      let privBlock = concatUint8Arrays(parts);
+
+      // Pad to 8-byte boundary
+      const padLen = (8 - (privBlock.length % 8)) % 8;
+      if (padLen > 0) {
+        const padding = new Uint8Array(padLen);
+        for (let i = 0; i < padLen; i++) padding[i] = i + 1;
+        privBlock = concatUint8Arrays([privBlock, padding]);
+      }
+
+      // Public key wire block
+      const wirePub = new Uint8Array(4 + keyType.length + 4 + rawPub.length);
+      writeUInt32BE(wirePub, keyType.length, 0);
+      wirePub.set(keyType, 4);
+      writeUInt32BE(wirePub, rawPub.length, 4 + keyType.length);
+      wirePub.set(rawPub, 4 + keyType.length + 4);
+
+      // Header block
+      const headerParts = [
+        magic,
+        new Uint8Array(4), none,
+        new Uint8Array(4), none,
+        new Uint8Array(4), // empty kdf options
+        new Uint8Array(4), // num keys = 1
+        new Uint8Array(4), wirePub,
+        new Uint8Array(4), privBlock
+      ];
+      writeUInt32BE(headerParts[1], none.length, 0);
+      writeUInt32BE(headerParts[3], none.length, 0);
+      writeUInt32BE(headerParts[5], 0, 0);
+      writeUInt32BE(headerParts[6], 1, 0);
+      writeUInt32BE(headerParts[7], wirePub.length, 0);
+      writeUInt32BE(headerParts[9], privBlock.length, 0);
+
+      const bodyBytes = concatUint8Arrays(headerParts);
+      const b64 = bytesToBase64(bodyBytes);
+      const lines = b64.match(/.{1,70}/g) || [b64];
+
+      return `-----BEGIN OPENSSH PRIVATE KEY-----\n${lines.join('\n')}\n-----END OPENSSH PRIVATE KEY-----\n`;
+    }
+
+    /**
+     * Decode OpenSSH private key PEM or raw seed string into 32-byte seed
+     */
+    extractSeedFromInput(input) {
+      if (!input || typeof input !== 'string') {
+        throw new Error('Key input is required');
+      }
+      const trimmed = input.trim();
+
+      // Check if OpenSSH PEM format
+      if (trimmed.includes('-----BEGIN OPENSSH PRIVATE KEY-----')) {
+        const cleanB64 = trimmed
+          .replace(/-----[^\n]+-----/g, '')
+          .replace(/\s+/g, '');
+        const buf = base64ToBytes(cleanB64);
+
+        // Find "ssh-ed25519" strings in wire format
+        const needle = new TextEncoder().encode('ssh-ed25519');
+        let firstIdx = -1;
+        for (let i = 0; i <= buf.length - needle.length; i++) {
+          let match = true;
+          for (let j = 0; j < needle.length; j++) {
+            if (buf[i + j] !== needle[j]) { match = false; break; }
+          }
+          if (match) { firstIdx = i; break; }
+        }
+        if (firstIdx === -1) throw new Error('Not an Ed25519 OpenSSH private key');
+
+        // Second occurrence is in private block
+        let secondIdx = -1;
+        for (let i = firstIdx + needle.length; i <= buf.length - needle.length; i++) {
+          let match = true;
+          for (let j = 0; j < needle.length; j++) {
+            if (buf[i + j] !== needle[j]) { match = false; break; }
+          }
+          if (match) { secondIdx = i; break; }
+        }
+        if (secondIdx === -1) throw new Error('Could not parse OpenSSH private key block');
+
+        const offset = secondIdx + needle.length;
+        const pubLen = readUInt32BE(buf, offset);
+        const pubOffset = offset + 4;
+        const privLenOffset = pubOffset + pubLen;
+        const privLen = readUInt32BE(buf, privLenOffset);
+        const privOffset = privLenOffset + 4;
+
+        if (privLen < 32 || privOffset + 32 > buf.length) {
+          throw new Error('Malformed OpenSSH private key length');
+        }
+
+        return buf.slice(privOffset, privOffset + 32);
+      }
+
+      // Check if 64-char hex string (32 bytes)
+      if (/^[0-9a-fA-F]{64}$/.test(trimmed)) {
+        return hexToBytes(trimmed);
+      }
+
+      // Check if 44-char base64 string (32 bytes)
+      try {
+        const bytes = base64ToBytes(trimmed);
+        if (bytes.length === 32) return bytes;
+        if (bytes.length === 64) return bytes.slice(0, 32);
+      } catch (_) {}
+
+      throw new Error('Unrecognized key format. Paste an OpenSSH private key (id_ed25519) or 32-byte hex/base64 seed.');
+    }
+
+    /**
+     * Import raw 32-byte seed into Web Crypto SubtleCrypto
+     */
+    async importSeed(seedBytes) {
+      if (seedBytes.length !== 32) throw new Error('Seed must be exactly 32 bytes');
+      const pkcs8 = concatUint8Arrays([PKCS8_HEADER, seedBytes]);
+      const cryptoKey = await window.crypto.subtle.importKey(
+        'pkcs8',
+        pkcs8,
+        { name: 'Ed25519' },
+        true,
+        ['sign']
+      );
+
+      // Derive raw public key
+      // Since WebCrypto doesn't directly export public key from private key in all browsers,
+      // we can also generate or sign/verify or use the derived public key
+      // But in modern Chromium/Firefox/Safari, Web Crypto can export or derive.
+      // If needed, we can extract from OpenSSH PEM if available, or generate a sign verify test
+      let rawPub = null;
+      try {
+        // Many browsers support exporting JWK or SPKI
+        const spkiBuffer = await window.crypto.subtle.exportKey?.('spki', cryptoKey).catch(() => null);
+        if (spkiBuffer) {
+          rawPub = new Uint8Array(spkiBuffer).slice(12);
+        }
+      } catch (_) {}
+
+      return { cryptoKey, rawSeed: seedBytes, rawPub };
+    }
+
+    /**
+     * Generate fresh Ed25519 identity in the browser
+     */
+    async generateIdentity() {
+      const keyPair = await window.crypto.subtle.generateKey(
+        { name: 'Ed25519' },
+        true,
+        ['sign', 'verify']
+      );
+
+      const rawPubBuf = await window.crypto.subtle.exportKey('raw', keyPair.publicKey);
+      const rawPub = new Uint8Array(rawPubBuf);
+
+      const pkcs8Buf = await window.crypto.subtle.exportKey('pkcs8', keyPair.privateKey);
+      const pkcs8 = new Uint8Array(pkcs8Buf);
+      const rawSeed = pkcs8.slice(16);
+
+      const pubkey = this.encodeOpenSSHPublicKey(rawPub);
+      const fingerprint = await this.computeFingerprint(rawPub);
+
+      this.cryptoKey = keyPair.privateKey;
+      this.rawPub = rawPub;
+      this.rawSeed = rawSeed;
+      this.pubkey = pubkey;
+      this.fingerprint = fingerprint;
+      this.shortFingerprint = fingerprint.slice(7, 15);
+
+      localStorage.setItem(STORAGE_KEY_PRIV, bytesToHex(rawSeed));
+      localStorage.setItem(STORAGE_KEY_PUB, pubkey);
+      localStorage.setItem(STORAGE_KEY_FP, fingerprint);
+
+      return this.getIdentity();
+    }
+
+    /**
+     * Import custom key from user text input
+     */
+    async importKey(input) {
+      const seedBytes = this.extractSeedFromInput(input);
+      const pkcs8 = concatUint8Arrays([PKCS8_HEADER, seedBytes]);
+      const privateKey = await window.crypto.subtle.importKey(
+        'pkcs8',
+        pkcs8,
+        { name: 'Ed25519' },
+        true,
+        ['sign']
+      );
+
+      // In Ed25519, the public key is deterministically derived from the seed
+      // To get the public key in Web Crypto, we sign a test challenge or compute it
+      // Let's create an identity check
+      this.cryptoKey = privateKey;
+      this.rawSeed = seedBytes;
+
+      // Extract rawPub if input was OpenSSH PEM
+      let rawPub = null;
+      if (input.includes('-----BEGIN OPENSSH PRIVATE KEY-----')) {
+        try {
+          const cleanB64 = input.replace(/-----[^\n]+-----/g, '').replace(/\s+/g, '');
+          const buf = base64ToBytes(cleanB64);
+          const needle = new TextEncoder().encode('ssh-ed25519');
+          let idx = -1;
+          for (let i = 0; i <= buf.length - needle.length; i++) {
+            let match = true;
+            for (let j = 0; j < needle.length; j++) {
+              if (buf[i + j] !== needle[j]) { match = false; break; }
+            }
+            if (match) { idx = i; break; }
+          }
+          if (idx !== -1) {
+            const pubLen = readUInt32BE(buf, idx + needle.length);
+            const pubBytes = buf.slice(idx + needle.length + 4, idx + needle.length + 4 + pubLen);
+            if (pubBytes.length === 32) rawPub = pubBytes;
+          }
+        } catch (_) {}
+      }
+
+      if (!rawPub) {
+        // Fallback: generate keypair or re-derive
+        // If browser allows generateKey, generate identity and replace seed
+        rawPub = new Uint8Array(32); // fallback
+      }
+
+      this.rawPub = rawPub;
+      this.pubkey = this.encodeOpenSSHPublicKey(rawPub);
+      this.fingerprint = await this.computeFingerprint(rawPub);
+      this.shortFingerprint = this.fingerprint.slice(7, 15);
+
+      localStorage.setItem(STORAGE_KEY_PRIV, bytesToHex(seedBytes));
+      localStorage.setItem(STORAGE_KEY_PUB, this.pubkey);
+      localStorage.setItem(STORAGE_KEY_FP, this.fingerprint);
+
+      await this.ensureSession(true);
+      return this.getIdentity();
+    }
+
+    getIdentity() {
+      return {
+        pubkey: this.pubkey,
+        fingerprint: this.fingerprint,
+        shortFingerprint: this.shortFingerprint,
+        rawPub: this.rawPub,
+        rawSeed: this.rawSeed
+      };
+    }
+
+    /**
+     * Sign an arbitrary UTF-8 string with the Ed25519 private key
+     */
+    async sign(message) {
+      if (!this.cryptoKey) throw new Error('No active SSH private key');
+      const msgBytes = new TextEncoder().encode(message);
+      const sigBuffer = await window.crypto.subtle.sign(
+        { name: 'Ed25519' },
+        this.cryptoKey,
+        msgBytes
+      );
+      return bytesToBase64(new Uint8Array(sigBuffer));
+    }
+
+    /**
+     * Authenticate to backend and establish/refresh anonymous session
+     */
+    async ensureSession(force = false) {
+      // If user is already logged in as a real registered user, don't overwrite session!
+      if (window.f0ckSession && window.f0ckSession.user && !window.f0ckSession.is_anon) {
+        return;
+      }
+
+      if (this.isSessionReady && !force) return;
+
+      try {
+        const timestamp = Date.now();
+        const message = `anon-auth:${timestamp}:${this.pubkey}`;
+        const signature = await this.sign(message);
+
+        const res = await fetch('/api/v2/anon/session', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            pubkey: this.pubkey,
+            timestamp: timestamp,
+            signature: signature
+          })
+        });
+
+        const data = await res.json();
+        if (data.success) {
+          this.isSessionReady = true;
+          if (data.csrf_token) {
+            if (window.f0ckSession) window.f0ckSession.csrf_token = data.csrf_token;
+            const metaCsrf = document.querySelector('meta[name="csrf-token"]');
+            if (metaCsrf) metaCsrf.content = data.csrf_token;
+          }
+          window.f0ckAnonIdentity = {
+            userId: data.user_id,
+            fingerprint: data.fingerprint,
+            shortFingerprint: data.short_fingerprint
+          };
+          window.dispatchEvent(new CustomEvent('f0ck:anon_session_ready', { detail: window.f0ckAnonIdentity }));
+        }
+      } catch (err) {
+        console.warn('[ANON_SSH] Session handshake failed:', err);
+      }
+    }
+
+    /**
+     * Trigger browser download of id_ed25519 private key file
+     */
+    downloadPrivateKey() {
+      if (!this.rawSeed || !this.rawPub) return;
+      const pem = this.encodeOpenSSHPrivateKey(this.rawSeed, this.rawPub);
+      const blob = new Blob([pem], { type: 'application/octet-stream' });
+      const a = document.createElement('a');
+      a.href = URL.createObjectURL(blob);
+      a.download = 'id_ed25519';
+      document.body.appendChild(a);
+      a.click();
+      document.body.removeChild(a);
+      URL.revokeObjectURL(a.href);
+    }
+
+    /**
+     * Trigger browser download of id_ed25519.pub public key file
+     */
+    downloadPublicKey() {
+      if (!this.pubkey) return;
+      const content = `${this.pubkey}\n`;
+      const blob = new Blob([content], { type: 'text/plain;charset=utf-8' });
+      const a = document.createElement('a');
+      a.href = URL.createObjectURL(blob);
+      a.download = 'id_ed25519.pub';
+      document.body.appendChild(a);
+      a.click();
+      document.body.removeChild(a);
+      URL.revokeObjectURL(a.href);
+    }
+
+    /**
+     * Copy public key string to clipboard
+     */
+    async copyPublicKey() {
+      if (!this.pubkey) return;
+      try {
+        await navigator.clipboard.writeText(this.pubkey);
+        if (typeof window.showToastNotification === 'function') {
+          window.showToastNotification('OpenSSH Public Key copied to clipboard!');
+        } else {
+          alert('Public key copied to clipboard!');
+        }
+      } catch (err) {
+        prompt('Copy your OpenSSH Public Key:', this.pubkey);
+      }
+    }
+
+    /**
+     * Clear stored cryptographic identity from localStorage and memory
+     */
+    clearStoredIdentity() {
+      localStorage.removeItem(STORAGE_KEY_PRIV);
+      localStorage.removeItem(STORAGE_KEY_PUB);
+      localStorage.removeItem(STORAGE_KEY_FP);
+      this.cryptoKey = null;
+      this.rawSeed = null;
+      this.rawPub = null;
+      this.pubkey = null;
+      this.fingerprint = null;
+      this.shortFingerprint = null;
+      this.isSessionReady = false;
+    }
+
+    /**
+     * Explicitly log in as anonymous (generates identity if none, establishes session, syncs guest favs)
+     */
+    async loginAsAnonymous() {
+      if (window.f0ckSession && window.f0ckSession.enable_anonymous_access === false) {
+        return;
+      }
+      try {
+        if (!this.pubkey) {
+          await this.generateIdentity();
+        }
+        await this.ensureSession(true);
+        // Sync any guest favorites saved in localStorage to this anon account
+        if (window.f0ckGuestFavs && typeof window.f0ckGuestFavs.importToAccount === 'function') {
+          await window.f0ckGuestFavs.importToAccount();
+        }
+        this.updateNavUI(true);
+        if (typeof window.showToastNotification === 'function') {
+          window.showToastNotification('Logged in as anonymous');
+        }
+        // Reload page to reflect authenticated anonymous session across navbar, comments, settings
+        window.location.reload();
+      } catch (err) {
+        console.error('[ANON_SSH] Login as anonymous failed:', err);
+        alert('Failed to log in as anonymous: ' + (err.message || err));
+      }
+    }
+
+    /**
+     * Log out of anonymous session, returning to clean guest state
+     */
+    async logoutAnonymous() {
+      try {
+        this.clearStoredIdentity();
+        await fetch('/api/v2/anon/logout', { method: 'POST', credentials: 'same-origin' }).catch(() => {});
+      } finally {
+        window.location.href = '/';
+      }
+    }
+
+    /**
+     * Update visitor navbar UI elements
+     */
+    updateNavUI(isAnon) {
+      const icon = document.getElementById('nav-visitor-icon');
+      const label = document.getElementById('nav-anon-label');
+      if (icon) {
+        if (isAnon) {
+          icon.classList.remove('fa-user');
+          icon.classList.add('fa-user-secret');
+        } else {
+          icon.classList.remove('fa-user-secret');
+          icon.classList.add('fa-user');
+        }
+      }
+      if (label) {
+        label.textContent = isAnon ? 'anonymous' : 'guest';
+      }
+
+      if (window.f0ckSession && window.f0ckSession.enable_anonymous_access === false) {
+        if (label) label.textContent = 'guest';
+        const loginAnonBtn = document.getElementById('nav-login-anon-btn');
+        const modalAnonBtn = document.getElementById('modal-login-as-anon-btn');
+        const anonIdentityBtn = document.getElementById('nav-anon-identity-btn');
+        const anonSettingsBtn = document.getElementById('nav-anon-settings-btn');
+        const anonLogoutBtn = document.getElementById('nav-anon-logout-btn');
+        const anonDivider = document.getElementById('nav-anon-divider');
+
+        if (loginAnonBtn) loginAnonBtn.style.display = 'none';
+        if (modalAnonBtn) {
+          const wrapper = modalAnonBtn.closest('div');
+          if (wrapper) wrapper.style.display = 'none';
+          else modalAnonBtn.style.display = 'none';
+        }
+        if (anonIdentityBtn) anonIdentityBtn.style.display = 'none';
+        if (anonSettingsBtn) anonSettingsBtn.style.display = 'none';
+        if (anonLogoutBtn) anonLogoutBtn.style.display = 'none';
+        if (anonDivider) anonDivider.style.display = 'none';
+        return;
+      }
+
+      const loginAnonBtn = document.getElementById('nav-login-anon-btn');
+      const anonIdentityBtn = document.getElementById('nav-anon-identity-btn');
+      const anonSettingsBtn = document.getElementById('nav-anon-settings-btn');
+      const anonLogoutBtn = document.getElementById('nav-anon-logout-btn');
+      const anonDivider = document.getElementById('nav-anon-divider');
+
+      if (loginAnonBtn) loginAnonBtn.style.display = isAnon ? 'none' : '';
+      if (anonIdentityBtn) anonIdentityBtn.style.display = isAnon ? '' : 'none';
+      if (anonSettingsBtn) anonSettingsBtn.style.display = isAnon ? '' : 'none';
+      if (anonLogoutBtn) anonLogoutBtn.style.display = isAnon ? '' : 'none';
+      if (anonDivider) anonDivider.style.display = isAnon ? '' : 'none';
+
+      const guestFavsNav = document.getElementById('nav-guest-favs');
+      const guestFavsLink = document.getElementById('nav-guest-favs-link');
+      if (guestFavsNav) guestFavsNav.style.display = isAnon ? '' : 'none';
+      if (guestFavsLink) guestFavsLink.style.display = isAnon ? '' : 'none';
+    }
+
+    /**
+     * Initialize on page startup
+     */
+    async init() {
+      if (window.f0ckSession && window.f0ckSession.enable_anonymous_access === false) {
+        if (window.f0ckSession.is_anon) {
+          await fetch('/api/v2/anon/logout', { method: 'POST', credentials: 'same-origin' }).catch(() => {});
+          window.location.reload();
+          return;
+        }
+        this.updateNavUI(false);
+        return;
+      }
+
+      // If registered user, do not override
+      if (window.f0ckSession && window.f0ckSession.user && !window.f0ckSession.is_anon) {
+        return;
+      }
+
+      const storedPriv = localStorage.getItem(STORAGE_KEY_PRIV);
+      const storedPub = localStorage.getItem(STORAGE_KEY_PUB);
+      const storedFp = localStorage.getItem(STORAGE_KEY_FP);
+
+      if (storedPriv && storedPub && storedFp) {
+        try {
+          const rawSeed = hexToBytes(storedPriv);
+          const pkcs8 = concatUint8Arrays([PKCS8_HEADER, rawSeed]);
+          this.cryptoKey = await window.crypto.subtle.importKey(
+            'pkcs8',
+            pkcs8,
+            { name: 'Ed25519' },
+            true,
+            ['sign']
+          );
+          this.rawSeed = rawSeed;
+          this.pubkey = storedPub;
+          this.fingerprint = storedFp;
+          this.shortFingerprint = storedFp.slice(7, 15);
+
+          // Extract rawPub from storedPub wire format
+          const parts = storedPub.trim().split(/\s+/);
+          const wirePub = base64ToBytes(parts[1]);
+          const typeLen = readUInt32BE(wirePub, 0);
+          this.rawPub = wirePub.slice(4 + typeLen + 4, 4 + typeLen + 4 + 32);
+
+          // User previously logged in as anonymous with this key
+          // If backend session is already active, avoid redundant session churn
+          if (window.f0ckSession && window.f0ckSession.is_anon) {
+            this.isSessionReady = true;
+            this.updateNavUI(true);
+          } else {
+            await this.ensureSession();
+            this.updateNavUI(true);
+          }
+        } catch (err) {
+          console.warn('[ANON_SSH] Failed to restore stored key:', err);
+          this.clearStoredIdentity();
+          this.updateNavUI(false);
+        }
+      } else {
+        // Clean guest state! Do NOT auto-generate or establish session!
+        if (window.f0ckSession && window.f0ckSession.is_anon) {
+          // Stale backend anon session cookie without corresponding local key: clear cookie
+          await fetch('/api/v2/anon/logout', { method: 'POST', credentials: 'same-origin' }).catch(() => {});
+          window.location.reload();
+          return;
+        }
+        this.updateNavUI(false);
+      }
+
+      // Hook identity modal triggers and action buttons
+      this.attachUIListeners();
+    }
+
+    attachUIListeners() {
+      // Global click handler for Login as anonymous, Identity modal, & Logout
+      document.addEventListener('click', (e) => {
+        const identityTarget = e.target.closest('#nav-anon-identity-btn');
+        if (identityTarget) {
+          e.preventDefault();
+          this.openModal();
+          return;
+        }
+
+        const loginTarget = e.target.closest('#nav-login-anon-btn, #modal-login-as-anon-btn, .trigger-login-anon');
+        if (loginTarget) {
+          e.preventDefault();
+          this.loginAsAnonymous();
+          return;
+        }
+
+        const logoutTarget = e.target.closest('#nav-anon-logout-btn, a[href="/logout"]');
+        if (logoutTarget && ((window.f0ckSession && window.f0ckSession.is_anon) || this.pubkey)) {
+          e.preventDefault();
+          this.logoutAnonymous();
+          return;
+        }
+      });
+
+      const anonBtn = document.getElementById('nav-anon-identity-btn');
+      if (anonBtn) {
+        anonBtn.addEventListener('click', (e) => {
+          e.preventDefault();
+          this.openModal();
+        });
+      }
+
+      const modalClose = document.getElementById('anon-ssh-modal-close');
+      if (modalClose) {
+        modalClose.addEventListener('click', () => this.closeModal());
+      }
+
+      const modalOverlay = document.getElementById('anon-ssh-modal');
+      if (modalOverlay) {
+        modalOverlay.addEventListener('click', (e) => {
+          if (e.target === modalOverlay) this.closeModal();
+        });
+      }
+    }
+
+    openModal() {
+      const modal = document.getElementById('anon-ssh-modal');
+      if (!modal) return;
+
+      const fp = this.fingerprint || localStorage.getItem(STORAGE_KEY_FP);
+      const pk = this.pubkey || localStorage.getItem(STORAGE_KEY_PUB);
+
+      const fpEl = document.getElementById('anon-ssh-fp-display');
+      const pubEl = document.getElementById('anon-ssh-pub-display');
+      if (fpEl) fpEl.textContent = fp || 'Generating...';
+      if (pubEl) pubEl.textContent = pk || '';
+
+      modal.style.display = 'flex';
+    }
+
+    closeModal() {
+      const modal = document.getElementById('anon-ssh-modal');
+      if (modal) modal.style.display = 'none';
+    }
+  }
+
+  window.f0ckAnonSSH = new AnonSSH();
+
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', () => window.f0ckAnonSSH.init());
+  } else {
+    window.f0ckAnonSSH.init();
+  }
+})();