mirror of
https://github.com/burrow-dev/burrow-server.git
synced 2026-11-18 17:27:50 -05:00
- the client (1.3.0) sends one-way hashes of the device's ids at sign-in; the server keys them again with a secret of its own (data/device-key) and keeps them per account (lib/devices.js). a sign-in without them is refused with 426 (AJ_REQUIRE_DEVICE=0 lets it in), so 1.2 clients cannot sign in. - hardware bans: every device an account used in the last 90 days. any id but a network card blocks sign-in, sign-up and the game, on any account. a network card match, ids that look altered, or a device shared with a banned player raise hardware alerts instead. - both panels: hardware ban and lift, the account's hardware ids, search by hardware id, other accounts by device or address, a timeline (bans, staff actions, reports, alerts), and hardware bans and alerts in the bans tab. - jam-a-grams and wall posts go into the chat log, the filtered ones marked not sent. chat search filters by kind, by what the filter stopped, and from a time back; each player's page lists their jam-a-grams and wall posts, sent and received. - account search runs on the server and ranks exact names first, then names starting with the search; the admin panel no longer downloads every account. hidden tabs only refresh the waiting counts in the title. masterpieces can be searched by maker, approved ones too. reports can show the reported player's chat at the time. links follow the open tab and player. - admin actions on accounts go into the moderator log. - privacy policy covers hardware hashes and the new logs.
260 lines
12 KiB
JavaScript
260 lines
12 KiB
JavaScript
"use strict";
|
|
|
|
const accounts = require("./accounts.js");
|
|
const bans = require("./bans.js");
|
|
const captcha = require("./captcha.js");
|
|
const defpacks = require("./defpacks.js");
|
|
const devices = require("./devices.js");
|
|
const config = require("../config.js");
|
|
const dens = require("./dens.js");
|
|
const limits = require("./limits.js");
|
|
const world = require("./world.js");
|
|
const {addClothing, sendClothingAdded, isUint} = require("./player.js");
|
|
|
|
// backs the item finder page (/shop): look any item up by id or name and put
|
|
// it straight into an account, since in-game shops only stock a slice each.
|
|
|
|
const MAX_RESULTS = 60;
|
|
const givesPerMinute = limits.limiter(120, 60000); // per account, from anywhere but this machine
|
|
const MAX_FAVOURITES = 200; // finder items remembered per account
|
|
// the nine animals the official sign-up page offers (public/register.html
|
|
// has their pictures): tiger, wolf, koala, panda, monkey, bunny, rhino, seal, penguin.
|
|
const STARTER_ANIMALS = [1, 4, 5, 6, 7, 8, 13, 18, 24];
|
|
|
|
let catalog = null;
|
|
|
|
const buildCatalog = () => [
|
|
...defpacks.clothingIds().map(id => {
|
|
const def = defpacks.itemDef(id);
|
|
return {kind: "clothing", id, name: defpacks.string(def.titleStrId), cost: Number(def.value), colors: String(def.colors).split(",").length};
|
|
}),
|
|
...defpacks.denItemIds().map(id => {
|
|
const def = defpacks.denItemDef(id);
|
|
return {kind: "den", id, name: defpacks.string(def.nameStrId) || def.abbrName, cost: Number(def.cost), colors: 1};
|
|
}),
|
|
].map(entry => ({...entry, search: entry.name.toLowerCase()}));
|
|
|
|
// `favourites` is an account's finderGiven, or null: with nothing typed, the
|
|
// items that account took most often come first, the latest first among
|
|
// equals. (The in-game finder says whose search it is.)
|
|
const search = (params, favourites = null) => {
|
|
catalog = catalog || buildCatalog();
|
|
const kind = params.get("kind") || "all";
|
|
const words = (params.get("q") || "").toLowerCase().split(/\s+/).filter(Boolean);
|
|
const matches = catalog.filter(entry => (kind === "all" || entry.kind === kind)
|
|
&& words.every(word => entry.search.includes(word) || String(entry.id) === word));
|
|
matches.sort((a, b) => words.includes(String(b.id)) - words.includes(String(a.id)));
|
|
if (words.length === 0 && favourites) {
|
|
const taken = entry => favourites[`${entry.kind}:${entry.id}`] || {count: 0, at: 0};
|
|
matches.sort((a, b) => taken(b).count - taken(a).count || taken(b).at - taken(a).at);
|
|
}
|
|
return {
|
|
total: matches.length,
|
|
results: matches.slice(0, MAX_RESULTS).map(({kind: entryKind, id, name, cost, colors}) => ({kind: entryKind, id, name, cost, colors})),
|
|
};
|
|
};
|
|
|
|
// one to four "#RRGGBB", spaces or commas between. the # is wanted: six
|
|
// digits alone are a colour id
|
|
const HEX_COLOURS = /^#[0-9a-f]{6}([\s,]+#[0-9a-f]{6}){0,3}$/i;
|
|
|
|
const give = body => {
|
|
const account = accounts.byName(body.username);
|
|
if (!account) {
|
|
return {status: 404, body: {error: "No such account"}};
|
|
}
|
|
const session = world.findOnline(account.username);
|
|
if (body.kind === "clothing") {
|
|
const def = defpacks.itemDef(body.id);
|
|
const colors = def ? String(def.colors).split(",") : [];
|
|
// `color` is a raw colour id of the caller's choosing, or one to four hex
|
|
// colours ("#FF8800", "#FF0000 #FFFFFF") for the item's four colour bands
|
|
// in order, the last filling the rest: a custom colour (lib/colours.js),
|
|
// made as the animal editor's hex box makes one. otherwise one of the
|
|
// item's own colours is picked by `colorIndex`.
|
|
let custom = body.color !== undefined && body.color !== "" ? String(body.color).trim() : "";
|
|
const hexes = custom.match(HEX_COLOURS) ? custom.split(/[\s,]+/).filter(Boolean) : null;
|
|
if (hexes) {
|
|
const rgbs = [0, 1, 2, 3].map(slot => parseInt(hexes[Math.min(slot, hexes.length - 1)].replace("#", ""), 16));
|
|
const entry = world.makeColour(account, rgbs, session);
|
|
if (!entry) {
|
|
return {status: 400, body: {error: "Bad colour"}};
|
|
}
|
|
if (entry.full) {
|
|
return {status: 429, body: {error: "No more new colours today. Colours made before can still be used."}};
|
|
}
|
|
custom = String(entry.id);
|
|
}
|
|
if (custom && !isUint(custom)) {
|
|
return {status: 400, body: {error: "Colour: an id, or #RRGGBB"}};
|
|
}
|
|
const color = custom || colors[Number(body.colorIndex) || 0];
|
|
if (!def || !defpacks.clothingIds().includes(Number(def.id)) || color === undefined) {
|
|
return {status: 400, body: {error: "No such clothing item or colour"}};
|
|
}
|
|
const item = addClothing(account, def.id, color);
|
|
if (!item) {
|
|
return {status: 409, body: {error: "That inventory is full"}};
|
|
}
|
|
accounts.save(account);
|
|
if (session) {
|
|
sendClothingAdded(session, item);
|
|
}
|
|
}
|
|
else if (body.kind === "den") {
|
|
if (!defpacks.denItemIds().includes(Number(body.id))) {
|
|
return {status: 400, body: {error: "No such den item"}};
|
|
}
|
|
if (!dens.giveDenItem(account, body.id)) {
|
|
return {status: 409, body: {error: "That inventory is full"}};
|
|
}
|
|
if (session) {
|
|
dens.sendDenItems(session);
|
|
}
|
|
}
|
|
else {
|
|
return {status: 400, body: {error: "Unknown item kind"}};
|
|
}
|
|
// what this account takes from the finder, for its favourites.
|
|
const key = `${body.kind}:${Number(body.id)}`;
|
|
account.finderGiven[key] = {count: ((account.finderGiven[key] || {}).count || 0) + 1, at: Math.floor(Date.now() / 1000)};
|
|
const kept = Object.entries(account.finderGiven).sort((one, other) => other[1].at - one[1].at).slice(0, MAX_FAVOURITES);
|
|
account.finderGiven = Object.fromEntries(kept);
|
|
accounts.save(account);
|
|
return {status: 200, body: {ok: true, online: Boolean(session)}};
|
|
};
|
|
|
|
const FORBIDDEN = {status: 403, body: {error: "forbidden"}};
|
|
|
|
// the account a login token is for, while it may play. A ban leaves the
|
|
// token alone (so that the client can ask about the ban with it, below),
|
|
// and it is good for nothing else until the ban is over.
|
|
const holderOf = token => {
|
|
const account = accounts.byToken(token);
|
|
return account && world.moderation.banRemaining(account) === 0 ? account : null;
|
|
};
|
|
|
|
// `from.local` marks a request made on the server's own machine: the owner,
|
|
// who may use the finder for any account. everyone else can only give items
|
|
// to the account whose login token they hold, which is how the in-game
|
|
// finder calls it.
|
|
const handle = async (route, params, body, from) => {
|
|
switch (route) {
|
|
case "GET /api/search": {
|
|
const asking = accounts.byName(params.get("username") || "");
|
|
const known = asking && (from.local || holderOf(params.get("token")) === asking);
|
|
return {status: 200, body: search(params, known ? asking.finderGiven : null)};
|
|
}
|
|
case "GET /api/accounts":
|
|
if (!from.local) {
|
|
return FORBIDDEN;
|
|
}
|
|
return {status: 200, body: accounts.all().map(account => ({username: account.username, online: Boolean(world.findOnline(account.username))}))};
|
|
case "POST /api/give": {
|
|
const owner = holderOf((body || {}).token);
|
|
if (!from.local && (!owner || owner !== accounts.byName((body || {}).username))) {
|
|
return FORBIDDEN;
|
|
}
|
|
if (!from.local && !givesPerMinute.allow(owner.id)) {
|
|
return {status: 429, body: {error: "Too many at once. Try again in a minute."}};
|
|
}
|
|
return give(body || {});
|
|
}
|
|
case "POST /api/theme": {
|
|
const account = accounts.byName((body || {}).username);
|
|
if (!account || (!from.local && holderOf((body || {}).token) !== account)) {
|
|
return FORBIDDEN;
|
|
}
|
|
return world.setTheme(account, String((body || {}).theme))
|
|
? {status: 200, body: {ok: true, theme: account.theme}}
|
|
: {status: 400, body: {error: "Unknown theme"}};
|
|
}
|
|
// for the settings menu's Outfits and Den layouts lists (gui.MySettings
|
|
// in the patched client): the names saved, and a way to run the chat
|
|
// commands that save, wear and load them.
|
|
case "GET /api/saved": {
|
|
const account = accounts.byName(params.get("username"));
|
|
if (!account || (!from.local && holderOf(params.get("token")) !== account)) {
|
|
return FORBIDDEN;
|
|
}
|
|
return {status: 200, body: {outfits: account.outfits.map(entry => entry.name), layouts: account.denLayouts.map(entry => entry.name)}};
|
|
}
|
|
case "POST /api/command": {
|
|
const account = accounts.byName((body || {}).username);
|
|
if (!account || (!from.local && holderOf((body || {}).token) !== account)) {
|
|
return FORBIDDEN;
|
|
}
|
|
const text = String((body || {}).text || "");
|
|
if (!/^!(outfit|den) (wear|load|savenew|off|undo)( [a-z0-9]{1,20})?$/.test(text)) {
|
|
return {status: 400, body: {error: "Unknown command"}};
|
|
}
|
|
return world.runCommand(account, text) ? {status: 200, body: {ok: true}} : {status: 409, body: {error: "Not in the game"}};
|
|
}
|
|
// what a client shows beside its login form and in the game's top bar:
|
|
// how many are playing (the world map says as much), and since when the
|
|
// server has been up.
|
|
case "GET /api/status":
|
|
return {status: 200, body: {online: world.players().length, uptimeSeconds: Math.floor(process.uptime())}};
|
|
// is the holder of this login token banned, or the address they ask
|
|
// from? the client asks when its game stops, to say why. the reason is
|
|
// for the banned player, and the token says that is who asks.
|
|
case "POST /api/ban": {
|
|
const account = accounts.byToken((body || {}).token);
|
|
if (!account) {
|
|
return FORBIDDEN;
|
|
}
|
|
const ban = world.moderation.banOf(account);
|
|
const addressBan = ban ? null : bans.addressBan(from.address);
|
|
const deviceBan = ban || addressBan ? null : devices.banOfAccount(account);
|
|
return {status: 200, body: ban ? {banned: "account", banned_seconds: ban.seconds, ban_reason: ban.reason}
|
|
: addressBan ? {banned: "address", banned_seconds: world.moderation.PERMANENT, ban_reason: addressBan.reason}
|
|
: deviceBan ? {banned: "device", banned_seconds: world.moderation.PERMANENT, ban_reason: deviceBan.reason} : {banned: null}};
|
|
}
|
|
case "POST /api/register": {
|
|
if (bans.addressBan(from.address)) {
|
|
return {status: 403, body: {error: "address_banned"}};
|
|
}
|
|
// the client says which computer it is on (lib/devices.js); the sign-up
|
|
// page cannot, and an account made there still signs in through the client.
|
|
const device = devices.read((body || {}).device);
|
|
if (device && devices.banOf(device)) {
|
|
return {status: 403, body: {error: "device_banned"}};
|
|
}
|
|
const {username, password, avatarType} = body || {};
|
|
// the terms and the privacy policy, and old enough to agree to them:
|
|
// said by the one signing up, on the page or in the client.
|
|
if ((body || {}).agreed !== true) {
|
|
return {status: 400, body: {error: "agree_first"}};
|
|
}
|
|
const captchaProblem = await captcha.check(body, from, "signup");
|
|
if (captchaProblem) {
|
|
return {status: captchaProblem === "captcha_unavailable" ? 503 : 400, body: {error: captchaProblem}};
|
|
}
|
|
const problem = accounts.usernameProblem(typeof username === "string" ? username.trim() : username);
|
|
if (problem) {
|
|
return {status: 400, body: {error: problem}};
|
|
}
|
|
if (!limits.registrationAllowed(from.address, from.local)) {
|
|
return {status: 429, body: {error: "too_many_registrations"}};
|
|
}
|
|
// the animals the sign-up page offers; the game's own Create Account
|
|
// screens (lib/signup.js) offer theirs.
|
|
if (!STARTER_ANIMALS.includes(avatarType)) {
|
|
return {status: 400, body: {error: "choose_animal"}};
|
|
}
|
|
const result = accounts.register(username, password, {type: avatarType});
|
|
if (result.account) {
|
|
result.account.agreed = {version: config.termsVersion, at: Math.floor(Date.now() / 1000)};
|
|
accounts.save(result.account);
|
|
}
|
|
// the client signs in straight after, and is not asked again.
|
|
return result.error ? {status: 400, body: {error: result.error}}
|
|
: {status: 200, body: {username: result.account.username, captcha_pass: captcha.issuePass(result.account, from)}};
|
|
}
|
|
default:
|
|
return {status: 404, body: {error: "not_found"}};
|
|
}
|
|
};
|
|
|
|
module.exports = {handle};
|