前端安全：使用JavaScript Obfuscator进行代码保护 – wiki基地

作者： /

前端安全：使用JavaScript Obfuscator进行代码保护的深度解析

在互联网技术飞速发展的今天，Web应用已经成为信息交互和服务交付的主要形式。前端作为用户直接交互的界面，其重要性不言而喻。然而，与后端代码通常运行在受控的服务端环境不同，前端代码（尤其是JavaScript）是完全暴露在用户浏览器中的。任何用户都可以通过浏览器开发者工具轻松查看、调试、甚至修改前端代码。这种开放性虽然极大地促进了Web的发展，但也带来了显著的安全挑战和知识产权风险。

想象一下，您投入了大量时间和精力构建了一个复杂的单页应用（SPA），其中包含了独特的业务逻辑、算法实现甚至一些敏感数据处理逻辑（尽管敏感数据处理应尽量放在后端）。如果这些核心代码被轻易地复制、分析，轻则您的技术优势丧失，重则可能被恶意利用，如发现客户端验证绕过、理解API调用方式进行爬取或攻击、甚至直接窃取您的业务模式。

传统的安全重点往往放在后端和网络层面，这无疑是正确的，因为后端掌握着核心数据和业务处理能力。然而，忽视前端安全同样危险。尽管前端无法保证绝对的安全，但通过采取一系列措施，我们可以显著提高攻击者的分析成本和门槛，从而保护我们的知识产权、增加应用的鲁棒性，并在一定程度上防止客户端代码被恶意篡改或用于非法目的。

在众多前端安全实践中，代码混淆（Obfuscation）是一种广泛采用的技术，旨在让代码变得难以理解和分析，从而保护源代码的逻辑和结构。本文将深入探讨JavaScript代码混淆的概念、必要性，并重点介绍如何使用一个功能强大且流行的工具——JavaScript Obfuscator——来进行代码保护。

为什么前端代码需要保护？

在深入了解混淆技术之前，我们首先要理解保护前端JavaScript代码的必要性。这不仅仅是“不让别人看到我的代码”这么简单。

  1. 保护知识产权和商业逻辑： 如果您的应用包含独特的用户体验流程、复杂的客户端算法（如图形渲染、数据可视化处理、游戏逻辑、前端AI模型等），这些都代表着您的技术积累和商业价值。未加保护的代码可能被竞争对手轻易“学习”甚至直接复制。
  2. 防止API滥用： 前端JavaScript代码通常包含了与后端API交互的逻辑和参数结构。通过分析这些代码，攻击者可以更轻松地理解您的API工作方式，进而构造恶意请求，进行数据爬取、接口攻击（如越权访问、注入攻击的基础信息收集）等。
  3. 增加客户端验证的安全性（辅助手段）： 虽然重要的验证必须在后端进行，但前端验证可以提高用户体验并减轻后端压力。攻击者可能通过分析前端代码来理解验证规则并尝试绕过。混淆可以增加分析这些规则的难度。
  4. 隐藏客户端敏感信息（谨慎使用）： 尽管强烈不建议在前端代码中硬编码密钥、密码等敏感信息，但有时为了特定目的（如某些SDK的初始化配置、公共API Key等）可能需要在客户端存储一些非核心敏感信息。混淆可以增加提取这些信息的难度。
  5. 防止代码篡改（结合其他技术）： 虽然JavaScript在客户端执行，难以完全防止篡改，但通过某些混淆技术（如自防御代码），可以使得简单的代码注入或修改尝试失效，或至少让攻击者付出更高的代价。
  6. 提高漏洞发现难度： 复杂的、非结构化的混淆代码使得静态代码分析工具和人工审计难以理解代码的真实意图，从而增加发现潜在漏洞（如DOM XSS的注入点、客户端逻辑缺陷）的难度。

需要强调的是，前端代码混淆不是一种安全漏洞的修复手段。它不能阻止网络请求被抓包、不能阻止数据在客户端被访问、更不能代替服务端的安全验证。混淆是一种防御性编程技术，目的是提高代码的逆向工程难度，为应用增加一道额外的保护层。它更像是在你的房子外面再加一层茂密的荆棘，让小偷更难靠近和行动，而不是一个坚不可摧的保险库。

什么是JavaScript代码混淆？

