676 lines
19 KiB
JavaScript
676 lines
19 KiB
JavaScript
import fs from 'fs';
|
|
import express from 'express';
|
|
import crypto from 'crypto';
|
|
import path from 'path';
|
|
import { fileURLToPath } from 'url';
|
|
import logger from './logger.js';
|
|
|
|
const __filename = fileURLToPath(import.meta.url);
|
|
const __dirname = path.dirname(__filename);
|
|
|
|
const PUSH_CHANNEL_TYPES = new Set([
|
|
'post_json',
|
|
'bark',
|
|
'get',
|
|
'dingtalk',
|
|
'pushplus',
|
|
'serverchan',
|
|
'custom',
|
|
'feishu',
|
|
'telegram'
|
|
]);
|
|
|
|
const PUSH_CHANNEL_TYPE_LABELS = {
|
|
post_json: 'POST JSON',
|
|
bark: 'Bark',
|
|
get: 'GET',
|
|
dingtalk: '钉钉',
|
|
pushplus: 'PushPlus',
|
|
serverchan: 'Server酱',
|
|
custom: '自定义',
|
|
feishu: '飞书',
|
|
telegram: 'Telegram'
|
|
};
|
|
|
|
class APIServer {
|
|
constructor(config, modem, smsProcessor, pushManager) {
|
|
this.config = config;
|
|
this.modem = modem;
|
|
this.smsProcessor = smsProcessor;
|
|
this.pushManager = pushManager;
|
|
this.app = express();
|
|
this.publicDir = path.join(__dirname, '../public');
|
|
this.configPath = path.join(__dirname, '../config.json');
|
|
|
|
this.setupMiddleware();
|
|
this.setupRoutes();
|
|
}
|
|
|
|
setupMiddleware() {
|
|
// JSON解析
|
|
this.app.use(express.json());
|
|
|
|
// Web Token认证，API保留Basic Auth兼容
|
|
this.app.use((req, res, next) => {
|
|
this.authenticateRequest(req, res, next);
|
|
});
|
|
|
|
// 请求日志
|
|
this.app.use((req, res, next) => {
|
|
logger.info(`${req.method} ${req.path}`);
|
|
next();
|
|
});
|
|
|
|
this.app.use('/assets', express.static(path.join(this.publicDir, 'assets')));
|
|
}
|
|
|
|
authenticateRequest(req, res, next) {
|
|
if (this.hasValidWebToken(req)) {
|
|
this.persistWebToken(req, res);
|
|
|
|
if (this.shouldCleanTokenFromUrl(req)) {
|
|
return res.redirect(302, this.getCleanUrl(req));
|
|
}
|
|
|
|
return next();
|
|
}
|
|
|
|
if (this.isWebRoute(req) && this.getConfiguredWebToken()) {
|
|
return this.sendTokenGate(res);
|
|
}
|
|
|
|
if (this.hasValidBasicAuth(req)) {
|
|
return next();
|
|
}
|
|
|
|
if (req.path.startsWith('/api/')) {
|
|
return res.status(401).json({
|
|
success: false,
|
|
error: this.getConfiguredWebToken() ? '需要有效token或Basic Auth' : '需要Basic Auth'
|
|
});
|
|
}
|
|
|
|
return this.sendBasicAuthChallenge(res);
|
|
}
|
|
|
|
getConfiguredWebToken() {
|
|
return String(this.config.api.webToken || '').trim();
|
|
}
|
|
|
|
hasValidWebToken(req) {
|
|
const expected = this.getConfiguredWebToken();
|
|
if (!expected) {
|
|
return false;
|
|
}
|
|
|
|
const token = this.getRequestToken(req);
|
|
return this.safeEqual(token, expected);
|
|
}
|
|
|
|
getRequestToken(req) {
|
|
const bearer = req.get('authorization')?.match(/^Bearer\s+(.+)$/i)?.[1];
|
|
return req.query.token || req.get('x-web-token') || bearer || this.getCookie(req, 'sms_gateway_token') || '';
|
|
}
|
|
|
|
getCookie(req, name) {
|
|
const cookieHeader = req.get('cookie') || '';
|
|
const cookies = cookieHeader.split(';').map(item => item.trim());
|
|
const prefix = `${name}=`;
|
|
const cookie = cookies.find(item => item.startsWith(prefix));
|
|
return cookie ? decodeURIComponent(cookie.slice(prefix.length)) : '';
|
|
}
|
|
|
|
persistWebToken(req, res) {
|
|
if (!req.query.token) {
|
|
return;
|
|
}
|
|
|
|
res.cookie('sms_gateway_token', req.query.token, {
|
|
httpOnly: true,
|
|
sameSite: 'strict',
|
|
maxAge: 7 * 24 * 60 * 60 * 1000,
|
|
path: '/'
|
|
});
|
|
}
|
|
|
|
shouldCleanTokenFromUrl(req) {
|
|
return this.isWebRoute(req) && Boolean(req.query.token);
|
|
}
|
|
|
|
getCleanUrl(req) {
|
|
const url = new URL(req.originalUrl, 'http://localhost');
|
|
url.searchParams.delete('token');
|
|
return `${url.pathname}${url.search}`;
|
|
}
|
|
|
|
hasValidBasicAuth(req) {
|
|
const auth = req.get('authorization') || '';
|
|
if (!auth.startsWith('Basic ')) {
|
|
return false;
|
|
}
|
|
|
|
const decoded = Buffer.from(auth.slice(6), 'base64').toString('utf8');
|
|
const separatorIndex = decoded.indexOf(':');
|
|
if (separatorIndex === -1) {
|
|
return false;
|
|
}
|
|
|
|
const username = decoded.slice(0, separatorIndex);
|
|
const password = decoded.slice(separatorIndex + 1);
|
|
return this.safeEqual(username, this.config.api.auth.username) &&
|
|
this.safeEqual(password, this.config.api.auth.password);
|
|
}
|
|
|
|
safeEqual(actual, expected) {
|
|
const actualBuffer = Buffer.from(String(actual));
|
|
const expectedBuffer = Buffer.from(String(expected));
|
|
|
|
if (actualBuffer.length !== expectedBuffer.length) {
|
|
return false;
|
|
}
|
|
|
|
return crypto.timingSafeEqual(actualBuffer, expectedBuffer);
|
|
}
|
|
|
|
isWebRoute(req) {
|
|
return req.path === '/' || req.path === '/admin' || req.path.startsWith('/assets/');
|
|
}
|
|
|
|
sendBasicAuthChallenge(res) {
|
|
res.set('WWW-Authenticate', 'Basic realm="SMS Gateway"');
|
|
return res.status(401).send('Authentication required');
|
|
}
|
|
|
|
sendTokenGate(res) {
|
|
res.set('Cache-Control', 'no-store');
|
|
return res.status(401).type('html').send(`<!doctype html>
|
|
<html lang="zh-CN">
|
|
<head>
|
|
<meta charset="utf-8">
|
|
<meta name="viewport" content="width=device-width, initial-scale=1">
|
|
<title>SMS Gateway Token</title>
|
|
<style>
|
|
:root { color-scheme: light; --canvas:#faf9f5; --ink:#141413; --body:#3d3d3a; --muted:#6c6a64; --card:#efe9de; --primary:#cc785c; --primary-active:#a9583e; --hairline:#e6dfd8; }
|
|
* { box-sizing: border-box; }
|
|
body { margin: 0; min-height: 100vh; display: grid; place-items: center; background: var(--canvas); color: var(--body); font-family: Inter, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; line-height: 1.55; }
|
|
main { width: min(480px, calc(100% - 32px)); border-radius: 12px; background: var(--card); padding: 32px; }
|
|
.mark { color: var(--ink); font-size: 20px; }
|
|
h1 { margin: 18px 0 10px; color: var(--ink); font-family: "Cormorant Garamond", "EB Garamond", Georgia, serif; font-size: 40px; font-weight: 500; line-height: 1.1; letter-spacing: 0; }
|
|
p { margin: 0 0 24px; color: var(--muted); }
|
|
label { display: grid; gap: 8px; color: var(--ink); font-size: 14px; font-weight: 500; }
|
|
input { width: 100%; min-height: 40px; border: 1px solid var(--hairline); border-radius: 8px; background: var(--canvas); color: var(--ink); padding: 10px 14px; font: inherit; }
|
|
input:focus { border-color: var(--primary); outline: 3px solid rgba(204, 120, 92, .15); }
|
|
button { margin-top: 18px; width: 100%; min-height: 40px; border: 0; border-radius: 8px; background: var(--primary); color: #fff; padding: 12px 20px; font: inherit; font-size: 14px; font-weight: 500; cursor: pointer; }
|
|
button:active { background: var(--primary-active); }
|
|
</style>
|
|
</head>
|
|
<body>
|
|
<main>
|
|
<span class="mark">✣</span>
|
|
<h1>输入访问 token</h1>
|
|
<p>管理台需要有效 token 才能继续访问。</p>
|
|
<form method="get" action="/admin">
|
|
<label>
|
|
Token
|
|
<input name="token" type="password" autocomplete="current-password" autofocus required>
|
|
</label>
|
|
<button type="submit">进入管理台</button>
|
|
</form>
|
|
</main>
|
|
</body>
|
|
</html>`);
|
|
}
|
|
|
|
async readConfigFile() {
|
|
const configContent = await fs.promises.readFile(this.configPath, 'utf8');
|
|
return JSON.parse(configContent);
|
|
}
|
|
|
|
async savePushChannels(channels) {
|
|
const diskConfig = await this.readConfigFile();
|
|
diskConfig.pushChannels = channels;
|
|
|
|
await fs.promises.writeFile(
|
|
this.configPath,
|
|
`${JSON.stringify(diskConfig, null, 2)}\n`,
|
|
'utf8'
|
|
);
|
|
|
|
this.config.pushChannels = channels;
|
|
if (this.pushManager?.config) {
|
|
this.pushManager.config.pushChannels = channels;
|
|
}
|
|
}
|
|
|
|
getPushChannelsFromConfig(config = this.config) {
|
|
return Array.isArray(config.pushChannels) ? config.pushChannels : [];
|
|
}
|
|
|
|
normalizePushChannels(channels) {
|
|
if (!Array.isArray(channels)) {
|
|
throw new Error('pushChannels 必须是数组');
|
|
}
|
|
|
|
if (channels.length > 30) {
|
|
throw new Error('推送通道数量不能超过 30 个');
|
|
}
|
|
|
|
return channels.map((channel, index) => this.normalizePushChannel(channel, index));
|
|
}
|
|
|
|
normalizePushChannel(channel, index = 0) {
|
|
if (!channel || typeof channel !== 'object' || Array.isArray(channel)) {
|
|
throw new Error(`第 ${index + 1} 个推送通道格式不正确`);
|
|
}
|
|
|
|
const type = this.normalizeString(channel.type, '推送类型', 32);
|
|
if (!PUSH_CHANNEL_TYPES.has(type)) {
|
|
throw new Error(`第 ${index + 1} 个推送通道类型不支持`);
|
|
}
|
|
|
|
const typeLabel = PUSH_CHANNEL_TYPE_LABELS[type] || type;
|
|
const fallbackName = `${typeLabel}通知`;
|
|
const name = this.normalizeString(channel.name || fallbackName, '通道名称', 80);
|
|
|
|
return {
|
|
enabled: Boolean(channel.enabled),
|
|
type,
|
|
name: name || fallbackName,
|
|
url: this.normalizeString(channel.url, 'URL', 2048),
|
|
secret: this.normalizeString(channel.secret, '密钥', 2048),
|
|
key1: this.normalizeString(channel.key1, 'Key1', 2048),
|
|
key2: this.normalizeString(channel.key2, 'Key2', 2048),
|
|
customBody: this.normalizeString(channel.customBody, '自定义请求体', 10000)
|
|
};
|
|
}
|
|
|
|
normalizeString(value, fieldName, maxLength) {
|
|
const text = String(value ?? '').trim();
|
|
if (text.length > maxLength) {
|
|
throw new Error(`${fieldName}长度不能超过 ${maxLength} 个字符`);
|
|
}
|
|
return text;
|
|
}
|
|
|
|
validatePushChannels(channels) {
|
|
channels.forEach((channel, index) => {
|
|
this.validatePushChannel(channel, { index });
|
|
});
|
|
}
|
|
|
|
validatePushChannel(channel, options = {}) {
|
|
const index = options.index ?? 0;
|
|
const requireDestination = Boolean(options.requireDestination || channel.enabled);
|
|
const prefix = `第 ${index + 1} 个推送通道`;
|
|
const urlTypes = new Set(['post_json', 'bark', 'get', 'dingtalk', 'custom', 'feishu']);
|
|
|
|
if (urlTypes.has(channel.type)) {
|
|
if (requireDestination && !channel.url) {
|
|
throw new Error(`${prefix}缺少 URL`);
|
|
}
|
|
|
|
if (channel.url && !this.isHttpUrl(channel.url)) {
|
|
throw new Error(`${prefix}的 URL 格式不正确`);
|
|
}
|
|
}
|
|
|
|
if (channel.type === 'telegram') {
|
|
if (requireDestination && !channel.url) {
|
|
throw new Error(`${prefix}缺少 Bot Token`);
|
|
}
|
|
|
|
if (requireDestination && !channel.key1) {
|
|
throw new Error(`${prefix}缺少 Chat ID`);
|
|
}
|
|
}
|
|
|
|
if (channel.type === 'pushplus' && requireDestination && !channel.key1) {
|
|
throw new Error(`${prefix}缺少 PushPlus Token`);
|
|
}
|
|
|
|
if (channel.type === 'serverchan' && requireDestination && !channel.key1) {
|
|
throw new Error(`${prefix}缺少 Server酱 SendKey`);
|
|
}
|
|
|
|
if (channel.type === 'custom' && channel.customBody) {
|
|
try {
|
|
JSON.parse(channel.customBody);
|
|
} catch (err) {
|
|
throw new Error(`${prefix}的自定义请求体不是有效 JSON`);
|
|
}
|
|
}
|
|
}
|
|
|
|
isHttpUrl(value) {
|
|
try {
|
|
const url = new URL(value);
|
|
return url.protocol === 'http:' || url.protocol === 'https:';
|
|
} catch (err) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
setupRoutes() {
|
|
this.app.get('/', (req, res) => {
|
|
res.redirect('/admin');
|
|
});
|
|
|
|
this.app.get('/admin', (req, res) => {
|
|
res.sendFile(path.join(this.publicDir, 'admin.html'));
|
|
});
|
|
|
|
// 状态查询
|
|
this.app.get('/api/status', async (req, res) => {
|
|
try {
|
|
const signal = await this.modem.getSignalQuality();
|
|
const operator = await this.modem.getOperator();
|
|
const mobileData = await this.modem.getMobileDataStatus();
|
|
|
|
res.json({
|
|
success: true,
|
|
data: {
|
|
ready: this.modem.ready,
|
|
model: this.modem.modelInfo,
|
|
signal,
|
|
operator,
|
|
mobileData,
|
|
uptime: process.uptime()
|
|
}
|
|
});
|
|
} catch (err) {
|
|
logger.error('查询状态失败:', err);
|
|
res.status(500).json({
|
|
success: false,
|
|
error: err.message
|
|
});
|
|
}
|
|
});
|
|
|
|
// 发送短信
|
|
this.app.post('/api/sms/send', async (req, res) => {
|
|
try {
|
|
const { phone, message } = req.body;
|
|
|
|
if (!phone || !message) {
|
|
return res.status(400).json({
|
|
success: false,
|
|
error: '缺少必要参数: phone, message'
|
|
});
|
|
}
|
|
|
|
const success = await this.modem.sendSMS(phone, message);
|
|
|
|
res.json({
|
|
success,
|
|
message: success ? '短信发送成功' : '短信发送失败'
|
|
});
|
|
} catch (err) {
|
|
logger.error('发送短信失败:', err);
|
|
res.status(500).json({
|
|
success: false,
|
|
error: err.message
|
|
});
|
|
}
|
|
});
|
|
|
|
// 查询收到的短信
|
|
this.app.get('/api/sms/received', (req, res) => {
|
|
try {
|
|
const messages = this.smsProcessor.getReceivedMessages(req.query.limit);
|
|
res.json({
|
|
success: true,
|
|
data: messages
|
|
});
|
|
} catch (err) {
|
|
logger.error('查询收到短信失败:', err);
|
|
res.status(500).json({
|
|
success: false,
|
|
error: err.message
|
|
});
|
|
}
|
|
});
|
|
|
|
// 查询信号强度
|
|
this.app.get('/api/modem/signal', async (req, res) => {
|
|
try {
|
|
const signal = await this.modem.getSignalQuality();
|
|
res.json({
|
|
success: true,
|
|
data: signal
|
|
});
|
|
} catch (err) {
|
|
logger.error('查询信号失败:', err);
|
|
res.status(500).json({
|
|
success: false,
|
|
error: err.message
|
|
});
|
|
}
|
|
});
|
|
|
|
// 查询模组信息
|
|
this.app.get('/api/modem/info', async (req, res) => {
|
|
try {
|
|
const iccid = await this.modem.getICCID();
|
|
res.json({
|
|
success: true,
|
|
data: {
|
|
model: this.modem.modelInfo,
|
|
iccid,
|
|
ready: this.modem.ready
|
|
}
|
|
});
|
|
} catch (err) {
|
|
logger.error('查询模组信息失败:', err);
|
|
res.status(500).json({
|
|
success: false,
|
|
error: err.message
|
|
});
|
|
}
|
|
});
|
|
|
|
// 查询移动数据连接状态
|
|
this.app.get('/api/modem/mobile-data', async (req, res) => {
|
|
try {
|
|
const mobileData = await this.modem.getMobileDataStatus();
|
|
res.json({
|
|
success: true,
|
|
data: mobileData
|
|
});
|
|
} catch (err) {
|
|
logger.error('查询移动数据状态失败:', err);
|
|
res.status(500).json({
|
|
success: false,
|
|
error: err.message
|
|
});
|
|
}
|
|
});
|
|
|
|
// 开启或关闭移动数据连接
|
|
this.app.post('/api/modem/mobile-data', async (req, res) => {
|
|
try {
|
|
if (typeof req.body?.enabled !== 'boolean') {
|
|
return res.status(400).json({
|
|
success: false,
|
|
error: '缺少必要参数: enabled'
|
|
});
|
|
}
|
|
|
|
const mobileData = await this.modem.setMobileDataEnabled(req.body.enabled);
|
|
res.json({
|
|
success: true,
|
|
message: req.body.enabled ? '移动数据已开启' : '移动数据已关闭',
|
|
data: mobileData
|
|
});
|
|
} catch (err) {
|
|
logger.error('设置移动数据状态失败:', err);
|
|
res.status(500).json({
|
|
success: false,
|
|
error: err.message
|
|
});
|
|
}
|
|
});
|
|
|
|
// 发送AT命令
|
|
this.app.post('/api/modem/at', async (req, res) => {
|
|
try {
|
|
const { command } = req.body;
|
|
|
|
if (!command) {
|
|
return res.status(400).json({
|
|
success: false,
|
|
error: '缺少必要参数: command'
|
|
});
|
|
}
|
|
|
|
const response = await this.modem.sendATCommand(command, 5000);
|
|
|
|
res.json({
|
|
success: true,
|
|
data: {
|
|
command,
|
|
response
|
|
}
|
|
});
|
|
} catch (err) {
|
|
logger.error('发送AT命令失败:', err);
|
|
res.status(500).json({
|
|
success: false,
|
|
error: err.message
|
|
});
|
|
}
|
|
});
|
|
|
|
// 获取日志
|
|
this.app.get('/api/logs', (req, res) => {
|
|
try {
|
|
const logs = logger.getBuffer().getAll();
|
|
res.json({
|
|
success: true,
|
|
data: logs
|
|
});
|
|
} catch (err) {
|
|
logger.error('获取日志失败:', err);
|
|
res.status(500).json({
|
|
success: false,
|
|
error: err.message
|
|
});
|
|
}
|
|
});
|
|
|
|
// 查询推送通道配置
|
|
this.app.get('/api/push/channels', async (req, res) => {
|
|
try {
|
|
const diskConfig = await this.readConfigFile();
|
|
const channels = this.normalizePushChannels(this.getPushChannelsFromConfig(diskConfig));
|
|
|
|
res.json({
|
|
success: true,
|
|
data: channels
|
|
});
|
|
} catch (err) {
|
|
logger.error('读取推送通道配置失败:', err);
|
|
res.status(500).json({
|
|
success: false,
|
|
error: err.message
|
|
});
|
|
}
|
|
});
|
|
|
|
// 保存推送通道配置
|
|
this.app.put('/api/push/channels', async (req, res) => {
|
|
try {
|
|
const rawChannels = Array.isArray(req.body) ? req.body : req.body?.channels;
|
|
const channels = this.normalizePushChannels(rawChannels);
|
|
this.validatePushChannels(channels);
|
|
await this.savePushChannels(channels);
|
|
|
|
res.json({
|
|
success: true,
|
|
message: '推送通道配置已保存',
|
|
data: channels
|
|
});
|
|
} catch (err) {
|
|
logger.error('保存推送通道配置失败:', err);
|
|
res.status(400).json({
|
|
success: false,
|
|
error: err.message
|
|
});
|
|
}
|
|
});
|
|
|
|
// 测试推送通道
|
|
this.app.post('/api/push/test', async (req, res) => {
|
|
try {
|
|
if (!this.pushManager) {
|
|
return res.status(500).json({
|
|
success: false,
|
|
error: '推送管理器未初始化'
|
|
});
|
|
}
|
|
|
|
const channel = this.normalizePushChannel(req.body?.channel || req.body);
|
|
this.validatePushChannel(channel, { requireDestination: true });
|
|
|
|
const success = await this.pushManager.pushToChannel(
|
|
{ ...channel, enabled: true },
|
|
'测试号码',
|
|
'这是一条短信网关推送测试消息',
|
|
new Date().toISOString()
|
|
);
|
|
|
|
if (!success) {
|
|
return res.status(502).json({
|
|
success: false,
|
|
error: '测试推送发送失败，请查看运行日志'
|
|
});
|
|
}
|
|
|
|
res.json({
|
|
success: true,
|
|
message: '测试推送已发送'
|
|
});
|
|
} catch (err) {
|
|
logger.error('测试推送失败:', err);
|
|
res.status(400).json({
|
|
success: false,
|
|
error: err.message
|
|
});
|
|
}
|
|
});
|
|
|
|
// 健康检查
|
|
this.app.get('/health', (req, res) => {
|
|
res.json({
|
|
status: 'ok',
|
|
uptime: process.uptime()
|
|
});
|
|
});
|
|
|
|
// 404处理
|
|
this.app.use((req, res) => {
|
|
res.status(404).json({
|
|
success: false,
|
|
error: 'Not Found'
|
|
});
|
|
});
|
|
|
|
// 错误处理
|
|
this.app.use((err, req, res, next) => {
|
|
logger.error('API错误:', err);
|
|
res.status(500).json({
|
|
success: false,
|
|
error: err.message
|
|
});
|
|
});
|
|
}
|
|
|
|
start() {
|
|
const port = this.config.api.port;
|
|
this.app.listen(port, () => {
|
|
logger.info(`API服务器已启动，监听端口: ${port}`);
|
|
});
|
|
}
|
|
}
|
|
|
|
export default APIServer;
|