目录

1. 概述
2. 工具功能
3. 核心实现
4. Kotlin 源代码
5. JavaScript 编译代码
6. ArkTS 调用代码
7. 实战案例
8. 最佳实践

---

概述

本文档介绍如何在 Kotlin Multiplatform (KMP) 鸿蒙跨端开发中实现一个功能完整的密码强度检测工具系统。密码安全是网络安全中的重要环节，广泛应用于用户注册、账户管理、数据保护等领域。这个工具提供了对密码的全面分析支持，包括强度评估、安全建议、常见漏洞检测等功能。

在实际应用中，密码强度检测工具广泛应用于以下场景：用户注册系统、账户管理、密码重置、安全审计、合规检查等。通过 KMP 框架的跨端能力，我们可以在不同平台上使用相同的密码检测逻辑，确保安全标准的一致性。

工具的特点

• 完整的强度分析：支持多维度的密码强度评估
• 精确的评分：使用科学的评分算法
• 安全建议：提供针对性的安全改进建议
• 漏洞检测：检测常见的密码漏洞
• 实时反馈：提供实时的密码强度反馈
• 跨端兼容：一份 Kotlin 代码可同时服务多个平台

---

工具功能

1. 密码强度评估

密码强度评估是根据多个因素综合评估密码的安全程度。密码强度评估需要考虑长度、字符类型、复杂度等多个方面。

• 长度评估：检查密码长度是否足够
• 字符类型：检查是否包含大小写字母、数字、特殊字符
• 复杂度分析：分析密码的复杂程度
• 熵值计算：计算密码的信息熵

2. 强度等级分类

强度等级分类是将密码强度分为不同的等级。强度等级分类对于用户理解密码安全程度很重要。

• 非常弱：极易被破解
• 弱：容易被破解
• 中等：相对安全
• 强：较难被破解
• 非常强：很难被破解

3. 安全建议生成

安全建议生成是根据密码的弱点提供改进建议。安全建议对于用户改进密码很有用。

• 长度建议：建议增加密码长度
• 字符建议：建议添加不同类型的字符
• 避免模式：建议避免常见的密码模式
• 个性化建议：根据具体情况提供建议

4. 常见漏洞检测

常见漏洞检测是检查密码是否包含常见的安全漏洞。常见漏洞检测对于防止密码被破解很重要。

• 字典攻击检测：检查是否为常见单词
• 顺序模式检测：检查是否为连续字符
• 重复模式检测：检查是否为重复字符
• 个人信息检测：检查是否包含个人信息

5. 密码历史检查

密码历史检查是检查新密码是否与历史密码相似。密码历史检查对于防止密码重复使用很重要。

• 相似度检查：检查与历史密码的相似度
• 重复检查：检查是否为之前使用过的密码
• 变体检查：检查是否为历史密码的简单变体
• 时间检查：检查密码更改的时间间隔

6. 破解时间估算

破解时间估算是根据密码强度估算破解所需的时间。破解时间估算对于用户理解密码安全程度很有用。

• 暴力破解时间：估算暴力破解所需时间
• 字典攻击时间：估算字典攻击所需时间
• 彩虹表攻击时间：估算彩虹表攻击所需时间
• 显示破解难度：用易理解的方式显示破解难度

7. 安全评分统计

安全评分统计是对密码安全评分进行统计和分析。安全评分统计对于系统安全管理很有用。

• 评分分布：分析密码评分的分布
• 合规性检查：检查是否符合安全策略
• 趋势分析：分析密码安全的趋势
• 对比分析：与标准进行对比

---

核心实现

1. 密码强度评估