JavaScript代码混淆（JavaScript Obfuscation）是指通过一系列转换技术，使得源代码在功能上保持不变，但在形式上变得难以阅读和理解的过程。这些转换通常包括：

  • 标识符重命名： 将有意义的变量名、函数名、类名、属性名替换为简短、无意义的字符（如a, b, $等），或者使用难以阅读的Unicode字符。
  • 字符串加密： 将代码中的字符串字面量（如URL、API端点、提示信息）加密或编码存储，并在运行时动态解密使用。
  • 控制流扁平化（Control Flow Flattening）： 改变代码的执行流程结构，将原本清晰的顺序、条件、循环结构转化为复杂的、基于状态机的跳转逻辑，使得代码难以通过阅读或简单的调试来理解执行路径。
  • 注入冗余代码（Dead Code Injection）： 添加一些不会被执行的代码片段，干扰分析器的判断和人工阅读。
  • 代码压缩与格式化： 移除空格、注释、缩短变量名等，但这更多是性能优化和减小文件体积的手段，与混淆的目的不同，混淆会进一步破坏代码的可读性。
  • 自防御（Self-Defending）： 插入代码片段，检测运行时环境是否被篡改或调试，如果检测到异常，则阻止代码执行或进入死循环。
  • 禁用浏览器开发者工具： 通过检测开发者工具的打开状态，干扰其正常功能，使得调试变得困难。

混淆与压缩/Minification的区别：

  • 目的： 压缩/Minification的主要目的是减小文件体积，提高加载速度。混淆的主要目的是保护代码，增加逆向工程难度。
  • 方式： 压缩主要移除不必要的字符（空格、注释）、缩短变量名（但通常保持作用域内的唯一性），不改变代码结构。混淆则会显著改变代码结构、重写逻辑表达方式，使其难以理解。
  • 结果： 压缩后的代码虽然不易读，但通过格式化和少量变量名映射通常可以恢复部分可读性。混淆后的代码即使格式化也仍然难以理解。

引入 JavaScript Obfuscator

JavaScript Obfuscator是一款强大且高度可配置的JavaScript代码混淆工具。它提供了多种先进的混淆技术，可以根据需求定制混淆强度和策略。与仅仅进行基础的变量名缩短和移除空白的工具不同，JavaScript Obfuscator专注于通过各种复杂的转换手段，最大化代码的不可读性。

JavaScript Obfuscator的主要特点：

  1. 丰富的混淆选项： 提供了几十种可配置项，覆盖了标识符重命名、字符串处理、控制流、调试保护、自防御等多个方面。
  2. 高强度的混淆效果： 特别是其控制流扁平化、字符串加密、自防御等高级技术，能够生成非常难以分析的代码。
  3. 灵活的使用方式： 支持命令行接口（CLI）、编程API，并且可以方便地集成到各种前端构建工具中（如Webpack、Rollup、Gulp、Grunt）。
  4. 持续维护和更新： 作为一个活跃的开源项目，它不断地吸收新的混淆技术和对抗逆向工程的策略。

如何使用 JavaScript Obfuscator

使用JavaScript Obfuscator通常涉及安装、配置和集成到构建流程中。

1. 安装

作为Node.js生态的一部分，JavaScript Obfuscator可以通过npm或yarn进行安装。

“`bash

使用 npm 安装

npm install javascript-obfuscator –save-dev

使用 yarn 安装

yarn add javascript-obfuscator –dev
“`

将其安装为开发依赖（--save-dev或-dev）是因为混淆是一个构建步骤，不需要在生产环境中运行。

2. 基本使用（CLI）

安装完成后，可以在项目的node_modules/.bin/目录下找到javascript-obfuscator命令。或者，如果将其集成到npm脚本中，可以直接调用。

最简单的用法是指定输入文件和输出目录：

bash
npx javascript-obfuscator ./src/script.js --output ./dist/obfuscated.js

这会使用默认配置对script.js文件进行混淆，并将结果输出到obfuscated.js。

处理多个文件或整个目录：

“`bash

混淆整个 src 目录到 dist 目录

npx javascript-obfuscator ./src –output ./dist
“`

3. 配置选项

JavaScript Obfuscator的强大之处在于其丰富的配置选项。通过这些选项，你可以精细控制混淆的强度和方式。配置可以通过命令行参数传递，更常见和推荐的方式是使用配置文件（如obfuscator.json或在构建工具配置中定义）。

