Rust支持跨平台，可以指定生成目标平台，交叉编译也是支持的。当然，想要交叉编译成功，还需要指定平台的编译器(如：msvc、gcc等)。

openssl是C语言开发的库，如果在Rust代码中用到openssl，需要先对openssl进行交叉编译。

关于在Linux进行交叉编译的文章很多，这篇文章讲如何在windows 10环境下设置aarch64的交叉编译，并基于openssl实现一个aarch64架构 TCP 双向认证示例。

aarch64的GCC编译器下载及配置

想要在windows进行交叉编译，需要下载能够在windows运行的编译器。aarch64的编译器一般都是在Linux下运行，好在 Linaro 提供了可以在windows上运行的aarch64编译器。

下载完成后，将编译器解压到一个目录，再将bin目录添加到环境变量中，保证在命令行中可以访问到gcc：

写一个helloworld，使用指令 "aarch64-linux-gnu-gcc.exe hello.c -o hello"编译成可执行文件，就可以将其复制到arm板上运行了。

我手里没有arm板，在虚拟机中安装ubuntu，使用 qemu的用户模式 模拟 aarch64 运行。

在ubuntu下，想要运行aarch64程序，需要安装以下组件：

sudo apt install qemu qemu-user gcc-aarch64-linux-gnu

aarch64编译器用于提供aarch64程序的动态链接库。运行指令需要使用指令参数 -L /usr/aarch64-linux-gnu 指定aarch64库位置。

Rust配置交叉编译

rustc是Rust语言的前端编译器，它会将Rust源码编译成 LLVM IR，然后再调用链接器(link.exe、ld等)链接，最终形成可执文件/动态库。

rustc本身并不提供链接的功能，这也是为什么在windows下要安装msvc编译器、在linux要安装gcc的原因。

gcc在前面一小节已经装好，在Rust中，需要安装一下aarch64的编译目标架构组件。在Rust支持的编译目标中，比较符合aarch64架构的目标是 aarch64-unknown-linux-gnu：

rustup target add aarch64-unknown-linux-gnu

使用cargo创建一个新项目，交叉编译需要进行一些额外的设置(非常重要)。在根目录下新建一个 .cargo 目录，并创建一个 config.toml 文件：

//  .cargo/config.toml文件
[build]
target = "aarch64-unknown-linux-gnu" # 编译目标

[target.aarch64-unknown-linux-gnu]
linker = "aarch64-linux-gnu-gcc" # 交叉编译编译器

使用 cargo build编译，成功编译成可执行文件，可执行文件位于
target/aarch64-unknown-linux-gnu\debug 下：

从可执行文件的信息来看，这是一个AArch64架构的程序。并且依赖thread、dl、c、gcc_s库，这些库都要求是aarch64的。因此，运行时需要提供库位置：

qemu-aarch64 -L /usr/aarch64-linux-gnu ./hello

openssl交叉编译

我们需要在程序中集成openssl的TLS功能。因此，我们只需要编译库文件就可以。编译openssl，最好有一个linux环境，由于我们是在windows下，可以使用Cygwin这种类Linux环境。这里使用msys2来编译openssl。

• MSYS2安装：

下载MSYS2安装程序，双击安装。安装完成后打开 "msys2.exe"终端程序。

• openssl编译:

下载openssl源码，msys终端跳转到openssl源码所在目录（这里将openssl源码放在 e:/opensource 目录下），解压openssl压缩包 => 编译配置 => 编译 => 安装：

# 将编译器的bin目录添加到 PATH 环境变量中
export PATH=$PATH:/d/software/gcc-linaro-7.5.0-2019.12-i686-mingw32_aarch64-linux-gnu/bin
cd /e/opensource
tar -zxvf openssl-3.5.1.tar.gz
cd openssl-3.5.1
# 编译配置，只编译静态库，不编程动态库和openssl可执行文件，并且不生成测试文件
./Configure linux-aarch64 --cross-compile-prefix=aarch64-linux-gnu- --prefix=installed no-asm no-async no-shared
make
make install

