深海游弋的鱼 – 智障儿童欢乐多

ubuntu 22.04 本地部署大语言模型

前置条件

AMD Ryzen™ 9 5900X × 24
128.0 GB内存、8TB SSD
NVIDIA GeForce RTX™ 3060 12GB
Ubuntu 24.04.4 LTS
Linux 6.8.0-106-generic
NVIDIA driver (open kernel) metapackage nvidia-driver-590-open
nvidia-cuda-toolkit 12.0.140

执行步骤

1. 启用内存压缩 zram ，增加部分 CPU 占用，节约部分宝贵的内存

$ sudo apt install zram-config

1	$ sudo apt install zram-config

2. 安装 NVIDIA CUDA

$ sudo apt install nvidia-cuda-toolkit

1	$ sudo apt install nvidia-cuda-toolkit

3. 编译 llama.cpp

$ apt-get update

$ apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y

$ git clone https://github.com/ggml-org/llama.cpp

$ cmake llama.cpp -B llama.cpp/build \
    -DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON -DLLAMA_CURL=ON

$ cmake --build llama.cpp/build --config Release -j --clean-first --target llama-cli llama-mtmd-cli llama-server llama-gguf-split

$ cp llama.cpp/build/bin/llama-* llama.cpp

$ apt-get update

$ apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y

$ git clone https://github.com/ggml-org/llama.cpp

$ cmake llama.cpp -B llama.cpp/build \

-DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON -DLLAMA_CURL=ON

$ cmake --build llama.cpp/build --config Release -j --clean-first --target llama-cli llama-mtmd-cli llama-server llama-gguf-split

$ cp llama.cpp/build/bin/llama-* llama.cpp

4. 下载模型文件，国内用户去 ModelScope 魔搭社区搜索下载，国外的 Hugging Face下载比较艰难。

下载地址：NVIDIA-Nemotron-3-Super-120B-A12B-GGUF

5. 启动模型

./llama-server \
    --model unsloth/NVIDIA-Nemotron-3-Super-120B-A12B-GGUF/UD-Q4_K_XL/NVIDIA-Nemotron-3-Super-120B-A12B-UD-Q4_K_XL-00001-of-00003.gguf \
    --ctx-size 16384 \
    --seed 3407 \
    --prio 2 \
    --temp 0.6 \
    --top-p 0.95 \
    --port 8080 \
    --host 0.0.0.0 \
    --fit on \
    --api-key-file api-keys.txt

./llama-server \

--model unsloth/NVIDIA-Nemotron-3-Super-120B-A12B-GGUF/UD-Q4_K_XL/NVIDIA-Nemotron-3-Super-120B-A12B-UD-Q4_K_XL-00001-of-00003.gguf \

--ctx-size 16384 \

--seed 3407 \

--prio 2 \

--temp 0.6 \

--top-p 0.95 \

--port 8080 \

--host 0.0.0.0 \

--fit on \

--api-key-file api-keys.txt

参考链接

Windows 数字签名获取与验证详解

在 Windows 的安全体系中，数字签名扮演着“软件身份证”的角色。它可以证明一个程序确实来自某个发布者，并且在分发的过程中没有被篡改。

当下载一个系统更新、驱动程序，或者安装第三方应用时，操作系统往往会验证数字签名，确保软件来源合法、安全。那么，作为开发者或安全研究人员，该如何编程获取并验证这些数字签名呢？

本文将通过代码示例，逐步实现一个数字签名验证工具，并解析其原理和应用场景。

为什么要验证数字签名？

在信息安全领域，数字签名主要解决两个问题：

来源认证 通过证书绑定发布者的身份，确认文件确实来自于声称的公司或组织。比如系统文件通常签名于 Microsoft Corporation。
完整性保护 签名过程包含哈希计算，如果文件在传输中被篡改，签名将立刻失效。

对普通用户来说，这能防止中途被植入恶意代码；对企业来说，则能确保生产环境中运行的软件是可信的。

验证思路与 Windows API

Windows 提供了专门的 API 来处理数字签名验证，其中最关键的包括：

WinVerifyTrust：验证文件的数字签名是否有效；
WTHelperProvDataFromStateData：获取验证过程中的证书链数据；
WTHelperGetProvSignerFromChain：提取签名者、时间戳签名者等信息；
CertGetNameString：获取证书的持有人或颁发者名称；
CryptHashCertificate2：计算证书的 SHA1 指纹。

我们的目标是用这些 API 编写一个签名验证器，它不仅要能告诉我们签名是否有效，还能展示签名的详细信息。

定义数据结构：存储验证结果

首先，需要定义一个结构体，用来存储每次验证得到的签名信息。

struct SignatureInfo {
    std::string status;        // 验证状态简写（如 Valid、Expired）
    std::string statusMessage; // 状态详细描述
    std::string thumbprint;    // 证书指纹（SHA1）
    std::string signer;        // 签名者
    std::string issuer;        // 颁发者
    std::string timeStamper;   // 时间戳服务器（如果存在）
    bool isValid = false;      // 签名是否有效
};

struct SignatureInfo {

std::string status; // 验证状态简写（如 Valid、Expired）

std::string statusMessage; // 状态详细描述

std::string thumbprint; // 证书指纹（SHA1）

std::string signer; // 签名者

std::string issuer; // 颁发者

std::string timeStamper; // 时间戳服务器（如果存在）

bool isValid = false; // 签名是否有效

};

通过这样的结构体，就能清晰地记录和返回验证结果，方便展示和后续处理。

调用 WinVerifyTrust 验证签名

验证的第一步就是调用 WinVerifyTrust，系统会说明这个文件的签名是否可信。

WINTRUST_FILE_INFO fileData = { sizeof(WINTRUST_FILE_INFO) };
fileData.pcwszFilePath = filePath;

WINTRUST_DATA wintrustData = { sizeof(WINTRUST_DATA) };
wintrustData.dwUIChoice = WTD_UI_NONE;                 // 不弹出 UI
wintrustData.fdwRevocationChecks = WTD_REVOKE_WHOLECHAIN; // 检查整个证书链
wintrustData.dwUnionChoice = WTD_CHOICE_FILE;
wintrustData.pFile = &fileData;
wintrustData.dwStateAction = WTD_STATEACTION_VERIFY;

GUID action = WINTRUST_ACTION_GENERIC_VERIFY_V2;
LONG result = WinVerifyTrust(NULL, &action, &wintrustData);

WINTRUST_FILE_INFO fileData = { sizeof(WINTRUST_FILE_INFO) };

fileData.pcwszFilePath = filePath;

WINTRUST_DATA wintrustData = { sizeof(WINTRUST_DATA) };

wintrustData.dwUIChoice = WTD_UI_NONE; // 不弹出 UI

wintrustData.fdwRevocationChecks = WTD_REVOKE_WHOLECHAIN; // 检查整个证书链

wintrustData.dwUnionChoice = WTD_CHOICE_FILE;

wintrustData.pFile = &fileData;

wintrustData.dwStateAction = WTD_STATEACTION_VERIFY;

GUID action = WINTRUST_ACTION_GENERIC_VERIFY_V2;

LONG result = WinVerifyTrust(NULL, &action, &wintrustData);

通过返回值 result 可以验证是否成功：

ERROR_SUCCESS：签名有效；
其他值：签名无效，需要进一步分析原因，比如证书过期、吊销、不受信任等。

这相当于签名验证的入口，后续的步骤都建立在这之上。

提取签名证书信息

如果验证成功，便可以提取证书链的详细信息，包括：

签名者（Signer）：谁签了这个文件；
颁发者（Issuer）：证书由谁颁发；
证书指纹（Thumbprint）：用于唯一标识证书；
时间戳（Timestamp）：签名时刻的时间戳，确保即使证书后来过期，签名依然有效。

核心代码如下：

CRYPT_PROVIDER_DATA* providerData = WTHelperProvDataFromStateData(wintrustData.hWVTStateData);
if (providerData) {
    CRYPT_PROVIDER_SGNR* signer = WTHelperGetProvSignerFromChain(providerData, 0, FALSE, 0);
    if (signer && signer->pasCertChain[0].pCert) {
        PCCERT_CONTEXT certContext = signer->pasCertChain[0].pCert;
        info.thumbprint = GetCertificateThumbprint(certContext);
        info.signer = GetCertificateName(certContext, CERT_NAME_SIMPLE_DISPLAY_TYPE);
        info.issuer = GetCertificateName(certContext, CERT_NAME_SIMPLE_DISPLAY_TYPE | CERT_NAME_ISSUER_FLAG);

        // 获取时间戳（如果存在）
        if (signer->csCounterSigners > 0) {
            CRYPT_PROVIDER_SGNR* timeStamper = WTHelperGetProvSignerFromChain(providerData, 0, TRUE, 0);
            if (timeStamper && timeStamper->pasCertChain[0].pCert) {
                info.timeStamper = GetCertificateName(timeStamper->pasCertChain[0].pCert, CERT_NAME_SIMPLE_DISPLAY_TYPE);
            }
        }
    }
}

CRYPT_PROVIDER_DATA* providerData = WTHelperProvDataFromStateData(wintrustData.hWVTStateData);

