第一章：Go语言安全传输概述

Go语言以其简洁、高效的特性被广泛应用于网络编程领域，尤其是在构建高性能服务器和实现安全传输方面表现突出。在现代分布式系统和云原生架构中，保障数据在网络中的传输安全已成为不可或缺的一环。Go语言标准库中提供了丰富的网络通信和加密支持，如crypto/tls包，能够帮助开发者快速实现基于TLS协议的安全通信。

在Go语言中，实现安全传输的核心在于利用net/http和crypto/tls包构建HTTPS服务。以下是一个基础的HTTPS服务实现示例：

package main

import (
    "fmt"
    "net/http"
)

func helloHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, secure world!")
}

func main() {
    http.HandleFunc("/hello", helloHandler)

    // 启动HTTPS服务，使用TLS证书和私钥
    err := http.ListenAndServeTLS(":443", "server.crt", "server.key", nil)
    if err != nil {
        panic(err)
    }
}

上述代码通过http.ListenAndServeTLS方法启动了一个基于TLS的安全HTTP服务。其中，server.crt和server.key分别为服务器的证书和私钥文件。这种实现方式不仅简洁，而且充分体现了Go语言在安全传输场景下的易用性和扩展性。

此外，Go语言还支持自定义TLS配置，例如设置加密套件、启用双向认证等，为不同安全等级的场景提供了灵活的开发接口。随着网络安全威胁的不断演进，掌握Go语言在安全传输方面的实践能力，已成为现代后端开发者的重要技能之一。

第二章：加密传输基础与协议选择

2.1 HTTPS协议原理与Go语言实现

HTTPS 是 HTTP 协议的安全版本，通过 SSL/TLS 协议实现数据加密传输，确保客户端与服务器之间的通信安全。其核心流程包括握手协商、密钥交换与数据加密传输。

Go语言实现HTTPS服务器

下面是一个使用 Go 标准库实现的简单 HTTPS 服务示例：

package main

import (
    "fmt"
    "net/http"
)

func helloHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, HTTPS!")
}

func main() {
    http.HandleFunc("/", helloHandler)

    // 启动HTTPS服务，指定证书和私钥文件
    err := http.ListenAndServeTLS(":443", "server.crt", "server.key", nil)
    if err != nil {
        panic(err)
    }
}

该代码使用 http.ListenAndServeTLS 方法启动 HTTPS 服务，参数说明如下：

参数	说明
addr	监听地址，如 :443
certFile	服务器证书文件路径
keyFile	私钥文件路径
handler	请求处理器，nil 表示使用默认的 http.DefaultServeMux

HTTPS握手流程

使用 Mermaid 可视化 HTTPS 握手流程如下：

graph TD
    A[Client Hello] --> B[Server Hello]
    B --> C[Certificate]
    C --> D[Server Key Exchange (可选)]
    D --> E[Server Hello Done]
    E --> F[Client Key Exchange]
    F --> G[Change Cipher Spec]
    G --> H[Encrypted Handshake Message]
    H --> I[Application Data]

整个流程确保双方完成身份验证和密钥协商，之后的数据传输均以加密形式进行，保障通信安全。

2.2 TLS版本演进与安全性分析

TLS（传输层安全协议）自1999年TLS 1.0发布以来，经历了多次迭代更新，逐步提升了通信安全性和加密强度。

协议版本演进路径

• TLS 1.0：基于SSL 3.0改进，存在BEAST攻击风险
• TLS 1.1：增加对CBC模式攻击的防御
• TLS 1.2：引入AEAD加密模式，支持现代加密套件
• TLS 1.3：大幅简化握手流程，提升性能与安全性

TLS 1.3握手流程优化

graph TD
    A[ClientHello] --> B[ServerHello]
    B --> C[EncryptedExtensions]
    C --> D[CertificateRequest]
    D --> E[Certificate + Verify]
    E --> F[Finished]
    F --> G[Application Data]

TLS 1.3将握手过程从2-RTT缩短至1-RTT，显著降低连接延迟，同时移除了对弱加密算法的支持，增强了整体安全性。

2.3 证书管理与双向认证配置

在构建高安全要求的通信系统中，SSL/TLS 证书管理是基础环节。双向认证（mTLS）在客户端与服务端均验证证书，提升身份可信度。

