한국어 AI 콘텐츠 안전 필터링: 유니코드 정규화, 자모 조합, 실시간 스트리밍 검사

// content-safety.service.ts — 4단계 정규화 파이프라인
private normalizeText(text: string): string {
  // 1. Unicode NFC 정규화 — 조합형/완성형 통일
  let normalized = text.normalize('NFC');
  // 2. 소문자 변환 — 영문 대소문자 우회 방지
  normalized = normalized.toLowerCase();
  // 3. 공백 제거 — "아 동" → "아동" 우회 차단
  normalized = normalized.replace(/\s+/g, '');
  // 4. 자모 조합 — ㅇㅏㄷㅗㅇ → 아동
  normalized = this.combineKoreanJamo(normalized);
  return normalized;
}

// content-safety.service.ts — 정규화된 문자열끼리 비교
checkText(
  text: string,
  blacklist: string[],
): { flagged: boolean; matchedKeywords: string[] } {
  const normalized = this.normalizeText(text);
  const matchedKeywords: string[] = [];

  for (const keyword of blacklist) {
    const normalizedKeyword = this.normalizeText(keyword);
    if (normalized.includes(normalizedKeyword)) {
      matchedKeywords.push(keyword);
    }
  }

  return {
    flagged: matchedKeywords.length > 0,
    matchedKeywords,
  };
}

코드포인트 = (초성 × 21 + 중성) × 28 + 종성 + 0xAC00

// 초성 매핑: 호환 자모 코드 → 초성 인덱스 (0~18)
const CHOSEONG_MAP: Record<number, number> = {
  0x3131: 0,  // ㄱ
  0x3132: 1,  // ㄲ
  0x3134: 2,  // ㄴ
  0x3137: 3,  // ㄷ
  // ... 총 19개 초성
  0x314e: 18, // ㅎ
};

// 중성 매핑: 호환 자모 코드 → 중성 인덱스 (0~20)
const JUNGSEONG_MAP: Record<number, number> = {
  0x314f: 0,  // ㅏ
  0x3150: 1,  // ㅐ
  0x3151: 2,  // ㅑ
  // ... 총 21개 중성
  0x3163: 20, // ㅣ
};

// 종성 매핑: 호환 자모 코드 → 종성 인덱스 (1~27, 0은 종성 없음)
const JONGSEONG_MAP: Record<number, number> = {
  0x3131: 1,  // ㄱ
  0x3132: 2,  // ㄲ
  0x3134: 4,  // ㄴ
  // ... 총 16개 종성
  0x314e: 27, // ㅎ
};

// content-safety.service.ts — 자모 조합 핵심 로직
private combineKoreanJamo(text: string): string {
  const result: string[] = [];
  let i = 0;

  while (i < text.length) {
    const code = text.charCodeAt(i);

    // 현재 문자가 초성이고, 다음 문자가 중성인 경우
    if (this.isChoseong(code) && i + 1 < text.length) {
      const nextCode = text.charCodeAt(i + 1);

      if (this.isJungseong(nextCode)) {
        const cho = CHOSEONG_MAP[code];
        const jung = JUNGSEONG_MAP[nextCode];
        let jong = 0;

        // 종성 후보 확인: 세 번째 문자가 자음인 경우
        if (i + 2 < text.length) {
          const thirdCode = text.charCodeAt(i + 2);

          if (this.isChoseong(thirdCode)) {
            // 핵심 판단: 다음 글자의 초성인가, 현재 글자의 종성인가?
            // → 뒤에 모음이 오면 다음 글자의 초성, 아니면 종성
            if (
              i + 3 >= text.length ||
              !this.isJungseong(text.charCodeAt(i + 3))
            ) {
              if (JONGSEONG_MAP[thirdCode] !== undefined) {
                jong = JONGSEONG_MAP[thirdCode];
                i += 3;
                result.push(
                  String.fromCharCode(
                    (cho * 21 + jung) * 28 + jong + 0xac00
                  ),
                );
                continue;
              }
            }
          }
        }

        // 종성 없이 조합
        result.push(
          String.fromCharCode((cho * 21 + jung) * 28 + jong + 0xac00),
        );
        i += 2;
        continue;
      }
    }

    result.push(text[i]);
    i++;
  }

  return result.join('');
}

// content-safety.service.spec.ts
it('should detect sexual keywords in jamo form (bypass attempt)', () => {
  // "ㅅㅔㄱㅅㅡ" → 정규화 → "섹스"
  const result = service.checkText('ㅅㅔㄱㅅㅡ', sexualKeywords);
  expect(result.flagged).toBe(true);
});

