Merge pull request #47 from yyyCode/harden/login-and-sensitive-word

harden(security): 登录失败不泄露账号状态，敏感词白名单豁免词库误伤

Author: yyyCode

OpenBlog-business/src/main/java/com/yqz/openblog/OpenBlogApplication.java

@@ -2,6 +2,7 @@
 
 import com.yqz.openblog.config.AuthSecurityProperties;
 import com.yqz.openblog.config.CorsProperties;
+import com.yqz.openblog.config.SensitiveWordProperties;
 import com.yqz.openblog.config.SiteProperties;
 import com.yqz.openblog.seo.SeoProperties;
 import org.apache.dubbo.config.spring.context.annotation.EnableDubbo;
@@ -29,7 +30,8 @@
         SiteProperties.class,
         CorsProperties.class,
         AuthSecurityProperties.class,
-        SeoProperties.class
+        SeoProperties.class,
+        SensitiveWordProperties.class
 })
 @ComponentScan(
         basePackages = "com.yqz.openblog",

OpenBlog-business/src/main/java/com/yqz/openblog/config/SensitiveWordProperties.java

@@ -0,0 +1,27 @@
+package com.yqz.openblog.config;
+
+import org.springframework.boot.context.properties.ConfigurationProperties;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 敏感词过滤配置。
+ */
+@ConfigurationProperties(prefix = "openblog.sensitive-word")
+public class SensitiveWordProperties {
+
+    /**
+     * 白名单：命中内置词库但属于误伤的词，在此逐条豁免（词库是通用词表，误伤只能靠这里兜）。
+     * 在启动时并入 DFA，改动需重启生效。
+     */
+    private List<String> allowWords = new ArrayList<>();
+
+    public List<String> getAllowWords() {
+        return allowWords;
+    }
+
+    public void setAllowWords(List<String> allowWords) {
+        this.allowWords = allowWords;
+    }
+}

OpenBlog-business/src/main/java/com/yqz/openblog/forum/filter/SensitiveWordFilter.java

@@ -3,6 +3,7 @@
 import com.github.houbb.sensitive.word.bs.SensitiveWordBs;
 import com.github.houbb.sensitive.word.support.allow.WordAllows;
 import com.github.houbb.sensitive.word.support.deny.WordDenys;
+import com.yqz.openblog.config.SensitiveWordProperties;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.stereotype.Component;
@@ -18,35 +19,48 @@
  *   <li>{@link #findAll(String)} — 返回所有命中的敏感词</li>
  *   <li>{@link #replace(String)} — 用 {@code *} 替换敏感词</li>
  * </ul>
+ * <p>
+ * 内置词库（6W+）是通用词表，必然带误伤：正常词被单独收录，正常语境下也会拦下来
+ * （例：「长期」在词库里是一条裸词，同段落邻居是「找长期小姐」「长期出售手枪」这类垃圾短语）。
+ * 词库自带的 allow 表只有十来条，兜不住，故白名单由
+ * {@code openblog.sensitive-word.allow-words} 配置补充；白名单在 {@code init()} 时并入 DFA，
+ * 改动需重启生效。命中会打 WARN 日志（命中词 + 局部上下文），事后按日志补白名单即可。
  */
 @Component
 public class SensitiveWordFilter {
 
     private static final Logger log = LoggerFactory.getLogger(SensitiveWordFilter.class);
 
+    /** 命中日志里上下文片段前后各留的字数。 */
+    private static final int CONTEXT_PADDING = 12;
+
     private final SensitiveWordBs sw;
 
-    public SensitiveWordFilter() {
-        // 使用内置词库（6W+），后续可扩展从 DB/文件加载自定义词库
+    public SensitiveWordFilter(SensitiveWordProperties properties) {
+        List<String> allowWords = properties.getAllowWords() == null ? List.of() : properties.getAllowWords();
+        // 内置词库 + 配置白名单叠加：白名单是「命中词库但属误伤」的唯一出口
         this.sw = SensitiveWordBs.newInstance()
                 .wordDeny(WordDenys.defaults())
-                .wordAllow(WordAllows.defaults())
+                .wordAllow(WordAllows.chains(WordAllows.defaults(), () -> allowWords))
                 .ignoreCase(true)
                 .ignoreWidth(true)
                 .ignoreNumStyle(true)
                 .ignoreChineseStyle(true)
                 .ignoreEnglishStyle(true)
                 .ignoreRepeat(false)
                 .init();
-        log.info("SensitiveWordFilter initialized");
+        log.info("SensitiveWordFilter initialized, allowWords={}", allowWords);
     }
 
     /**
-     * 是否包含敏感词。
+     * 是否包含敏感词。命中时打一条 WARN（命中词 + 局部上下文）——只记录片段不记录全文。
      */
     public boolean contains(String text) {
         if (text == null || text.isBlank()) return false;
-        return sw.contains(text);
+        if (!sw.contains(text)) return false;
+        List<String> words = findAll(text).stream().distinct().toList();
+        log.warn("敏感词命中 words={} context={}", words, context(text, words));
+        return true;
     }
 
     /**
@@ -64,4 +78,15 @@ public String replace(String text) {
         if (text == null || text.isBlank()) return text;
         return sw.replace(text);
     }
+
+    /** 取首个命中词前后各 {@value #CONTEXT_PADDING} 字、空白压成单空格；无命中返回空串。 */
+    private String context(String text, List<String> words) {
+        if (words.isEmpty()) return "";
+        String first = words.get(0);
+        int idx = text.indexOf(first);
+        if (idx < 0) return "";
+        int start = Math.max(0, idx - CONTEXT_PADDING);
+        int end = Math.min(text.length(), idx + first.length() + CONTEXT_PADDING);
+        return text.substring(start, end).replaceAll("\\s+", " ");
+    }
 }

OpenBlog-business/src/main/java/com/yqz/openblog/forum/service/ForumService.java

@@ -275,8 +275,9 @@ private void ensureUserActive(Long uid) {
     private void checkSensitive(String... texts) {
         for (String text : texts) {
             if (text == null || text.isBlank()) continue;
+            // 命中详情（哪个词、哪段上下文）由 SensitiveWordFilter 内部打 WARN 日志；
+            // 对外仍是通用提示，不回显命中词（那等于把词库送给用户）
             if (sensitiveWordFilter.contains(text)) {
-                List<String> words = sensitiveWordFilter.findAll(text);
                 throw new BizException(4003, "内容包含敏感词，请修改后重试");
             }
         }

OpenBlog-business/src/main/java/com/yqz/openblog/user/service/AuthService.java

@@ -33,6 +33,12 @@
 @Service
 public class AuthService {
 
+    /**
+     * 哨兵口令：仅用于启动时生成一个合法 BCrypt 哈希做恒定开销陪跑（见 {@link #absentAccountHash}）。
+     * 它的明文与哈希都不落库、不回显，也永远不会成为任何账号的凭据。
+     */
+    private static final String ABSENT_ACCOUNT_SENTINEL = "openblog-absent-account-sentinel";
+
     private final UserMapper userMapper;
     private final RefreshTokenMapper refreshTokenMapper;
     private final PasswordEncoder passwordEncoder;
@@ -46,6 +52,13 @@ public class AuthService {
     private final EmailValidator emailValidator;
     private final EmailCodeService emailCodeService;
 
+    /**
+     * 账号不存在时用来陪跑的 BCrypt 哈希（启动时由 {@link #ABSENT_ACCOUNT_SENTINEL} 生成）。
+     * BCrypt 比对是有意设计的慢操作（约几十毫秒），若账号不存在时直接返回，攻击者按响应时间
+     * 就能区分「账号不存在」与「密码错误」——错误提示统一也挡不住这个信道，故补一次等开销比对。
+     */
+    private final String absentAccountHash;
+
     public AuthService(UserMapper userMapper,
                         RefreshTokenMapper refreshTokenMapper,
                         PasswordEncoder passwordEncoder,
@@ -70,6 +83,8 @@ public AuthService(UserMapper userMapper,
         this.mediaService = mediaService;
         this.emailValidator = emailValidator;
         this.emailCodeService = emailCodeService;
+        // 启动时生成一次（约一次 BCrypt 的开销），此后每条「账号不存在」的登录请求复用同一个哈希
+        this.absentAccountHash = passwordEncoder.encode(ABSENT_ACCOUNT_SENTINEL);
     }
 
     public AuthResponse register(RegisterRequest req) {
@@ -132,25 +147,26 @@ public AuthResponse login(LoginRequest req) {
         if (user == null) {
             user = userMapper.selectOne(Wrappers.lambdaQuery(User.class).eq(User::getEmail, req.getAccount()));
         }
-        if (user == null) {
+
+        // 账号不存在时也跑一次 BCrypt（哨兵哈希），与「密码错误」保持等开销，堵住按响应时间枚举账号的信道
+        boolean passwordOk = passwordEncoder.matches(req.getPassword(),
+                user != null && user.getPasswordHash() != null ? user.getPasswordHash() : absentAccountHash);
+        if (user == null || !passwordOk) {
             loginLockoutService.recordPasswordFailure(ipSeg);
             loginLockoutService.recordDevicePasswordFailure(fp);
             throw new BizException(clientErrorCode(), "账号或密码错误");
         }
 
+        // 账号状态必须在密码校验之后判定：放在前面则不需要正确密码，就能从响应区分出
+        // 「账号不存在 / 待审核 / 已封禁」，等于白送一份账号枚举与状态探测接口。
+        // 走到这里密码已证明正确，故不再计失败次数——那是「密码错误」的计数，误计会让同 NAT 出口
+        // 上无关用户被牵连锁定（封禁态本身已是拒绝登录的终态）。
         if ("PENDING".equals(user.getStatus())) {
             throw new BizException(4014, "账号待管理员审核通过后方可登录");
         }
         if ("BANNED".equals(user.getStatus())) {
-            loginLockoutService.recordPasswordFailure(ipSeg);
-            loginLockoutService.recordDevicePasswordFailure(fp);
             throw new BizException(4011, "账号已被封禁");
         }
-        if (!passwordEncoder.matches(req.getPassword(), user.getPasswordHash())) {
-            loginLockoutService.recordPasswordFailure(ipSeg);
-            loginLockoutService.recordDevicePasswordFailure(fp);
-            throw new BizException(clientErrorCode(), "账号或密码错误");
-        }
 
         loginLockoutService.clearFailures(ipSeg);
         loginLockoutService.clearDeviceFailures(fp);

OpenBlog-business/src/main/resources/application.yaml

@@ -122,6 +122,13 @@ openblog:
     issuer: openblog
     access-token-expire-seconds: 7200
     refresh-token-expire-seconds: 2592000
+  # 敏感词过滤白名单：内置词库是通用表，正常词也会被误收（comment/forum 提交时 4003 拦截）。
+  # 「长期」在词库里是一条裸词（邻居是「找长期小姐」「长期出售手枪」这类垃圾短语），
+  # 正常语境（如「长期共事」）会被误伤，故豁免。新增条目依据服务日志的
+  # "敏感词命中 words=... context=..." 行判断；改此项需重启服务。
+  sensitive-word:
+    allow-words:
+      - "长期"
   storage:
     # 存储类型：local（本地磁盘）| minio（对象存储，本地与服务器共用同一 MinIO 即可访问相同图片）
     type: minio

OpenBlog-business/src/test/java/com/yqz/openblog/forum/filter/SensitiveWordFilterTest.java

@@ -0,0 +1,69 @@
+package com.yqz.openblog.forum.filter;
+
+import com.yqz.openblog.config.SensitiveWordProperties;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * 敏感词过滤器回归测试：锁住「内置词库误伤正常表达」这条修复路径。
+ * <p>
+ * 背景：内置词库把「长期」单独收成一条敏感词（词库里它的邻居是「找长期小姐」「长期出售手枪」
+ * 这类垃圾短语，这条裸词疑似切词残留），于是正常语境（「长期共事」）也会被 4003 拦下。
+ * 出口是配置白名单 {@code openblog.sensitive-word.allow-words}。
+ */
+class SensitiveWordFilterTest {
+
+    /** 实际被误拦的一段文字（面试经验分享），正文里除「长期」外没有任何命中。 */
+    private static final String INTERVIEW_PARAGRAPH = """
+            面试中，技术能力决定你能否进入候选池，而非技术因素往往决定你能否最终拿到 Offer。其中最重要的是语言流畅与表达清晰，回答要有结构、少卡顿、语速适中；其次是普通话标准或口音可懂，不要求播音员水平，但必须让面试官轻松听懂。仪容仪表与精神面貌同样关键，着装得体、整洁清爽、视频面试背景干净光线充足，能体现你对机会的重视。此外，礼貌与职业素养、情绪稳定、自信真诚、时间观念也直接影响印象分——准时到场、不打断对方、遇到难题不慌乱、不会的问题坦诚说，都比硬撑或夸大更加分。
+
+            团队协作与沟通意愿是技术岗常被考察的隐性指标，讲述项目时能体现与产品、测试、运维的配合，面对分歧能平和表达，会让面试官觉得你善于协作。学习意愿与成长潜力、文化匹配度与长期性虽然权重稍低，但对初级岗位和长期共事判断很重要，准备一个“最近在学什么”的具体例子、离职原因聚焦成长方向而非抱怨，都能加分。
+
+            总的来说，技术决定你能不能进面试，非技术因素决定你能不能拿 Offer。其中表达清晰、普通话可懂、仪表得体、情绪稳定、真诚自信，是性价比最高的五个发力点，提前练习远比临场紧张更有用。""";
+
+    @Test
+    void interviewParagraph_withAllowWord_notFlagged() {
+        assertFalse(filterWith(List.of("长期")).contains(INTERVIEW_PARAGRAPH));
+    }
+
+    /**
+     * 反证：白名单是这段文字唯一的解药——去掉「长期」后同一段文字立即命中。
+     * 本用例依赖内置词库收录了「长期」；若日后升级词库它开始失败，说明上游已自行修掉该误伤，
+     * 可连同配置里的白名单条目一起删掉。
+     */
+    @Test
+    void sameParagraphWithoutAllowWord_flaggedByBuiltinDict() {
+        assertTrue(filterWith(List.of()).contains(INTERVIEW_PARAGRAPH));
+    }
+
+    /** 白名单只豁免列出的词，不影响词库对真正违规内容的拦截。 */
+    @Test
+    void realDenyWord_stillFlaggedDespiteAllowWords() {
+        assertTrue(filterWith(List.of("长期")).contains("本店代开发票，长期有效"));
+    }
+
+    /** 豁免是精确匹配：「长期」被加白后，词库里含它的垃圾短语仍然照拦。 */
+    @Test
+    void spamPhraseBuiltFromAllowWord_stillFlagged() {
+        assertTrue(filterWith(List.of("长期")).contains("找长期小姐"));
+    }
+
+    /** 空/空白输入不命中（contains 的边界）。 */
+    @Test
+    void blankText_notFlagged() {
+        SensitiveWordFilter filter = filterWith(List.of());
+        assertFalse(filter.contains(null));
+        assertFalse(filter.contains(""));
+        assertFalse(filter.contains("   "));
+    }
+
+    private SensitiveWordFilter filterWith(List<String> allowWords) {
+        SensitiveWordProperties properties = new SensitiveWordProperties();
+        properties.setAllowWords(allowWords);
+        return new SensitiveWordFilter(properties);
+    }
+}