证书管理流程

证书管理包括生成密钥对、申请证书、签发与更新。通常使用 OpenSSL 工具链完成：

openssl req -new -x509 -days 365 -nodes -out server.crt -keyout server.key

• req：表示证书请求操作
• -new：生成新证书请求
• -x509：输出自签名证书
• -days 365：证书有效期为一年
• -out：输出证书文件
• -keyout：私钥输出路径

双向认证配置示例

Nginx 中启用 mTLS 的关键配置如下：

server {
    listen 443 ssl;
    ssl_certificate /etc/nginx/certs/server.crt;
    ssl_certificate_key /etc/nginx/certs/server.key;
    ssl_client_certificate /etc/nginx/certs/ca.crt;
    ssl_verify_client on;
}

• ssl_certificate：服务端证书路径
• ssl_client_certificate：信任的客户端CA证书
• ssl_verify_client on：开启客户端证书验证

通信流程示意

使用 Mermaid 描述 mTLS 握手流程：

graph TD
    A[ClientHello] --> B[ServerHello]
    B --> C[Server Certificate]
    C --> D[Client Certificate Request]
    D --> E[Client Certificate]
    E --> F[Key Exchange & Verify]

2.4 常见中间人攻击防范策略

在网络安全领域，防范中间人攻击（MITM）是保障通信机密性和完整性的关键环节。最基础且有效的手段是启用加密通信，例如使用 HTTPS 替代 HTTP，确保数据在传输过程中不被窃听或篡改。

加密与证书验证

import requests

response = requests.get('https://example.com', verify=True)

逻辑说明：

• verify=True 表示启用 SSL 证书验证；
• 该参数确保客户端只与具有合法证书的服务器通信，防止连接到伪装的中间人。

防范策略对比表

策略类型	实施方式	防御效果
SSL/TLS 加密	使用 HTTPS、FTPS 等协议	数据加密，防窃听
证书钉扎	固定信任特定证书或公钥	防止 CA 误签风险
双向认证	客户端与服务端互相验证	增强身份可信度

网络层防护流程

graph TD
    A[客户端发起连接] --> B{是否启用HTTPS?}
    B -- 是 --> C[验证服务器证书]
    B -- 否 --> D[连接被拒绝或警告]
    C --> E{证书是否可信?}
    E -- 是 --> F[建立加密通道]
    E -- 否 --> G[中断连接]

通过以上多层防护机制，可以显著降低中间人攻击的成功率，构建更安全的通信环境。

2.5 Go中构建安全通信通道的实践

在Go语言中，通过crypto/tls包可以方便地构建基于TLS协议的安全通信通道，保障数据传输的机密性和完整性。

TLS客户端/服务端基础实现

以下是一个简单的TLS服务端示例：

package main

import (
    "crypto/tls"
    "log"
)

func main() {
    // 配置TLS参数
    config := &tls.Config{
        MinVersion: tls.VersionTLS12, // 最小TLS版本
    }

    // 启动监听
    listener, err := tls.Listen("tcp", ":443", config)
    if err != nil {
        log.Fatalf("监听失败: %v", err)
    }
    defer listener.Close()

    log.Println("服务端启动成功")
    // 接收连接
    for {
        conn, err := listener.Accept()
        if err != nil {
            log.Println("连接失败:", err)
            continue
        }
        go handleConnection(conn)
    }
}

func handleConnection(conn tls.Conn) {
    defer conn.Close()
    buf := make([]byte, 1024)
    n, err := conn.Read(buf)
    if err != nil {
        log.Println("读取失败:", err)
        return
    }
    log.Printf("收到数据: %s", buf[:n])
}

逻辑分析

• tls.Listen用于创建一个基于TLS协议的监听器，使用TCP协议和指定端口。
• tls.Config结构用于配置TLS参数，如最小支持的协议版本。
• Accept方法用于接受客户端连接，并返回一个tls.Conn对象。
• handleConnection函数处理每个连接，读取客户端发送的数据并打印。

安全通信的配置建议

在实际部署中，应根据安全需求配置以下参数：

