jakciehan
522 lines
16 KiB
JavaScript
522 lines
16 KiB
JavaScript
/**
|
||
* ContentSecurityManager
|
||
* Client-side content security filtering for WeChat mini game.
|
||
*
|
||
* Features:
|
||
* - Local sensitive word filtering (50ms target)
|
||
* - Remote word list fetching with 24-hour local cache
|
||
* - Built-in fallback word list when remote fetch fails
|
||
* - Incremental word list updates without blocking ongoing checks
|
||
* - Integration with server-side msgSecCheck/imgSecCheck APIs
|
||
*/
|
||
|
||
// ============================================================
|
||
// Configuration
|
||
// ============================================================
|
||
const CACHE_KEY = 'content_security_word_cache';
|
||
const CACHE_VERSION_KEY = 'content_security_word_version';
|
||
const CACHE_TIMESTAMP_KEY = 'content_security_word_timestamp';
|
||
const CACHE_VALIDITY_MS = 24 * 60 * 60 * 1000; // 24 hours
|
||
const SERVER_BASE_URL = ''; // Will use relative URL or configured server URL
|
||
const DEFAULT_GAME_ID = 'tankwar'; // Default game identifier for multi-tenant isolation
|
||
|
||
// Scene mapping (must match server-side)
|
||
const SCENE = {
|
||
NICKNAME: 1,
|
||
CHAT: 2,
|
||
SIGNATURE: 3,
|
||
DESCRIPTION: 4,
|
||
};
|
||
|
||
// Report reasons
|
||
const REPORT_REASONS = {
|
||
POLITICS: 'politics',
|
||
PORNOGRAPHY: 'pornography',
|
||
GAMBLING: 'gambling',
|
||
OTHER: 'other',
|
||
};
|
||
|
||
// Report reason display labels
|
||
const REPORT_REASON_LABELS = {
|
||
politics: '政治有害',
|
||
pornography: '色情低俗',
|
||
gambling: '赌博诈骗',
|
||
other: '其他',
|
||
};
|
||
|
||
// ============================================================
|
||
// Built-in Fallback Sensitive Word List
|
||
// This is used when the remote word list is unavailable.
|
||
// ============================================================
|
||
const FALLBACK_WORDS = [
|
||
// Politics
|
||
'颠覆国家', '推翻政权', '分裂国家', '恐怖组织', '极端主义',
|
||
'法轮', '法轮功', '台独', '藏独', '疆独',
|
||
'习近平', '刁近平', '习大大', '习主席', '习总',
|
||
'XiJinping', 'xijinping', '习近', '近平',
|
||
'李强', '王岐山', '栗战书', '汪洋', '韩正',
|
||
'李克强', '胡锦涛', '江泽民', '温家宝', '朱镕基',
|
||
'邓小平', '毛泽东', '周恩来', '刘少奇', '彭德怀',
|
||
'薄熙来', '周永康', '徐才厚', '郭伯雄', '令计划',
|
||
'孙政才', '赵乐际', '王沪宁', '丁薛祥', '蔡奇',
|
||
// Pornography
|
||
'色情', '淫秽', '裸体', '卖淫', '嫖娼',
|
||
'约炮', '援交', '一夜情', '黄色视频',
|
||
// Gambling
|
||
'赌博', '赌场', '下注', '博彩', '六合彩',
|
||
'时时彩', '赌球', '百家乐', '老虎机',
|
||
// Violence
|
||
'杀人', '砍人', '捅死', '自制炸弹', '血腥屠杀',
|
||
// Abuse
|
||
'傻逼', '操你', '妈的', '草泥马', '脑残',
|
||
'贱人', '狗日的', '废物', '滚蛋', '王八蛋',
|
||
// Fraud
|
||
'代开发票', '传销', '诈骗', '洗钱',
|
||
// Other
|
||
'代孕', '毒品', '吸毒', '走私', '枪支',
|
||
];
|
||
|
||
class ContentSecurityManager {
|
||
constructor() {
|
||
/** @type {string[]} Active sensitive word list */
|
||
this._words = [];
|
||
|
||
/** @type {string} Current word list version */
|
||
this._version = '';
|
||
|
||
/** @type {boolean} Whether the manager is initialized */
|
||
this._initialized = false;
|
||
|
||
/** @type {boolean} Whether an update is in progress */
|
||
this._updating = false;
|
||
|
||
/** @type {string} Server base URL for API calls */
|
||
this._serverUrl = '';
|
||
|
||
/** @type {string} Game identifier for multi-tenant isolation */
|
||
this._gameId = DEFAULT_GAME_ID;
|
||
}
|
||
|
||
/**
|
||
* Initialize the manager: load cached words, then fetch latest.
|
||
* @param {object} [options]
|
||
* @param {string} [options.serverUrl] - Server base URL
|
||
* @returns {Promise<void>}
|
||
*/
|
||
async init(options = {}) {
|
||
this._serverUrl = options.serverUrl || '';
|
||
this._gameId = options.gameId || DEFAULT_GAME_ID;
|
||
|
||
// Try to load from cache first
|
||
this._loadFromCache();
|
||
|
||
// If no cached words, use fallback
|
||
if (this._words.length === 0) {
|
||
this._words = [...FALLBACK_WORDS];
|
||
console.log('[ContentSecurity] Using fallback word list (' + this._words.length + ' words)');
|
||
}
|
||
|
||
this._initialized = true;
|
||
|
||
// Fetch latest words from server (non-blocking)
|
||
this.fetchWordList();
|
||
|
||
console.log('[ContentSecurity] Initialized with ' + this._words.length + ' words');
|
||
}
|
||
|
||
/**
|
||
* Check text content against local sensitive words.
|
||
* Must complete within 50ms.
|
||
* @param {string} content - Text to check
|
||
* @returns {{ hasViolation: boolean, matchedWords: string[] }}
|
||
*/
|
||
checkLocalText(content) {
|
||
if (!content || typeof content !== 'string') {
|
||
return { hasViolation: false, matchedWords: [] };
|
||
}
|
||
|
||
const startTime = Date.now();
|
||
const lowerContent = content.toLowerCase();
|
||
// Strip common evasion characters (punctuation, spaces, zero-width chars) for split-char detection
|
||
const strippedContent = content.replace(/[\s\u3000.,;:!?·…—\-_\|\\/～~`@#$%^&*+=<>()\[\]{}""''「」『』【】（）〈〕\u200b\u200c\u200d\ufeff]/g, '').toLowerCase();
|
||
const matchedWords = [];
|
||
|
||
for (let i = 0; i < this._words.length; i++) {
|
||
const word = this._words[i];
|
||
if (!word) continue;
|
||
const lowerWord = word.toLowerCase();
|
||
// Direct match
|
||
if (lowerContent.includes(lowerWord)) {
|
||
matchedWords.push(word);
|
||
if (matchedWords.length >= 3) break;
|
||
continue;
|
||
}
|
||
// Split-char evasion match: check if word chars appear in order with evasion chars between
|
||
// Only for multi-char words (length >= 2)
|
||
if (word.length >= 2 && strippedContent.includes(lowerWord)) {
|
||
matchedWords.push(word);
|
||
if (matchedWords.length >= 3) break;
|
||
}
|
||
}
|
||
|
||
const duration = Date.now() - startTime;
|
||
if (duration > 50) {
|
||
console.warn('[ContentSecurity] Local check took ' + duration + 'ms (target: 50ms)');
|
||
}
|
||
|
||
return {
|
||
hasViolation: matchedWords.length > 0,
|
||
matchedWords,
|
||
};
|
||
}
|
||
|
||
/**
|
||
* Check text content via server-side API (msgSecCheck).
|
||
* @param {string} openid - User's openid
|
||
* @param {string} content - Text to check
|
||
* @param {number} scene - Scene value (1=nickname, 2=chat, 3=signature, 4=description)
|
||
* @returns {Promise<{pass: boolean, errcode: number, errmsg: string, suggest: string, label: number}>}
|
||
*/
|
||
async checkTextContent(openid, content, scene) {
|
||
if (!this._serverUrl) {
|
||
return {
|
||
pass: true,
|
||
errcode: 0,
|
||
errmsg: 'ok',
|
||
suggest: 'pass',
|
||
label: 100,
|
||
};
|
||
}
|
||
try {
|
||
const res = await this._request({
|
||
url: `${this._serverUrl}/api/content/check-text`,
|
||
method: 'POST',
|
||
data: { openid, content, scene },
|
||
});
|
||
return res;
|
||
} catch (err) {
|
||
console.error('[ContentSecurity] checkTextContent error:', err && (err.message || err.errMsg) || 'unknown');
|
||
return {
|
||
pass: false,
|
||
errcode: -1,
|
||
errmsg: '审核服务暂时不可用，请稍后再试',
|
||
suggest: 'risky',
|
||
label: 100,
|
||
};
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Check image content via server-side API (imgSecCheck).
|
||
* @param {string} filePath - Local temporary file path of the image
|
||
* @param {string} openid - User's openid
|
||
* @returns {Promise<{pass: boolean, errcode: number, errmsg: string}>}
|
||
*/
|
||
async checkImageContent(filePath, openid) {
|
||
if (!this._serverUrl) {
|
||
return { pass: true, errcode: 0, errmsg: 'ok' };
|
||
}
|
||
try {
|
||
const res = await this._uploadImage(filePath, openid);
|
||
return res;
|
||
} catch (err) {
|
||
console.error('[ContentSecurity] checkImageContent error:', err && (err.message || err.errMsg) || 'unknown');
|
||
return {
|
||
pass: false,
|
||
errcode: -1,
|
||
errmsg: '审核服务暂时不可用，请稍后再试',
|
||
};
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Fetch sensitive word list from server with cache validation.
|
||
* Non-blocking: does not interfere with ongoing checks.
|
||
* @returns {Promise<boolean>}
|
||
*/
|
||
async fetchWordList() {
|
||
if (this._updating) return false;
|
||
if (!this._serverUrl) return false;
|
||
this._updating = true;
|
||
|
||
try {
|
||
const res = await this._request({
|
||
url: `${this._serverUrl}/api/content/sensitive-words`,
|
||
method: 'GET',
|
||
data: { version: this._version },
|
||
});
|
||
|
||
if (res.updated && res.words) {
|
||
// Incremental update: replace word list atomically
|
||
this._words = res.words;
|
||
this._version = res.version;
|
||
|
||
// Cache locally
|
||
this._saveToCache();
|
||
|
||
console.log('[ContentSecurity] Word list updated: ' + this._words.length + ' words, version: ' + this._version);
|
||
}
|
||
|
||
this._updating = false;
|
||
return true;
|
||
} catch (err) {
|
||
console.error('[ContentSecurity] fetchWordList error:', err && (err.message || err.errMsg) || 'unknown');
|
||
this._updating = false;
|
||
return false;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Check if user is muted.
|
||
* @param {string} openid
|
||
* @returns {Promise<{isMuted: boolean, remainingMs: number, remainingText: string}>}
|
||
*/
|
||
async getMuteStatus(openid) {
|
||
if (!this._serverUrl) {
|
||
return { isMuted: false, remainingMs: 0, remainingText: '' };
|
||
}
|
||
try {
|
||
const res = await this._request({
|
||
url: `${this._serverUrl}/api/content/user/mute-status`,
|
||
method: 'GET',
|
||
data: { openid },
|
||
});
|
||
return res;
|
||
} catch (err) {
|
||
console.error('[ContentSecurity] getMuteStatus error:', err && (err.message || err.errMsg) || 'unknown');
|
||
return { isMuted: false, remainingMs: 0, remainingText: '' };
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Submit a content report.
|
||
* @param {object} entry
|
||
* @param {string} entry.contentId - Unique content identifier
|
||
* @param {string} entry.targetUserId - Content author's user ID
|
||
* @param {string} entry.contentType - Content type ('chat', 'nickname', 'signature', 'description', 'avatar')
|
||
* @param {string} entry.contentSummary - Content summary
|
||
* @param {string} entry.reporterId - Reporter's user ID
|
||
* @param {string} entry.reason - Report reason
|
||
* @returns {Promise<{success: boolean, message: string}>}
|
||
*/
|
||
async submitReport(entry) {
|
||
if (!this._serverUrl) {
|
||
return { success: false, message: '举报功能暂不可用' };
|
||
}
|
||
try {
|
||
const res = await this._request({
|
||
url: `${this._serverUrl}/api/content/report`,
|
||
method: 'POST',
|
||
data: entry,
|
||
});
|
||
return res;
|
||
} catch (err) {
|
||
console.error('[ContentSecurity] submitReport error:', err && (err.message || err.errMsg) || 'unknown');
|
||
return { success: false, message: '举报提交失败，请稍后再试' };
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Full text check: local check first, then server-side if local passes.
|
||
* @param {string} openid
|
||
* @param {string} content
|
||
* @param {number} scene
|
||
* @returns {Promise<{pass: boolean, localViolation: boolean, serverResult: object|null, errorMessage: string}>}
|
||
*/
|
||
async fullTextCheck(openid, content, scene) {
|
||
// Step 1: Local sensitive word check (fast)
|
||
const localResult = this.checkLocalText(content);
|
||
if (localResult.hasViolation) {
|
||
return {
|
||
pass: false,
|
||
localViolation: true,
|
||
serverResult: null,
|
||
errorMessage: this._getErrorMessage({ suggest: 'risky' }, scene),
|
||
};
|
||
}
|
||
|
||
// Step 2: Check mute status (for nickname/signature/description scenes)
|
||
if (scene === SCENE.NICKNAME || scene === SCENE.SIGNATURE || scene === SCENE.DESCRIPTION) {
|
||
const muteStatus = await this.getMuteStatus(openid);
|
||
if (muteStatus.isMuted) {
|
||
return {
|
||
pass: false,
|
||
localViolation: false,
|
||
serverResult: null,
|
||
errorMessage: '由于违规行为，您暂无法修改个人信息',
|
||
};
|
||
}
|
||
}
|
||
|
||
// Step 3: Server-side msgSecCheck
|
||
const serverResult = await this.checkTextContent(openid, content, scene);
|
||
if (!serverResult.pass) {
|
||
return {
|
||
pass: false,
|
||
localViolation: false,
|
||
serverResult,
|
||
errorMessage: this._getErrorMessage(serverResult, scene),
|
||
};
|
||
}
|
||
|
||
return {
|
||
pass: true,
|
||
localViolation: false,
|
||
serverResult,
|
||
errorMessage: '',
|
||
};
|
||
}
|
||
|
||
/**
|
||
* Get appropriate error message based on scene and result.
|
||
* @param {object} result
|
||
* @param {number} scene
|
||
* @returns {string}
|
||
*/
|
||
_getErrorMessage(result, scene) {
|
||
if (scene === SCENE.NICKNAME) {
|
||
return '昵称包含违规内容，请重新输入';
|
||
}
|
||
if (scene === SCENE.CHAT) {
|
||
return '消息发送失败：内容违规';
|
||
}
|
||
if (scene === SCENE.SIGNATURE || scene === SCENE.DESCRIPTION) {
|
||
return '内容包含违规信息，请修改';
|
||
}
|
||
return '内容违规，请修改';
|
||
}
|
||
|
||
/**
|
||
* Make an HTTP request using wx.request.
|
||
* @param {object} options
|
||
* @returns {Promise<object>}
|
||
*/
|
||
_request(options) {
|
||
return new Promise((resolve, reject) => {
|
||
const header = Object.assign({}, options.header || { 'content-type': 'application/json' });
|
||
// Add X-Game-Id header for multi-tenant isolation
|
||
if (this._gameId) {
|
||
header['X-Game-Id'] = this._gameId;
|
||
}
|
||
wx.request({
|
||
url: options.url,
|
||
method: options.method || 'GET',
|
||
data: options.data || {},
|
||
header,
|
||
success: (res) => {
|
||
if (res.statusCode >= 200 && res.statusCode < 300) {
|
||
resolve(res.data);
|
||
} else {
|
||
reject(new Error(`HTTP ${res.statusCode}`));
|
||
}
|
||
},
|
||
fail: (err) => {
|
||
reject(err);
|
||
},
|
||
});
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Upload image for security check using wx.uploadFile.
|
||
* @param {string} filePath - Local file path
|
||
* @param {string} openid - User openid
|
||
* @returns {Promise<object>}
|
||
*/
|
||
_uploadImage(filePath, openid) {
|
||
return new Promise((resolve, reject) => {
|
||
const header = {};
|
||
if (this._gameId) {
|
||
header['X-Game-Id'] = this._gameId;
|
||
}
|
||
wx.uploadFile({
|
||
url: `${this._serverUrl}/api/content/check-image`,
|
||
filePath,
|
||
name: 'image',
|
||
formData: { openid },
|
||
header,
|
||
success: (res) => {
|
||
if (res.statusCode >= 200 && res.statusCode < 300) {
|
||
try {
|
||
const data = JSON.parse(res.data);
|
||
resolve(data);
|
||
} catch (e) {
|
||
reject(new Error('Invalid response'));
|
||
}
|
||
} else {
|
||
reject(new Error(`HTTP ${res.statusCode}`));
|
||
}
|
||
},
|
||
fail: (err) => {
|
||
reject(err);
|
||
},
|
||
});
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Load word list from local cache.
|
||
*/
|
||
_loadFromCache() {
|
||
try {
|
||
const timestamp = wx.getStorageSync(CACHE_TIMESTAMP_KEY);
|
||
const version = wx.getStorageSync(CACHE_VERSION_KEY);
|
||
const words = wx.getStorageSync(CACHE_KEY);
|
||
|
||
if (timestamp && version && words && Array.isArray(words)) {
|
||
// Check if cache is still valid
|
||
if (Date.now() - timestamp < CACHE_VALIDITY_MS) {
|
||
this._words = words;
|
||
this._version = version;
|
||
console.log('[ContentSecurity] Loaded ' + words.length + ' words from cache (version: ' + version + ')');
|
||
}
|
||
}
|
||
} catch (err) {
|
||
console.error('[ContentSecurity] Failed to load cache:', err.message);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Save word list to local cache.
|
||
*/
|
||
_saveToCache() {
|
||
try {
|
||
wx.setStorageSync(CACHE_KEY, this._words);
|
||
wx.setStorageSync(CACHE_VERSION_KEY, this._version);
|
||
wx.setStorageSync(CACHE_TIMESTAMP_KEY, Date.now());
|
||
} catch (err) {
|
||
console.error('[ContentSecurity] Failed to save cache:', err.message);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Get current word count.
|
||
* @returns {number}
|
||
*/
|
||
getWordCount() {
|
||
return this._words.length;
|
||
}
|
||
|
||
/**
|
||
* Get current version.
|
||
* @returns {string}
|
||
*/
|
||
getVersion() {
|
||
return this._version;
|
||
}
|
||
|
||
/**
|
||
* Check if initialized.
|
||
* @returns {boolean}
|
||
*/
|
||
isInitialized() {
|
||
return this._initialized;
|
||
}
|
||
}
|
||
|
||
// Export scene and report reason constants
|
||
ContentSecurityManager.SCENE = SCENE;
|
||
ContentSecurityManager.REPORT_REASONS = REPORT_REASONS;
|
||
ContentSecurityManager.REPORT_REASON_LABELS = REPORT_REASON_LABELS;
|
||
|
||
module.exports = ContentSecurityManager; |