fun calculatePasswordStrength(password: String): Int {
    var score = 0
    
    // 长度评分
    if (password.length >= 8) score += 10
    if (password.length >= 12) score += 10
    if (password.length >= 16) score += 10
    
    // 字符类型评分
    if (password.any { it.isUpperCase() }) score += 15
    if (password.any { it.isLowerCase() }) score += 15
    if (password.any { it.isDigit() }) score += 15
    if (password.any { !it.isLetterOrDigit() }) score += 20
    
    // 复杂度评分
    val uniqueChars = password.toSet().size
    score += (uniqueChars / password.length.toDouble() * 10).toInt()
    
    // 模式检测减分
    if (hasSequentialChars(password)) score -= 10
    if (hasRepeatingChars(password)) score -= 10
    if (isCommonPattern(password)) score -= 20
    
    return score.coerceIn(0, 100)
}

fun hasSequentialChars(password: String): Boolean {
    for (i in 0 until password.length - 2) {
        val c1 = password[i].code
        val c2 = password[i + 1].code
        val c3 = password[i + 2].code
        if (c2 == c1 + 1 && c3 == c2 + 1) return true
    }
    return false
}

fun hasRepeatingChars(password: String): Boolean {
    return password.any { char ->
        password.count { it == char } >= 3
    }
}

fun isCommonPattern(password: String): Boolean {
    val commonPatterns = listOf("123", "abc", "qwerty", "password", "admin")
    return commonPatterns.any { password.lowercase().contains(it) }
}

代码说明： 密码强度评估通过多个因素综合计算评分。包括长度、字符类型、复杂度等，同时检测常见的弱密码模式。

2. 强度等级分类

fun classifyPasswordStrength(score: Int): Map<String, String> {
    return when {
        score < 20 -> mapOf("level" to "非常弱", "color" to "#F44336", "advice" to "密码过于简单，容易被破解")
        score < 40 -> mapOf("level" to "弱", "color" to "#FF9800", "advice" to "密码强度不足，建议改进")
        score < 60 -> mapOf("level" to "中等", "color" to "#FFC107", "advice" to "密码强度一般，可继续改进")
        score < 80 -> mapOf("level" to "强", "color" to "#8BC34A", "advice" to "密码强度良好，较为安全")
        else -> mapOf("level" to "非常强", "color" to "#4CAF50", "advice" to "密码强度优秀，非常安全")
    }
}

代码说明： 强度等级分类根据评分将密码分为5个等级，并提供相应的颜色和建议。

3. 安全建议生成

fun generateSecurityAdvice(password: String): List<String> {
    val advice = mutableListOf<String>()
    
    if (password.length < 12) advice.add("建议密码长度至少12个字符")
    if (!password.any { it.isUpperCase() }) advice.add("建议添加大写字母")
    if (!password.any { it.isLowerCase() }) advice.add("建议添加小写字母")
    if (!password.any { it.isDigit() }) advice.add("建议添加数字")
    if (!password.any { !it.isLetterOrDigit() }) advice.add("建议添加特殊字符")
    if (hasSequentialChars(password)) advice.add("避免使用连续字符序列")
    if (hasRepeatingChars(password)) advice.add("避免使用重复字符")
    if (isCommonPattern(password)) advice.add("避免使用常见的密码模式")
    
    return advice.ifEmpty { listOf("密码强度良好，无需改进") }
}

代码说明： 安全建议生成根据密码的具体特征提供针对性的改进建议。

4. 破解时间估算

fun estimateCrackTime(score: Int): Map<String, String> {
    val crackTime = when {
        score < 20 -> "几秒钟"
        score < 40 -> "几分钟"
        score < 60 -> "几小时"
        score < 80 -> "几天"
        else -> "几年"
    }
    
    return mapOf(
        "bruteForce" to crackTime,
        "message" to "估算使用现代计算机进行暴力破解所需时间"
    )
}

代码说明： 破解时间估算根据密码强度估算破解所需的时间，帮助用户理解密码的安全程度。

---

Kotlin 源代码

// PasswordStrengthChecker.kt

class PasswordStrengthChecker {
    