配置项	推荐值	说明
MinVersion	tls.VersionTLS12	最低TLS版本
CipherSuites	仅启用高强度加密套件	控制可用的加密算法
ClientAuth	tls.RequireAndVerifyClientCert	启用双向认证
InsecureSkipVerify	false	禁用证书校验（开发环境可临时启用）

使用双向认证增强安全性

为了实现双向认证，服务端和客户端都需要配置证书和私钥。服务端配置如下：

cert, err := tls.LoadX509KeyPair("server.crt", "server.key")
if err != nil {
    log.Fatalf("加载证书失败: %v", err)
}

rootCAs := x509.NewCertPool()
rootCAs.AppendCertsFromPEM(caCertBytes)

config := &tls.Config{
    Certificates: []tls.Certificate{cert},
    ClientAuth:   tls.RequireAndVerifyClientCert,
    ClientCAs:    rootCAs,
    MinVersion:   tls.VersionTLS12,
}

逻辑分析

• tls.LoadX509KeyPair用于加载服务端的证书和私钥。
• x509.NewCertPool创建一个证书池，用于存储信任的CA证书。
• AppendCertsFromPEM方法将CA证书加入信任池。
• ClientAuth字段设置为tls.RequireAndVerifyClientCert表示要求客户端提供证书并验证。
• ClientCAs字段指定用于验证客户端证书的CA证书池。

客户端配置

客户端也需要加载自己的证书和私钥，并信任服务端的CA证书：

cert, err := tls.LoadX509KeyPair("client.crt", "client.key")
if err != nil {
    log.Fatalf("加载客户端证书失败: %v", err)
}

rootCAs := x509.NewCertPool()
rootCAs.AppendCertsFromPEM(caCertBytes)

config := &tls.Config{
    Certificates: []tls.Certificate{cert},
    RootCAs:      rootCAs,
    MinVersion:   tls.VersionTLS12,
}

conn, err := tls.Dial("tcp", "localhost:443", config)
if err != nil {
    log.Fatalf("连接失败: %v", err)
}
defer conn.Close()

逻辑分析

• 客户端同样使用tls.LoadX509KeyPair加载本地证书和私钥。
• RootCAs字段指定信任的服务端CA证书池。
• tls.Dial方法建立与服务端的TLS连接。
• 双向认证中，客户端和服务端都会验证对方的证书，从而提高通信的安全性。

安全通信流程图

graph TD
    A[客户端发起连接] --> B[服务端发送证书]
    B --> C[客户端验证证书]
    C --> D{验证是否通过?}
    D -- 是 --> E[客户端发送证书]
    E --> F[服务端验证证书]
    F --> G{验证是否通过?}
    G -- 是 --> H[建立安全通道]
    G -- 否 --> I[中断连接]
    D -- 否 --> J[中断连接]

小结

通过上述实践，Go开发者可以基于crypto/tls包构建出符合现代安全标准的安全通信通道。从基础的TLS服务端搭建，到双向认证的实现，再到安全配置建议，层层递进地提升通信安全性。在实际部署时，应结合业务需求和安全策略进行适当调整。

第三章：数据加密算法与应用

3.1 对称加密与非对称加密对比

在信息安全领域，加密技术是保障数据传输和存储安全的核心手段。其中，对称加密与非对称加密是两种基础且关键的加密方式，它们在原理、性能和应用场景上存在显著差异。

对称加密特点

对称加密使用相同的密钥进行加密和解密，典型算法包括 AES 和 DES。其优势在于加解密速度快，适合处理大量数据。然而，密钥分发问题限制了其在网络通信中的广泛应用。

非对称加密优势

非对称加密使用一对密钥（公钥和私钥），典型算法如 RSA 和 ECC。其优点在于解决了密钥分发问题，增强了通信安全性，但加解密效率较低，适合用于密钥交换或数字签名场景。

性能与适用场景对比

特性	对称加密	非对称加密
密钥数量	单一密钥	公私钥配对
加密速度	快	慢
安全性保障	依赖密钥保密	基于数学难题
典型应用场景	数据批量加密	身份认证、签名

数据传输流程示意

graph TD
    A[发送方] --> B(使用接收方公钥加密)
    B --> C[数据传输]
    C --> D[接收方使用私钥解密]

