如何在 Rust 中将十六进制值转换为 Base64

Question

我在理解 Rust 中的特征概念时遇到了一些问题。我正在尝试将一个简单的十六进制值编码为 Base64 但没有运气，这是我的代码（还有一个字符串到 Base64 的示例）

extern crate serialize;

use serialize::base64::{ToBase64, STANDARD};
use serialize::hex::{FromHex, ToHex};

fn main () {
  let stringOfText = "This is a String";
  let mut config = STANDARD;

  println!("String to base64 = {}", stringOfText.as_bytes().to_base64(config));

  // Can't figure out this 

Vladimir 提供的解决方案适用于 0x 表示的十六进制值。现在我正在寻找以字符串表示的十六进制值：

extern crate serialize;

use serialize::base64::{ToBase64, STANDARD};
use serialize::hex::{FromHex, ToHex};
fn main () {
  let stringOfText = "49276d206b696c6c696e6720796f757220627261696e206c696b65206120706f69736f6e6f7573206d757368726f6f6d";
  let mut config = STANDARD;

  println!("String to base64 = {}", stringOfText.from_hex().from_utf8_owned().as_bytes().to_base64(config));

  // result should be: SSdtIGtpbGxpbmcgeW91ciBicmFpbiBsaWtlIGEgcG9pc29ub3VzIG11c2hyb29t

}

from_hex() 给了我一个Vec<u8> 和.to_base64() 期待u8, 的缓冲区首先我想将Vec<u8> 转换为字符串，然后使用as_bytes() 来获取缓冲区，到目前为止仍然不走运。

Answer 1

现在是 2017 年，并且 rustc-serialize 现在也已弃用（请参阅 here）。新的大型序列化库称为serde，但我认为这对于这个问题来说有点沉重。

这是一个快速的解决方案，手动将十六进制的String 转换为Vec<u8>，然后使用this 转换为base64 编码的String。

我不相信这个 for 循环是将十六进制的 String 转换为 Vec<u8> 的最佳解决方案，但我对 Rust 相当陌生，这就是我所拥有的。评论/改进表示赞赏。

（嘿，等一下，我认出了这些编码字符串，你在做cryptopals吗？）

extern crate base64;
use std::u8;
use self::base64::{encode};

pub fn hex_to_base64(hex: String) -> String {

    // Make vector of bytes from octets
    let mut bytes = Vec::new();
    for i in 0..(hex.len()/2) {
        let res = u8::from_str_radix(&hex[2*i .. 2*i+2], 16);
        match res {
            Ok(v) => bytes.push(v),
            Err(e) => println!("Problem with hex: {}", e),
        };
    };

    encode(&bytes) // now convert from Vec<u8> to b64-encoded String
}    

Answer 2

Rust 目前正在发展，接受的答案不再正常工作。具体来说，extern crate 语句不允许引用参数，并且 rustc-serialize crate 的名称现在是 rustc_serialize。

以下代码正确地对字符串进行 base64 编码，产生与接受的答案相同的结果（rustc 1.3.0）：

extern crate rustc_serialize as serialize;

use serialize::base64::{self, ToBase64};
use serialize::hex::FromHex;

fn main() {
    let input = "49276d206b696c6c696e6720796f757220627261696e206c696b65206120706f69736f6e6f7573206d757368726f6f6d";
    let result = input.from_hex().unwrap().to_base64(base64::STANDARD);
    println!("{}", result);
}

结果：

SSdtIGtpbGxpbmcgeW91ciBicmFpbiBsaWtlIGEgcG9pc29ub3VzIG11c2hyb29t

Answer 3

对于您更新的问题，试试这个：

extern crate "rustc-serialize" as serialize;

use serialize::base64::{self, ToBase64};
use serialize::hex::FromHex;

fn main() {
    let input = "49276d206b696c6c696e6720796f757220627261696e206c696b65206120706f69736f6e6f7573206d757368726f6f6d";
    let result = input.from_hex().unwrap().as_slice().to_base64(base64::STANDARD);
    println!("{}", result);
}

（请注意，序列化现在位于外部 crate 中，请参阅 rustc-serialize。感谢 gsingh2011。）

from_hex 返回一个Result<Vec<u8>, FromHexError>，它被解包为Vec<u8>，然后用作&[u8] 和as_slice()。

Result 是Ok 或Err 的类型，通常从无法计算结果的方法返回。在上述情况下，unwrap 用于获取Ok 值。如果结果不是Ok，则失败（尝试从字符串中删除其中一个字母）。

根据你的程序做什么，错误情况应该使用匹配来明确处理：

match input.from_hex() {
    Ok(result) => println!("Yay: {}", result.as_slice().to_base64(base64::STANDARD)),
    Err(error) => println!("Nay: {}", error)
}

或者如果你只是想继续使用默认值，你可以使用unwrap_or：

println!("{}", input.from_hex().unwrap_or(vec!()).as_slice().to_base64(base64::STANDARD));

其他方法见documentation for Result。

Answer 4

我不知道你是什么意思 - 将十六进制值转换为 base64（fwiw 没有十六进制值之类的东西 - 它只是相同文字数字的另一种形式）。假设您要转换构成 int 值的字节，您可以执行以下操作：

extern crate serialize;

use std::mem;
use serialize::base64::{mod, ToBase64};

fn decompose_int(n: int, buf: &mut [u8]) {
    assert!(mem::size_of::<int>() == buf.len());
    for i in range(0, buf.len()) {
        buf[i] = ((n >> i*8) & 0xFF) as u8;
    }
}

fn main() {
    let mut bytes = [0u8, ..8];
    let x = 0x1122334455667788;
    decompose_int(x, &mut bytes);
    println!("{}", bytes.to_base64(base64::STANDARD));
}

（试试看here）

这里decompose_int 函数将int 值序列化为小端格式的字节片。然后这个切片照常转换为base64。

如果您需要大端表示，则需要将buf[i] 更改为buf[buf.len()-1-i]。