Files
dragonroll/backend/src/services/service-links.js
2026-10-14 14:07:52 +00:00

255 lines
8.9 KiB
JavaScript

const crypto = require('node:crypto');
const jwt = require('jsonwebtoken');
const ServiceLinkRequest = require('../models/ServiceLinkRequest');
const Campaign = require('../models/Campaign');
const keys = require('./keys');
// How long a sign-up link waits for somebody to open it.
const LINK_TTL_MS = 10 * 60 * 1000;
// How long the Discord bot can still confirm an authorization it was away for.
const NOTIFICATION_WINDOW_MS = 15 * 60 * 1000;
// The token the Obsidian plugin gets back is its long-lived credential: a plugin cannot ask
// somebody to open the sign-up link again every 48 hours. It carries the id of the link so that
// revoking the link works right away — see services/passport.js.
const OBSIDIAN_TOKEN_TTL = '365d';
// Every service that connects to a campaign does it the same way: it asks the
// backend for a sign-up link, shows it to the person sitting in front of it,
// and picks its credential up once a Dragonroll user has signed in through that
// link and chosen a campaign. `botOnly` services are the ones that can prove
// who they are to the backend; the others can only be trusted with their own
// link, which is why what they get from a link is decided by the user.
const SERVICES = {
foundry: { name: 'Foundry VTT' },
discord: { name: 'Discord', botOnly: true },
obsidian: { name: 'Obsidian' },
};
function isService(value) {
return Object.prototype.hasOwnProperty.call(SERVICES, value);
}
function serviceName(service) {
return SERVICES[service]?.name || service;
}
function isBotOnly(service) {
return SERVICES[service]?.botOnly === true;
}
function codeHash(code) {
return crypto.createHash('sha256').update(String(code ?? '').trim()).digest('hex');
}
function newLinkCode() {
return crypto.randomBytes(32).toString('base64url');
}
function frontendBaseUrl() {
return (process.env.DRAGONROLL_FRONTEND_URL || 'http://localhost:3000').trim().replace(/\/+$/, '');
}
// The sign-up link a service shows: it opens the Dragonroll page where somebody
// signs in and picks the campaign. The code travels in the fragment, so the
// browser never sends it to the server.
function signUpLinkUrl(service, code) {
return `${frontendBaseUrl()}/link/authorize?service=${encodeURIComponent(service)}#code=${encodeURIComponent(code)}`;
}
// The bot talks to the backend with a shared secret instead of a login, so a
// Discord server cannot be claimed by somebody who merely knows its id.
function isDiscordBot(req) {
const configuredSecret = process.env.DRAGONROLL_DISCORD_BOT_SECRET?.trim() || '';
const suppliedSecret = req.get('x-dragonroll-discord-bot-secret') || '';
const expected = Buffer.from(configuredSecret);
const supplied = Buffer.from(suppliedSecret);
return !!expected.length
&& expected.length === supplied.length
&& crypto.timingSafeEqual(expected, supplied);
}
function requireDiscordBot(req, res, next) {
if (!isDiscordBot(req)) {
return res.status(401).json({ status: 'error', msg: 'errors.unauthorized' });
}
return next();
}
function readText(value, max) {
return typeof value === 'string' ? value.trim().slice(0, max) : '';
}
// Whatever else a service says about itself: the Foundry system it runs, the
// Discord user id behind the person who asked... Values are kept short and
// plain, because they come from a service and end up shown to a user.
function readMeta(source) {
const meta = {};
for (const [key, value] of Object.entries(source).slice(0, MAX_META_ENTRIES)) {
if (value === null || value === undefined || typeof value === 'boolean') {
if (typeof value === 'boolean') meta[key] = value;
continue;
}
if (typeof value !== 'string' && typeof value !== 'number') continue;
meta[key] = String(value).trim().slice(0, MAX_META_VALUE_LENGTH);
}
return meta;
}
// How a service describes itself: which world/server/vault is asking, on whose
// behalf, and the little that goes with it.
function readTarget(body) {
const source = body?.target && typeof body.target === 'object' ? body.target : {};
const target = {
targetId: readText(source.id, 120),
targetName: readText(source.name, 200),
targetUser: readText(source.user, 120),
targetMeta: source.meta && typeof source.meta === 'object' && !Array.isArray(source.meta)
? readMeta(source.meta)
: {}
};
if (typeof target.targetMeta.url === 'string') {
try {
const url = new URL(target.targetMeta.url);
target.targetMeta.url = url.protocol === 'http:' || url.protocol === 'https:' ? url.origin : '';
} catch {
target.targetMeta.url = '';
}
}
return target;
}
function linkIsExpired(request) {
return request?.state === 'pending' && (!request.expiresAt || request.expiresAt <= new Date());
}
// A service asking again reuses its own row: one world, one Discord server and
// one vault each have a single link, and asking for it replaces the last one.
async function startServiceLink(service, target) {
const code = newLinkCode();
const expiresAt = new Date(Date.now() + LINK_TTL_MS);
const request = await ServiceLinkRequest.findOneAndUpdate(
{ service: service, targetId: target.targetId },
{
$set: {
service: service,
targetId: target.targetId,
targetName: target.targetName,
targetUser: target.targetUser,
targetMeta: target.targetMeta,
codeHash: codeHash(code),
state: 'pending',
expiresAt: expiresAt
},
$unset: {
campaign: 1,
dragonrollUser: 1,
credentials: 1,
linkedAt: 1,
pickedUpAt: 1,
notifiedAt: 1
}
},
{ new: true, upsert: true, setDefaultsOnInsert: true }
);
return { request, code, url: signUpLinkUrl(service, code), expiresAt };
}
async function findServiceLinkByCode(code) {
if (!code) return null;
return ServiceLinkRequest.findOne({ codeHash: codeHash(code) }).select('+credentials').lean();
}
// The credential that belongs to a link is handed over once and then dropped:
// whoever loses it starts the link again from the service, which is where they
// got the link from in the first place.
async function takeServiceLinkCredentials(request) {
const credentials = request?.credentials || null;
if (!credentials) return null;
await ServiceLinkRequest.updateOne(
{ _id: request._id },
{ $set: { pickedUpAt: new Date() }, $unset: { credentials: 1 } }
);
return credentials;
}
// The user who owns the campaign picked it for this link.
async function completeServiceLink(request, campaign, user, credentials = null) {
request.campaign = campaign._id;
request.dragonrollUser = user.id;
request.state = 'linked';
request.linkedAt = new Date();
request.pickedUpAt = null;
request.notifiedAt = null;
request.credentials = credentials || undefined;
// An answered link is the record of a live connection: it stays until the
// service re-links or the campaign unlinks it.
request.expiresAt = null;
await request.save();
return request;
}
// A campaign dropping a service: the link stops being valid, and the service
// finds that out the next time it asks.
async function revokeServiceLink(service, campaignId) {
const result = await ServiceLinkRequest.updateMany(
{ service: service, campaign: campaignId, state: 'linked' },
{
$set: { state: 'revoked', campaign: null },
$unset: { credentials: 1, linkedAt: 1 }
}
);
return result.matchedCount;
}
// What a campaign has connected to it, newest link first and one row per
// service, so the campaign settings can list its services together.
async function listLinkedServices(campaignId) {
const links = await ServiceLinkRequest.find({ campaign: campaignId, state: 'linked' })
.sort({ linkedAt: -1 })
.lean();
const seen = new Set();
const services = [];
for (const link of links) {
if (seen.has(link.service)) continue;
seen.add(link.service);
services.push({
service: link.service,
name: serviceName(link.service),
targetId: link.targetId || '',
targetName: link.targetName || '',
targetUser: link.targetUser || '',
dragonrollUser: link.dragonrollUser || null,
linkedAt: link.linkedAt
});
}
return services;
}
module.exports = {
LINK_TTL_MS,
NOTIFICATION_WINDOW_MS,
SERVICES,
codeHash,
completeServiceLink,
findServiceLinkByCode,
isBotOnly,
isDiscordBot,
isService,
linkIsExpired,
listLinkedServices,
readTarget,
requireDiscordBot,
revokeServiceLink,
serviceName,
signUpLinkUrl,
startServiceLink,
takeServiceLinkCredentials
};