非对称加密在建立安全通信初期用于交换对称密钥，后续数据传输则采用对称加密，兼顾安全与效率。这种混合加密模式已成为现代安全协议（如 TLS）的标准做法。

3.2 AES与RSA在Go中的加密实践

在Go语言中，使用标准库 crypto/aes 和 crypto/rsa 可实现对称与非对称加密。AES适用于加密大量数据，而RSA常用于加密密钥或签名验证。

AES加密示例

package main

import (
    "crypto/aes"
    "crypto/cipher"
    "fmt"
)

func main() {
    key := []byte("example key 1234") // 16字节的密钥
    plaintext := []byte("Hello, AES encryption!")

    block, _ := aes.NewCipher(key)
    ciphertext := make([]byte, len(plaintext))
    mode := cipher.NewECBEncrypter(block)
    mode.CryptBlocks(ciphertext, plaintext)

    fmt.Printf("密文: %x\n", ciphertext)
}

逻辑分析：

• 使用 aes.NewCipher 创建一个AES加密块，支持128、192或256位密钥；
• ECB模式是最基础的加密模式，但不推荐用于高安全性场景；
• CryptBlocks 对明文进行加密并输出十六进制格式的密文。

RSA加密示例

package main

import (
    "crypto/rand"
    "crypto/rsa"
    "crypto/x509"
    "encoding/pem"
    "fmt"
)

func main() {
    privateKey, _ := rsa.GenerateKey(rand.Reader, 2048)
    publicKey := &privateKey.PublicKey

    msg := []byte("Secret message")
    ciphertext, _ := rsa.EncryptPKCS1v15(rand.Reader, publicKey, msg)

    fmt.Printf("加密数据: %x\n", ciphertext)
}

逻辑分析：

• rsa.GenerateKey 生成2048位的RSA密钥对；
• 使用 EncryptPKCS1v15 对明文进行非对称加密；
• 加密后的数据只能通过对应的私钥解密。

加密策略对比

加密方式	密钥类型	性能表现	适用场景
AES	对称密钥	高	大量数据加密
RSA	非对称密钥	低	密钥交换、数字签名

综合应用建议

通常在实际项目中，AES用于加密数据主体，而RSA用于加密AES密钥，从而结合两者优势，实现高效且安全的加密通信。

3.3 使用JWT实现安全身份验证

JSON Web Token（JWT）是一种开放标准（RFC 7519），用于在网络应用间安全地传递声明（claims）。它以紧凑、可验证的方式承载用户身份信息，广泛应用于现代系统的身份验证与授权流程。

JWT的结构

一个JWT由三部分组成：头部（Header）、载荷（Payload）和签名（Signature）。它们通过点号连接形成一个字符串，如下所示：

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.
eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.
SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

• Header：定义签名算法和令牌类型
• Payload：包含声明（如用户ID、权限、过期时间等）
• Signature：确保令牌未被篡改

身份验证流程

使用JWT进行身份验证的基本流程如下：

graph TD
    A[客户端提交用户名和密码] --> B[服务端验证凭证]
    B --> C{凭证是否正确?}
    C -->|是| D[生成JWT并返回给客户端]
    C -->|否| E[返回错误信息]
    D --> F[客户端携带JWT访问受保护资源]
    F --> G[服务端验证JWT签名]
    G --> H[返回请求资源或拒绝访问]

JWT的优势

• 无状态：服务端无需保存会话信息，适合分布式系统
• 可扩展性：载荷中可自定义声明，适应多种业务场景
• 安全性高：通过签名机制防止篡改

使用示例代码（Node.js）

以下是一个使用 jsonwebtoken 模块生成和验证 JWT 的示例：

const jwt = require('jsonwebtoken');

// 签发令牌
const token = jwt.sign(
  {
    userId: '1234567890',
    username: 'john_doe',
    role: 'admin',
    iat: Math.floor(Date.now() / 1000) - 30, // 签发时间
    exp: Math.floor(Date.now() / 1000) + 60 * 60 // 过期时间
  },
  'your-secret-key', // 签名密钥
  { algorithm: 'HS256' } // 签名算法
);

console.log('Generated Token:', token);

// 验证令牌
try {
  const decoded = jwt.verify(token, 'your-secret-key');
  console.log('Decoded Payload:', decoded);
} catch (err) {
  console.error('Invalid Token:', err.message);
}