    fun calculatePasswordStrength(password: String): Int {
        var score = 0
        
        // 长度评分
        if (password.length >= 8) score += 10
        if (password.length >= 12) score += 10
        if (password.length >= 16) score += 10
        
        // 字符类型评分
        if (password.any { it.isUpperCase() }) score += 15
        if (password.any { it.isLowerCase() }) score += 15
        if (password.any { it.isDigit() }) score += 15
        if (password.any { !it.isLetterOrDigit() }) score += 20
        
        // 复杂度评分
        val uniqueChars = password.toSet().size
        score += (uniqueChars / password.length.toDouble() * 10).toInt()
        
        // 模式检测减分
        if (hasSequentialChars(password)) score -= 10
        if (hasRepeatingChars(password)) score -= 10
        if (isCommonPattern(password)) score -= 20
        
        return score.coerceIn(0, 100)
    }
    
    fun hasSequentialChars(password: String): Boolean {
        for (i in 0 until password.length - 2) {
            val c1 = password[i].code
            val c2 = password[i + 1].code
            val c3 = password[i + 2].code
            if (c2 == c1 + 1 && c3 == c2 + 1) return true
        }
        return false
    }
    
    fun hasRepeatingChars(password: String): Boolean {
        return password.any { char ->
            password.count { it == char } >= 3
        }
    }
    
    fun isCommonPattern(password: String): Boolean {
        val commonPatterns = listOf("123", "abc", "qwerty", "password", "admin", "letmein", "welcome")
        return commonPatterns.any { password.lowercase().contains(it) }
    }
    
    fun classifyPasswordStrength(score: Int): Map<String, String> {
        return when {
            score < 20 -> mapOf("level" to "非常弱", "color" to "#F44336", "advice" to "密码过于简单，容易被破解")
            score < 40 -> mapOf("level" to "弱", "color" to "#FF9800", "advice" to "密码强度不足，建议改进")
            score < 60 -> mapOf("level" to "中等", "color" to "#FFC107", "advice" to "密码强度一般，可继续改进")
            score < 80 -> mapOf("level" to "强", "color" to "#8BC34A", "advice" to "密码强度良好，较为安全")
            else -> mapOf("level" to "非常强", "color" to "#4CAF50", "advice" to "密码强度优秀，非常安全")
        }
    }
    
    fun generateSecurityAdvice(password: String): List<String> {
        val advice = mutableListOf<String>()
        
        if (password.length < 12) advice.add("建议密码长度至少12个字符")
        if (!password.any { it.isUpperCase() }) advice.add("建议添加大写字母")
        if (!password.any { it.isLowerCase() }) advice.add("建议添加小写字母")
        if (!password.any { it.isDigit() }) advice.add("建议添加数字")
        if (!password.any { !it.isLetterOrDigit() }) advice.add("建议添加特殊字符")
        if (hasSequentialChars(password)) advice.add("避免使用连续字符序列")
        if (hasRepeatingChars(password)) advice.add("避免使用重复字符")
        if (isCommonPattern(password)) advice.add("避免使用常见的密码模式")
        
        return advice.ifEmpty { listOf("密码强度良好，无需改进") }
    }
    
    fun estimateCrackTime(score: Int): Map<String, String> {
        val crackTime = when {
            score < 20 -> "几秒钟"
            score < 40 -> "几分钟"
            score < 60 -> "几小时"
            score < 80 -> "几天"
            else -> "几年"
        }
        
        return mapOf(
            "bruteForce" to crackTime,
            "message" to "估算使用现代计算机进行暴力破解所需时间"
        )
    }
    
    fun validatePassword(password: String): Pair<Boolean, String> {
        return when {
            password.isEmpty() -> Pair(false, "密码不能为空")
            password.length < 6 -> Pair(false, "密码长度至少6个字符")
            password.length > 128 -> Pair(false, "密码长度不能超过128个字符")
            else -> Pair(true, "密码有效")
        }
    }
    