// chat.controller.ts — 입력 필터링 + 환불 로직
// 입력 필터: 블랙리스트 키워드 검사
const blacklist = await this.contentSafety.loadBlacklist();
const inputCheck = this.contentSafety.checkText(content, blacklist);
if (inputCheck.flagged) {
  await this.contentSafety.logSafetyEvent({
    sessionId,
    userId: (req as { user?: { userId?: string } }).user?.userId,
    filterStage: 'input',
    originalContent: content,
    matchedKeywords: inputCheck.matchedKeywords,
    action: 'blocked',
  });

  // BIL-016: 입력 필터 차단 시 행동력(+젬) 환불
  if (energyResult) {
    await this.energyService.refundEnergy(
      userId, ENERGY_CONSTANTS.COST_PER_ACTION
    );
    if (energyResult.gemCharged) {
      await this.gemsService.refund(
        userId, GemTransactionReason.ENERGY_CHARGE, sessionId
      );
    }
  }

  // SSE 에러 이벤트로 차단 사유 전송
  res.write(`event: error\ndata: ${JSON.stringify({
    message: '부적절한 내용이 포함되어 있어 전송할 수 없습니다.',
    code: 'INPUT_FILTER_BLOCKED',
    energyRefunded: true,
    gemRefunded,
  })}\n\n`);
  res.end();
  return;
}

// chat.controller.ts — 스트리밍 중 출력 필터링
const result = await this.aiPipelineService.runStream(
  pipelineContext,
  (item) => {
    // 출력 필터: 블랙리스트 키워드 검사
    const outputCheck = this.contentSafety.checkText(
      item.text, blacklist
    );
    if (outputCheck.flagged) {
      this.contentSafety.logSafetyEvent({
        sessionId,
        filterStage: 'output',
        originalContent: item.text,
        matchedKeywords: outputCheck.matchedKeywords,
        action: 'replaced',
      }).catch((err) => this.logger.warn('Safety log failed', err));
      // 대체 나레이션 전송
      res.write(
        `event: narration\ndata: ${JSON.stringify({
          text: '묘한 침묵이 흘렀다.'
        })}\n\n`
      );
      return;
    }
    // 정상 콘텐츠 스트리밍
    if (item.type === 'narration') {
      res.write(`event: narration\ndata: ${JSON.stringify({
        text: item.text
      })}\n\n`);
    } else if (item.type === 'dialogue') {
      res.write(`event: dialogue\ndata: ${JSON.stringify({
        character: item.character, text: item.text
      })}\n\n`);
    }
  },
);

// ai-pipeline.service.ts — 정적 NSFW 패턴
private static readonly NSFW_PATTERNS = [
  /섹스/, /성관계/, /성행위/, /자위/,
  /가슴.*벗/, /벗.*가슴/, /옷.*벗/, /벗.*옷/,
  // ... 총 17개 패턴
];

// NSFW 감지 시 호감도 양수 차단
if (this.containsNsfwContent(userMessage, aiResponseText)) {
  rawAffinityChanges = rawAffinityChanges.map((c) => ({
    ...c,
    delta: Math.min(0, c.delta), // 양수를 0으로 클램핑
    reason: c.delta > 0
      ? `${c.reason} [NSFW 가드: 긍정 변화 차단]`
      : c.reason,
  }));
}

// content-safety.service.ts — Redis 캐싱
const BLACKLIST_CACHE_KEY = 'safety:blacklist';
const BLACKLIST_CACHE_TTL = 3600; // 1시간

async loadBlacklist(): Promise<string[]> {
  const cached = await this.redis.get(BLACKLIST_CACHE_KEY);
  if (cached) {
    try {
      return JSON.parse(cached) as string[];
    } catch {
      await this.redis.del(BLACKLIST_CACHE_KEY); // 파싱 실패 시 캐시 삭제
    }
  }

  // DB에서 활성 키워드만 조회
  const keywords = await this.prisma.blacklistKeyword.findMany({
    where: { isActive: true },
    select: { keyword: true },
  });

  const list = keywords.map((k) => k.keyword);
  await this.redis.set(BLACKLIST_CACHE_KEY, JSON.stringify(list), {
    ex: BLACKLIST_CACHE_TTL,
  });
  return list;
}

model ContentSafetyLog {
  id              String   @id @default(uuid())
  sessionId       String?  @map("session_id")
  userId          String?  @map("user_id")
  filterStage     String   @map("filter_stage")     // 'input' | 'output'
  originalContent String   @map("original_content")
  matchedKeywords String[] @map("matched_keywords")
  action          String                              // 'blocked' | 'replaced'
  createdAt       DateTime @default(now())

  @@index([sessionId])
  @@index([userId])
  @@index([createdAt])
}