逻辑分析与参数说明：

• jwt.sign()：用于生成 JWT

  • 第一个参数为 payload，包含用户信息和元数据（如签发时间 iat、过期时间 exp）
  • 第二个参数为签名密钥（应为安全的随机字符串）
  • 第三个参数为选项，指定签名算法（HS256 为常用对称加密算法）

• jwt.verify()：用于验证 JWT 的签名和有效性

  • 若签名无效或已过期，抛出错误
  • 若验证成功，返回解码后的 payload

安全建议

为确保 JWT 的安全性，应遵循以下最佳实践：

• 使用 HTTPS 传输令牌，防止中间人攻击
• 设置合理的过期时间（如 1 小时），避免长期有效
• 敏感操作应结合刷新令牌（Refresh Token）机制
• 签名密钥应足够复杂并妥善保存，避免硬编码在代码中

适用场景

JWT适用于以下典型场景：

场景	描述
单点登录（SSO）	用户在多个系统间共享认证状态
移动端认证	无状态特性适合移动端频繁请求
微服务授权	各服务可独立验证令牌，无需共享会话
API 接口保护	通过中间件统一校验令牌有效性

小结

JWT提供了一种简洁、安全的身份验证机制，适用于现代分布式系统。通过合理配置和使用，可以有效保障系统的认证安全与访问控制。

第四章：前后端数据传输安全加固

4.1 接口签名机制设计与实现

在分布式系统和开放平台中，接口签名机制是保障通信安全的重要手段。其核心思想是通过特定算法对请求参数进行签名，服务端对接收到的请求签名进行验证，防止请求被篡改或重放。

签名流程概述

接口签名通常包括以下步骤：

1. 客户端按规则拼接待签名字符串；
2. 使用加密算法（如 HMAC-SHA256）生成签名；
3. 将签名附加在请求头或参数中；
4. 服务端按相同规则重组字符串并验签。

签名算法实现示例

import hmac
import hashlib

def generate_sign(params, secret_key):
    # 按参数名排序后拼接值
    sorted_values = ''.join([params[k] for k in sorted(params)])
    sign_str = f"{sorted_values}{secret_key}"
    # 生成HMAC-SHA256签名
    signature = hmac.new(secret_key.encode(), sign_str.encode(), hashlib.sha256).hexdigest()
    return signature

参数说明：

• params：请求参数字典，需排除签名字段本身；
• secret_key：双方约定的密钥；
• 返回值为十六进制格式的签名字符串。

签名验证流程图

graph TD
    A[客户端发起请求] --> B[服务端提取签名与参数]
    B --> C[服务端按规则重组签名字符串]
    C --> D{签名是否一致?}
    D -- 是 --> E[接受请求]
    D -- 否 --> F[拒绝请求]

4.2 数据完整性校验方法

在数据传输与存储过程中，确保数据的完整性是系统可靠性的重要保障。常用的数据完整性校验方法包括校验和（Checksum）、循环冗余校验（CRC）和哈希校验（如MD5、SHA系列）。

校验和与CRC

校验和通过累加数据块的字节值进行校验，逻辑简单，适合实时性要求高的场景：

unsigned short checksum(void *data, int len) {
    unsigned short *addr = data;
    unsigned int sum = 0;

    while (len > 1) {
        sum += *addr++;
        len -= 2;
    }

    if (len == 1) {
        sum += *(unsigned char*)addr;
    }

    sum = (sum >> 16) + (sum & 0xffff);
    return ~sum;
}

上述函数计算16位校验和，适用于小型协议或内存块校验。

CRC则基于多项式除法，具备更强的错误检测能力，常用于网络通信和文件存储。其计算过程可通过硬件加速，具有良好的实时性。

哈希算法对比

算法类型	输出长度	安全性	适用场景
MD5	128位	低	快速校验
SHA-1	160位	中	非加密完整性校验
SHA-256	256位	高	安全敏感型校验

哈希算法适用于对数据唯一性要求较高的场景，如版本控制、数字签名等。

4.3 敏感信息脱敏与过滤策略

