How to convert hexadecimal values to Base64 in Rust

Question

I'm having some issues understanding the concept of traits in Rust. I'm trying to encode a simple hex value to Base64 but with no luck, here is my code (with an example of string to Base64 also)

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 

The solution provided by Vladimir works for 0x notated hex values. Now I'm looking to convert a hex value that is represented in a string:

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() gives me a Vec<u8> and .to_base64() is expecting a buffer of u8, first I thought to convert the Vec<u8> to string and then use the as_bytes() to get the buffer, so far still no luck.

Answer 1

It is now 2017, and rustc-serialize is now deprecated as well (see here). The new big serialization library is called serde but I think that's a little heavy for this problem.

Here's a quick solution that manually converts from the String of hex to a Vec<u8> and then uses this to convert to a base64-encoded String.

I am not convinced that this for loop is anywhere near the best solution for converting a String of hex into a Vec<u8>, but I'm fairly new to Rust and this is all I've got. Comments/improvements are appreciated.

(Hey, wait a minute, I recognize these encoded strings, are you doing cryptopals?)

extern crate base64;
use std::u8;
use base64::{Engine as _, engine::general_purpose};

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),
        };
    };

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

Answer 2

Rust is currently evolving, and the accepted answer does not work properly any more. Specifically, the extern crate statement does not allow quoted parameters, and the name of the rustc-serialize crate is now rustc_serialize.

The following code correctly base64 encodes the string, yielding the same result as the accepted answer (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);
}

Result:

SSdtIGtpbGxpbmcgeW91ciBicmFpbiBsaWtlIGEgcG9pc29ub3VzIG11c2hyb29t

Answer 3

For your updated question, try this:

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);
}

(Note that serialize is now in an external crate, see rustc-serialize. Thanks to gsingh2011.)

from_hex returns a Result<Vec<u8>, FromHexError>, which is unwrapped to a Vec<u8>, then used as a &[u8] with as_slice().

Result is a type that is either Ok or Err and is usually returned from methods that can fail to compute a result. In the above case unwrap is used to get to the Ok value. If the result wasn't Ok, it fails (try it by removing one of the letters from the string).

Depending on what your program does, the error case should be handled explicitly using a match:

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

Or if you just want to continue with a default value, you can use unwrap_or:

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

See documentation for Result for other methods.

Answer 4

I'm not sure what do you mean - convert hex value to base64 (fwiw there is no such thing as hex value - it's just another form of the same literal number). Assuming that you want to convert bytes which make up int value, you can do something like this:

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));
}

(try it here)

Here decompose_int function serializes an int value into a slice of bytes in little endian format. Then this slice is converted to base64 as usual.

If you need big endian representation, you will need to change buf[i] to buf[buf.len()-1-i].