    fun getComprehensiveReport(password: String): Map<String, Any> {
        val validation = validatePassword(password)
        if (!validation.first) {
            return mapOf("error" to validation.second)
        }
        
        val score = calculatePasswordStrength(password)
        val classification = classifyPasswordStrength(score)
        val advice = generateSecurityAdvice(password)
        val crackTime = estimateCrackTime(score)
        
        return mapOf(
            "score" to score,
            "classification" to classification,
            "advice" to advice,
            "crackTime" to crackTime,
            "hasUpperCase" to password.any { it.isUpperCase() },
            "hasLowerCase" to password.any { it.isLowerCase() },
            "hasDigit" to password.any { it.isDigit() },
            "hasSpecialChar" to password.any { !it.isLetterOrDigit() },
            "length" to password.length
        )
    }
}

fun main() {
    val checker = PasswordStrengthChecker()
    
    println("=== 密码强度检测工具演示 ===\n")
    
    val passwords = listOf("123456", "Password1", "MyP@ssw0rd!", "Tr0pic@lSunset#2024")
    
    for (password in passwords) {
        val score = checker.calculatePasswordStrength(password)
        val classification = checker.classifyPasswordStrength(score)
        
        println("密码: $password")
        println("强度评分: $score")
        println("强度等级: ${classification["level"]}")
        println("建议: ${classification["advice"]}")
        println()
    }
}

Kotlin 代码说明： 这个实现提供了完整的密码强度检测功能。PasswordStrengthChecker 类包含了强度计算、分类、建议生成、破解时间估算等多个方法。通过多维度的分析，确保了密码安全评估的准确性。

---

JavaScript 编译代码

// PasswordStrengthChecker.js
class PasswordStrengthChecker {
    calculatePasswordStrength(password) {
        let score = 0;
        
        // 长度评分
        if (password.length >= 8) score += 10;
        if (password.length >= 12) score += 10;
        if (password.length >= 16) score += 10;
        
        // 字符类型评分
        if (/[A-Z]/.test(password)) score += 15;
        if (/[a-z]/.test(password)) score += 15;
        if (/[0-9]/.test(password)) score += 15;
        if (/[^a-zA-Z0-9]/.test(password)) score += 20;
        
        // 复杂度评分
        const uniqueChars = new Set(password).size;
        score += Math.floor((uniqueChars / password.length) * 10);
        
        // 模式检测减分
        if (this.hasSequentialChars(password)) score -= 10;
        if (this.hasRepeatingChars(password)) score -= 10;
        if (this.isCommonPattern(password)) score -= 20;
        
        return Math.max(0, Math.min(100, score));
    }
    
    hasSequentialChars(password) {
        for (let i = 0; i < password.length - 2; i++) {
            const c1 = password.charCodeAt(i);
            const c2 = password.charCodeAt(i + 1);
            const c3 = password.charCodeAt(i + 2);
            if (c2 === c1 + 1 && c3 === c2 + 1) return true;
        }
        return false;
    }
    
    hasRepeatingChars(password) {
        for (let char of password) {
            if (password.split(char).length - 1 >= 3) return true;
        }
        return false;
    }
    
    isCommonPattern(password) {
        const commonPatterns = ["123", "abc", "qwerty", "password", "admin", "letmein", "welcome"];
        return commonPatterns.some(pattern => password.toLowerCase().includes(pattern));
    }
    
    classifyPasswordStrength(score) {
        if (score < 20) return { level: "非常弱", color: "#F44336", advice: "密码过于简单，容易被破解" };
        if (score < 40) return { level: "弱", color: "#FF9800", advice: "密码强度不足，建议改进" };
        if (score < 60) return { level: "中等", color: "#FFC107", advice: "密码强度一般，可继续改进" };
        if (score < 80) return { level: "强", color: "#8BC34A", advice: "密码强度良好，较为安全" };
        return { level: "非常强", color: "#4CAF50", advice: "密码强度优秀，非常安全" };
    }
    