以下是一些重要且常用的配置选项及其说明：

  • compact (boolean): 是否移除额外的空格、换行符等。默认为true，用于减小文件体积。
  • controlFlowFlattening (boolean): 是否启用控制流扁平化。这是一个非常强大的混淆技术，但会显著增加代码体积和运行时开销。默认为false。
  • controlFlowFlatteningThreshold (number): 启用控制流扁平化时，对代码中的哪些函数进行扁平化（基于函数体内的语句数量）。值越高，越少的函数会被扁平化。默认为0.75。
  • deadCodeInjection (boolean): 是否注入无用代码。默认为false。
  • deadCodeInjectionThreshold (number): 启用无用代码注入时，注入的概率。默认为0.4。
  • debugProtection (boolean): 是否启用调试保护。当检测到开发者工具被打开时，会使代码难以执行。默认为false。
  • debugProtectionInterval (number): 启用调试保护时，检查开发者工具状态的时间间隔（毫秒）。默认为0（即不启用定时检查）。
  • disableConsoleRedirection (boolean): 是否禁用控制台函数（如console.log）重定向到空函数。默认为false。启用此选项可以防止在调试时看到控制台输出。
  • identifierNamesGenerator (string): 生成混淆后标识符名称的生成器类型。常用选项有：
    • hexadecimal: 使用十六进制字符串（如_0xabc123）。
    • mangled: 使用短的、无意义的字符（如a, b, $等）。
    • mangled-shuffled: mangled的变体，顺序随机化。
    • nolnol: 结合数字和字母，难以区分。
    • 默认为hexadecimal。
  • log (boolean): 是否在控制台输出混淆信息。默认为false。
  • numbersToExpressions (boolean): 将数字字面量转换为表达式（如1变成+!![]）。默认为false。
  • renameGlobals (boolean): 是否重命名全局变量和函数。不建议在浏览器环境中使用此选项，因为它可能破坏与其他脚本或全局对象的交互。默认为false。
  • selfDefense (boolean): 是否启用自防御。检测代码是否被格式化或以某种方式修改，如果检测到则可能导致代码失效。默认为false。
  • shuffleStringArray (boolean): 启用字符串数组时，是否随机化字符串数组的元素顺序。默认为true。
  • skipTargets (string[]): 一个字符串数组，指定不需要混淆的目标，可以使用'file'跳过整个文件，'className'跳过类名，'functionName'跳过函数名，'variable'跳过变量名等。
  • sourceMap (boolean): 是否生成Source Map。Source Map可以将混淆后的代码映射回原始代码，便于调试（通常在开发或内部测试环境使用）。默认为false。
  • sourceMapBaseUrl (string): Source Map文件的Base URL。
  • sourceMapFileName (string): Source Map文件的文件名模板。
  • sourceMapMode (string): Source Map的模式。'separate'生成独立文件，'inline'将Source Map嵌入到混淆文件中。默认为'separate'。
  • splitStrings (boolean): 是否将长字符串分割成小块，并使用字符串数组连接。默认为false。
  • splitStringsChunkLength (number): 启用字符串分割时，每个块的最大长度。默认为10。
  • stringArray (boolean): 是否将代码中的字符串字面量存储在一个数组中，并在运行时通过索引访问。这是保护字符串内容的主要方式。默认为true。
  • stringArrayThreshold (number): 启用字符串数组时，对代码中的哪些节点进行字符串替换（基于字符串出现的频率）。值越高，越少的字符串会被放入数组。默认为0.75。
  • stringArrayEncoding (string[] | boolean): 字符串数组中字符串的编码方式。可以是'base64', 'rc4', 或false（不编码）。可以指定多个编码方式，混淆器会随机选择。默认为false。
  • stringArrayWrappersCount (number): 在字符串数组外部添加多少层额外的封装函数。值越高，提取字符串越困难，但性能开销越大。默认为1。
  • stringArrayWrappersType (string): 字符串数组封装函数的类型。'variable', 'function', 'recursive'. 默认为'variable'.
  • transformObjectKeys (boolean): 是否重命名对象字面量的键。默认为false。
  • unicodeEscapeSequence (boolean): 是否将字符串字面量和标识符转换为Unicode转义序列。默认为false。这使得代码看起来像乱码。

配置示例（JSON文件）：