在数据处理流程中，敏感信息的脱敏与过滤是保障数据安全与隐私合规的重要环节。常见的脱敏方式包括数据替换、掩码处理、加密转换等。

脱敏策略示例

以下是一个简单的脱敏函数示例，用于对手机号进行掩码处理：

def mask_phone(phone):
    # 判断手机号长度是否为11位
    if len(str(phone)) != 11:
        return phone
    # 返回前3位和后4位，中间用****代替
    return phone[:3] + '****' + phone[-4:]

逻辑分析：

• phone[:3]：保留手机号前三位；
• '****'：中间四位用星号替代；
• phone[-4:]：保留手机号最后四位；
• 该方式有效隐藏真实手机号，同时保留部分信息便于识别。

常见脱敏方法对比

方法	适用场景	安全性	可逆性
数据替换	用户名、地址	中	否
掩码处理	手机号、身份证	高	否
加密转换	密码、敏感字段	极高	是

4.4 安全日志记录与审计机制

安全日志记录是系统安全的基础环节，它负责收集、存储和分析与安全相关的事件信息。一个完善的日志系统应包含用户行为、系统异常、访问控制等多个维度的数据。

日志记录关键要素

典型的日志条目应包含以下信息：

字段名	描述
时间戳	事件发生的具体时间
用户标识	操作主体的身份标识
操作类型	事件类型（登录、访问等）
源IP地址	客户端发起请求的IP
结果状态	操作是否成功

审计机制实现方式

系统可通过日志采集代理进行集中审计，如下图所示：

graph TD
    A[客户端操作] --> B{安全事件触发}
    B --> C[本地日志写入]
    C --> D[日志采集代理]
    D --> E[中心日志服务器]
    E --> F[审计与分析平台]

上述流程确保日志数据从源头采集，经过集中处理后可用于安全分析与合规审计。

第五章：总结与安全传输最佳实践

在现代网络通信中，数据安全已成为不可忽视的核心要素。随着攻击手段的不断演进，仅依赖基础加密协议已难以保障数据的完整性和机密性。本章将从实战角度出发，归纳安全传输的核心要点，并提供可落地的最佳实践建议。

安全协议选型建议

在选择安全传输协议时，应优先考虑 TLS 1.2 及以上版本，避免使用已被证明存在漏洞的 SSL 3.0 或 TLS 1.0。对于需要更高安全等级的场景，可启用 TLS 1.3，其不仅提升了握手效率，还增强了加密算法的安全性。以下是一个典型的 Nginx 配置片段，用于启用 TLS 1.3 并禁用不安全协议：

ssl_protocols TLSv1.2 TLSv1.3;
ssl_ciphers HIGH:!aNULL:!MD5;

密钥管理与轮换机制

密钥管理是安全传输的核心环节。建议采用自动化密钥轮换机制，并结合 HSM（硬件安全模块）存储主密钥。某大型电商平台在实施密钥自动轮换后，成功将密钥泄露风险降低了 90%。此外，密钥应遵循最小权限原则，确保每个服务或用户仅能访问其所需的最小密钥集合。

数据完整性校验策略

在传输过程中，除了加密数据本身，还应确保其完整性。使用 HMAC（哈希消息认证码）或数字签名机制，可以有效防止中间人篡改数据。例如，在 API 请求中加入签名字段，服务端通过验证签名来判断请求是否被篡改：

import hmac
from hashlib import sha256

signature = hmac.new(secret_key, message.encode(), sha256).hexdigest()

安全审计与监控体系

建立完整的安全审计日志体系，是发现潜在威胁的重要手段。建议将所有传输层日志集中存储，并启用异常行为检测模块。某金融系统通过部署实时流量分析系统，成功识别出多起异常数据外泄尝试，并及时进行了阻断。

实施建议清单

以下是安全传输部署的推荐操作清单：

• 启用前向保密（Forward Secrecy）
• 配置强加密套件并定期更新
• 实施证书生命周期管理
• 启用 OCSP Stapling 提升证书验证效率
• 对所有对外接口启用 HTTPS
• 配置 CSP（内容安全策略）防止 XSS 攻击
• 使用 WAF 防止常见 Web 攻击模式

通过上述措施的系统化部署，可以在实际业务中显著提升数据传输的安全性，降低被攻击的风险。