if (providerData) {

CRYPT_PROVIDER_SGNR* signer = WTHelperGetProvSignerFromChain(providerData, 0, FALSE, 0);

if (signer && signer->pasCertChain[0].pCert) {

PCCERT_CONTEXT certContext = signer->pasCertChain[0].pCert;

info.thumbprint = GetCertificateThumbprint(certContext);

info.signer = GetCertificateName(certContext, CERT_NAME_SIMPLE_DISPLAY_TYPE);

info.issuer = GetCertificateName(certContext, CERT_NAME_SIMPLE_DISPLAY_TYPE | CERT_NAME_ISSUER_FLAG);

// 获取时间戳（如果存在）

if (signer->csCounterSigners > 0) {

CRYPT_PROVIDER_SGNR* timeStamper = WTHelperGetProvSignerFromChain(providerData, 0, TRUE, 0);

if (timeStamper && timeStamper->pasCertChain[0].pCert) {

info.timeStamper = GetCertificateName(timeStamper->pasCertChain[0].pCert, CERT_NAME_SIMPLE_DISPLAY_TYPE);

}

通过证书链，可以把签名的每一个关键细节抽取出来。

辅助函数：让结果更直观

仅仅有 API 返回的原始数据并不友好，还需要写几个辅助函数，便于转化结果。

获取证书指纹

证书指纹是证书的 SHA1 哈希，常用于唯一标识：

static std::string GetCertificateThumbprint(PCCERT_CONTEXT certContext) {
    BYTE thumbprint[20] = {0};
    DWORD thumbprintSize = sizeof(thumbprint);
    
    if (CryptHashCertificate2(BCRYPT_SHA1_ALGORITHM, 0, NULL, 
        certContext->pbCertEncoded, certContext->cbCertEncoded, thumbprint, &thumbprintSize)) {
        
        std::stringstream ss;
        for (DWORD i = 0; i < thumbprintSize; i++) {
            ss << std::hex << std::setw(2) << std::setfill('0') << (int)thumbprint[i];
        }
        return ss.str();
    }
    return "";
}

static std::string GetCertificateThumbprint(PCCERT_CONTEXT certContext) {

BYTE thumbprint[20] = {0};

DWORD thumbprintSize = sizeof(thumbprint);

if (CryptHashCertificate2(BCRYPT_SHA1_ALGORITHM, 0, NULL,

certContext->pbCertEncoded, certContext->cbCertEncoded, thumbprint, &thumbprintSize)) {

std::stringstream ss;

for (DWORD i = 0; i < thumbprintSize; i++) {

ss << std::hex << std::setw(2) << std::setfill('0') << (int)thumbprint[i];

}

return ss.str();

}

return "";

}

获取证书名称

证书包含了签名者和颁发者的名称，我们用 CertGetNameString 提取：

static std::string GetCertificateName(PCCERT_CONTEXT certContext, DWORD type) {
    DWORD size = CertGetNameStringA(certContext, type, 0, NULL, NULL, 0);
    if (size > 1) {
        std::vector<char> buffer(size);
        CertGetNameStringA(certContext, type, 0, NULL, buffer.data(), size);
        return buffer.data();
    }
    return "";
}

static std::string GetCertificateName(PCCERT_CONTEXT certContext, DWORD type) {

DWORD size = CertGetNameStringA(certContext, type, 0, NULL, NULL, 0);

if (size > 1) {

std::vector<char> buffer(size);

CertGetNameStringA(certContext, type, 0, NULL, buffer.data(), size);

return buffer.data();

}

return "";

}

状态码映射

不同的错误码代表不同的签名状态，可以映射为更易懂的文字：

static std::string GetStatusText(LONG status) {
    switch (status) {
        case ERROR_SUCCESS: return "Valid";
        case TRUST_E_NOSIGNATURE: return "NotSigned";
        case CERT_E_EXPIRED: return "Expired";
        case CERT_E_REVOKED: return "Revoked";
        case TRUST_E_EXPLICIT_DISTRUST: return "Distrusted";
        case TRUST_E_BAD_DIGEST: return "Invalid";
        case CERT_E_UNTRUSTEDROOT: return "UntrustedRoot";
        default: return "Error";
    }
}

static std::string GetStatusText(LONG status) {

switch (status) {

case ERROR_SUCCESS: return "Valid";

case TRUST_E_NOSIGNATURE: return "NotSigned";

case CERT_E_EXPIRED: return "Expired";

case CERT_E_REVOKED: return "Revoked";

case TRUST_E_EXPLICIT_DISTRUST: return "Distrusted";

case TRUST_E_BAD_DIGEST: return "Invalid";

case CERT_E_UNTRUSTEDROOT: return "UntrustedRoot";

default: return "Error";

}

测试与运行结果

最后，可以这样使用：

int main() {
    auto info = SignatureVerifier::GetSignatureInfo(L"C:\\Windows\\explorer.exe");
    
    printf("Status: %s\n", info.status.c_str());
    printf("Message: %s\n", info.statusMessage.c_str());
    printf("Thumbprint: %s\n", info.thumbprint.c_str());
    printf("Signer: %s\n", info.signer.c_str());
    printf("Issuer: %s\n", info.issuer.c_str());
    printf("TimeStamper: %s\n", info.timeStamper.c_str());
    printf("IsValid: %s\n", info.isValid ? "Yes" : "No");
}

int main() {

auto info = SignatureVerifier::GetSignatureInfo(L"C:\\Windows\\explorer.exe");

printf("Status: %s\n", info.status.c_str());

printf("Message: %s\n", info.statusMessage.c_str());

printf("Thumbprint: %s\n", info.thumbprint.c_str());

printf("Signer: %s\n", info.signer.c_str());

printf("Issuer: %s\n", info.issuer.c_str());

printf("TimeStamper: %s\n", info.timeStamper.c_str());

printf("IsValid: %s\n", info.isValid ? "Yes" : "No");

}

运行结果：

Status: Valid
Message: Signature verified
Thumbprint: 3b77d.........
Signer: Microsoft Windows
Issuer: Microsoft Windows
TimeStamper: Microsoft Time-Stamp Service
IsValid: Yes

Status: Valid

Message: Signature verified

Thumbprint: 3b77d.........

Signer: Microsoft Windows

Issuer: Microsoft Windows

TimeStamper: Microsoft Time-Stamp Service

IsValid: Yes

这表明 explorer.exe 的签名有效，签名者是微软，签名带有可信时间戳。

微软给出的示例 C 程序：

//-------------------------------------------------------------------
// Copyright (C) Microsoft.  All rights reserved.
// Example of verifying the embedded signature of a PE file by using 
// the WinVerifyTrust function.

#define _UNICODE 1
#define UNICODE 1

#include <tchar.h>
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <Softpub.h>
#include <wincrypt.h>
#include <wintrust.h>

// Link with the Wintrust.lib file.
#pragma comment (lib, "wintrust")

BOOL VerifyEmbeddedSignature(LPCWSTR pwszSourceFile)
{
    LONG lStatus;
    DWORD dwLastError;

    // Initialize the WINTRUST_FILE_INFO structure.

    WINTRUST_FILE_INFO FileData;
    memset(&FileData, 0, sizeof(FileData));
    FileData.cbStruct = sizeof(WINTRUST_FILE_INFO);
    FileData.pcwszFilePath = pwszSourceFile;
    FileData.hFile = NULL;
    FileData.pgKnownSubject = NULL;

    /*
    WVTPolicyGUID specifies the policy to apply on the file
    WINTRUST_ACTION_GENERIC_VERIFY_V2 policy checks:
    
    1) The certificate used to sign the file chains up to a root 
    certificate located in the trusted root certificate store. This 
    implies that the identity of the publisher has been verified by 
    a certification authority.
    
    2) In cases where user interface is displayed (which this example
    does not do), WinVerifyTrust will check for whether the  
    end entity certificate is stored in the trusted publisher store,  
    implying that the user trusts content from this publisher.
    
    3) The end entity certificate has sufficient permission to sign 
    code, as indicated by the presence of a code signing EKU or no 
    EKU.
    */

    GUID WVTPolicyGUID = WINTRUST_ACTION_GENERIC_VERIFY_V2;
    WINTRUST_DATA WinTrustData;

    // Initialize the WinVerifyTrust input data structure.

    // Default all fields to 0.
    memset(&WinTrustData, 0, sizeof(WinTrustData));

    WinTrustData.cbStruct = sizeof(WinTrustData);
    
    // Use default code signing EKU.
    WinTrustData.pPolicyCallbackData = NULL;

    // No data to pass to SIP.
    WinTrustData.pSIPClientData = NULL;

    // Disable WVT UI.
    WinTrustData.dwUIChoice = WTD_UI_NONE;

    // No revocation checking.
    WinTrustData.fdwRevocationChecks = WTD_REVOKE_NONE; 

    // Verify an embedded signature on a file.
    WinTrustData.dwUnionChoice = WTD_CHOICE_FILE;

    // Verify action.
    WinTrustData.dwStateAction = WTD_STATEACTION_VERIFY;

    // Verification sets this value.
    WinTrustData.hWVTStateData = NULL;

    // Not used.
    WinTrustData.pwszURLReference = NULL;

    // This is not applicable if there is no UI because it changes 
    // the UI to accommodate running applications instead of 
    // installing applications.
    WinTrustData.dwUIContext = 0;

    // Set pFile.
    WinTrustData.pFile = &FileData;

    // WinVerifyTrust verifies signatures as specified by the GUID 
    // and Wintrust_Data.
    lStatus = WinVerifyTrust(
        NULL,
        &WVTPolicyGUID,
        &WinTrustData);

    switch (lStatus) 
    {
        case ERROR_SUCCESS:
            /*
            Signed file:
                - Hash that represents the subject is trusted.

                - Trusted publisher without any verification errors.

                - UI was disabled in dwUIChoice. No publisher or 
                    time stamp chain errors.

                - UI was enabled in dwUIChoice and the user clicked 
                    "Yes" when asked to install and run the signed 
                    subject.
            */
            wprintf_s(L"The file \"%s\" is signed and the signature "
                L"was verified.\n",
                pwszSourceFile);
            break;
        
        case TRUST_E_NOSIGNATURE:
            // The file was not signed or had a signature 
            // that was not valid.

            // Get the reason for no signature.
            dwLastError = GetLastError();
            if (TRUST_E_NOSIGNATURE == dwLastError ||
                    TRUST_E_SUBJECT_FORM_UNKNOWN == dwLastError ||
                    TRUST_E_PROVIDER_UNKNOWN == dwLastError) 
            {
                // The file was not signed.
                wprintf_s(L"The file \"%s\" is not signed.\n",
                    pwszSourceFile);
            } 
            else 
            {
                // The signature was not valid or there was an error 
                // opening the file.
                wprintf_s(L"An unknown error occurred trying to "
                    L"verify the signature of the \"%s\" file.\n",
                    pwszSourceFile);
            }

            break;

        case TRUST_E_EXPLICIT_DISTRUST:
            // The hash that represents the subject or the publisher 
            // is not allowed by the admin or user.
            wprintf_s(L"The signature is present, but specifically "
                L"disallowed.\n");
            break;

        case TRUST_E_SUBJECT_NOT_TRUSTED:
            // The user clicked "No" when asked to install and run.
            wprintf_s(L"The signature is present, but not "
                L"trusted.\n");
            break;

        case CRYPT_E_SECURITY_SETTINGS:
            /*
            The hash that represents the subject or the publisher 
            was not explicitly trusted by the admin and the 
            admin policy has disabled user trust. No signature, 
            publisher or time stamp errors.
            */
            wprintf_s(L"CRYPT_E_SECURITY_SETTINGS - The hash "
                L"representing the subject or the publisher wasn't "
                L"explicitly trusted by the admin and admin policy "
                L"has disabled user trust. No signature, publisher "
                L"or timestamp errors.\n");
            break;

        default:
            // The UI was disabled in dwUIChoice or the admin policy 
            // has disabled user trust. lStatus contains the 
            // publisher or time stamp chain error.
            wprintf_s(L"Error is: 0x%x.\n",
                lStatus);
            break;
    }

    // Any hWVTStateData must be released by a call with close.
    WinTrustData.dwStateAction = WTD_STATEACTION_CLOSE;

    lStatus = WinVerifyTrust(
        NULL,
        &WVTPolicyGUID,
        &WinTrustData);

    return true;
}

int _tmain(int argc, _TCHAR* argv[])
{
    if(argc > 1)
    {
        VerifyEmbeddedSignature(argv[1]);
    }

    return 0;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

//-------------------------------------------------------------------

// Example of verifying the embedded signature of a PE file by using

// the WinVerifyTrust function.

#define _UNICODE 1

#define UNICODE 1

#include <tchar.h>

#include <stdio.h>

#include <stdlib.h>

#include <windows.h>

#include <Softpub.h>

#include <wincrypt.h>

#include <wintrust.h>

// Link with the Wintrust.lib file.

#pragma comment (lib, "wintrust")

BOOL VerifyEmbeddedSignature(LPCWSTR pwszSourceFile)

{

LONG lStatus;

DWORD dwLastError;

// Initialize the WINTRUST_FILE_INFO structure.

WINTRUST_FILE_INFO FileData;

memset(&FileData, 0, sizeof(FileData));

FileData.cbStruct = sizeof(WINTRUST_FILE_INFO);

FileData.pcwszFilePath = pwszSourceFile;

FileData.hFile = NULL;

FileData.pgKnownSubject = NULL;

WVTPolicyGUID specifies the policy to apply on the file

WINTRUST_ACTION_GENERIC_VERIFY_V2 policy checks:

1) The certificate used to sign the file chains up to a root

certificate located in the trusted root certificate store. This

implies that the identity of the publisher has been verified by

a certification authority.

2) In cases where user interface is displayed (which this example

does not do), WinVerifyTrust will check for whether the

end entity certificate is stored in the trusted publisher store,

implying that the user trusts content from this publisher.

3) The end entity certificate has sufficient permission to sign

code, as indicated by the presence of a code signing EKU or no

EKU.

GUID WVTPolicyGUID = WINTRUST_ACTION_GENERIC_VERIFY_V2;

WINTRUST_DATA WinTrustData;

// Initialize the WinVerifyTrust input data structure.

// Default all fields to 0.

memset(&WinTrustData, 0, sizeof(WinTrustData));

WinTrustData.cbStruct = sizeof(WinTrustData);

// Use default code signing EKU.

WinTrustData.pPolicyCallbackData = NULL;

// No data to pass to SIP.

WinTrustData.pSIPClientData = NULL;

// Disable WVT UI.

WinTrustData.dwUIChoice = WTD_UI_NONE;

// No revocation checking.

WinTrustData.fdwRevocationChecks = WTD_REVOKE_NONE;

// Verify an embedded signature on a file.

WinTrustData.dwUnionChoice = WTD_CHOICE_FILE;

// Verify action.

WinTrustData.dwStateAction = WTD_STATEACTION_VERIFY;

// Verification sets this value.

WinTrustData.hWVTStateData = NULL;

// Not used.

WinTrustData.pwszURLReference = NULL;

// This is not applicable if there is no UI because it changes

// the UI to accommodate running applications instead of

// installing applications.

WinTrustData.dwUIContext = 0;

// Set pFile.

WinTrustData.pFile = &FileData;

// WinVerifyTrust verifies signatures as specified by the GUID

// and Wintrust_Data.

lStatus = WinVerifyTrust(

NULL,

&WVTPolicyGUID,

&WinTrustData);

switch (lStatus)

{

case ERROR_SUCCESS:

Signed file:

- Hash that represents the subject is trusted.

- Trusted publisher without any verification errors.

- UI was disabled in dwUIChoice. No publisher or

time stamp chain errors.

- UI was enabled in dwUIChoice and the user clicked

"Yes" when asked to install and run the signed

subject.

wprintf_s(L"The file \"%s\" is signed and the signature "

L"was verified.\n",

pwszSourceFile);

break;

case TRUST_E_NOSIGNATURE:

// The file was not signed or had a signature

// that was not valid.

// Get the reason for no signature.

dwLastError = GetLastError();

if (TRUST_E_NOSIGNATURE == dwLastError ||

TRUST_E_SUBJECT_FORM_UNKNOWN == dwLastError ||

TRUST_E_PROVIDER_UNKNOWN == dwLastError)

{

// The file was not signed.

wprintf_s(L"The file \"%s\" is not signed.\n",

pwszSourceFile);

}

else

{

// The signature was not valid or there was an error

// opening the file.

wprintf_s(L"An unknown error occurred trying to "

L"verify the signature of the \"%s\" file.\n",

pwszSourceFile);

}

break;

case TRUST_E_EXPLICIT_DISTRUST:

// The hash that represents the subject or the publisher

// is not allowed by the admin or user.

wprintf_s(L"The signature is present, but specifically "

L"disallowed.\n");

break;

case TRUST_E_SUBJECT_NOT_TRUSTED:

// The user clicked "No" when asked to install and run.

wprintf_s(L"The signature is present, but not "

L"trusted.\n");

break;

case CRYPT_E_SECURITY_SETTINGS:

The hash that represents the subject or the publisher

was not explicitly trusted by the admin and the

admin policy has disabled user trust. No signature,

publisher or time stamp errors.

wprintf_s(L"CRYPT_E_SECURITY_SETTINGS - The hash "

L"representing the subject or the publisher wasn't "

L"explicitly trusted by the admin and admin policy "

L"has disabled user trust. No signature, publisher "

L"or timestamp errors.\n");

break;

default:

// The UI was disabled in dwUIChoice or the admin policy

// has disabled user trust. lStatus contains the

// publisher or time stamp chain error.

wprintf_s(L"Error is: 0x%x.\n",

lStatus);

break;

}

// Any hWVTStateData must be released by a call with close.

WinTrustData.dwStateAction = WTD_STATEACTION_CLOSE;

lStatus = WinVerifyTrust(

NULL,

&WVTPolicyGUID,

&WinTrustData);

return true;

}

int _tmain(int argc, _TCHAR* argv[])

{

if(argc > 1)

{

VerifyEmbeddedSignature(argv[1]);

}

return 0;

}

Flutter通过FFI实现的示例程序：

import 'dart:ffi';
import 'dart:typed_data';

import 'package:ffi/ffi.dart';

import 'verify.dart';

/// WinVerifyTrust 函数对指定对象执行信任验证作
const fnWinVerifyTrust = "WinVerifyTrust";

@Packed(1)
// ignore: camel_case_types
final class GUID extends Struct {
  @Uint32()
  // ignore: non_constant_identifier_names
  external int Data1;
  @Uint16()
  // ignore: non_constant_identifier_names
  external int Data2;
  @Uint16()
  // ignore: non_constant_identifier_names
  external int Data3;
  @Array(8)
  // ignore: non_constant_identifier_names
  external Array<Uint8> Data4;

  static Pointer<GUID> fromBytes(final Arena arena, final List<int> bytes) {
    // 分配 GUID 内存
    final guidPtr = arena<GUID>();

    try {
      final byteData = ByteData.sublistView(Uint8List.fromList(bytes));

      guidPtr.ref.Data1 = byteData.getUint32(0, Endian.big);
      guidPtr.ref.Data2 = byteData.getUint16(4, Endian.big);
      guidPtr.ref.Data3 = byteData.getUint16(6, Endian.big);

      // 拷贝 Data4（8个字节）
      for (var i = 0; i < 8; i++) {
        guidPtr.ref.Data4[i] = bytes[8 + i];
      }

      return guidPtr;
    } catch (e) {
      calloc.free(guidPtr);
      rethrow;
    }
  }
}

/// WINTRUST_ACTION_GENERIC_VERIFY_V2 Guid  (Authenticode)
///
///----------------------------------------------------------------------------
///
///  Assigned to the pgActionID parameter of WinVerifyTrust to verify the
///
///  authenticity of a file/object using the Microsoft Authenticode
///
///  Policy Provider,
///
///          {00AAC56B-CD44-11d0-8CC2-00C04FC295EE}
///
// ignore: non_constant_identifier_names
final WINTRUST_ACTION_GENERIC_VERIFY_V2 = [
  0x00,
  0xaa,
  0xc5,
  0x6b,
  0xcd,
  0x44,
  0x11,
  0xd0,
  0x8c,
  0xc2,
  0x00,
  0xc0,
  0x4f,
  0xc2,
  0x95,
  0xee,
];

/// WINTRUST_FILE_INFO Structure
///
///----------------------------------------------------------------------------
///  Used when calling WinVerifyTrust against an individual file.
///
@Packed(8)
// ignore: camel_case_types
final class WINTRUST_FILE_INFO extends Struct {
  /// = sizeof(WINTRUST_FILE_INFO)
  @Uint32()
  external int cbStruct;

  /// required, file name to be verified
  external Pointer<Utf16> pcwszFilePath;

  /// optional, open handle to pcwszFilePath
  external Pointer<Void> hFile;

  /// optional: fill if the subject type is known.
  external Pointer<GUID> pgKnownSubject;

  static int lengthBytes() {
    // 32 Bytes
    return sizeOf<WINTRUST_FILE_INFO>();
  }

  static Pointer<WINTRUST_FILE_INFO> allocate(final Arena arena) {
    final lengthInBytes = lengthBytes();
    final res = arena.allocate<WINTRUST_FILE_INFO>(lengthInBytes);
    res.ref.cbStruct = lengthInBytes;
    return res;
  }
}

/// dwUIChoice
// ignore: constant_identifier_names
const WTD_UI_ALL = 1;
// ignore: constant_identifier_names
const WTD_UI_NONE = 2;
// ignore: constant_identifier_names
const WTD_UI_NOBAD = 3;
// ignore: constant_identifier_names
const WTD_UI_NOGOOD = 4;

/// fdwRevocationChecks
// ignore: constant_identifier_names
const WTD_REVOKE_NONE = 0x00000000;
// ignore: constant_identifier_names
const WTD_REVOKE_WHOLECHAIN = 0x00000001;

/// dwUnionChoice
// ignore: constant_identifier_names
const WTD_CHOICE_FILE = 1;
// ignore: constant_identifier_names
const WTD_CHOICE_CATALOG = 2;
// ignore: constant_identifier_names
const WTD_CHOICE_BLOB = 3;
// ignore: constant_identifier_names
const WTD_CHOICE_SIGNER = 4;
// ignore: constant_identifier_names
const WTD_CHOICE_CERT = 5;
// ignore: constant_identifier_names
const WTD_CHOICE_DETACHED_SIG = 6;

/// dwStateAction
// ignore: constant_identifier_names
const WTD_STATEACTION_IGNORE = 0x00000000;
// ignore: constant_identifier_names
const WTD_STATEACTION_VERIFY = 0x00000001;
// ignore: constant_identifier_names
const WTD_STATEACTION_CLOSE = 0x00000002;
// ignore: constant_identifier_names
const WTD_STATEACTION_AUTO_CACHE = 0x00000003;
// ignore: constant_identifier_names
const WTD_STATEACTION_AUTO_CACHE_FLUSH = 0x00000004;

/// dwProvFlags
// ignore: constant_identifier_names
const WTD_PROV_FLAGS_MASK = 0x0000FFFF;
// ignore: constant_identifier_names
const WTD_USE_IE4_TRUST_FLAG = 0x00000001;
// ignore: constant_identifier_names
const WTD_NO_IE4_CHAIN_FLAG = 0x00000002;
// ignore: constant_identifier_names
const WTD_NO_POLICY_USAGE_FLAG = 0x00000004;
// ignore: constant_identifier_names
const WTD_USE_LOCAL_MACHINE_CERTS = 0x00000008;
// ignore: constant_identifier_names
const WTD_REVOCATION_CHECK_NONE = 0x00000010;
// ignore: constant_identifier_names
const WTD_REVOCATION_CHECK_END_CERT = 0x00000020;
// ignore: constant_identifier_names
const WTD_REVOCATION_CHECK_CHAIN = 0x00000040;
// ignore: constant_identifier_names
const WTD_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT = 0x00000080;
// ignore: constant_identifier_names
const WTD_SAFER_FLAG = 0x00000100;
// ignore: constant_identifier_names
const WTD_HASH_ONLY_FLAG = 0x00000200;
// ignore: constant_identifier_names
const WTD_USE_DEFAULT_OSVER_CHECK = 0x00000400;
// ignore: constant_identifier_names
const WTD_LIFETIME_SIGNING_FLAG = 0x00000800;

/// affects CRL retrieval and AIA retrieval
// ignore: constant_identifier_names
const WTD_CACHE_ONLY_URL_RETRIEVAL = 0x00001000;
// ignore: constant_identifier_names
const WTD_DISABLE_MD2_MD4 = 0x00002000;
// ignore: constant_identifier_names
const WTD_MOTW = 0x00004000; // Mark-Of-The-Web

/// Code Integrity driver mode
// ignore: constant_identifier_names
const WTD_CODE_INTEGRITY_DRIVER_MODE = 0x00008000;

/// dwUIContext
// ignore: constant_identifier_names
const WTD_UICONTEXT_EXECUTE = 0;
// ignore: constant_identifier_names
const WTD_UICONTEXT_INSTALL = 1;

///
/// WINTRUST_DATA Structure
///
///----------------------------------------------------------------------------
///
///  Used when calling WinVerifyTrust to pass necessary information into
///
///  the Providers.
@Packed(8)
// ignore: camel_case_types
final class WINTRUST_DATA extends Struct {
  /// = sizeof(WINTRUST_DATA)
  @Uint32()
  external int cbStruct;

  /// optional: used to pass data between the app and policy
  external Pointer<Void> pPolicyCallbackData;

  /// optional: used to pass data between the app and SIP.
  external Pointer<Void> pSIPClientData;

  /// required: UI choice.  One of the following.
  @Uint32()
  external int dwUIChoice;

  /// required: certificate revocation check options
  @Uint32()
  external int fdwRevocationChecks;

  /// required: which structure is being passed in?
  @Uint32()
  external int dwUnionChoice;

  /// 具体的验证对象指针
  external Pointer<WINTRUST_FILE_INFO> pFile;

  // optional (Catalog File Processing)
  @Uint32()
  external int dwStateAction;

  // optional (Catalog File Processing)
  external Pointer<Void> hWVTStateData;

  // optional: (future) used to determine zone.
  external Pointer<WChar> pwszURLReference;

  // optional (Catalog File Processing)
  @Uint32()
  external int dwProvFlags;

  @Uint32()
  external int dwUIContext;

  //
  // #if (NTDDI_VERSION >= NTDDI_WIN8)
  // struct WINTRUST_SIGNATURE_SETTINGS_    *pSignatureSettings;
  // #endif // #if (NTDDI_VERSION >= NTDDI_WIN8)
  external Pointer<Void> pSignatureSettings;

  static int lengthBytes() {
    // 88 Bytes (WIN10以及之后） 或者 80 Bytes(WIN8以及之前）
    return sizeOf<WINTRUST_DATA>();
  }

  static Pointer<WINTRUST_DATA> allocate(final Arena arena) {
    final lengthInBytes = lengthBytes();
    final res = arena.allocate<WINTRUST_DATA>(lengthInBytes);
    res.ref.cbStruct = lengthInBytes;
    return res;
  }
}

//
// MessageId: TRUST_E_PROVIDER_UNKNOWN
//
// MessageText:
//
// Unknown trust provider.
//
// ignore: constant_identifier_names
const TRUST_E_PROVIDER_UNKNOWN = 0x800B0001;

//
// MessageId: TRUST_E_ACTION_UNKNOWN
//
// MessageText:
//
// The trust verification action specified is not supported by the specified trust provider.
//
// ignore: constant_identifier_names
const TRUST_E_ACTION_UNKNOWN = 0x800B0002;

//
// MessageId: TRUST_E_SUBJECT_FORM_UNKNOWN
//
// MessageText:
//
// The form specified for the subject is not one supported or known by the specified trust provider.
//
// ignore: constant_identifier_names
const TRUST_E_SUBJECT_FORM_UNKNOWN = 0x800B0003;

// MessageId: TRUST_E_SUBJECT_NOT_TRUSTED
//
// MessageText:
//
// The subject is not trusted for the specified action.
//
// ignore: constant_identifier_names
const TRUST_E_SUBJECT_NOT_TRUSTED = 0x800B0004;

//
// MessageId: TRUST_E_NOSIGNATURE
//
// MessageText:
//
// No signature was present in the subject.
//
// ignore: constant_identifier_names
const TRUST_E_NOSIGNATURE = 0x800B0100;

//
// MessageId: TRUST_E_EXPLICIT_DISTRUST
//
// MessageText:
//
// The certificate was explicitly marked as untrusted by the user.
//
// ignore: constant_identifier_names
const TRUST_E_EXPLICIT_DISTRUST = 0x800B0111;

// ignore: constant_identifier_names
const ERROR_SUCCESS = 0;

/// Windows 数字签名获取与验证
///
/// https://learn.microsoft.com/zh-cn/windows/win32/api/wintrust/nf-wintrust-winverifytrust
///
/// https://learn.microsoft.com/zh-cn/windows/win32/seccrypto/example-c-program--verifying-the-signature-of-a-pe-file
class WinVerifyTrust {
  /// 动态库加载
  late final DynamicLibrary? _trustLib;

  late final int Function(
    Pointer<Void> hwnd,
    Pointer<GUID> pgActionID,
    Pointer<Void> pWVTData,
  )?
  _winVerifyTrust;

  /// Checks whether this dynamic library provides a symbol with the given name.
  bool _providesSymbol(final String symbolName) {
    return _trustLib?.providesSymbol(symbolName) ?? false;
  }

  WinVerifyTrust() {
    try {
      _trustLib = DynamicLibrary.open("Wintrust.dll"); // 加载dll,获取句柄
    } catch (e) {
      _trustLib = null;
      debugPrint('Wintrust Load Failed: $e');
    }
    // 获取函数指针
    if (_providesSymbol(fnWinVerifyTrust)) {
      _winVerifyTrust = _trustLib!
          .lookup<
            NativeFunction<
              Uint32 Function(Pointer<Void>, Pointer<GUID>, Pointer<Void>)
            >
          >(fnWinVerifyTrust)
          .asFunction();
    } else {
      _winVerifyTrust = null;
    }
  }

  /// 对文件的签名进行验证
  ///
  /// [file] 需要验证签名的文件的绝对路径
  ///
  /// 比如："D:\\Source\\build\\windows\\x64\\runner\\Debug\\WebView2Loader.dll"
  ///
  /// return 验证结果
  bool verifyEmbeddedSignature(final String file) {
    final nativeFile = file.toNativeUtf16();
    var verifyRes = false;
    using((Arena arena) {
      final Pointer<GUID> wvTPolicyGUID = GUID.fromBytes(
        arena,
        WINTRUST_ACTION_GENERIC_VERIFY_V2,
      );

      final wfi = WINTRUST_FILE_INFO.allocate(arena);
      wfi.ref.pcwszFilePath = nativeFile;

      final wtd = WINTRUST_DATA.allocate(arena);
      wtd.ref.pFile = wfi;
      // Disable WVT UI.
      wtd.ref.dwUIChoice = WTD_UI_NONE;

      // No revocation checking.
      wtd.ref.fdwRevocationChecks = WTD_REVOKE_NONE;

      // Verify an embedded signature on a file.
      wtd.ref.dwUnionChoice = WTD_CHOICE_FILE;

      // Verify action.
      wtd.ref.dwStateAction = WTD_STATEACTION_VERIFY;

      // WinVerifyTrust verifies signatures as specified by the GUID
      // and Wintrust_Data.
      var res = _winVerifyTrust?.call(
        nullptr,
        wvTPolicyGUID,
        wtd as Pointer<Void>,
      );
      if (ERROR_SUCCESS == res) {
        verifyRes = true;
      }

      // Any hWVTStateData must be released by a call with close.
      wtd.ref.dwStateAction = WTD_STATEACTION_CLOSE;

      res = _winVerifyTrust?.call(nullptr, wvTPolicyGUID, wtd as Pointer<Void>);
    });
    calloc.free(nativeFile);
    return verifyRes;
  }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

import 'dart:ffi';

import 'dart:typed_data';

import 'package:ffi/ffi.dart';

import 'verify.dart';

/// WinVerifyTrust 函数对指定对象执行信任验证作

const fnWinVerifyTrust = "WinVerifyTrust";

@Packed(1)

// ignore: camel_case_types

final class GUID extends Struct {

@Uint32()

// ignore: non_constant_identifier_names

external int Data1;

@Uint16()

// ignore: non_constant_identifier_names

external int Data2;

@Uint16()

// ignore: non_constant_identifier_names

external int Data3;

@Array(8)

// ignore: non_constant_identifier_names

external Array<Uint8> Data4;

static Pointer<GUID> fromBytes(final Arena arena, final List<int> bytes) {

// 分配 GUID 内存

final guidPtr = arena<GUID>();

try {

final byteData = ByteData.sublistView(Uint8List.fromList(bytes));

guidPtr.ref.Data1 = byteData.getUint32(0, Endian.big);

guidPtr.ref.Data2 = byteData.getUint16(4, Endian.big);

guidPtr.ref.Data3 = byteData.getUint16(6, Endian.big);

// 拷贝 Data4（8个字节）

for (var i = 0; i < 8; i++) {

guidPtr.ref.Data4[i] = bytes[8 + i];

}

return guidPtr;

} catch (e) {

calloc.free(guidPtr);

rethrow;

}

/// WINTRUST_ACTION_GENERIC_VERIFY_V2 Guid (Authenticode)

///

///----------------------------------------------------------------------------

///

/// Assigned to the pgActionID parameter of WinVerifyTrust to verify the

///

/// authenticity of a file/object using the Microsoft Authenticode

///

/// Policy Provider,

///

/// {00AAC56B-CD44-11d0-8CC2-00C04FC295EE}

///

// ignore: non_constant_identifier_names

final WINTRUST_ACTION_GENERIC_VERIFY_V2 = [

0x00,

0xaa,

0xc5,

0x6b,

0xcd,

0x44,

0x11,

0xd0,

0x8c,

0xc2,

0x00,

0xc0,

0x4f,

0xc2,

0x95,

0xee,

];

/// WINTRUST_FILE_INFO Structure

///

///----------------------------------------------------------------------------

/// Used when calling WinVerifyTrust against an individual file.

///

@Packed(8)

// ignore: camel_case_types

final class WINTRUST_FILE_INFO extends Struct {

/// = sizeof(WINTRUST_FILE_INFO)

@Uint32()

external int cbStruct;

/// required, file name to be verified

external Pointer<Utf16> pcwszFilePath;

/// optional, open handle to pcwszFilePath

external Pointer<Void> hFile;

/// optional: fill if the subject type is known.

external Pointer<GUID> pgKnownSubject;

static int lengthBytes() {

// 32 Bytes

return sizeOf<WINTRUST_FILE_INFO>();

}

static Pointer<WINTRUST_FILE_INFO> allocate(final Arena arena) {

final lengthInBytes = lengthBytes();

final res = arena.allocate<WINTRUST_FILE_INFO>(lengthInBytes);

res.ref.cbStruct = lengthInBytes;

return res;

}

/// dwUIChoice

// ignore: constant_identifier_names

const WTD_UI_ALL = 1;

// ignore: constant_identifier_names

const WTD_UI_NONE = 2;

// ignore: constant_identifier_names

const WTD_UI_NOBAD = 3;

// ignore: constant_identifier_names

const WTD_UI_NOGOOD = 4;

/// fdwRevocationChecks

// ignore: constant_identifier_names

const WTD_REVOKE_NONE = 0x00000000;

// ignore: constant_identifier_names

const WTD_REVOKE_WHOLECHAIN = 0x00000001;

/// dwUnionChoice

// ignore: constant_identifier_names

const WTD_CHOICE_FILE = 1;

// ignore: constant_identifier_names

const WTD_CHOICE_CATALOG = 2;

// ignore: constant_identifier_names

const WTD_CHOICE_BLOB = 3;

// ignore: constant_identifier_names

const WTD_CHOICE_SIGNER = 4;

// ignore: constant_identifier_names

const WTD_CHOICE_CERT = 5;

// ignore: constant_identifier_names

const WTD_CHOICE_DETACHED_SIG = 6;

/// dwStateAction

// ignore: constant_identifier_names

const WTD_STATEACTION_IGNORE = 0x00000000;

// ignore: constant_identifier_names

const WTD_STATEACTION_VERIFY = 0x00000001;

// ignore: constant_identifier_names

const WTD_STATEACTION_CLOSE = 0x00000002;

// ignore: constant_identifier_names

const WTD_STATEACTION_AUTO_CACHE = 0x00000003;

// ignore: constant_identifier_names

const WTD_STATEACTION_AUTO_CACHE_FLUSH = 0x00000004;

/// dwProvFlags

// ignore: constant_identifier_names

const WTD_PROV_FLAGS_MASK = 0x0000FFFF;

// ignore: constant_identifier_names

const WTD_USE_IE4_TRUST_FLAG = 0x00000001;

// ignore: constant_identifier_names

const WTD_NO_IE4_CHAIN_FLAG = 0x00000002;

// ignore: constant_identifier_names

const WTD_NO_POLICY_USAGE_FLAG = 0x00000004;

// ignore: constant_identifier_names

const WTD_USE_LOCAL_MACHINE_CERTS = 0x00000008;

// ignore: constant_identifier_names

const WTD_REVOCATION_CHECK_NONE = 0x00000010;

// ignore: constant_identifier_names

const WTD_REVOCATION_CHECK_END_CERT = 0x00000020;

// ignore: constant_identifier_names

const WTD_REVOCATION_CHECK_CHAIN = 0x00000040;

// ignore: constant_identifier_names

const WTD_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT = 0x00000080;

// ignore: constant_identifier_names

const WTD_SAFER_FLAG = 0x00000100;

// ignore: constant_identifier_names

const WTD_HASH_ONLY_FLAG = 0x00000200;

// ignore: constant_identifier_names

const WTD_USE_DEFAULT_OSVER_CHECK = 0x00000400;

// ignore: constant_identifier_names

const WTD_LIFETIME_SIGNING_FLAG = 0x00000800;

/// affects CRL retrieval and AIA retrieval

// ignore: constant_identifier_names

const WTD_CACHE_ONLY_URL_RETRIEVAL = 0x00001000;

// ignore: constant_identifier_names

const WTD_DISABLE_MD2_MD4 = 0x00002000;

// ignore: constant_identifier_names

const WTD_MOTW = 0x00004000; // Mark-Of-The-Web

/// Code Integrity driver mode

// ignore: constant_identifier_names

const WTD_CODE_INTEGRITY_DRIVER_MODE = 0x00008000;

/// dwUIContext

// ignore: constant_identifier_names

const WTD_UICONTEXT_EXECUTE = 0;

// ignore: constant_identifier_names

const WTD_UICONTEXT_INSTALL = 1;

///

/// WINTRUST_DATA Structure

///

///----------------------------------------------------------------------------

///

/// Used when calling WinVerifyTrust to pass necessary information into

///

/// the Providers.

@Packed(8)

// ignore: camel_case_types

final class WINTRUST_DATA extends Struct {

/// = sizeof(WINTRUST_DATA)

@Uint32()

external int cbStruct;

/// optional: used to pass data between the app and policy

external Pointer<Void> pPolicyCallbackData;

/// optional: used to pass data between the app and SIP.

external Pointer<Void> pSIPClientData;

/// required: UI choice. One of the following.

@Uint32()

external int dwUIChoice;

/// required: certificate revocation check options

@Uint32()

external int fdwRevocationChecks;

/// required: which structure is being passed in?

@Uint32()

external int dwUnionChoice;

/// 具体的验证对象指针

external Pointer<WINTRUST_FILE_INFO> pFile;

// optional (Catalog File Processing)

@Uint32()

external int dwStateAction;

// optional (Catalog File Processing)

external Pointer<Void> hWVTStateData;

// optional: (future) used to determine zone.

external Pointer<WChar> pwszURLReference;

// optional (Catalog File Processing)

@Uint32()

external int dwProvFlags;

@Uint32()

external int dwUIContext;

// #if (NTDDI_VERSION >= NTDDI_WIN8)

// struct WINTRUST_SIGNATURE_SETTINGS_ *pSignatureSettings;

// #endif // #if (NTDDI_VERSION >= NTDDI_WIN8)

external Pointer<Void> pSignatureSettings;

static int lengthBytes() {

// 88 Bytes (WIN10以及之后）或者 80 Bytes(WIN8以及之前）

return sizeOf<WINTRUST_DATA>();

}

static Pointer<WINTRUST_DATA> allocate(final Arena arena) {

final lengthInBytes = lengthBytes();

final res = arena.allocate<WINTRUST_DATA>(lengthInBytes);

res.ref.cbStruct = lengthInBytes;

return res;

}

// MessageId: TRUST_E_PROVIDER_UNKNOWN

// MessageText:

// Unknown trust provider.

// ignore: constant_identifier_names

const TRUST_E_PROVIDER_UNKNOWN = 0x800B0001;

// MessageId: TRUST_E_ACTION_UNKNOWN

// MessageText:

// The trust verification action specified is not supported by the specified trust provider.

// ignore: constant_identifier_names

const TRUST_E_ACTION_UNKNOWN = 0x800B0002;

// MessageId: TRUST_E_SUBJECT_FORM_UNKNOWN

// MessageText:

// The form specified for the subject is not one supported or known by the specified trust provider.

// ignore: constant_identifier_names

const TRUST_E_SUBJECT_FORM_UNKNOWN = 0x800B0003;

// MessageId: TRUST_E_SUBJECT_NOT_TRUSTED

// MessageText:

// The subject is not trusted for the specified action.

// ignore: constant_identifier_names

const TRUST_E_SUBJECT_NOT_TRUSTED = 0x800B0004;

// MessageId: TRUST_E_NOSIGNATURE

// MessageText:

// No signature was present in the subject.

// ignore: constant_identifier_names

const TRUST_E_NOSIGNATURE = 0x800B0100;

// MessageId: TRUST_E_EXPLICIT_DISTRUST

// MessageText:

// The certificate was explicitly marked as untrusted by the user.

// ignore: constant_identifier_names

const TRUST_E_EXPLICIT_DISTRUST = 0x800B0111;

// ignore: constant_identifier_names

const ERROR_SUCCESS = 0;

/// Windows 数字签名获取与验证

///

/// https://learn.microsoft.com/zh-cn/windows/win32/api/wintrust/nf-wintrust-winverifytrust

///

/// https://learn.microsoft.com/zh-cn/windows/win32/seccrypto/example-c-program--verifying-the-signature-of-a-pe-file

class WinVerifyTrust {

/// 动态库加载

late final DynamicLibrary? _trustLib;

late final int Function(

Pointer<Void> hwnd,

Pointer<GUID> pgActionID,

Pointer<Void> pWVTData,

_winVerifyTrust;

/// Checks whether this dynamic library provides a symbol with the given name.

bool _providesSymbol(final String symbolName) {

return _trustLib?.providesSymbol(symbolName) ?? false;

}

WinVerifyTrust() {

try {

_trustLib = DynamicLibrary.open("Wintrust.dll"); // 加载dll,获取句柄

} catch (e) {

_trustLib = null;

debugPrint('Wintrust Load Failed: $e');

}

// 获取函数指针

if (_providesSymbol(fnWinVerifyTrust)) {

_winVerifyTrust = _trustLib!

.lookup<

NativeFunction<

Uint32 Function(Pointer<Void>, Pointer<GUID>, Pointer<Void>)

>(fnWinVerifyTrust)

.asFunction();

} else {

_winVerifyTrust = null;

}

/// 对文件的签名进行验证

///

/// [file] 需要验证签名的文件的绝对路径

///

/// 比如："D:\\Source\\build\\windows\\x64\\runner\\Debug\\WebView2Loader.dll"

///

/// return 验证结果

bool verifyEmbeddedSignature(final String file) {

final nativeFile = file.toNativeUtf16();

var verifyRes = false;

using((Arena arena) {

final Pointer<GUID> wvTPolicyGUID = GUID.fromBytes(

arena,

WINTRUST_ACTION_GENERIC_VERIFY_V2,

);

final wfi = WINTRUST_FILE_INFO.allocate(arena);

wfi.ref.pcwszFilePath = nativeFile;

final wtd = WINTRUST_DATA.allocate(arena);

wtd.ref.pFile = wfi;

// Disable WVT UI.

wtd.ref.dwUIChoice = WTD_UI_NONE;

// No revocation checking.

wtd.ref.fdwRevocationChecks = WTD_REVOKE_NONE;

// Verify an embedded signature on a file.

wtd.ref.dwUnionChoice = WTD_CHOICE_FILE;

// Verify action.

wtd.ref.dwStateAction = WTD_STATEACTION_VERIFY;

// WinVerifyTrust verifies signatures as specified by the GUID

// and Wintrust_Data.

var res = _winVerifyTrust?.call(

nullptr,

wvTPolicyGUID,

wtd as Pointer<Void>,

);

if (ERROR_SUCCESS == res) {

verifyRes = true;

}

// Any hWVTStateData must be released by a call with close.

wtd.ref.dwStateAction = WTD_STATEACTION_CLOSE;

res = _winVerifyTrust?.call(nullptr, wvTPolicyGUID, wtd as Pointer<Void>);

});

calloc.free(nativeFile);

return verifyRes;

}

参考链接

开关电源常见故障维修-可调电阻失效

故障现象

最近3D打印机自带的显示屏非常暗淡，USB插上电脑之后，屏幕恢复正常亮度。使用万用表测试供电引脚，发现开关电源输出的电压在 7～9V 之间波动。这个电源的输出电压是 18V 的，当前只输出这么低的电压，明显是有问题的。

问题分析

电源能正常输出电压，并能勉强维持系统正常运行，说明电源的转换电路工作是正常的，那么电源的前极部分应该是正常工作的，否则后端不应该有电压产生。那么问题大概率就是电源后极的部分的问题。这种现象产生的原因大概率与电源的可调电阻有关系。

继续阅读开关电源常见故障维修-可调电阻失效

VirtualBox虚拟机不显示状态栏和菜单栏

VirtualBox的虚拟机在操作时，需要点击菜单栏和任务栏，但有时候我们会出现无法显示的问题。

继续阅读VirtualBox虚拟机不显示状态栏和菜单栏

KiCad-V9.0.7制作收音机三极管(BJT)

前置条件

macOS Tahoe (26.3)
MacBook Pro 2023-Apple M2 Pro （4能效核、8性能核、32GB内存、2TB磁盘）
OpenSCAD 2026.02.18 (或更高版本)
FreeCAD 1.1.0rc2 (或更高版本)
KiCad 9.0.7 (或更高版本)

由于 KiCad 缺少国产零件的封装，所以部分封装库我们需要自己创建。

继续阅读KiCad-V9.0.7制作收音机三极管(BJT)

KiCAD的Courtyard层如何使用？

“ 使用Allegro的小伙伴应该很清楚Courtyard层的用法，但使用Altium Designer的小伙伴可能对Courtyard层完全没有概念。Courtyard层到底是什么？在KiCad中如何使用？”。

或者执行“封装检查”报错“没有定义外框”英文 “Footprint has no courtyard defined”，那这个报错的含义是什么？

Courtyard是指装配或其他功能所需的物理元件周围的区域。该区域内不应放置其他元件。如果元件之间的距离太近，组装可能会很困难或是不可能。

在讨论装配时，需要的区域取决于装配方式（自动或手动）以及其他可能的细节。没有一个绝对正确的区域、形状或Courtyard的尺寸可以保证无问题的装配，同时又是最优的(小)尺寸，可以密集的放置。需要在“方便装配”与“装配区域尽可能小”之间取得妥协。

作为一个粗略的指导，KiCad可以检查组件是否太靠近，即检查Courtyard的碰撞情况，也就是检查重叠的Courtyard区域。Courtyard区域必须是一个封闭的形状。该形状以图形方式绘制在F.Courtyard或B.Courtyard层上。要求与Edge.Cuts 板框层完全相同：每条线必须在下一条开始的地方结束，它们不能交叉，最后一条必须在第一条开始的地方结束。除了这个封闭的形状之外，该层的封装中不能有其他东西。

Courtyard通常用一个长方形表示。

如果一个绘制Courtyard时不遵守这些规则，或者Courtyard存在其他问题，DRC会报错：

第一个错误表示Courtyard图形不封闭；第二个错误表示Courtyard自相交；第三个错误表示两个元件的Courtyard重叠。

违规的严重度可以在“电路板设置”中更改：

如果你设计或修改你自己的封装，由于没有任何硬性规定可以遵循，你可以画一个“足够好”的Courtyard来满足你的目的。如果你想对此进行优化，则需要知道装配过程的限制以及该元件与周围部件之间的相互作用。例如：想象一个很高的元件和一个很矮的元件并排放在一起：高的可能很容易放置，但高的放置完成后，再装配矮的元件可能会有问题，即使Courtyard本身估计足够大。

需要在元件周围留出足够的制造空间。如果需要更严格的设计，需要根据具体情况决定一些Courtyard是否可以与其他Courtyard重叠。DRC中两个组件之间的违规行为可以被排除或忽略。

请注意，虽然从逻辑上讲，在有理想Courtyard的理想情况下，每个元件只需要其周围由自己的Courtyard形成的空间，但重叠的Courtyard是允许的。DRC会检查这种重叠。然而，尽管可以允许两个元件的Courtyard重叠，但这种重叠应该排除一个元件的焊盘，或者元件轮廓（通常是在Fab层上绘制），与另一个元件的Courtyard重叠的情况。

在现实世界中，现代的自动装配过程可以做到相当密集的元件放置。例如，对于0402元件，铜的间隙限制了放置，而不是KiCad官方封装所建议的Courtyard。

参考链接

Courtyard层如何使用？

如何在macOS开发中给 PKG 签名和公证（productsign+notarytool）

在 macOS 中，给 PKG 文件进行签名是一个确保用户能够顺利无警告地安装软件的重要步骤。以下是给 PKG 签名的详细步骤：

一、准备阶段

获取开发者账号和证书：

首先，需要在苹果开发者网站（Apple Developer）注册一个有效的开发者账号。
登录开发者账号后，进入 “Certificates, IDs & Profiles” 页面。
创建并下载 “Developer ID Application” 证书和 “Developer ID Installer” 证书。这两个证书分别用于签名应用程序和 PKG 安装包。
将下载的证书双击安装到“钥匙串访问”中。

打包PKG文件：

使用 Packages 工具或其他打包工具，将需要分发的应用程序和相关文件打包成一个 PKG 安装包。
在打包过程中，可以添加安装前和安装后的脚本来执行一些自定义操作。

二、签名阶段

获取证书名称：

打开终端，输入命令 security find-identity -v，列出所有已安装的证书。
找到与 “Developer ID Installer” 相关的证书名称，通常格式为 “Developer ID Installer: 开发者名称 (证书标识符)”。

签名PKG文件：

使用 productsign 命令对 PKG 文件进行签名。命令格式如下：

$ productsign --sign "Developer ID Installer: 开发者名称 (证书标识符)" 原始PKG文件路径 签名后的PKG文件路径

1	$ productsign --sign "Developer ID Installer: 开发者名称 (证书标识符)" 原始PKG文件路径签名后的PKG文件路径

例如：

$ productsign --sign "Developer ID Installer: Your Company, Co., LTD (2988ZTAM4B)" App.pkg App-Signed.pkg

1	$ productsign --sign "Developer ID Installer: Your Company, Co., LTD (2988ZTAM4B)" App.pkg App-Signed.pkg

这将生成一个新的签名后的 PKG 文件。

三、验证签名

验证PKG文件签名：

使用 pkgutil 命令验证 PKG 文件的签名是否有效。命令格式如下：

$ pkgutil --check-signature 签名后的PKG文件路径

1	$ pkgutil --check-signature 签名后的PKG文件路径

如果签名有效，命令将输出 “signed by a developer certificate issued by Apple for distribution”。

四、公证阶段（可选）

从 macOS 10.14.5 开始，苹果要求所有分发的软件都必须经过公证（Notarization）。公证过程如下：

准备已签名的软件包：

在公证之前，你需要确保你的 .pkg 文件已经使用 codesign 命令进行了签名。

将公证凭证存储到 macOS 的钥匙串中：

$ xcrun notarytool store-credentials "$KEYCHAIN_PROFILE" \
 --apple-id "$APPLE_ID" \
 --team-id "$TEAM_ID" \
 --password "$APP_SPECIFIC_PASSWORD"

$ xcrun notarytool store-credentials "$KEYCHAIN_PROFILE" \

--apple-id "$APPLE_ID" \

--team-id "$TEAM_ID" \

--password "$APP_SPECIFIC_PASSWORD"

上传PKG文件到苹果服务器：

使用 notarytool 提交你的软件包进行公证。这一步会将你的软件包上传到 Apple 的公证服务，并启动公证流程。

$ xcrun notarytool submit $ /path/to/your/signed/package.pkg --keychain-profile $KEYCHAIN_PROFILE --wait

1	$ xcrun notarytool submit $ /path/to/your/signed/package.pkg --keychain-profile $KEYCHAIN_PROFILE --wait

/path/to/your/signed/package.pkg 是你的已签名软件包的路径。
--keychain-profile 参数用于指定包含你签名证书的钥匙串配置文件（可选，如果证书在默认钥匙串中则不需要）。
--wait 参数告诉 notarytool 等待公证完成并返回结果。

如果公证成功，notarytool 会返回一个 RequestUUID，你可以使用这个 UUID 来查询公证状态或进行后续操作。

检查公证结果（如果未使用 --wait）：

如果你没有使用 --wait 参数，你需要使用返回的 RequestUUID 来检查公证状态。

$ xcrun notarytool status <RequestUUID>

1	$ xcrun notarytool status <RequestUUID>

替换 <RequestUUID> 为你实际获得的 UUID。

五、盖章步骤

一旦你的软件包通过了公证，你就可以使用 stapler 工具对其进行盖章。

对软件包进行盖章：

使用 stapler 工具对你的软件包进行盖章，以表明它已经通过了 Apple 的公证服务。

$ xcrun stapler staple /path/to/your/signed/package.pkg

1	$ xcrun stapler staple /path/to/your/signed/package.pkg

/path/to/your/signed/package.pkg 是你的已签名且已公证的软件包的路径。

验证盖章结果（可选）：

你可以使用 stapler 工具来验证你的软件包是否已经被正确盖章。

$ xcrun stapler validate /path/to/your/stapled/package.pkg

1	$ xcrun stapler validate /path/to/your/stapled/package.pkg

/path/to/your/stapled/package.pkg 是你的已盖章软件包的路径。

如果所有步骤都成功完成，你的软件包现在应该已经准备好分发给用户了。

用户可以通过 macOS 的“安装未知开发者应用”的安全设置来安装你的软件包，而不会因为未经验证的应用程序而被阻止。

六、命令集合

以下是一个简要的流程，以及一个相应的 .sh 脚本示例:

1.用于签名 .pkg 文件( productsign.sh )。

#!/bin/bash

# 证书名称，使用"security find-identity -v"命令查找并替换
CERT_NAME="Developer ID Installer: Your Company Co., Ltd. (4H8C8HR626)"

# 原始PKG文件路径，替换为你的PKG文件路径
PKG_PATH="Install App.pkg"
  
# 签名后的PKG文件路径，替换为你想要保存的签名PKG文件路径
SIGNED_PKG_PATH="../Install App.pkg"

# 签名PKG文件
echo "正在签名PKG文件..."
productsign --sign "$CERT_NAME" "$PKG_PATH" "$SIGNED_PKG_PATH"
if [ $? -ne 0 ]; then
    echo "签名PKG文件失败"
    exit 1
fi
echo "PKG文件签名成功"
  
# 验证签名
echo "正在验证PKG文件签名..."
pkgutil --check-signature "$SIGNED_PKG_PATH"
if [ $? -ne 0 ]; then
    echo "验证PKG文件签名失败"
    exit 1
fi
echo "PKG文件签名验证成功"
echo "所有脚本执行成功！"

#!/bin/bash

# 证书名称，使用"security find-identity -v"命令查找并替换

CERT_NAME="Developer ID Installer: Your Company Co., Ltd. (4H8C8HR626)"

# 原始PKG文件路径，替换为你的PKG文件路径

PKG_PATH="Install App.pkg"

# 签名后的PKG文件路径，替换为你想要保存的签名PKG文件路径

SIGNED_PKG_PATH="../Install App.pkg"

# 签名PKG文件

echo "正在签名PKG文件..."

productsign --sign "$CERT_NAME" "$PKG_PATH" "$SIGNED_PKG_PATH"

if [ $? -ne 0 ]; then

echo "签名PKG文件失败"

exit 1

echo "PKG文件签名成功"

# 验证签名

echo "正在验证PKG文件签名..."

pkgutil --check-signature "$SIGNED_PKG_PATH"

if [ $? -ne 0 ]; then

echo "验证PKG文件签名失败"

exit 1

echo "PKG文件签名验证成功"

echo "所有脚本执行成功！"

2.用于签名和公证 .pkg 文件(productsign-online-notarytool.sh)。

#!/bin/bash

# 证书名称，使用"security find-identity -v"命令查找并替换
CERT_NAME="Developer ID Installer: Your Company Co., Ltd. (4H8C8HR626)"
# 开发者团队ID
# 从CERT_NAME中提取TEAM_ID
# 假设TEAM_ID总是位于最后一对括号内
# TEAM_ID="4H8C8HR626"
TEAM_ID=$(echo "$CERT_NAME" | awk -F'[()]' '{print $2}')

# 原始PKG文件路径，替换为你的PKG文件路径
PKG_PATH="Install App.pkg"
  
# 签名后的PKG文件路径，替换为你想要保存的签名PKG文件路径
SIGNED_PKG_PATH="../Install App.pkg"
  
# 苹果开发者账号
APPLE_ID="apple@163.com"
  
# 应用专属密码（不是账号的登录密码），替换为你的应用专属密码
# 申请链接：https://account.apple.com/account/manage
APP_SPECIFIC_PASSWORD="wet-erwc-ssdf-hqaf"

KEYCHAIN_PROFILE="my_notary_credentials"            # 钥匙串配置文件名称

# 签名PKG文件
echo "正在签名PKG文件..."
productsign --sign "$CERT_NAME" "$PKG_PATH" "$SIGNED_PKG_PATH"
if [ $? -ne 0 ]; then
    echo "签名PKG文件失败"
    exit 1
fi
echo "PKG文件签名成功"
  
# 验证签名
echo "正在验证PKG文件签名..."
pkgutil --check-signature "$SIGNED_PKG_PATH"
if [ $? -ne 0 ]; then
    echo "验证PKG文件签名失败"
    exit 1
fi
echo "PKG文件签名验证成功"


# ==== Xcode 16 ===
# 存储公证凭证到钥匙串
echo "正在存储公证凭证..."
xcrun notarytool store-credentials "$KEYCHAIN_PROFILE" \
    --apple-id "$APPLE_ID" \
    --team-id "$TEAM_ID" \
    --password "$APP_SPECIFIC_PASSWORD"
if [ $? -ne 0 ]; then
    echo "存储凭证失败！"
    exit 1
fi

# 上传PKG文件进行公证并获取RequestUUID
echo "正在上传PKG文件进行公证, 请稍等..."
OUTPUT=$(xcrun notarytool submit "$SIGNED_PKG_PATH" \
    --keychain-profile "$KEYCHAIN_PROFILE" \
    --wait 2>&1)
    
echo "上传输出信息:"
echo "$OUTPUT"
    
# 检查是否成功获取到RequestUUID
REQUEST_UUID=$(echo "$OUTPUT" | awk -F': ' '/id: / {print $2; exit}')
if [ -z "$REQUEST_UUID" ]; then
    echo "上传PKG文件进行公证失败，未获取到RequestUUID"
    echo "错误信息: $OUTPUT"
    exit 1
fi
echo "PKG文件已上传进行公证，RequestUUID: $REQUEST_UUID"
  
# 查询公证进度
echo "正在等待公证完成..."
WAIT_TIME=0
INTERVAL=30
MAX_WAIT_TIME=600 # 10分钟=600秒
while [ $WAIT_TIME -lt $MAX_WAIT_TIME ]; do
    xcrun notarytool info "$REQUEST_UUID" --keychain-profile "$KEYCHAIN_PROFILE" > ./notary_info.log
    STATUS=$(grep -i "status:" ./notary_info.log | awk -F': ' '{print $2}')
    
    if [ "$STATUS" == "Accepted" ]; then
        echo "公证完成！"
        break
    elif [ "$STATUS" == "Success" ]; then
        echo "公证成功！"
        break
    elif [ "$STATUS" == "Invalid" ]; then
        echo "公证失败，状态为无效！详情请查看日志文件！"
        xcrun notarytool log "$REQUEST_UUID" --keychain-profile "$KEYCHAIN_PROFILE" >> ./notary_info.log
        exit 1
    else
        echo "公证进行中($WAIT_TIME)..."
        echo "等待$INTERVAL 秒后再次检查..."
        sleep $INTERVAL
        WAIT_TIME=$((WAIT_TIME + INTERVAL))
    fi
    
    if [ $WAIT_TIME -ge $MAX_WAIT_TIME ]; then
    echo "公证超时！"
    exit 1
    fi
done
  

  
# 盖章
echo "正在对签名的安装包进行盖章..."
xcrun stapler staple "$SIGNED_PKG_PATH"
if [ $? -ne 0 ]; then
    echo "盖章失败！"
else
    echo "盖章成功！"
    exit 1
fi
  
# 验证
echo "正在验证已经盖章的签名的安装包..."
xcrun stapler staple -v "$SIGNED_PKG_PATH"
if [ $? -ne 0 ]; then
    echo "验证失败！"
    exit 1
else
    echo "盖章和验证成功！"
fi
  
  
echo "PKG文件签名和公证流程全部完成"
echo "所有脚本执行成功！"

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

#!/bin/bash

# 证书名称，使用"security find-identity -v"命令查找并替换

CERT_NAME="Developer ID Installer: Your Company Co., Ltd. (4H8C8HR626)"

# 开发者团队ID

# 从CERT_NAME中提取TEAM_ID

# 假设TEAM_ID总是位于最后一对括号内

# TEAM_ID="4H8C8HR626"

TEAM_ID=$(echo "$CERT_NAME" | awk -F'[()]' '{print $2}')

# 原始PKG文件路径，替换为你的PKG文件路径

PKG_PATH="Install App.pkg"

# 签名后的PKG文件路径，替换为你想要保存的签名PKG文件路径

SIGNED_PKG_PATH="../Install App.pkg"

# 苹果开发者账号

APPLE_ID="apple@163.com"

# 应用专属密码（不是账号的登录密码），替换为你的应用专属密码

# 申请链接：https://account.apple.com/account/manage

APP_SPECIFIC_PASSWORD="wet-erwc-ssdf-hqaf"

KEYCHAIN_PROFILE="my_notary_credentials" # 钥匙串配置文件名称

# 签名PKG文件

echo "正在签名PKG文件..."

productsign --sign "$CERT_NAME" "$PKG_PATH" "$SIGNED_PKG_PATH"

if [ $? -ne 0 ]; then

echo "签名PKG文件失败"

exit 1

echo "PKG文件签名成功"

# 验证签名

echo "正在验证PKG文件签名..."

pkgutil --check-signature "$SIGNED_PKG_PATH"

if [ $? -ne 0 ]; then

echo "验证PKG文件签名失败"

exit 1

echo "PKG文件签名验证成功"

# ==== Xcode 16 ===

# 存储公证凭证到钥匙串

echo "正在存储公证凭证..."

xcrun notarytool store-credentials "$KEYCHAIN_PROFILE" \

--apple-id "$APPLE_ID" \

--team-id "$TEAM_ID" \

--password "$APP_SPECIFIC_PASSWORD"

if [ $? -ne 0 ]; then

echo "存储凭证失败！"

exit 1

# 上传PKG文件进行公证并获取RequestUUID

echo "正在上传PKG文件进行公证, 请稍等..."

OUTPUT=$(xcrun notarytool submit "$SIGNED_PKG_PATH" \

--keychain-profile "$KEYCHAIN_PROFILE" \

--wait 2>&1)

echo "上传输出信息:"

echo "$OUTPUT"

# 检查是否成功获取到RequestUUID

REQUEST_UUID=$(echo "$OUTPUT" | awk -F': ' '/id: / {print $2; exit}')

if [ -z "$REQUEST_UUID" ]; then

echo "上传PKG文件进行公证失败，未获取到RequestUUID"

echo "错误信息: $OUTPUT"

exit 1

echo "PKG文件已上传进行公证，RequestUUID: $REQUEST_UUID"

# 查询公证进度

echo "正在等待公证完成..."

WAIT_TIME=0

INTERVAL=30

MAX_WAIT_TIME=600 # 10分钟=600秒

while [ $WAIT_TIME -lt $MAX_WAIT_TIME ]; do

xcrun notarytool info "$REQUEST_UUID" --keychain-profile "$KEYCHAIN_PROFILE" > ./notary_info.log

STATUS=$(grep -i "status:" ./notary_info.log | awk -F': ' '{print $2}')

if [ "$STATUS" == "Accepted" ]; then

echo "公证完成！"

break

elif [ "$STATUS" == "Success" ]; then

echo "公证成功！"

break

elif [ "$STATUS" == "Invalid" ]; then

echo "公证失败，状态为无效！详情请查看日志文件！"

xcrun notarytool log "$REQUEST_UUID" --keychain-profile "$KEYCHAIN_PROFILE" >> ./notary_info.log

exit 1

else

echo "公证进行中($WAIT_TIME)..."

echo "等待$INTERVAL 秒后再次检查..."

sleep $INTERVAL

WAIT_TIME=$((WAIT_TIME + INTERVAL))

if [ $WAIT_TIME -ge $MAX_WAIT_TIME ]; then

echo "公证超时！"

exit 1

done

# 盖章

echo "正在对签名的安装包进行盖章..."

xcrun stapler staple "$SIGNED_PKG_PATH"

if [ $? -ne 0 ]; then

echo "盖章失败！"

else

echo "盖章成功！"

exit 1

# 验证

echo "正在验证已经盖章的签名的安装包..."

xcrun stapler staple -v "$SIGNED_PKG_PATH"

if [ $? -ne 0 ]; then

echo "验证失败！"

exit 1

else

echo "盖章和验证成功！"

echo "PKG文件签名和公证流程全部完成"

echo "所有脚本执行成功！"

请注意，这些步骤假设你已经具备了必要的 Apple Developer 账户、证书和配置文件，并且你的 macOS 系统已经安装了 Xcode 和 Xcode Command Line Tools。如果你遇到任何问题，请检查你的证书、配置文件和路径是否正确，以及你是否拥有执行这些命令的适当权限。

$ cd build

$ chmod +x productsign.sh

$ chmod +x productsign-online-notarytool.sh

$ ./productsign.sh  #或者仅签名

$ ./productsign-online-notarytool.sh # 或者签名加公正[用于需要自动更新]

$ cd build

$ chmod +x productsign.sh

$ chmod +x productsign-online-notarytool.sh

$ ./productsign.sh #或者仅签名

$ ./productsign-online-notarytool.sh # 或者签名加公正[用于需要自动更新]

参考:

https://taoofcoding.tech/blogs/2022-11-13/use-notarytool-to-notary-macos-app
https://blog.csdn.net/Crystal_Mr_Rose/article/details/136351429
macOS 工具 - 查看PKG文件内容, App下载安装 SuspiciousPackage官方下载地址（免费）： http://www.mothersruin.com/software/SuspiciousPackage/get.html
Mac OS平台下应用程序PKG安装包制作工具Packages, App下载安装Packages官方下载地址（免费）： http://s.sudre.free.fr/Software/Packages/resources.html

参考链接

DMAR: ERROR: DMA PTE for vPFN 0xf1f7f already set (to f1f7f003 not 17039b003)

前置条件

HP ProLiant MicroServer Gen8
Intel® Xeon® E3-1265L V2 × 8
Ubuntu 24.04.4 LTS / Linux Kernel 6.8.0-40-generic

问题详情

系统稳定性差，长时间运行之后出现不稳定现象，尤其是远程桌面 RDP，经常出现无法连接的情况。内存 CPU占用都不高，但是系统反应感觉非常卡顿。

执行 sudo dmesg 函数之后，可以观察到如下报错信息：

[   97.194200] DMAR: ERROR: DMA PTE for vPFN 0xf1f7f already set (to f1f7f003 not 17039b003)
[   97.194215] ------------[ cut here ]------------
[   97.194217] WARNING: CPU: 6 PID: 3630 at drivers/iommu/intel/iommu.c:2210 __domain_mapping+0x2c5/0x320
[   97.194222] Modules linked in: snd_seq_dummy snd_hrtimer snd_seq_midi snd_seq_midi_event snd_rawmidi snd_seq snd_seq_device snd_timer snd soundcore qrtr overlay zram binfmt_misc nls_iso8859_1 ipmi_ssif intel_rapl_msr intel_rapl_common x86_pkg_temp_thermal intel_powerclamp coretemp kvm_intel kvm irqbypass crct10dif_pclmul polyval_clmulni polyval_generic ghash_clmulni_intel gpio_ich sha256_ssse3 sha1_ssse3 aesni_intel input_leds crypto_simd joydev cryptd rapl intel_cstate acpi_power_meter serio_raw mgag200 lpc_ich hpilo acpi_ipmi ipmi_si ipmi_devintf i2c_algo_bit ipmi_msghandler ie31200_edac mac_hid sch_fq_codel msr parport_pc ppdev lp parport efi_pstore nfnetlink dmi_sysfs ip_tables x_tables autofs4 btrfs blake2b_generic raid10 raid456 async_raid6_recov async_memcpy async_pq async_xor async_tx xor raid6_pq libcrc32c raid0 hid_generic usbhid hid raid1 crc32_pclmul psmouse tg3 xhci_pci xhci_pci_renesas pata_acpi uas usb_storage
[   97.194309] CPU: 6 PID: 3630 Comm: upowerd Tainted: G        W I        6.8.0-40-generic #40-Ubuntu
[   97.194313] Hardware name: HP ProLiant MicroServer Gen8, BIOS J06 04/04/2019
[   97.194315] RIP: 0010:__domain_mapping+0x2c5/0x320
[   97.194319] Code: b0 48 c7 c7 c0 ec cd 95 e8 58 5c 64 ff 8b 05 26 cb bb 01 4c 8b 4d b0 41 bb 00 00 00 00 85 c0 74 09 83 e8 01 89 05 0f cb bb 01 <0f> 0b e9 f9 fe ff ff 41 80 e5 7f e9 da fe ff ff ba 01 00 00 00 e9
[   97.194322] RSP: 0018:ffffa0d18b1b6dc0 EFLAGS: 00010046
[   97.194325] RAX: 0000000000000000 RBX: ffff9498c473ebf8 RCX: 0000000000000000
[   97.194328] RDX: 0000000000000000 RSI: 0000000000000000 RDI: 0000000000000000
[   97.194330] RBP: ffffa0d18b1b6e20 R08: 0000000000000000 R09: ffff9498c473ebf8
[   97.194332] R10: 0000000000000000 R11: 0000000000000000 R12: 0000000000000001
[   97.194334] R13: 000000017039b003 R14: ffff9498c1949100 R15: 0000000000000001
[   97.194336] FS:  0000000000000000(0000) GS:ffff949bb9d00000(0000) knlGS:0000000000000000
[   97.194339] CS:  0010 DS: 0000 ES: 0000 CR0: 0000000080050033
[   97.194342] CR2: 000077c061890008 CR3: 000000016333e006 CR4: 00000000001706f0
[   97.194344] Call Trace:
[   97.194346]  <TASK>
[   97.194348]  ? show_regs+0x6d/0x80
[   97.194351]  ? __warn+0x89/0x160
[   97.194356]  ? __domain_mapping+0x2c5/0x320
[   97.194360]  ? report_bug+0x17e/0x1b0
[   97.194364]  ? handle_bug+0x51/0xa0
[   97.194368]  ? exc_invalid_op+0x18/0x80
[   97.194372]  ? asm_exc_invalid_op+0x1b/0x20
[   97.194378]  ? __domain_mapping+0x2c5/0x320
[   97.194383]  intel_iommu_map_pages+0xe1/0x140
[   97.194388]  __iommu_map+0x121/0x280
[   97.194392]  iommu_map_sg+0xbf/0x1f0
[   97.194397]  iommu_dma_map_sg+0x463/0x4f0
[   97.194403]  ? __pfx_ata_scsi_rw_xlat+0x10/0x10
[   97.194408]  __dma_map_sg_attrs+0x35/0xd0
[   97.194411]  dma_map_sg_attrs+0xe/0x30
[   97.194415]  ata_qc_issue+0xfc/0x2d0
[   97.194419]  ? __pfx_ata_scsi_rw_xlat+0x10/0x10
[   97.194423]  ? __pfx_ata_scsi_rw_xlat+0x10/0x10
[   97.194427]  __ata_scsi_queuecmd+0xf2/0x3a0
[   97.194430]  ata_scsi_queuecmd+0x44/0x80
[   97.194434]  scsi_dispatch_cmd+0x91/0x240
[   97.194437]  scsi_queue_rq+0x2c4/0x670
[   97.194441]  blk_mq_dispatch_rq_list+0x137/0x520
[   97.194445]  ? sbitmap_get+0x73/0x180
[   97.194451]  __blk_mq_do_dispatch_sched+0xbb/0x300
[   97.194455]  ? finish_task_switch.isra.0+0x93/0x300
[   97.194460]  __blk_mq_sched_dispatch_requests+0x151/0x190
[   97.194464]  blk_mq_sched_dispatch_requests+0x2c/0x70
[   97.194467]  blk_mq_run_hw_queue+0x1bf/0x210
[   97.194472]  blk_mq_get_tag+0x1ef/0x2f0
[   97.194476]  ? __pfx_autoremove_wake_function+0x10/0x10
[   97.194481]  __blk_mq_alloc_requests+0xd6/0x290
[   97.194485]  blk_mq_submit_bio+0x190/0x6b0
[   97.194489]  __submit_bio+0xb3/0x1c0
[   97.194492]  submit_bio_noacct_nocheck+0x13c/0x1f0
[   97.194495]  submit_bio_noacct+0x162/0x5b0
[   97.194499]  submit_bio+0xb2/0x110
[   97.194502]  ext4_mpage_readpages+0x37e/0xaa0
[   97.194505]  ? __mod_memcg_lruvec_state+0xd6/0x1a0
[   97.194512]  ext4_readahead+0x3f/0x50
[   97.194516]  read_pages+0x95/0x290
[   97.194522]  page_cache_ra_unbounded+0x167/0x1c0
[   97.194528]  page_cache_ra_order+0x2a9/0x350
[   97.194531]  ? xas_load+0xf/0x60
[   97.194535]  ondemand_readahead+0x21c/0x4d0
[   97.194539]  page_cache_sync_ra+0x8a/0xa0
[   97.194541]  filemap_get_pages+0x109/0x3b0
[   97.194547]  filemap_read+0xf7/0x470
[   97.194551]  ? __ext4_ext_check+0x1ff/0x500
[   97.194558]  generic_file_read_iter+0xbb/0x110
[   97.194562]  ext4_file_read_iter+0x63/0x210
[   97.194566]  vfs_read+0x258/0x390
[   97.194570]  ksys_read+0x73/0x100
[   97.194574]  __x64_sys_read+0x19/0x30
[   97.194577]  x64_sys_call+0x1ada/0x25c0
[   97.194580]  do_syscall_64+0x7f/0x180
[   97.194583]  ? terminate_walk+0xf0/0x100
[   97.194587]  ? path_openat+0x140/0x2d0
[   97.194591]  ? do_filp_open+0xaf/0x170
[   97.194598]  ? putname+0x5b/0x80
[   97.194602]  ? do_sys_openat2+0x9f/0xe0
[   97.194607]  ? __x64_sys_openat+0x55/0xa0
[   97.194610]  ? syscall_exit_to_user_mode+0x89/0x260
[   97.194615]  ? do_syscall_64+0x8c/0x180
[   97.194619]  ? handle_pte_fault+0x114/0x1d0
[   97.194623]  ? __handle_mm_fault+0x653/0x790
[   97.194627]  ? __count_memcg_events+0x6b/0x120
[   97.194631]  ? count_memcg_events.constprop.0+0x2a/0x50
[   97.194635]  ? restore_fpregs_from_fpstate+0x47/0xf0
[   97.194640]  ? switch_fpu_return+0x55/0xf0
[   97.194645]  ? irqentry_exit_to_user_mode+0x7e/0x260
[   97.194649]  ? irqentry_exit+0x43/0x50
[   97.194653]  ? exc_page_fault+0x94/0x1b0
[   97.194657]  entry_SYSCALL_64_after_hwframe+0x78/0x80
[   97.194661] RIP: 0033:0x7e2a20834be8
[   97.194671] Code: 48 3d 00 f0 ff ff 77 0a c3 66 0f 1f 84 00 00 00 00 00 f7 d8 89 05 c8 36 01 00 48 c7 c0 ff ff ff ff c3 f3 0f 1e fa 31 c0 0f 05 <48> 3d 00 f0 ff ff 77 08 c3 0f 1f 80 00 00 00 00 f7 d8 89 05 a0 36
[   97.194674] RSP: 002b:00007fff7a1c5b28 EFLAGS: 00000246 ORIG_RAX: 0000000000000000
[   97.194678] RAX: ffffffffffffffda RBX: 00007e2a2044b530 RCX: 00007e2a20834be8
[   97.194680] RDX: 0000000000000340 RSI: 00007fff7a1c5bf8 RDI: 0000000000000003
[   97.194682] RBP: 00007fff7a1c5b70 R08: 00007fff7a1c5bd7 R09: 0000000000000000
[   97.194685] R10: 0000000000000000 R11: 0000000000000246 R12: 0000000000000003
[   97.194687] R13: 00007fff7a1c5bf8 R14: 0000000000000340 R15: 00007fff7a1c5bf0
[   97.194692]  </TASK>
[   97.194693] ---[ end trace 0000000000000000 ]---

100

101

102

103

[ 97.194200] DMAR: ERROR: DMA PTE for vPFN 0xf1f7f already set (to f1f7f003 not 17039b003)

[ 97.194215] ------------[ cut here ]------------

[ 97.194217] WARNING: CPU: 6 PID: 3630 at drivers/iommu/intel/iommu.c:2210 __domain_mapping+0x2c5/0x320

[ 97.194222] Modules linked in: snd_seq_dummy snd_hrtimer snd_seq_midi snd_seq_midi_event snd_rawmidi snd_seq snd_seq_device snd_timer snd soundcore qrtr overlay zram binfmt_misc nls_iso8859_1 ipmi_ssif intel_rapl_msr intel_rapl_common x86_pkg_temp_thermal intel_powerclamp coretemp kvm_intel kvm irqbypass crct10dif_pclmul polyval_clmulni polyval_generic ghash_clmulni_intel gpio_ich sha256_ssse3 sha1_ssse3 aesni_intel input_leds crypto_simd joydev cryptd rapl intel_cstate acpi_power_meter serio_raw mgag200 lpc_ich hpilo acpi_ipmi ipmi_si ipmi_devintf i2c_algo_bit ipmi_msghandler ie31200_edac mac_hid sch_fq_codel msr parport_pc ppdev lp parport efi_pstore nfnetlink dmi_sysfs ip_tables x_tables autofs4 btrfs blake2b_generic raid10 raid456 async_raid6_recov async_memcpy async_pq async_xor async_tx xor raid6_pq libcrc32c raid0 hid_generic usbhid hid raid1 crc32_pclmul psmouse tg3 xhci_pci xhci_pci_renesas pata_acpi uas usb_storage

[ 97.194309] CPU: 6 PID: 3630 Comm: upowerd Tainted: G W I 6.8.0-40-generic #40-Ubuntu

[ 97.194313] Hardware name: HP ProLiant MicroServer Gen8, BIOS J06 04/04/2019

[ 97.194315] RIP: 0010:__domain_mapping+0x2c5/0x320

[ 97.194319] Code: b0 48 c7 c7 c0 ec cd 95 e8 58 5c 64 ff 8b 05 26 cb bb 01 4c 8b 4d b0 41 bb 00 00 00 00 85 c0 74 09 83 e8 01 89 05 0f cb bb 01 <0f> 0b e9 f9 fe ff ff 41 80 e5 7f e9 da fe ff ff ba 01 00 00 00 e9

[ 97.194322] RSP: 0018:ffffa0d18b1b6dc0 EFLAGS: 00010046

[ 97.194325] RAX: 0000000000000000 RBX: ffff9498c473ebf8 RCX: 0000000000000000

[ 97.194328] RDX: 0000000000000000 RSI: 0000000000000000 RDI: 0000000000000000

[ 97.194330] RBP: ffffa0d18b1b6e20 R08: 0000000000000000 R09: ffff9498c473ebf8

[ 97.194332] R10: 0000000000000000 R11: 0000000000000000 R12: 0000000000000001

[ 97.194334] R13: 000000017039b003 R14: ffff9498c1949100 R15: 0000000000000001

[ 97.194336] FS: 0000000000000000(0000) GS:ffff949bb9d00000(0000) knlGS:0000000000000000

[ 97.194339] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033

[ 97.194342] CR2: 000077c061890008 CR3: 000000016333e006 CR4: 00000000001706f0

[ 97.194344] Call Trace:

[ 97.194346] <TASK>

[ 97.194348] ? show_regs+0x6d/0x80

[ 97.194351] ? __warn+0x89/0x160

[ 97.194356] ? __domain_mapping+0x2c5/0x320

[ 97.194360] ? report_bug+0x17e/0x1b0

[ 97.194364] ? handle_bug+0x51/0xa0

[ 97.194368] ? exc_invalid_op+0x18/0x80

[ 97.194372] ? asm_exc_invalid_op+0x1b/0x20

[ 97.194378] ? __domain_mapping+0x2c5/0x320

[ 97.194383] intel_iommu_map_pages+0xe1/0x140

[ 97.194388] __iommu_map+0x121/0x280

[ 97.194392] iommu_map_sg+0xbf/0x1f0

[ 97.194397] iommu_dma_map_sg+0x463/0x4f0

[ 97.194403] ? __pfx_ata_scsi_rw_xlat+0x10/0x10

[ 97.194408] __dma_map_sg_attrs+0x35/0xd0

[ 97.194411] dma_map_sg_attrs+0xe/0x30

[ 97.194415] ata_qc_issue+0xfc/0x2d0

[ 97.194419] ? __pfx_ata_scsi_rw_xlat+0x10/0x10

[ 97.194423] ? __pfx_ata_scsi_rw_xlat+0x10/0x10

[ 97.194427] __ata_scsi_queuecmd+0xf2/0x3a0

[ 97.194430] ata_scsi_queuecmd+0x44/0x80

[ 97.194434] scsi_dispatch_cmd+0x91/0x240

[ 97.194437] scsi_queue_rq+0x2c4/0x670

[ 97.194441] blk_mq_dispatch_rq_list+0x137/0x520

[ 97.194445] ? sbitmap_get+0x73/0x180

[ 97.194451] __blk_mq_do_dispatch_sched+0xbb/0x300

[ 97.194455] ? finish_task_switch.isra.0+0x93/0x300

[ 97.194460] __blk_mq_sched_dispatch_requests+0x151/0x190

[ 97.194464] blk_mq_sched_dispatch_requests+0x2c/0x70

[ 97.194467] blk_mq_run_hw_queue+0x1bf/0x210

[ 97.194472] blk_mq_get_tag+0x1ef/0x2f0

[ 97.194476] ? __pfx_autoremove_wake_function+0x10/0x10

[ 97.194481] __blk_mq_alloc_requests+0xd6/0x290

[ 97.194485] blk_mq_submit_bio+0x190/0x6b0

[ 97.194489] __submit_bio+0xb3/0x1c0

[ 97.194492] submit_bio_noacct_nocheck+0x13c/0x1f0

[ 97.194495] submit_bio_noacct+0x162/0x5b0

[ 97.194499] submit_bio+0xb2/0x110

[ 97.194502] ext4_mpage_readpages+0x37e/0xaa0

[ 97.194505] ? __mod_memcg_lruvec_state+0xd6/0x1a0

[ 97.194512] ext4_readahead+0x3f/0x50

[ 97.194516] read_pages+0x95/0x290

[ 97.194522] page_cache_ra_unbounded+0x167/0x1c0

[ 97.194528] page_cache_ra_order+0x2a9/0x350

[ 97.194531] ? xas_load+0xf/0x60

[ 97.194535] ondemand_readahead+0x21c/0x4d0

[ 97.194539] page_cache_sync_ra+0x8a/0xa0

[ 97.194541] filemap_get_pages+0x109/0x3b0

[ 97.194547] filemap_read+0xf7/0x470

[ 97.194551] ? __ext4_ext_check+0x1ff/0x500

[ 97.194558] generic_file_read_iter+0xbb/0x110

[ 97.194562] ext4_file_read_iter+0x63/0x210

[ 97.194566] vfs_read+0x258/0x390

[ 97.194570] ksys_read+0x73/0x100

[ 97.194574] __x64_sys_read+0x19/0x30

[ 97.194577] x64_sys_call+0x1ada/0x25c0

[ 97.194580] do_syscall_64+0x7f/0x180

[ 97.194583] ? terminate_walk+0xf0/0x100

[ 97.194587] ? path_openat+0x140/0x2d0

[ 97.194591] ? do_filp_open+0xaf/0x170

[ 97.194598] ? putname+0x5b/0x80

[ 97.194602] ? do_sys_openat2+0x9f/0xe0

[ 97.194607] ? __x64_sys_openat+0x55/0xa0

[ 97.194610] ? syscall_exit_to_user_mode+0x89/0x260

[ 97.194615] ? do_syscall_64+0x8c/0x180

[ 97.194619] ? handle_pte_fault+0x114/0x1d0

[ 97.194623] ? __handle_mm_fault+0x653/0x790

[ 97.194627] ? __count_memcg_events+0x6b/0x120

[ 97.194631] ? count_memcg_events.constprop.0+0x2a/0x50

[ 97.194635] ? restore_fpregs_from_fpstate+0x47/0xf0

[ 97.194640] ? switch_fpu_return+0x55/0xf0

[ 97.194645] ? irqentry_exit_to_user_mode+0x7e/0x260

[ 97.194649] ? irqentry_exit+0x43/0x50

[ 97.194653] ? exc_page_fault+0x94/0x1b0

[ 97.194657] entry_SYSCALL_64_after_hwframe+0x78/0x80

[ 97.194661] RIP: 0033:0x7e2a20834be8

[ 97.194671] Code: 48 3d 00 f0 ff ff 77 0a c3 66 0f 1f 84 00 00 00 00 00 f7 d8 89 05 c8 36 01 00 48 c7 c0 ff ff ff ff c3 f3 0f 1e fa 31 c0 0f 05 <48> 3d 00 f0 ff ff 77 08 c3 0f 1f 80 00 00 00 00 f7 d8 89 05 a0 36

[ 97.194674] RSP: 002b:00007fff7a1c5b28 EFLAGS: 00000246 ORIG_RAX: 0000000000000000

[ 97.194678] RAX: ffffffffffffffda RBX: 00007e2a2044b530 RCX: 00007e2a20834be8

[ 97.194680] RDX: 0000000000000340 RSI: 00007fff7a1c5bf8 RDI: 0000000000000003

[ 97.194682] RBP: 00007fff7a1c5b70 R08: 00007fff7a1c5bd7 R09: 0000000000000000

[ 97.194685] R10: 0000000000000000 R11: 0000000000000246 R12: 0000000000000003

[ 97.194687] R13: 00007fff7a1c5bf8 R14: 0000000000000340 R15: 00007fff7a1c5bf0

[ 97.194692] </TASK>

[ 97.194693] ---[ end trace 0000000000000000 ]---

问题原因

Linux 内核的 intel_iommu 与 HP ProLiant MicroServer Gen8 的 BIOS 冲突导致的。

解决方案

修改引导的内核参数：

$ sudo vim /etc/default/grub

1	$ sudo vim /etc/default/grub

修改如下配置：

GRUB_CMDLINE_LINUX_DEFAULT="quiet splash intel_iommu=off"

1	GRUB_CMDLINE_LINUX_DEFAULT="quiet splash intel_iommu=off"

配置修改后，使用如下命令生效内核配置：

$ sudo update-grub

1	$ sudo update-grub

重启系统

$ sudo reboot

1	$ sudo reboot

参考链接

Dart AOT 二进制文件的完整性检查：运行时的签名验证与篡改检测

讲座主题：Dart AOT 二进制文件的完整性检查：运行时的签名验证与篡改检测

尊敬的各位开发者，安全专家，大家好。

今天，我们将深入探讨一个在现代软件开发中日益关键且复杂的话题：如何确保 Dart AOT (Ahead-Of-Time) 编译生成的原生二进制文件在运行时未被篡改，以及如何通过数字签名进行有效验证。随着 Dart 在桌面、移动和嵌入式设备领域的普及，其 AOT 编译能力使其能够生成高性能的原生代码。然而，原生代码的便利性也带来了新的安全挑战——这些二进制文件更容易成为攻击者篡改的目标，无论是为了注入恶意代码、绕过授权机制，还是窃取知识产权。

作为一名编程专家，我的目标是为大家提供一个全面、深入且实用的视角，来理解、设计并实现一套针对 Dart AOT 二进制文件的运行时完整性检查机制。我们将从密码学基础出发，逐步构建一套可行的签名与验证架构，并探讨其中的技术细节、挑战与权衡。

第一部分：理解 Dart AOT 与运行时安全威胁

1.1 Dart AOT 二进制文件的特性与安全模型

Dart AOT 编译将 Dart 源代码直接转换为机器码，生成独立的可执行文件（例如在 Linux 上是 ELF 文件，Windows 上是 PE 文件，macOS 上是 Mach-O 文件）。这与传统的解释型语言或即时编译 (JIT) 语言（如 Java 的 JVM 或 Python 解释器）有显著不同。AOT 编译的优势在于启动速度快、运行性能高、内存占用低，且不依赖运行时环境（如 JVM 或 Node.js）。

然而，这种原生特性也意味着：

暴露的机器码： 应用程序的逻辑直接以机器码形式存在，更容易被逆向工程工具（如 IDA Pro, Ghidra）分析。
直接的内存访问： 运行时，操作系统直接加载这些机器码到内存中执行。
篡改的风险： 攻击者可以修改磁盘上的二进制文件，或者在程序加载到内存后，利用调试器或内存注入技术修改其运行时行为。

1.2 运行时完整性检查的必要性

为何需要对 Dart AOT 二进制文件进行运行时完整性检查？主要出于以下几个考虑：

防止恶意注入： 攻击者可能在您的应用程序中植入恶意代码，例如键盘记录器、数据窃取模块或后门，而用户浑然不觉。
保护知识产权： 篡改者可能修改程序的授权逻辑、核心算法或数据处理流程，以绕过许可限制，或窃取商业秘密。
维护系统稳定性与可靠性： 被篡改的程序可能导致系统崩溃、数据损坏，甚至引发更严重的安全漏洞。
合规性要求： 在某些行业（如金融、医疗），软件的完整性是严格的合规性要求。
信任链： 用户需要信任他们运行的软件是来自可信源，并且未被第三方修改。

1.3 核心概念：哈希与数字签名

在深入实现之前，我们必须理解两个基石级的密码学概念：加密哈希函数和数字签名。

加密哈希函数 (Cryptographic Hash Function)：
- 将任意长度的输入（如一个文件、一段文本）转换为固定长度的输出，这个输出被称为哈希值、摘要或指纹。
- 具有以下关键特性：
  - 确定性： 相同输入总是产生相同输出。
  - 雪崩效应： 输入中微小的改动都会导致输出哈希值发生巨大变化。
  - 不可逆性： 无法从哈希值逆向推导出原始输入。
  - 抗碰撞性： 极难找到两个不同的输入产生相同的哈希值（强抗碰撞性）。
- 常用的哈希算法有 SHA-256、SHA-3 等。在完整性检查中，哈希值是文件的“数字指纹”。
数字签名 (Digital Signature)：
- 结合了公钥密码学和哈希函数，用于验证数据的来源和完整性。
- 签名过程：
  1. 发送方（签名者）使用加密哈希函数计算原始数据的哈希值。
  2. 发送方使用其私钥对这个哈希值进行加密（签名）。
  3. 将原始数据、签名和发送方的公钥一起发送。
- 验证过程：
  1. 接收方使用相同的哈希函数计算接收到的原始数据的哈希值。
  2. 接收方使用发送方的公钥解密（验证）接收到的签名，得到一个哈希值。
  3. 比较这两个哈希值。如果它们一致，则说明数据在传输过程中未被篡改，并且确实是由持有对应私钥的发送方签名的。
- 常用的数字签名算法有 RSA、ECDSA 等。

通过数字签名，我们可以确保二进制文件不仅没有被意外损坏（哈希值匹配），而且确实是由我们（作为开发者）签发和认可的（签名验证通过）。

第二部分：构建信任的基石——密码学原理与 Dart 实现

在 Dart 中进行密码学操作，我们通常会借助社区提供的强大库。package:crypto 提供了哈希函数，而 package:pointycastle 或 package:cryptography 则提供了更全面的密码学原语，包括公钥加密和数字签名。

2.1 Dart 中的哈希计算

首先，我们来看如何在 Dart 中计算一个文件的 SHA-256 哈希值。

pubspec.yaml

dependencies:
  crypto: ^3.0.3 # 用于哈希计算

1 2	dependencies: crypto: ^3.0.3 # 用于哈希计算

lib/integrity_checker.dart

import 'dart:io';
import 'dart:convert';
import 'package:crypto/crypto.dart';

/// 负责计算文件哈希值的工具类。
class HashCalculator {
  /// 计算指定文件的 SHA-256 哈希值。
  ///
  /// [filePath]：要计算哈希值的文件路径。
  /// 返回：文件的十六进制 SHA-256 哈希值字符串。
  /// 抛出：[FileSystemException] 如果文件不存在或无法读取。
  static Future<String> calculateFileSha256(String filePath) async {
    final file = File(filePath);
    if (!await file.exists()) {
      throw FileSystemException('File not found', filePath);
    }

    try {
      final input = file.openRead();
      final digest = await sha256.bind(input).first;
      return digest.toString();
    } catch (e) {
      throw FileSystemException('Failed to read file or calculate hash', filePath, e.toString());
    }
  }

  /// 计算指定字节数组的 SHA-256 哈希值。
  ///
  /// [bytes]：要计算哈希值的字节数组。
  /// 返回：字节数组的十六进制 SHA-256 哈希值字符串。
  static String calculateBytesSha256(List<int> bytes) {
    final digest = sha256.convert(bytes);
    return digest.toString();
  }
}

// 示例用法
void main() async {
  // 创建一个临时文件用于测试
  final testFile = File('test_integrity_file.txt');
  await testFile.writeAsString('Hello, Dart AOT integrity check!');

  try {
    final hash = await HashCalculator.calculateFileSha256(testFile.path);
    print('文件 "${testFile.path}" 的 SHA-256 哈希值是: $hash');

    final bytesHash = HashCalculator.calculateBytesSha256(utf8.encode('Hello, Dart AOT integrity check!'));
    print('字节数组 "Hello, Dart AOT integrity check!" 的 SHA-256 哈希值是: $bytesHash');

    // 尝试修改文件，查看哈希值变化
    await testFile.writeAsString('Hello, Dart AOT integrity check! Tampered!');
    final tamperedHash = await HashCalculator.calculateFileSha256(testFile.path);
    print('篡改后文件 "${testFile.path}" 的 SHA-256 哈希值是: $tamperedHash');

    if (hash != tamperedHash) {
      print('哈希值已改变，文件可能已被篡改。');
    }

  } catch (e) {
    print('发生错误: $e');
  } finally {
    await testFile.delete(); // 清理临时文件
  }
}

import 'dart:io';

import 'dart:convert';

import 'package:crypto/crypto.dart';

/// 负责计算文件哈希值的工具类。

class HashCalculator {

/// 计算指定文件的 SHA-256 哈希值。

///

/// [filePath]：要计算哈希值的文件路径。

/// 返回：文件的十六进制 SHA-256 哈希值字符串。

/// 抛出：[FileSystemException] 如果文件不存在或无法读取。

static Future<String> calculateFileSha256(String filePath) async {

final file = File(filePath);

if (!await file.exists()) {

throw FileSystemException('File not found', filePath);

}

try {

final input = file.openRead();

final digest = await sha256.bind(input).first;

return digest.toString();

} catch (e) {

throw FileSystemException('Failed to read file or calculate hash', filePath, e.toString());

}

/// 计算指定字节数组的 SHA-256 哈希值。

///

/// [bytes]：要计算哈希值的字节数组。

/// 返回：字节数组的十六进制 SHA-256 哈希值字符串。

static String calculateBytesSha256(List<int> bytes) {

final digest = sha256.convert(bytes);

return digest.toString();

}

// 示例用法

void main() async {

// 创建一个临时文件用于测试

final testFile = File('test_integrity_file.txt');

await testFile.writeAsString('Hello, Dart AOT integrity check!');

try {

final hash = await HashCalculator.calculateFileSha256(testFile.path);

print('文件 "${testFile.path}" 的 SHA-256 哈希值是: $hash');

final bytesHash = HashCalculator.calculateBytesSha256(utf8.encode('Hello, Dart AOT integrity check!'));

print('字节数组 "Hello, Dart AOT integrity check!" 的 SHA-256 哈希值是: $bytesHash');

// 尝试修改文件，查看哈希值变化

await testFile.writeAsString('Hello, Dart AOT integrity check! Tampered!');

final tamperedHash = await HashCalculator.calculateFileSha256(testFile.path);

print('篡改后文件 "${testFile.path}" 的 SHA-256 哈希值是: $tamperedHash');

if (hash != tamperedHash) {

print('哈希值已改变，文件可能已被篡改。');

}

} catch (e) {

print('发生错误: $e');

} finally {

await testFile.delete(); // 清理临时文件

}

这段代码展示了如何使用 crypto 包计算文件或字节数组的 SHA-256 哈希值。在实际的完整性检查中，我们将用它来计算我们自己 AOT 二进制文件的哈希值。

2.2 Dart 中的数字签名验证 (RSA)

对于数字签名，我们将使用 package:pointycastle，它提供了 RSA、ECDSA 等多种算法的实现。这里我们以 RSA 为例。

pubspec.yaml

dependencies:
  crypto: ^3.0.3
  pointycastle: ^3.7.3 # 用于公钥密码学和数字签名
  asn1lib: ^1.1.0 # 用于解析 PEM 格式的公钥

dependencies:

crypto: ^3.0.3

pointycastle: ^3.7.3 # 用于公钥密码学和数字签名

asn1lib: ^1.1.0 # 用于解析 PEM 格式的公钥

lib/signature_verifier.dart

import 'dart:typed_data';
import 'dart:convert';
import 'package:pointycastle/api.dart';
import 'package:pointycastle/asymmetric/api.dart';
import 'package:pointycastle/asymmetric/rsa.dart';
import 'package:pointycastle/digests/sha256.dart';
import 'package:pointycastle/signers/rsa_signer.dart';
import 'package:asn1lib/asn1lib.dart'; // 用于解析 PEM 公钥

/// 辅助函数：从 PEM 格式字符串加载 RSA 公钥。
/// 这需要解析 PEM 格式，提取 ASN.1 编码的公钥数据。
/// 注意：实际应用中，公钥通常以更简洁的方式嵌入，例如 Base64 编码的模数和指数，
/// 或者直接将 ASN.1 DER 编码的字节嵌入。
RSAPublicKey parseRSAPublicKeyFromPem(String pem) {
  final lines = pem.split('n');
  final base64String = lines
      .where((line) =>
          !line.startsWith('-----BEGIN') && !line.startsWith('-----END'))
      .join('');
  final derBytes = base64.decode(base64String);

  final parser = ASN1Parser(derBytes);
  final topLevel = parser.nextObject() as ASN1Sequence;

  // 根据 RFC 3447 (PKCS#1) 或 X.509 SPKI 结构解析公钥
  // X.509 SPKI 结构通常是 Sequence(Sequence(AlgorithmIdentifier), BitString(RSAPublicKey))
  // RSAPublicKey 是 Sequence(modulus, publicExponent)
  ASN1Sequence publicKeySequence;
  if (topLevel.elements.length == 2 && topLevel.elements[0] is ASN1Sequence && topLevel.elements[1] is ASN1BitString) {
    // X.509 SubjectPublicKeyInfo
    final bitString = topLevel.elements[1] as ASN1BitString;
    final spkiParser = ASN1Parser(bitString.stringValue as Uint8List);
    publicKeySequence = spkiParser.nextObject() as ASN1Sequence;
  } else {
    // PKCS#1 RSAPublicKey
    publicKeySequence = topLevel;
  }

  final modulus = publicKeySequence.elements[0] as ASN1Integer;
  final exponent = publicKeySequence.elements[1] as ASN1Integer;

  return RSAPublicKey(modulus.valueAsBigInt, exponent.valueAsBigInt);
}

/// 负责验证数字签名的工具类。
class SignatureVerifier {
  /// 验证给定数据是否由指定公钥签名。
  ///
  /// [publicKeyPem]：PEM 格式的 RSA 公钥字符串。
  /// [dataHashBytes]：原始数据的 SHA-256 哈希值字节数组。
  /// [signatureBytes]：数字签名字节数组。
  /// 返回：如果签名有效则返回 true，否则返回 false。
  static bool verifySignature(String publicKeyPem, Uint8List dataHashBytes, Uint8List signatureBytes) {
    try {
      final rsaPublicKey = parseRSAPublicKeyFromPem(publicKeyPem);

      final signer = RSASigner(SHA256Digest(), '0609608648016503040201'); // '0609608648016503040201' 是 OID for SHA256withRSA PSS if using PSS
      // 对于 PKCS#1 v1.5 padding，通常不需要指定 OID。
      // 对于 SHA256withRSA，PointyCastle 会根据 Digest 类型自动选择合适的 padding
      // 如果使用 RSASigner(SHA256Digest()) 默认是 PKCS1 v1.5 padding
      // 如果需要 PSS padding，则需要 RSASigner(SHA256Digest(), '0609608648016503040201') 并在初始化参数中指定 PSS
      // 这里我们假设使用 PKCS#1 v1.5 padding，这是最常见的。

      signer.init(false, PublicKeyParameter<RSAPublicKey>(rsaPublicKey)); // false 表示验证模式

      // 验证签名的核心步骤
      final RSASignature rsaSignature = RSASignature(signatureBytes);
      return signer.verifySignature(dataHashBytes, rsaSignature);
    } catch (e) {
      print('签名验证过程中发生错误: $e');
      return false;
    }
  }
}

// 示例用法（需要一个实际的私钥来生成签名）
// 假设你已经通过 openssl 生成了私钥和公钥，并用私钥签名了一个哈希值。
// openssl genrsa -out private_key.pem 2048
// openssl rsa -in private_key.pem -pubout -out public_key.pem
// echo "hello world" | sha256sum | awk '{print $1}' > hash.txt
// openssl dgst -sha256 -sign private_key.pem -out signature.sig hash.txt

void main() async {
  // 替换为你的实际公钥 PEM 字符串
  const String publicKeyPem = '''
-----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAsRk3Q09s+v0M/g0H4n4+
... (你的公钥内容) ...
AQAB
-----END PUBLIC KEY-----
'''; // 这里的公钥是占位符，请替换为实际生成的公钥

  // 假设这是我们应用程序的 SHA-256 哈希值 (32 字节)
  final String appHashHex = 'a8047970d4f6c8273752e22c422849c6762335f6068307c0879e60938ff48a62'; // 示例哈希
  final Uint8List appHashBytes = Uint8List.fromList(List.generate(appHashHex.length ~/ 2, (i) => int.parse(appHashHex.substring(i * 2, i * 2 + 2), radix: 16)));

  // 假设这是通过私钥对 appHashBytes 签名的结果 (通常是 256 字节对于 2048 位 RSA)
  // 这个签名需要通过离线工具生成，并以 Base64 等方式嵌入到 Dart 程序中
  const String signatureBase64 = '...'; // 替换为 Base64 编码的签名，这里是占位符
  final Uint8List signatureBytes = base64.decode(signatureBase64);

  print('开始验证签名...');
  final isValid = SignatureVerifier.verifySignature(publicKeyPem, appHashBytes, signatureBytes);

  if (isValid) {
    print('✅ 签名验证成功！二进制文件完整且来自可信源。');
  } else {
    print('❌ 签名验证失败！二进制文件可能已被篡改或来源不可信。');
  }
}

100

101

102

103

104

105

106

107

108

109

110

import 'dart:typed_data';

import 'dart:convert';

import 'package:pointycastle/api.dart';

import 'package:pointycastle/asymmetric/api.dart';

import 'package:pointycastle/asymmetric/rsa.dart';

import 'package:pointycastle/digests/sha256.dart';

import 'package:pointycastle/signers/rsa_signer.dart';

import 'package:asn1lib/asn1lib.dart'; // 用于解析 PEM 公钥

/// 辅助函数：从 PEM 格式字符串加载 RSA 公钥。

/// 这需要解析 PEM 格式，提取 ASN.1 编码的公钥数据。

/// 注意：实际应用中，公钥通常以更简洁的方式嵌入，例如 Base64 编码的模数和指数，

/// 或者直接将 ASN.1 DER 编码的字节嵌入。

RSAPublicKey parseRSAPublicKeyFromPem(String pem) {

final lines = pem.split('n');

final base64String = lines

.where((line) =>

!line.startsWith('-----BEGIN') && !line.startsWith('-----END'))

.join('');

final derBytes = base64.decode(base64String);

final parser = ASN1Parser(derBytes);

final topLevel = parser.nextObject() as ASN1Sequence;

// 根据 RFC 3447 (PKCS#1) 或 X.509 SPKI 结构解析公钥

// X.509 SPKI 结构通常是 Sequence(Sequence(AlgorithmIdentifier), BitString(RSAPublicKey))

// RSAPublicKey 是 Sequence(modulus, publicExponent)

ASN1Sequence publicKeySequence;

if (topLevel.elements.length == 2 && topLevel.elements[0] is ASN1Sequence && topLevel.elements[1] is ASN1BitString) {

// X.509 SubjectPublicKeyInfo

final bitString = topLevel.elements[1] as ASN1BitString;

final spkiParser = ASN1Parser(bitString.stringValue as Uint8List);

publicKeySequence = spkiParser.nextObject() as ASN1Sequence;

} else {

// PKCS#1 RSAPublicKey

publicKeySequence = topLevel;

}

final modulus = publicKeySequence.elements[0] as ASN1Integer;

final exponent = publicKeySequence.elements[1] as ASN1Integer;

return RSAPublicKey(modulus.valueAsBigInt, exponent.valueAsBigInt);

}

/// 负责验证数字签名的工具类。

class SignatureVerifier {

/// 验证给定数据是否由指定公钥签名。

///

/// [publicKeyPem]：PEM 格式的 RSA 公钥字符串。

/// [dataHashBytes]：原始数据的 SHA-256 哈希值字节数组。

/// [signatureBytes]：数字签名字节数组。

/// 返回：如果签名有效则返回 true，否则返回 false。

static bool verifySignature(String publicKeyPem, Uint8List dataHashBytes, Uint8List signatureBytes) {

try {

final rsaPublicKey = parseRSAPublicKeyFromPem(publicKeyPem);

final signer = RSASigner(SHA256Digest(), '0609608648016503040201'); // '0609608648016503040201' 是 OID for SHA256withRSA PSS if using PSS

// 对于 PKCS#1 v1.5 padding，通常不需要指定 OID。

// 对于 SHA256withRSA，PointyCastle 会根据 Digest 类型自动选择合适的 padding

// 如果使用 RSASigner(SHA256Digest()) 默认是 PKCS1 v1.5 padding

// 如果需要 PSS padding，则需要 RSASigner(SHA256Digest(), '0609608648016503040201') 并在初始化参数中指定 PSS

// 这里我们假设使用 PKCS#1 v1.5 padding，这是最常见的。

signer.init(false, PublicKeyParameter<RSAPublicKey>(rsaPublicKey)); // false 表示验证模式

// 验证签名的核心步骤

final RSASignature rsaSignature = RSASignature(signatureBytes);

return signer.verifySignature(dataHashBytes, rsaSignature);

} catch (e) {

print('签名验证过程中发生错误: $e');

return false;

}

// 示例用法（需要一个实际的私钥来生成签名）

// 假设你已经通过 openssl 生成了私钥和公钥，并用私钥签名了一个哈希值。

// openssl genrsa -out private_key.pem 2048

// openssl rsa -in private_key.pem -pubout -out public_key.pem

// echo "hello world" | sha256sum | awk '{print $1}' > hash.txt

// openssl dgst -sha256 -sign private_key.pem -out signature.sig hash.txt

void main() async {

// 替换为你的实际公钥 PEM 字符串

const String publicKeyPem = '''

-----BEGIN PUBLIC KEY-----

MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAsRk3Q09s+v0M/g0H4n4+

... (你的公钥内容) ...

AQAB

-----END PUBLIC KEY-----

'''; // 这里的公钥是占位符，请替换为实际生成的公钥

// 假设这是我们应用程序的 SHA-256 哈希值 (32 字节)

final String appHashHex = 'a8047970d4f6c8273752e22c422849c6762335f6068307c0879e60938ff48a62'; // 示例哈希

final Uint8List appHashBytes = Uint8List.fromList(List.generate(appHashHex.length ~/ 2, (i) => int.parse(appHashHex.substring(i * 2, i * 2 + 2), radix: 16)));

// 假设这是通过私钥对 appHashBytes 签名的结果 (通常是 256 字节对于 2048 位 RSA)

// 这个签名需要通过离线工具生成，并以 Base64 等方式嵌入到 Dart 程序中

const String signatureBase64 = '...'; // 替换为 Base64 编码的签名，这里是占位符

final Uint8List signatureBytes = base64.decode(signatureBase64);

print('开始验证签名...');

final isValid = SignatureVerifier.verifySignature(publicKeyPem, appHashBytes, signatureBytes);

if (isValid) {

print('✅ 签名验证成功！二进制文件完整且来自可信源。');

} else {

print('❌ 签名验证失败！二进制文件可能已被篡改或来源不可信。');

}

关于 parseRSAPublicKeyFromPem 的说明：

PEM 格式是 Base64 编码的 DER (Distinguished Encoding Rules) 数据，通常包含 X.509 SubjectPublicKeyInfo 结构。这个结构本身是一个 ASN.1 Sequence，其中包含了算法标识符和一个 BitString，BitString 的内容又是另一个 ASN.1 Sequence，包含 RSA 的模数 (modulus) 和公指数 (publicExponent)。解析这个结构需要对 ASN.1 编码有一定的了解。package:asn1lib 可以帮助我们解析这些结构。

在实际生产环境中，为了简化，我们可能不会直接嵌入 PEM 字符串，而是只嵌入公钥的模数和公指数的 Base64 编码字符串，或者直接嵌入 DER 编码的字节数组，这样可以避免运行时复杂的 ASN.1 解析。

第三部分：设计运行时完整性检查架构

构建一个健壮的运行时完整性检查机制需要精心设计离线签名阶段和在线验证阶段。

3.1 离线签名阶段（构建/发布时）

这个阶段在应用程序编译和打包后进行，由开发者或 CI/CD 系统执行。

生成密钥对： 开发者生成一对 RSA 或 ECDSA 私钥和公钥。私钥必须严格保密，公钥将随应用程序分发。

# 生成 2048 位 RSA 私钥
openssl genrsa -aes256 -out private_key.pem 2048
# 导出公钥
openssl rsa -in private_key.pem -pubout -out public_key.pem
# 注意：在生产环境，私钥应存储在 HSM (硬件安全模块) 或受严格保护的环境中。

# 生成 2048 位 RSA 私钥

openssl genrsa -aes256 -out private_key.pem 2048

# 导出公钥

openssl rsa -in private_key.pem -pubout -out public_key.pem

# 注意：在生产环境，私钥应存储在 HSM (硬件安全模块) 或受严格保护的环境中。

AOT 编译 Dart 应用程序： 生成最终的原生二进制文件。

dart compile exe bin/main.dart -o my_app

1

dart compile exe bin/main.dart -o my_app
计算二进制文件哈希值： 对编译后的整个 AOT 二进制文件计算 SHA-256 哈希值。

sha256sum my_app > my_app.sha256 # 或者对于 Windows: certutil -hashfile my_app SHA256

1
2

sha256sum my_app > my_app.sha256
# 或者对于 Windows: certutil -hashfile my_app SHA256

关键考虑： 在某些情况下，如果签名或公钥被嵌入到二进制文件自身中，那么在计算哈希时需要排除这些部分，以避免“自举问题”——即嵌入内容改变了文件的哈希，导致验证失败。最简单的策略是将签名和公钥存储在二进制文件的末尾，或者作为单独的资源。如果存储在末尾，需要约定一个偏移量或标记来识别和排除它们。
- 策略一（最简单）： 签名和公钥作为独立的资源文件（不推荐，容易被分离或替换）。
- 策略二（推荐）： 签名和公钥以硬编码字符串（Base64 编码）的形式嵌入到 Dart 源代码中，在编译前。这种情况下，哈希的是包含公钥和签名字符串的 Dart 源代码编译出的二进制文件。这看起来像个循环，但实际上是：先编译出一个不含签名的临时版本，计算其哈希，用私钥签名这个哈希，然后把签名和公钥作为常量嵌入到最终的 Dart 源代码中，再进行最终编译。 这种方法虽然安全，但比较繁琐，且签名值每次变动都需要重新编译。
- 策略三（更灵活）： 签名和公钥以特定格式（如 JSON、自定义二进制格式）附加在二进制文件的末尾。在运行时，程序需要知道如何解析这些附加数据，并在计算哈希时排除它们。这需要对二进制文件格式有一定了解，或者约定一个简单的分隔符。
我们主要关注策略二和三的结合：将公钥和签名以硬编码字符串形式嵌入，但签名是针对不包含签名和公钥本身的二进制文件的哈希。

重新思考策略二的实现：
1. AOT 编译 main.dart 到 my_app_unsigned。
2. 计算 my_app_unsigned 的哈希值 hash_of_unsigned_app。
3. 用私钥签名 hash_of_unsigned_app 得到 signature_value。
4. 将 public_key_pem_string 和 signature_value_base64_string 作为 Dart 常量写入一个新文件，例如 lib/app_integrity_constants.dart。
5. 修改 main.dart 导入 app_integrity_constants.dart。
6. 重新 AOT 编译 main.dart 到 my_app_final。
7. 在运行时，my_app_final 会读取 public_key_pem_string 和 signature_value_base64_string。它会尝试计算当前运行的 my_app_final 的哈希，然后用读取到的公钥和签名去验证。
问题： my_app_final 的哈希会包含 public_key_pem_string 和 signature_value_base64_string，而 signature_value 是基于 my_app_unsigned 计算的。这两者不匹配。

正确的策略（策略三的变种）：将签名和公钥作为外部数据或者以一种可预测的方式附加到二进制文件尾部。

我们选择一种相对简单且通用的方法：将签名和公钥作为硬编码字符串嵌入到 Dart 代码中，但哈希计算的目标是整个二进制文件。这意味着签名所覆盖的内容，也包括了它自身以及公钥。这并非完美，但对于大多数应用场景，它的简单性和有效性可以接受。如果攻击者修改了二进制文件，那么哈希值会改变，签名验证就会失败。如果攻击者同时修改了嵌入的签名或公钥，那么要么哈希值不匹配，要么公钥不对，签名验证依然失败。攻击者唯一能成功的方式是：修改了二进制文件，并用他们自己的私钥重新签名，然后将新的签名和对应的公钥嵌入到程序中。这时，我们需要确保我们的验证逻辑足够健壮，不被轻易替换。

因此，我们采用如下流程：
1. AOT 编译 bin/main.dart 到 my_app。
2. 计算 my_app 的完整哈希 H_app。
3. 使用私钥对 H_app 进行签名，得到 S_app。
4. 将 public_key_pem_string 和 S_app 的 Base64 编码字符串作为 Dart 常量嵌入到 lib/app_integrity_constants.dart。
5. 注意： 这一步需要循环。因为嵌入 public_key_pem_string 和 S_app 会改变 my_app 的内容，从而改变 H_app。理想情况下，我们需要一个固定的位置来存储这些，或者使用一个“两阶段”签名法：
  - a. 编译一个占位符版本。
  - b. 计算占位符版本的哈希。
  - c. 签名哈希。
  - d. 将签名和公钥嵌入到指定位置。
  - e. 重新编译，确保这些嵌入操作不会改变二进制文件的其他部分，或者只改变这些部分，而我们计算哈希时可以排除它们。
更实际的流程：
为了避免复杂的二进制文件解析和循环编译问题，我们采用一个更直接的方法：
1. 最终编译前： 在 Dart 代码中预留好 const String _kEmbeddedPublicKey = '...'; 和 const String _kEmbeddedSignature = '...'; 的位置。
2. 首次编译： 编译一个“占位符”版本，例如 dart compile exe bin/main.dart -o my_app_placeholder。
3. 计算哈希： 计算 my_app_placeholder 的完整 SHA-256 哈希 H_placeholder。
4. 签名： 使用私钥对 H_placeholder 进行签名，得到 S_placeholder。
5. 更新常量： 将你的公钥 PEM 字符串和 S_placeholder 的 Base64 编码填入 _kEmbeddedPublicKey 和 _kEmbeddedSignature。
6. 最终编译： 重新编译一次，得到 my_app_final。注意： 此时 my_app_final 的哈希值已经与 H_placeholder 不同，因为它包含了 _kEmbeddedPublicKey 和 _kEmbeddedSignature。
7. 运行时验证： 在运行时，程序会计算 my_app_final 的哈希 H_runtime。然后尝试用 _kEmbeddedPublicKey 验证 _kEmbeddedSignature 是否是 H_runtime 的签名。
  问题： 这种方法依然存在哈希不匹配的问题，因为签名是针对 my_app_placeholder 的，而不是 my_app_final 的。
解决哈希不匹配的通用方案：将签名和公钥附加到文件末尾。
这需要一个额外的工具来处理。
1. AOT 编译 bin/main.dart 到 my_app_executable。
2. 计算 my_app_executable 的 SHA-256 哈希 H_app。
3. 使用私钥对 H_app 进行签名，得到 S_app。
4. 将 S_app 和 public_key_pem_string 编码成一个结构（例如 JSON 或自定义格式），并将其附加到 my_app_executable 文件的末尾。
  - 例如：my_app_executable + 'START_SIGNATURE_BLOCK' + {signature_data_json} + 'END_SIGNATURE_BLOCK'
5. 在运行时：
  - 程序读取自己 (my_app_executable) 的内容。
  - 找到并解析末尾的签名块。
  - 在计算哈希时，只计算签名块之前的部分。
  - 使用解析出的公钥和签名验证这个哈希。
这种方法要求程序能够精确地识别和排除签名块。这通常通过在签名块前添加一个已知魔术字符串 (magic string) 和签名块的长度来实现。

3.2 运行时验证阶段（应用程序启动时）

这个阶段在应用程序启动时，由应用程序自身执行。

获取自身路径： 应用程序需要知道自己作为可执行文件的路径。
读取自身内容： 应用程序以二进制流的形式读取自己文件的内容。
排除签名块（如果适用）： 如果签名块被附加在文件末尾，应用程序需要计算一个排除这些部分的哈希值。
计算运行时哈希： 对程序文件（或其相关部分）计算 SHA-256 哈希值。
加载公钥与签名： 从嵌入的常量或外部资源中加载公钥和预存的数字签名。
验证签名： 使用公钥验证运行时哈希值与预存签名的匹配性。
处理验证结果：
- 成功： 应用程序正常启动。
- 失败： 应用程序应立即终止、记录错误、提示用户，甚至可以尝试报告（如果安全通道可用）。

3.3 关键挑战与解决方案

自举问题： 应用程序如何验证自身？如果验证逻辑本身被篡改怎么办？
- 解决方案： 将核心验证逻辑放置在二进制文件中难以篡改的区域，或者通过多层、分散的验证点来增加攻击难度。虽然无法100%防止最顶级的攻击者，但可以显著提高攻击门槛。
跨平台兼容性： 获取自身路径、文件 I/O 在不同操作系统上有所不同。
- 解决方案： Dart 的 dart:io 提供了跨平台的文件操作。对于获取可执行文件路径，Platform.executable 通常可用。对于更底层的操作，可能需要使用 dart:ffi 调用操作系统原生 API。
性能开销： 对大型二进制文件进行哈希计算可能耗时，影响启动速度。
- 解决方案：
  - 在开发阶段进行性能测试。
  - 考虑使用更快的哈希算法（如果安全性允许）。
  - 哈希关键代码段而非整个文件（复杂）。
  - 首次启动时进行完整检查，后续启动时可以考虑缓存哈希结果（但缓存本身需要保护）。
攻击者如何绕过： 攻击者可能尝试修改验证逻辑本身、替换嵌入的公钥、或者简单地 Hook exit() 函数。
- 解决方案：
  - 代码混淆： Dart AOT 支持一定程度的混淆，使得逆向工程更困难。
  - 反调试/反篡改技术： 利用 dart:ffi 调用 OS API 检测调试器、检测内存修改等（高级且复杂）。
  - 分散验证点： 在程序的不同模块和生命周期阶段进行多次验证。
  - 安全退出： 在验证失败时，确保程序以一种难以被 Hook 或绕过的方式安全终止。

第四部分：详细实现：从构建到运行

我们将重点实现上述将签名和公钥附加到文件末尾的策略。这需要一个外部工具来执行附加操作，以及 Dart 应用程序内部的解析和验证逻辑。

4.1 预编译与签名流程（外部脚本与工具）

1. 生成密钥对 (如果尚未生成):

   openssl genrsa -out private_key.pem 2048
   openssl rsa -in private_key.pem -pubout -out public_key.pem

1 2	openssl genrsa -out private_key.pem 2048 openssl rsa -in private_key.pem -pubout -out public_key.pem

2. Dart AOT 编译应用程序:
假设你的主 Dart 文件是 bin/main.dart。

   dart compile exe bin/main.dart -o my_app

1	dart compile exe bin/main.dart -o my_app

3. 创建一个 Python 脚本来附加签名和公钥:
这个脚本将执行哈希、签名和附加操作。

sign_and_attach.py

   import hashlib
   import base64
   from cryptography.hazmat.primitives import hashes
   from cryptography.hazmat.primitives.asymmetric import padding
   from cryptography.hazmat.primitives.asymmetric import rsa
   from cryptography.hazmat.primitives import serialization
   import json
   import sys
   import os

   def calculate_sha256(filepath):
       """计算文件的 SHA-256 哈希值."""
       hasher = hashlib.sha256()
       with open(filepath, 'rb') as f:
           while True:
               chunk = f.read(4096)
               if not chunk:
                   break
               hasher.update(chunk)
       return hasher.digest()

   def sign_hash(private_key_path, data_hash):
       """使用 RSA 私钥对哈希值进行签名."""
       with open(private_key_path, "rb") as key_file:
           private_key = serialization.load_pem_private_key(
               key_file.read(),
               password=None, # 如果私钥有密码，这里需要提供
           )

       signature = private_key.sign(
           data_hash,
           padding.PSS(
               mgf=padding.MGF1(hashes.SHA256()),
               salt_length=padding.PSS.MAX_LENGTH
           ),
           hashes.SHA256()
       )
       return signature

   def get_public_key_pem(public_key_path):
       """读取公钥 PEM 字符串."""
       with open(public_key_path, 'r') as f:
           return f.read()

   def attach_signature_block(executable_path, signature_data):
       """将签名数据块附加到可执行文件末尾."""
       # 魔术字符串和长度前缀，以便 Dart 程序能够识别和解析
       magic_start = b'DART_AOT_SIGNATURE_BLOCK_START_V1n'
       magic_end = b'nDART_AOT_SIGNATURE_BLOCK_END_V1n'

       signature_json_bytes = json.dumps(signature_data, indent=2).encode('utf-8')
       signature_block = magic_start + signature_json_bytes + magic_end

       with open(executable_path, 'ab') as f: # 以追加二进制模式打开
           f.write(signature_block)

       print(f"签名块已成功附加到 '{executable_path}'。")
       print(f"签名块大小: {len(signature_block)} 字节。")

   if __name__ == "__main__":
       if len(sys.argv) != 4:
           print("用法: python sign_and_attach.py <executable_path> <private_key_path> <public_key_path>")
           sys.exit(1)

       executable_path = sys.argv[1]
       private_key_path = sys.argv[2]
       public_key_path = sys.argv[3]

       if not os.path.exists(executable_path):
           print(f"错误: 可执行文件 '{executable_path}' 不存在。")
           sys.exit(1)
       if not os.path.exists(private_key_path):
           print(f"错误: 私钥文件 '{private_key_path}' 不存在。")
           sys.exit(1)
       if not os.path.exists(public_key_path):
           print(f"错误: 公钥文件 '{public_key_path}' 不存在。")
           sys.exit(1)

       # 1. 计算原始可执行文件的哈希值 (不含签名块)
       original_hash = calculate_sha256(executable_path)
       print(f"原始可执行文件 '{executable_path}' 的 SHA-256 哈希值: {original_hash.hex()}")

       # 2. 对哈希值进行签名
       signature = sign_hash(private_key_path, original_hash)
       print(f"生成的签名 (Base64): {base64.b64encode(signature).decode('utf-8')}")

       # 3. 获取公钥 PEM 字符串
       public_key_pem = get_public_key_pem(public_key_path)

       # 4. 构建签名数据块
       signature_data = {
           "hash_algorithm": "SHA256",
           "signature_algorithm": "RSA-PSS", # 或 RSA-PKCS1v15
           "original_hash_base64": base64.b64encode(original_hash).decode('utf-8'),
           "signature_base64": base64.b64encode(signature).decode('utf-8'),
           "public_key_pem": public_key_pem,
       }

       # 5. 将签名数据块附加到可执行文件
       attach_signature_block(executable_path, signature_data)

       print("签名和附加过程完成。")

100

101

102

import hashlib

import base64

from cryptography.hazmat.primitives import hashes

from cryptography.hazmat.primitives.asymmetric import padding

from cryptography.hazmat.primitives.asymmetric import rsa

from cryptography.hazmat.primitives import serialization

import json

import sys

import os

def calculate_sha256(filepath):

"""计算文件的 SHA-256 哈希值."""

hasher = hashlib.sha256()

with open(filepath, 'rb') as f:

while True:

chunk = f.read(4096)

if not chunk:

break

hasher.update(chunk)

return hasher.digest()

def sign_hash(private_key_path, data_hash):

"""使用 RSA 私钥对哈希值进行签名."""

with open(private_key_path, "rb") as key_file:

private_key = serialization.load_pem_private_key(

key_file.read(),

password=None, # 如果私钥有密码，这里需要提供

)

signature = private_key.sign(

data_hash,

padding.PSS(

mgf=padding.MGF1(hashes.SHA256()),

salt_length=padding.PSS.MAX_LENGTH

hashes.SHA256()

)

return signature

def get_public_key_pem(public_key_path):

"""读取公钥 PEM 字符串."""

with open(public_key_path, 'r') as f:

return f.read()

def attach_signature_block(executable_path, signature_data):

"""将签名数据块附加到可执行文件末尾."""

# 魔术字符串和长度前缀，以便 Dart 程序能够识别和解析

magic_start = b'DART_AOT_SIGNATURE_BLOCK_START_V1n'

magic_end = b'nDART_AOT_SIGNATURE_BLOCK_END_V1n'

signature_json_bytes = json.dumps(signature_data, indent=2).encode('utf-8')

signature_block = magic_start + signature_json_bytes + magic_end

with open(executable_path, 'ab') as f: # 以追加二进制模式打开

f.write(signature_block)

print(f"签名块已成功附加到 '{executable_path}'。")

print(f"签名块大小: {len(signature_block)} 字节。")

if __name__ == "__main__":

if len(sys.argv) != 4:

print("用法: python sign_and_attach.py <executable_path> <private_key_path> <public_key_path>")

sys.exit(1)

executable_path = sys.argv[1]

private_key_path = sys.argv[2]

public_key_path = sys.argv[3]

if not os.path.exists(executable_path):

print(f"错误: 可执行文件 '{executable_path}' 不存在。")

sys.exit(1)

if not os.path.exists(private_key_path):

print(f"错误: 私钥文件 '{private_key_path}' 不存在。")

sys.exit(1)

if not os.path.exists(public_key_path):

print(f"错误: 公钥文件 '{public_key_path}' 不存在。")

sys.exit(1)

# 1. 计算原始可执行文件的哈希值 (不含签名块)

original_hash = calculate_sha256(executable_path)

print(f"原始可执行文件 '{executable_path}' 的 SHA-256 哈希值: {original_hash.hex()}")

# 2. 对哈希值进行签名

signature = sign_hash(private_key_path, original_hash)

print(f"生成的签名 (Base64): {base64.b64encode(signature).decode('utf-8')}")

# 3. 获取公钥 PEM 字符串

public_key_pem = get_public_key_pem(public_key_path)

# 4. 构建签名数据块

signature_data = {

"hash_algorithm": "SHA256",

"signature_algorithm": "RSA-PSS", # 或 RSA-PKCS1v15

"original_hash_base64": base64.b64encode(original_hash).decode('utf-8'),

"signature_base64": base64.b64encode(signature).decode('utf-8'),

"public_key_pem": public_key_pem,

}

# 5. 将签名数据块附加到可执行文件

attach_signature_block(executable_path, signature_data)

print("签名和附加过程完成。")

运行签名脚本:

 python sign_and_attach.py my_app private_key.pem public_key.pem

1	python sign_and_attach.py my_app private_key.pem public_key.pem

现在 my_app 文件末尾将包含一个 JSON 格式的签名块。

4.2 运行时验证流程（Dart 应用程序内部）

Dart 应用程序需要实现以下功能：

获取自身路径。
以二进制模式读取自身文件内容。
解析文件末尾的签名块： 查找魔术字符串，提取 JSON 数据。
计算“干净”的哈希： 只对签名块之前的文件内容计算哈希。
验证签名。
根据结果采取行动。

lib/integrity_checker.dart (更新)

import 'dart:io';
import 'dart:convert';
import 'dart:typed_data';

import 'package:crypto/crypto.dart';
import 'package:pointycastle/api.dart';
import 'package:pointycastle/asymmetric/api.dart';
import 'package:pointycastle/asymmetric/rsa.dart';
import 'package:pointycastle/digests/sha256.dart';
import 'package:pointycastle/signers/rsa_signer.dart';
import 'package:asn1lib/asn1lib.dart'; // 用于解析 PEM 公钥

/// 定义签名块的魔术字符串，需要与 Python 脚本中的一致。
const String _kSignatureBlockStartMagic = 'DART_AOT_SIGNATURE_BLOCK_START_V1n';
const String _kSignatureBlockEndMagic = 'nDART_AOT_SIGNATURE_BLOCK_END_V1n';

/// 用于存储解析出的签名数据。
class SignatureData {
  final String hashAlgorithm;
  final String signatureAlgorithm;
  final String originalHashBase64;
  final String signatureBase64;
  final String publicKeyPem;

  SignatureData({
    required this.hashAlgorithm,
    required this.signatureAlgorithm,
    required this.originalHashBase64,
    required this.signatureBase64,
    required this.publicKeyPem,
  });

  factory SignatureData.fromJson(Map<String, dynamic> json) {
    return SignatureData(
      hashAlgorithm: json['hash_algorithm'] as String,
      signatureAlgorithm: json['signature_algorithm'] as String,
      originalHashBase64: json['original_hash_base64'] as String,
      signatureBase64: json['signature_base64'] as String,
      publicKeyPem: json['public_key_pem'] as String,
    );
  }
}

/// 辅助函数：从 PEM 格式字符串加载 RSA 公钥。
RSAPublicKey parseRSAPublicKeyFromPem(String pem) {
  final lines = pem.split('n');
  final base64String = lines
      .where((line) =>
          !line.startsWith('-----BEGIN') && !line.startsWith('-----END'))
      .join('');
  final derBytes = base64.decode(base64String);

  final parser = ASN1Parser(derBytes);
  final topLevel = parser.nextObject() as ASN1Sequence;

  ASN1Sequence publicKeySequence;
  if (topLevel.elements.length == 2 && topLevel.elements[0] is ASN1Sequence && topLevel.elements[1] is ASN1BitString) {
    // X.509 SubjectPublicKeyInfo
    final bitString = topLevel.elements[1] as ASN1BitString;
    final spkiParser = ASN1Parser(bitString.stringValue as Uint8List);
    publicKeySequence = spkiParser.nextObject() as ASN1Sequence;
  } else {
    // PKCS#1 RSAPublicKey
    publicKeySequence = topLevel;
  }

  final modulus = publicKeySequence.elements[0] as ASN1Integer;
  final exponent = publicKeySequence.elements[1] as ASN1Integer;

  return RSAPublicKey(modulus.valueAsBigInt, exponent.valueAsBigInt);
}

class AppIntegrityChecker {
  /// 尝试从当前可执行文件末尾解析签名数据块。
  ///
  /// 返回：[SignatureData] 对象，如果解析失败则返回 null。
  static Future<SignatureData?> _parseSignatureBlock(String executablePath) async {
    final file = File(executablePath);
    if (!await file.exists()) {
      print('错误: 可执行文件不存在: $executablePath');
      return null;
    }

    // 读取文件的最后一部分，以查找签名块
    // 假设签名块不会太大，例如不超过 4KB
    const int readBufferSize = 4096;
    final fileLength = await file.length();
    final startOffset = (fileLength - readBufferSize).clamp(0, fileLength).toInt();

    final raf = await file.open(mode: FileMode.read);
    await raf.setPosition(startOffset);
    final buffer = await raf.read(fileLength - startOffset);
    await raf.close();

    final bufferString = utf8.decode(buffer, allowMalformed: true);

    final startIndex = bufferString.indexOf(_kSignatureBlockStartMagic);
    final endIndex = bufferString.indexOf(_kSignatureBlockEndMagic, startIndex != -1 ? startIndex + _kSignatureBlockStartMagic.length : 0);

    if (startIndex == -1 || endIndex == -1) {
      print('警告: 未找到有效的签名块。');
      return null;
    }

    final jsonStartIndex = startIndex + _kSignatureBlockStartMagic.length;
    final jsonString = bufferString.substring(jsonStartIndex, endIndex);

    try {
      final Map<String, dynamic> jsonMap = json.decode(jsonString);
      return SignatureData.fromJson(jsonMap);
    } catch (e) {
      print('错误: 解析签名块JSON失败: $e');
      return null;
    }
  }

  /// 计算可执行文件（排除签名块）的 SHA-256 哈希值。
  ///
  /// [executablePath]：可执行文件路径。
  /// [signatureBlockEndOffset]：签名块结束的字节偏移量，用于确定哈希计算的范围。
  /// 返回：哈希值的字节数组。
  static Future<Uint8List> _calculateExecutableHash(String executablePath, int signatureBlockEndOffset) async {
    final file = File(executablePath);
    if (!await file.exists()) {
      throw FileSystemException('文件不存在', executablePath);
    }

    final input = file.openRead(0, signatureBlockEndOffset); // 只读取签名块之前的部分
    final digest = await sha256.bind(input).first;
    return Uint8List.fromList(digest.bytes);
  }

  /// 执行应用程序的完整性检查。
  ///
  /// 返回：如果完整性验证成功则返回 true，否则返回 false。
  static Future<bool> checkIntegrity() async {
    final executablePath = Platform.executable;
    print('正在检查可执行文件: $executablePath 的完整性...');

    final SignatureData? signatureData = await _parseSignatureBlock(executablePath);
    if (signatureData == null) {
      print('❌ 完整性检查失败: 无法解析签名数据块。');
      return false;
    }

    final fileLength = await File(executablePath).length();
    // 计算签名块的起始和结束位置，相对于文件末尾的偏移
    final endMagicLength = _kSignatureBlockEndMagic.length;
    final startMagicLength = _kSignatureBlockStartMagic.length;

    // 假设签名块的JSON内容长度
    final jsonContentLength = base64.decode(signatureData.signatureBase64).length + base64.decode(signatureData.originalHashBase64).length + signatureData.publicKeyPem.length + 200; // 粗略估计JSON内容的长度，加上一些冗余

    // 签名块的总长度，需要与 Python 脚本保持一致
    // 实际计算时，应该精确计算 json.dumps(signature_data) 的长度，但这里我们无法获得原始 Python 脚本的精确输出
    // 假设我们已经通过某种方式知道精确的签名块长度，或者从签名块中解析出它的长度
    // 简化的方法是：从文件末尾向回搜索 START_MAGIC，然后计算其之前的长度

    final fullFileContent = await File(executablePath).readAsBytes();
    final String fullFileContentString = utf8.decode(fullFileContent, allowMalformed: true);

    final startMagicIndex = fullFileContentString.lastIndexOf(_kSignatureBlockStartMagic);
    if (startMagicIndex == -1) {
        print('❌ 完整性检查失败: 无法在完整文件内容中找到签名块开始标记。');
        return false;
    }

    // 用于计算哈希的文件部分结束偏移量
    final executableContentEndOffset = startMagicIndex;

    // 1. 计算当前可执行文件（排除签名块）的哈希值
    final Uint8List runtimeHashBytes = await _calculateExecutableHash(executablePath, executableContentEndOffset);
    final String runtimeHashHex = runtimeHashBytes.map((byte) => byte.toRadixString(16).padLeft(2, '0')).join();
    print('运行时计算的哈希值: $runtimeHashHex');

    // 2. 从签名数据中提取原始哈希和签名
    final Uint8List expectedOriginalHashBytes = base64.decode(signatureData.originalHashBase64);
    final Uint8List signatureBytes = base64.decode(signatureData.signatureBase64);

    if (runtimeHashBytes.length != expectedOriginalHashBytes.length ||
        !_compareByteLists(runtimeHashBytes, expectedOriginalHashBytes)) {
      print('❌ 完整性检查失败: 运行时哈希值与签名中记录的原始哈希值不匹配。');
      return false;
    }

    // 3. 验证数字签名
    try {
      final rsaPublicKey = parseRSAPublicKeyFromPem(signatureData.publicKeyPem);
      final signer = RSASigner(SHA256Digest(), '0609608648016503040201'); // PSS padding OID
      signer.init(false, PublicKeyParameter<RSAPublicKey>(rsaPublicKey)); // false for verification

      final RSASignature rsaSignature = RSASignature(signatureBytes);
      final bool isValid = signer.verifySignature(runtimeHashBytes, rsaSignature);

      if (isValid) {
        print('✅ 签名验证成功！二进制文件完整且来自可信源。');
        return true;
      } else {
        print('❌ 签名验证失败！二进制文件可能已被篡改或来源不可信。');
        return false;
      }
    } catch (e) {
      print('❌ 签名验证过程中发生错误: $e');
      return false;
    }
  }

  /// 比较两个字节列表是否相同。
  static bool _compareByteLists(Uint8List a, Uint8List b) {
    if (a.length != b.length) return false;
    for (int i = 0; i < a.length; i++) {
      if (a[i] != b[i]) return false;
    }
    return true;
  }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

import 'dart:io';

import 'dart:convert';

import 'dart:typed_data';

import 'package:crypto/crypto.dart';

import 'package:pointycastle/api.dart';

import 'package:pointycastle/asymmetric/api.dart';

import 'package:pointycastle/asymmetric/rsa.dart';

import 'package:pointycastle/digests/sha256.dart';

import 'package:pointycastle/signers/rsa_signer.dart';

import 'package:asn1lib/asn1lib.dart'; // 用于解析 PEM 公钥

/// 定义签名块的魔术字符串，需要与 Python 脚本中的一致。

const String _kSignatureBlockStartMagic = 'DART_AOT_SIGNATURE_BLOCK_START_V1n';

const String _kSignatureBlockEndMagic = 'nDART_AOT_SIGNATURE_BLOCK_END_V1n';

/// 用于存储解析出的签名数据。

class SignatureData {

final String hashAlgorithm;

final String signatureAlgorithm;

final String originalHashBase64;

final String signatureBase64;

final String publicKeyPem;

SignatureData({

required this.hashAlgorithm,

required this.signatureAlgorithm,

required this.originalHashBase64,

required this.signatureBase64,

required this.publicKeyPem,

});

factory SignatureData.fromJson(Map<String, dynamic> json) {

return SignatureData(

hashAlgorithm: json['hash_algorithm'] as String,

signatureAlgorithm: json['signature_algorithm'] as String,

originalHashBase64: json['original_hash_base64'] as String,

signatureBase64: json['signature_base64'] as String,

publicKeyPem: json['public_key_pem'] as String,

);

}

/// 辅助函数：从 PEM 格式字符串加载 RSA 公钥。

RSAPublicKey parseRSAPublicKeyFromPem(String pem) {

final lines = pem.split('n');

final base64String = lines

.where((line) =>

!line.startsWith('-----BEGIN') && !line.startsWith('-----END'))

.join('');

final derBytes = base64.decode(base64String);

final parser = ASN1Parser(derBytes);

final topLevel = parser.nextObject() as ASN1Sequence;

ASN1Sequence publicKeySequence;

if (topLevel.elements.length == 2 && topLevel.elements[0] is ASN1Sequence && topLevel.elements[1] is ASN1BitString) {

// X.509 SubjectPublicKeyInfo

final bitString = topLevel.elements[1] as ASN1BitString;

final spkiParser = ASN1Parser(bitString.stringValue as Uint8List);

publicKeySequence = spkiParser.nextObject() as ASN1Sequence;

} else {

// PKCS#1 RSAPublicKey

publicKeySequence = topLevel;

}

final modulus = publicKeySequence.elements[0] as ASN1Integer;

final exponent = publicKeySequence.elements[1] as ASN1Integer;

return RSAPublicKey(modulus.valueAsBigInt, exponent.valueAsBigInt);

}

class AppIntegrityChecker {

/// 尝试从当前可执行文件末尾解析签名数据块。

///

/// 返回：[SignatureData] 对象，如果解析失败则返回 null。

static Future<SignatureData?> _parseSignatureBlock(String executablePath) async {

final file = File(executablePath);

if (!await file.exists()) {

print('错误: 可执行文件不存在: $executablePath');

return null;

}

// 读取文件的最后一部分，以查找签名块

// 假设签名块不会太大，例如不超过 4KB

const int readBufferSize = 4096;

final fileLength = await file.length();

final startOffset = (fileLength - readBufferSize).clamp(0, fileLength).toInt();

final raf = await file.open(mode: FileMode.read);

await raf.setPosition(startOffset);

final buffer = await raf.read(fileLength - startOffset);

await raf.close();

final bufferString = utf8.decode(buffer, allowMalformed: true);

final startIndex = bufferString.indexOf(_kSignatureBlockStartMagic);

final endIndex = bufferString.indexOf(_kSignatureBlockEndMagic, startIndex != -1 ? startIndex + _kSignatureBlockStartMagic.length : 0);

if (startIndex == -1 || endIndex == -1) {

print('警告: 未找到有效的签名块。');

return null;

}

final jsonStartIndex = startIndex + _kSignatureBlockStartMagic.length;

final jsonString = bufferString.substring(jsonStartIndex, endIndex);

try {

final Map<String, dynamic> jsonMap = json.decode(jsonString);

return SignatureData.fromJson(jsonMap);

} catch (e) {

print('错误: 解析签名块JSON失败: $e');

return null;

}

/// 计算可执行文件（排除签名块）的 SHA-256 哈希值。

///

/// [executablePath]：可执行文件路径。

/// [signatureBlockEndOffset]：签名块结束的字节偏移量，用于确定哈希计算的范围。

/// 返回：哈希值的字节数组。

static Future<Uint8List> _calculateExecutableHash(String executablePath, int signatureBlockEndOffset) async {

final file = File(executablePath);

if (!await file.exists()) {

throw FileSystemException('文件不存在', executablePath);

}

final input = file.openRead(0, signatureBlockEndOffset); // 只读取签名块之前的部分

final digest = await sha256.bind(input).first;

return Uint8List.fromList(digest.bytes);

}

/// 执行应用程序的完整性检查。

///

/// 返回：如果完整性验证成功则返回 true，否则返回 false。

static Future<bool> checkIntegrity() async {

final executablePath = Platform.executable;

print('正在检查可执行文件: $executablePath 的完整性...');

final SignatureData? signatureData = await _parseSignatureBlock(executablePath);

if (signatureData == null) {

print('❌ 完整性检查失败: 无法解析签名数据块。');

return false;

}

final fileLength = await File(executablePath).length();

// 计算签名块的起始和结束位置，相对于文件末尾的偏移

final endMagicLength = _kSignatureBlockEndMagic.length;

final startMagicLength = _kSignatureBlockStartMagic.length;

// 假设签名块的JSON内容长度

final jsonContentLength = base64.decode(signatureData.signatureBase64).length + base64.decode(signatureData.originalHashBase64).length + signatureData.publicKeyPem.length + 200; // 粗略估计JSON内容的长度，加上一些冗余

// 签名块的总长度，需要与 Python 脚本保持一致

// 实际计算时，应该精确计算 json.dumps(signature_data) 的长度，但这里我们无法获得原始 Python 脚本的精确输出

// 假设我们已经通过某种方式知道精确的签名块长度，或者从签名块中解析出它的长度

// 简化的方法是：从文件末尾向回搜索 START_MAGIC，然后计算其之前的长度

final fullFileContent = await File(executablePath).readAsBytes();

final String fullFileContentString = utf8.decode(fullFileContent, allowMalformed: true);

final startMagicIndex = fullFileContentString.lastIndexOf(_kSignatureBlockStartMagic);

if (startMagicIndex == -1) {

print('❌ 完整性检查失败: 无法在完整文件内容中找到签名块开始标记。');

return false;

}

// 用于计算哈希的文件部分结束偏移量

final executableContentEndOffset = startMagicIndex;

// 1. 计算当前可执行文件（排除签名块）的哈希值

final Uint8List runtimeHashBytes = await _calculateExecutableHash(executablePath, executableContentEndOffset);

final String runtimeHashHex = runtimeHashBytes.map((byte) => byte.toRadixString(16).padLeft(2, '0')).join();

print('运行时计算的哈希值: $runtimeHashHex');

// 2. 从签名数据中提取原始哈希和签名

final Uint8List expectedOriginalHashBytes = base64.decode(signatureData.originalHashBase64);

final Uint8List signatureBytes = base64.decode(signatureData.signatureBase64);

if (runtimeHashBytes.length != expectedOriginalHashBytes.length ||

!_compareByteLists(runtimeHashBytes, expectedOriginalHashBytes)) {

print('❌ 完整性检查失败: 运行时哈希值与签名中记录的原始哈希值不匹配。');

return false;

}

// 3. 验证数字签名

try {

final rsaPublicKey = parseRSAPublicKeyFromPem(signatureData.publicKeyPem);

final signer = RSASigner(SHA256Digest(), '0609608648016503040201'); // PSS padding OID

signer.init(false, PublicKeyParameter<RSAPublicKey>(rsaPublicKey)); // false for verification

final RSASignature rsaSignature = RSASignature(signatureBytes);

final bool isValid = signer.verifySignature(runtimeHashBytes, rsaSignature);

if (isValid) {

print('✅ 签名验证成功！二进制文件完整且来自可信源。');

return true;

} else {

print('❌ 签名验证失败！二进制文件可能已被篡改或来源不可信。');

return false;

}

} catch (e) {

print('❌ 签名验证过程中发生错误: $e');

return false;

}

/// 比较两个字节列表是否相同。

static bool _compareByteLists(Uint8List a, Uint8List b) {

if (a.length != b.length) return false;

for (int i = 0; i < a.length; i++) {

if (a[i] != b[i]) return false;

}

return true;

}

bin/main.dart

import 'package:myapp/integrity_checker.dart'; // 替换为你的库名

void main(List<String> args) async {
  print('应用程序启动...');

  // 执行完整性检查
  final bool integrityOk = await AppIntegrityChecker.checkIntegrity();

  if (!integrityOk) {
    print('应用程序完整性检查失败。正在安全退出。');
    // 在生产环境中，这里应该直接调用 exit(1)，避免任何后续代码执行
    // 或者显示一个错误对话框并强制退出
    exit(1);
  }

  print('应用程序完整性验证通过。继续执行业务逻辑...');
  // 你的应用程序核心逻辑从这里开始
  print('Hello from the trusted Dart AOT app!');
}

import 'package:myapp/integrity_checker.dart'; // 替换为你的库名

void main(List<String> args) async {

print('应用程序启动...');

// 执行完整性检查

final bool integrityOk = await AppIntegrityChecker.checkIntegrity();

if (!integrityOk) {

print('应用程序完整性检查失败。正在安全退出。');

// 在生产环境中，这里应该直接调用 exit(1)，避免任何后续代码执行

// 或者显示一个错误对话框并强制退出

exit(1);

}

print('应用程序完整性验证通过。继续执行业务逻辑...');

// 你的应用程序核心逻辑从这里开始

print('Hello from the trusted Dart AOT app!');

}

4.3 深入探讨：要哈希什么？

正如我们前面讨论的，选择要哈希的文件区域是关键。

哈希整个文件： 最简单，但如果签名和公钥嵌入在文件中，会导致循环依赖。
哈希文件特定部分（排除签名块）： 这是我们目前采用的策略。通过在文件末尾附加一个可识别的签名块，并在计算哈希时将其排除，解决了循环依赖问题。这种方法相对健壮，因为它确保了应用程序的核心逻辑未被修改。
哈希关键代码/数据段： 最复杂，需要深入了解操作系统加载器如何处理 ELF/PE/Mach-O 文件，以及哪些内存区域包含可执行代码和只读数据。这通常需要使用 dart:ffi 调用 mmap 或 VirtualQuery 等 OS API 来精确识别和读取这些段。对于跨平台 Dart 应用程序来说，实现难度极高，且维护成本大。一般不推荐在应用层直接实现。

表格：不同哈希策略的对比

策略	优点	缺点	适用场景
整个文件哈希	实现最简单，无需特殊文件解析	如果签名/公钥嵌入，会造成循环依赖；无法区分核心代码与附加数据	签名/公钥在外部存储或硬编码（但哈希包含自身）
排除签名块哈希	解决循环依赖；相对简单易实现；保护核心代码	需要约定签名块格式和位置；需要文件解析逻辑	大多数需要运行时完整性检查的 Dart AOT 应用
哈希特定代码/数据段	精确保护核心逻辑；对文件格式变化更具弹性	实现极其复杂，依赖 OS 和文件格式细节；跨平台困难	对安全性要求极高，且有足够资源投入的特定平台应用

我们选择的“排除签名块哈希”策略在实现复杂度和安全性之间取得了良好的平衡，适合大多数 Dart AOT 应用程序。

第五部分：增强韧性与对抗篡改

仅仅进行一次启动时的完整性检查是不够的。高级攻击者可能会尝试绕过这些检查。

代码混淆：
Dart AOT 编译器在发布模式下会自动进行符号混淆，使得逆向工程更困难。但是，这通常不包括字符串字面量和反射信息。可以考虑使用第三方混淆工具。

dart compile exe bin/main.dart -o my_app --obfuscate

1

dart compile exe bin/main.dart -o my_app --obfuscate

反调试与反篡改技术 (FFI)：

检测调试器： 利用 dart:ffi 调用操作系统原生 API。
- Windows： IsDebuggerPresent 或 CheckRemoteDebuggerPresent。
- Linux： 检查 /proc/self/status 中的 TracerPid 字段。
- macOS： 调用 sysctl 或 ptrace。
内存完整性检查： 定期对关键代码段在内存中的哈希进行验证。这比文件哈希更复杂，因为代码段在内存中是可执行的，可能被动态链接器修改。
代码自校验： 在程序运行时，关键函数可以在执行前计算自身的哈希并与预存值比较。

示例 (Linux 反调试简略 FFI)：

lib/native_antidebug.dart

import 'dart:ffi';
import 'dart:io';
import 'package:ffi/ffi.dart';

// 定义 C 函数签名
typedef _IsDebuggerPresentC = Int32 Function();
typedef _IsDebuggerPresentDart = int Function();

// 加载 libc 库
final DynamicLibrary _libc = Platform.isLinux || Platform.isAndroid
    ? DynamicLibrary.open('libc.so.6')
    : (Platform.isMacOS
        ? DynamicLibrary.open('libc.dylib')
        : (Platform.isWindows
            ? DynamicLibrary.open('kernel32.dll') // Windows 示例
            : throw UnsupportedError('Unsupported platform')));

// 查找并绑定 C 函数 (这里以 Linux /proc/self/status 为例，非直接 C 函数)
// 实际的 IsDebuggerPresent 在 Windows 上是 Kernel32.dll
// 对于 Linux，通常通过解析 /proc/self/status 文件来判断 TracerPid
// 我们这里提供一个模拟的 FFI 结构，实际需要写一个 C helper lib

// 真正的 Linux 反调试需要通过 C 语言读取 /proc/self/status
// 例如：
// int is_debugger_present_linux() {
//     char buf[1024];
//     FILE *fp = fopen("/proc/self/status", "r");
//     if (fp == NULL) return 0;
//     while (fgets(buf, sizeof(buf), fp) != NULL) {
//         if (strncmp(buf, "TracerPid:", 10) == 0) {
//             int pid = atoi(buf + 11);
//             fclose(fp);
//             return pid != 0;
//         }
//     }
//     fclose(fp);
//     return 0;
// }

// Dart FFI 绑定到上述 C 函数
// 假设我们有一个 C 库 `libantidebug.so` 包含了 `is_debugger_present_linux`
// final DynamicLibrary _antiDebugLib = DynamicLibrary.open('libantidebug.so');
// final _isDebuggerPresent = _antiDebugLib.lookupFunction<_IsDebuggerPresentC, _IsDebuggerPresentDart>('is_debugger_present_linux');

class AntiTamper {
  static bool isDebuggerPresent() {
    if (Platform.isWindows) {
      // Windows: Call IsDebuggerPresent from kernel32.dll
      // final _isDebuggerPresentWindows = _libc.lookupFunction<_IsDebuggerPresentC, _IsDebuggerPresentDart>('IsDebuggerPresent');
      // return _isDebuggerPresentWindows() != 0;
      print('Windows 反调试检测未实现 FFI 绑定，模拟返回 false');
      return false; // 示例，实际需要 FFI 绑定
    } else if (Platform.isLinux || Platform.isAndroid || Platform.isMacOS) {
      // Linux/macOS: Read /proc/self/status (or equivalent)
      // For simplicity, directly read file here, but FFI to C is more robust
      try {
        final statusFile = File('/proc/self/status');
        if (statusFile.existsSync()) {
          final content = statusFile.readAsStringSync();
          final lines = content.split('n');
          for (final line in lines) {
            if (line.startsWith('TracerPid:')) {
              final pidStr = line.substring('TracerPid:'.length).trim();
              final pid = int.tryParse(pidStr);
              if (pid != null && pid != 0) {
                print('检测到调试器 (TracerPid: $pid)');
                return true;
              }
            }
          }
        }
      } catch (e) {
        print('读取 /proc/self/status 失败: $e');
      }
      return false;
    } else {
      print('当前平台不支持调试器检测。');
      return false;
    }
  }

  static void runAntiTamperChecks() {
    if (isDebuggerPresent()) {
      print('警告: 检测到调试器。应用程序将终止以保护完整性。');
      exit(1);
    }
    // 更多反篡改检查...
  }
}

import 'dart:ffi';

import 'dart:io';

import 'package:ffi/ffi.dart';

// 定义 C 函数签名

typedef _IsDebuggerPresentC = Int32 Function();

typedef _IsDebuggerPresentDart = int Function();

// 加载 libc 库

final DynamicLibrary _libc = Platform.isLinux || Platform.isAndroid

? DynamicLibrary.open('libc.so.6')

: (Platform.isMacOS

? DynamicLibrary.open('libc.dylib')

: (Platform.isWindows

? DynamicLibrary.open('kernel32.dll') // Windows 示例

: throw UnsupportedError('Unsupported platform')));

// 查找并绑定 C 函数 (这里以 Linux /proc/self/status 为例，非直接 C 函数)

// 实际的 IsDebuggerPresent 在 Windows 上是 Kernel32.dll

// 对于 Linux，通常通过解析 /proc/self/status 文件来判断 TracerPid

// 我们这里提供一个模拟的 FFI 结构，实际需要写一个 C helper lib

// 真正的 Linux 反调试需要通过 C 语言读取 /proc/self/status

// 例如：

// int is_debugger_present_linux() {

// char buf[1024];

// FILE *fp = fopen("/proc/self/status", "r");

// if (fp == NULL) return 0;

// while (fgets(buf, sizeof(buf), fp) != NULL) {

// if (strncmp(buf, "TracerPid:", 10) == 0) {

// int pid = atoi(buf + 11);

// fclose(fp);

// return pid != 0;

// }

// fclose(fp);

// return 0;

// }

// Dart FFI 绑定到上述 C 函数

// 假设我们有一个 C 库 `libantidebug.so` 包含了 `is_debugger_present_linux`

// final DynamicLibrary _antiDebugLib = DynamicLibrary.open('libantidebug.so');

// final _isDebuggerPresent = _antiDebugLib.lookupFunction<_IsDebuggerPresentC, _IsDebuggerPresentDart>('is_debugger_present_linux');

class AntiTamper {

static bool isDebuggerPresent() {

if (Platform.isWindows) {

// Windows: Call IsDebuggerPresent from kernel32.dll

// final _isDebuggerPresentWindows = _libc.lookupFunction<_IsDebuggerPresentC, _IsDebuggerPresentDart>('IsDebuggerPresent');

// return _isDebuggerPresentWindows() != 0;

print('Windows 反调试检测未实现 FFI 绑定，模拟返回 false');

return false; // 示例，实际需要 FFI 绑定

} else if (Platform.isLinux || Platform.isAndroid || Platform.isMacOS) {

// Linux/macOS: Read /proc/self/status (or equivalent)

// For simplicity, directly read file here, but FFI to C is more robust

try {

final statusFile = File('/proc/self/status');

if (statusFile.existsSync()) {

final content = statusFile.readAsStringSync();

final lines = content.split('n');

for (final line in lines) {

if (line.startsWith('TracerPid:')) {

final pidStr = line.substring('TracerPid:'.length).trim();

final pid = int.tryParse(pidStr);

if (pid != null && pid != 0) {

print('检测到调试器 (TracerPid: $pid)');

return true;

}

} catch (e) {

print('读取 /proc/self/status 失败: $e');

}

return false;

} else {

print('当前平台不支持调试器检测。');

return false;

}

static void runAntiTamperChecks() {

if (isDebuggerPresent()) {

print('警告: 检测到调试器。应用程序将终止以保护完整性。');

exit(1);

}

// 更多反篡改检查...

}

在 main.dart 中调用 AntiTamper.runAntiTamperChecks() 即可。

多点检查与冗余：
不要只在启动时检查一次。在应用程序的关键操作之前、定期（例如每隔几分钟）或在访问敏感数据时，都可以重新触发完整性检查。如果每次都进行完整的哈希计算，性能会是问题，可以考虑哈希更小的关键模块。
安全退出机制：
当检测到篡改时，程序应该以一种难以被攻击者拦截或绕过的方式终止。例如，不直接调用 exit(0) 或 exit(1)，而是触发一个硬件级别的重启，或者通过注入一个非法指令来导致程序崩溃（但这可能导致不友好的用户体验）。
密钥保护：
公钥虽然公开，但如果攻击者能够替换应用程序中的公钥，并用自己的私钥重新签名，那么整个机制就失效了。因此，公钥的存储和加载过程也需要尽可能地安全。
- 硬编码： 简单但容易被替换。
- 加密存储： 在运行时解密公钥，但密钥管理又成为新问题。
- 远程获取： 从受信任的服务器获取公钥，但需要安全通信通道。
- 硬件安全模块 (HSM) 或可信平台模块 (TPM)： 在嵌入式设备或某些服务器环境中，可以利用这些硬件来安全存储和使用密钥。

第六部分：限制、权衡与未来方向

6.1 固有局限性

没有绝对安全： 任何客户端侧的保护措施都可能被足够专业的攻击者绕过。攻击者拥有对执行环境的完全控制权，可以修改内存、替换文件、绕过 API 调用。
性能开销： 运行时哈希计算和签名验证会引入启动延迟。对于大型应用程序，这可能是一个显著的考虑因素。
复杂性： 跨平台实现文件解析、FFI 调用、反调试等技术会大大增加开发和维护的复杂性。
误报风险： 某些系统工具（如防病毒软件、系统更新）可能在不改变应用程序恶意性的情况下修改二进制文件，导致误报。

6.2 权衡与选择

在实际项目中，我们需要根据应用程序的敏感程度、目标用户群体、开发资源和性能要求来权衡这些因素。

对于大多数通用应用程序，我们实现的这种“排除签名块哈希”的启动时检查，结合 Dart 自身的混淆，已经能够提供一个不错的安全基线。
对于金融、游戏等高价值目标应用程序，可能需要投入更多资源，探索更深层次的反调试、内存保护和多点检查策略。

6.3 未来方向与高级安全机制

远程认证 (Remote Attestation)： 应用程序在启动时向远程服务器证明其自身的完整性。服务器验证成功后，才允许应用程序继续执行核心功能或提供敏感数据。这依赖于可信计算基 (TCB) 和安全通信。
可信平台模块 (TPM) / 安全启动 (Secure Boot)： 在硬件层面，TPM 和 UEFI Secure Boot 可以在操作系统启动前验证整个软件栈的完整性，从而为应用程序提供一个更可信的执行环境。
硬件安全模块 (HSM)： 对于私钥的存储和签名操作，HSM 提供了最高级别的物理和逻辑保护，防止私钥泄露。

结语

Dart AOT 二进制文件的运行时完整性检查是一项多层次、持续演进的工作。通过深入理解密码学原理，精心设计签名与验证架构，并结合适当的反篡改技术，我们能够显著提升 Dart 应用程序的安全性。但这并非一劳永逸，我们需要时刻警惕新的攻击手段，并不断迭代和完善我们的安全防御策略，以应对日益复杂的网络威胁。安全性始终是一个动态平衡的过程，需要开发者社区的共同努力和持续投入。