json
{
"compact": true,
"controlFlowFlattening": true,
"controlFlowFlatteningThreshold": 0.5,
"deadCodeInjection": true,
"deadCodeInjectionThreshold": 0.3,
"debugProtection": true,
"debugProtectionInterval": 4000,
"disableConsoleRedirection": true,
"identifierNamesGenerator": "mangled",
"log": false,
"numbersToExpressions": true,
"selfDefense": true,
"shuffleStringArray": true,
"skipTargets": [],
"sourceMap": false,
"sourceMapMode": "separate",
"splitStrings": true,
"splitStringsChunkLength": 5,
"stringArray": true,
"stringArrayThreshold": 0.8,
"stringArrayEncoding": ["base64", "rc4"],
"stringArrayWrappersCount": 5,
"stringArrayWrappersType": "function",
"transformObjectKeys": true,
"unicodeEscapeSequence": true
}

使用CLI指定配置文件：

bash
npx javascript-obfuscator ./src --output ./dist --config ./obfuscator.json

4. 集成到构建工具

在实际项目中，通常会将JavaScript Obfuscator集成到前端项目的构建流程中，例如使用Webpack、Rollup、Gulp或Grunt。

集成到 Webpack：

可以使用javascript-obfuscator-webpack-plugin插件。

  1. 安装插件：
    bash
    npm install javascript-obfuscator-webpack-plugin --save-dev

  2. 在webpack.config.js中配置：

    “`javascript
    const JavaScriptObfuscator = require(‘javascript-obfuscator-webpack-plugin’);

    module.exports = {
    // … 其他 Webpack 配置
    plugins: [
    // … 其他插件
    new JavaScriptObfuscator({
    // 这里是 JavaScript Obfuscator 的配置选项
    // 例如：
    compact: true,
    controlFlowFlattening: true,
    stringArray: true,
    stringArrayEncoding: [‘base64’],
    // … 更多选项
    }, [‘excluded_file_name.js’]) // 可选：指定不需要混淆的文件
    ]
    };
    “`

集成到 Rollup：

可以使用rollup-plugin-javascript-obfuscator插件。

  1. 安装插件：
    bash
    npm install rollup-plugin-javascript-obfuscator --save-dev

  2. 在rollup.config.js中配置：

    “`javascript
    import obfuscatorPlugin from ‘rollup-plugin-javascript-obfuscator’;

    export default {
    input: ‘src/main.js’,
    output: {
    file: ‘dist/bundle.js’,
    format: ‘esm’
    },
    plugins: [
    // … 其他插件
    obfuscatorPlugin({
    // JavaScript Obfuscator 配置选项
    compact: true,
    controlFlowFlattening: false, // 注意性能影响
    stringArray: true,
    // …
    })
    ]
    };
    “`

集成到Gulp或Grunt也类似，通常有相应的插件可用。将混淆作为构建过程的最后一步（在压缩之后）进行，可以确保对最终生成的代码进行保护。

深度解析混淆技术（JavaScript Obfuscator 实现）