    generateSecurityAdvice(password) {
        const advice = [];
        
        if (password.length < 12) advice.push("建议密码长度至少12个字符");
        if (!/[A-Z]/.test(password)) advice.push("建议添加大写字母");
        if (!/[a-z]/.test(password)) advice.push("建议添加小写字母");
        if (!/[0-9]/.test(password)) advice.push("建议添加数字");
        if (!/[^a-zA-Z0-9]/.test(password)) advice.push("建议添加特殊字符");
        if (this.hasSequentialChars(password)) advice.push("避免使用连续字符序列");
        if (this.hasRepeatingChars(password)) advice.push("避免使用重复字符");
        if (this.isCommonPattern(password)) advice.push("避免使用常见的密码模式");
        
        return advice.length > 0 ? advice : ["密码强度良好，无需改进"];
    }
    
    estimateCrackTime(score) {
        let crackTime;
        if (score < 20) crackTime = "几秒钟";
        else if (score < 40) crackTime = "几分钟";
        else if (score < 60) crackTime = "几小时";
        else if (score < 80) crackTime = "几天";
        else crackTime = "几年";
        
        return {
            bruteForce: crackTime,
            message: "估算使用现代计算机进行暴力破解所需时间"
        };
    }
    
    validatePassword(password) {
        if (!password) return { valid: false, message: "密码不能为空" };
        if (password.length < 6) return { valid: false, message: "密码长度至少6个字符" };
        if (password.length > 128) return { valid: false, message: "密码长度不能超过128个字符" };
        return { valid: true, message: "密码有效" };
    }
    
    getComprehensiveReport(password) {
        const validation = this.validatePassword(password);
        if (!validation.valid) {
            return { error: validation.message };
        }
        
        const score = this.calculatePasswordStrength(password);
        const classification = this.classifyPasswordStrength(score);
        const advice = this.generateSecurityAdvice(password);
        const crackTime = this.estimateCrackTime(score);
        
        return {
            score: score,
            classification: classification,
            advice: advice,
            crackTime: crackTime,
            hasUpperCase: /[A-Z]/.test(password),
            hasLowerCase: /[a-z]/.test(password),
            hasDigit: /[0-9]/.test(password),
            hasSpecialChar: /[^a-zA-Z0-9]/.test(password),
            length: password.length
        };
    }
}

// 使用示例
const checker = new PasswordStrengthChecker();

console.log("=== 密码强度检测工具演示 ===\n");

const passwords = ["123456", "Password1", "MyP@ssw0rd!", "Tr0pic@lSunset#2024"];

for (const password of passwords) {
    const score = checker.calculatePasswordStrength(password);
    const classification = checker.classifyPasswordStrength(score);
    
    console.log(`密码: ${password}`);
    console.log(`强度评分: ${score}`);
    console.log(`强度等级: ${classification.level}`);
    console.log(`建议: ${classification.advice}`);
    console.log();
}

JavaScript 代码说明： JavaScript 版本是 Kotlin 代码的直接转译。使用正则表达式进行字符类型检测，整体逻辑和算法与 Kotlin 版本保持一致。

---

ArkTS 调用代码

// PasswordStrengthPage.ets
import { PasswordStrengthChecker } from './PasswordStrengthChecker';

@Entry
@Component
struct PasswordStrengthPage {
    @State password: string = '';
    @State result: string = '';
    @State showResult: boolean = false;
    @State isLoading: boolean = false;
    @State score: number = 0;
    @State level: string = '';
    @State color: string = '#999999';
    @State passwordVisible: boolean = false;
    
    private checker: PasswordStrengthChecker = new PasswordStrengthChecker();
    
