zqlu 0.3.0

zqlu is a convenient text-based format for public keys
Documentation 
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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

// SPDX-License-Identifier: MIT OR Apache-2.0
// Copyright (c) 2026 The zqlu project contributors

use anyhow::Result;
use clap::Parser;
use std::fs::File;
use std::io;
use std::io::{Read, Write};
use std::path::PathBuf;
use zqlu::{Zqlu, parse};

/// This tool converts between the openssh and zqlu public key formats
#[derive(Parser)]
struct Cli {
    #[clap(short, long, value_name = "FILE")]
    input: Option<PathBuf>,
    #[clap(short, long, value_name = "FILE")]
    output: Option<PathBuf>,
    #[clap(short, long, conflicts_with = "fingerprint")]
    decode: bool,
    #[clap(short, long, conflicts_with = "decode")]
    fingerprint: bool,
}

fn main() -> Result<()> {
    let cli = Cli::parse();
    let input = read_input(cli.input)?;
    let result = transform(&input, cli.decode, cli.fingerprint)?;
    if let Some(output) = cli.output {
        // we want a newline at the end of the file
        let key = format!("{}\n", result);
        File::create(output)?.write_all(key.as_bytes())?;
    } else {
        println!("{}", result);
    }
    Ok(())
}

fn transform(input: &str, decode: bool, fingerprint: bool) -> Result<String> {
    if fingerprint {
        let key = parse(input)?;
        return Ok(key.fingerprint(Default::default()).to_string());
    }

    match decode {
        true => {
            let zqlu = Zqlu::new(input)?;
            let key = zqlu.public_key();
            Ok(key.to_openssh()?)
        }
        false => {
            let key = parse(input)?;
            Ok(Zqlu::from_public_key(&key)?.to_string())
        }
    }
}

fn read_input(maybe_file: Option<PathBuf>) -> Result<String> {
    Ok(match maybe_file {
        Some(input) => {
            let mut file = File::open(input)?;
            let mut buf = Vec::new();
            file.read_to_end(&mut buf)?;
            String::from_utf8(buf)?
        }
        None => {
            let mut buf = Vec::new();
            io::stdin().read_to_end(&mut buf)?;
            String::from_utf8(buf)?
        }
    })
}

#[cfg(test)]
mod tests {
    use super::transform;
    use anyhow::Result;
    use ssh_key::PublicKey;

    #[test]
    fn test_fingerprint_from_openssh() -> Result<()> {
        let input = include_str!("../tests/ed25519.openssh");
        let expected = PublicKey::from_openssh(input)?
            .fingerprint(Default::default())
            .to_string();

        assert_eq!(transform(input, false, true)?, expected);
        Ok(())
    }

    #[test]
    fn test_fingerprint_from_zqlu() -> Result<()> {
        let openssh = include_str!("../tests/ed25519.openssh");
        let zqlu = include_str!("../tests/ed25519.zq");
        let expected = PublicKey::from_openssh(openssh)?
            .fingerprint(Default::default())
            .to_string();

        assert_eq!(transform(zqlu, false, true)?, expected);
        Ok(())
    }
}