Repository Public
1// Autorisation par adresse : ce qu'un appelant (clé ou session) peut lire et au nom de quelles adresses il peut agir.2// Recalculé à chaque requête à partir de la base : rien n'est déduit d'un identifiant fourni par l'appelant.3import { isActive, canSendNow, type AddressRow } from "../addresses.js"4import { sql } from "../db.js"5import type { Principal } from "../keys.js"6import type { Mbx } from "../mailjmap.js"7import { bad } from "../util.js"89export type Access = {10 mailbox: Mbx11 /** full : toute la boîte ; restricted : seulement les messages adressés à / envoyés par `addresses` ; none : aucun droit de lecture. */12 read: "full" | "restricted" | "none"13 /** Adresses au nom desquelles l'appelant peut agir dans cette boîte. */14 addresses: AddressRow[]15 canSend: boolean16 owner: boolean17}18export type View = { mailbox: Mbx; restrict: string[] | null }1920const cache = new WeakMap<object, Promise<Map<string, Access>>>()21export function accessMap(p: Principal): Promise<Map<string, Access>> {22 let m = cache.get(p)23 if (!m) { m = load(p); cache.set(p, m) }24 return m25}26async function load(p: Principal): Promise<Map<string, Access>> {27 const out = new Map<string, Access>()28 if (p.type === "key") {29 const addrs = (p.allAddresses ? await sql`select * from addresses` : p.addressIds.length ? await sql`select * from addresses where id = any(${p.addressIds}::uuid[])` : []) as unknown as AddressRow[]30 if (!addrs.length) return out31 const boxes = (await sql`select id, user_id, address, display_name, stalwart_id, secret_enc from mailboxes where id = any(${[...new Set(addrs.map((a) => a.mailbox_id))]}::uuid[])`) as unknown as Mbx[]32 for (const mb of boxes) {33 const mine = addrs.filter((a) => a.mailbox_id === mb.id)34 const primary = mine.find((a) => a.address === mb.address)35 out.set(mb.id, { mailbox: mb, read: primary && isActive(primary) ? "full" : "restricted", addresses: mine, canSend: true, owner: false })36 }37 return out38 }39 const boxes = (await sql`select m.id, m.user_id, m.address, m.display_name, m.stalwart_id, m.secret_enc, g.can_read, g.can_send40 from mailboxes m left join mailbox_grants g on g.mailbox_id = m.id and g.user_id = ${p.userId}41 where m.user_id = ${p.userId} or g.user_id is not null order by m.position, m.created_at`) as unknown as (Mbx & { can_read: boolean | null; can_send: boolean | null })[]42 if (!boxes.length) return out43 const addrs = (await sql`select * from addresses where mailbox_id = any(${boxes.map((b) => b.id)}::uuid[])`) as unknown as AddressRow[]44 for (const mb of boxes) {45 const owner = mb.user_id === p.userId46 out.set(mb.id, { mailbox: mb, read: owner || mb.can_read ? "full" : "none", addresses: addrs.filter((a) => a.mailbox_id === mb.id), canSend: owner || !!mb.can_send, owner })47 }48 return out49}5051/** Adresses utilisables par l'appelant (toutes boîtes confondues). */52export async function allowedAddresses(p: Principal): Promise<{ address: AddressRow; access: Access }[]> {53 const out: { address: AddressRow; access: Access }[] = []54 for (const acc of (await accessMap(p)).values()) for (const a of acc.addresses) out.push({ address: a, access: acc })55 return out56}57export async function findAllowed(p: Principal, emailOrId: string): Promise<{ address: AddressRow; access: Access } | null> {58 const v = emailOrId.toLowerCase()59 return (await allowedAddresses(p)).find((x) => x.address.address === v || x.address.id === v) ?? null60}6162/** Adresse d'expédition : dans la liste de l'appelant, active, autorisée à envoyer. Sinon 403 (jamais d'usurpation de From). */63export async function sendAddress(p: Principal, email: string): Promise<{ address: AddressRow; access: Access }> {64 const hit = await findAllowed(p, email)65 if (!hit || !hit.access.canSend) throw bad("from_not_allowed", 403, "This caller is not allowed to send from that address")66 if (!isActive(hit.address)) throw bad("address_inactive", 403, "The sender address is suspended or expired")67 if (!canSendNow(hit.address)) throw bad("address_cannot_send", 403, "The sender address is not allowed to send (receive-only)")68 return hit69}7071/** Vues de lecture : toutes celles de l'appelant, ou seulement celles des adresses demandées (chacune revérifiée). */72export async function readViews(p: Principal, only?: string[]): Promise<View[]> {73 const map = await accessMap(p)74 const views = new Map<string, View>()75 if (!only?.length) {76 for (const acc of map.values()) {77 if (acc.read === "full") views.set(acc.mailbox.id, { mailbox: acc.mailbox, restrict: null })78 else if (acc.read === "restricted") {79 const list = acc.addresses.filter(isActive).map((a) => a.address)80 if (list.length) views.set(acc.mailbox.id, { mailbox: acc.mailbox, restrict: list })81 }82 }83 return [...views.values()]84 }85 for (const raw of only) {86 const hit = await findAllowed(p, raw)87 if (!hit || hit.access.read === "none") throw bad("address_not_allowed", 403, "This caller is not allowed to read that address")88 if (p.type === "key" && !isActive(hit.address)) throw bad("address_inactive", 403, "That address is suspended or expired")89 const mb = hit.access.mailbox90 const primary = hit.address.address === mb.address91 const cur = views.get(mb.id)92 if (primary) {93 if (hit.access.read !== "full") throw bad("address_not_allowed", 403, "This caller is not allowed to read that address")94 views.set(mb.id, { mailbox: mb, restrict: null })95 } else if (!cur) views.set(mb.id, { mailbox: mb, restrict: [hit.address.address] })96 else if (cur.restrict && !cur.restrict.includes(hit.address.address)) cur.restrict.push(hit.address.address)97 }98 return [...views.values()]99}100101/** Vue d'une boîte désignée par un identifiant opaque : absente ou interdite → indiscernables (404). */102export async function viewOfMailbox(p: Principal, mailboxId: string): Promise<View> {103 const v = (await readViews(p)).find((x) => x.mailbox.id === mailboxId)104 if (!v) throw bad("not_found", 404, "Not found")105 return v106}107export async function fullViewOfMailbox(p: Principal, mailboxId: string): Promise<View> {108 const v = await viewOfMailbox(p, mailboxId)109 if (v.restrict) throw bad("mailbox_scope_required", 403, "This operation needs access to the whole mailbox (its primary address must be in the key's allowlist)")110 return v111}112113type Addr = { email?: string | null }114export type EmailLike = Record<string, any>115export const deliveredTo = (e: EmailLike): string[] => ((e["header:Delivered-To:asText:all"] ?? []) as (string | null)[]).map((x) => String(x ?? "").trim().replace(/^<|>$/g, "").toLowerCase()).filter(Boolean)116/**117 * Un message appartient à une vue restreinte s'il a été remis à (en-tête Delivered-To, posé par le serveur) ou adressé à (To/Cc/Bcc)118 * ou envoyé par (From) l'une des adresses permises.119 */120export function matchesView(view: View, e: EmailLike): boolean {121 if (!view.restrict) return true122 const set = new Set(view.restrict)123 if (deliveredTo(e).some((a) => set.has(a))) return true124 for (const list of [e.from, e.to, e.cc, e.bcc] as (Addr[] | null | undefined)[]) for (const a of list ?? []) if (a.email && set.has(a.email.toLowerCase())) return true125 return false126}127