    checkPassword() {
        this.isLoading = true;
        try {
            const validation = this.checker.validatePassword(this.password);
            if (!validation.valid) {
                this.result = '✗ ' + validation.message;
                this.showResult = true;
                this.isLoading = false;
                return;
            }
            
            const score = this.checker.calculatePasswordStrength(this.password);
            const classification = this.checker.classifyPasswordStrength(score);
            const advice = this.checker.generateSecurityAdvice(this.password);
            const crackTime = this.checker.estimateCrackTime(score);
            const report = this.checker.getComprehensiveReport(this.password);
            
            this.score = score;
            this.level = classification.level;
            this.color = classification.color;
            
            let resultText = `📊 密码强度检测报告\n`;
            resultText += `━━━━━━━━━━━━━━━━━━━━━\n`;
            resultText += `强度评分: ${score}/100\n`;
            resultText += `强度等级: ${this.level}\n`;
            resultText += `密码长度: ${report.length} 字符\n\n`;
            resultText += `✓ 包含的字符类型:\n`;
            if (report.hasUpperCase) resultText += `  • 大写字母\n`;
            if (report.hasLowerCase) resultText += `  • 小写字母\n`;
            if (report.hasDigit) resultText += `  • 数字\n`;
            if (report.hasSpecialChar) resultText += `  • 特殊字符\n`;
            resultText += `\n💡 安全建议:\n`;
            advice.forEach(item => {
                resultText += `  • ${item}\n`;
            });
            resultText += `\n⏱️ 破解时间: ${crackTime.bruteForce}\n`;
            resultText += `${crackTime.message}`;
            
            this.result = resultText;
            this.showResult = true;
        } catch (error) {
            this.result = '检测失败: ' + (error instanceof Error ? error.message : String(error));
            this.showResult = true;
        } finally {
            this.isLoading = false;
        }
    }
    
    build() {
        Column() {
            // 标题
            Text('密码强度检测工具')
                .fontSize(28)
                .fontWeight(FontWeight.Bold)
                .margin({ top: 20, bottom: 20 })
                .textAlign(TextAlign.Center)
                .width('100%')
            
            // 密码输入
            Column() {
                Text('输入密码')
                    .fontSize(14)
                    .fontColor('#666666')
                    .margin({ bottom: 10 })
                
                Row() {
                    TextInput({ placeholder: '输入要检测的密码' })
                        .value(this.password)
                        .onChange((value: string) => {
                            this.password = value;
                        })
                        .type(this.passwordVisible ? InputType.Text : InputType.Password)
                        .width('85%')
                        .height(45)
                        .padding({ left: 10, right: 10 })
                        .border({ width: 1, color: '#cccccc', radius: 8 })
                        .fontSize(14)
                    
                    Button(this.passwordVisible ? '隐' : '显')
                        .width('13%')
                        .height(45)
                        .fontSize(12)
                        .margin({ left: 10 })
                        .onClick(() => {
                            this.passwordVisible = !this.passwordVisible;
                        })
                }
            }
            .width('100%')
            .padding(15)
            .backgroundColor('#ffffff')
            .borderRadius(10)
            .border({ width: 1, color: '#eeeeee' })
            .margin({ bottom: 20 })
            
            // 检测按钮
            Button('检测密码强度')
                .width('100%')
                .height(45)
                .fontSize(16)
                .fontWeight(FontWeight.Bold)
                .backgroundColor('#1B7837')
                .fontColor('#ffffff')
                .onClick(() => {
                    this.checkPassword();
                })
                .margin({ bottom: 20 })
            
            // 强度显示卡片
            if (this.showResult && this.score > 0) {
                Column() {
                    Text('强度评分')
                        .fontSize(12)
                        .fontColor('#999999')
                    
                    Row() {
                        Text(`${this.score}`)
                            .fontSize(48)
                            .fontWeight(FontWeight.Bold)
                            .fontColor(this.color)
                        
                        Text('/100')
                            .fontSize(16)
                            .fontColor('#999999')
                            .margin({ top: 20 })
                    }
                    .margin({ top: 10, bottom: 10 })
                    
                    Text(this.level)
                        .fontSize(16)
                        .fontColor(this.color)
                        .fontWeight(FontWeight.Bold)
                }
                .width('100%')
                .padding(20)
                .backgroundColor('#f5f5f5')
                .borderRadius(10)
                .border({ width: 2, color: this.color })
                .margin({ bottom: 20 })
            }
            
            // 结果显示
            if (this.showResult) {
                Column() {
                    Text('检测结果')
                        .fontSize(16)
                        .fontWeight(FontWeight.Bold)
                        .fontColor('#FFFFFF')
                        .width('100%')
                        .padding(12)
                        .backgroundColor('#1B7837')
                        .borderRadius(8)
                        .margin({ bottom: 12 })
                    
                    Scroll() {
                        Text(this.result)
                            .fontSize(13)
                            .fontColor('#333333')
                            .width('100%')
                            .padding(12)
                            .backgroundColor('#f9f9f9')
                            .borderRadius(6)
                            .textAlign(TextAlign.Start)
                            .selectable(true)
                    }
                    .width('100%')
                    .height(250)
                }
                .width('100%')
                .padding(15)
                .backgroundColor('#ffffff')
                .borderRadius(10)
                .border({ width: 1, color: '#eeeeee' })
            }
            
            Blank()
        }
        .width('100%')
        .height('100%')
        .padding(15)
        .backgroundColor('#f5f5f5')
        .scrollable(ScrollDirection.Vertical)
    }
}

