mte/tools/offline.ml

(* TODO
   - clean up cmdliner
   - setup
   - sign *)
(* doc: https://docs.taler.net/manpages/taler-exchange-offline.1.html *)

let download ~base_url ~output =
  let open Bos in
  let uri =
    Uri.with_path (Uri.of_string base_url) "/management/keys/" |> Uri.to_string
  in
  let wget = Cmd.(v "wget" % "-O" % output % uri) in
  OS.Cmd.run wget

let setup ~output =
  let output = Fpath.v output in
  let () = Mirage_crypto_rng_unix.use_default () in
  let priv, _pub = Mirage_crypto_ec.Ed25519.generate () in
  let priv_data = Mirage_crypto_ec.Ed25519.priv_to_octets priv in
  Bos.OS.File.write output priv_data

let _denom_signature master_priv master_pub
    Api.FutureDenom.
      {
        section_name= _;
        value;
        stamp_start;
        stamp_expire_withdraw;
        stamp_expire_deposit;
        stamp_expire_legal;
        denom_pub;
        fee_withdraw;
        fee_deposit;
        fee_refresh;
        fee_refund= _;
        (* TODO check sigs *)
        denom_secmod_sig= _;
      } =
  let pub_octets =
    let denom_pub =
      match denom_pub with
      | Rsa v -> v
      | CS _ -> Fmt.failwith "CS key types are not supported."
    in
    let pub = denom_pub.Api.RsaDenominationKey.rsa_pub in
    Crypto.RsaPublicKey.to_octets pub
  in
  let h_denom_pub = Api.HashCode.hash pub_octets in
  let master_sig =
    let open Bin_type in
    let open Bin_signature.DenominationKeyValidityPS in
    let of_time ts : TimeAbsoluteNBO.t =
      TimeAbsoluteNBO.of_int64 @@ Api.Timestamp.to_int64 ts
    in
    let of_amount v = AmountNBO.of_amount v in
    let denom_key_validity =
      {
        master= master_pub;
        start= of_time stamp_start;
        expire_withdraw= of_time stamp_expire_withdraw;
        expire_spend= of_time stamp_expire_deposit;
        expire_legal= of_time stamp_expire_legal;
        value= of_amount value;
        fee_withdraw= of_amount fee_withdraw;
        fee_deposit= of_amount fee_deposit;
        fee_refresh= of_amount fee_refresh;
        denom_hash= Bin_type.DenominationHash.hash pub_octets;
      }
    in
    let data = Bin.to_string bin denom_key_validity in
    Crypto.EddsaSignature.sign ~key:master_priv data
  in
  Api.DenomSignature.{ h_denom_pub; master_sig }

let sign ~input ~output ~master_key =
  let open Syntax in
  let open Bos.OS in
  let open Crypto in
  let input = Fpath.v input in
  let _output = Fpath.v output in
  let master_key = Fpath.v master_key in
  let* input = File.read input |> unwrap_err_msg in
  let* master_key = File.read master_key |> unwrap_err_msg in
  let _master_key = EddsaPrivateKey.of_octets master_key in
  let* _future_key_response = Api.decode Api.FutureKeysResponse.jsont input in
  (* TODO sign *)
  Ok ()

(* CLI *)

open Cmdliner
open Cmdliner.Term.Syntax

let setup_cmd =
  let doc = "Generate offline master keys" in
  let output =
    let doc = "Output file for the generated private Eddsa key." in
    Arg.(
      value
      & opt filepath "data/eddsa_master_offline"
      & info [ "o"; "output" ] ~doc)
  in
  Cmd.make (Cmd.info "setup" ~version:"%%VERSION%%" ~doc)
  @@
  let+ output = output in
  match setup ~output with
  | Error (`Msg err) ->
      Fmt.epr "Setup failure: %s@." err;
      exit 1
  | Ok () -> ()

let download_cmd =
  let doc = "Downloads /management/keys/" in
  let man =
    [ `S Manpage.s_description; `P "$(cmd) download /management/keys." ]
  in
  let output =
    let doc = "File to save data to be signed." in
    Arg.(value & opt filepath "future_keys.json" & info [ "o"; "output" ] ~doc)
  in
  let base_url =
    let doc = "Base url of the exchange." in
    Arg.(value & opt string "http://localhost:3434/" & info [ "base-url" ] ~doc)
  in
  Cmd.make (Cmd.info "download" ~version:"%%VERSION%%" ~doc ~man)
  @@
  let+ output = output and+ base_url = base_url in
  match download ~base_url ~output with
  | Error (`Msg err) ->
      Fmt.epr "Download failure: %s@." err;
      exit 1
  | Ok () -> ()

let sign_cmd =
  let doc = "Sign FutureKeysResponse." in
  let input =
    let doc = "File with FutureKeysResponse data." in
    Arg.(value & opt filepath "future_keys.json" & info [ "i"; "input" ] ~doc)
  in
  let output =
    let doc = "File to save signature to." in
    Arg.(
      value
      & opt filepath "master_signatures.json"
      & info [ "o"; "output" ] ~doc)
  in
  let master_key =
    let doc = "Master offline Eddsa private key file." in
    Arg.(
      value
      & opt filepath "data/eddsa_master_offline"
      & info [ "master-key" ] ~doc)
  in
  Cmd.make (Cmd.info "sign" ~version:"%%VERSION%%" ~doc)
  @@
  let+ input = input and+ output = output and+ master_key = master_key in
  match sign ~input ~output ~master_key with
  | Error (*`Msg*) err ->
      Fmt.epr "Signature failure: %s@." err;
      exit 1
  | Ok () -> ()

let main () = Cmd.eval setup_cmd
let _main () = Cmd.eval download_cmd
let __main () = Cmd.eval sign_cmd
let () = if !Sys.interactive then () else exit (main ())