').slice(1);
+}
+
+// A GRP_TXT packet ChannelDecrypt can really verify and decrypt: AES-128-ECB
+// under SHA-256(channelName)[:16], 2-byte HMAC-SHA256 MAC over the ciphertext
+// with key + 16 zero bytes. Same construction as buildEncryptedGrpTxt in
+// test-channel-live-decrypt.js, which runs on require and so cannot be imported.
+function encryptedGrpTxt(channelName, sender, message) {
+ const key = createHash('sha256').update(channelName).digest().slice(0, 16);
+ const channelHash = createHash('sha256').update(key).digest()[0];
+ const text = `${sender}: ${message}`;
+ const pt = Buffer.alloc(Math.ceil((5 + Buffer.byteLength(text, 'utf8') + 1) / 16) * 16);
+ pt.writeUInt32LE(1788256800, 0);
+ pt.write(text, 5, 'utf8');
+ const cipher = createCipheriv('aes-128-ecb', key, null);
+ cipher.setAutoPadding(false);
+ const ct = Buffer.concat([cipher.update(pt), cipher.final()]);
+ const mac = createHmac('sha256', Buffer.concat([key, Buffer.alloc(16)])).update(ct).digest().slice(0, 2);
+ return {
+ keyHex: key.toString('hex'),
+ channelHash,
+ decodedJson: JSON.stringify({ type: 'GRP_TXT', channelHash, mac: mac.toString('hex'), encryptedData: ct.toString('hex') }),
+ };
+}
+
+// Three encrypted packets on one channel, one per scope_name state.
+function encryptedChannelPackets(channelName) {
+ const rows = [
+ { sender: 'Alice', text: 'secret matched', scope: '#belgium' },
+ { sender: 'Bob', text: 'secret unmatched', scope: '' },
+ { sender: 'Carol', text: 'secret plain', scope: null },
+ ];
+ let fx;
+ const packets = rows.map((r, i) => {
+ fx = encryptedGrpTxt(channelName, r.sender, r.text);
+ return { id: 10 + i, hash: 'e' + i, first_seen: `2026-09-01T10:0${i}:00Z`, scope_name: r.scope, decoded_json: fx.decodedJson };
+ });
+ return { packets, keyHex: fx.keyHex, channelHash: fx.channelHash, lastTs: packets[packets.length - 1].first_seen };
+}
+
+function packetsApi(packets) {
+ return listApi((path) => Promise.resolve(path.indexOf('/packets?') === 0 ? { packets } : {}));
+}
+
+const SCOPE_CHIP =/
]*>([^<]*)<\/span>/;
+const UNKNOWN_CHIP = /]*>unknown scope<\/span>/;
+
+console.log('\n=== #1851: channel message region scope ===');
+
+test('REST messages render a scope chip per state: name, unknown, none', async () => {
+ const { ctx, dom } = makeChannelsSandbox(listApi((path) => {
+ if (path.indexOf('/channels/general/messages') === 0) {
+ return Promise.resolve({ messages: [
+ { sender: 'Alice', text: 'matched', timestamp: '2026-09-01T10:00:00Z', packetHash: 'h1', scope_name: '#belgium' },
+ { sender: 'Bob', text: 'unmatched', timestamp: '2026-09-01T10:01:00Z', packetHash: 'h2', scope_name: '' },
+ { sender: 'Carol', text: 'plain flood', timestamp: '2026-09-01T10:02:00Z', packetHash: 'h3', scope_name: null },
+ { sender: 'Dave', text: 'older server', timestamp: '2026-09-01T10:03:00Z', packetHash: 'h4' },
+ ] });
+ }
+ return Promise.resolve({});
+ }));
+ for (let i = 0; i < 10; i++) await Promise.resolve();
+ await ctx.window._channelsSelectChannelForTest('general');
+ const chunks = messageChunks(dom.chMessages.innerHTML);
+ assert.strictEqual(chunks.length, 4, 'expected 4 rendered messages');
+
+ const named = chunks[0].match(SCOPE_CHIP);
+ assert.ok(named, 'matched-region message must render a scope chip');
+ assert.strictEqual(named[1], '#belgium');
+ assert.ok(!UNKNOWN_CHIP.test(chunks[0]), 'matched-region message must not say unknown');
+
+ assert.ok(UNKNOWN_CHIP.test(chunks[1]), "scope_name '' must render the unknown-scope chip");
+ assert.ok(!SCOPE_CHIP.test(chunks[1]), "scope_name '' must not render a named chip");
+ // '' is stored both when no region key matched and when several matched
+ // with no operator-configured winner (cmd/ingestor/region_keys.go match),
+ // so the tooltip must not claim that no key matched.
+ const title = (chunks[1].match(/ch-msg-scope" title="([^"]*)"/) || [])[1];
+ assert.strictEqual(title, 'Sent with a region scope that could not be matched to a single region on this instance');
+
+ assert.ok(!/ch-msg-scope/.test(chunks[2]), 'scope_name null must render no chip');
+ assert.ok(!/ch-msg-scope/.test(chunks[3]), 'a message without scope_name must render no chip');
+});
+
+test('scope name is escaped before it reaches innerHTML', async () => {
+ const { ctx, dom } = makeChannelsSandbox(listApi((path) => {
+ if (path.indexOf('/channels/general/messages') === 0) {
+ return Promise.resolve({ messages: [
+ { sender: 'Eve', text: 'x', timestamp: '2026-09-01T10:00:00Z', packetHash: 'h1', scope_name: '
' },
+ ] });
+ }
+ return Promise.resolve({});
+ }));
+ for (let i = 0; i < 10; i++) await Promise.resolve();
+ await ctx.window._channelsSelectChannelForTest('general');
+ const html = dom.chMessages.innerHTML;
+ assert.ok(!html.includes(' {
+ const { ctx, dom } = makeChannelsSandbox(listApi(() => Promise.resolve({ messages: [] })));
+ ctx.window._channelsSetStateForTest({
+ selectedHash: 'general',
+ channels: [{ hash: 'general', name: 'general', messageCount: 0, lastActivityMs: 0 }],
+ messages: [],
+ });
+ const packet = (hash, text, scope) => ({
+ type: 'packet',
+ data: {
+ hash, scope_name: scope,
+ decoded: { header: { payloadTypeName: 'GRP_TXT' }, payload: { channel: 'general', text } },
+ packet: { hash, observer_name: 'Obs', scope_name: scope },
+ },
+ });
+ ctx.window._channelsProcessWSBatchForTest([
+ packet('w1', 'Alice: live matched', '#belgium'),
+ packet('w2', 'Bob: live unmatched', ''),
+ packet('w3', 'Carol: live plain', null),
+ ], null);
+ const state = ctx.window._channelsGetStateForTest();
+ assert.deepStrictEqual(Array.from(state.messages, (m) => m.scope_name), ['#belgium', '', null]);
+ const chunks = messageChunks(dom.chMessages.innerHTML);
+ assert.strictEqual(chunks.length, 3, 'expected 3 rendered messages');
+ assert.strictEqual((chunks[0].match(SCOPE_CHIP) || [])[1], '#belgium');
+ assert.ok(UNKNOWN_CHIP.test(chunks[1]), 'live message with scope_name "" must render the unknown chip');
+ assert.ok(!/ch-msg-scope/.test(chunks[2]), 'live message with scope_name null must render no chip');
+});
+
+test('client-side decrypted channel keeps scope_name from the /api/packets row', async () => {
+ const { ctx, dom } = makeChannelsSandbox(listApi((path) => {
+ if (path.indexOf('/packets?') === 0) {
+ return Promise.resolve({ packets: [
+ { id: 1, hash: 'd1', first_seen: '2026-09-01T10:00:00Z', scope_name: '#belgium',
+ decoded_json: JSON.stringify({ type: 'CHAN', channel: '#priv', sender: 'Alice', text: 'Alice: decrypted' }) },
+ { id: 2, hash: 'd2', first_seen: '2026-09-01T10:01:00Z', scope_name: '',
+ decoded_json: JSON.stringify({ type: 'CHAN', channel: '#priv', sender: 'Bob', text: 'Bob: decrypted' }) },
+ ] });
+ }
+ return Promise.resolve({});
+ }));
+ for (let i = 0; i < 10; i++) await Promise.resolve();
+ await ctx.window._channelsSelectChannelForTest('user:#priv', {
+ userKey: '00112233445566778899aabbccddeeff', channelHashByte: 1, channelName: '#priv',
+ });
+ const state = ctx.window._channelsGetStateForTest();
+ assert.deepStrictEqual(Array.from(state.messages, (m) => m.scope_name), ['#belgium', '']);
+ const chunks = messageChunks(dom.chMessages.innerHTML);
+ assert.strictEqual((chunks[0].match(SCOPE_CHIP) || [])[1], '#belgium');
+ assert.ok(UNKNOWN_CHIP.test(chunks[1]), 'decrypted message with scope_name "" must render the unknown chip');
+});
+
+test('packets decrypted with the stored key keep scope_name from the /api/packets row', async () => {
+ const fx = encryptedChannelPackets('#secret');
+ const { ctx, dom } = makeChannelsSandbox(packetsApi(fx.packets));
+ for (let i = 0; i < 10; i++) await Promise.resolve();
+ await ctx.window._channelsSelectChannelForTest('user:#secret', {
+ userKey: fx.keyHex, channelHashByte: fx.channelHash, channelName: '#secret',
+ });
+ const state = ctx.window._channelsGetStateForTest();
+ // Sender and text only exist after a MAC check and AES decrypt, so these
+ // messages came through the encrypted branch, not the already-decrypted one.
+ assert.deepStrictEqual(Array.from(state.messages, (m) => m.sender + ': ' + m.text),
+ ['Alice: secret matched', 'Bob: secret unmatched', 'Carol: secret plain']);
+ assert.deepStrictEqual(Array.from(state.messages, (m) => m.scope_name), ['#belgium', '', null]);
+ const chunks = messageChunks(dom.chMessages.innerHTML);
+ assert.strictEqual(chunks.length, 3, 'expected 3 rendered messages');
+ assert.strictEqual((chunks[0].match(SCOPE_CHIP) || [])[1], '#belgium');
+ assert.ok(UNKNOWN_CHIP.test(chunks[1]), 'decrypted message with scope_name "" must render the unknown chip');
+ assert.ok(!/ch-msg-scope/.test(chunks[2]), 'decrypted message with scope_name null must render no chip');
+});
+
+test('a decrypt cache written before scope_name existed is decrypted again', async () => {
+ const fx = encryptedChannelPackets('#secret');
+ const { ctx } = makeChannelsSandbox(packetsApi(fx.packets));
+ // Same candidate count and last timestamp as the API returns, so without the
+ // missing key the delta path would find nothing new and serve this cache.
+ ctx.ChannelDecrypt.setCache('#secret', fx.packets.map((p, i) => ({
+ sender: 'Old', text: 'cached ' + i, timestamp: p.first_seen, packetHash: p.hash, packetId: p.id,
+ hops: 0, snr: null, observers: [], repeats: 1,
+ })), fx.lastTs, fx.packets.length);
+ for (let i = 0; i < 10; i++) await Promise.resolve();
+ await ctx.window._channelsSelectChannelForTest('user:#secret', {
+ userKey: fx.keyHex, channelHashByte: fx.channelHash, channelName: '#secret',
+ });
+ const state = ctx.window._channelsGetStateForTest();
+ assert.deepStrictEqual(Array.from(state.messages, (m) => m.scope_name), ['#belgium', '', null]);
+ assert.deepStrictEqual(Array.from(ctx.ChannelDecrypt.getCache('#secret').messages, (m) => m.scope_name),
+ ['#belgium', '', null], 'the rewritten cache must carry scope_name');
+});
+
+test('a decrypt cache that already carries scope_name is still served by the delta path', async () => {
+ const fx = encryptedChannelPackets('#secret');
+ const { ctx } = makeChannelsSandbox(packetsApi(fx.packets));
+ ctx.ChannelDecrypt.setCache('#secret', fx.packets.map((p, i) => ({
+ sender: 'Old', text: 'cached ' + i, timestamp: p.first_seen, packetHash: p.hash, packetId: p.id,
+ hops: 0, snr: null, observers: [], scope_name: null, repeats: 1,
+ })), fx.lastTs, fx.packets.length);
+ for (let i = 0; i < 10; i++) await Promise.resolve();
+ await ctx.window._channelsSelectChannelForTest('user:#secret', {
+ userKey: fx.keyHex, channelHashByte: fx.channelHash, channelName: '#secret',
+ });
+ const state = ctx.window._channelsGetStateForTest();
+ assert.deepStrictEqual(Array.from(state.messages, (m) => m.text), ['cached 0', 'cached 1', 'cached 2']);
+});
+
+Promise.all(pending).then(() => {
+ console.log(`\n${passed} passed, ${failed} failed`);
+ if (failed > 0) process.exit(1);
+});