ArkTS 代码说明： ArkTS 调用代码展示了如何在 OpenHarmony 应用中使用密码强度检测工具。页面包含密码输入、显示/隐藏按钮、检测按钮、强度显示卡片和详细结果等功能。通过 @State 装饰器管理状态，实现了完整的用户交互流程。

---

实战案例

案例1：用户注册系统

在用户注册系统中，需要实时检测用户输入的密码强度。

fun validateRegistrationPassword(password: String): Map<String, Any> {
    val checker = PasswordStrengthChecker()
    val score = checker.calculatePasswordStrength(password)
    
    return mapOf(
        "canRegister" to (score >= 60),
        "score" to score,
        "level" to checker.classifyPasswordStrength(score)["level"],
        "advice" to checker.generateSecurityAdvice(password)
    )
}

案例2：密码策略检查

在企业应用中，需要检查密码是否符合安全策略。

fun checkPasswordPolicy(password: String, minScore: Int = 60): Map<String, Any> {
    val checker = PasswordStrengthChecker()
    val score = checker.calculatePasswordStrength(password)
    val report = checker.getComprehensiveReport(password)
    
    val meetsPolicy = score >= minScore && 
        report["hasUpperCase"] as Boolean &&
        report["hasDigit"] as Boolean &&
        report["hasSpecialChar"] as Boolean
    
    return mapOf(
        "meetsPolicy" to meetsPolicy,
        "score" to score,
        "message" to if (meetsPolicy) "密码符合安全策略" else "密码不符合安全策略"
    )
}

案例3：密码安全审计

在安全审计中，需要分析用户密码的安全程度。

fun auditPasswordSecurity(passwords: List<String>): Map<String, Any> {
    val checker = PasswordStrengthChecker()
    val scores = passwords.map { checker.calculatePasswordStrength(it) }
    
    return mapOf(
        "totalPasswords" to passwords.size,
        "averageScore" to (scores.sum() / scores.size),
        "weakPasswords" to scores.count { it < 40 },
        "strongPasswords" to scores.count { it >= 80 }
    )
}

---

最佳实践

1. 实时反馈

在用户输入密码时提供实时的强度反馈。

2. 清晰的建议

提供清晰、可操作的改进建议。

3. 安全提示

提示用户避免常见的密码漏洞。

4. 隐私保护

不存储或记录用户的密码。

5. 标准遵循

遵循行业标准的密码安全要求。

6. 用户教育

帮助用户理解密码安全的重要性。

---

总结

密码强度检测工具是现代安全应用中的重要组件。通过 KMP 框架，我们可以创建一个跨端的密码检测系统，在 Kotlin、JavaScript 和 ArkTS 中使用相同的检测逻辑。这不仅提高了代码的可维护性，还确保了不同平台上检测标准的一致性。

在实际应用中，合理使用密码强度检测工具可以显著提高系统的安全性。无论是用户注册、账户管理还是安全审计，密码强度检测工具都能发挥重要作用。通过提供完整的密码分析功能和个性化的安全建议，我们可以帮助用户创建更加安全的密码。