dqb-dev
65755bf520
含 app/server/server.cjs 服务端、app/www 网页(admin/auth/项目云/库备份/settings)、 app/ui 图标、cmd 安装脚本、config、wizard、manifest、图标与对接文档。 按仓库规则排除构建产物 *.fpk 与 .mimosa 缓存。
912 lines
46 KiB
JavaScript
Executable File
912 lines
46 KiB
JavaScript
Executable File
// 会员系统服务器(零依赖纯 node http)
|
|
// · 端口: HY_PORT → MEMBER_PORT → TRIM_SERVICE_PORT → 12701;
|
|
// 绑定 MEMBER_HOST 或 0.0.0.0(供局域网内成套报价软件访问)
|
|
// · 数据库存 huiyuan.json,目录解析(逐级回退,目录不可写自动降级):
|
|
// HY_DB_DIR(向导/网页设置指定) → TRIM_DATA_SHARE_PATHS 第一项 → TRIM_PKGVAR/files → 本目录(本地开发)
|
|
// · 项目云数据落 DB_DIR/项目云/<手机号安全化>/<编号安全化>/{项目.zip,meta.json}
|
|
// · 配置持久化: TRIM_PKGETC/app.env(KEY=VALUE),与 cmd 脚本共用,存 HY_PORT/HY_DB_DIR
|
|
// · 客户端 API(与原版完全兼容):
|
|
// POST /api/login {手机号,密码} → {ok,会员类型,有效期} | {ok:false,msg}
|
|
// POST /api/register {手机号,密码} → {ok} 注册为"试用会员",有效期=今天+30天
|
|
// GET /api/member?手机号=xxx → {ok,手机号,会员类型,有效期}
|
|
// POST /api/changepwd {手机号,旧密码,新密码} → {ok}
|
|
// GET /api/list → {ok,会员:[...]}(管理页用)
|
|
// POST /api/save {会员:[...]} → {ok}(管理页整表保存)
|
|
// · 项目云 API(2026-09-16):
|
|
// POST /api/proj/upload body=JSON头 + \n\n + zip二进制 → {ok,编号,大小,时间}(覆盖式,上限 2GB)
|
|
// GET /api/proj/list?手机号= → {ok,项目:[{编号,名称,时间,大小}]}
|
|
// GET /api/proj/download?手机号=&编号= → zip 二进制流
|
|
// POST /api/proj/delete {手机号,编号} → {ok}
|
|
// 上传前校验会员已注册(huiyuan.json);手机号/编号文件名安全化+防路径穿越;
|
|
// 元数据存各项目目录 meta.json(项目名/上传时间/大小)。
|
|
// · 设置 API(网页设置页用):
|
|
// GET /api/settings → 端口/数据目录/数据库与项目云路径/默认目录/已授权目录/会员数
|
|
// POST /api/settings {dbdir} → 校验可写→迁移 huiyuan.json+项目云→回写 app.env
|
|
// 已授权目录经 Unix Socket 调开放 API trim.file.getSharedAccessibleFolders(失败优雅降级)
|
|
// · 安全(v1.4.0 双层加密通讯):
|
|
// 第1层 TLS:HTTPS 端口(自动=网页端口+1,可用 HY_API_PORT 覆盖)供客户端,
|
|
// 自签证书首次启动由 openssl 自动生成(存配置目录,升级保留/重装重生成)
|
|
// 第2层 信封加密(/api/enc,仅 HTTPS):客户端随机 AES-256 密钥加密业务 JSON,
|
|
// AES 密钥用 RSA-2048 公钥封装(OAEP),服务端私钥永不出服务器;
|
|
// HMAC-SHA256 验签防篡改;时间戳±5分钟+随机数缓存防重放
|
|
// 登录/注册/查会员/改密/项目云列表与删除走双层;项目 zip 上传下载走 TLS 单层(大文件)
|
|
// 客户端接口已从 HTTP 端口撤下(返回 TLS_REQUIRED 提示);HTTP 端口仅剩网页管理(管理密码保护)
|
|
// 管理接口(/api/list /api/save /api/settings /api/admin/changepwd)需管理密码登录:
|
|
// POST /api/admin/login 换 token,后续请求带 X-Admin-Token 头(24h 过期;自定义头同时天然防 CSRF)
|
|
// 登录/注册/管理登录失败按 IP 限速(1 分钟内失败≥10 次锁 60 秒)
|
|
// 注册校验手机号 11 位/密码 4-64 位,HY_REG_OPEN=0 可关闭开放注册(设置页开关)
|
|
// 上传配额每会员 1GB;整表保存与目录迁移前滚动备份 huiyuan.json.bak
|
|
// · 页面: / 或 /admin.html(会员管理) /xiangmu-cloud.html(项目云) /lib-cloud.html(库备份) /settings.html(设置)
|
|
var http = require('http');
|
|
var fs = require('fs');
|
|
var path = require('path');
|
|
var crypto = require('crypto');
|
|
var execFileSync = require('child_process').execFileSync;
|
|
|
|
var VERSION = '1.5.1';
|
|
var APPNAME = 'fnnas.huiyuan';
|
|
var HOST = process.env.MEMBER_HOST || '0.0.0.0';
|
|
var DB_NAME = 'huiyuan.json';
|
|
var PROJ_DIR_NAME = '项目云';
|
|
var UPLOAD_MAX = 2 * 1024 * 1024 * 1024; // 单次上传上限 2GB,防磁盘打满
|
|
var USER_QUOTA = 1024 * 1024 * 1024; // 每会员项目云总配额 1GB
|
|
|
|
// ---- 开放 API(应用共享授权):仅后端可通过 Unix Socket 调用 ----
|
|
var API_SOCKET = '/var/run/trim_open_gateway_apiscope.socket';
|
|
var API_PATH = '/api/v1/trimapp';
|
|
|
|
// ---- 端口 ----
|
|
var PORT = parseInt(process.env.HY_PORT || process.env.MEMBER_PORT || '', 10)
|
|
|| parseInt(process.env.TRIM_SERVICE_PORT || '', 10)
|
|
|| 12701;
|
|
var WWW = path.join(__dirname, '..', 'www');
|
|
|
|
// ---- 配置文件(TRIM_PKGETC/app.env,cmd 脚本与本服务共用) ----
|
|
var CFG_FILE = process.env.HY_CFG
|
|
|| (process.env.TRIM_PKGETC ? path.join(process.env.TRIM_PKGETC, 'app.env') : null);
|
|
function 读配置() {
|
|
var cfg = {};
|
|
if (!CFG_FILE) return cfg;
|
|
try {
|
|
fs.readFileSync(CFG_FILE, 'utf8').split(/\r?\n/).forEach(function (line) {
|
|
var m = line.match(/^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/);
|
|
if (m) cfg[m[1]] = m[2];
|
|
});
|
|
} catch (e) { /* 配置不存在用默认值 */ }
|
|
return cfg;
|
|
}
|
|
function 写配置(cfg) {
|
|
if (!CFG_FILE) return; // 本地开发无配置文件,仅内存生效
|
|
var tmp = CFG_FILE + '.tmp';
|
|
fs.writeFileSync(tmp, Object.keys(cfg).map(function (k) { return k + '=' + (cfg[k] || ''); }).join('\n') + '\n', 'utf8');
|
|
fs.renameSync(tmp, CFG_FILE);
|
|
}
|
|
|
|
// ---- 管理密码鉴权(sha256(盐+密码) 存 app.env;token 在内存,重启失效) ----
|
|
function sha256hex(s) { return crypto.createHash('sha256').update(s, 'utf8').digest('hex'); }
|
|
function 管理密码已设置() {
|
|
var cfg = 读配置();
|
|
return !!(cfg.ADMIN_PWD_SALT && cfg.ADMIN_PWD_SHA256);
|
|
}
|
|
function 管理密码正确(密码) {
|
|
var cfg = 读配置();
|
|
if (!cfg.ADMIN_PWD_SALT || !cfg.ADMIN_PWD_SHA256) return false;
|
|
var got = sha256hex(cfg.ADMIN_PWD_SALT + String(密码 || ''));
|
|
var want = String(cfg.ADMIN_PWD_SHA256).toLowerCase();
|
|
if (got.length !== want.length) return false;
|
|
try { return crypto.timingSafeEqual(Buffer.from(got), Buffer.from(want)); }
|
|
catch (e) { return false; }
|
|
}
|
|
function 设置管理密码(新密码) {
|
|
var salt = crypto.randomBytes(8).toString('hex');
|
|
var cfg = 读配置();
|
|
cfg.ADMIN_PWD_SALT = salt;
|
|
cfg.ADMIN_PWD_SHA256 = sha256hex(salt + 新密码);
|
|
写配置(cfg);
|
|
}
|
|
var TOKENS = new Map(); // token → 过期时间戳
|
|
var TOKEN_TTL = 24 * 3600 * 1000; // 24 小时
|
|
function 新token() {
|
|
var t = crypto.randomBytes(24).toString('hex');
|
|
TOKENS.set(t, Date.now() + TOKEN_TTL);
|
|
return t;
|
|
}
|
|
function token有效(t) {
|
|
if (!t || !TOKENS.has(t)) return false;
|
|
if (Date.now() > TOKENS.get(t)) { TOKENS.delete(t); return false; }
|
|
return true;
|
|
}
|
|
function 是管理员(req) { return token有效(req.headers['x-admin-token']); }
|
|
setInterval(function () {
|
|
var now = Date.now();
|
|
TOKENS.forEach(function (exp, t) { if (now > exp) TOKENS.delete(t); });
|
|
清理NONCES();
|
|
}, 3600 * 1000).unref();
|
|
|
|
// ---- 限速:按 key 记失败,1 分钟内失败≥10 次锁 60 秒(内存,重启清零) ----
|
|
var FAILS = new Map(); // key → {n, window, lock}
|
|
function 被锁秒(key) {
|
|
var f = FAILS.get(key);
|
|
return f && f.lock && Date.now() < f.lock ? Math.ceil((f.lock - Date.now()) / 1000) : 0;
|
|
}
|
|
function 失败记录(key) {
|
|
var now = Date.now();
|
|
var f = FAILS.get(key);
|
|
if (!f || now > f.window) f = { n: 0, window: now + 60000, lock: 0 };
|
|
f.n++;
|
|
if (f.n >= 10) f.lock = now + 60000;
|
|
FAILS.set(key, f);
|
|
}
|
|
function 失败清零(key) { FAILS.delete(key); }
|
|
|
|
// ---- 配置目录(TLS 证书/RSA 密钥存放处) ----
|
|
var CFG_DIR = CFG_FILE ? path.dirname(CFG_FILE) : __dirname;
|
|
|
|
// ---- RSA-2048 密钥对(信封加密;私钥永不出服务器,首次启动生成并持久化) ----
|
|
var RSA_PRIV_FILE = path.join(CFG_DIR, 'huiyuan_rsa.pem');
|
|
var RSA_KEY = null;
|
|
try {
|
|
if (!fs.existsSync(RSA_PRIV_FILE)) {
|
|
var kp = crypto.generateKeyPairSync('rsa', {
|
|
modulusLength: 2048,
|
|
publicKeyEncoding: { type: 'spki', format: 'pem' },
|
|
privateKeyEncoding: { type: 'pkcs8', format: 'pem' }
|
|
});
|
|
fs.writeFileSync(RSA_PRIV_FILE, kp.privateKey, { mode: 0o600 });
|
|
}
|
|
RSA_KEY = crypto.createPrivateKey(fs.readFileSync(RSA_PRIV_FILE));
|
|
} catch (e) { console.warn('RSA 密钥初始化失败(加密通道不可用): ' + e.message); }
|
|
function 公钥PEM() { return crypto.createPublicKey(RSA_KEY).export({ type: 'spki', format: 'pem' }).toString(); }
|
|
function 公钥指纹() { // SHA256 前 16 位 hex,供管理员核验公钥身份
|
|
var der = crypto.createPublicKey(RSA_KEY).export({ type: 'spki', format: 'der' });
|
|
return crypto.createHash('sha256').update(der).digest('hex').slice(0, 16).toUpperCase();
|
|
}
|
|
|
|
// ---- 信封加密(应用层第2层):RSA-OAEP 封装 AES-256 密钥 + AES-CBC 加密 + HMAC 验签 + 防重放 ----
|
|
var NONCES = new Map(); // nonce → 过期时间戳(防重放)
|
|
function 清理NONCES() {
|
|
var now = Date.now();
|
|
NONCES.forEach(function (exp, n) { if (now > exp) NONCES.delete(n); });
|
|
}
|
|
function 解密信封(payload, ip) {
|
|
try {
|
|
if (!RSA_KEY) return { err: '服务端加密未初始化' };
|
|
if (!payload || !payload.k || !payload.iv || !payload.data || !payload.mac || !payload.ts || !payload.nonce)
|
|
return { err: '信封字段缺失' };
|
|
var aesKey = crypto.privateDecrypt(
|
|
{ key: RSA_KEY, padding: crypto.constants.RSA_PKCS1_OAEP_PADDING, oaepHash: 'sha1' },
|
|
Buffer.from(payload.k, 'base64'));
|
|
if (aesKey.length !== 32) return { err: '会话密钥长度非法' };
|
|
var ts = Number(payload.ts);
|
|
if (!ts || Math.abs(Date.now() - ts) > 300000) return { err: '时间戳超出允许窗口(±5分钟)' };
|
|
if (NONCES.has(String(payload.nonce))) return { err: '重复的请求(疑似抓包重放),已拒绝' };
|
|
var want = crypto.createHmac('sha256', aesKey)
|
|
.update(payload.ts + '.' + payload.nonce + '.' + payload.iv + '.' + payload.data).digest('hex');
|
|
if (want !== String(payload.mac)) return { err: '签名校验失败(数据可能被篡改)' };
|
|
var d = crypto.createDecipheriv('aes-256-cbc', aesKey, Buffer.from(payload.iv, 'hex'));
|
|
var inner = JSON.parse(Buffer.concat([d.update(Buffer.from(payload.data, 'base64')), d.final()]).toString('utf8'));
|
|
return { aesKey: aesKey, inner: inner, nonce: String(payload.nonce) };
|
|
} catch (e) { return { err: '信封解密失败: ' + e.message }; }
|
|
}
|
|
function 加密响应(aesKey, obj) {
|
|
var ivb = crypto.randomBytes(16);
|
|
var c = crypto.createCipheriv('aes-256-cbc', aesKey, ivb);
|
|
var dataB = Buffer.concat([c.update(Buffer.from(JSON.stringify(obj), 'utf8')), c.final()]).toString('base64');
|
|
var iv = ivb.toString('hex');
|
|
var mac = crypto.createHmac('sha256', aesKey).update(iv + '.' + dataB).digest('hex');
|
|
return { ok: true, iv: iv, mac: mac, data: dataB };
|
|
}
|
|
// 信封内允许的业务接口(凭据类小数据;zip 上传下载走 TLS 单层)
|
|
var ENC_ROUTES = {
|
|
'/api/login': function (b, req, ip) { return 登录(b || {}, ip); },
|
|
'/api/register': function (b, req, ip) { return 注册(b || {}, ip); },
|
|
'/api/member': function (b) { return 查会员(b || {}); },
|
|
'/api/changepwd': function (b) { return 改密(b || {}); },
|
|
'/api/proj/list': function (b, req) {
|
|
if (!项目云鉴权(b['手机号'], b['密码'], req)) return { ok: false, msg: '手机号或密码错误' };
|
|
return 列项目(b['手机号']);
|
|
},
|
|
'/api/proj/delete': function (b, req) {
|
|
if (!项目云鉴权(b['手机号'], b['密码'], req)) return { ok: false, msg: '手机号或密码错误' };
|
|
var d3 = b['手机号'] && b['编号'] ? 项目目录(b['手机号'], b['编号']) : null;
|
|
if (!d3) return { ok: false, msg: '参数错误' };
|
|
try { fs.rmSync(d3, { recursive: true, force: true }); return { ok: true }; }
|
|
catch (e2) { return { ok: false, msg: '删除失败: ' + e2.message }; }
|
|
}
|
|
};
|
|
|
|
// ---- 数据库目录解析 ----
|
|
function 目录不可写原因(dir) {
|
|
try {
|
|
if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
|
|
var t = path.join(dir, '.huiyuan-write-test');
|
|
fs.writeFileSync(t, '1'); fs.unlinkSync(t);
|
|
return null; // 可写
|
|
} catch (e) { return (e.code ? e.code + ' ' : '') + e.message; }
|
|
}
|
|
function 目录可写(dir) { return 目录不可写原因(dir) === null; }
|
|
function 默认目录() {
|
|
var share = (process.env.TRIM_DATA_SHARE_PATHS || '').split(':')[0];
|
|
if (share) return share; // 应用数据目录(文件管理→应用文件)
|
|
if (process.env.TRIM_PKGVAR) return path.join(process.env.TRIM_PKGVAR, 'files');
|
|
return __dirname; // 本地开发回退
|
|
}
|
|
var DEFAULT_DIR = 默认目录();
|
|
var DB_DIR;
|
|
(function () {
|
|
var cands = [];
|
|
var cfgDbDir = 读配置().HY_DB_DIR || process.env.HY_DB_DIR || '';
|
|
if (cfgDbDir) cands.push(cfgDbDir);
|
|
cands.push(DEFAULT_DIR);
|
|
if (process.env.TRIM_PKGVAR) cands.push(path.join(process.env.TRIM_PKGVAR, 'files'));
|
|
cands.push(__dirname);
|
|
for (var i = 0; i < cands.length; i++) {
|
|
if (目录可写(cands[i])) { DB_DIR = cands[i]; return; }
|
|
}
|
|
DB_DIR = __dirname;
|
|
})();
|
|
var DB_FILE = path.join(DB_DIR, DB_NAME);
|
|
|
|
// 启动时确保数据库文件存在:缺失则落一个空会员库(安装包不带任何会员数据)
|
|
if (!fs.existsSync(DB_FILE)) {
|
|
try { 写库({ '会员': [] }); console.log('数据库不存在,已创建空会员库: ' + DB_FILE); }
|
|
catch (e) { console.warn('空数据库创建失败(首次保存时再写入): ' + e.message); }
|
|
}
|
|
|
|
// ---- 会员密码哈希(v1.3.0):存储格式 盐(32hex)$哈希(64hex),每会员独立随机盐 ----
|
|
// 协议不变:客户端仍传明文,服务端哈希后比对/存储
|
|
var 哈希格式 = /^[0-9a-f]{32}\$[0-9a-f]{64}$/;
|
|
function 哈希密码(明文) {
|
|
var salt = crypto.randomBytes(16).toString('hex');
|
|
return salt + '$' + sha256hex(salt + String(明文));
|
|
}
|
|
function 校验密码(存储值, 输入) {
|
|
var stored = String(存储值 || '');
|
|
var input = String(输入 === undefined || 输入 === null ? '' : 输入);
|
|
if (!stored) return false;
|
|
if (哈希格式.test(stored)) {
|
|
var i = stored.indexOf('$');
|
|
return sha256hex(stored.slice(0, i) + input) === stored.slice(i + 1);
|
|
}
|
|
return stored === input; // 迁移前的明文兜底
|
|
}
|
|
// 启动时把明文密码一次性升级为哈希(迁移前备份,成功后用哈希版刷新备份,磁盘不残留明文)
|
|
(function 升级哈希() {
|
|
try {
|
|
var d = 读库(), changed = 0;
|
|
d['会员'].forEach(function (m) {
|
|
if (m['密码'] && !哈希格式.test(String(m['密码']))) { m['密码'] = 哈希密码(m['密码']); changed++; }
|
|
});
|
|
if (changed) {
|
|
备份库(); // 迁移前备份(此刻 .bak 为明文版)
|
|
写库(d);
|
|
备份库(); // 用哈希版覆盖备份
|
|
console.log('已把 ' + changed + ' 个会员密码升级为哈希存储');
|
|
}
|
|
} catch (e) { console.warn('密码哈希迁移失败(保持原样,下次启动重试): ' + e.message); }
|
|
})();
|
|
|
|
// ---- 数据读写(原子写:临时文件+rename) ----
|
|
function 读库() {
|
|
try {
|
|
var d = JSON.parse(fs.readFileSync(DB_FILE, 'utf8'));
|
|
if (!Array.isArray(d['会员'])) d['会员'] = [];
|
|
return d;
|
|
} catch (e) { return { '会员': [] }; }
|
|
}
|
|
function 备份库() { // 整表保存/迁移前滚动备份上一版,防误操作丢数据
|
|
try {
|
|
if (fs.existsSync(DB_FILE)) {
|
|
// 不能用 copyFileSync 直接覆盖:飞牛 ACL 下已有文件可能是 000 权限,打开即 EACCES;
|
|
// 与 写库 一致走 tmp+rename(只需目录可写)
|
|
var tmp = DB_FILE + '.bak.tmp';
|
|
fs.writeFileSync(tmp, fs.readFileSync(DB_FILE));
|
|
fs.renameSync(tmp, DB_FILE + '.bak');
|
|
}
|
|
} catch (e) { console.warn('备份失败: ' + e.message); }
|
|
}
|
|
function 写库(data) {
|
|
var tmp = DB_FILE + '.tmp';
|
|
fs.writeFileSync(tmp, JSON.stringify(data, null, 2), 'utf8');
|
|
fs.renameSync(tmp, DB_FILE);
|
|
}
|
|
function 今天加天数(n) {
|
|
var d = new Date(Date.now() + n * 86400000);
|
|
return d.getFullYear() + '-' + ('0' + (d.getMonth() + 1)).slice(-2) + '-' + ('0' + d.getDate()).slice(-2);
|
|
}
|
|
|
|
// ---- 业务 ----
|
|
function 登录(b, ip) {
|
|
var lock = 被锁秒('login:' + ip);
|
|
if (lock) return { ok: false, msg: '尝试过于频繁,请 ' + lock + ' 秒后再试' };
|
|
var db = 读库();
|
|
for (var i = 0; i < db['会员'].length; i++) {
|
|
var m = db['会员'][i];
|
|
if (m['手机号'] === b['手机号']) {
|
|
if (!校验密码(m['密码'], b['密码'])) { 失败记录('login:' + ip); return { ok: false, msg: '密码错误' }; }
|
|
失败清零('login:' + ip);
|
|
return { ok: true, 会员类型: m['会员类型'], 有效期: m['有效期'] };
|
|
}
|
|
}
|
|
失败记录('login:' + ip);
|
|
return { ok: false, msg: '该手机号未注册' };
|
|
}
|
|
function 注册(b, ip) {
|
|
var lock = 被锁秒('reg:' + ip);
|
|
if (lock) return { ok: false, msg: '尝试过于频繁,请 ' + lock + ' 秒后再试' };
|
|
if ((读配置().HY_REG_OPEN || '1') !== '1') return { ok: false, msg: '注册已关闭,请联系管理员开通' };
|
|
if (!/^1\d{10}$/.test(String(b['手机号'] || ''))) return { ok: false, msg: '手机号格式不正确(11 位数字)' };
|
|
var p = String(b['密码'] || '');
|
|
if (p.length < 4 || p.length > 64) return { ok: false, msg: '密码长度需 4-64 位' };
|
|
var db = 读库();
|
|
for (var i = 0; i < db['会员'].length; i++)
|
|
if (db['会员'][i]['手机号'] === b['手机号']) { 失败记录('reg:' + ip); return { ok: false, msg: '该手机号已注册' }; }
|
|
失败清零('reg:' + ip);
|
|
db['会员'].push({
|
|
'手机号': b['手机号'], '密码': 哈希密码(p),
|
|
'会员类型': '试用会员', '有效期': 今天加天数(30),
|
|
'注册时间': 今天加天数(0), '备注': ''
|
|
});
|
|
写库(db);
|
|
return { ok: true, msg: '注册成功' };
|
|
}
|
|
function 查会员(b) {
|
|
var db = 读库();
|
|
for (var i = 0; i < db['会员'].length; i++) {
|
|
var m = db['会员'][i];
|
|
if (m['手机号'] === b['手机号'])
|
|
return { ok: true, 手机号: m['手机号'], 会员类型: m['会员类型'], 有效期: m['有效期'] };
|
|
}
|
|
return { ok: false, msg: '该手机号未注册' };
|
|
}
|
|
function 改密(b) {
|
|
var db = 读库();
|
|
for (var i = 0; i < db['会员'].length; i++) {
|
|
var m = db['会员'][i];
|
|
if (m['手机号'] === b['手机号']) {
|
|
if (!校验密码(m['密码'], b['旧密码'])) return { ok: false, msg: '旧密码错误' };
|
|
if (!b['新密码']) return { ok: false, msg: '新密码不能为空' };
|
|
m['密码'] = 哈希密码(b['新密码']);
|
|
写库(db);
|
|
return { ok: true };
|
|
}
|
|
}
|
|
return { ok: false, msg: '该手机号未注册' };
|
|
}
|
|
|
|
// ---- 项目云(2026-09-16):数据落 DB_DIR/项目云/<手机号安全化>/<编号安全化>/{项目.zip,meta.json} ----
|
|
function 项目根() { return path.join(DB_DIR, PROJ_DIR_NAME); } // DB_DIR 可在设置页切换,须动态取
|
|
function 安全名(s) { // 文件名安全化:去掉路径分隔/非法字符,限长 80
|
|
var t = String(s || '').replace(/[\\\/:*?"<>|]/g, '_').replace(/\.\./g, '_').trim();
|
|
if (t.length > 80) t = t.slice(0, 80);
|
|
return t;
|
|
}
|
|
function 会员存在(手机号) {
|
|
var db = 读库();
|
|
for (var i = 0; i < db['会员'].length; i++)
|
|
if (db['会员'][i]['手机号'] === 手机号) return true;
|
|
return false;
|
|
}
|
|
function 会员密码正确(手机号, 密码) {
|
|
if (!密码) return false;
|
|
var db = 读库();
|
|
for (var i = 0; i < db['会员'].length; i++)
|
|
if (db['会员'][i]['手机号'] === 手机号) return 校验密码(db['会员'][i]['密码'], 密码);
|
|
return false;
|
|
}
|
|
// 项目云鉴权:管理 token 通过,或 会员手机号+密码 匹配(客户端需在各接口带上"密码")
|
|
function 项目云鉴权(手机号, 密码, req) {
|
|
return 是管理员(req) || 会员密码正确(手机号, 密码);
|
|
}
|
|
function 目录大小(dir) { // 递归估算目录总字节,读不了的部分按 0
|
|
var total = 0;
|
|
try {
|
|
fs.readdirSync(dir).forEach(function (name) {
|
|
var p = path.join(dir, name);
|
|
var st = fs.statSync(p);
|
|
if (st.isDirectory()) total += 目录大小(p);
|
|
else total += st.size;
|
|
});
|
|
} catch (e) { }
|
|
return total;
|
|
}
|
|
function 项目目录(手机号, 编号) { // 防穿越:拼好后必须仍在项目云根下
|
|
var root = 项目根();
|
|
var d = path.join(root, 安全名(手机号), 安全名(编号));
|
|
return d.indexOf(root) === 0 ? d : null;
|
|
}
|
|
function 列项目(手机号) {
|
|
if (!手机号 || !会员存在(手机号)) return { ok: false, msg: '该手机号未注册' };
|
|
var dir = 项目目录(手机号, '');
|
|
var 出 = [];
|
|
try {
|
|
fs.readdirSync(dir).forEach(function (编号) {
|
|
var p = path.join(dir, 编号);
|
|
try {
|
|
var meta = JSON.parse(fs.readFileSync(path.join(p, 'meta.json'), 'utf8'));
|
|
出.push({ 编号: meta['编号'] || 编号, 名称: meta['名称'] || '', 时间: meta['时间'] || '', 大小: meta['大小'] || 0 });
|
|
} catch (e) { }
|
|
});
|
|
} catch (e) { } // 目录不存在=无项目
|
|
return { ok: true, '项目': 出 };
|
|
}
|
|
|
|
// ---- 开放 API 调用(查管理员授权给本应用的目录) ----
|
|
function 查授权目录(cb) {
|
|
var token = process.env.TRIM_API_TOKEN;
|
|
if (!token) return cb({ ok: false, msg: '未获取到 TRIM_API_TOKEN(需从飞牛应用中心启动)' });
|
|
if (!fs.existsSync(API_SOCKET)) return cb({ ok: false, msg: '开放 API 接口不存在:需要 fnOS 1.2.0401 及以上、App 1.34.0 及以上' });
|
|
var body = JSON.stringify({ reqId: String(Date.now()), req: 'trim.file.getSharedAccessibleFolders', appName: APPNAME, data: {} });
|
|
var req = http.request({
|
|
socketPath: API_SOCKET, path: API_PATH, method: 'POST',
|
|
headers: { 'Content-Type': 'application/json', 'Authorization': 'Bearer ' + token, 'Content-Length': Buffer.byteLength(body) }
|
|
}, function (res) {
|
|
var chunks = [];
|
|
res.on('data', function (c) { chunks.push(c); });
|
|
res.on('end', function () {
|
|
try {
|
|
var j = JSON.parse(Buffer.concat(chunks).toString('utf8'));
|
|
if (j.code === 0) return cb({ ok: true, paths: ((j.data || {}).paths || []).sort() });
|
|
cb({ ok: false, msg: j.msg || ('开放 API 返回 code=' + j.code) });
|
|
} catch (e) { cb({ ok: false, msg: '开放 API 响应异常: ' + e.message }); }
|
|
});
|
|
});
|
|
req.on('error', function (e) { cb({ ok: false, msg: '开放 API 调用失败: ' + e.message }); });
|
|
req.end(body);
|
|
}
|
|
|
|
// ---- 设置:查询 / 切换数据库目录 ----
|
|
function 设置信息(cb) {
|
|
查授权目录(function (auth) {
|
|
var db = 读库();
|
|
var cfgDir = 读配置().HY_DB_DIR || '';
|
|
cb({
|
|
ok: true, version: VERSION, port: PORT,
|
|
dbdir: DB_DIR, dbfile: DB_FILE, defaultdir: DEFAULT_DIR,
|
|
isDefaultDir: DB_DIR === DEFAULT_DIR,
|
|
configuredDir: cfgDir,
|
|
projroot: 项目根(),
|
|
authorized: auth.ok ? auth.paths : [],
|
|
authorizedOk: auth.ok, authorizedMsg: auth.ok ? '' : auth.msg,
|
|
count: db['会员'].length,
|
|
regOpen: (读配置().HY_REG_OPEN || '1') === '1',
|
|
adminConfigured: 管理密码已设置(),
|
|
tlsfp: TLS指纹(),
|
|
keyfp: RSA_KEY ? 公钥指纹() : ''
|
|
});
|
|
});
|
|
}
|
|
function 切换数据库目录(newDir, cb) {
|
|
if (typeof newDir !== 'string' || !/^\/.+/.test(newDir.trim()))
|
|
return cb({ ok: false, msg: '数据库目录必须是以 / 开头的完整路径' });
|
|
newDir = newDir.trim();
|
|
if (newDir === DB_DIR) return cb({ ok: true, dbdir: DB_DIR, dbfile: DB_FILE, msg: '目录未变化' });
|
|
var why = 目录不可写原因(newDir);
|
|
if (why) return cb({ ok: false, msg: '目标目录不可写（' + why + '）。共享目录需先在应用设置或本页「授权新目录」完成目录授权' });
|
|
var 旧文件 = DB_FILE;
|
|
var 旧项目根 = 项目根();
|
|
var 新文件 = path.join(newDir, DB_NAME);
|
|
var warn = '';
|
|
备份库(); // 迁移前备份
|
|
// 迁移顺序:先写新文件→回读校验→再删旧文件,任何一步失败都不丢数据
|
|
try {
|
|
if (fs.existsSync(旧文件)) {
|
|
var content = fs.readFileSync(旧文件);
|
|
fs.writeFileSync(新文件, content);
|
|
JSON.parse(fs.readFileSync(新文件, 'utf8')); // 新文件完整性校验
|
|
try { fs.unlinkSync(旧文件); }
|
|
catch (e) { warn = '旧文件暂无法删除,已保留在 ' + 旧文件 + ' (不影响使用)'; }
|
|
}
|
|
try { fs.unlinkSync(旧文件 + '.tmp'); } catch (e) {}
|
|
} catch (e) {
|
|
console.error('数据库迁移失败: ' + ((e.code ? e.code + ' ' : '') + e.message));
|
|
return cb({ ok: false, msg: '迁移失败: ' + ((e.code ? e.code + ' ' : '') + e.message) + ',原数据未受影响' });
|
|
}
|
|
DB_DIR = newDir; DB_FILE = 新文件;
|
|
// 新目录无库文件时落一个空会员库
|
|
try {
|
|
if (!fs.existsSync(DB_FILE)) 写库({ '会员': [] });
|
|
} catch (e) { console.warn('新目录空库初始化失败: ' + e.message); }
|
|
// 项目云整目录一并迁移(尽力而为:失败不回滚,旧数据保留并提示)
|
|
try {
|
|
if (fs.existsSync(旧项目根)) {
|
|
var 新项目根 = path.join(newDir, PROJ_DIR_NAME);
|
|
try { fs.renameSync(旧项目根, 新项目根); }
|
|
catch (e) { fs.cpSync(旧项目根, 新项目根, { recursive: true }); fs.rmSync(旧项目根, { recursive: true, force: true }); }
|
|
}
|
|
} catch (e) {
|
|
warn = (warn ? warn + ';' : '') + '项目云目录未能迁移,仍保留在 ' + 旧项目根 + ' (' + e.message + ')';
|
|
}
|
|
process.env.HY_DB_DIR = newDir;
|
|
try {
|
|
var cfg = 读配置(); cfg.HY_DB_DIR = newDir; 写配置(cfg);
|
|
} catch (e) {
|
|
console.error('配置回写失败: ' + e.message);
|
|
return cb({ ok: false, msg: '已迁移到 ' + DB_DIR + ' 但配置回写失败(重启后可能回退): ' + e.message });
|
|
}
|
|
console.log('数据库目录已切换: ' + 旧文件 + ' → ' + DB_FILE + (warn ? ' (' + warn + ')' : ''));
|
|
cb({ ok: true, dbdir: DB_DIR, dbfile: DB_FILE, msg: warn });
|
|
}
|
|
|
|
// ---- HTTP ----
|
|
function sendJson(res, obj) {
|
|
res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8', 'Cache-Control': 'no-store' });
|
|
res.end(JSON.stringify(obj));
|
|
}
|
|
function readBody(req, cb) {
|
|
var chunks = [];
|
|
req.on('data', function (c) { chunks.push(c); });
|
|
req.on('end', function () {
|
|
try { cb(null, JSON.parse(Buffer.concat(chunks).toString('utf8'))); }
|
|
catch (e) { cb(e, null); }
|
|
});
|
|
}
|
|
|
|
var MIME = {
|
|
'.html': 'text/html; charset=utf-8',
|
|
'.js': 'application/javascript; charset=utf-8',
|
|
'.css': 'text/css; charset=utf-8',
|
|
'.json': 'application/json; charset=utf-8',
|
|
'.png': 'image/png',
|
|
'.ico': 'image/x-icon'
|
|
};
|
|
|
|
var TLS_HINT = { ok: false, code: 'TLS_REQUIRED', msg: '该接口已迁移至加密通道,请升级客户端并使用 https://IP:端口 连接' };
|
|
|
|
function handler(req, res, isTLS) {
|
|
// 全站 HTTPS 安全响应头
|
|
res.setHeader('X-Content-Type-Options', 'nosniff');
|
|
res.setHeader('X-Frame-Options', 'SAMEORIGIN');
|
|
res.setHeader('Strict-Transport-Security', 'max-age=31536000');
|
|
var urlPath = decodeURIComponent(req.url.split('?')[0]);
|
|
var ip = (req.socket.remoteAddress || '').replace(/^::ffff:/, '') || 'unknown';
|
|
var query = {};
|
|
(req.url.split('?')[1] || '').split('&').forEach(function (kv) {
|
|
var p = kv.split('=');
|
|
if (p[0]) query[decodeURIComponent(p[0])] = decodeURIComponent((p[1] || '').replace(/\+/g, ' '));
|
|
});
|
|
|
|
// 公开:版本号(页面徽章用,不含敏感信息)
|
|
if (urlPath === '/api/version') return sendJson(res, { ok: true, version: VERSION });
|
|
|
|
// 公开:TLS 证书下载(安装到系统"受信任的根证书"后,浏览器/客户端不再有证书警告)
|
|
if (urlPath === '/api/cert') {
|
|
try {
|
|
var crt = fs.readFileSync(TLS_CRT_FILE);
|
|
res.writeHead(200, {
|
|
'Content-Type': 'application/x-x509-ca-cert',
|
|
'Content-Disposition': 'attachment; filename="fnnas-huiyuan.crt"',
|
|
'Content-Length': crt.length
|
|
});
|
|
return res.end(crt);
|
|
} catch (e) { return sendJson(res, { ok: false, msg: '证书读取失败: ' + e.message }); }
|
|
}
|
|
|
|
// ---- 加密通道(仅 HTTPS) ----
|
|
if (urlPath === '/api/pubkey') {
|
|
if (!isTLS) return sendJson(res, TLS_HINT);
|
|
if (!RSA_KEY) return sendJson(res, { ok: false, msg: '服务端加密未初始化' });
|
|
return sendJson(res, { ok: true, pubkey: 公钥PEM(), keyfp: 公钥指纹() });
|
|
}
|
|
if (urlPath === '/api/enc') {
|
|
if (!isTLS) return sendJson(res, TLS_HINT);
|
|
return readBody(req, function (e, payload) {
|
|
if (e || !payload || !payload.k) return sendJson(res, { ok: false, msg: '信封格式错误' });
|
|
var r = 解密信封(payload, ip);
|
|
if (r.err) return sendJson(res, { ok: false, msg: r.err });
|
|
NONCES.set(r.nonce, Date.now() + 600000); // 记录 nonce 防重放
|
|
var route = ENC_ROUTES[r.inner.path];
|
|
var result;
|
|
if (!route) result = { ok: false, msg: '不支持的加密接口: ' + r.inner.path };
|
|
else {
|
|
try { result = route(r.inner.body || {}, req, ip); }
|
|
catch (e2) { result = { ok: false, msg: '处理失败: ' + e2.message }; }
|
|
}
|
|
sendJson(res, 加密响应(r.aesKey, result));
|
|
});
|
|
}
|
|
|
|
// ---- 客户端会员接口:仅加密通道提供(HTTP 端口返回迁移提示) ----
|
|
var 仅TLS = (urlPath === '/api/login' || urlPath === '/api/register' || urlPath === '/api/member' ||
|
|
urlPath === '/api/changepwd');
|
|
if (仅TLS && !isTLS) return sendJson(res, TLS_HINT);
|
|
|
|
// 管理密码登录/登录态/改管理密码
|
|
if (urlPath === '/api/admin/login') return readBody(req, function (e, b) {
|
|
b = b || {};
|
|
var lock = 被锁秒('adm:' + ip);
|
|
if (lock) return sendJson(res, { ok: false, msg: '尝试过于频繁,请 ' + lock + ' 秒后再试' });
|
|
if (!管理密码已设置()) return sendJson(res, { ok: false, msg: '管理密码未设置(请在安装向导或应用设置中设置)' });
|
|
if (!管理密码正确(b['密码'])) { 失败记录('adm:' + ip); return sendJson(res, { ok: false, msg: '管理密码错误' }); }
|
|
失败清零('adm:' + ip);
|
|
return sendJson(res, { ok: true, token: 新token() });
|
|
});
|
|
if (urlPath === '/api/admin/check') return sendJson(res, { ok: 是管理员(req), adminConfigured: 管理密码已设置() });
|
|
if (urlPath === '/api/admin/addmember') return readBody(req, function (e, b) {
|
|
if (!是管理员(req)) return sendJson(res, { ok: false, msg: '未登录或登录已过期' });
|
|
b = b || {};
|
|
if (!/^1\d{10}$/.test(String(b['手机号'] || ''))) return sendJson(res, { ok: false, msg: '手机号格式不正确(11 位数字)' });
|
|
var p = String(b['密码'] || '');
|
|
if (p.length < 4 || p.length > 64) return sendJson(res, { ok: false, msg: '密码长度需 4-64 位' });
|
|
var db = 读库();
|
|
for (var i = 0; i < db['会员'].length; i++)
|
|
if (db['会员'][i]['手机号'] === b['手机号']) return sendJson(res, { ok: false, msg: '该手机号已注册' });
|
|
db['会员'].push({
|
|
'手机号': b['手机号'], '密码': 哈希密码(p),
|
|
'会员类型': String(b['会员类型'] || '试用会员'),
|
|
'有效期': String(b['有效期'] || 今天加天数(30)),
|
|
'注册时间': 今天加天数(0), '备注': String(b['备注'] || '')
|
|
});
|
|
备份库();
|
|
写库(db);
|
|
return sendJson(res, { ok: true, msg: '创建成功' });
|
|
});
|
|
// TLS 证书导入/信息/重置(管理登录)
|
|
if (urlPath === '/api/admin/tls/info') {
|
|
if (!是管理员(req)) return sendJson(res, { ok: false, msg: '未登录或登录已过期' });
|
|
try {
|
|
var crtText = fs.readFileSync(TLS_CRT_FILE, 'utf8');
|
|
var tlsInfo = 解析证书(crtText);
|
|
tlsInfo.source = (tlsInfo.subject.indexOf('fnnas-huiyuan') >= 0 && tlsInfo.issuer.indexOf('fnnas-huiyuan') >= 0) ? 'selfsigned' : 'custom';
|
|
return sendJson(res, { ok: true, tls: tlsInfo });
|
|
} catch (e) { return sendJson(res, { ok: false, msg: '证书读取失败: ' + e.message }); }
|
|
}
|
|
if (urlPath === '/api/admin/tls/import') return readBody(req, function (e, b) {
|
|
if (!是管理员(req)) return sendJson(res, { ok: false, msg: '未登录或登录已过期' });
|
|
b = b || {};
|
|
if (!b.cert || !b.key) return sendJson(res, { ok: false, msg: '请同时提供证书文件和私钥文件(PEM 格式)' });
|
|
var info;
|
|
try { info = 解析证书(b.cert); }
|
|
catch (e2) { return sendJson(res, { ok: false, msg: '证书文件无法解析(需 PEM 格式;证书链请用 fullchain 全链文件): ' + e2.message }); }
|
|
if (!密钥证书匹配(b.key, b.cert)) return sendJson(res, { ok: false, msg: '私钥与证书不匹配,请确认两个文件是同一套' });
|
|
try {
|
|
fs.writeFileSync(TLS_CRT_FILE, String(b.cert));
|
|
fs.writeFileSync(TLS_KEY_FILE, String(b.key), { mode: 0o600 });
|
|
console.log('已导入自定义 TLS 证书: ' + info.subject);
|
|
// 先响应本请求,再热切换监听(切换会断开旧连接,不能打断响应本身)
|
|
res.on('finish', function () { setTimeout(热重载证书, 200); });
|
|
return sendJson(res, { ok: true, tls: info, msg: '导入成功,已立即生效' });
|
|
} catch (e3) { return sendJson(res, { ok: false, msg: '写入证书失败: ' + e3.message }); }
|
|
});
|
|
if (urlPath === '/api/admin/tls/reset') {
|
|
if (!是管理员(req)) return sendJson(res, { ok: false, msg: '未登录或登录已过期' });
|
|
try {
|
|
生成自签证书();
|
|
res.on('finish', function () { setTimeout(热重载证书, 200); });
|
|
return sendJson(res, { ok: true, tls: 解析证书(fs.readFileSync(TLS_CRT_FILE, 'utf8')) });
|
|
} catch (e) { return sendJson(res, { ok: false, msg: '重置失败: ' + e.message }); }
|
|
}
|
|
if (urlPath === '/api/admin/changepwd') return readBody(req, function (e, b) {
|
|
if (!是管理员(req)) return sendJson(res, { ok: false, msg: '未登录或登录已过期' });
|
|
b = b || {};
|
|
var p = String(b['新密码'] || '');
|
|
if (p.length < 6) return sendJson(res, { ok: false, msg: '新管理密码至少 6 位' });
|
|
try { 设置管理密码(p); return sendJson(res, { ok: true }); }
|
|
catch (e2) { return sendJson(res, { ok: false, msg: '写入配置失败: ' + e2.message }); }
|
|
});
|
|
|
|
// (客户端会员接口 login/register/member/changepwd 已迁至加密通道 /api/enc,见上)
|
|
|
|
// 管理 API(需 X-Admin-Token;自定义头跨站请求带不了,同时天然防 CSRF)
|
|
if (urlPath === '/api/list') {
|
|
if (!是管理员(req)) return sendJson(res, { ok: false, msg: '未登录或登录已过期' });
|
|
var db = 读库();
|
|
return sendJson(res, { ok: true, '会员': db['会员'] });
|
|
}
|
|
if (urlPath === '/api/save') return readBody(req, function (e, b) {
|
|
if (!是管理员(req)) return sendJson(res, { ok: false, msg: '未登录或登录已过期' });
|
|
if (e || !b || !Array.isArray(b['会员'])) return sendJson(res, { ok: false, msg: '参数错误' });
|
|
// 密码语义:空=保持现有;明文=重置该会员密码(哈希入库);符合哈希格式=原样保留(管理页回传未改值)
|
|
var 旧库 = 读库();
|
|
var 旧密码 = {};
|
|
旧库['会员'].forEach(function (m) { if (m['手机号']) 旧密码[m['手机号']] = m['密码'] || ''; });
|
|
b['会员'].forEach(function (m, idx) {
|
|
var p = m['密码'];
|
|
if (!p) {
|
|
m['密码'] = 旧密码[m['手机号']] !== undefined ? 旧密码[m['手机号']]
|
|
: (旧库['会员'][idx] ? 旧库['会员'][idx]['密码'] || '' : '');
|
|
} else if (!哈希格式.test(String(p))) {
|
|
m['密码'] = 哈希密码(p);
|
|
}
|
|
});
|
|
备份库();
|
|
写库(b);
|
|
return sendJson(res, { ok: true });
|
|
});
|
|
|
|
// ---- 项目云路由(HTTPS:会员密码或管理 token;HTTP:仅管理 token,网页管理用) ----
|
|
// 上传:body = JSON 文本(项目编号/名称/手机号/密码) + "\n\n" + zip 二进制
|
|
if (urlPath === '/api/proj/upload') {
|
|
if (!isTLS && !是管理员(req)) return sendJson(res, TLS_HINT);
|
|
var 收到 = 0, 超限 = false;
|
|
var chunks = [];
|
|
req.on('data', function (c) {
|
|
收到 += c.length;
|
|
if (收到 > UPLOAD_MAX) { 超限 = true; req.destroy(); return; }
|
|
chunks.push(c);
|
|
});
|
|
req.on('end', function () {
|
|
if (超限) return sendJson(res, { ok: false, msg: '超出上传上限 2GB' });
|
|
var buf = Buffer.concat(chunks);
|
|
var sep = buf.indexOf('\n\n');
|
|
if (sep < 0) return sendJson(res, { ok: false, msg: '缺少 JSON 头' });
|
|
var 头 = {};
|
|
try { 头 = JSON.parse(buf.slice(0, sep).toString('utf8')); } catch (e) { return sendJson(res, { ok: false, msg: 'JSON 头解析失败' }); }
|
|
var 手机号 = 头['手机号'], 编号 = 头['编号'];
|
|
if (!手机号 || !编号) return sendJson(res, { ok: false, msg: '缺少手机号或项目编号' });
|
|
if (!项目云鉴权(手机号, 头['密码'], req)) return sendJson(res, { ok: false, msg: '手机号或密码错误' });
|
|
var zip = buf.slice(sep + 2);
|
|
if (zip.length < 100) return sendJson(res, { ok: false, msg: 'zip 数据为空或过小' });
|
|
var d = 项目目录(手机号, 编号);
|
|
if (!d) return sendJson(res, { ok: false, msg: '路径非法' });
|
|
if (目录大小(项目目录(手机号, '')) + zip.length > USER_QUOTA)
|
|
return sendJson(res, { ok: false, msg: '云空间已满(每会员上限 1GB),请联系管理员清理' });
|
|
try {
|
|
fs.mkdirSync(d, { recursive: true });
|
|
var tmp = path.join(d, '项目.zip.tmp');
|
|
fs.writeFileSync(tmp, zip);
|
|
var 目标 = path.join(d, '项目.zip');
|
|
try { fs.unlinkSync(目标); } catch (e) { }
|
|
fs.renameSync(tmp, 目标);
|
|
var meta = { 编号: 编号, 名称: 头['名称'] || '', 时间: 头['时间'] || 今天加天数(0), 大小: zip.length };
|
|
var mt = path.join(d, 'meta.json.tmp');
|
|
fs.writeFileSync(mt, JSON.stringify(meta), 'utf8');
|
|
fs.renameSync(mt, path.join(d, 'meta.json'));
|
|
return sendJson(res, { ok: true, 编号: 编号, 大小: zip.length, 时间: meta['时间'] });
|
|
} catch (e) { return sendJson(res, { ok: false, msg: '写盘失败: ' + e.message }); }
|
|
});
|
|
return;
|
|
}
|
|
if (urlPath === '/api/proj/list') {
|
|
if (!isTLS && !是管理员(req)) return sendJson(res, TLS_HINT);
|
|
if (!项目云鉴权(query['手机号'], query['密码'], req)) return sendJson(res, { ok: false, msg: '手机号或密码错误' });
|
|
return sendJson(res, 列项目(query['手机号']));
|
|
}
|
|
if (urlPath === '/api/proj/download') {
|
|
if (!isTLS && !是管理员(req)) return sendJson(res, TLS_HINT);
|
|
var 手机号 = query['手机号'], 编号 = query['编号'];
|
|
if (!项目云鉴权(手机号, query['密码'], req)) return sendJson(res, { ok: false, msg: '手机号或密码错误' });
|
|
var d2 = 手机号 && 编号 ? 项目目录(手机号, 编号) : null;
|
|
var zp = d2 ? path.join(d2, '项目.zip') : '';
|
|
if (!d2 || !fs.existsSync(zp)) return sendJson(res, { ok: false, msg: '云上没有该项目' });
|
|
// 中文文件名只能放 filename*(UTF-8 百分号编码),ASCII fallback 防 latin-1 编码崩溃
|
|
var 下载名 = 安全名(编号) + '.zip';
|
|
var ascii名 = 下载名.replace(/[^\x20-\x7e]/g, '_');
|
|
res.writeHead(200, {
|
|
'Content-Type': 'application/zip', 'Content-Length': fs.statSync(zp).size,
|
|
'Content-Disposition': "attachment; filename=\"" + ascii名 + "\"; filename*=UTF-8''" + encodeURIComponent(下载名)
|
|
});
|
|
fs.createReadStream(zp).pipe(res);
|
|
return;
|
|
}
|
|
if (urlPath === '/api/proj/delete') return readBody(req, function (e, b) {
|
|
b = b || {};
|
|
if (!isTLS && !是管理员(req)) return sendJson(res, TLS_HINT);
|
|
if (!项目云鉴权(b['手机号'], b['密码'], req)) return sendJson(res, { ok: false, msg: '手机号或密码错误' });
|
|
var d3 = b['手机号'] && b['编号'] ? 项目目录(b['手机号'], b['编号']) : null;
|
|
if (!d3) return sendJson(res, { ok: false, msg: '参数错误' });
|
|
try { fs.rmSync(d3, { recursive: true, force: true }); return sendJson(res, { ok: true }); }
|
|
catch (e2) { return sendJson(res, { ok: false, msg: '删除失败: ' + e2.message }); }
|
|
});
|
|
|
|
// 设置 API(需管理登录)
|
|
if (urlPath === '/api/settings' && req.method === 'GET') {
|
|
if (!是管理员(req)) return sendJson(res, { ok: false, msg: '未登录或登录已过期' });
|
|
return 设置信息(function (j) { sendJson(res, j); });
|
|
}
|
|
if (urlPath === '/api/settings' && req.method === 'POST')
|
|
return readBody(req, function (e, b) {
|
|
if (!是管理员(req)) return sendJson(res, { ok: false, msg: '未登录或登录已过期' });
|
|
if (e || !b) return sendJson(res, { ok: false, msg: '参数错误' });
|
|
if (typeof b.regOpen === 'boolean') {
|
|
try {
|
|
var c = 读配置(); c.HY_REG_OPEN = b.regOpen ? '1' : '0'; 写配置(c);
|
|
return sendJson(res, { ok: true, regOpen: b.regOpen });
|
|
} catch (e2) { return sendJson(res, { ok: false, msg: '写入配置失败: ' + e2.message }); }
|
|
}
|
|
切换数据库目录(b.dbdir || '', function (j) { sendJson(res, j); });
|
|
});
|
|
|
|
// 静态文件(会员管理页/设置页)
|
|
if (urlPath === '/' || urlPath === '/admin.html') urlPath = '/admin.html';
|
|
var file = path.join(WWW, path.normalize(urlPath).replace(/^([A-Za-z]:)?[\\\/]+/, ''));
|
|
if (file.indexOf(WWW) !== 0) { res.writeHead(403); res.end('Forbidden'); return; }
|
|
fs.readFile(file, function (err, data) {
|
|
if (err) { res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' }); res.end('Not Found: ' + urlPath); return; }
|
|
var ext = path.extname(file).toLowerCase();
|
|
// 禁止缓存:应用升级后浏览器必须取新页面,避免跑旧版脚本
|
|
res.writeHead(200, { 'Content-Type': MIME[ext] || 'application/octet-stream', 'Cache-Control': 'no-cache' });
|
|
res.end(data);
|
|
});
|
|
}
|
|
|
|
// ---- 全站 HTTPS(唯一监听;HTTP 明文通道彻底停用) ----
|
|
var TLS_KEY_FILE = path.join(CFG_DIR, 'tls.key');
|
|
var TLS_CRT_FILE = path.join(CFG_DIR, 'tls.crt');
|
|
function TLS指纹() { // 证书 SHA256 前 16 位,供管理员核验
|
|
try { return crypto.createHash('sha256').update(fs.readFileSync(TLS_CRT_FILE)).digest('hex').slice(0, 16).toUpperCase(); }
|
|
catch (e) { return ''; }
|
|
}
|
|
function 生成自签证书() {
|
|
execFileSync('openssl', ['req', '-x509', '-newkey', 'rsa:2048', '-nodes',
|
|
'-keyout', TLS_KEY_FILE, '-out', TLS_CRT_FILE, '-days', '3650',
|
|
'-subj', '/CN=fnnas-huiyuan'], { stdio: 'ignore' });
|
|
console.log('已生成自签 TLS 证书: ' + TLS_CRT_FILE);
|
|
}
|
|
// 用 openssl 解析证书文本 → 结构化信息(导入校验与设置页展示用)
|
|
function 解析证书(pemCert) {
|
|
var tmp = path.join(CFG_DIR, '.import-cert.pem');
|
|
fs.writeFileSync(tmp, String(pemCert));
|
|
try {
|
|
var out = execFileSync('openssl', ['x509', '-in', tmp, '-noout',
|
|
'-subject', '-issuer', '-startdate', '-enddate', '-ext', 'subjectAltName'], { encoding: 'utf8' });
|
|
var info = { subject: '', issuer: '', notBefore: '', notAfter: '', san: '' };
|
|
out.split(/\r?\n/).forEach(function (line) {
|
|
if (line.indexOf('subject=') === 0) info.subject = line.slice(8).trim();
|
|
else if (line.indexOf('issuer=') === 0) info.issuer = line.slice(7).trim();
|
|
else if (line.indexOf('notBefore=') === 0) info.notBefore = line.slice(10).trim();
|
|
else if (line.indexOf('notAfter=') === 0) info.notAfter = line.slice(9).trim();
|
|
else if (line.indexOf('Subject Alternative Name') >= 0 && line.indexOf(':') >= 0)
|
|
info.san = line.slice(line.indexOf(':') + 1).trim();
|
|
});
|
|
info.fp = crypto.createHash('sha256').update(pemCert).digest('hex').slice(0, 16).toUpperCase();
|
|
return info;
|
|
} finally { try { fs.unlinkSync(tmp); } catch (e) { } }
|
|
}
|
|
// 校验私钥与证书匹配(公钥比对)
|
|
function 密钥证书匹配(pemKey, pemCert) {
|
|
var k = path.join(CFG_DIR, '.import-key.pem'), c = path.join(CFG_DIR, '.import-cert.pem');
|
|
fs.writeFileSync(k, String(pemKey)); fs.writeFileSync(c, String(pemCert));
|
|
try {
|
|
var pub1 = execFileSync('openssl', ['pkey', '-in', k, '-pubout'], { encoding: 'utf8' });
|
|
var pub2 = execFileSync('openssl', ['x509', '-in', c, '-noout', '-pubkey'], { encoding: 'utf8' });
|
|
return pub1.replace(/\s+/g, '') === pub2.replace(/\s+/g, '');
|
|
} finally { try { fs.unlinkSync(k); } catch (e) { } try { fs.unlinkSync(c); } catch (e2) { } }
|
|
}
|
|
var HTTPS_SERVER = null; // 当前 HTTPS 监听(导入/重置证书时整体热切换)
|
|
function TLS选项() {
|
|
return {
|
|
key: fs.readFileSync(TLS_KEY_FILE),
|
|
cert: fs.readFileSync(TLS_CRT_FILE),
|
|
SNICallback: function (servername, cb) { // 域名访问(SNI)握手期间动态取上下文,配合热切换
|
|
try { cb(null, require('tls').createSecureContext({ key: fs.readFileSync(TLS_KEY_FILE), cert: fs.readFileSync(TLS_CRT_FILE) })); }
|
|
catch (e) { cb(e); }
|
|
}
|
|
};
|
|
}
|
|
function 启动HTTPS监听(首次) {
|
|
var https = require('https');
|
|
var srv = https.createServer(TLS选项(), function (req, res) { handler(req, res, true); });
|
|
srv.on('error', function (e) {
|
|
var msg = 'HTTPS 监听失败: ' + e.message + (e.code === 'EADDRINUSE' ? '(端口被占用,可在应用设置中更换端口)' : '');
|
|
if (首次) { console.error(msg); process.exit(1); }
|
|
console.error(msg + ',1 秒后重试');
|
|
setTimeout(function () { try { 启动HTTPS监听(false); } catch (e2) { console.error(e2.message); } }, 1000);
|
|
});
|
|
HTTPS_SERVER = srv;
|
|
srv.listen(PORT, HOST, function () {
|
|
if (首次) {
|
|
console.log('会员系统服务 v' + VERSION + '(全站 HTTPS) on https://' + HOST + ':' + PORT
|
|
+ ' 数据库=' + DB_FILE + (DB_DIR === DEFAULT_DIR ? '(默认目录)' : '(自定义目录)')
|
|
+ ' 项目云=' + 项目根()
|
|
+ ' 默认目录=' + DEFAULT_DIR
|
|
+ ' 证书指纹=' + TLS指纹() + ' RSA指纹=' + (RSA_KEY ? 公钥指纹() : '未初始化'));
|
|
} else {
|
|
console.log('HTTPS 证书已热切换并重新监听,当前指纹=' + TLS指纹());
|
|
}
|
|
});
|
|
}
|
|
function 热重载证书() { // 导入/重置证书后调用:断开旧连接,用新证书重建监听
|
|
try { if (HTTPS_SERVER) { HTTPS_SERVER.closeAllConnections(); HTTPS_SERVER.close(); } } catch (e) { }
|
|
启动HTTPS监听(false);
|
|
}
|
|
(function 启动HTTPS() {
|
|
try {
|
|
if (!fs.existsSync(TLS_KEY_FILE) || !fs.existsSync(TLS_CRT_FILE)) 生成自签证书();
|
|
} catch (e) {
|
|
console.error('TLS 证书初始化失败(本应用强制全站 HTTPS,拒绝以明文启动): ' + e.message);
|
|
process.exit(1);
|
|
}
|
|
启动HTTPS监听(true);
|
|
})();
|