上面的编译配置中，只生成静态库文件。编译成功后，会在当前目录下的installed输出openssl的输出文件，包含头文件、库文件、帮助文档等。

集成到Rust中

在Cargo.toml配置中，添加openssl依赖。在环境变量中配置OPENSSL_DIR：

// Cargo.toml文件

# 服务端
[[bin]]
name = "tls_server"
path = "src/bin/server.rs"

# 客户端
[[bin]]
name = "tls_client"
path = "src/bin/client.rs"

#  openssl依赖
[dependencies]
openssl = "0"

// 环境变量配置
set OPENSSL_DIR=E:\opensource\openssl-3.5.1\installed

接下分别写一个服务端和客户端，测试一下openssl的双向认证功能：

// server.rs
use std::io::{Read, Write};
use std::net::{SocketAddrV4, TcpListener};
use std::str::FromStr;
use openssl::ssl::{SslAcceptor, SslFiletype, SslMethod, SslVerifyMode};

fn openssl_server_test(host: &str, port: u16) -> Result<(), Box<dyn std::error::Error>> {
    let mut builder = SslAcceptor::mozilla_intermediate(SslMethod::tls())?;
    builder.set_private_key_file("certs/server.key", SslFiletype::PEM)?;
    builder.set_certificate_chain_file("certs/server.crt")?;
    builder.set_ca_file("certs/ca.crt")?;
    // 设置客户端认证
    builder.set_verify(SslVerifyMode::PEER | SslVerifyMode::FAIL_IF_NO_PEER_CERT);
    let acceptor = builder.build();
    // 绑定地址
    let addr = SocketAddrV4::from_str(format!("{}:{}", host, port).as_str())?;
    let listener = TcpListener::bind(addr)?;
    // 等待客户端连接
    let (stream, addr) = listener.accept()?;
    // ssl握手
    let mut stream = acceptor.accept(stream)?;
    // 读到数据
    let mut buffer: [u8; 1024] = [0; 1024];
    let r = stream.read(&mut buffer)?;
    // 写数据
    stream.write(&buffer[0..r])?;
    stream.shutdown()?;
    Ok(())
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    openssl_server_test("127.0.0.1",8080)
}

// client.rs
use std::io::{Read, Write};
use std::net::TcpStream;
use openssl::ssl::{SslConnector, SslFiletype, SslMethod};

fn openssl_client_test(host: &str, port:i32) -> Result<(), Box<dyn std::error::Error>> {
    // 设置客户端证书
    let mut connector = SslConnector::builder(SslMethod::tls())?;
    connector.set_ca_file("certs/ca.crt")?;
    connector.set_private_key_file("certs/client.key", SslFiletype::PEM)?;
    connector.set_certificate_chain_file("certs/client.crt")?;
    let connector = connector.build();
    // TCP连接
    let stream = TcpStream::connect(format!("{}:{}",host,port))?;
    // SSL握手
    let mut stream = connector.connect(host, stream)?;
    // 写数据
    stream.write_all("Hello".as_bytes())?;
    //  读数据
    let mut response = vec![];
    stream.read_to_end(&mut response)?;
    println!("{}", std::str::from_utf8(&response)?);
    Ok(())
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    openssl_client_test("127.0.0.1",8080)
}

使用cargo build进行编译，会在 target\aarch64-unknown-linux-gnu\debug 目录下生成tls_server和tls_client两个文件。

从文件信息来看，生成的可执行文件格式是aarch64格式的。编译的openssl是静态库，最终生成的可执行文件自身就包含openssl，不再外部依赖openssl。

使用qemu-aarch64运行一下(证书生成参见《Rust中的TLS库深度对比：openssl、rustls 和 native-tls》)：

总结

上面只演示了aarch64的交叉编译过程。总体来讲，Rust交叉编译分以下几步：

• 配置编译目标的交叉编译环境
• 安装与编译目标匹配的Rust目标架构组件
• 如果Rust库依赖C库，需要使用交叉编译器先编译C库，再进行库配置
• 在项目中配置交叉编译，关键步骤是配置.cargo/config.toml文件

以上就是基于windows的arrch64交叉编译过程，如果遇到问题，欢迎在评论区留言。