mirror of
https://github.com/github/codeql-action.git
synced 2025-12-27 01:30:10 +08:00
307 lines
8.0 KiB
JavaScript
307 lines
8.0 KiB
JavaScript
'use strict'
|
|
|
|
const {Buffer} = require('buffer')
|
|
const NoFilter = require('nofilter')
|
|
const stream = require('stream')
|
|
const constants = require('./constants')
|
|
const {NUMBYTES, SHIFT32, BI, SYMS} = constants
|
|
const MAX_SAFE_HIGH = 0x1fffff
|
|
|
|
/**
|
|
* Convert a UTF8-encoded Buffer to a JS string. If possible, throw an error
|
|
* on invalid UTF8. Byte Order Marks are not looked at or stripped.
|
|
*
|
|
* @private
|
|
*/
|
|
const td = new TextDecoder('utf8', {fatal: true, ignoreBOM: true})
|
|
exports.utf8 = buf => td.decode(buf)
|
|
exports.utf8.checksUTF8 = true
|
|
|
|
function isReadable(s) {
|
|
// Is this a readable stream? In the webpack version, instanceof isn't
|
|
// working correctly.
|
|
if (s instanceof stream.Readable) {
|
|
return true
|
|
}
|
|
return ['read', 'on', 'pipe'].every(f => typeof s[f] === 'function')
|
|
}
|
|
|
|
exports.isBufferish = function isBufferish(b) {
|
|
return b &&
|
|
(typeof b === 'object') &&
|
|
((Buffer.isBuffer(b)) ||
|
|
(b instanceof Uint8Array) ||
|
|
(b instanceof Uint8ClampedArray) ||
|
|
(b instanceof ArrayBuffer) ||
|
|
(b instanceof DataView))
|
|
}
|
|
|
|
exports.bufferishToBuffer = function bufferishToBuffer(b) {
|
|
if (Buffer.isBuffer(b)) {
|
|
return b
|
|
} else if (ArrayBuffer.isView(b)) {
|
|
return Buffer.from(b.buffer, b.byteOffset, b.byteLength)
|
|
} else if (b instanceof ArrayBuffer) {
|
|
return Buffer.from(b)
|
|
}
|
|
return null
|
|
}
|
|
|
|
exports.parseCBORint = function parseCBORint(ai, buf) {
|
|
switch (ai) {
|
|
case NUMBYTES.ONE:
|
|
return buf.readUInt8(0)
|
|
case NUMBYTES.TWO:
|
|
return buf.readUInt16BE(0)
|
|
case NUMBYTES.FOUR:
|
|
return buf.readUInt32BE(0)
|
|
case NUMBYTES.EIGHT: {
|
|
const f = buf.readUInt32BE(0)
|
|
const g = buf.readUInt32BE(4)
|
|
if (f > MAX_SAFE_HIGH) {
|
|
return (BigInt(f) * BI.SHIFT32) + BigInt(g)
|
|
}
|
|
return (f * SHIFT32) + g
|
|
}
|
|
default:
|
|
throw new Error(`Invalid additional info for int: ${ai}`)
|
|
}
|
|
}
|
|
|
|
exports.writeHalf = function writeHalf(buf, half) {
|
|
// Assume 0, -0, NaN, Infinity, and -Infinity have already been caught
|
|
|
|
// HACK: everyone settle in. This isn't going to be pretty.
|
|
// Translate cn-cbor's C code (from Carsten Borman):
|
|
|
|
// uint32_t be32;
|
|
// uint16_t be16, u16;
|
|
// union {
|
|
// float f;
|
|
// uint32_t u;
|
|
// } u32;
|
|
// u32.f = float_val;
|
|
|
|
const u32 = Buffer.allocUnsafe(4)
|
|
u32.writeFloatBE(half, 0)
|
|
const u = u32.readUInt32BE(0)
|
|
|
|
// If ((u32.u & 0x1FFF) == 0) { /* worth trying half */
|
|
|
|
// hildjj: If the lower 13 bits aren't 0,
|
|
// we will lose precision in the conversion.
|
|
// mant32 = 24bits, mant16 = 11bits, 24-11 = 13
|
|
if ((u & 0x1FFF) !== 0) {
|
|
return false
|
|
}
|
|
|
|
// Sign, exponent, mantissa
|
|
// int s16 = (u32.u >> 16) & 0x8000;
|
|
// int exp = (u32.u >> 23) & 0xff;
|
|
// int mant = u32.u & 0x7fffff;
|
|
|
|
let s16 = (u >> 16) & 0x8000 // Top bit is sign
|
|
const exp = (u >> 23) & 0xff // Then 5 bits of exponent
|
|
const mant = u & 0x7fffff
|
|
|
|
// Hildjj: zeros already handled. Assert if you don't believe me.
|
|
// if (exp == 0 && mant == 0)
|
|
// ; /* 0.0, -0.0 */
|
|
|
|
// else if (exp >= 113 && exp <= 142) /* normalized */
|
|
// s16 += ((exp - 112) << 10) + (mant >> 13);
|
|
|
|
if ((exp >= 113) && (exp <= 142)) {
|
|
s16 += ((exp - 112) << 10) + (mant >> 13)
|
|
} else if ((exp >= 103) && (exp < 113)) {
|
|
// Denormalized numbers
|
|
// else if (exp >= 103 && exp < 113) { /* denorm, exp16 = 0 */
|
|
// if (mant & ((1 << (126 - exp)) - 1))
|
|
// goto float32; /* loss of precision */
|
|
// s16 += ((mant + 0x800000) >> (126 - exp));
|
|
|
|
if (mant & ((1 << (126 - exp)) - 1)) {
|
|
return false
|
|
}
|
|
s16 += ((mant + 0x800000) >> (126 - exp))
|
|
} else {
|
|
// } else if (exp == 255 && mant == 0) { /* Inf */
|
|
// s16 += 0x7c00;
|
|
|
|
// hildjj: Infinity already handled
|
|
|
|
// } else
|
|
// goto float32; /* loss of range */
|
|
|
|
return false
|
|
}
|
|
|
|
// Done
|
|
// ensure_writable(3);
|
|
// u16 = s16;
|
|
// be16 = hton16p((const uint8_t*)&u16);
|
|
buf.writeUInt16BE(s16)
|
|
return true
|
|
}
|
|
|
|
exports.parseHalf = function parseHalf(buf) {
|
|
const sign = buf[0] & 0x80 ? -1 : 1
|
|
const exp = (buf[0] & 0x7C) >> 2
|
|
const mant = ((buf[0] & 0x03) << 8) | buf[1]
|
|
if (!exp) {
|
|
return sign * 5.9604644775390625e-8 * mant
|
|
} else if (exp === 0x1f) {
|
|
return sign * (mant ? NaN : Infinity)
|
|
}
|
|
return sign * (2 ** (exp - 25)) * (1024 + mant)
|
|
}
|
|
|
|
exports.parseCBORfloat = function parseCBORfloat(buf) {
|
|
switch (buf.length) {
|
|
case 2:
|
|
return exports.parseHalf(buf)
|
|
case 4:
|
|
return buf.readFloatBE(0)
|
|
case 8:
|
|
return buf.readDoubleBE(0)
|
|
default:
|
|
throw new Error(`Invalid float size: ${buf.length}`)
|
|
}
|
|
}
|
|
|
|
exports.hex = function hex(s) {
|
|
return Buffer.from(s.replace(/^0x/, ''), 'hex')
|
|
}
|
|
|
|
exports.bin = function bin(s) {
|
|
s = s.replace(/\s/g, '')
|
|
let start = 0
|
|
let end = (s.length % 8) || 8
|
|
const chunks = []
|
|
while (end <= s.length) {
|
|
chunks.push(parseInt(s.slice(start, end), 2))
|
|
start = end
|
|
end += 8
|
|
}
|
|
return Buffer.from(chunks)
|
|
}
|
|
|
|
exports.arrayEqual = function arrayEqual(a, b) {
|
|
if ((a == null) && (b == null)) {
|
|
return true
|
|
}
|
|
if ((a == null) || (b == null)) {
|
|
return false
|
|
}
|
|
return (a.length === b.length) && a.every((elem, i) => elem === b[i])
|
|
}
|
|
|
|
exports.bufferToBigInt = function bufferToBigInt(buf) {
|
|
return BigInt(`0x${buf.toString('hex')}`)
|
|
}
|
|
|
|
exports.cborValueToString = function cborValueToString(val, float_bytes = -1) {
|
|
switch (typeof val) {
|
|
case 'symbol': {
|
|
switch (val) {
|
|
case SYMS.NULL:
|
|
return 'null'
|
|
case SYMS.UNDEFINED:
|
|
return 'undefined'
|
|
case SYMS.BREAK:
|
|
return 'BREAK'
|
|
}
|
|
// Impossible in node 10
|
|
/* istanbul ignore if */
|
|
if (val.description) {
|
|
return val.description
|
|
}
|
|
// On node10, Symbol doesn't have description. Parse it out of the
|
|
// toString value, which looks like `Symbol(foo)`.
|
|
const s = val.toString()
|
|
const m = s.match(/^Symbol\((?<name>.*)\)/)
|
|
/* istanbul ignore if */
|
|
if (m && m.groups.name) {
|
|
// Impossible in node 12+
|
|
/* istanbul ignore next */
|
|
return m.groups.name
|
|
}
|
|
return 'Symbol'
|
|
}
|
|
case 'string':
|
|
return JSON.stringify(val)
|
|
case 'bigint':
|
|
return val.toString()
|
|
case 'number': {
|
|
const s = Object.is(val, -0) ? '-0' : String(val)
|
|
return (float_bytes > 0) ? `${s}_${float_bytes}` : s
|
|
}
|
|
case 'object': {
|
|
// A null should be caught above
|
|
const buf = exports.bufferishToBuffer(val)
|
|
if (buf) {
|
|
const hex = buf.toString('hex')
|
|
return (float_bytes === -Infinity) ? hex : `h'${hex}'`
|
|
}
|
|
if (typeof val[Symbol.for('nodejs.util.inspect.custom')] === 'function') {
|
|
return val[Symbol.for('nodejs.util.inspect.custom')]()
|
|
}
|
|
// Shouldn't get non-empty arrays here
|
|
if (Array.isArray(val)) {
|
|
return '[]'
|
|
}
|
|
// This should be all that is left
|
|
return '{}'
|
|
}
|
|
}
|
|
return String(val)
|
|
}
|
|
|
|
exports.guessEncoding = function guessEncoding(input, encoding) {
|
|
if (typeof input === 'string') {
|
|
return new NoFilter(input, (encoding == null) ? 'hex' : encoding)
|
|
}
|
|
const buf = exports.bufferishToBuffer(input)
|
|
if (buf) {
|
|
return new NoFilter(buf)
|
|
}
|
|
if (isReadable(input)) {
|
|
return input
|
|
}
|
|
throw new Error('Unknown input type')
|
|
}
|
|
|
|
const B64URL_SWAPS = {
|
|
'=': '',
|
|
'+': '-',
|
|
'/': '_',
|
|
}
|
|
|
|
/**
|
|
* @param {Buffer|Uint8Array|Uint8ClampedArray|ArrayBuffer|DataView} buf
|
|
* Buffer to convert.
|
|
* @returns {string} Base64url string.
|
|
* @private
|
|
*/
|
|
exports.base64url = function base64url(buf) {
|
|
return exports.bufferishToBuffer(buf)
|
|
.toString('base64')
|
|
.replace(/[=+/]/g, c => B64URL_SWAPS[c])
|
|
}
|
|
|
|
/**
|
|
* @param {Buffer|Uint8Array|Uint8ClampedArray|ArrayBuffer|DataView} buf
|
|
* Buffer to convert.
|
|
* @returns {string} Base64 string.
|
|
* @private
|
|
*/
|
|
exports.base64 = function base64(buf) {
|
|
return exports.bufferishToBuffer(buf).toString('base64')
|
|
}
|
|
|
|
exports.isBigEndian = function isBigEndian() {
|
|
const array = new Uint8Array(4)
|
|
const view = new Uint32Array(array.buffer)
|
|
return !((view[0] = 1) & array[0])
|
|
}
|