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

API 版本迭代，怎么进行 API 多版本处理？

API 版本迭代是在软件开发过程中非常常见的一种需求，尤其对于 Web API 来说，随着业务需求的不断变化和技术的发展，API 的版本迭代变得愈发重要。API 版本迭代的目的是为了满足不断变化的业务需求、修复缺陷和改进功能，同时保持向后兼容性。然而，随着多个版本的 API 共存，如何进行多版本处理成为了必不可少的问题。

为什么需要进行版本迭代？

向后兼容性：在引入新功能或修改现有功能的同时，应该尽可能保持与现有版本的 API 的兼容，避免对已有客户端和应用程序的影响。
兼容性测试：为了确保新版本 API 的稳定性，需要进行兼容性测试。可以通过多版本处理来降低测试的成本和风险。
用户体验：通过多版本处理来提供更好的用户体验，向用户和开发者提供更多的选择和灵活性，使其能够逐步升级到新版本而不会影响其业务。
因此，API 多版本处理对于确保系统的稳定性、提高开发效率和用户体验至关重要。

常见的 API 迭代模式

API 版本迭代需要进行版本控制，以便开发者和用户能清晰地了解各个版本之间的差异和兼容性情况。常见的 API 版本迭代模式包括语义版本控制（Semantic Versioning），它是一种广泛应用于软件开发领域的版本号命名规范。

语义版本控制将版本号分为主版本号、次版本号和修订号三个部分，分别代表了不同层次的变化：

主版本号：当你做了不兼容的 API 修改时，需要升级主版本号。
次版本号：当你做了向下兼容的功能性新增时，需要升级次版本号。
修订号：当你做了向下兼容的问题修正时，需要升级修订号。
语义版本控制的优点在于，通过版本号的规范化命名，能够清晰地表达版本之间的关系和变化。开发者和用户可以根据版本号了解这个版本带来了什么样的变化，以及对其现有应用的影响。这有助于提高版本变更的可预测性和透明度。

多版本处理的挑战

多版本处理是 API 设计中常见的问题之一。当 API 需要支持多个版本时，可能会遇到以下挑战：

兼容性：不同版本的 API 可能存在不兼容的情况，导致客户端无法访问或使用所需版本的 API。
功能冲突：不同版本的 API 可能包含不同的功能，导致客户端在使用不同版本的 API 时遇到功能冲突。
对用户的影响：API 版本的变化可能会对用户的使用体验产生影响，例如用户需要升级客户端软件或重新学习如何使用 API。
对开发者的影响：API 版本的变化可能会给开发者带来额外的开发和维护工作，例如开发者需要维护多个版本的 API 文档和代码库。

解决方案一：URI 版本控制

URI 版本控制是一种通过在 API 的 URI 中包含版本号来区分不同版本的 API 的方法。这种方法简单易懂，并且支持大部分客户端工具。

解决方案	URI 版本控制
概念	API 版本作为 URI 的一部分，如`/api/v1/users`表示第一个版本，`/api/v2/users`表示第二个版本。客户端通过在请求中指定 URI 版本号选择 API 版本。
优点	简单易懂：概念直观，易于理解。
	广泛支持：得到大部分客户端工具支持，包括浏览器、HTTP 客户端库和 RESTful API 框架。
	独立部署：不同 API 版本可独立部署，有利于开发和维护。
缺点	冗长：每个 URI 中包含版本号导致 URI 冗长。
	版本冲突：存在不同 API 版本时可能发生冲突，导致客户端无法访问所需版本。
	难以发现：URI 中包含版本号可能使客户端难以发现新 API 版本。
适用场景	API 版本较少且不经常更新。
	客户端工具支持 URI 版本控制。
	API 需要与多种客户端工具兼容。

解决方案二：标头版本控制

标头版本控制是一种通过在请求头中包含版本号来区分不同版本的 API 的方法。这种方法与 URI 版本控制相似，但更加灵活，并且可以支持更多类型的客户端工具。

解决方案	标头版本控制
概念	API 版本作为请求头的一部分，例如，使用`Accept: application/json; version=2`表示客户端请求使用 API 的第二个版本。服务器根据请求头中的版本号选择 API 版本。
优点	灵活：更加灵活，支持多种客户端工具，包括浏览器、HTTP 客户端库和 RESTful API 框架。
	版本独立：与 URI 无关，不同 API 版本可以在同一个 URI 上部署。
	易于发现：通过请求头可以发现新的 API 版本。
缺点	复杂性：概念较复杂，可能需要客户端工具特殊处理。
	兼容性：需要客户端工具支持，否则无法使用。
	性能：可能影响性能，因为服务器需要额外处理请求头。
适用场景	API 版本较多且经常更新。
	客户端工具支持标头版本控制。
	API 需要与多种类型的客户端工具兼容。

解决方案三：内容协商

内容协商是一种根据客户端的需求动态选择合适的 API 版本的机制。这种机制允许客户端在请求中指定它支持的 API 版本，然后服务器根据客户端支持的版本选择要使用的 API 版本。

解决方案	内容协商
概念	根据客户端需求动态选择合适的 API 版本，通过 HTTP 协议中的`Accept和Content-Type`请求头指定客户端支持的版本和内容类型。服务器根据请求头信息选择 API 版本和内容类型。
优点	动态选择：允许客户端动态选择合适的 API 版本，更容易适应客户端需求。
	兼容性：允许客户端使用不同的 API 版本，提高 API 兼容性。
	性能：提高性能，服务器可以根据客户端需求选择最合适的 API 版本和内容类型。
缺点	复杂性：概念较复杂，需要客户端工具和服务器特殊处理。
	兼容性：需要客户端工具和服务器都支持内容协商，否则无法使用。
适用场景	API 版本较多且经常更新。
	客户端工具和服务器都支持内容协商。
	API 需要与多种类型的客户端工具兼容。

通过 Apifox 进行版本控制

Apifox 是一个集接口文档、API 调试、自动化测试、Mock 服务等功能于一体的综合 API 开发协作工具。Apifox = Postman + Swagger + Mock + JMeter，Apifox 支持调试 http(s)、WebSocket、Socket、gRPC、Dubbo 等协议的接口，并且集成了 IDEA 插件。

原始链接

API 版本迭代，怎么进行 API 多版本处理？

macOS 26 系统如何在聚焦搜索中不显示 iPhone App

在 macOS 26 系统中，Apple 增强了「聚焦搜索」（Spotlight）的功能。如果你启用了 iPhone 镜像，系统会自动将 iPhone 上的应用程序同步到 Mac 的聚焦搜索结果中，方便直接在 Mac 上快速启动或查找。

如下图：

继续阅读macOS 26 系统如何在聚焦搜索中不显示 iPhone App

商用密码32款认证产品、功能及认证依据详细介绍

为贯彻落实《中华人民共和国密码法》,建立完善商用密码产品认证体系，市场监管总局、国家密码管理局根据《国家密码管理局市场监管总局关于调整商用密码产品管理方式的公告》（第39号）分别于2020年、2022年及2025年连续发布三次商用密码产品目录，相关商用密码认证检测均依据此目录进行产品检测、认证。

以下是截止2025年3月27日，全量商用密码产品门类/目录，看看哪些是大家所了解和擅长的密码产品，具体如下：

第一批商用密码产品名录

市场监管总局国家密码管理局于2020年5月11日发布《商用密码产品认证目录（第一批）》，具体如下：

1、智能密码钥匙

产品名称：智能密码钥匙
功能描述：实现密码运算、密钥管理功能的终端密码设备，一般使用 USB 接口形态。
认证依据：

1）GM/T 0027《智能密码钥匙技术规范》

2）GM/T 0028《密码模块安全技术要求》

2、智能 IC 卡

产品名称：智能 IC 卡
功能描述：实现密码运算和密钥管理功能的含 CPU 的集成电路卡，包括应用于金融等行业领域的智能 IC 卡。
认证依据：

1）GM/T 0028《密码模块安全技术要求》

2）GM/T 0041《智能 IC 卡密码检测规范》

3、POS/ATM/多功能/互联网终端密码应用系统

产品名称：POS 密码应用系统、ATM 密码应用系统、多功能密码应用系统、互联网终端
功能描述：为金融终端设备提供密码服务的密码应用系统。
认证依据：

1）GM/T 0028《密码模块安全技术要求》

2）JR/T 0025-2018《中国金融集成电路 (IC) 卡规范第 7 部分：借记贷记应用安全规范》

4、PCI-E/PCI 密码卡

产品名称：PCI-E/PCI 密码卡
功能描述：具有密码运算功能和自身安全保护功能的 PCI 硬件板卡设备。
认证依据：

1）GM/T 0018《密码设备应用接口规范》

2）GM/T 0028《密码模块安全技术要求》

3）《PCI 密码卡技术规范》

5、IPSec VPN 产品 / 安全网关

产品名称：IPSec VPN 产品 / IPSec VPN 安全网关
功能描述：基于 IPSec 协议，在通信网络中构建安全通道的设备。
认证依据：

1）GM/T 0022《IPSec VPN 技术规范》

2）GM/T 0023《IPSec VPN 网关产品规范》

3）GM/T 0028《密码模块安全技术要求》

6、SSL VPN 产品 / 安全网关

产品名称：SSL VPN 产品 / SSL VPN 安全网关
功能描述：基于 SSL/TLS 协议，在通信网络中构建安全通道的设备。
认证依据：

1）GM/T 0024《SSL VPN 技术规范》

2）GM/T 0025《SSL VPN 网关产品规范》

3）GM/T 0028《密码模块安全技术要求》

7. 安全认证网关

产品名称：安全认证网关
功能描述：采用数字证书为应用系统提供用户管理、身份鉴别、单点登录、传输加密、访问控制和安全审计服务的设备。
认证依据：

1）GM/T 0026《安全认证网关产品规范》

2）GM/T 0028《密码模块安全技术要求》

8、密码键盘

产品名称：密码键盘
功能描述：用于保护 PIN 输入安全并对 PIN 进行加密的独立式密码模块。
认证依据：

1）GM/T 0028《密码模块安全技术要求》

2）GM/T 0049《密码键盘密码检测规范》

9、金融数据密码机

产品名称：金融数据密码机
功能描述：用于确保金融数据安全，实现 PIN 加密、MAC 产生与校验、签名验证等密码服务功能的设备。
认证依据：