了解一些核心的混淆技术原理，有助于我们更好地配置和理解JavaScript Obfuscator的作用。

  1. 标识符重命名 (Identifier Names Generator: mangled, hexadecimal等)

    • 原理： 将诸如getUserData、calculateTotalPrice、items等有意义的变量名和函数名替换为a、b、_0x1a3e等无意义或难以记忆的名称。同时，会确保在同一作用域内重命名后的名称是唯一的。
    • 效果： 显著降低代码可读性。人类大脑习惯于通过有意义的名称来理解代码功能，一旦名称被破坏，理解代码逻辑变得困难。
    • JavaScript Obfuscator实现： 提供了多种生成名称的策略，从简单的短字符到复杂的十六进制或Unicode序列，可以根据对抗强度选择。

  2. 字符串加密 (String Array, String Array Encoding)

    • 原理： 将代码中所有的字符串字面量提取出来，存放在一个数组中。在代码执行时，通过计算索引从数组中获取字符串。为了进一步增强安全性，数组中的字符串本身可以进行加密（如Base64、RC4）或编码，并在运行时进行解密。
    • 效果： 隐藏代码中的敏感字符串（如API密钥片段、URL、错误消息等），使得通过简单搜索字符串来定位关键代码变得困难。
    • JavaScript Obfuscator实现： stringArray选项启用此功能，stringArrayEncoding指定编码方式，stringArrayThreshold控制哪些字符串进入数组，shuffleStringArray打乱数组顺序，stringArrayWrappersCount/Type增加访问数组的复杂度。

  3. 控制流扁平化 (Control Flow Flattening)

    • 原理： 将函数体内原本的线性、分支（if/else）、循环（for/while）结构，转换为一个大的switch语句或类似的结构，通过一个状态变量来控制执行流程。原本的每个基本代码块变成switch语句的一个case分支，执行完一个分支后，更新状态变量，跳到下一个要执行的分支。
    • 效果： 极大地破坏代码的逻辑结构，使得通过静态分析或单步调试来理解代码执行路径变得异常困难。代码看起来像一个混乱的状态机。
    • JavaScript Obfuscator实现： controlFlowFlattening选项启用此功能，controlFlowFlatteningThreshold控制应用此技术的范围。这是JavaScript Obfuscator中最具代表性的高级混淆手段之一。

  4. 注入冗余代码 (Dead Code Injection)

    • 原理： 在代码中插入一些不会被实际执行到的代码片段。这些代码块可能是无用的计算、永远不会满足的条件分支等。
    • 效果： 增加代码的体积和复杂度，干扰代码分析工具和人工阅读，使得区分有用代码和无用代码变得困难。
    • JavaScript Obfuscator实现： deadCodeInjection和deadCodeInjectionThreshold选项控制是否以及以多大概率注入无用代码。

  5. 自防御 (Self-Defending)

    • 原理： 在混淆后的代码中加入检查机制。例如，检查toString()方法是否被修改（这可能是代码格式化工具的迹象），检查是否存在调试器，检查代码是否在预期之外的环境中运行等。如果检测到异常，则可能触发无限循环、抛出错误或清除关键变量，阻止代码正常执行。
    • 效果： 使得攻击者难以对混淆后的代码进行格式化、美化或使用调试器进行分析。
    • JavaScript Obfuscator实现： selfDefense选项启用此功能，它会在混淆代码的入口点附近或关键位置插入检查代码。

  6. 禁用浏览器开发者工具 (Debug Protection, Disable Console Redirection)

    • 原理： 利用浏览器的一些特性（如反复调用debugger语句、检测console对象属性等）来干扰开发者工具的正常功能。例如，不断触发debugger语句会使调试器频繁中断，使得单步调试几乎不可能。
    • 效果： 极大地阻碍了攻击者使用浏览器内置工具进行动态代码分析和调试。
    • JavaScript Obfuscator实现： debugProtection选项用于插入debugger语句和相关的反调试代码，debugProtectionInterval可以设置定时触发检查，disableConsoleRedirection阻止控制台输出，进一步干扰调试。

  7. 数字与表达式转换 (Numbers To Expressions)

    • 原理： 将代码中的数字字面量（如1, 100）转换为复杂的表达式（如+!![], (function(){return 100})()）。
    • 效果： 增加了代码的视觉混乱度，使得通过字面量搜索关键数值变得困难。

  8. Unicode转义 (Unicode Escape Sequence)

    • 原理： 将代码中的字符串字面量和重命名后的标识符转换为Unicode转义序列（如\u0061代表a）。
    • 效果： 使代码在文本编辑器中显示为一串乱码，极大地降低人工阅读的可能性。

混淆的局限性与注意事项

