Skip to content

Commit 2feb5c8

Browse files
authored
tls: normalize session buffer views
Client sessions can be supplied as ArrayBuffer views, but session state checks only recognize Buffers. Normalize views to Buffers before applying those checks, preserving their byte offset and length. This hardens session reuse handling and keeps tagged sessions reusable when stored as typed arrays. Assisted-by: Codex Signed-off-by: Matteo Collina <hello@matteocollina.com> PR-URL: #67251 Reviewed-By: Robert Nagy <ronagy@icloud.com> Reviewed-By: James M Snell <jasnell@gmail.com> Reviewed-By: Filip Skokan <panva.ip@gmail.com> Reviewed-By: Gürgün Dayıoğlu <hey@gurgun.day>
1 parent d0d82d9 commit 2feb5c8

2 files changed

Lines changed: 130 additions & 0 deletions

File tree

‎lib/internal/tls/wrap.js‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -175,6 +175,9 @@ function getSessionForReuse(session, options) {
175175
if (options?.isServer)
176176
return session;
177177

178+
if (!Buffer.isBuffer(session) && isArrayBufferView(session))
179+
session = Buffer.from(session.buffer, session.byteOffset, session.byteLength);
180+
178181
const wrappedSession = unwrapSessionState(session);
179182
if (wrappedSession !== undefined) {
180183
const servername = getSessionServerIdentity(options);
Lines changed: 127 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,127 @@
1+
'use strict';
2+
const common = require('../common');
3+
if (!common.hasCrypto)
4+
common.skip('missing crypto');
5+
6+
const assert = require('assert');
7+
const { once } = require('events');
8+
const tls = require('tls');
9+
const fixtures = require('../common/fixtures');
10+
11+
async function connect(options, useSetter = false, captureSession = false) {
12+
const { session, ...connectOptions } = options;
13+
const socket = tls.connect(useSetter ? connectOptions : options);
14+
const closed = new Promise((resolve) => {
15+
socket.once('close', common.mustCall(resolve));
16+
});
17+
if (useSetter)
18+
socket.setSession(session);
19+
const sessionPromise = captureSession ? once(socket, 'session') : undefined;
20+
socket.resume();
21+
22+
try {
23+
await once(socket, 'secureConnect');
24+
const result = {
25+
reused: socket.isSessionReused(),
26+
authorized: socket.authorized,
27+
session: captureSession ? (await sessionPromise)[0] : undefined,
28+
};
29+
await closed;
30+
return result;
31+
} finally {
32+
socket.destroy();
33+
}
34+
}
35+
36+
function offsetView(session, View) {
37+
// Keep unrelated bytes on both sides to check that only the view is used.
38+
const buffer = new ArrayBuffer(session.length + 16);
39+
new Uint8Array(buffer).fill(0xff);
40+
new Uint8Array(buffer, 8, session.length).set(session);
41+
return new View(buffer, 8, session.length);
42+
}
43+
44+
async function testVersion(version) {
45+
const server = tls.createServer({
46+
key: fixtures.readKey('agent1-key.pem'),
47+
cert: fixtures.readKey('agent1-cert.pem'),
48+
minVersion: version,
49+
maxVersion: version,
50+
}, (socket) => socket.end('ok'));
51+
server.listen(0);
52+
await once(server, 'listening');
53+
54+
try {
55+
const options = {
56+
port: server.address().port,
57+
host: '127.0.0.1',
58+
servername: 'agent1',
59+
ca: fixtures.readKey('ca1-cert.pem'),
60+
minVersion: version,
61+
maxVersion: version,
62+
};
63+
const first = await connect(options, false, true);
64+
assert.strictEqual(first.authorized, true);
65+
assert.strictEqual(first.reused, false);
66+
67+
const tagged = first.session;
68+
const prefix = Buffer.from('\0nodejs:tls:session:1\0');
69+
assert.deepStrictEqual(tagged.subarray(0, prefix.length), prefix);
70+
const raw = tagged.subarray(
71+
prefix.length + 2 + tagged.readUInt16BE(prefix.length));
72+
73+
const conversions = [
74+
(session) => session,
75+
(session) => session.toString('latin1'),
76+
(session) => new Uint8Array(session),
77+
(session) => new Uint8ClampedArray(session),
78+
(session) => new Int8Array(session),
79+
(session) => offsetView(session, Uint8Array),
80+
(session) => offsetView(session, DataView),
81+
];
82+
83+
for (const convert of conversions) {
84+
for (const useSetter of [false, true]) {
85+
// Untagged sessions must cause a full handshake on verified clients.
86+
const fresh = await connect({
87+
...options,
88+
session: convert(raw),
89+
}, useSetter);
90+
assert.strictEqual(fresh.authorized, true);
91+
assert.strictEqual(fresh.reused, false);
92+
93+
// A tagged session still resumes for its authenticated host.
94+
const resumed = await connect({
95+
...options,
96+
session: convert(tagged),
97+
}, useSetter);
98+
assert.strictEqual(resumed.authorized, true);
99+
assert.strictEqual(resumed.reused, true);
100+
101+
for (const session of [raw, tagged]) {
102+
await assert.rejects(connect({
103+
...options,
104+
servername: 'bank.example',
105+
session: convert(session),
106+
}, useSetter), { code: 'ERR_TLS_CERT_ALTNAME_INVALID' });
107+
}
108+
109+
// Raw sessions remain usable when verification is explicitly disabled.
110+
const unverified = await connect({
111+
...options,
112+
session: convert(raw),
113+
rejectUnauthorized: false,
114+
}, useSetter);
115+
assert.strictEqual(unverified.reused, true);
116+
}
117+
}
118+
} finally {
119+
server.close();
120+
await once(server, 'close');
121+
}
122+
}
123+
124+
(async () => {
125+
await testVersion('TLSv1.2');
126+
await testVersion('TLSv1.3');
127+
})().then(common.mustCall());

0 commit comments

Comments
 (0)