1）GM/T 0028《密码模块安全技术要求》

2）GM/T 0045《金融数据密码机技术规范》

10、服务器密码机

产品名称：服务器密码机
功能描述：能独立或并行为多个应用实体提供密码运算、密钥管理等功能的设备。
认证依据：

1）GM/T 0028《密码模块安全技术要求》

2）GM/T 0030《服务器密码机技术规范》

11、签名验签服务器

产品名称：签名验签服务器
功能描述：为应用实体提供基于 PKI 体系的数字签名、验证签名等运算功能的服务器。
认证依据：

1）GM/T 0028《密码模块安全技术要求》

2）GM/T 0029《签名验签服务器技术规范》

12、时间戳服务器

产品名称：时间戳服务器
功能描述：基于公钥密码基础设施应用技术体系框架内的时间戳服务相关设备。
认证依据：

1）GM/T 0028《密码模块安全技术要求》

2）GM/T 0033《时间戳接口规范》

13、安全门禁系统

产品名称：安全门禁系统
功能描述：采用密码技术，确定用户身份和用户权限的门禁控制系统。
认证依据：

GM/T 0036《采用非接触卡的门禁系统密码应用技术指南》

14、动态令牌 / 动态令牌认证系统

产品名称：动态令牌 / 动态令牌认证系统
功能描述：生成并验证动态口令的载体与系统。
认证依据：

1）GM/T 0021《动态口令密码应用技术规范》

2）GM/T 0028《密码模块安全技术要求》（仅适用于动态令牌）

15、安全电子签章系统

产品名称：安全电子签章系统
功能描述：提供电子印章管理、电子签章/验章等功能的密码应用系统。
认证依据：

1）GM/T 0031《安全电子签章密码技术规范》

2）GM/T 0055《电子文件密码应用技术规范》

16、电子文件密码应用系统

产品名称：电子文件密码应用系统
功能描述：在电子文件全生命周期中提供密码运算、密钥管理等功能的应用系统。
认证依据：

GM/T 0055《电子文件密码应用技术规范》

17、可信计算密码支撑平台

产品名称：可信计算密码支撑平台
功能描述：为可信计算平台提供完整性、身份可信性和数据安全性密码支持。
认证依据：

1）GM/T 0011《可信计算密码支撑平台功能与接口规范》

2）GM/T 0012《可信计算可信密码模块接口规范》

3）GM/T 0028《密码模块安全技术要求》

4）GM/T 0058《可信计算 TCM 服务模块接口规范》

18、证书认证系统 / 证书认证密钥管理系统

产品名称：证书认证系统 / 证书认证密钥管理系统
功能描述：用于数字证书全生命周期管理与密钥对全过程管理的系统。
认证依据：

GM/T 0034《基于 SM2 密码算法的证书认证系统密码及其相关安全技术规范》

19、对称密钥管理产品

产品名称：对称密钥管理产品
功能描述：为密码应用系统生产、分发和管理对称密钥的系统及设备。
认证依据：

GM/T 0051《密码设备管理对称密钥管理技术规范》

20、安全芯片

产品名称：安全芯片
功能描述：含密码算法、安全功能，可实现密钥管理机制的集成电路芯片。
认证依据：

GM/T 0008《安全芯片密码检测准则》

21、电子标签芯片

产品名称：电子标签芯片
功能描述：采用密码技术，用于射频识别的电子识别信息芯片。
认证依据：

GM/T 0035.2《射频识别系统密码应用技术要求第 2 部分：电子标签芯片密码应用技术要求》

22、其他密码模块

产品名称：其他密码模块
功能描述：实现密码运算、密钥管理等功能的软件、硬件、固件及其组合。
认证依据：

GM/T 0028《密码模块安全技术要求》

//第二批商用密码产品名录

市场监管总局国家密码管理局于2022年7月14日发布《商用密码产品认证目录（第二批）》，具体如下：

23、可信密码模块

产品名称：可信密码模块
功能描述：为可信计算平台提供密码运算功能，具有受保护存储空间的硬件模块。
认证依据：

1）GM/T 0012《可信计算可信密码模块接口规范》

2）GM/T 0028《密码模块安全技术要求》

24、智能 IC 卡密钥管理系统

产品名称：智能 IC 卡密钥管理系统
功能描述：统一管理智能 IC 卡应用的密钥生命周期，为业务系统提供密钥服务。
认证依据：

GM/T 0107《智能 IC 卡密钥管理系统基本技术要求》

25、云服务器密码机

产品名称：云服务器密码机
功能描述：通过虚拟化技术为多租户提供密码服务的云形态服务器密码机。
认证依据：

1）GM/T 0028《密码模块安全技术要求》

2）GM/T 0104《云服务器密码机技术规范》

26、随机数发生器

产品名称：随机数发生器（软件 / 硬件）
功能描述：生成随机二元序列的程序或器件。
认证依据：

- 软件：

1）GM/T 0028《密码模块安全技术要求》

2）GM/T 0103《随机数发生器总体框架》

3）GM/T 0105《软件随机数发生器设计指南》

- 硬件：

1）GM/T 0028《密码模块安全技术要求》

2）GM/T 0078《密码随机数生成模块设计指南》

3）GM/T 0103《随机数发生器总体框架》

27、区块链密码模块

产品名称：区块链密码模块
功能描述：提供用户安全、共识安全、账本保护、隐私保护、身份认证等密码功能。
认证依据：

1）GM/T 0028《密码模块安全技术要求》

2）GM/T 0111《区块链密码应用技术要求》

28、安全浏览器密码模块

产品名称：安全浏览器密码模块
功能描述：集成浏览器内核与密码协议逻辑，保障浏览器场景下的密码安全。
认证依据：

1）GB/T 38636《信息安全技术传输层密码协议（TLCP）》

2）GM/T 0028《密码模块安全技术要求》

3）GM/T 0086《基于 SM9 标识密码算法的密钥管理系统技术规范》

4）GM/T 0087《浏览器密码应用接口规范》

//第三批商用密码产品名录

市场监管总局国家密码管理局于2025年3月27日发布《商用密码产品认证目录（第三批）》，具体如下：

29、基于 SM9 标识密码算法的密钥管理系统

产品名称：基于 SM9 标识密码算法的密钥管理系统
功能描述：实现标识密钥注册、生成、管理、发布的信息系统。
认证依据：

GM/T 0086《基于 SM9 标识密码算法的密钥管理系统技术规范》

30、PLC 控制器密码模块

产品名称：PLC 控制器密码模块
功能描述：为 PLC 控制器提供密钥存储、密码安全服务及与后台安全管理服务器交互功能的设备。
认证依据：

1）GM/T 0028《密码模块安全技术要求》

2）GM/T 0119《PLC 控制系统及 PLC 控制器密码应用技术规范》

31、DTLCP 密码模块

产品名称：DTLCP 密码模块
功能描述：基于数据报传输层密码协议（DTLCP），构建安全通信通道的设备。
认证依据：

1）GM/T 0028《密码模块安全技术要求》

2）GM/T 0128《数据报传输层密码协议规范》

32、SSH 客户端密码模块 / SSH 服务端密码模块

产品名称：SSH 客户端密码模块 / SSH 服务端密码模块
功能描述：基于 SSH 协议，提供安全远程登录和网络服务的设备。
认证依据：

1）GM/T 0028《密码模块安全技术要求》

2）GM/T 0129《SSH 密码协议规范》

参考链接

商用密码32款认证产品、功能及认证依据详细介绍

WebDAV服务不能下载大文件，文件超过50M报错[0x800700DF]怎么办？

解除50M文件限制，Windows访问服务时，大于50M文件提示错误[错误:0x800700DF]

继续阅读WebDAV服务不能下载大文件，文件超过50M报错[0x800700DF]怎么办？

Flutter桌面端-应用启动后占满屏幕

前置条件

MacBook Pro M2 macOS Tahoe (26.0) / Windows 11 24H2
Flutter 3.35.3

功能需求

以目前的情况来看，Flutter 的桌面端软件其实跟移动端软件很像，因为 Flutter 桌面端目前默认只有一个窗口，而不是像原生的桌面端软件一样，经常会有很多个窗口。比较不一样的是，移动端是直接全屏显示，桌面端的软件是以窗口的形式存在的。

而桌面端窗口大小可以设置，还可以由用户自由放大缩小。

所以一般桌面端软件都需要对窗口做一些配置，比如设置启动时的默认窗口大小以达到最佳的界面显示，设置最小的窗口大小来避免界面变形严重或者遮盖了重要界面等等。

我们希望应用启动后就占据整个屏幕，但是不是最大化，顶部状态栏，底部不要进行覆盖，类似 Chrome 浏览器的行为。

解决方法

可以使用 window_manager 插件来实现，但是发现达不到想要的效果。

后面发现 learnFlutter 还有一个开源库是 screen_retriever ，这个插件允许 Flutter 桌面应用检索关于屏幕大小，显示，光标位置等信息。

试了下确实可以获取到屏幕的高度，可行的实现方式是使用 screen_retriever 获取到屏幕的高度之后再使用window_manager 设置窗口大小。

但是，上述的代码由于需要 Flutter 引擎初始化之后才能执行，因此会短暂先出现小窗口，然后窗口才会变大。整个过程中有明显的延迟，用户体验不好。

因此，还是需要从底层API层面进行窗口大小的调整，应用启动后，窗口大小立即调整完成，用户体验较好。

macOS 解决方案

方案一：

通过调用 NSWindow 的 zoom 函数，实现窗口的放大。代码如下：

import Cocoa
import FlutterMacOS

@main
class AppDelegate: FlutterAppDelegate {
    
    override func applicationDidFinishLaunching(_ notification: Notification) {
        mainFlutterWindow?.zoom(nil)
    }
    
    override func applicationShouldTerminateAfterLastWindowClosed(_ sender: NSApplication) -> Bool {
        return true
    }
    
    override func applicationSupportsSecureRestorableState(_ app: NSApplication) -> Bool {
        return true
    }
}

import Cocoa

import FlutterMacOS

@main