尽管代码混淆是保护前端代码的有效手段，但它并非万能药，使用时需要注意其局限性：

  1. 混淆不是加密： 混淆后的代码仍然是可执行的JavaScript代码，它最终需要在浏览器中被解释执行。这意味着浏览器必须能够理解并运行它。虽然混淆使其难以理解，但并不能阻止有经验的逆向工程师通过各种工具和技术（如Hooking、AST分析、动态调试）来还原或理解其逻辑。高级的混淆也只能提高还原的成本和所需的时间。
  2. 性能开销： 某些高级混淆技术，尤其是控制流扁平化和字符串加密，会显著增加代码体积和运行时执行开销。控制流扁平化需要更多的状态判断和跳转，字符串解密需要额外的计算。在高频执行的关键代码或对性能要求极高的场景下，需要仔细权衡混淆强度与性能损耗。
  3. 增加代码体积： 为了实现混淆效果（如注入冗余代码、字符串数组、控制流结构），混淆后的代码通常会比原始代码或仅仅压缩后的代码体积更大。这可能影响应用的加载速度。
  4. 调试困难： 混淆后的代码几乎无法直接阅读和调试。即使生成了Source Map，高级混淆技术（如控制流扁平化）也可能导致Source Map不完全准确，或者在调试时跳跃异常。这给后期的维护、错误排查带来了挑战。
  5. 兼容性问题： 某些极端的混淆方式或特定的混淆工具版本，可能在某些旧版本浏览器或特定环境中产生兼容性问题或运行时错误。因此，混淆后必须进行全面的测试。
  6. “安全通过模糊化”的本质： 混淆是一种典型的“安全通过模糊化”（Security Through Obscurity）手段。它依赖于隐藏信息来增加攻击难度，而不是通过根本性的安全机制来防止攻击。一旦模糊被解除，其提供的保护也就失效了。

使用 JavaScript Obfuscator 的最佳实践

考虑到上述局限性，以下是一些使用JavaScript Obfuscator的最佳实践：

  1. 分层保护： 将混淆视为前端安全策略中的一个环节，而不是全部。它应该与其他安全措施结合使用，如：
    • 重要的业务逻辑和敏感数据处理放在后端。
    • 严格的后端输入验证和输出编码，防止注入和XSS攻击。
    • 使用HTTPS加密传输数据。
    • 实施Content Security Policy (CSP)来限制可执行的脚本来源。
    • 对API接口进行身份验证和授权控制。
  2. 根据重要性选择混淆强度： 不是所有前端代码都需要最高强度的混淆。对于包含核心商业逻辑、关键算法的代码段，可以采用控制流扁平化、字符串加密等强力手段。而对于UI组件、简单的事件处理代码等，可能只需要基本的标识符重命名和字符串数组即可，以平衡保护强度与性能/体积开销。JavaScript Obfuscator的配置选项允许你对不同的文件或代码块应用不同的混淆策略（通过构建工具配置或skipTargets等选项）。
  3. 充分测试： 在部署到生产环境之前，必须对混淆后的代码进行全面的功能测试和性能测试。确保所有功能正常工作，没有引入新的bug，并且性能在可接受范围内。特别要注意跨浏览器和设备的兼容性。
  4. 结合Source Map进行内部调试（可选）： 在开发或测试阶段，可以生成Source Map，以便在需要时能够调试原始代码。但在生产环境中，通常不建议公开Source Map，除非你有特定的需求并且能够确保其安全。JavaScript Obfuscator支持Source Map生成。
  5. 不要在客户端存储密钥或密码： 即使混淆了代码，也绝对不要在前端JavaScript代码中硬编码敏感密钥、用户密码等信息。这些信息本质上属于后端或需要更安全的管理方式（如通过安全的API获取、使用OAuth等）。
  6. 定期更新混淆工具： 逆向工程技术也在不断发展。使用最新版本的JavaScript Obfuscator可以获得最新的混淆技术和反逆向手段，提高保护效果。

结论

前端JavaScript代码的开放性带来了知识产权泄露和代码被滥用的风险。代码混淆作为一种重要的前端安全手段，通过改变代码形式使其难以理解，能够显著增加攻击者的分析成本和逆向工程难度。

JavaScript Obfuscator是一款功能丰富、高度可配置的JavaScript代码混淆工具，提供了从基础的标识符重命名到高级的控制流扁平化、字符串加密、自防御等多种技术。通过合理配置和集成到构建流程中，它可以为您的前端应用提供一道强大的代码保护层。

然而，我们必须清醒地认识到，混淆并非绝对安全，它不能替代完善的后端安全策略，也可能带来性能和调试上的挑战。最佳的前端安全实践是采用多层防御机制，将混淆与后端安全、API安全、内容安全策略等手段结合起来，并根据应用的具体需求和安全风险，权衡混淆的强度与带来的副作用。

在数字化资产日益重要的今天，保护前端代码中的核心逻辑和知识产权，是每一个负责任的Web开发团队不可忽视的任务。熟练掌握并合理运用JavaScript Obfuscator这样的工具，将是提升前端应用整体安全性和鲁棒性的关键一步。

发表评论

您的邮箱地址不会被公开。 必填项已用 * 标注

滚动至顶部