swiftii/SpamPattern.swift at master

 // retoor <retoor@molodetz.nl>
 import Foundation
 struct SpamPattern: Sendable {
     let name: String
     let regex: NSRegularExpression?
     let keywords: [String]
     let minScore: Int
     init(name: String, pattern: String? = nil, keywords: [String] = [], minScore: Int = 1) {
         self.name = name
         self.keywords = keywords.map { $0.lowercased() }
         self.minScore = minScore
         if let pattern = pattern {
             self.regex = try? NSRegularExpression(pattern: pattern, options: [.caseInsensitive])
         } else {
             self.regex = nil
         }
     }
     func matches(_ text: String) -> Bool {
         let lowerText = text.lowercased()
         if let regex = regex {
             let range = NSRange(text.startIndex..., in: text)
             if regex.firstMatch(in: text, options: [], range: range) != nil {
                 return true
             }
         }
         for keyword in keywords {
             if lowerText.contains(keyword) {
                 return true
             }
         }
         return false
     }
 }
 struct SpamDetector: Sendable {
     let patterns: [SpamPattern]
     let repetitionThreshold: Int
     let minAccountAgeSeconds: TimeInterval
     let suspiciousPostFrequencySeconds: TimeInterval
     init() {
         self.patterns = [
             SpamPattern(
                 name: "crypto_scam",
                 pattern: "(?:bitcoin|crypto|ethereum|btc|eth|nft|web3).*(?:invest|earn|profit|money|free|giveaway)",
                 keywords: ["airdrop", "whitelist", "moon", "100x", "1000x"]
             ),
             SpamPattern(
                 name: "promotion_spam",
                 pattern: "(?:check out|visit|click|join|subscribe).*(?:my|our|this).*(?:channel|website|link|discord|telegram)",
                 keywords: ["t.me/", "discord.gg/", "bit.ly/", "tinyurl"]
             ),
             SpamPattern(
                 name: "adult_content",
                 keywords: ["onlyfans", "18+", "xxx", "porn", "nude", "nsfw link"]
             ),
             SpamPattern(
                 name: "repetitive_chars",
                 pattern: "(.)\\1{10,}",
                 minScore: 2
             ),
             SpamPattern(
                 name: "excessive_caps",
                 pattern: "^[A-Z\\s!?]{50,}$"
             ),
             SpamPattern(
                 name: "phishing",
                 pattern: "(?:verify|confirm|update).*(?:account|password|login|credentials)",
                 keywords: ["suspended", "blocked", "verify now", "act now", "urgent"]
             ),
             SpamPattern(
                 name: "gambling",
                 keywords: ["casino", "betting", "poker online", "slots", "jackpot", "win big"]
             ),
             SpamPattern(
                 name: "malware_links",
                 pattern: "(?:download|install|get).*(?:free|cracked|hack|keygen|patch)"
             )
         ]
         self.repetitionThreshold = 3
         self.minAccountAgeSeconds = 86400 * 7
         self.suspiciousPostFrequencySeconds = 60
     }
     func analyze(_ text: String) -> SpamAnalysis {
         var matchedPatterns: [String] = []
         var totalScore = 0
         for pattern in patterns {
             if pattern.matches(text) {
                 matchedPatterns.append(pattern.name)
                 totalScore += pattern.minScore
             }
         }
         let linkCount = countLinks(in: text)
         if linkCount > 3 {
             matchedPatterns.append("excessive_links")
             totalScore += linkCount - 2
         }
         let textLength = text.count
         if textLength < 10 && linkCount > 0 {
             matchedPatterns.append("short_with_link")
             totalScore += 2
         }
         return SpamAnalysis(
             isSpam: totalScore >= 2,
             score: totalScore,
             matchedPatterns: matchedPatterns
         )
     }
     func analyzeUserBehavior(posts: [PostInfo]) -> BehaviorAnalysis {
         guard posts.count >= 2 else {
             return BehaviorAnalysis(isSuspicious: false, reasons: [])
         }
         var reasons: [String] = []
         let sortedPosts = posts.sorted { $0.created < $1.created }
         var rapidPosts = 0
         for i in 1..<sortedPosts.count {
             let timeDiff = sortedPosts[i].created.timeIntervalSince(sortedPosts[i-1].created)
             if timeDiff < suspiciousPostFrequencySeconds {
                 rapidPosts += 1
             }
         }
         if rapidPosts >= 3 {
             reasons.append("rapid_posting:\(rapidPosts)")
         }
         let uniqueTexts = Set(posts.map { normalizeText($0.text) })
         let duplicateRatio = 1.0 - (Double(uniqueTexts.count) / Double(posts.count))
         if duplicateRatio > 0.5 && posts.count >= 3 {
             reasons.append("duplicate_content:\(Int(duplicateRatio * 100))%")
         }
         return BehaviorAnalysis(
             isSuspicious: !reasons.isEmpty,
             reasons: reasons
         )
     }
     private func countLinks(in text: String) -> Int {
         let pattern = try? NSRegularExpression(
             pattern: "https?://[^\\s]+",
             options: [.caseInsensitive]
         )
         let range = NSRange(text.startIndex..., in: text)
         return pattern?.numberOfMatches(in: text, options: [], range: range) ?? 0
     }
     private func normalizeText(_ text: String) -> String {
         return text.lowercased()
             .components(separatedBy: .whitespacesAndNewlines)
             .joined(separator: " ")
             .trimmingCharacters(in: .whitespaces)
     }
 }
 struct SpamAnalysis: Sendable {
     let isSpam: Bool
     let score: Int
     let matchedPatterns: [String]
 }
 struct BehaviorAnalysis: Sendable {
     let isSuspicious: Bool
     let reasons: [String]
 }
 struct PostInfo: Sendable {
     let id: Int
     let text: String
     let created: Date
     let authorId: Int
 }