From 6721db23acd2fcb9769e73bbf6a18bbed471e7ff Mon Sep 17 00:00:00 2001 From: EJClaw Date: Thu, 15 Oct 2026 11:19:13 +0900 Subject: [PATCH] =?UTF-8?q?=EB=B3=B4=EC=95=88=20=EB=A6=AC=EB=B7=B0=20?= =?UTF-8?q?=EB=B0=98=EC=98=81:=20=EB=B4=87=20=EC=A4=91=EA=B3=84=20?= =?UTF-8?q?=EC=9C=A0=EC=A0=80=EB=B3=84=20=EC=84=9C=EB=B2=84=20=C2=B7=20?= =?UTF-8?q?=EC=B1=84=EB=84=90=20=EA=B6=8C=ED=95=9C,=20=EC=9D=B8=EC=A6=9D?= =?UTF-8?q?=EC=84=9C=20=EA=B2=80=EC=A6=9D=20=EC=9A=B0=ED=9A=8C=20=EC=B0=A8?= =?UTF-8?q?=EB=8B=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 봇 중계 권한 (앱 유저의 디스코드 아이디 기준) - 서버 목록 · watch: 그 유저가 가입한 서버만. 아니면 watch_denied (명령 등록 · 멤버 목록도 거절) - 채널 · 음성 상태: 그 유저가 볼 수 있는(ViewChannel) 채널만. 볼 수 없는 채널로 옮기면 "나감"으로 가린다 - 음성 참여 op 4: 그 유저가 들어갈 수 있는(ViewChannel + Connect) 음성채널만 - /녹음시작 은 그 음성채널에 들어갈 수 있는 유저의 PC 로만, 다른 PC 로 가는 명령에는 볼 수 없는 채널 이름을 넣지 않는다 인증서 - 사이트 서버 https/wss(로그인 · 기기 등록 · 봇 중계 · 기기 중계)는 Node 내장 Mozilla 루트만 믿고 검증을 항상 켠다 (core/util/secure-http.ts) NODE_TLS_REJECT_UNAUTHORIZED=0 · 시스템 인증서 저장소의 가짜 루트로 엿볼 수 없다 - 시작할 때 NODE_TLS_REJECT_UNAUTHORIZED 를 지운다 (Electron main · 헤드리스 코어). fuses 로 막히지 않는 변수 - win smoke: 내장 루트만으로 실서버 https 가 검증되는지 확인 (siteTls) 테스트: 봇 중계 권한 1건(가입하지 않은 서버 · 비공개 채널 · 연결 권한 없는 채널 · 명령), 자체 서명 서버 + 검증 끄기 변수 1건(대조군 포함) login-e2e 친구 계정을 실제 F&L 멤버(테스트봇)로 Co-Authored-By: Claude Opus 5.5 --- README.md | 2 + app/scripts/login-e2e.mts | 3 +- app/src/core/auth.ts | 5 +- app/src/core/discord/gateway.ts | 10 ++- app/src/core/index.ts | 2 + app/src/core/relay/client.ts | 12 ++- app/src/core/util/secure-http.ts | 45 +++++++++++ app/src/main/main.ts | 10 ++- app/test/bot-gateway.test.ts | 125 ++++++++++++++++++++++++++---- app/test/security.test.ts | 73 +++++++++++++++++ docs/dev/ARCHITECTURE.md | 4 +- packages/shared/src/protocol.ts | 5 +- site/server/src/bot-broker.ts | 103 +++++++++++++++++------- site/server/src/discord-source.ts | 41 +++++++--- 14 files changed, 372 insertions(+), 68 deletions(-) create mode 100644 app/src/core/util/secure-http.ts diff --git a/README.md b/README.md index bf09745..63bcbd7 100644 --- a/README.md +++ b/README.md @@ -29,6 +29,8 @@ ## 통신 · 데이터 보안 (v1.2.2~) - 앱 ↔ 사이트 서버(로그인 토큰 · 기기 키 · 기록 중계 · 봇 중계)는 **https/wss 만** 쓴다. 사이트 서버 주소를 http 로 바꾸면 거절하고 아무것도 보내지 않는다 (이 PC 안 127.0.0.1 · localhost 만 예외, 개발용). `app/src/core/util/secure-url.ts` +- 사이트 서버 인증서는 앱에 들어 있는 Mozilla 루트 인증서로만 검증하고 검증을 끌 수 없다. `NODE_TLS_REJECT_UNAUTHORIZED=0`, Windows 인증서 저장소에 깐 가짜 루트 인증서(감시 · 프록시 프로그램)로는 통신을 엿볼 수 없다. 검증 끄기 변수는 시작할 때 지워서 사이트 밖 통신도 검증한다. `app/src/core/util/secure-http.ts` +- 겜녹이 봇 중계 권한: 앱 유저가 가입한 디스코드 서버, 그 유저가 볼 수 있는 채널만 보이고, 그 유저가 들어갈 수 있는 음성채널에만 봇을 부를 수 있다. - 게임 연동(Riot 로컬 API)의 자체 서명 인증서 예외는 이 PC 안 주소에만 쓴다. Riot 원격 API 등 바깥 주소는 항상 인증서를 검증한다. - exe(Electron) 잠금: `NODE_OPTIONS` · `NODE_EXTRA_CA_CERTS`(가짜 인증서를 끼워 통신을 엿보는 데 쓰임) · `ELECTRON_RUN_AS_NODE` · `--inspect` 를 무시하고 `app.asar` 만 읽는다 (Electron fuses). 설정 창은 앱 화면만 띄우고 바깥 주소는 브라우저로 연다. 권한 요청(마이크 · 카메라 등)은 거절한다. - 사이트 서버: 보안 정책(CSP)으로 이 사이트 스크립트와 이 사이트로의 접속만 허용, 실시간 WebSocket 은 이 사이트에서 온 연결만, 로그인 세션 · 앱 토큰 · 기기 키는 해시로만 저장, 로그에서 로그인 code · state · 검색어를 지운다. 등록 코드 대입 · 로그인 요청 폭주는 IP 별로 막는다. HSTS · http→https 이동 · TLS 1.2 미만 차단은 앞단 프록시(NPMplus)가 한다. diff --git a/app/scripts/login-e2e.mts b/app/scripts/login-e2e.mts index f8caad2..94dd80b 100644 --- a/app/scripts/login-e2e.mts +++ b/app/scripts/login-e2e.mts @@ -17,7 +17,8 @@ const BOT = process.env.GVR_E2E_BOT_TOKEN; if (!BOT) throw new Error('GVR_E2E_BOT_TOKEN 이 필요합니다'); const shots = process.argv[2]; const SUPER = '293719842274541579'; -const FRIEND = '111111111111111111'; +// 친구 = 테스트봇 계정 (F&L 서버 멤버). 봇 중계는 앱 유저가 가입한 서버만 보여 주므로 실제 멤버여야 한다 +const FRIEND = '1538122882528321536'; const PORT = 18931; const base = `http://127.0.0.1:${PORT}`; const work = fs.mkdtempSync(path.join(process.env.TMPDIR || os.tmpdir(), 'gvr-login-e2e-')); diff --git a/app/src/core/auth.ts b/app/src/core/auth.ts index c303c2d..0bbf82a 100644 --- a/app/src/core/auth.ts +++ b/app/src/core/auth.ts @@ -7,6 +7,7 @@ import { EventEmitter } from 'node:events'; import type { AppLoginBegin, AppLoginPoll, AppMe, AppRole, AppUserInfo, AppUserRow } from '@gvr/shared'; import type { SettingsStore } from './settings.js'; import { logger } from './util/log.js'; +import { secureFetch } from './util/secure-http.js'; import { secureServerUrl } from './util/secure-url.js'; const log = logger('auth'); @@ -70,7 +71,7 @@ export class AppAuth extends EventEmitter { } private async call(method: string, path: string, body?: unknown, token = this.settings.getSecret('appToken')): Promise { - const r = await fetch(this.server + path, { + const r = await secureFetch(this.server + path, { method, headers: { ...(body !== undefined ? { 'content-type': 'application/json' } : {}), @@ -78,7 +79,7 @@ export class AppAuth extends EventEmitter { 'x-gvr-version': this.opts.version, }, body: body !== undefined ? JSON.stringify(body) : undefined, - signal: AbortSignal.timeout(15000), + timeoutMs: 15000, }); const text = await r.text(); let json: any = null; diff --git a/app/src/core/discord/gateway.ts b/app/src/core/discord/gateway.ts index b1fd7fa..71d417c 100644 --- a/app/src/core/discord/gateway.ts +++ b/app/src/core/discord/gateway.ts @@ -8,6 +8,7 @@ import { ChannelType, Client, Events, GatewayIntentBits, MessageFlags, type Guil import { EventEmitter } from 'node:events'; import WebSocket from 'ws'; import { logger } from '../util/log.js'; +import { TLS_TRUST } from '../util/secure-http.js'; import { wsUrl } from '../util/secure-url.js'; const log = logger('gateway'); @@ -264,7 +265,7 @@ export class RemoteGateway extends EventEmitter implements BotGateway { log.error(e.message); return; } - const ws = new WebSocket(url, { headers: { authorization: `Bearer ${token}`, 'x-gvr-version': this.opts.version }, handshakeTimeout: 10000, maxPayload: 8 * 1024 * 1024 }); + const ws = new WebSocket(url, { headers: { authorization: `Bearer ${token}`, 'x-gvr-version': this.opts.version }, handshakeTimeout: 10000, maxPayload: 8 * 1024 * 1024, ...TLS_TRUST }); this.ws = ws; let unauthorized = false; let alive = Date.now(); @@ -346,6 +347,13 @@ export class RemoteGateway extends EventEmitter implements BotGateway { this.wait?.resolve(m.guild); this.wait = null; return; + case 'watch_denied': + // 이 유저가 가입하지 않은 서버 + if (this.watched?.id !== m.guildId) return; + log.warn('이 디스코드 서버에 가입되어 있지 않아 녹음할 수 없습니다'); + this.wait?.resolve(null); + this.wait = null; + return; case 'voiceState': if (this.watched?.id !== m.guildId) return; this.remember(m.member); diff --git a/app/src/core/index.ts b/app/src/core/index.ts index 4400556..718a2ca 100644 --- a/app/src/core/index.ts +++ b/app/src/core/index.ts @@ -18,6 +18,7 @@ import { WorkerClient, type WorkerCommand } from './stt/worker.js'; import { Timeline } from './timeline.js'; import { Bus } from './util/events.js'; import { initLogFile, logger } from './util/log.js'; +import { hardenTlsEnv } from './util/secure-http.js'; const log = logger('core'); @@ -39,6 +40,7 @@ export type Core = Awaited>; /** 코어 조립 (Electron 메인 프로세스와 헤드리스 CLI 가 같이 쓴다) */ export async function startCore(opts: CoreOptions) { + hardenTlsEnv(); // 헤드리스 CLI 도 (Electron 은 main.ts 에서 먼저) fs.mkdirSync(opts.dataDir, { recursive: true }); const settings = opts.settings ?? new SettingsStore(opts.dataDir, opts.codec); const S = () => settings.get(); diff --git a/app/src/core/relay/client.ts b/app/src/core/relay/client.ts index 8218b98..ed62b5e 100644 --- a/app/src/core/relay/client.ts +++ b/app/src/core/relay/client.ts @@ -3,6 +3,7 @@ import WebSocket from 'ws'; import type { LiveEvent, RelayFromDevice, RelayToDevice } from '@gvr/shared'; import type { Bus } from '../util/events.js'; import { logger } from '../util/log.js'; +import { secureFetch, TLS_TRUST } from '../util/secure-http.js'; import { secureServerUrl, wsUrl } from '../util/secure-url.js'; const log = logger('relay'); @@ -70,7 +71,7 @@ export class RelayClient { return; } this.status = { ...this.status, state: 'connecting', serverUrl: c.serverUrl }; - const ws = new WebSocket(url, { headers: { authorization: `Device ${c.deviceId}.${c.deviceKey}` }, handshakeTimeout: 10000, maxPayload: 8 * 1024 * 1024 }); + const ws = new WebSocket(url, { headers: { authorization: `Device ${c.deviceId}.${c.deviceKey}` }, handshakeTimeout: 10000, maxPayload: 8 * 1024 * 1024, ...TLS_TRUST }); this.ws = ws; ws.on('open', () => { this.retries = 0; @@ -157,12 +158,17 @@ export class RelayClient { /** 1회용 등록 코드로 이 PC 를 사이트 서버에 등록한다 */ export async function registerDevice(serverUrl: string, code: string, name: string): Promise<{ deviceId: string; deviceKey: string }> { - const r = await fetch(secureServerUrl(serverUrl) + '/device/register', { + const r = await secureFetch(secureServerUrl(serverUrl) + '/device/register', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ code: code.trim(), name }), }); - const data: any = await r.json().catch(() => ({})); + let data: any = {}; + try { + data = JSON.parse(await r.text()); + } catch { + /* JSON 아님 */ + } if (!r.ok) throw new Error(data.message || (r.status === 400 || r.status === 404 ? '등록 코드가 올바르지 않거나 만료되었습니다' : `서버 오류 ${r.status}`)); return { deviceId: data.deviceId, deviceKey: data.deviceKey }; } diff --git a/app/src/core/util/secure-http.ts b/app/src/core/util/secure-http.ts new file mode 100644 index 0000000..d7f4968 --- /dev/null +++ b/app/src/core/util/secure-http.ts @@ -0,0 +1,45 @@ +// 사이트 서버와의 https/wss 통신에 쓰는 인증서 신뢰 설정. +// Node 에 들어 있는 Mozilla 루트 인증서만 믿고, 검증은 항상 켠다. 그래서 아래 방법으로는 통신을 엿볼 수 없다 +// - NODE_TLS_REJECT_UNAUTHORIZED=0 (검증 끄기), NODE_EXTRA_CA_CERTS · NODE_USE_SYSTEM_CA (가짜 루트 인증서 끼우기) +// - Windows 인증서 저장소에 가짜 루트 인증서 설치 (프록시 · 감시 프로그램) +import https from 'node:https'; +import tls from 'node:tls'; + +export const TLS_TRUST: { ca: string[]; rejectUnauthorized: true } = { ca: [...tls.rootCertificates], rejectUnauthorized: true }; +const agent = new https.Agent({ ...TLS_TRUST, keepAlive: true }); + +export interface SecureResponse { + status: number; + ok: boolean; + text(): Promise; +} + +/** fetch 와 비슷한 작은 요청 함수. https 는 위 신뢰 설정으로, http 는 이 PC 안 주소(개발 · 테스트, secureServerUrl 이 거른다)만 */ +export function secureFetch(url: string, init: { method?: string; headers?: Record; body?: string; timeoutMs?: number } = {}): Promise { + const u = new URL(url); + if (u.protocol === 'http:') { + return fetch(url, { method: init.method, headers: init.headers, body: init.body, signal: AbortSignal.timeout(init.timeoutMs ?? 15000) }); + } + if (u.protocol !== 'https:') return Promise.reject(new Error(`지원하지 않는 주소: ${u.protocol}`)); + return new Promise((resolve, reject) => { + const req = https.request(u, { method: init.method || 'GET', headers: init.headers, agent, ...TLS_TRUST, timeout: init.timeoutMs ?? 15000 }, (res) => { + const chunks: Buffer[] = []; + res.on('data', (c: Buffer) => chunks.push(c)); + res.on('error', reject); + res.on('end', () => { + const status = res.statusCode || 0; + const body = Buffer.concat(chunks).toString('utf8'); + resolve({ status, ok: status >= 200 && status < 300, text: async () => body }); + }); + }); + req.on('timeout', () => req.destroy(new Error('timeout'))); + req.on('error', reject); + if (init.body) req.write(init.body); + req.end(); + }); +} + +/** 검증을 끄는 환경변수는 시작할 때 지운다 (사이트 밖 통신: 다른 봇 모드의 디스코드 연결 · Riot 원격 API 등도 검증하게) */ +export function hardenTlsEnv(): void { + delete process.env.NODE_TLS_REJECT_UNAUTHORIZED; +} diff --git a/app/src/main/main.ts b/app/src/main/main.ts index f4259dc..6452b23 100644 --- a/app/src/main/main.ts +++ b/app/src/main/main.ts @@ -7,11 +7,14 @@ import { AppAuth } from '../core/auth.js'; import { startCore, type Core } from '../core/index.js'; import { plainCodec, SettingsStore, type SecretCodec } from '../core/settings.js'; import { logger } from '../core/util/log.js'; +import { hardenTlsEnv, secureFetch } from '../core/util/secure-http.js'; import { Finetuner } from './finetune.js'; import type { AuthView } from './api-types.js'; import { buildState, registerIpc } from './ipc.js'; import { brandDir, rendererDir, resolveDataDir, resourcesDir, workerCommand } from './paths.js'; +// 인증서 검증을 끄는 환경변수(NODE_TLS_REJECT_UNAUTHORIZED=0)는 무시한다. fuses 로 막지 못하는 변수라 가장 먼저 지운다 +hardenTlsEnv(); const log = logger('app'); const argv = process.argv.slice(1); const flag = (name: string) => argv.includes(`--${name}`); @@ -187,13 +190,18 @@ async function smoke(): Promise { out.bot = { status: c.bot.state.status, error: c.bot.state.error }; const botOk = a.status === 'signed_out' && !st.hasBuiltinBot && c.bot.state.status !== 'ready'; out.gpu = await c.worker.request('gpu_info', {}, 30000).catch((e) => String(e)); + // 사이트 서버 https: 앱이 믿는 루트 인증서(Node 내장 Mozilla 목록)만으로 실제 서버 인증서가 검증되는지 + out.siteTls = await secureFetch(`${c.settings.get().site.serverUrl}/healthz`, { timeoutMs: 20000 }).then( + (r) => r.ok, + (e) => String(e?.message ?? e), + ); c.settings.setSecret('riotApiKey', 'smoke-test'); out.secretRoundTrip = c.settings.getSecret('riotApiKey') === 'smoke-test'; c.settings.setSecret('riotApiKey', null); out.dict = c.store.listDict().length; out.renderer = fs.existsSync(path.join(rendererDir(), 'index.html')); out.tray = fs.existsSync(path.join(brandDir(), 'tray.png')); - code = ready && botOk && out.secretRoundTrip && out.renderer && out.tray ? 0 : 1; + code = ready && botOk && out.secretRoundTrip && out.renderer && out.tray && out.siteTls === true ? 0 : 1; await c.stop(); } catch (e: any) { out.error = e.stack || e.message; diff --git a/app/test/bot-gateway.test.ts b/app/test/bot-gateway.test.ts index d371886..d187a61 100644 --- a/app/test/bot-gateway.test.ts +++ b/app/test/bot-gateway.test.ts @@ -22,6 +22,11 @@ const OTHER_G = '900000000000000002'; const VC1 = '910000000000000001'; const VC2 = '910000000000000002'; const TEXT = '910000000000000009'; +/** 최고 관리자만 볼 수 있는 비공개 음성채널 */ +const PRIV = '910000000000000003'; +/** 모두 볼 수 있지만 최고 관리자만 들어갈 수 있는 음성채널 */ +const LOCKED = '910000000000000004'; +const OTHER_VC = '920000000000000001'; const tmp = () => fs.mkdtempSync(path.join(process.env.TMPDIR || os.tmpdir(), 'gvr-botgw-')); delete process.env.GVR_BOT_TOKEN; @@ -36,25 +41,48 @@ class FakeSource extends EventEmitter implements BotSource { me() { return ME; } - guilds(): BotGwGuild[] { - return [ - { id: G, name: 'M&L', icon: null }, - { id: OTHER_G, name: '다른 서버', icon: null }, - ]; + private all: BotGwGuild[] = [ + { id: G, name: 'M&L', icon: null }, + { id: OTHER_G, name: '다른 서버', icon: null }, + ]; + /** 서버별 멤버: 친구는 M&L 에만 가입 */ + private memberOf: Record = { [G]: [SUPER, FRIEND], [OTHER_G]: [SUPER] }; + private channels: Record = { + [G]: [ + { id: VC1, name: '일반', voice: true, view: [SUPER, FRIEND], connect: [SUPER, FRIEND] }, + { id: VC2, name: '게임', voice: true, view: [SUPER, FRIEND], connect: [SUPER, FRIEND] }, + { id: PRIV, name: '운영진', voice: true, view: [SUPER], connect: [SUPER] }, + { id: LOCKED, name: '방송', voice: true, view: [SUPER, FRIEND], connect: [SUPER] }, + { id: TEXT, name: '채팅', voice: false, view: [SUPER, FRIEND], connect: [] }, + ], + [OTHER_G]: [{ id: OTHER_VC, name: '다른 음성', voice: true, view: [SUPER], connect: [SUPER] }], + }; + /** 지금 음성채널에 있는 사람 */ + voice: { member: BotGwMember; channelId: string; guildId: string }[] = [ + { member: m(SUPER, '관리자'), channelId: VC1, guildId: G }, + { member: m('300000000000000001', '운영진'), channelId: PRIV, guildId: G }, + ]; + private ch(g: string, c: string) { + return this.channels[g]?.find((x) => x.id === c); } - snapshot(guildId: string) { - const g = this.guilds().find((x) => x.id === guildId); - if (!g) return null; - const channels: BotGwChannel[] = [ - { id: VC1, name: '일반' }, - { id: VC2, name: '게임' }, - ]; - return { guild: g, channels, voice: [{ member: m(SUPER, '관리자'), channelId: VC1 }] }; + async guildsFor(userId: string) { + return this.all.filter((g) => this.memberOf[g.id]?.includes(userId)); } - isVoiceChannel(guildId: string, channelId: string) { - return guildId === G && (channelId === VC1 || channelId === VC2); + async snapshot(guildId: string, userId: string) { + const g = this.all.find((x) => x.id === guildId); + if (!g || !this.memberOf[guildId]?.includes(userId)) return null; + const channels: BotGwChannel[] = this.channels[guildId]!.filter((c) => c.voice && c.view.includes(userId)).map((c) => ({ id: c.id, name: c.name })); + return { guild: g, channels, voice: this.voice.filter((v) => v.guildId === guildId && channels.some((c) => c.id === v.channelId)).map(({ member, channelId }) => ({ member, channelId })) }; } - async members() { + canView(guildId: string, userId: string, channelId: string) { + return !!this.ch(guildId, channelId)?.view.includes(userId); + } + canConnect(guildId: string, userId: string, channelId: string) { + const c = this.ch(guildId, channelId); + return !!c?.voice && c.view.includes(userId) && c.connect.includes(userId); + } + async members(guildId: string, userId: string) { + if (!this.memberOf[guildId]?.includes(userId)) throw new Error('forbidden'); return [m(SUPER, '관리자'), m(FRIEND, '친구'), m('700000000000000001', '음악봇', true)]; } async registerCommands(guildId: string) { @@ -312,3 +340,68 @@ test('봇 중계: 슬래시 명령은 그 서버를 지켜보는 앱으로 가 await s.close(); } }); + +test('봇 중계 권한: 일반 유저는 가입한 서버 · 볼 수 있는 채널만 보이고, 들어갈 수 있는 음성채널에만 봇을 부른다', async () => { + const s = await stack(); + const a = await s.pc(SUPER); + const admin = new AppAuth(a.st, { version: 't', openUrl: () => undefined }); + await admin.adminAddUser(FRIEND, 'user'); + const b = await s.pc(FRIEND); + try { + await b.gw.start(); + // 서버 목록: 가입한 M&L 만 + assert.deepEqual(b.gw.guilds().map((g) => g.id), [G]); + // 가입하지 않은 서버는 지켜볼 수 없다 (바로 거절) + const t0 = Date.now(); + assert.equal(await b.gw.watch(OTHER_G, { commands: true }), null); + assert.ok(Date.now() - t0 < 3000, '거절은 바로 온다'); + assert.ok(!s.source.commands.includes(OTHER_G), '가입하지 않은 서버에 명령을 등록하지 않는다'); + await assert.rejects(b.gw.members(OTHER_G), /forbidden/); + + // M&L: 비공개 채널과 그 안의 사람은 안 보인다 + assert.ok(await b.gw.watch(G, { commands: false })); + assert.deepEqual((b.gw as any).channels && [...(b.gw as any).channels.keys()].sort(), [VC1, VC2, LOCKED].sort()); + assert.equal(b.gw.voiceChannelOf(G, '300000000000000001'), null); + assert.equal(b.gw.channel(G, PRIV), null); + + // 비공개 채널 안의 움직임은 안 오고, 비공개 채널로 옮기면 "나감"으로만 보인다 + const evs: any[] = []; + b.gw.on('voiceState', (e) => evs.push(e)); + s.source.emit('voiceState', { guildId: G, member: m('300000000000000002', '운영진2'), oldChannelId: null, newChannelId: PRIV, channel: { id: PRIV, name: '운영진' } }); + s.source.emit('voiceState', { guildId: G, member: m(SUPER, '관리자'), oldChannelId: VC1, newChannelId: PRIV, channel: { id: PRIV, name: '운영진' } }); + await until(() => evs.length === 1); + await new Promise((r) => setTimeout(r, 100)); + assert.equal(evs.length, 1); + assert.deepEqual([evs[0].member.id, evs[0].oldChannelId, evs[0].newChannelId, evs[0].channel], [SUPER, VC1, null, null]); + + // 음성 참여: 비공개 · 연결 권한 없는 채널 · 다른 서버는 거절, 들어갈 수 있는 채널만 + const ad = b.gw.adapterCreator(G)({ onVoiceServerUpdate: () => undefined, onVoiceStateUpdate: () => undefined, destroy: () => undefined }); + ad.sendPayload(op4(G, PRIV)); + ad.sendPayload(op4(G, LOCKED)); + ad.sendPayload(op4(G, OTHER_VC)); + ad.sendPayload(op4(G, VC2)); + await until(() => s.source.sent.length === 1); + await new Promise((r) => setTimeout(r, 100)); + assert.deepEqual(s.source.sent.map((x) => x.payload.d.channel_id), [VC2]); + + // 슬래시 명령: 최고 관리자가 비공개 채널에서 /녹음시작 → 그 채널에 못 들어가는 친구 PC 로는 보내지 않는다 + const cmds: any[] = []; + b.gw.on('command', (c, respond) => (cmds.push(c), respond('ok'))); + const cmd = (name: string) => + new Promise((resolve) => s.source.emit('command', { name, guildId: G, user: m(SUPER, '관리자'), voiceChannel: { id: PRIV, name: '운영진' } } satisfies BotCommand, resolve)); + assert.equal(await cmd('녹음시작'), '이 음성채널에 들어갈 수 있는 겜녹이 앱이 없습니다.'); + // /녹음제외 는 친구 PC 기록에도 남기되 비공개 채널 이름은 보내지 않는다 + assert.equal(await cmd('녹음제외'), 'ok'); + assert.equal(cmds.length, 1); + assert.equal(cmds[0].voiceChannel, null); + + // 친구 PC 가 받은 메시지 어디에도 비공개 채널 · 그 안의 사람 정보가 없다 + const all = b.seen.join('\n'); + // (OTHER_G 는 친구가 직접 보낸 watch 의 거절 응답에만 나온다) + for (const secret of [PRIV, '운영진', '300000000000000001', '300000000000000002', '다른 서버', OTHER_VC]) assert.ok(!all.includes(secret), secret); + } finally { + await a.gw.stop(); + await b.gw.stop(); + await s.close(); + } +}); diff --git a/app/test/security.test.ts b/app/test/security.test.ts index 4e0d42f..d009772 100644 --- a/app/test/security.test.ts +++ b/app/test/security.test.ts @@ -46,3 +46,76 @@ test('암호화되지 않은 주소로는 로그인 토큰 · 기기 등록 코 test('게임 연동: 인증서 검증을 끄는 건 이 PC 안 주소뿐 (local 을 잘못 넘겨도 바깥 주소는 거절)', async () => { await assert.rejects(request('https://pd.ap.a.pvp.net/x', { local: true }), /로컬 API 가 아닌 주소/); }); + +test('인증서: NODE_TLS_REJECT_UNAUTHORIZED=0 이어도 믿을 수 없는 인증서의 서버로는 토큰 · 기기 키를 보내지 않는다 (https · wss)', async () => { + const { execFileSync } = await import('node:child_process'); + const https = await import('node:https'); + const { WebSocketServer } = await import('ws'); + const { RelayClient } = await import('../src/core/relay/client.ts'); + const { Bus } = await import('../src/core/util/events.ts'); + // 가짜 서버 (자체 서명 인증서): 받은 요청의 인증 헤더를 모두 기록한다 + const dir = tmp(); + execFileSync('openssl', ['req', '-x509', '-newkey', 'rsa:2048', '-nodes', '-subj', '/CN=127.0.0.1', '-addext', 'subjectAltName=IP:127.0.0.1', '-days', '1', '-keyout', path.join(dir, 'k.pem'), '-out', path.join(dir, 'c.pem')], { stdio: 'ignore' }); + const got: string[] = []; + const srv = https.createServer({ key: fs.readFileSync(path.join(dir, 'k.pem')), cert: fs.readFileSync(path.join(dir, 'c.pem')) }, (req, res) => { + got.push(`${req.url} ${req.headers.authorization ?? ''}`); + res.setHeader('content-type', 'application/json'); + res.end('{"state":"pending","user":{"id":"1","name":"x","avatar":null},"role":"user","serverTime":0}'); + }); + const wss = new WebSocketServer({ noServer: true }); + srv.on('upgrade', (req, socket, head) => { + got.push(`WS ${req.url} ${req.headers.authorization ?? ''}`); + wss.handleUpgrade(req, socket, head, (ws) => ws.close()); + }); + await new Promise((r) => srv.listen(0, '127.0.0.1', () => r())); + const base = `https://127.0.0.1:${(srv.address() as any).port}`; + const prev = process.env.NODE_TLS_REJECT_UNAUTHORIZED; + process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0'; + const origWarn = process.emitWarning; + process.emitWarning = () => undefined; + try { + // 대조군: 기본 fetch 는 이 변수 때문에 실제로 토큰을 보낸다 (테스트가 우회를 잡아낼 수 있는지 확인) + await fetch(`${base}/control`, { headers: { authorization: 'Bearer control' } }); + assert.deepEqual(got, ['/control Bearer control']); + got.length = 0; + + const st = new SettingsStore(tmp()); + st.update({ site: { serverUrl: base, deviceId: 'dev1' } }); + st.setSecret('appToken', 'secret-app-token'); + st.setSecret('deviceKey', 'secret-device-key'); + // 로그인 확인 (https) + const auth = new AppAuth(st, { version: 't', openUrl: () => undefined }); + const a = await auth.check(); + assert.notEqual(a.status, 'ok'); + assert.match(a.error ?? '', /연결할 수 없습니다/); + // 기기 등록 (https) + await assert.rejects(registerDevice(base, 'ABCD-EFGH', 'pc')); + // 겜녹이 봇 중계 (wss) + const gw = new RemoteGateway({ serverUrl: () => base, appToken: () => 'secret-app-token', version: 't' }); + const started = gw.start().then(() => 'ready', () => 'failed'); + await new Promise((r) => setTimeout(r, 1500)); + await gw.stop(); + assert.equal(await Promise.race([started, new Promise((r) => setTimeout(() => r('pending'), 100))]) === 'ready', false); + // 사이트 기기 중계 (wss) + const relay = new RelayClient({} as any, new Bus(), () => ({ serverUrl: base, deviceId: 'dev1', deviceKey: 'secret-device-key', name: 'pc', version: 't', guildId: null })); + relay.start(); + await new Promise((r) => setTimeout(r, 1500)); + assert.notEqual(relay.status.state, 'online'); + relay.stop(); + + assert.deepEqual(got, [], '믿을 수 없는 인증서의 서버에 요청 · 토큰이 가면 안 된다'); + + // 앱 시작 때 이 변수를 지우면 (main.ts · startCore) 사이트 밖 통신(일반 fetch: 다른 봇 · Riot 원격 API 등)도 다시 검증한다 + const { hardenTlsEnv } = await import('../src/core/util/secure-http.ts'); + hardenTlsEnv(); + assert.equal(process.env.NODE_TLS_REJECT_UNAUTHORIZED, undefined); + await assert.rejects(fetch(`${base}/after-harden`, { headers: { authorization: 'Bearer x' } })); + assert.deepEqual(got, []); + } finally { + if (prev === undefined) delete process.env.NODE_TLS_REJECT_UNAUTHORIZED; + else process.env.NODE_TLS_REJECT_UNAUTHORIZED = prev; + process.emitWarning = origWarn; + srv.closeAllConnections(); + srv.close(); + } +}); diff --git a/docs/dev/ARCHITECTURE.md b/docs/dev/ARCHITECTURE.md index 5ea4cb3..3fe8de5 100644 --- a/docs/dev/ARCHITECTURE.md +++ b/docs/dev/ARCHITECTURE.md @@ -228,7 +228,9 @@ type TimelineItem = - 서버 → 앱: `ready{me, guilds}` · `guilds` · `guild{guild, channels, voice}`(watch 응답) · `voiceState`(지켜보는 서버만) · `cmd`(슬래시 명령) · `vserver`/`vstate`(봇 자신의 VOICE_SERVER/STATE_UPDATE 원문 = 일회용 음성 접속 정보) · `taken` · `res` - 앱 → 서버: `watch{guildId, commands}` · `voice{guildId, payload}`(@discordjs/voice 어댑터의 op 4) · `cmd_res{id, content}` · `req{op:'members'}` -- 음성채널 참여: 앱의 @discordjs/voice 가 어댑터로 op 4 를 보내면 서버가 검사(지켜보는 서버 · 음성채널 · op 4 만, 필드를 다시 만들어)한 뒤 대신 보내고, +- 권한 (앱 유저의 디스코드 아이디 기준): 서버 목록 · watch 는 그 유저가 가입한 서버만 (아니면 `watch_denied`), 채널 · 음성 상태는 그 유저가 볼 수 있는(ViewChannel) 채널만 + (볼 수 없는 채널로 옮기면 "나감"으로 가린다), 음성 참여는 그 유저가 들어갈 수 있는(ViewChannel + Connect) 음성채널만. 슬래시 명령 /녹음시작 도 그 채널에 들어갈 수 있는 유저의 PC 로만 보낸다 +- 음성채널 참여: 앱의 @discordjs/voice 가 어댑터로 op 4 를 보내면 서버가 검사(지켜보는 서버 · 들어갈 수 있는 음성채널 · op 4 만, 필드를 다시 만들어)한 뒤 대신 보내고, 디스코드가 준 session_id · 음성 서버 token · endpoint 를 그 앱에만 넘긴다. 음성(UDP · DAVE)은 앱 ↔ 디스코드 음성 서버로 바로 간다 (Lavalink 와 같은 방식) - 한 서버에서 봇은 음성채널 하나에만 있을 수 있다: 마지막으로 참여를 요청한 앱이 가져가고 이전 앱은 `taken` 을 받는다. 이전 앱의 늦은 나가기는 무시한다. 음성을 가진 앱이 끊기면 서버가 봇을 음성채널에서 뺀다 diff --git a/packages/shared/src/protocol.ts b/packages/shared/src/protocol.ts index 7b92021..970b08a 100644 --- a/packages/shared/src/protocol.ts +++ b/packages/shared/src/protocol.ts @@ -272,6 +272,7 @@ export interface AppUserRow { } // 겜녹이 봇 중계 (사이트 서버 WebSocket /app/bot/ws, Authorization: Bearer <앱 토큰>) +// 권한: 앱 유저가 가입한 디스코드 서버만, 그 유저가 볼 수 있는 채널만 보이고, 들어갈 수 있는(보기 + 연결) 음성채널에만 봇을 부를 수 있다 // 봇 토큰은 서버에만 있다. 서버가 디스코드 게이트웨이에 붙어 있고, 앱은 필요한 정보만 받는다. // 음성채널에 들어갈 때는 앱의 @discordjs/voice 가 보낸 op 4 를 서버가 대신 보내고, // 디스코드가 준 일회용 음성 접속 정보(VOICE_STATE/SERVER_UPDATE)를 앱에 넘긴다. 음성은 앱 ↔ 디스코드로 바로 간다. @@ -294,8 +295,10 @@ export interface BotGwChannel { export type BotGwToApp = | { t: 'ready'; me: BotGwMember; guilds: BotGwGuild[] } | { t: 'guilds'; guilds: BotGwGuild[] } - /** watch 응답: 그 서버의 음성채널 · 음성채널에 있는 사람 */ + /** watch 응답: 그 서버에서 이 유저가 볼 수 있는 음성채널 · 그 채널에 있는 사람 */ | { t: 'guild'; guild: BotGwGuild; channels: BotGwChannel[]; voice: { member: BotGwMember; channelId: string }[] } + /** watch 거절: 이 유저가 가입하지 않은 서버 */ + | { t: 'watch_denied'; guildId: string } | { t: 'voiceState'; guildId: string; member: BotGwMember; oldChannelId: string | null; newChannelId: string | null; channel: BotGwChannel | null } | { t: 'cmd'; id: string; name: string; guildId: string; user: BotGwMember; voiceChannel: BotGwChannel | null } /** 음성 접속 정보 (디스코드 VOICE_SERVER_UPDATE / 봇 자신의 VOICE_STATE_UPDATE 원문) */ diff --git a/site/server/src/bot-broker.ts b/site/server/src/bot-broker.ts index 3cf831c..39e10a7 100644 --- a/site/server/src/bot-broker.ts +++ b/site/server/src/bot-broker.ts @@ -24,19 +24,31 @@ export interface BotCommand { voiceChannel: BotGwChannel | null; } +export interface BotSnapshot { + guild: BotGwGuild; + channels: BotGwChannel[]; + voice: { member: BotGwMember; channelId: string }[]; +} + /** * 디스코드 게이트웨이 쪽 (실서버: discord-source.ts 의 discord.js, 테스트: 가짜). * 이벤트: 'ready', 'guilds', 'voiceState' (BotVoiceEvent), 'command' (BotCommand, respond(content)) + * 권한은 앱 유저(디스코드 아이디) 기준: 그 유저가 가입한 서버, 그 유저가 볼 수 있는 채널만 */ export interface BotSource extends EventEmitter { /** 이 서버의 슬래시 명령을 받을지 (지켜보는 앱이 없으면 응답하지 않는다: 아직 봇 토큰을 직접 쓰는 v1.1.0 PC 의 응답을 가로채지 않게) */ wants?: (guildId: string) => boolean; me(): BotGwMember | null; - guilds(): BotGwGuild[]; - /** 음성채널 목록과 음성채널에 있는 사람 */ - snapshot(guildId: string): { guild: BotGwGuild; channels: BotGwChannel[]; voice: { member: BotGwMember; channelId: string }[] } | null; - isVoiceChannel(guildId: string, channelId: string): boolean; - members(guildId: string): Promise; + /** 봇이 들어가 있고 이 유저도 가입한 서버 */ + guildsFor(userId: string): Promise; + /** 이 유저가 볼 수 있는 음성채널과 그 채널에 있는 사람. 서버 멤버가 아니면 null */ + snapshot(guildId: string, userId: string): Promise; + /** 이 유저가 이 채널을 볼 수 있는지 (멤버 · 권한 캐시 기준) */ + canView(guildId: string, userId: string, channelId: string): boolean; + /** 이 유저가 들어갈 수 있는 음성채널인지 (보기 + 연결 권한) */ + canConnect(guildId: string, userId: string, channelId: string): boolean; + /** 서버 멤버 목록 (이 유저가 멤버일 때만) */ + members(guildId: string, userId: string): Promise; registerCommands(guildId: string): Promise; /** 서버마다 하나. 디스코드가 보낸 봇 자신의 음성 접속 정보를 handlers 로 넘기고, send 로 op 4 를 보낸다 */ voiceAdapter(guildId: string, handlers: { server: (d: any) => void; state: (d: any) => void }): { send: (payload: any) => boolean }; @@ -71,12 +83,21 @@ export class BotBroker { private log: { info: (o: any, m?: string) => void; warn: (o: any, m?: string) => void }, ) { source.on('ready', () => { - const me = source.me(); - if (me) for (const c of this.conns) this.send(c, { t: 'ready', me, guilds: source.guilds() }); + for (const c of this.conns) void this.sendReady(c); + }); + source.on('guilds', () => { + for (const c of this.conns) void this.source.guildsFor(c.userId).then((guilds) => this.send(c, { t: 'guilds', guilds }), () => undefined); }); - source.on('guilds', () => this.broadcast({ t: 'guilds', guilds: source.guilds() })); source.on('voiceState', (e: BotVoiceEvent) => { - for (const c of this.conns) if (c.guildId === e.guildId) this.send(c, { t: 'voiceState', ...e }); + for (const c of this.conns) { + if (c.guildId !== e.guildId) continue; + // 이 유저가 볼 수 없는 채널은 "없는 곳"으로 가린다 (비공개 채널에 누가 있는지 새지 않게) + const vis = (ch: string | null) => (ch && this.source.canView(e.guildId, c.userId, ch) ? ch : null); + const oldChannelId = vis(e.oldChannelId); + const newChannelId = vis(e.newChannelId); + if (!oldChannelId && !newChannelId) continue; + this.send(c, { t: 'voiceState', guildId: e.guildId, member: e.member, oldChannelId, newChannelId, channel: newChannelId ? e.channel : null }); + } }); source.wants = (guildId) => [...this.conns].some((c) => c.guildId === guildId); source.on('command', (cmd: BotCommand, respond: (content: string) => void) => void this.onCommand(cmd).then(respond)); @@ -107,8 +128,7 @@ export class BotBroker { const c: Conn = { id: crypto.randomBytes(6).toString('hex'), ws, token: a.token, userId: a.userId, guildId: null, at: Date.now() }; this.conns.add(c); this.log.info({ user: a.userId, conn: c.id }, '겜녹이 봇 중계 연결'); - const me = this.source.me(); - if (me) this.send(c, { t: 'ready', me, guilds: this.source.guilds() }); + void this.sendReady(c); ws.on('message', (data, isBinary) => { if (isBinary || !this.conns.has(c)) return; let m: BotGwFromApp; @@ -139,12 +159,16 @@ export class BotBroker { } } + private async sendReady(c: Conn): Promise { + const me = this.source.me(); + if (!me) return; + const guilds = await this.source.guildsFor(c.userId).catch(() => []); + if (this.conns.has(c)) this.send(c, { t: 'ready', me, guilds }); + } + private send(c: Conn, m: BotGwToApp): void { if (c.ws.readyState === WebSocket.OPEN) c.ws.send(JSON.stringify(m)); } - private broadcast(m: BotGwToApp): void { - for (const c of this.conns) this.send(c, m); - } private adapter(guildId: string) { let a = this.adapters.get(guildId); @@ -167,18 +191,7 @@ export class BotBroker { private onMessage(c: Conn, m: BotGwFromApp): void { switch (m.t) { case 'watch': { - const snap = SNOWFLAKE.test(String(m.guildId)) ? this.source.snapshot(m.guildId) : null; - if (!snap) return; - c.guildId = m.guildId; - c.at = Date.now(); - this.send(c, { t: 'guild', ...snap }); - if (m.commands && !this.commandsDone.has(m.guildId)) { - this.commandsDone.add(m.guildId); - this.source.registerCommands(m.guildId).catch((e) => { - this.commandsDone.delete(m.guildId); - this.log.warn(e, '슬래시 명령 등록 실패'); - }); - } + void this.watch(c, m); return; } case 'voice': { @@ -187,7 +200,8 @@ export class BotBroker { const d = m.payload?.d; if (!g || m.guildId !== g || m.payload?.op !== 4 || d?.guild_id !== g) return; const ch = d.channel_id === null ? null : String(d.channel_id); - if (ch !== null && !this.source.isVoiceChannel(g, ch)) return; + // 이 유저가 직접 들어갈 수 있는 음성채널에만 봇을 부른다 (비공개 채널 · 권한 없는 채널 거절) + if (ch !== null && !this.source.canConnect(g, c.userId, ch)) return; const owner = this.owners.get(g); if (ch === null) { // 이미 다른 PC 가 가져간 봇을 이전 PC 가 빼지 못하게 @@ -207,7 +221,7 @@ export class BotBroker { } case 'req': { if (m.op !== 'members' || m.guildId !== c.guildId) return this.send(c, { t: 'res', id: m.id, ok: false, error: 'forbidden' }); - this.source.members(m.guildId).then( + this.source.members(m.guildId, c.userId).then( (data) => this.send(c, { t: 'res', id: m.id, ok: true, data }), (e) => this.send(c, { t: 'res', id: m.id, ok: false, error: String(e?.message ?? e) }), ); @@ -216,6 +230,26 @@ export class BotBroker { } } + /** 서버 지켜보기: 이 유저가 가입한 서버만, 이 유저가 볼 수 있는 채널만 보낸다 */ + private async watch(c: Conn, m: Extract): Promise { + const snap = SNOWFLAKE.test(String(m.guildId)) ? await this.source.snapshot(m.guildId, c.userId).catch(() => null) : null; + if (!this.conns.has(c)) return; + if (!snap) { + this.send(c, { t: 'watch_denied', guildId: String(m.guildId) }); + return; + } + c.guildId = m.guildId; + c.at = Date.now(); + this.send(c, { t: 'guild', ...snap }); + if (m.commands && !this.commandsDone.has(m.guildId)) { + this.commandsDone.add(m.guildId); + this.source.registerCommands(m.guildId).catch((e) => { + this.commandsDone.delete(m.guildId); + this.log.warn(e, '슬래시 명령 등록 실패'); + }); + } + } + /** 슬래시 명령을 맞는 앱으로 보내고 첫 응답을 돌려준다 */ private async onCommand(cmd: BotCommand): Promise { const here = [...this.conns].filter((c) => c.guildId === cmd.guildId).sort((a, b) => b.at - a.at); @@ -225,7 +259,15 @@ export class BotBroker { let targets: Conn[]; if (cmd.name === '녹음제외' || cmd.name === '녹음참여') targets = here; // 각 PC 기록에 모두 남긴다 else if (cmd.name === '녹음종료') targets = owner && here.includes(owner) ? [owner] : []; - else targets = [mine ?? (owner && here.includes(owner) ? owner : here[0])]; + else { + // 녹음시작: 명령한 사람의 음성채널에 그 PC 의 유저도 들어갈 수 있어야 한다 (비공개 채널에 남의 PC 가 봇을 부르지 않게) + const vc = cmd.voiceChannel; + const able = vc ? here.filter((c) => this.source.canConnect(cmd.guildId, c.userId, vc.id)) : here; + const pick = (c: Conn | undefined) => (c && able.includes(c) ? c : undefined); + const t = pick(mine) ?? pick(owner) ?? able[0]; + if (!t) return '이 음성채널에 들어갈 수 있는 겜녹이 앱이 없습니다.'; + targets = [t]; + } if (!targets.length) return '지금은 녹음 중이 아닙니다.'; const id = crypto.randomBytes(8).toString('hex'); const content = await new Promise((resolve) => { @@ -235,7 +277,8 @@ export class BotBroker { this.cmds.delete(id); resolve(v); }); - for (const c of targets) this.send(c, { t: 'cmd', id, ...cmd }); + // 그 PC 의 유저가 볼 수 없는 채널 이름은 보내지 않는다 + for (const c of targets) this.send(c, { t: 'cmd', id, ...cmd, voiceChannel: cmd.voiceChannel && this.source.canView(cmd.guildId, c.userId, cmd.voiceChannel.id) ? cmd.voiceChannel : null }); }); this.cmds.delete(id); return content ?? '겜녹이 앱이 응답하지 않습니다. 잠시 뒤 다시 시도해 주세요.'; diff --git a/site/server/src/discord-source.ts b/site/server/src/discord-source.ts index 8bdcd2c..96f540d 100644 --- a/site/server/src/discord-source.ts +++ b/site/server/src/discord-source.ts @@ -1,6 +1,6 @@ // 서버의 겜녹이 봇 디스코드 연결 (discord.js). bot-broker.ts 의 BotSource 구현 import { EventEmitter } from 'node:events'; -import { ChannelType, Client, Events, GatewayIntentBits, MessageFlags, type Guild, type GuildMember, type VoiceBasedChannel } from 'discord.js'; +import { ChannelType, Client, Events, GatewayIntentBits, MessageFlags, PermissionFlagsBits, type Guild, type GuildMember, type VoiceBasedChannel } from 'discord.js'; import type { BotGwChannel, BotGwGuild, BotGwMember } from '@gvr/shared'; import type { BotCommand, BotSource, BotVoiceEvent } from './bot-broker.js'; @@ -70,28 +70,45 @@ export class DiscordSource extends EventEmitter implements BotSource { const u = this.client.isReady() ? this.client.user : null; return u ? { id: u.id, name: u.username, avatar: u.displayAvatarURL({ size: 128 }), bot: true } : null; } - guilds(): BotGwGuild[] { - return [...this.client.guilds.cache.values()].map(guild); + /** 서버 멤버 (캐시에 없으면 디스코드에서 받아 온다). 멤버가 아니면 null */ + private async memberOf(g: Guild, userId: string): Promise { + if (!/^\d{17,20}$/.test(userId)) return null; + return g.members.cache.get(userId) ?? (await g.members.fetch(userId).catch(() => null)); } - snapshot(guildId: string) { + private perms(guildId: string, userId: string, channelId: string) { const g = this.client.guilds.cache.get(guildId); - if (!g) return null; + const m = g?.members.cache.get(userId); + const ch = g?.channels.cache.get(channelId); + return m && ch && 'permissionsFor' in ch ? { ch, p: ch.permissionsFor(m) } : null; + } + async guildsFor(userId: string): Promise { + const out: BotGwGuild[] = []; + for (const g of this.client.guilds.cache.values()) if (await this.memberOf(g, userId)) out.push(guild(g)); + return out; + } + async snapshot(guildId: string, userId: string) { + const g = this.client.guilds.cache.get(guildId); + const m = g ? await this.memberOf(g, userId) : null; + if (!g || !m) return null; const channels: BotGwChannel[] = []; const voice: { member: BotGwMember; channelId: string }[] = []; for (const ch of g.channels.cache.values()) { - if (!isVoice(ch)) continue; + if (!isVoice(ch) || !ch.permissionsFor(m).has(PermissionFlagsBits.ViewChannel)) continue; channels.push({ id: ch.id, name: ch.name }); - for (const m of ch.members.values()) voice.push({ member: member(m), channelId: ch.id }); + for (const vm of ch.members.values()) voice.push({ member: member(vm), channelId: ch.id }); } return { guild: guild(g), channels, voice }; } - isVoiceChannel(guildId: string, channelId: string): boolean { - const ch = this.client.guilds.cache.get(guildId)?.channels.cache.get(channelId); - return isVoice(ch); + canView(guildId: string, userId: string, channelId: string): boolean { + return !!this.perms(guildId, userId, channelId)?.p?.has(PermissionFlagsBits.ViewChannel); } - async members(guildId: string): Promise { + canConnect(guildId: string, userId: string, channelId: string): boolean { + const r = this.perms(guildId, userId, channelId); + return !!r && isVoice(r.ch) && !!r.p?.has([PermissionFlagsBits.ViewChannel, PermissionFlagsBits.Connect]); + } + async members(guildId: string, userId: string): Promise { const g = this.client.guilds.cache.get(guildId); - if (!g) return []; + if (!g || !(await this.memberOf(g, userId))) throw new Error('forbidden'); const ms = await g.members.fetch().catch(() => g.members.cache); return [...ms.values()].map(member); }