skytool 0.1.0-pre.2

an experimental API client for BlueSky / ATProto
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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

use crate::{input, options::output};
use camino::{Utf8Path, Utf8PathBuf};
use clap::{Args, Parser, ValueEnum};
use rand_chacha::ChaCha20Rng;
use rand_core::{CryptoRngCore, SeedableRng};
use rand_hc::Hc128Rng;
use rand_seeder::Seeder;

#[derive(Debug, thiserror::Error, miette::Diagnostic)]
#[error(transparent)]
#[remain::sorted]
pub(crate) enum Error {
  EllipticCurve(#[from] elliptic_curve::Error),
  Input(#[from] input::Error),
  Io(#[from] std::io::Error),
}

#[derive(Debug, Clone, clap::Parser)]
pub(crate) struct Command {
  #[clap(flatten)]
  input: input::InputOrOptions<Options>,
  #[command(flatten)]
  output_file: output::OutputFile,
}

impl crate::Output for Options {}

#[derive(Debug, Clone, clap::Parser, serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
#[command(about = "generates private keys")]
#[group(id = "key")]
#[remain::sorted]
#[rustfmt::skip]
#[schemars(rename = "KeyGenerationOptions")]
pub(crate) struct Options {
  #[arg(
    env  = "KEY_CURVE",
    long = "key-curve",
    id   = "key.curve",
    value_name    = "CURVE",
    default_value = "k256"
  )]
  curve: Curve,
  #[arg(
    env  = "OUTPUT_FORMAT",
    long = "output-format",
    id   = "output.format",
    value_name    = "FORMAT",
    default_value = "jwk",
    help_heading = "Output Options",
  )]
  format: Format,
  #[command(flatten)]
  rng: crate::options::rng::RngOptions,
}

impl Command {
  pub async fn run(self, valkey: &crate::integrations::fred::ValkeyOptions) -> Result<Box<dyn crate::Output>, Error> {
    let Self {
      input,
      output_file: output::OutputFile { path },
    } = self;

    let Options { curve, format, rng, .. } = input.consume()?;

    let mut rng = rng.to_crypto_rng();

    let key = SecretKey::new(&mut rng, &curve);

    let contents = format.encode(&key);

    match path {
      Some(path) => fs_err::write(path, contents)?,
      None => println!("{contents}"),
    }

    Ok(Box::new(()))
  }
}

#[derive(Debug, Clone, Copy, Default, clap::ValueEnum, serde::Deserialize, serde::Serialize, schemars::JsonSchema)]
#[clap(rename_all = "lowercase")]
#[remain::sorted]
pub enum Curve {
  #[default]
  K256,
  P256,
}

#[derive(Debug, Clone, Copy, Default, clap::ValueEnum, serde::Deserialize, serde::Serialize, schemars::JsonSchema)]
#[clap(rename_all = "lowercase")]
#[remain::sorted]
pub enum Format {
  #[default]
  Jwk,
}

impl Format {
  fn encode(&self, key: &SecretKey) -> String {
    match self {
      Self::Jwk => match key {
        SecretKey::K256(key) => key.to_jwk_string().to_string(),
        SecretKey::P256(key) => key.to_jwk_string().to_string(),
      },
    }
  }
}

#[derive(Debug, Clone)]
#[remain::sorted]
pub enum SecretKey {
  K256(k256::SecretKey),
  P256(p256::SecretKey),
}

impl SecretKey {
  fn new(rng: &mut impl CryptoRngCore, curve: &Curve) -> Self {
    match curve {
      Curve::K256 => Self::K256(k256::SecretKey::random(rng)),
      Curve::P256 => Self::P256(p256::SecretKey::random(rng)),
    }
  }
}