class AppDelegate: FlutterAppDelegate {

override func applicationDidFinishLaunching(_ notification: Notification) {

mainFlutterWindow?.zoom(nil)

}

override func applicationShouldTerminateAfterLastWindowClosed(_ sender: NSApplication) -> Bool {

return true

}

override func applicationSupportsSecureRestorableState(_ app: NSApplication) -> Bool {

return true

}

方案二：

通过调整 NSWindow 的 visibleFrame ，实现窗口的放大。代码如下：

import Cocoa
import FlutterMacOS

@main
class AppDelegate: FlutterAppDelegate {
    
    override func applicationDidFinishLaunching(_ notification: Notification) {
        // Get the main screen's visible frame                 
        if let screenFrame = NSScreen.main?.visibleFrame {
            // Set the window's frame to match the screen's visible frame
            mainFlutterWindow?.setFrame(screenFrame, display: true)
        }
    }
    
    override func applicationShouldTerminateAfterLastWindowClosed(_ sender: NSApplication) -> Bool {
        return true
    }
    
    override func applicationSupportsSecureRestorableState(_ app: NSApplication) -> Bool {
        return true
    }
}

import Cocoa

import FlutterMacOS

@main

class AppDelegate: FlutterAppDelegate {

override func applicationDidFinishLaunching(_ notification: Notification) {

// Get the main screen's visible frame

if let screenFrame = NSScreen.main?.visibleFrame {

// Set the window's frame to match the screen's visible frame

mainFlutterWindow?.setFrame(screenFrame, display: true)

}

override func applicationShouldTerminateAfterLastWindowClosed(_ sender: NSApplication) -> Bool {

return true

}

override func applicationSupportsSecureRestorableState(_ app: NSApplication) -> Bool {

return true

}

方案三（推荐）：

调整 MainFlutterWindow 的代码，直接设置窗口大小：

import Cocoa
import FlutterMacOS

class MainFlutterWindow: NSWindow {
  override func awakeFromNib() {
    let flutterViewController = FlutterViewController.init()
    // let windowFrame = self.frame
    self.contentViewController = flutterViewController
    // self.setFrame(windowFrame, display: true)

    // 设置窗口启动后铺满整个屏幕
    // Get the main screen's visible frame
    if let screenFrame = NSScreen.main?.visibleFrame {
        // Set the window's frame to match the screen's visible frame
        self.setFrame(screenFrame, display: true)
    } else {
        let windowFrame = self.frame
        self.setFrame(windowFrame, display: true)
    }

    RegisterGeneratedPlugins(registry: flutterViewController)

    super.awakeFromNib()
  }
}

import Cocoa

import FlutterMacOS

class MainFlutterWindow: NSWindow {

override func awakeFromNib() {

let flutterViewController = FlutterViewController.init()

// let windowFrame = self.frame

self.contentViewController = flutterViewController

// self.setFrame(windowFrame, display: true)

// 设置窗口启动后铺满整个屏幕

// Get the main screen's visible frame

if let screenFrame = NSScreen.main?.visibleFrame {

// Set the window's frame to match the screen's visible frame

self.setFrame(screenFrame, display: true)

} else {

let windowFrame = self.frame

self.setFrame(windowFrame, display: true)

}

RegisterGeneratedPlugins(registry: flutterViewController)

super.awakeFromNib()

}

Windows 解决方案

Windows 系统下的解决方案比较简单，直接修改 ShowWindow 函数的参数，设置为 SW_MAXIMIZE 即可。代码如下：

.....................................................

bool Win32Window::Show() {
  return ShowWindow(window_handle_, /*SW_SHOWNORMAL*/ SW_MAXIMIZE);
}

.....................................................

.....................................................

bool Win32Window::Show() {

return ShowWindow(window_handle_, /*SW_SHOWNORMAL*/ SW_MAXIMIZE);

}

.....................................................

Linux 解决方案

Linux 系统下的使用的是 GTK，因此可以通过在初始化窗口之前调用 gtk_window_maximize 函数即可（此函数支持窗口显示之前调用）。代码如下：

// Implements GApplication::activate.
static void my_application_activate(GApplication *application) {

    ................................................................

    const int64_t window_width = 1280;
    const int64_t window_height = 720;
    gtk_window_set_default_size(window, window_width, window_height);

    // 设置窗口最大化
    gtk_window_maximize(window);

    gtk_widget_show(GTK_WIDGET(window));

    ................................................................

}

// Implements GApplication::activate.

static void my_application_activate(GApplication *application) {

................................................................

const int64_t window_width = 1280;

const int64_t window_height = 720;

gtk_window_set_default_size(window, window_width, window_height);

// 设置窗口最大化

gtk_window_maximize(window);

gtk_widget_show(GTK_WIDGET(window));

................................................................

}

参考链接

Microsoft Store初始化失败

前置条件

Windows 11 家庭中文版 24H2 操作系统版本 26100.6584

继续阅读Microsoft Store初始化失败

Android页面内嵌入FlutterView

随着 Flutter 的流行，越来越多的开发者希望在现有的 Android 应用中引入 Flutter 的功能。本文将介绍如何在Android 应用中嵌入 Flutter View，并提供示例代码来帮助开发者快速上手。

1. 环境准备

在开始之前，请确保您已安装以下工具：

Android Studio
Flutter SDK

首先，您需要在您的 Android 应用中添加 Flutter 依赖。在 build.gradle 文件中添加 Flutter 相关的依赖：

dependencies {
    implementation 'io.flutter:flutter_embedding_debug:1.0.0' // 请根据具体版本调整
}

dependencies {

implementation 'io.flutter:flutter_embedding_debug:1.0.0' // 请根据具体版本调整

}

2. 创建Flutter Module

接下来，您需要创建一个 Flutter 模块。在命令行中运行以下命令：

flutter create -t module flutter_module

1	flutter create -t module flutter_module

这将创建一个名为 flutter_module 的 Flutter 模块。

3. 在Android中集成Flutter

3.1 修改Android原生代码

在您的 Android 项目中，首先需要设置 Flutter 引擎。在 Acticity 的 onCreate 方法中，添加如下代码来初始化 Flutter：

import io.flutter.embedding.android.FlutterActivity;
import io.flutter.embedding.engine.FlutterEngine;
import io.flutter.plugin.common.MethodChannel;

public class MainActivity extends AppCompatActivity {
    private static final String CHANNEL = "com.example.channel";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        // Initialize Flutter Engine
        FlutterEngine flutterEngine = new FlutterEngine(this);
        flutterEngine.getDartExecutor().executeDartEntrypoint(
            DartExecutor.DartEntrypoint.createDefault()
        );

        // Set up MethodChannel to communicate between Android and Flutter
        new MethodChannel(flutterEngine.getDartExecutor().getBinaryMessenger(), CHANNEL)
            .setMethodCallHandler((call, result) -> {
                // Handle method calls from Flutter here
            });

        // Start FlutterActivity
        FlutterActivity.withCachedEngine("my_engine_id")
            .startActivity(this);
    }
}

import io.flutter.embedding.android.FlutterActivity;

import io.flutter.embedding.engine.FlutterEngine;

import io.flutter.plugin.common.MethodChannel;

public class MainActivity extends AppCompatActivity {

private static final String CHANNEL = "com.example.channel";

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

// Initialize Flutter Engine

FlutterEngine flutterEngine = new FlutterEngine(this);

flutterEngine.getDartExecutor().executeDartEntrypoint(

DartExecutor.DartEntrypoint.createDefault()

);

// Set up MethodChannel to communicate between Android and Flutter

new MethodChannel(flutterEngine.getDartExecutor().getBinaryMessenger(), CHANNEL)

.setMethodCallHandler((call, result) -> {

// Handle method calls from Flutter here

});

// Start FlutterActivity

FlutterActivity.withCachedEngine("my_engine_id")

.startActivity(this);

}

3.2 在XML布局中添加FlutterView

接下来，您可以在 XML 布局中添加 FlutterView。这里是一个示例布局：

<RelativeLayout xmlns:android="
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <io.flutter.embedding.android.FlutterView
        android:id="@+id/flutter_view"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />
</RelativeLayout>

<RelativeLayout xmlns:android="

android:layout_width="match_parent"

android:layout_height="match_parent">

<io.flutter.embedding.android.FlutterView

android:id="@+id/flutter_view"

android:layout_width="match_parent"

android:layout_height="match_parent" />

</RelativeLayout>

3.3 Flutter View的显示

在设置好布局后，您需要在 Java 代码中加载 FlutterView 并显示它：

FlutterView flutterView = findViewById(R.id.flutter_view);
flutterView.attachToFlutterEngine(flutterEngine);

1 2	FlutterView flutterView = findViewById(R.id.flutter_view); flutterView.attachToFlutterEngine(flutterEngine);

3.4 生命周期绑定

在 Android Acvitity 的生命周期中调用 appIsResumed()、appIsInactive、appIsPaused、appIsDetached以通知 Flutter 界面进入相应状态，否则页面会出现绘制异常。

@Override
protected void onResume() {
    super.onResume();
    /*...dosomething*/
    getEngine().getLifecycleChannel().appIsResumed();
}

@Override
protected void onPause() {
    super.onPause();
    /*...dosomething*/
    getEngine().getLifecycleChannel().appIsInactive();
}

@Override
protected void onDestroy() {
    super.onDestroy();
    /*...dosomething*/
    getEngine().getLifecycleChannel().appIsDetached();
}

@Override

protected void onResume() {

super.onResume();

/*...dosomething*/

getEngine().getLifecycleChannel().appIsResumed();

}

@Override

protected void onPause() {

super.onPause();

/*...dosomething*/

getEngine().getLifecycleChannel().appIsInactive();

}

@Override

protected void onDestroy() {

super.onDestroy();

/*...dosomething*/

getEngine().getLifecycleChannel().appIsDetached();

}

参考链接

mbedtls tls 客户端应用详解

介绍 mbedtls 的 tls client 的使用方法，常见的功能参数配置和含义。当前使用的 mbedtls 版本是： mbedtls-3.4.0。

功能参数配置

需要配置的功能选项

设置 tls 协议版本: 配置 tls 1.2, tls 1.3, 还是二者都支持。
认证方式设置：单向认证、双向认证、还是 psk。
握手时的校验等级设置：不校验证书合法性，仅加密；校验，但如果失败也继续执行后面的握手流程；校验不通过则终止握手流程。
服务器ca证书设置
客户端证书和密钥设置
预定义共享密钥设置

编译配置

使用 mbedtls_config.h 配置文件，tls 1.2 默认打开，不需要修改，但 tls 1.3 未开启，需要特别设置。

//mbedtls_config.h 
#define MBEDTLS_SSL_PROTO_TLS1_3
#define MBEDTLS_SSL_TLS1_3_COMPATIBILITY_MODE
#define MBEDTLS_USE_PSA_CRYPTO
#define MBEDTLS_PSA_CRYPTO_CONFIG

//mbedtls_config.h

#define MBEDTLS_SSL_PROTO_TLS1_3

#define MBEDTLS_SSL_TLS1_3_COMPATIBILITY_MODE

#define MBEDTLS_USE_PSA_CRYPTO

#define MBEDTLS_PSA_CRYPTO_CONFIG

解决 mps_common.h 中的编译问题，替换 MBEDTLS_MPS_STORED_SIZE_MAX 和 MBEDTLS_MPS_SIZE_MAX 宏定义。

//mps_common.h
#define MBEDTLS_MPS_STORED_SIZE_MAX  (SIZE_MAX)
#define MBEDTLS_MPS_SIZE_MAX  (SIZE_MAX)

//mps_common.h

#define MBEDTLS_MPS_STORED_SIZE_MAX (SIZE_MAX)

#define MBEDTLS_MPS_SIZE_MAX (SIZE_MAX)

API 设计和实现

接口处理的事情，主要是连接参数配置、打开和关闭连接，接收和发送数据。

数据结构定义：

typedef enum
{
    QTF_TLS_AUTH_MODE_CERT = 0, // 校验证书
    QTF_TLS_AUTH_MODE_PSK, // 预定义共享密钥
    QTF_TLS_AUTH_MODE_MAX
}qtf_tls_auth_mode_t;

typedef enum
{
    QTF_TLS_VERSION_TLS1_2 = 0,     // TLS v1.2
    QTF_TLS_VERSION_TLS1_3,         // TLS v1.3
    QTF_TLS_VERSION_TLS1_2_1_3,     // TLS v1.2 and TLS v1.3
    QTF_TLS_VERSION_MAX
}qtf_tls_version_t;

typedef enum
{
    QTF_TLS_VERIFY_MODE_NONE = 0, // 不校验证书是否合法
    QTF_TLS_VERIFY_MODE_OPTIONAL, // 证书校验失败，继续执行握手
    QTF_TLS_VERIFY_MODE_REQUIRED, // 证书校验失败终止握手，推荐配置
    QTF_TLS_VERIFY_MODE_MAX
}qtf_tls_verify_mode_t;

typedef enum
{
    QTF_TLS_DEBUG_LEVEL_NONE = 0,
    QTF_TLS_DEBUG_LEVEL_ERROR,
    QTF_TLS_DEBUG_LEVEL_STATE,
    QTF_TLS_DEBUG_LEVEL_INFO,
    QTF_TLS_DEBUG_LEVEL_VERBOSE,
}qtf_tls_debug_level_t;

// tls 报文分片大小设置
typedef enum
{
    QTF_TLS_MAX_FRAG_LEN_NO_USE = 0, // 不设置
    QTF_TLS_MAX_FRAG_LEN_512, // 设置 tls 报文分片大小 512 字节
    QTF_TLS_MAX_FRAG_LEN_1024,
    QTF_TLS_MAX_FRAG_LEN_2048,
    QTF_TLS_MAX_FRAG_LEN_4096,
}qtf_tls_max_frag_len_t;

typedef struct
{
    qtf_tls_auth_mode_t auth_mode; // 认证方式
    qtf_tls_verify_mode_t verify_mode; // 握手校验等级
    qtf_tls_version_t tls_version; // tls 协议版本设置
    qtf_tls_debug_level_t debug_level; // 调试日志等级设置
    qtf_tls_max_frag_len_t max_frag_len; // 报文分片大小设置
    uint32_t hanshake_timeout_ms; // 握手超时时间设置
    const char *ca_cert; 	// 服务器ca 证书
    uint32_t ca_cert_len;
    const char *client_cert; // 客户端证书
    uint32_t client_cert_len;
    const char *client_key; // 客户端密钥
    uint32_t client_key_len;
    const char *client_key_passwd;
    uint32_t client_key_passwd_len;
    const char *psk; // 预定义共享密钥
    uint32_t psk_len;
    const char *psk_id;
}qtf_tls_conn_param_t;

typedef enum

{

QTF_TLS_AUTH_MODE_CERT = 0, // 校验证书

QTF_TLS_AUTH_MODE_PSK, // 预定义共享密钥

QTF_TLS_AUTH_MODE_MAX

}qtf_tls_auth_mode_t;

typedef enum

{

QTF_TLS_VERSION_TLS1_2 = 0, // TLS v1.2

QTF_TLS_VERSION_TLS1_3, // TLS v1.3

QTF_TLS_VERSION_TLS1_2_1_3, // TLS v1.2 and TLS v1.3

QTF_TLS_VERSION_MAX

}qtf_tls_version_t;

typedef enum

{

QTF_TLS_VERIFY_MODE_NONE = 0, // 不校验证书是否合法

QTF_TLS_VERIFY_MODE_OPTIONAL, // 证书校验失败，继续执行握手

QTF_TLS_VERIFY_MODE_REQUIRED, // 证书校验失败终止握手，推荐配置

QTF_TLS_VERIFY_MODE_MAX

}qtf_tls_verify_mode_t;

typedef enum

{

QTF_TLS_DEBUG_LEVEL_NONE = 0,

QTF_TLS_DEBUG_LEVEL_ERROR,

QTF_TLS_DEBUG_LEVEL_STATE,

QTF_TLS_DEBUG_LEVEL_INFO,

QTF_TLS_DEBUG_LEVEL_VERBOSE,

}qtf_tls_debug_level_t;

// tls 报文分片大小设置

typedef enum

{

QTF_TLS_MAX_FRAG_LEN_NO_USE = 0, // 不设置

QTF_TLS_MAX_FRAG_LEN_512, // 设置 tls 报文分片大小 512 字节

QTF_TLS_MAX_FRAG_LEN_1024,

QTF_TLS_MAX_FRAG_LEN_2048,

QTF_TLS_MAX_FRAG_LEN_4096,

}qtf_tls_max_frag_len_t;

typedef struct

{

qtf_tls_auth_mode_t auth_mode; // 认证方式

qtf_tls_verify_mode_t verify_mode; // 握手校验等级

qtf_tls_version_t tls_version; // tls 协议版本设置

qtf_tls_debug_level_t debug_level; // 调试日志等级设置

qtf_tls_max_frag_len_t max_frag_len; // 报文分片大小设置

uint32_t hanshake_timeout_ms; // 握手超时时间设置

const char *ca_cert; // 服务器ca 证书

uint32_t ca_cert_len;

const char *client_cert; // 客户端证书

uint32_t client_cert_len;

const char *client_key; // 客户端密钥

uint32_t client_key_len;

const char *client_key_passwd;

uint32_t client_key_passwd_len;

const char *psk; // 预定义共享密钥

uint32_t psk_len;

const char *psk_id;

}qtf_tls_conn_param_t;

连接参数配置说明：

auth_mode：认证方式设置。

一是通过证书认证，另一个是通过预定义密钥 PSK。
verify_mode：握手的校验等级。

推荐配置为 QTF_TLS_VERIFY_MODE_REQUIRED。如果只是想加密而不校验，可以配置 QTF_TLS_VERIFY_MODE_NONE 或 QTF_TLS_VERIFY_MODE_OPTIONAL。
tls_version：tls 协议版本。

推荐配置成 tls 1.2 或 tls 1.3，tls 1.2 以下的版本不安全，tls 1.3 版本 mbedtls 没有完整支持。
debug_level：日志等级。

推荐设置 QTF_TLS_DEBUG_LEVEL_NONE 关闭日志输出。排查问题时可以将日志打开 QTF_TLS_DEBUG_LEVEL_VERBOSE（注意会打印密钥和收发数据的明文内容）。
max_frag_len：数据分片大小设置。

在客户端侧设置，用于协商数据分片大小，设置这个参数应该是出于对使用内存大小和带宽的考虑。

设置太小，可能会出现服务器证书接收不完整导致握手失败问题，但最大值也不能设置超过接收缓冲区的大小。
hanshake_timeout_ms：握手超时时间。
ca_cert：服务器的 ca 证书。

如果要求校验证书，则必须设置。客户端校验服务器是否合法，单向认证。
client_cert：客户端证书。

要求双向认证的时候必须设置，用于服务器校验客户端是否合法。同时还要设置 client_key。
psk ：预定义共享密钥。

psk 不需要证书认证，减少握手数据交互流程，但需要指定 psk_id 身份标识和指定加密套件。

接口定义：

void *qtf_tls_connect(const char *host, uint16_t port, qtf_tls_conn_param_t *param);
int qtf_tls_send(void *handle, const void *buf, uint32_t len, uint32_t timeout_ms);
int qtf_tls_recv(void *handle, void *buf, uint32_t len, uint32_t timeout_ms);
int qtf_tls_close(void *handle);

void *qtf_tls_connect(const char *host, uint16_t port, qtf_tls_conn_param_t *param);

int qtf_tls_send(void *handle, const void *buf, uint32_t len, uint32_t timeout_ms);

int qtf_tls_recv(void *handle, void *buf, uint32_t len, uint32_t timeout_ms);

int qtf_tls_close(void *handle);

接口实现:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "qt_idf_tls.h"
#include "dlg/dlg.h"

#include "mbedtls/net_sockets.h"
#include "mbedtls/ssl.h"
#include "mbedtls/ctr_drbg.h"
#include "mbedtls/debug.h"
#include "mbedtls/platform.h"
#include "mbedtls/timing.h"
#include "mbedtls/entropy.h"
#include "mbedtls/error.h"

typedef struct
{
    mbedtls_net_context      socket_fd;
    mbedtls_entropy_context  entropy;
    mbedtls_ctr_drbg_context ctr_drbg;
    mbedtls_ssl_context      ssl;
    mbedtls_ssl_config       ssl_conf;
    mbedtls_x509_crt         ca_cert;
    mbedtls_x509_crt         client_cert;
    mbedtls_pk_context       private_key;
}qtf_tls_handle_t;

#if defined(MBEDTLS_DEBUG_C)
static void _ssl_debug(void *ctx, int level, const char *file, int line, const char *str)
{
    printf("[mbedTLS]:[%s]:[%d]: %s\r\n", (file), line, (str));
}

#endif

static int _mbedtls_tcp_connect(mbedtls_net_context *ctx, const char *host, uint16_t port)
{
    int ret = 0;
    char port_str[6] = {0};

    snprintf(port_str, sizeof(port_str), "%d", port);

    ret = mbedtls_net_connect(ctx, host, port_str, MBEDTLS_NET_PROTO_TCP);
    if(ret != 0)
    {
        dlg_error("mbedtls_net_connect connect failed returned 0x%04x errno: %d", ret < 0 ? -ret : ret, errno);
       
        return ret;
    }

    ret = mbedtls_net_set_block(ctx);
    if(ret != 0)
    {
        dlg_error("mbedtls_net_set_block failed returned 0x%04x errno: %d", ret < 0 ? -ret : ret, errno);
        return ret;
    }

    return 0;
}

static int _tls_net_init(qtf_tls_handle_t *handle, qtf_tls_conn_param_t *param)
{
    int ret = -1;

    mbedtls_net_init(&(handle->socket_fd));
    mbedtls_ssl_init(&(handle->ssl));
    mbedtls_ssl_config_init(&(handle->ssl_conf));
    mbedtls_ctr_drbg_init(&(handle->ctr_drbg));
    
    mbedtls_entropy_init(&(handle->entropy));

#if defined(MBEDTLS_DEBUG_C)
    mbedtls_debug_set_threshold(param->debug_level);
    mbedtls_ssl_conf_dbg(&handle->ssl_conf, _ssl_debug, NULL);
#endif

#if defined(MBEDTLS_USE_PSA_CRYPTO) || defined(MBEDTLS_SSL_PROTO_TLS1_3)
    // tls 1.3 需要调用 psa_crypto_init
    ret = psa_crypto_init();
    if (ret != PSA_SUCCESS)
    {
        dlg_error("psa_crypto_init failed");
        goto error;
    }
#endif

    ret = mbedtls_ssl_conf_max_frag_len(&(handle->ssl_conf), param->max_frag_len);
    if (ret != 0)
    {
        dlg_error("mbedtls_ssl_conf_max_frag_len failed");
        goto error;
    }


    ret = mbedtls_ctr_drbg_seed(&(handle->ctr_drbg), mbedtls_entropy_func, &(handle->entropy), NULL, 0);
    if (ret != 0)
    {
        dlg_error("mbedtls_ctr_drbg_seed failed");
        goto error;
    }
	
    // 证书认证方式
    if(param->auth_mode == QTF_TLS_AUTH_MODE_CERT)
    {
        if(param->ca_cert && param->ca_cert_len)
        {
            mbedtls_x509_crt_init(&(handle->ca_cert));
            ret = mbedtls_x509_crt_parse(&(handle->ca_cert), (const unsigned char *)param->ca_cert, param->ca_cert_len+1);
            if (ret != 0)
            {
                dlg_error("mbedtls_x509_crt_parse failed");
                goto error;
            }
        }
        else
        {
            if(param->verify_mode != QTF_TLS_VERIFY_MODE_NONE)
            {
                dlg_error("invalid ca cert");
                goto error;
            }
            dlg_info("verify mode is none");
        }
        
        mbedtls_ssl_conf_ca_chain(&(handle->ssl_conf), &(handle->ca_cert), NULL);
		
        if (param->client_cert && param->client_cert_len && param->client_key && param->client_key_len)
        {
            // 双向认证
            mbedtls_x509_crt_init(&(handle->client_cert));
            mbedtls_pk_init(&(handle->private_key));
            ret = mbedtls_x509_crt_parse(&(handle->client_cert), (const unsigned char *)param->client_cert, param->client_cert_len + 1);
            if (ret != 0)
            {
                dlg_error("mbedtls_x509_crt_parse failed");
                goto error;
            }

            ret = mbedtls_pk_parse_key(&(handle->private_key), (const unsigned char *)param->client_key,
                                       param->client_key_len + 1, (const unsigned char *)param->client_key_passwd, param->client_key_passwd_len + 1, NULL, NULL);
            if (ret != 0)
            {
                dlg_error("mbedtls_pk_parse_key failed");
                goto error;
            }
            ret = mbedtls_ssl_conf_own_cert(&(handle->ssl_conf), &(handle->client_cert), &(handle->private_key));
            if (ret != 0)
            {
                dlg_error("mbedtls_ssl_conf_own_cert failed");
                goto error;
            }
        }
    }
    // psk 认证
    else if(param->auth_mode == QTF_TLS_AUTH_MODE_PSK)
    {
        if(param->psk && param->psk_len && param->psk_id)
        {
            ret = mbedtls_ssl_conf_psk(&(handle->ssl_conf), (const unsigned char *)param->psk, param->psk_len,
                                       (const unsigned char *)param->psk_id, strlen(param->psk_id));
            if (ret != 0)
            {
                dlg_error("mbedtls_ssl_conf_psk failed");
                goto error;
            }
        }
        else
        {
            dlg_error("invalid psk");
            goto error;
        }
    }
    else
    {
        dlg_error("invalid auth mode");
        goto error;
    }
    return ret;

error:
    
    return ret;

}

static int __tls_net_deinit(qtf_tls_handle_t *handle)
{
    mbedtls_net_free(&(handle->socket_fd));
    mbedtls_ssl_free(&(handle->ssl));
    mbedtls_ssl_config_free(&(handle->ssl_conf));
    mbedtls_ctr_drbg_free(&(handle->ctr_drbg));
    mbedtls_entropy_free(&(handle->entropy));
    mbedtls_x509_crt_free(&(handle->ca_cert));
    mbedtls_x509_crt_free(&(handle->client_cert));
    mbedtls_pk_free(&(handle->private_key));

    return 0;
}

void *qtf_tls_connect(const char *host, uint16_t port, qtf_tls_conn_param_t *param)
{
    qtf_tls_handle_t *handle = NULL;
    int ret = 0;

    if(!host || !param)
    {
        dlg_error("invalid param");
        goto error;
    }

    handle = (qtf_tls_handle_t *)malloc(sizeof(qtf_tls_handle_t));
    if(!handle)
    {
        dlg_error("malloc failed");
        goto error;
    }
	
    // 配置 tls 连接参数
    ret = _tls_net_init(handle, param);
    if(ret != 0)
    {
        dlg_error("tls net init failed");
        goto error;
    }

    dlg_info("Connecting to %s:%d...", host, port);
	// 建立 tcp 连接
    ret = _mbedtls_tcp_connect(&(handle->socket_fd), host, port);
    if (ret != 0)
    {
        dlg_error("mbedtls_tcp_connect failed");
        goto error;
    }
	
    // 设置 tls 客户端
    mbedtls_ssl_config_defaults(&(handle->ssl_conf), MBEDTLS_SSL_IS_CLIENT, MBEDTLS_SSL_TRANSPORT_STREAM, MBEDTLS_SSL_PRESET_DEFAULT);

    mbedtls_ssl_conf_read_timeout(&(handle->ssl_conf), param->hanshake_timeout_ms);
	
    // 配置认证等级
    mbedtls_ssl_conf_authmode(&(handle->ssl_conf), param->verify_mode);
	
    // 协议版本设置
    if(param->tls_version == QTF_TLS_VERSION_TLS1_2)
    {
        mbedtls_ssl_conf_max_tls_version(&(handle->ssl_conf), MBEDTLS_SSL_VERSION_TLS1_2);
        mbedtls_ssl_conf_min_tls_version(&(handle->ssl_conf), MBEDTLS_SSL_VERSION_TLS1_2);
    }
    else if(param->tls_version == QTF_TLS_VERSION_TLS1_3)
    {
        mbedtls_ssl_conf_max_tls_version(&(handle->ssl_conf), MBEDTLS_SSL_VERSION_TLS1_3);
        mbedtls_ssl_conf_min_tls_version(&(handle->ssl_conf), MBEDTLS_SSL_VERSION_TLS1_3);
    }
    else
    {
        mbedtls_ssl_conf_max_tls_version(&(handle->ssl_conf), MBEDTLS_SSL_VERSION_TLS1_3);
        mbedtls_ssl_conf_min_tls_version(&(handle->ssl_conf), MBEDTLS_SSL_VERSION_TLS1_2);
    }


    mbedtls_ssl_conf_rng(&(handle->ssl_conf), mbedtls_ctr_drbg_random, &(handle->ctr_drbg));

    // todo: config ciphersuites

    ret = mbedtls_ssl_setup(&(handle->ssl), &(handle->ssl_conf));
    if (ret != 0)
    {
        dlg_error("mbedtls_ssl_setup failed");
        goto error;
    }
	
    // 配置 tcp 收发函数，可自定义也可使用 mbedtls 的实现
    mbedtls_ssl_set_bio(&(handle->ssl), &(handle->socket_fd), mbedtls_net_send, mbedtls_net_recv, mbedtls_net_recv_timeout);
	
    // 设置服务器域名，目的是配置 SNI （Server Name Indication） 扩展。
    ret = mbedtls_ssl_set_hostname(&(handle->ssl), host);
    if (ret != 0)
    {
        dlg_error("mbedtls_ssl_set_hostname failed");
        goto error;
    }

    // 执行握手流程
    while ((ret = mbedtls_ssl_handshake(&(handle->ssl))) != 0)
    {
        if (ret != MBEDTLS_ERR_SSL_WANT_READ && ret != MBEDTLS_ERR_SSL_WANT_WRITE)
        {
            dlg_error("mbedtls_ssl_handshake failed 0x%04x", ret < 0 ? -ret : ret);
            goto error;
        }
    }
	
    // 证书校验结果
    ret = mbedtls_ssl_get_verify_result(&(handle->ssl));
    if (ret < 0)
    {
        dlg_error("mbedtls_ssl_get_verify_result  0x%04x", ret < 0 ? -ret : ret);
        goto error;
    }

    return handle;

error:

    if(handle)
    {
        __tls_net_deinit(handle);
        free(handle);
    }

    return NULL;
}

int qtf_tls_send(void *handle, const void *buf, uint32_t len, uint32_t timeout_ms)
{
    qtf_tls_handle_t *tls_handle = (qtf_tls_handle_t *)handle;
    int ret = 0;

    if(!handle || !buf || !len)
    {
        dlg_error("invalid param");
        return -1;
    }
	// 发送数据
    while ((ret = mbedtls_ssl_write(&(tls_handle->ssl), (const unsigned char *)buf, len)) <= 0)
    {
        if (ret != MBEDTLS_ERR_SSL_WANT_READ && ret != MBEDTLS_ERR_SSL_WANT_WRITE)
        {
            dlg_error("mbedtls_ssl_write failed 0x%04x", ret < 0 ? -ret : ret);
            return -1;
        }
    }

    return ret;
}
int qtf_tls_recv(void *handle, void *buf, uint32_t len, uint32_t timeout_ms)
{
    qtf_tls_handle_t *tls_handle = (qtf_tls_handle_t *)handle;
    int ret = 0;

    if(!handle || !buf || !len)
    {
        dlg_error("invalid param");
        return -1;
    }
	// 接收数据
    while ((ret = mbedtls_ssl_read(&(tls_handle->ssl), (unsigned char *)buf, len)) <= 0)
    {
        if (ret != MBEDTLS_ERR_SSL_WANT_READ && ret != MBEDTLS_ERR_SSL_WANT_WRITE)
        {
            dlg_error("mbedtls_ssl_read failed 0x%04x", ret < 0 ? -ret : ret);
            return -1;
        }
    }

    return ret;
}

int qtf_tls_close(void *handle)
{
    int ret = 0;
    qtf_tls_handle_t *tls_handle = (qtf_tls_handle_t *)handle;

    if (!handle)
    {
        dlg_error("invalid param");
        return -1;
    }
	// 关闭连接，释放资源
    do
    {
        ret = mbedtls_ssl_close_notify(&(tls_handle->ssl));
    } while (ret == MBEDTLS_ERR_SSL_WANT_READ || ret == MBEDTLS_ERR_SSL_WANT_WRITE);

    __tls_net_deinit(tls_handle);
    free(tls_handle);

    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

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

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "qt_idf_tls.h"

#include "dlg/dlg.h"

#include "mbedtls/net_sockets.h"

#include "mbedtls/ssl.h"

#include "mbedtls/ctr_drbg.h"

#include "mbedtls/debug.h"

#include "mbedtls/platform.h"

#include "mbedtls/timing.h"

#include "mbedtls/entropy.h"

#include "mbedtls/error.h"

typedef struct

{

mbedtls_net_context socket_fd;

mbedtls_entropy_context entropy;

mbedtls_ctr_drbg_context ctr_drbg;

mbedtls_ssl_context ssl;

mbedtls_ssl_config ssl_conf;

mbedtls_x509_crt ca_cert;

mbedtls_x509_crt client_cert;

mbedtls_pk_context private_key;

}qtf_tls_handle_t;

#if defined(MBEDTLS_DEBUG_C)

static void _ssl_debug(void *ctx, int level, const char *file, int line, const char *str)

{

printf("[mbedTLS]:[%s]:[%d]: %s\r\n", (file), line, (str));

}

#endif

static int _mbedtls_tcp_connect(mbedtls_net_context *ctx, const char *host, uint16_t port)

{

int ret = 0;

char port_str[6] = {0};

snprintf(port_str, sizeof(port_str), "%d", port);

ret = mbedtls_net_connect(ctx, host, port_str, MBEDTLS_NET_PROTO_TCP);

if(ret != 0)

{

dlg_error("mbedtls_net_connect connect failed returned 0x%04x errno: %d", ret < 0 ? -ret : ret, errno);

return ret;

}

ret = mbedtls_net_set_block(ctx);

if(ret != 0)

{

dlg_error("mbedtls_net_set_block failed returned 0x%04x errno: %d", ret < 0 ? -ret : ret, errno);

return ret;

}

return 0;

}

static int _tls_net_init(qtf_tls_handle_t *handle, qtf_tls_conn_param_t *param)

{

int ret = -1;

mbedtls_net_init(&(handle->socket_fd));

mbedtls_ssl_init(&(handle->ssl));

mbedtls_ssl_config_init(&(handle->ssl_conf));

mbedtls_ctr_drbg_init(&(handle->ctr_drbg));

mbedtls_entropy_init(&(handle->entropy));

#if defined(MBEDTLS_DEBUG_C)

mbedtls_debug_set_threshold(param->debug_level);

mbedtls_ssl_conf_dbg(&handle->ssl_conf, _ssl_debug, NULL);

#endif

#if defined(MBEDTLS_USE_PSA_CRYPTO) || defined(MBEDTLS_SSL_PROTO_TLS1_3)

// tls 1.3 需要调用 psa_crypto_init

ret = psa_crypto_init();

if (ret != PSA_SUCCESS)

{

dlg_error("psa_crypto_init failed");

goto error;

}

#endif

ret = mbedtls_ssl_conf_max_frag_len(&(handle->ssl_conf), param->max_frag_len);

if (ret != 0)

{

dlg_error("mbedtls_ssl_conf_max_frag_len failed");

goto error;

}

ret = mbedtls_ctr_drbg_seed(&(handle->ctr_drbg), mbedtls_entropy_func, &(handle->entropy), NULL, 0);

if (ret != 0)

{

dlg_error("mbedtls_ctr_drbg_seed failed");

goto error;

}

// 证书认证方式

if(param->auth_mode == QTF_TLS_AUTH_MODE_CERT)

{

if(param->ca_cert && param->ca_cert_len)

{

mbedtls_x509_crt_init(&(handle->ca_cert));

ret = mbedtls_x509_crt_parse(&(handle->ca_cert), (const unsigned char *)param->ca_cert, param->ca_cert_len+1);

if (ret != 0)

{

dlg_error("mbedtls_x509_crt_parse failed");

goto error;

}

else

{

if(param->verify_mode != QTF_TLS_VERIFY_MODE_NONE)

{

dlg_error("invalid ca cert");

goto error;

}

dlg_info("verify mode is none");

}

mbedtls_ssl_conf_ca_chain(&(handle->ssl_conf), &(handle->ca_cert), NULL);

if (param->client_cert && param->client_cert_len && param->client_key && param->client_key_len)

{

// 双向认证

mbedtls_x509_crt_init(&(handle->client_cert));

mbedtls_pk_init(&(handle->private_key));

ret = mbedtls_x509_crt_parse(&(handle->client_cert), (const unsigned char *)param->client_cert, param->client_cert_len + 1);

if (ret != 0)

{

dlg_error("mbedtls_x509_crt_parse failed");

goto error;

}

ret = mbedtls_pk_parse_key(&(handle->private_key), (const unsigned char *)param->client_key,

param->client_key_len + 1, (const unsigned char *)param->client_key_passwd, param->client_key_passwd_len + 1, NULL, NULL);

if (ret != 0)

{

dlg_error("mbedtls_pk_parse_key failed");

goto error;

}

ret = mbedtls_ssl_conf_own_cert(&(handle->ssl_conf), &(handle->client_cert), &(handle->private_key));

if (ret != 0)

{

dlg_error("mbedtls_ssl_conf_own_cert failed");

goto error;

}

// psk 认证

else if(param->auth_mode == QTF_TLS_AUTH_MODE_PSK)

{

if(param->psk && param->psk_len && param->psk_id)

{

ret = mbedtls_ssl_conf_psk(&(handle->ssl_conf), (const unsigned char *)param->psk, param->psk_len,

(const unsigned char *)param->psk_id, strlen(param->psk_id));

if (ret != 0)

{

dlg_error("mbedtls_ssl_conf_psk failed");

goto error;

}

else

{

dlg_error("invalid psk");

goto error;

}

else

{

dlg_error("invalid auth mode");

goto error;

}

return ret;

error:

return ret;

}

static int __tls_net_deinit(qtf_tls_handle_t *handle)

{

mbedtls_net_free(&(handle->socket_fd));

mbedtls_ssl_free(&(handle->ssl));

mbedtls_ssl_config_free(&(handle->ssl_conf));

mbedtls_ctr_drbg_free(&(handle->ctr_drbg));

mbedtls_entropy_free(&(handle->entropy));

mbedtls_x509_crt_free(&(handle->ca_cert));

mbedtls_x509_crt_free(&(handle->client_cert));

mbedtls_pk_free(&(handle->private_key));

return 0;

}

void *qtf_tls_connect(const char *host, uint16_t port, qtf_tls_conn_param_t *param)

{

qtf_tls_handle_t *handle = NULL;

int ret = 0;

if(!host || !param)

{

dlg_error("invalid param");

goto error;

}

handle = (qtf_tls_handle_t *)malloc(sizeof(qtf_tls_handle_t));

if(!handle)

{

dlg_error("malloc failed");

goto error;

}

// 配置 tls 连接参数

ret = _tls_net_init(handle, param);

if(ret != 0)

{

dlg_error("tls net init failed");

goto error;

}

dlg_info("Connecting to %s:%d...", host, port);

// 建立 tcp 连接

ret = _mbedtls_tcp_connect(&(handle->socket_fd), host, port);

if (ret != 0)

{

dlg_error("mbedtls_tcp_connect failed");

goto error;

}

// 设置 tls 客户端

mbedtls_ssl_config_defaults(&(handle->ssl_conf), MBEDTLS_SSL_IS_CLIENT, MBEDTLS_SSL_TRANSPORT_STREAM, MBEDTLS_SSL_PRESET_DEFAULT);

mbedtls_ssl_conf_read_timeout(&(handle->ssl_conf), param->hanshake_timeout_ms);

// 配置认证等级

mbedtls_ssl_conf_authmode(&(handle->ssl_conf), param->verify_mode);

// 协议版本设置

if(param->tls_version == QTF_TLS_VERSION_TLS1_2)

{

mbedtls_ssl_conf_max_tls_version(&(handle->ssl_conf), MBEDTLS_SSL_VERSION_TLS1_2);

mbedtls_ssl_conf_min_tls_version(&(handle->ssl_conf), MBEDTLS_SSL_VERSION_TLS1_2);

}

else if(param->tls_version == QTF_TLS_VERSION_TLS1_3)

{

mbedtls_ssl_conf_max_tls_version(&(handle->ssl_conf), MBEDTLS_SSL_VERSION_TLS1_3);

mbedtls_ssl_conf_min_tls_version(&(handle->ssl_conf), MBEDTLS_SSL_VERSION_TLS1_3);

}

else

{

mbedtls_ssl_conf_max_tls_version(&(handle->ssl_conf), MBEDTLS_SSL_VERSION_TLS1_3);

mbedtls_ssl_conf_min_tls_version(&(handle->ssl_conf), MBEDTLS_SSL_VERSION_TLS1_2);

}

mbedtls_ssl_conf_rng(&(handle->ssl_conf), mbedtls_ctr_drbg_random, &(handle->ctr_drbg));

// todo: config ciphersuites

ret = mbedtls_ssl_setup(&(handle->ssl), &(handle->ssl_conf));

if (ret != 0)

{

dlg_error("mbedtls_ssl_setup failed");

goto error;

}

// 配置 tcp 收发函数，可自定义也可使用 mbedtls 的实现

mbedtls_ssl_set_bio(&(handle->ssl), &(handle->socket_fd), mbedtls_net_send, mbedtls_net_recv, mbedtls_net_recv_timeout);

// 设置服务器域名，目的是配置 SNI （Server Name Indication）扩展。

ret = mbedtls_ssl_set_hostname(&(handle->ssl), host);

if (ret != 0)

{

dlg_error("mbedtls_ssl_set_hostname failed");

goto error;

}

// 执行握手流程

while ((ret = mbedtls_ssl_handshake(&(handle->ssl))) != 0)

{

if (ret != MBEDTLS_ERR_SSL_WANT_READ && ret != MBEDTLS_ERR_SSL_WANT_WRITE)

{

dlg_error("mbedtls_ssl_handshake failed 0x%04x", ret < 0 ? -ret : ret);

goto error;

}

// 证书校验结果

ret = mbedtls_ssl_get_verify_result(&(handle->ssl));

if (ret < 0)

{

dlg_error("mbedtls_ssl_get_verify_result 0x%04x", ret < 0 ? -ret : ret);

goto error;

}

return handle;

error:

if(handle)

{

__tls_net_deinit(handle);

free(handle);

}

return NULL;

}

int qtf_tls_send(void *handle, const void *buf, uint32_t len, uint32_t timeout_ms)

{

qtf_tls_handle_t *tls_handle = (qtf_tls_handle_t *)handle;

int ret = 0;

if(!handle || !buf || !len)

{

dlg_error("invalid param");

return -1;

}

// 发送数据

while ((ret = mbedtls_ssl_write(&(tls_handle->ssl), (const unsigned char *)buf, len)) <= 0)

{

if (ret != MBEDTLS_ERR_SSL_WANT_READ && ret != MBEDTLS_ERR_SSL_WANT_WRITE)

{

dlg_error("mbedtls_ssl_write failed 0x%04x", ret < 0 ? -ret : ret);

return -1;

}

return ret;

}

int qtf_tls_recv(void *handle, void *buf, uint32_t len, uint32_t timeout_ms)

{

qtf_tls_handle_t *tls_handle = (qtf_tls_handle_t *)handle;

int ret = 0;

if(!handle || !buf || !len)

{

dlg_error("invalid param");

return -1;

}

// 接收数据

while ((ret = mbedtls_ssl_read(&(tls_handle->ssl), (unsigned char *)buf, len)) <= 0)

{

if (ret != MBEDTLS_ERR_SSL_WANT_READ && ret != MBEDTLS_ERR_SSL_WANT_WRITE)

{

dlg_error("mbedtls_ssl_read failed 0x%04x", ret < 0 ? -ret : ret);

return -1;

}

return ret;

}

int qtf_tls_close(void *handle)

{

int ret = 0;

qtf_tls_handle_t *tls_handle = (qtf_tls_handle_t *)handle;

if (!handle)

{

dlg_error("invalid param");

return -1;

}

// 关闭连接，释放资源

{

ret = mbedtls_ssl_close_notify(&(tls_handle->ssl));

} while (ret == MBEDTLS_ERR_SSL_WANT_READ || ret == MBEDTLS_ERR_SSL_WANT_WRITE);

__tls_net_deinit(tls_handle);

free(tls_handle);

return 0;

}

测试例子

测试代码，连接 https 测试服务器 httpbin.org，发送一个 get 请求，并接收服务器回复。

void shell_tlstest_cmd(int argc, char *argv)
{
	qtf_tls_conn_param_t tls_param = {0};
	void *tls_handle = NULL;
	char recv_buf[1024] = {0};
	int ret = 0;

	const char request[] = "GET /get?a=1 HTTP/1.1\r\n"
		"Host: httpbin.org\r\n"
		"Connection: close\r\n"
		"\r\n";
	const char *test_ca_cert =
		{

			"-----BEGIN CERTIFICATE-----\r\n"
			"MIIDdTCCAl2gAwIBAgILBAAAAAABFUtaw5QwDQYJKoZIhvcNAQEFBQAwVzELMAkG\r\n"
			"A1UEBhMCQkUxGTAXBgNVBAoTEEdsb2JhbFNpZ24gbnYtc2ExEDAOBgNVBAsTB1Jv\r\n"
			"b3QgQ0ExGzAZBgNVBAMTEkdsb2JhbFNpZ24gUm9vdCBDQTAeFw05ODA5MDExMjAw\r\n"
			"MDBaFw0yODAxMjgxMjAwMDBaMFcxCzAJBgNVBAYTAkJFMRkwFwYDVQQKExBHbG9i\r\n"
			"YWxTaWduIG52LXNhMRAwDgYDVQQLEwdSb290IENBMRswGQYDVQQDExJHbG9iYWxT\r\n"
			"aWduIFJvb3QgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDaDuaZ\r\n"
			"jc6j40+Kfvvxi4Mla+pIH/EqsLmVEQS98GPR4mdmzxzdzxtIK+6NiY6arymAZavp\r\n"
			"xy0Sy6scTHAHoT0KMM0VjU/43dSMUBUc71DuxC73/OlS8pF94G3VNTCOXkNz8kHp\r\n"
			"1Wrjsok6Vjk4bwY8iGlbKk3Fp1S4bInMm/k8yuX9ifUSPJJ4ltbcdG6TRGHRjcdG\r\n"
			"snUOhugZitVtbNV4FpWi6cgKOOvyJBNPc1STE4U6G7weNLWLBYy5d4ux2x8gkasJ\r\n"
			"U26Qzns3dLlwR5EiUWMWea6xrkEmCMgZK9FGqkjWZCrXgzT/LCrBbBlDSgeF59N8\r\n"
			"9iFo7+ryUp9/k5DPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8E\r\n"
			"BTADAQH/MB0GA1UdDgQWBBRge2YaRQ2XyolQL30EzTSo//z9SzANBgkqhkiG9w0B\r\n"
			"AQUFAAOCAQEA1nPnfE920I2/7LqivjTFKDK1fPxsnCwrvQmeU79rXqoRSLblCKOz\r\n"
			"yj1hTdNGCbM+w6DjY1Ub8rrvrTnhQ7k4o+YviiY776BQVvnGCv04zcQLcFGUl5gE\r\n"
			"38NflNUVyRRBnMRddWQVDf9VMOyGj/8N7yy5Y0b2qvzfvGn9LhJIZJrglfCm7ymP\r\n"
			"AbEVtQwdpf5pLGkkeB6zpxxxYu7KyJesF12KwvhHhm4qxFYxldBniYUr+WymXUad\r\n"
			"DKqC5JlR3XC321Y9YeRq4VzW9v493kHMB65jUr9TU/Qr6cf9tveCX4XSQRjbgbME\r\n"
			"HMUfpIBvFSDJ3gyICh3WZlXi/EjJKSZp4A==\r\n"
			"-----END CERTIFICATE-----"};
	tls_param.auth_mode = QTF_TLS_AUTH_MODE_CERT;
	tls_param.verify_mode = QTF_TLS_VERIFY_MODE_OPTIONAL;
	tls_param.hanshake_timeout_ms = 10000;
	tls_param.ca_cert = test_ca_cert;
	tls_param.ca_cert_len = strlen(test_ca_cert);
	tls_param.client_cert = NULL;
	tls_param.client_cert_len = 0;
	tls_param.client_key = NULL;
	tls_param.client_key_len = 0;
	tls_param.client_key_passwd = NULL;
	tls_param.client_key_passwd_len = 0;
	tls_param.psk = NULL;
	tls_param.psk_len = 0;
	tls_param.psk_id = NULL;
	tls_param.debug_level = QTF_TLS_DEBUG_LEVEL_ERROR;
	tls_param.tls_version = QTF_TLS_VERSION_TLS1_2;
	tls_param.max_frag_len = QTF_TLS_MAX_FRAG_LEN_NO_USE;

	tls_handle = qtf_tls_connect("httpbin.org", 443, &tls_param);
	if(tls_handle)
	{
		shell_printf("tls connect success\r\n");
	}
	else
	{
		shell_printf("tls connect failed\r\n");
		return;
	}

	ret = qtf_tls_send(tls_handle, request, strlen(request), 1000);
	if(ret > 0)
	{
		shell_printf("tls send success\r\n");
	}
	else
	{
		shell_printf("tls send failed\r\n");
		qtf_tls_close(tls_handle);
		return;
	}

	ret = qtf_tls_recv(tls_handle, recv_buf, sizeof(recv_buf), 1000);
	if(ret > 0)
	{
		shell_printf("tls recv success\r\n");
		shell_printf("recv:%s\r\n", recv_buf);
	}
	else
	{
		shell_printf("tls recv failed\r\n");
	}

	qtf_tls_close(tls_handle);

}

void shell_tlstest_cmd(int argc, char *argv)

{

qtf_tls_conn_param_t tls_param = {0};

void *tls_handle = NULL;

char recv_buf[1024] = {0};

int ret = 0;

const char request[] = "GET /get?a=1 HTTP/1.1\r\n"

"Host: httpbin.org\r\n"

"Connection: close\r\n"

"\r\n";

const char *test_ca_cert =

{

"-----BEGIN CERTIFICATE-----\r\n"

"MIIDdTCCAl2gAwIBAgILBAAAAAABFUtaw5QwDQYJKoZIhvcNAQEFBQAwVzELMAkG\r\n"

"A1UEBhMCQkUxGTAXBgNVBAoTEEdsb2JhbFNpZ24gbnYtc2ExEDAOBgNVBAsTB1Jv\r\n"

"b3QgQ0ExGzAZBgNVBAMTEkdsb2JhbFNpZ24gUm9vdCBDQTAeFw05ODA5MDExMjAw\r\n"

"MDBaFw0yODAxMjgxMjAwMDBaMFcxCzAJBgNVBAYTAkJFMRkwFwYDVQQKExBHbG9i\r\n"

"YWxTaWduIG52LXNhMRAwDgYDVQQLEwdSb290IENBMRswGQYDVQQDExJHbG9iYWxT\r\n"

"aWduIFJvb3QgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDaDuaZ\r\n"

"jc6j40+Kfvvxi4Mla+pIH/EqsLmVEQS98GPR4mdmzxzdzxtIK+6NiY6arymAZavp\r\n"

"xy0Sy6scTHAHoT0KMM0VjU/43dSMUBUc71DuxC73/OlS8pF94G3VNTCOXkNz8kHp\r\n"

"1Wrjsok6Vjk4bwY8iGlbKk3Fp1S4bInMm/k8yuX9ifUSPJJ4ltbcdG6TRGHRjcdG\r\n"

"snUOhugZitVtbNV4FpWi6cgKOOvyJBNPc1STE4U6G7weNLWLBYy5d4ux2x8gkasJ\r\n"

"U26Qzns3dLlwR5EiUWMWea6xrkEmCMgZK9FGqkjWZCrXgzT/LCrBbBlDSgeF59N8\r\n"

"9iFo7+ryUp9/k5DPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8E\r\n"

"BTADAQH/MB0GA1UdDgQWBBRge2YaRQ2XyolQL30EzTSo//z9SzANBgkqhkiG9w0B\r\n"

"AQUFAAOCAQEA1nPnfE920I2/7LqivjTFKDK1fPxsnCwrvQmeU79rXqoRSLblCKOz\r\n"

"yj1hTdNGCbM+w6DjY1Ub8rrvrTnhQ7k4o+YviiY776BQVvnGCv04zcQLcFGUl5gE\r\n"

"38NflNUVyRRBnMRddWQVDf9VMOyGj/8N7yy5Y0b2qvzfvGn9LhJIZJrglfCm7ymP\r\n"

"AbEVtQwdpf5pLGkkeB6zpxxxYu7KyJesF12KwvhHhm4qxFYxldBniYUr+WymXUad\r\n"

"DKqC5JlR3XC321Y9YeRq4VzW9v493kHMB65jUr9TU/Qr6cf9tveCX4XSQRjbgbME\r\n"

"HMUfpIBvFSDJ3gyICh3WZlXi/EjJKSZp4A==\r\n"

"-----END CERTIFICATE-----"};

tls_param.auth_mode = QTF_TLS_AUTH_MODE_CERT;

tls_param.verify_mode = QTF_TLS_VERIFY_MODE_OPTIONAL;

tls_param.hanshake_timeout_ms = 10000;

tls_param.ca_cert = test_ca_cert;

tls_param.ca_cert_len = strlen(test_ca_cert);

tls_param.client_cert = NULL;

tls_param.client_cert_len = 0;

tls_param.client_key = NULL;

tls_param.client_key_len = 0;

tls_param.client_key_passwd = NULL;

tls_param.client_key_passwd_len = 0;

tls_param.psk = NULL;

tls_param.psk_len = 0;

tls_param.psk_id = NULL;

tls_param.debug_level = QTF_TLS_DEBUG_LEVEL_ERROR;

tls_param.tls_version = QTF_TLS_VERSION_TLS1_2;

tls_param.max_frag_len = QTF_TLS_MAX_FRAG_LEN_NO_USE;

tls_handle = qtf_tls_connect("httpbin.org", 443, &tls_param);

if(tls_handle)

{

shell_printf("tls connect success\r\n");

}

else

{

shell_printf("tls connect failed\r\n");

return;

}

ret = qtf_tls_send(tls_handle, request, strlen(request), 1000);

if(ret > 0)

{

shell_printf("tls send success\r\n");

}

else

{

shell_printf("tls send failed\r\n");

qtf_tls_close(tls_handle);

return;

}

ret = qtf_tls_recv(tls_handle, recv_buf, sizeof(recv_buf), 1000);

if(ret > 0)

{

shell_printf("tls recv success\r\n");

shell_printf("recv:%s\r\n", recv_buf);

}

else

{

shell_printf("tls recv failed\r\n");

}

qtf_tls_close(tls_handle);

}

测试日志：

[qt_idf_tls.c:250 qtf_tls_connect] Connecting to httpbin.org:443...
[mbedTLS]:[D:/workspace/QT/qt_idf/components/mbedtls/library/ssl_client.c]:[258]: got supported group(001d)

[mbedTLS]:[D:/workspace/QT/qt_idf/components/mbedtls/library/ssl_client.c]:[258]: got supported group(0017)

[mbedTLS]:[D:/workspace/QT/qt_idf/components/mbedtls/library/ssl_client.c]:[258]: got supported group(0018)

[mbedTLS]:[D:/workspace/QT/qt_idf/components/mbedtls/library/ssl_client.c]:[258]: got supported group(001e)

[mbedTLS]:[D:/workspace/QT/qt_idf/components/mbedtls/library/ssl_client.c]:[258]: got supported group(0019)

[mbedTLS]:[D:/workspace/QT/qt_idf/components/mbedtls/library/ssl_client.c]:[258]: got supported group(001a)

[mbedTLS]:[D:/workspace/QT/qt_idf/components/mbedtls/library/ssl_client.c]:[258]: got supported group(001b)

[mbedTLS]:[D:/workspace/QT/qt_idf/components/mbedtls/library/ssl_client.c]:[258]: got supported group(001c)

[mbedTLS]:[D:/workspace/QT/qt_idf/components/mbedtls/library/ssl_tls.c]:[7384]: x509_verify_cert() returned -9984 (-0x2700)

[mbedTLS]:[D:/workspace/QT/qt_idf/components/mbedtls/library/ssl_tls12_client.c]:[2762]: Perform PSA-based ECDH computation.

tls connect success
tls send success
tls recv success
recv:HTTP/1.1 200 OK
Date: Sun, 02 Jul 2023 12:02:04 GMT
Content-Type: application/json
Content-Length: 220
Connection: close
Server: gunicorn/19.9.0
Access-Control-Allow-Origin: *
Access-Control-Allow-Credentials: true

{
  "args": {
    "a": "1"
  },
  "headers": {
    "Host": "httpbin.org",
    "X-Amzn-Trace-Id": "Root=1-64a1673a-5197ca4a2ff801443ac81bc6"
  },
  "origin": "223.73.211.183",
  "url": "https://httpbin.org/get?a=1"
}

[qt_idf_tls.c:250 qtf_tls_connect] Connecting to httpbin.org:443...

[mbedTLS]:[D:/workspace/QT/qt_idf/components/mbedtls/library/ssl_client.c]:[258]: got supported group(001d)

[mbedTLS]:[D:/workspace/QT/qt_idf/components/mbedtls/library/ssl_client.c]:[258]: got supported group(0017)

[mbedTLS]:[D:/workspace/QT/qt_idf/components/mbedtls/library/ssl_client.c]:[258]: got supported group(0018)

[mbedTLS]:[D:/workspace/QT/qt_idf/components/mbedtls/library/ssl_client.c]:[258]: got supported group(001e)

[mbedTLS]:[D:/workspace/QT/qt_idf/components/mbedtls/library/ssl_client.c]:[258]: got supported group(0019)

[mbedTLS]:[D:/workspace/QT/qt_idf/components/mbedtls/library/ssl_client.c]:[258]: got supported group(001a)

[mbedTLS]:[D:/workspace/QT/qt_idf/components/mbedtls/library/ssl_client.c]:[258]: got supported group(001b)

[mbedTLS]:[D:/workspace/QT/qt_idf/components/mbedtls/library/ssl_client.c]:[258]: got supported group(001c)

[mbedTLS]:[D:/workspace/QT/qt_idf/components/mbedtls/library/ssl_tls.c]:[7384]: x509_verify_cert() returned -9984 (-0x2700)

[mbedTLS]:[D:/workspace/QT/qt_idf/components/mbedtls/library/ssl_tls12_client.c]:[2762]: Perform PSA-based ECDH computation.

tls connect success

tls send success

tls recv success

recv:HTTP/1.1 200 OK

Date: Sun, 02 Jul 2023 12:02:04 GMT

Content-Type: application/json

Content-Length: 220

Connection: close

Server: gunicorn/19.9.0

Access-Control-Allow-Origin: *

Access-Control-Allow-Credentials: true

{

"args": {

"a": "1"

"headers": {

"Host": "httpbin.org",

"X-Amzn-Trace-Id": "Root=1-64a1673a-5197ca4a2ff801443ac81bc6"

"origin": "223.73.211.183",

"url": "https://httpbin.org/get?a=1"

}

继续阅读mbedtls tls 客户端应用详解

Xcode 16 调整 Provisioning Profiles 目录导致证书查不到

cronet demo 使用的 ninja 打包，查找 Provisioning Profiles 路径是 ~/Library/MobileDevice/Provisioning Profiles，但 Xcode 16 把该路径改为了 ~/Library/Developer/Xcode/UserData/Provisioning Profiles，导致在编译 cronet 的 demo 时找不到证书。

解决办法是把 Xcode 16 的路径下的证书拷贝一份到老的路径 ~/Library/MobileDevice/Provisioning Profiles 即可。

参考链接

Xcode16 调整 Provisioning Profiles 目录导致证书查不到

Mac应用第三方渠道发布指南

1.申请证书

Mac 应用有多种证书，主要包含以下几种：

Apple Development: Xcode 11之后Apple全平台开发证书
Apple Distribution: Xcode 11之后Apple全平台发布
Mac Development：用来开发和Debug的证书
Mac App Distribution：用来给APP文件签名后上传到Mac App Store
Mac Installer Distribution：用来给PKG文件签名后上传到Mac App Store
Developer ID Installer：用于给PKG文件签名，在非Mac App Store场景使用
Developer ID Application：用于给APP文件签名，在非Mac App Store场景使用

继续阅读Mac应用第三方渠道发布指南

2025 年 11 月
一	二	三	四	五	六	日
					1	2
3	4	5	6	7	8	9
10	11	12	13	14	15	16
17	18	19	20	21	22	23
24	25	26	27	28	29	30