postgrejs 2.23.1 → 3.0.2

package/protocol/backend.js

@@ -23,35 +23,70 @@ const ErrorFieldTypes = {
     R: 'routine',
 };
 export class Backend {
-    _buf;
+    _headerBuf = Buffer.allocUnsafe(HEADER_LENGTH);
+    _headerFilled = 0;
+    _code;
+    _len = 0;
+    _bodyBuf;
+    _bodyFilled = 0;
     reset() {
-        this._buf = undefined;
+        this._headerFilled = 0;
+        this._code = undefined;
+        this._bodyBuf = undefined;
+        this._bodyFilled = 0;
     }
     parse(data, callback) {
-        if (this._buf) {
-            data = Buffer.concat([this._buf, data]);
-            this._buf = undefined;
-        }
-        const io = new BufferReader(data);
-        let offsetBookmark;
-        while (io.length - io.offset >= HEADER_LENGTH) {
-            offsetBookmark = io.offset;
-            const code = io.readUInt8();
-            const len = io.readUInt32BE();
-            // Check if frame data not received yet
-            if (io.length - io.offset < len - 4) {
-                io.offset = offsetBookmark;
-                this._buf = io.readBuffer();
-                return;
+        const dataLen = data.length;
+        let pos = 0;
+        while (pos < dataLen) {
+            if (this._headerFilled === 0 &&
+                !this._bodyBuf &&
+                dataLen - pos >= HEADER_LENGTH) {
+                const code = data.readUInt8(pos);
+                const len = data.readUInt32BE(pos + 1);
+                const bodyStart = pos + HEADER_LENGTH;
+                const bodyEnd = bodyStart + (len - 4);
+                if (bodyEnd <= dataLen) {
+                    const io = new BufferReader(data.subarray(bodyStart, bodyEnd));
+                    const parser = MessageParsers[code];
+                    const v = parser && parser(io, code, len);
+                    callback(code, v);
+                    pos = bodyEnd;
+                    continue;
+                }
+            }
+            if (!this._bodyBuf) {
+                const need = HEADER_LENGTH - this._headerFilled;
+                const take = Math.min(need, dataLen - pos);
+                data.copy(this._headerBuf, this._headerFilled, pos, pos + take);
+                this._headerFilled += take;
+                pos += take;
+                if (this._headerFilled < HEADER_LENGTH)
+                    return; // header not complete yet
+                this._code = this._headerBuf.readUInt8(0);
+                this._len = this._headerBuf.readUInt32BE(1);
+                this._bodyBuf = Buffer.allocUnsafe(this._len - 4);
+                this._bodyFilled = 0;
+            }
+            const need = this._bodyBuf.length - this._bodyFilled;
+            const take = Math.min(need, dataLen - pos);
+            if (take > 0) {
+                data.copy(this._bodyBuf, this._bodyFilled, pos, pos + take);
+                this._bodyFilled += take;
+                pos += take;
             }
-            const parser = MessageParsers[code];
-            const v = parser && parser(io, code, len);
-            callback(code, v);
-            // Set offset to next message
-            io.offset = offsetBookmark + len + 1;
+            if (this._bodyFilled < this._bodyBuf.length)
+                return; // body not complete yet
+            const io = new BufferReader(this._bodyBuf);
+            const parser = MessageParsers[this._code];
+            const v = parser && parser(io, this._code, this._len);
+            callback(this._code, v);
+            // Reset reassembly state for the next message.
+            this._headerFilled = 0;
+            this._code = undefined;
+            this._bodyBuf = undefined;
+            this._bodyFilled = 0;
         }
-        if (io.offset < io.length)
-            this._buf = io.readBuffer(io.length - io.offset);
     }
 }
 const MessageParsers = {
@@ -158,7 +193,9 @@ function parseCopyResponse(io) {
     };
     if (out.columnCount) {
         out.columnFormats = [];
-        for (let i = 0; i < out.columnCount; i++) {
+        const l = out.columnCount;
+        let i;
+        for (i = 0; i < l; i++) {
             out.columnFormats.push(io.readUInt16BE() === 0
                 ? Protocol.DataFormat.text
                 : Protocol.DataFormat.binary);
@@ -166,24 +203,10 @@ function parseCopyResponse(io) {
     }
     return out;
 }
-function parseDataRow(io) {
-    const out = {
-        columnCount: io.readUInt16BE(),
-    };
-    if (out.columnCount) {
-        out.columns = [];
-        for (let i = 0; i < out.columnCount; i++) {
-            // The length of the column value, in bytes (this count does not include itself).
-            // Can be zero. As a special case, -1 indicates a NULL column value.
-            // No value bytes follow in the NULL case.
-            const l = io.readInt32BE();
-            if (l < 0)
-                out.columns.push(null);
-            else
-                out.columns.push(io.readBuffer(l));
-        }
-    }
-    return out;
+function parseDataRow(io, code, len) {
+    const columnCount = io.readUInt16BE();
+    const data = io.readBuffer(len - 6);
+    return { columnCount, data };
 }
 function parseErrorResponse(io) {
     const out = {};
@@ -217,10 +240,12 @@ function parseNegotiateProtocolVersion(io) {
 }
 function parseParameterDescription(io) {
     const out = {
-        parameterCount: io.readUInt32BE(),
+        parameterCount: io.readUInt16BE(),
         parameterIds: [],
     };
-    for (let i = 0; i < out.parameterCount; i++) {
+    const l = out.parameterCount;
+    let i;
+    for (i = 0; i < l; i++) {
         out.parameterIds.push(io.readUInt32BE());
     }
     return out;

package/protocol/buffer-reader.d.ts

@@ -11,7 +11,5 @@ export declare class BufferReader {
     readCString(encoding?: BufferEncoding): string;
     readLString(len: number, encoding?: BufferEncoding): string | null;
     readBuffer(len?: number): Buffer;
-    moveBy(n: number): this;
-    moveTo(pos: number): this;
     private _checkReadable;
 }

package/protocol/buffer-reader.js

@@ -39,6 +39,8 @@ export class BufferReader {
     }
     readCString(encoding) {
         const idx = this.buffer.indexOf(0, this.offset);
+        if (idx === -1)
+            throw new Error('Eof in buffer detected (readCString)');
         const v = this.buffer.toString(encoding, this.offset, idx);
         this.offset = idx + 1;
         return v;
@@ -55,19 +57,10 @@ export class BufferReader {
         if (len)
             this._checkReadable(len);
         const end = len !== undefined ? this.offset + len : this.length;
-        const buf = this.buffer.slice(this.offset, end);
+        const buf = this.buffer.subarray(this.offset, end);
         this.offset = end;
         return buf;
     }
-    moveBy(n) {
-        return this.moveTo(this.offset + n);
-    }
-    moveTo(pos) {
-        if (pos >= this.length)
-            throw new Error('Eof in buffer detected');
-        this.offset = pos;
-        return this;
-    }
     _checkReadable(size) {
         if (this.offset + size - 1 >= this.length)
             throw new Error('Eof in buffer detected');

package/protocol/cert-signature.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Finds the hash a certificate was signed with, which is the hash
+ * `tls-server-end-point` channel binding has to use (RFC 5929).
+ *
+ * Node exposes a certificate's SHA-1, SHA-256 and SHA-512 fingerprints but
+ * not the algorithm it was signed with, and X509Certificate.toLegacyObject()
+ * does not carry it either - so the DER has to be read. Only as far as the
+ * signature algorithm's OID: a Certificate is a SEQUENCE of tbsCertificate,
+ * signatureAlgorithm and signatureValue, so this skips the first and reads
+ * the OID out of the second.
+ */
+export declare function signatureHashOfCertificate(der: Buffer): string;

package/protocol/cert-signature.js

@@ -0,0 +1,114 @@
+/**
+ * Finds the hash a certificate was signed with, which is the hash
+ * `tls-server-end-point` channel binding has to use (RFC 5929).
+ *
+ * Node exposes a certificate's SHA-1, SHA-256 and SHA-512 fingerprints but
+ * not the algorithm it was signed with, and X509Certificate.toLegacyObject()
+ * does not carry it either - so the DER has to be read. Only as far as the
+ * signature algorithm's OID: a Certificate is a SEQUENCE of tbsCertificate,
+ * signatureAlgorithm and signatureValue, so this skips the first and reads
+ * the OID out of the second.
+ */
+function readLength(data, index) {
+    let length = data[index++];
+    if (length < 0x80)
+        return { length, index };
+    const lengthBytes = length & 0x7f;
+    if (lengthBytes > 4)
+        throw certError('length field too large', data);
+    length = 0;
+    for (let i = 0; i < lengthBytes; i++)
+        length = (length << 8) | data[index++];
+    return { length, index };
+}
+function expectSequence(data, index) {
+    if (data[index++] !== 0x30)
+        throw certError('expected a SEQUENCE', data);
+    return { index: readLength(data, index).index };
+}
+function readOID(data, index) {
+    if (data[index++] !== 0x06)
+        throw certError('expected an OID', data);
+    const { length, index: start } = readLength(data, index);
+    index = start;
+    const end = index + length;
+    // The first byte packs the first two arcs as 40 * a + b.
+    const first = data[index++];
+    let oid = Math.floor(first / 40) + '.' + (first % 40);
+    let value = 0;
+    while (index < end) {
+        const byte = data[index++];
+        value = (value << 7) | (byte & 0x7f);
+        // The high bit marks a continuation, so an arc ends when it is clear.
+        if (!(byte & 0x80)) {
+            oid += '.' + value;
+            value = 0;
+        }
+    }
+    return { oid, index };
+}
+function certError(message, data) {
+    return new Error(`Channel binding: ${message} while reading the server certificate (${data.length} bytes)`);
+}
+// OID -> the Node hash name to feed createHash().
+const SIGNATURE_HASHES = {
+    // RSA
+    '1.2.840.113549.1.1.4': 'md5',
+    '1.2.840.113549.1.1.5': 'sha1',
+    '1.2.840.113549.1.1.11': 'sha256',
+    '1.2.840.113549.1.1.12': 'sha384',
+    '1.2.840.113549.1.1.13': 'sha512',
+    '1.2.840.113549.1.1.14': 'sha224',
+    '1.2.840.113549.1.1.15': 'sha512-224',
+    '1.2.840.113549.1.1.16': 'sha512-256',
+    // ECDSA
+    '1.2.840.10045.4.1': 'sha1',
+    '1.2.840.10045.4.3.1': 'sha224',
+    '1.2.840.10045.4.3.2': 'sha256',
+    '1.2.840.10045.4.3.3': 'sha384',
+    '1.2.840.10045.4.3.4': 'sha512',
+    // Ed25519, whose signature hashes with SHA-512.
+    '1.3.101.110': 'sha512',
+    '1.3.101.112': 'sha512',
+};
+// RSASSA-PSS names its hash separately, in the algorithm parameters.
+const PSS_HASHES = {
+    '1.2.840.113549.2.5': 'md5',
+    '1.3.14.3.2.26': 'sha1',
+    '2.16.840.1.101.3.4.2.1': 'sha256',
+    '2.16.840.1.101.3.4.2.2': 'sha384',
+    '2.16.840.1.101.3.4.2.3': 'sha512',
+};
+export function signatureHashOfCertificate(der) {
+    let index = expectSequence(der, 0).index; // Certificate
+    const tbs = readLength(der, index + 1); // tbsCertificate's own header
+    if (der[index] !== 0x30)
+        throw certError('expected tbsCertificate', der);
+    index = tbs.index + tbs.length; // skip it whole
+    index = expectSequence(der, index).index; // AlgorithmIdentifier
+    const { oid, index: afterOID } = readOID(der, index);
+    if (oid === '1.2.840.113549.1.1.10') {
+        // RSASSA-PSS: parameters SEQUENCE, then [0] holding the hash algorithm.
+        let i = expectSequence(der, afterOID).index;
+        if (der[i++] !== 0xa0)
+            throw certError('expected the PSS hash tag', der);
+        i = readLength(der, i).index;
+        i = expectSequence(der, i).index;
+        const { oid: hashOID } = readOID(der, i);
+        const hash = PSS_HASHES[hashOID];
+        if (!hash)
+            throw certError(`unknown PSS hash OID ${hashOID}`, der);
+        return upgradeWeak(hash);
+    }
+    const hash = SIGNATURE_HASHES[oid];
+    if (!hash) {
+        if (oid === '1.3.101.111' || oid === '1.3.101.113')
+            throw certError('Ed448 certificates are not supported by PostgreSQL', der);
+        throw certError(`unknown signature algorithm OID ${oid}`, der);
+    }
+    return upgradeWeak(hash);
+}
+/** RFC 5929: a certificate signed with MD5 or SHA-1 binds with SHA-256. */
+function upgradeWeak(hash) {
+    return hash === 'md5' || hash === 'sha1' ? 'sha256' : hash;
+}

package/protocol/frontend.d.ts

@@ -43,6 +43,13 @@ export declare class Frontend {
     constructor(options?: FrontendOptions);
     getSSLRequestMessage(): Buffer;
     getStartupMessage(args: Frontend.StartupMessageArgs): Buffer;
+    /**
+     * Asks the server to cancel whatever the given session is currently
+     * running. Sent on its own fresh connection - a backend busy with a query
+     * is not reading its own socket, which is the whole reason this cannot go
+     * down the normal one.
+     */
+    getCancelRequestMessage(processID: number, secretKey: number): Buffer;
     getPasswordMessage(password: string): Buffer;
     getSASLMessage(sasl: SASL.Session): Buffer;
     getSASLFinalMessage(session: SASL.Session): Buffer;
@@ -52,6 +59,15 @@ export declare class Frontend {
     getExecuteMessage(args: Frontend.ExecuteMessageArgs): Buffer;
     getCloseMessage(args: Frontend.CloseMessageArgs): Buffer;
     getQueryMessage(sql: string): Buffer;
+    /**
+     * Returns the CopyData header and the caller's payload as two buffers
+     * rather than one, so a bulk import never copies the caller's bytes.
+     * PgSocket writes an array of buffers as a single corked write anyway,
+     * so this costs nothing on the wire.
+     */
+    getCopyDataMessage(data: Buffer): Buffer[];
+    getCopyDoneMessage(): Buffer;
+    getCopyFailMessage(message: string): Buffer;
     getFlushMessage(): Buffer;
     getTerminateMessage(): Buffer;
     getSyncMessage(): Buffer;

package/protocol/frontend.js

@@ -26,6 +26,13 @@ const StaticSyncBuffer = Buffer.from([
     0x00,
     0x04,
 ]);
+const StaticCopyDoneBuffer = Buffer.from([
+    Protocol.FrontendMessageCode.CopyDone,
+    0x00,
+    0x00,
+    0x00,
+    0x04,
+]);
 export class Frontend {
     _io;
     constructor(options) {
@@ -45,7 +52,12 @@ export class Frontend {
             .writeInt32BE(0) // Preserve length
             .writeInt16BE(Protocol.VERSION_MAJOR)
             .writeInt16BE(Protocol.VERSION_MINOR);
-        for (const [k, v] of Object.entries(args)) {
+        const entries = Object.entries(args);
+        const l = entries.length;
+        let k;
+        let v;
+        for (let i = 0; i < l; i++) {
+            [k, v] = entries[i];
             if (k !== 'client_encoding')
                 io.writeCString(k, 'utf8').writeCString(v, 'utf8');
         }
@@ -54,6 +66,22 @@ export class Frontend {
             .writeUInt8(0);
         return setLengthAndFlush(io, 0);
     }
+    /**
+     * Asks the server to cancel whatever the given session is currently
+     * running. Sent on its own fresh connection - a backend busy with a query
+     * is not reading its own socket, which is the whole reason this cannot go
+     * down the normal one.
+     */
+    getCancelRequestMessage(processID, secretKey) {
+        return this._io
+            .start()
+            .writeUInt32BE(16) // Length of message contents in bytes, including self.
+            .writeUInt16BE(1234)
+            .writeUInt16BE(5678)
+            .writeUInt32BE(processID)
+            .writeUInt32BE(secretKey)
+            .flush();
+    }
     getPasswordMessage(password) {
         const io = this._io
             .start()
@@ -82,16 +110,19 @@ export class Frontend {
     getParseMessage(args) {
         if (args.statement && args.statement.length > 63)
             throw new Error('Query name length must be lower than 63');
+        const { paramTypes } = args;
         const io = this._io
             .start()
             .writeInt8(Protocol.FrontendMessageCode.Parse)
             .writeInt32BE(0) // Preserve header
             .writeCString(args.statement || '', 'utf8')
             .writeCString(args.sql, 'utf8')
-            .writeUInt16BE(args.paramTypes ? args.paramTypes.length : 0);
-        if (args.paramTypes) {
-            for (const t of args.paramTypes) {
-                io.writeUInt32BE(t || 0);
+            .writeUInt16BE(paramTypes?.length || 0);
+        if (paramTypes) {
+            let i;
+            const l = paramTypes.length;
+            for (i = 0; i < l; i++) {
+                io.writeUInt32BE(paramTypes[i] || 0);
             }
         }
         return setLengthAndFlush(io, 1);
@@ -114,13 +145,16 @@ export class Frontend {
         if (params && params.length) {
             io.writeInt16BE(params.length);
             const formatOffset = io.offset;
-            for (let i = 0; i < params.length; i++) {
+            const l = params.length;
+            let i;
+            for (i = 0; i < l; i++) {
                 io.writeInt16BE(0); // Preserve
             }
             // Write parameter values
-            io.writeUInt16BE(params.length);
-            for (let i = 0; i < params?.length; i++) {
-                let v = params[i];
+            io.writeUInt16BE(l);
+            let v;
+            for (i = 0; i < l; i++) {
+                v = params[i];
                 if (v === null || v === undefined) {
                     io.writeInt32BE(-1);
                     continue;
@@ -175,8 +209,10 @@ export class Frontend {
             io.writeUInt16BE(0);
         }
         if (Array.isArray(columnFormat)) {
-            io.writeUInt16BE(columnFormat.length);
-            for (let i = 0; i < columnFormat.length; i++) {
+            const l = columnFormat.length;
+            io.writeUInt16BE(l);
+            let i;
+            for (i = 0; i < l; i++) {
                 io.writeUInt16BE(columnFormat[i]);
             }
         }
@@ -237,6 +273,29 @@ export class Frontend {
             .writeCString(sql || '', 'utf8');
         return setLengthAndFlush(io, 1);
     }
+    /**
+     * Returns the CopyData header and the caller's payload as two buffers
+     * rather than one, so a bulk import never copies the caller's bytes.
+     * PgSocket writes an array of buffers as a single corked write anyway,
+     * so this costs nothing on the wire.
+     */
+    getCopyDataMessage(data) {
+        const header = Buffer.allocUnsafe(5);
+        header[0] = Protocol.FrontendMessageCode.CopyData;
+        header.writeUInt32BE(data.length + 4, 1);
+        return [header, data];
+    }
+    getCopyDoneMessage() {
+        return StaticCopyDoneBuffer;
+    }
+    getCopyFailMessage(message) {
+        const io = this._io
+            .start()
+            .writeInt8(Protocol.FrontendMessageCode.CopyFail)
+            .writeInt32BE(0) // Preserve header
+            .writeCString(message || '', 'utf8');
+        return setLengthAndFlush(io, 1);
+    }
     getFlushMessage() {
         return StaticFlushBuffer;
     }