uptime-kuma/server/util-server.js

557 lines
15 KiB
JavaScript
Raw Normal View History

2021-07-27 13:47:13 -04:00
const tcpp = require("tcp-ping");
2021-07-01 05:00:23 -04:00
const Ping = require("./ping-lite");
2021-07-27 13:47:13 -04:00
const { R } = require("redbean-node");
const { log, genSecret } = require("../src/util");
2021-08-09 01:34:44 -04:00
const passwordHash = require("./password-hash");
2021-08-23 10:30:11 -04:00
const { Resolver } = require("dns");
2022-04-13 12:30:32 -04:00
const childProcess = require("child_process");
const iconv = require("iconv-lite");
const chardet = require("chardet");
2021-11-03 21:46:43 -04:00
const mqtt = require("mqtt");
2022-01-03 09:48:52 -05:00
const chroma = require("chroma-js");
2022-01-04 06:21:53 -05:00
const { badgeConstants } = require("./config");
2021-08-09 01:34:44 -04:00
// From ping-lite
exports.WIN = /^win/.test(process.platform);
exports.LIN = /^linux/.test(process.platform);
exports.MAC = /^darwin/.test(process.platform);
exports.FBSD = /^freebsd/.test(process.platform);
2022-01-09 11:27:24 -05:00
exports.BSD = /bsd$/.test(process.platform);
2021-08-09 01:34:44 -04:00
/**
* Init or reset JWT secret
* @returns {Promise<Bean>}
*/
exports.initJWTSecret = async () => {
let jwtSecretBean = await R.findOne("setting", " `key` = ? ", [
"jwtSecret",
]);
2021-11-03 21:46:43 -04:00
if (!jwtSecretBean) {
2021-08-09 01:34:44 -04:00
jwtSecretBean = R.dispense("setting");
jwtSecretBean.key = "jwtSecret";
}
2022-03-29 05:38:48 -04:00
jwtSecretBean.value = passwordHash.generate(genSecret());
2021-08-09 01:34:44 -04:00
await R.store(jwtSecretBean);
return jwtSecretBean;
2021-09-20 04:22:18 -04:00
};
2021-07-01 02:03:06 -04:00
/**
* Send TCP request to specified hostname and port
* @param {string} hostname Hostname / address of machine
* @param {number} port TCP port to test
* @returns {Promise<number>} Maximum time in ms rounded to nearest integer
*/
2021-07-01 02:03:06 -04:00
exports.tcping = function (hostname, port) {
return new Promise((resolve, reject) => {
tcpp.ping({
address: hostname,
port: port,
attempts: 1,
}, function (err, data) {
2021-07-01 02:03:06 -04:00
if (err) {
reject(err);
}
if (data.results.length >= 1 && data.results[0].err) {
reject(data.results[0].err);
}
resolve(Math.round(data.max));
});
});
2021-09-20 04:22:18 -04:00
};
2021-07-01 05:00:23 -04:00
/**
* Ping the specified machine
* @param {string} hostname Hostname / address of machine
* @returns {Promise<number>} Time for ping in ms rounded to nearest integer
*/
exports.ping = async (hostname) => {
try {
2021-08-10 10:00:29 -04:00
return await exports.pingAsync(hostname);
} catch (e) {
// If the host cannot be resolved, try again with ipv6
if (e.message.includes("service not known")) {
2021-08-10 10:00:29 -04:00
return await exports.pingAsync(hostname, true);
} else {
throw e;
}
}
2021-09-20 04:22:18 -04:00
};
/**
* Ping the specified machine
* @param {string} hostname Hostname / address of machine to ping
* @param {boolean} ipv6 Should IPv6 be used?
* @returns {Promise<number>} Time for ping in ms rounded to nearest integer
*/
exports.pingAsync = function (hostname, ipv6 = false) {
2021-07-01 05:00:23 -04:00
return new Promise((resolve, reject) => {
const ping = new Ping(hostname, {
ipv6
});
2021-07-01 05:00:23 -04:00
ping.send(function (err, ms, stdout) {
2021-07-01 05:00:23 -04:00
if (err) {
reject(err);
2021-07-01 05:00:23 -04:00
} else if (ms === null) {
2021-09-20 04:22:18 -04:00
reject(new Error(stdout));
2021-07-01 05:00:23 -04:00
} else {
2021-09-20 04:22:18 -04:00
resolve(Math.round(ms));
2021-07-01 05:00:23 -04:00
}
});
});
2021-09-20 04:22:18 -04:00
};
2021-07-09 02:14:03 -04:00
/**
* MQTT Monitor
* @param {string} hostname Hostname / address of machine to test
* @param {string} topic MQTT topic
* @param {string} okMessage Expected result
* @param {Object} [options={}] MQTT options. Contains port, username,
* password and interval (interval defaults to 20)
* @returns {Promise<string>}
*/
exports.mqttAsync = function (hostname, topic, okMessage, options = {}) {
2021-11-03 21:46:43 -04:00
return new Promise((resolve, reject) => {
const { port, username, password, interval = 20 } = options;
2022-01-12 23:42:34 -05:00
// Adds MQTT protocol to the hostname if not already present
if (!/^(?:http|mqtt)s?:\/\//.test(hostname)) {
hostname = "mqtt://" + hostname;
2021-11-03 21:46:43 -04:00
}
2022-01-12 23:42:34 -05:00
const timeoutID = setTimeout(() => {
2022-04-16 01:37:17 -04:00
log.debug("mqtt", "MQTT timeout triggered");
client.end();
reject(new Error("Timeout"));
}, interval * 1000 * 0.8);
2022-04-16 01:37:17 -04:00
log.debug("mqtt", "MQTT connecting");
2022-01-12 23:42:34 -05:00
let client = mqtt.connect(hostname, {
port,
username,
password
});
client.on("connect", () => {
log.debug("mqtt", "MQTT connected");
try {
log.debug("mqtt", "MQTT subscribe topic");
client.subscribe(topic);
} catch (e) {
client.end();
clearTimeout(timeoutID);
reject(new Error("Cannot subscribe topic"));
}
2022-01-12 23:42:34 -05:00
});
client.on("error", (error) => {
client.end();
clearTimeout(timeoutID);
2022-01-12 23:42:34 -05:00
reject(error);
});
client.on("message", (messageTopic, message) => {
2022-04-25 19:26:57 -04:00
if (messageTopic === topic) {
client.end();
clearTimeout(timeoutID);
if (okMessage != null && okMessage !== "" && message.toString() !== okMessage) {
reject(new Error(`Message Mismatch - Topic: ${messageTopic}; Message: ${message.toString()}`));
2022-01-12 23:42:34 -05:00
} else {
resolve(`Topic: ${messageTopic}; Message: ${message.toString()}`);
2022-01-12 23:42:34 -05:00
}
}
});
2021-11-03 21:46:43 -04:00
});
};
/**
* Resolves a given record using the specified DNS server
* @param {string} hostname The hostname of the record to lookup
* @param {string} resolverServer The DNS server to use
* @param {string} rrtype The type of record to request
* @returns {Promise<(string[]|Object[]|Object)>}
*/
exports.dnsResolve = function (hostname, resolverServer, rrtype) {
2021-08-22 18:05:48 -04:00
const resolver = new Resolver();
2022-04-17 03:27:35 -04:00
resolver.setServers([ resolverServer ]);
2021-08-22 18:05:48 -04:00
return new Promise((resolve, reject) => {
2022-04-17 03:43:03 -04:00
if (rrtype === "PTR") {
2021-08-22 18:05:48 -04:00
resolver.reverse(hostname, (err, records) => {
if (err) {
reject(err);
} else {
resolve(records);
}
});
} else {
resolver.resolve(hostname, rrtype, (err, records) => {
if (err) {
reject(err);
} else {
resolve(records);
}
});
}
2021-09-20 04:22:18 -04:00
});
};
2021-08-22 18:05:48 -04:00
/**
* Retrieve value of setting based on key
* @param {string} key Key of setting to retrieve
* @returns {Promise<any>} Value
*/
2021-07-09 02:14:03 -04:00
exports.setting = async function (key) {
2021-07-31 10:02:30 -04:00
let value = await R.getCell("SELECT `value` FROM setting WHERE `key` = ? ", [
2021-07-27 13:47:13 -04:00
key,
2021-07-31 10:02:30 -04:00
]);
try {
const v = JSON.parse(value);
log.debug("util", `Get Setting: ${key}: ${v}`);
return v;
2021-07-31 10:02:30 -04:00
} catch (e) {
return value;
}
2021-09-20 04:22:18 -04:00
};
2021-07-09 02:14:03 -04:00
/**
* Sets the specified setting to specifed value
* @param {string} key Key of setting to set
* @param {any} value Value to set to
* @param {?string} type Type of setting
* @returns {Promise<void>}
*/
2021-10-09 12:16:13 -04:00
exports.setSetting = async function (key, value, type = null) {
2021-07-21 14:02:35 -04:00
let bean = await R.findOne("setting", " `key` = ? ", [
2021-07-27 13:47:13 -04:00
key,
2021-09-20 04:22:18 -04:00
]);
if (!bean) {
2021-09-20 04:22:18 -04:00
bean = R.dispense("setting");
2021-07-21 14:02:35 -04:00
bean.key = key;
}
2021-10-09 12:16:13 -04:00
bean.type = type;
2021-07-31 10:02:30 -04:00
bean.value = JSON.stringify(value);
2021-09-20 04:22:18 -04:00
await R.store(bean);
};
2021-07-21 14:02:35 -04:00
/**
* Get settings based on type
* @param {?string} type The type of setting
* @returns {Promise<Bean>}
*/
2021-07-09 02:14:03 -04:00
exports.getSettings = async function (type) {
2021-07-31 09:57:58 -04:00
let list = await R.getAll("SELECT `key`, `value` FROM setting WHERE `type` = ? ", [
2021-07-27 13:47:13 -04:00
type,
2021-09-20 04:22:18 -04:00
]);
2021-07-09 02:14:03 -04:00
let result = {};
for (let row of list) {
2021-07-31 10:02:30 -04:00
try {
result[row.key] = JSON.parse(row.value);
} catch (e) {
result[row.key] = row.value;
}
2021-07-09 02:14:03 -04:00
}
return result;
2021-09-20 04:22:18 -04:00
};
/**
* Set settings based on type
* @param {?string} type Type of settings to set
* @param {Object} data Values of settings
* @returns {Promise<void>}
*/
2021-07-31 09:57:58 -04:00
exports.setSettings = async function (type, data) {
let keyList = Object.keys(data);
let promiseList = [];
for (let key of keyList) {
let bean = await R.findOne("setting", " `key` = ? ", [
key
]);
if (bean == null) {
bean = R.dispense("setting");
bean.type = type;
bean.key = key;
}
if (bean.type === type) {
bean.value = JSON.stringify(data[key]);
2021-09-20 04:22:18 -04:00
promiseList.push(R.store(bean));
2021-07-31 09:57:58 -04:00
}
}
await Promise.all(promiseList);
2021-09-20 04:22:18 -04:00
};
2021-07-31 09:57:58 -04:00
// ssl-checker by @dyaa
//https://github.com/dyaa/ssl-checker/blob/master/src/index.ts
/**
* Get number of days between two dates
* @param {Date} validFrom Start date
* @param {Date} validTo End date
* @returns {number}
*/
const getDaysBetween = (validFrom, validTo) =>
Math.round(Math.abs(+validFrom - +validTo) / 8.64e7);
/**
* Get days remaining from a time range
* @param {Date} validFrom Start date
* @param {Date} validTo End date
* @returns {number}
*/
const getDaysRemaining = (validFrom, validTo) => {
const daysRemaining = getDaysBetween(validFrom, validTo);
if (new Date(validTo).getTime() < new Date().getTime()) {
return -daysRemaining;
}
return daysRemaining;
};
/**
* Fix certificate info for display
* @param {Object} info The chain obtained from getPeerCertificate()
* @returns {Object} An object representing certificate information
*/
2021-10-01 06:44:32 -04:00
const parseCertificateInfo = function (info) {
let link = info;
let i = 0;
const existingList = {};
2021-10-01 06:44:32 -04:00
while (link) {
log.debug("cert", `[${i}] ${link.fingerprint}`);
2021-10-01 06:44:32 -04:00
if (!link.valid_from || !link.valid_to) {
break;
}
link.validTo = new Date(link.valid_to);
link.validFor = link.subjectaltname?.replace(/DNS:|IP Address:/g, "").split(", ");
link.daysRemaining = getDaysRemaining(new Date(), link.validTo);
existingList[link.fingerprint] = true;
2021-10-01 06:44:32 -04:00
// Move up the chain until loop is encountered
if (link.issuerCertificate == null) {
break;
} else if (link.issuerCertificate.fingerprint in existingList) {
log.debug("cert", `[Last] ${link.issuerCertificate.fingerprint}`);
2021-10-01 06:44:32 -04:00
link.issuerCertificate = null;
break;
} else {
link = link.issuerCertificate;
}
// Should be no use, but just in case.
if (i > 500) {
throw new Error("Dead loop occurred in parseCertificateInfo");
}
i++;
}
2021-10-01 06:44:32 -04:00
return info;
};
/**
* Check if certificate is valid
* @param {Object} res Response object from axios
* @returns {Object} Object containing certificate information
*/
2021-10-01 06:44:32 -04:00
exports.checkCertificate = function (res) {
const info = res.request.res.socket.getPeerCertificate(true);
const valid = res.request.res.socket.authorized || false;
log.debug("cert", "Parsing Certificate Info");
2021-10-01 06:44:32 -04:00
const parsedInfo = parseCertificateInfo(info);
return {
2021-10-01 06:44:32 -04:00
valid: valid,
certInfo: parsedInfo
};
2021-09-20 04:22:18 -04:00
};
/**
* Check if the provided status code is within the accepted ranges
* @param {string} status The status code to check
* @param {string[]} acceptedCodes An array of accepted status codes
* @returns {boolean} True if status code within range, false otherwise
* @throws {Error} Will throw an error if the provided status code is not a valid range string or code string
*/
exports.checkStatusCode = function (status, acceptedCodes) {
if (acceptedCodes == null || acceptedCodes.length === 0) {
return false;
}
for (const codeRange of acceptedCodes) {
const codeRangeSplit = codeRange.split("-").map(string => parseInt(string));
if (codeRangeSplit.length === 1) {
if (status === codeRangeSplit[0]) {
return true;
}
} else if (codeRangeSplit.length === 2) {
if (status >= codeRangeSplit[0] && status <= codeRangeSplit[1]) {
return true;
}
} else {
throw new Error("Invalid status code range");
}
}
return false;
2021-09-20 04:22:18 -04:00
};
/**
* Get total number of clients in room
* @param {Server} io Socket server instance
* @param {string} roomName Name of room to check
* @returns {number}
*/
exports.getTotalClientInRoom = (io, roomName) => {
const sockets = io.sockets;
2021-11-03 21:46:43 -04:00
if (!sockets) {
return 0;
}
const adapter = sockets.adapter;
2021-11-03 21:46:43 -04:00
if (!adapter) {
return 0;
}
const room = adapter.rooms.get(roomName);
if (room) {
return room.size;
} else {
return 0;
}
2021-09-20 04:22:18 -04:00
};
2021-09-11 07:40:03 -04:00
/**
* Allow CORS all origins if development
* @param {Object} res Response object from axios
*/
2021-09-11 07:40:03 -04:00
exports.allowDevAllOrigin = (res) => {
if (process.env.NODE_ENV === "development") {
exports.allowAllOrigin(res);
}
2021-09-20 04:22:18 -04:00
};
2021-09-11 07:40:03 -04:00
/**
* Allow CORS all origins
* @param {Object} res Response object from axios
*/
2021-09-11 07:40:03 -04:00
exports.allowAllOrigin = (res) => {
res.header("Access-Control-Allow-Origin", "*");
res.header("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept");
2021-09-20 04:22:18 -04:00
};
2021-09-16 10:48:28 -04:00
/**
* Check if a user is logged in
* @param {Socket} socket Socket instance
*/
2021-09-16 10:48:28 -04:00
exports.checkLogin = (socket) => {
2021-11-03 21:46:43 -04:00
if (!socket.userID) {
2021-09-16 10:48:28 -04:00
throw new Error("You are not logged in.");
}
2021-09-20 04:22:18 -04:00
};
2022-03-29 05:38:48 -04:00
/**
* For logged-in users, double-check the password
* @param {Socket} socket Socket.io instance
* @param {string} currentPassword
2022-03-29 05:38:48 -04:00
* @returns {Promise<Bean>}
*/
exports.doubleCheckPassword = async (socket, currentPassword) => {
if (typeof currentPassword !== "string") {
throw new Error("Wrong data type?");
}
let user = await R.findOne("user", " id = ? AND active = 1 ", [
socket.userID,
]);
if (!user || !passwordHash.verify(currentPassword, user.password)) {
throw new Error("Incorrect current password");
}
return user;
};
/** Start Unit tests */
exports.startUnitTest = async () => {
console.log("Starting unit test...");
const npm = /^win/.test(process.platform) ? "npm.cmd" : "npm";
2022-04-17 03:27:35 -04:00
const child = childProcess.spawn(npm, [ "run", "jest" ]);
child.stdout.on("data", (data) => {
console.log(data.toString());
});
child.stderr.on("data", (data) => {
console.log(data.toString());
});
child.on("close", function (code) {
console.log("Jest exit code: " + code);
2021-10-05 08:40:40 -04:00
process.exit(code);
});
};
/**
* Convert unknown string to UTF8
* @param {Uint8Array} body Buffer
* @returns {string}
*/
exports.convertToUTF8 = (body) => {
const guessEncoding = chardet.detect(body);
const str = iconv.decode(body, guessEncoding);
return str.toString();
};
2022-01-03 10:04:37 -05:00
/**
* Returns a color code in hex format based on a given percentage:
* 0% => hue = 10 => red
* 100% => hue = 90 => green
*
* @param {number} percentage float, 0 to 1
* @param {number} maxHue
2022-01-03 10:04:37 -05:00
* @param {number} minHue, int
* @returns {string}, hex value
*/
2022-01-03 09:48:52 -05:00
exports.percentageToColor = (percentage, maxHue = 90, minHue = 10) => {
const hue = percentage * (maxHue - minHue) + minHue;
try {
return chroma(`hsl(${hue}, 90%, 40%)`).hex();
} catch (err) {
2022-01-04 06:21:53 -05:00
return badgeConstants.naColor;
2022-01-03 09:48:52 -05:00
}
};
/**
* Joins and array of string to one string after filtering out empty values
*
* @param {string[]} parts
* @param {string} connector
* @returns {string}
*/
exports.filterAndJoin = (parts, connector = "") => {
return parts.filter((part) => !!part && part !== "").join(connector);
};