fix sk init, use future_sk
This commit is contained in:
parent
77d5327745
commit
09d0539537
10 changed files with 414 additions and 467 deletions
579
src/secmod.ml
579
src/secmod.ml
|
|
@ -1,6 +1,7 @@
|
|||
module type S = sig
|
||||
open Crypto
|
||||
|
||||
val sm_pubkey : eddsa_pub
|
||||
val sign_with_sm_key : string -> eddsa_sig
|
||||
val sign_with_signkey : pub:eddsa_pub -> string -> eddsa_sig
|
||||
val verify_with_master_key : eddsa_sig -> msg:string -> (unit, string) result
|
||||
|
|
@ -9,26 +10,20 @@ module type S = sig
|
|||
val verify_with_signkey :
|
||||
pub:eddsa_pub -> eddsa_sig -> msg:string -> (unit, string) result
|
||||
|
||||
(* TODO query database instead? *)
|
||||
val get_sm_key_pub : unit -> eddsa_pub
|
||||
val get_signkeys_data : unit -> Signkey_data.t list
|
||||
val get_denoms_data : unit -> Denom_data.t list
|
||||
val find_signkey_data : eddsa_pub -> Signkey_data.t option
|
||||
val find_denom_data : denomination_hash -> Denom_data.t option
|
||||
val find_denom_section_name : denomination_hash -> string option
|
||||
val get_signkeys : unit -> Signkey.t list
|
||||
val get_denominations : unit -> Denomination.t list
|
||||
val get_future_signkeys : unit -> Api.FutureSignKey.t list
|
||||
val get_future_denominations : unit -> Api.FutureDenom.t list
|
||||
val find_signkey : eddsa_pub -> Signkey.t option
|
||||
val find_denomination : denom_hash -> Denomination.t option
|
||||
|
||||
(* - management operations - *)
|
||||
(* TODO
|
||||
problem of keeping db and secmod state syncronized
|
||||
do db interaction from secmod? *)
|
||||
|
||||
val add_signkey_master_signatures :
|
||||
(eddsa_pub * Signatures.ExchangeSigningKeyValidity.t) list ->
|
||||
val certify_future_signkey :
|
||||
eddsa_pub ->
|
||||
Signatures.ExchangeSigningKeyValidity.t ->
|
||||
(unit, string) result
|
||||
|
||||
val add_denom_master_signatures :
|
||||
(denomination_hash * Signatures.DenominationKeyValidity.t) list ->
|
||||
(unit, string) result
|
||||
val certify_future_denomination :
|
||||
denom_hash -> Signatures.DenominationKeyValidity.t -> (unit, string) result
|
||||
|
||||
val revoke_signkey :
|
||||
eddsa_pub ->
|
||||
|
|
@ -36,156 +31,175 @@ module type S = sig
|
|||
(unit, string) result
|
||||
|
||||
val revoke_denomination :
|
||||
denomination_hash ->
|
||||
denom_hash ->
|
||||
Signatures.MasterDenominationKeyRevocation.t ->
|
||||
(unit, string) result
|
||||
|
||||
val store : unit -> (unit, string) result
|
||||
val save : unit -> (unit, string) result
|
||||
end
|
||||
|
||||
module Make (Conn : Pg.CONN) = struct
|
||||
(* TODO
|
||||
- key rotation
|
||||
- how many signkey to use?
|
||||
we just use 1 for now
|
||||
- does the secmod's own key as metadata/expiration date?
|
||||
- something to refer to valid sk/dn
|
||||
|
||||
- eddsa.ml with phantom type for key-kind + signed-data-kind *)
|
||||
open Syntax
|
||||
open Crypto
|
||||
module DenominationHash = Hash.DenominationHash
|
||||
|
||||
type signkey = {
|
||||
priv: eddsa_priv;
|
||||
sk_data: Signkey_data.t;
|
||||
}
|
||||
|
||||
type denom = {
|
||||
priv: rsa_priv;
|
||||
dn_data: Denom_data.t;
|
||||
}
|
||||
type sk = Signkey.t
|
||||
type future_sk = Api.FutureSignKey.t
|
||||
type dn = Denomination.t
|
||||
type future_dn = Api.FutureDenom.t
|
||||
|
||||
(* TODO ! use lock *)
|
||||
(* not sure what to do with coin section_name, rm if possible *)
|
||||
type t = {
|
||||
lock: Miou.Mutex.t;
|
||||
sm_key_priv: eddsa_priv;
|
||||
sm_key_pub: eddsa_pub;
|
||||
sk_ht: (eddsa_pub, signkey) Hashtbl.t;
|
||||
dn_ht: (denomination_hash, denom) Hashtbl.t;
|
||||
dn_section_name_ht: (denomination_hash, string) Hashtbl.t;
|
||||
sm_key: eddsa_priv;
|
||||
sm_pubkey: eddsa_pub;
|
||||
sk_ht: (eddsa_pub, sk) Hashtbl.t;
|
||||
dn_ht: (denom_hash, dn) Hashtbl.t;
|
||||
sk_key_ht: (eddsa_pub, eddsa_priv) Hashtbl.t;
|
||||
dn_key_ht: (denom_hash, rsa_priv) Hashtbl.t;
|
||||
future_sk_ht: (eddsa_pub, future_sk) Hashtbl.t;
|
||||
future_dn_ht: (denom_hash, future_dn) Hashtbl.t;
|
||||
future_sk_key_ht: (eddsa_pub, eddsa_priv) Hashtbl.t;
|
||||
future_dn_key_ht: (denom_hash, rsa_priv) Hashtbl.t;
|
||||
dn_section_name_ht: (denom_hash, string) Hashtbl.t;
|
||||
}
|
||||
|
||||
let db_lookup_signkey_data conn fname pub =
|
||||
let sm_key_fname = Fpath.(Config.secrets_dir / "sm_key")
|
||||
let sk_key_fname i = Fpath.(Config.secrets_dir / Fmt.str "sk_%d" i)
|
||||
|
||||
let dn_key_fname section_name =
|
||||
Fpath.(Config.secrets_dir / Fmt.str "dn_%s" section_name)
|
||||
|
||||
let database_find_sk conn pub =
|
||||
let* opt = Pg.find_signkey conn pub |> unwrap_err_caqti in
|
||||
match opt with
|
||||
| None ->
|
||||
Fmt.error
|
||||
"load_signkey error, no associated data found in database for \
|
||||
signkey `%s`."
|
||||
(Fpath.to_string fname)
|
||||
Fmt.error "secmod failure: a signkey could not be found in database"
|
||||
| Some sk_data -> Ok sk_data
|
||||
|
||||
let db_lookup_denom_data conn ~section_name priv =
|
||||
let pub = RsaPrivateKey.pub_of_priv priv in
|
||||
let h_pub = Hash.DenominationHash.hash (RsaPublicKey.to_octets pub) in
|
||||
let database_find_dn conn h_pub =
|
||||
let* opt = Pg.find_denom conn h_pub |> unwrap_err_caqti in
|
||||
match opt with
|
||||
| None ->
|
||||
Fmt.error
|
||||
"load_denom error no associated metadata found in database for \
|
||||
denomination `%s`."
|
||||
section_name
|
||||
"secmod failure: a denomination could not be found in database"
|
||||
| Some dn_data -> Ok dn_data
|
||||
|
||||
let load_signkey conn fname =
|
||||
let* opt = Data_file.read_eddsa fname in
|
||||
match opt with
|
||||
| None -> Ok None
|
||||
| Some priv ->
|
||||
let pub = EddsaPrivateKey.pub_of_priv priv in
|
||||
let* sk_data = db_lookup_signkey_data conn fname pub in
|
||||
let signkey = { priv; sk_data } in
|
||||
Ok (Some signkey)
|
||||
|
||||
(* TODO clean up *)
|
||||
let load conn =
|
||||
let error_invalid_state =
|
||||
Fmt.error "secmod load error: invalid store state."
|
||||
in
|
||||
let* sm_key_priv =
|
||||
Data_file.read_eddsa Fpath.(Config.secrets_dir / "sk_sm")
|
||||
in
|
||||
let* signkeys =
|
||||
let l =
|
||||
List.init 1 (fun i -> Fpath.(Config.secrets_dir / Fmt.str "sk_%d" i))
|
||||
in
|
||||
let* l = list_map (fun fname -> load_signkey conn fname) l in
|
||||
let* sm_key = Data_file.read_eddsa sm_key_fname in
|
||||
let* sk_keys =
|
||||
let l = List.init 1 sk_key_fname in
|
||||
let* l = list_map (fun fname -> Data_file.read_eddsa fname) l in
|
||||
match opt_list l with Error () -> error_invalid_state | Ok opt -> Ok opt
|
||||
in
|
||||
let dn_section_name_ht = Hashtbl.create 0xff in
|
||||
let* denoms =
|
||||
let* dn_keys =
|
||||
let* l =
|
||||
let open Config.Coin in
|
||||
list_map
|
||||
(fun coin ->
|
||||
let section_name = coin.section_name in
|
||||
let fname = Fpath.(Config.secrets_dir / section_name) in
|
||||
let* opt = Data_file.read_rsa fname in
|
||||
match opt with
|
||||
| None -> Ok None
|
||||
| Some priv ->
|
||||
(* todo: could check that coin config match db values *)
|
||||
let* dn_data = db_lookup_denom_data conn ~section_name priv in
|
||||
Hashtbl.replace dn_section_name_ht dn_data.h_pub section_name;
|
||||
let denom = { priv; dn_data } in
|
||||
Ok (Some denom))
|
||||
let+ opt = Data_file.read_rsa (dn_key_fname section_name) in
|
||||
Option.map (fun priv -> (section_name, priv)) opt)
|
||||
all_coins
|
||||
in
|
||||
match Syntax.opt_list l with
|
||||
| Error () -> error_invalid_state
|
||||
| Ok opt -> Ok opt
|
||||
in
|
||||
match (sm_key_priv, signkeys, denoms) with
|
||||
match (sm_key, sk_keys, dn_keys) with
|
||||
| None, None, None -> Ok None
|
||||
| Some sm_key_priv, Some signkeys, Some denoms ->
|
||||
let sm_key_pub = EddsaPrivateKey.pub_of_priv sm_key_priv in
|
||||
let lock = Miou.Mutex.create () in
|
||||
let sk_ht =
|
||||
signkeys
|
||||
|> List.map (fun v -> (v.sk_data.pub, v))
|
||||
|> List.to_seq
|
||||
|> Hashtbl.of_seq
|
||||
| Some sm_key, Some sk_keys, Some dn_keys ->
|
||||
let list_to_ht l = Hashtbl.of_seq (List.to_seq l) in
|
||||
let sm_pubkey = EddsaPrivateKey.pub_of_priv sm_key in
|
||||
(* sk *)
|
||||
let* l =
|
||||
list_map
|
||||
(fun priv ->
|
||||
let pub = EddsaPrivateKey.pub_of_priv priv in
|
||||
let+ sk = database_find_sk conn pub in
|
||||
((pub, sk), (pub, priv)))
|
||||
sk_keys
|
||||
in
|
||||
let dn_ht =
|
||||
denoms
|
||||
|> List.map (fun v -> (v.dn_data.h_pub, v))
|
||||
|> List.to_seq
|
||||
|> Hashtbl.of_seq
|
||||
let sk_ht, sk_key_ht =
|
||||
let sk_l, priv_l = List.split l in
|
||||
(list_to_ht sk_l, list_to_ht priv_l)
|
||||
in
|
||||
Ok
|
||||
(Some
|
||||
{ lock; sm_key_priv; sm_key_pub; sk_ht; dn_ht; dn_section_name_ht })
|
||||
(* dn *)
|
||||
let dn_section_name_ht = Hashtbl.create 0xff in
|
||||
let* l =
|
||||
list_map
|
||||
(fun (section_name, priv) ->
|
||||
let h_pub =
|
||||
priv
|
||||
|> RsaPrivateKey.pub_of_priv
|
||||
|> RsaPublicKey.to_octets
|
||||
|> DenominationHash.hash
|
||||
in
|
||||
|
||||
(* fill dn_section_name_ht *)
|
||||
Hashtbl.replace dn_section_name_ht h_pub section_name;
|
||||
|
||||
let+ dn = database_find_dn conn h_pub in
|
||||
((h_pub, dn), (h_pub, priv)))
|
||||
dn_keys
|
||||
in
|
||||
let dn_ht, dn_key_ht =
|
||||
match List.split l with l1, l2 -> (list_to_ht l1, list_to_ht l2)
|
||||
in
|
||||
(* future keys are not stored anywhere until they are certified with a master_sig
|
||||
so we don't have any future key to load *)
|
||||
let t =
|
||||
{
|
||||
sm_key;
|
||||
sm_pubkey;
|
||||
sk_ht;
|
||||
dn_ht;
|
||||
sk_key_ht;
|
||||
dn_key_ht;
|
||||
future_sk_ht= Hashtbl.create 0xff;
|
||||
future_dn_ht= Hashtbl.create 0xff;
|
||||
future_sk_key_ht= Hashtbl.create 0xff;
|
||||
future_dn_key_ht= Hashtbl.create 0xff;
|
||||
dn_section_name_ht;
|
||||
}
|
||||
in
|
||||
Ok (Some t)
|
||||
| _, _, _ -> error_invalid_state
|
||||
|
||||
let make_new_signkey () =
|
||||
let sign_with_sm_key t s = EddsaSignature.sign ~key:t.sm_key s
|
||||
|
||||
let make_future_sk t =
|
||||
let start = Time.Absolute.of_ptime (Ptime_clock.now ()) in
|
||||
let expire =
|
||||
Time.Absolute.add start Config.Exchange.signkey_legal_duration
|
||||
in
|
||||
let stamp_start = Time.Timestamp.of_absolute start in
|
||||
let stamp_expire = Time.Timestamp.of_absolute expire in
|
||||
let stamp_start = Timestamp.of_absolute start in
|
||||
let stamp_expire = Timestamp.of_absolute expire in
|
||||
let stamp_end = stamp_expire in
|
||||
let priv, pub = Mirage_crypto_ec.Ed25519.generate () in
|
||||
let master_sig = None in
|
||||
let revoked_sig = None in
|
||||
let sk_data =
|
||||
Signkey_data.
|
||||
{ pub; stamp_start; stamp_expire; stamp_end; master_sig; revoked_sig }
|
||||
let signkey_secmod_sig =
|
||||
let open Signatures.SigningKeyAnnouncement in
|
||||
let exchange_pub = pub in
|
||||
let anchor_time = stamp_start in
|
||||
let duration = Timestamp.diff stamp_start stamp_expire in
|
||||
sign_f ~f:(sign_with_sm_key t) { exchange_pub; anchor_time; duration }
|
||||
in
|
||||
{ priv; sk_data }
|
||||
let future_sk =
|
||||
Api.FutureSignKey.
|
||||
{ key= pub; stamp_start; stamp_expire; stamp_end; signkey_secmod_sig }
|
||||
in
|
||||
Hashtbl.replace t.future_sk_ht pub future_sk;
|
||||
Hashtbl.replace t.future_sk_key_ht pub priv;
|
||||
()
|
||||
|
||||
let make_new_denom
|
||||
let make_future_dn t
|
||||
Config.Coin.
|
||||
{
|
||||
section_name= _;
|
||||
section_name;
|
||||
value;
|
||||
duration_withdraw;
|
||||
duration_spend;
|
||||
|
|
@ -199,65 +213,76 @@ module Make (Conn : Pg.CONN) = struct
|
|||
age_restricted= _;
|
||||
} =
|
||||
assert (cipher = `RSA);
|
||||
let open Time in
|
||||
let start = Absolute.of_ptime (Ptime_clock.now ()) in
|
||||
let start = Time.Absolute.of_ptime (Ptime_clock.now ()) in
|
||||
let stamp_start = Timestamp.of_absolute start in
|
||||
let stamp_expire_withdraw =
|
||||
Timestamp.of_absolute @@ Absolute.add start duration_withdraw
|
||||
Timestamp.of_absolute @@ Time.Absolute.add start duration_withdraw
|
||||
in
|
||||
let stamp_expire_deposit =
|
||||
Timestamp.of_absolute @@ Absolute.add start duration_spend
|
||||
Timestamp.of_absolute @@ Time.Absolute.add start duration_spend
|
||||
in
|
||||
let stamp_expire_legal =
|
||||
Timestamp.of_absolute @@ Absolute.add start duration_legal
|
||||
Timestamp.of_absolute @@ Time.Absolute.add start duration_legal
|
||||
in
|
||||
|
||||
let priv, pub = RsaPrivateKey.generate ~bits:rsa_keysize () in
|
||||
let h_pub = Hash.DenominationHash.hash (RsaPublicKey.to_octets pub) in
|
||||
let master_sig = None in
|
||||
let revoked_sig = None in
|
||||
let dn_data =
|
||||
Denom_data.
|
||||
let open Api in
|
||||
let rsa_denomination_key =
|
||||
RsaDenominationKey.{ age_mask= 0; rsa_pub= pub }
|
||||
in
|
||||
let denom_pub = DenominationKey.Rsa rsa_denomination_key in
|
||||
let h_pub = DenominationHash.hash (RsaPublicKey.to_octets pub) in
|
||||
let denom_secmod_sig =
|
||||
let open Signatures.DenominationKeyAnnouncement in
|
||||
let h_denom_pub = h_pub in
|
||||
let h_section_name = Hash.Cstring.H64.hash section_name in
|
||||
let anchor_time = stamp_start in
|
||||
let duration_withdraw =
|
||||
Timestamp.diff stamp_start stamp_expire_withdraw
|
||||
in
|
||||
sign_f ~f:(sign_with_sm_key t)
|
||||
{ h_denom_pub; h_section_name; anchor_time; duration_withdraw }
|
||||
in
|
||||
let future_dn =
|
||||
FutureDenom.
|
||||
{
|
||||
pub;
|
||||
section_name;
|
||||
value;
|
||||
stamp_start;
|
||||
stamp_expire_withdraw;
|
||||
stamp_expire_deposit;
|
||||
stamp_expire_legal;
|
||||
denom_pub;
|
||||
fee_withdraw;
|
||||
fee_deposit;
|
||||
fee_refresh;
|
||||
fee_refund;
|
||||
age_mask= 0;
|
||||
h_pub;
|
||||
master_sig;
|
||||
revoked_sig;
|
||||
denom_secmod_sig;
|
||||
}
|
||||
in
|
||||
{ priv; dn_data }
|
||||
Hashtbl.replace t.future_dn_ht h_pub future_dn;
|
||||
Hashtbl.replace t.future_dn_key_ht h_pub priv;
|
||||
()
|
||||
|
||||
let make_new () =
|
||||
let lock = Miou.Mutex.create () in
|
||||
let sm_key_priv, sm_key_pub = Mirage_crypto_ec.Ed25519.generate () in
|
||||
let sk_ht =
|
||||
[ make_new_signkey () ]
|
||||
|> List.map (fun v -> (v.sk_data.pub, v))
|
||||
|> List.to_seq
|
||||
|> Hashtbl.of_seq
|
||||
let sm_key, sm_pubkey = Mirage_crypto_ec.Ed25519.generate () in
|
||||
let t =
|
||||
{
|
||||
sm_key;
|
||||
sm_pubkey;
|
||||
sk_ht= Hashtbl.create 0xff;
|
||||
dn_ht= Hashtbl.create 0xff;
|
||||
sk_key_ht= Hashtbl.create 0xff;
|
||||
dn_key_ht= Hashtbl.create 0xff;
|
||||
future_sk_ht= Hashtbl.create 0xff;
|
||||
future_dn_ht= Hashtbl.create 0xff;
|
||||
future_sk_key_ht= Hashtbl.create 0xff;
|
||||
future_dn_key_ht= Hashtbl.create 0xff;
|
||||
dn_section_name_ht= Hashtbl.create 0xff;
|
||||
}
|
||||
in
|
||||
let dn_section_name_ht = Hashtbl.create 0xff in
|
||||
let dn_ht =
|
||||
Config.Coin.all_coins
|
||||
|> List.map (fun coin ->
|
||||
let denom = make_new_denom coin in
|
||||
Hashtbl.replace dn_section_name_ht denom.dn_data.h_pub
|
||||
coin.section_name;
|
||||
(denom.dn_data.h_pub, denom))
|
||||
|> List.to_seq
|
||||
|> Hashtbl.of_seq
|
||||
in
|
||||
{ lock; sm_key_priv; sm_key_pub; sk_ht; dn_ht; dn_section_name_ht }
|
||||
make_future_sk t;
|
||||
List.iter (make_future_dn t) Config.Coin.all_coins;
|
||||
t
|
||||
|
||||
let t =
|
||||
match load (module Conn) with
|
||||
|
|
@ -270,142 +295,178 @@ module Make (Conn : Pg.CONN) = struct
|
|||
t
|
||||
| Error e -> Fmt.failwith "secmod init failure: %s." e
|
||||
|
||||
(* note: don't expose a signing function if we want a real "security module" one day *)
|
||||
let sign_with_sm_key s = EddsaSignature.sign ~key:t.sm_key_priv s
|
||||
let verify_with_sm_key s ~msg = EddsaSignature.verify ~key:t.sm_key_pub s ~msg
|
||||
let sm_pubkey = t.sm_pubkey
|
||||
let sign_with_sm_key s = sign_with_sm_key t s
|
||||
|
||||
let verify_with_master_key s ~msg =
|
||||
EddsaSignature.verify ~key:Config.master_public_key s ~msg
|
||||
|
||||
(* TODO
|
||||
- do something to force `pub` to be one of the valid signkey
|
||||
how to handle revocation?
|
||||
raise exn for now *)
|
||||
let sign_with_signkey ~pub s =
|
||||
Miou.Mutex.protect t.lock @@ fun () ->
|
||||
match Hashtbl.find_opt t.sk_ht pub with
|
||||
| None -> Fmt.failwith "secmod failure: public key not found."
|
||||
| Some signkey ->
|
||||
let v = EddsaSignature.sign ~key:signkey.priv s in
|
||||
v
|
||||
match Hashtbl.find_opt t.sk_key_ht pub with
|
||||
| None -> Fmt.failwith "secmod failure: signkey not found."
|
||||
| Some priv -> EddsaSignature.sign ~key:priv s
|
||||
|
||||
let verify_with_sm_key s ~msg = EddsaSignature.verify ~key:t.sm_pubkey s ~msg
|
||||
|
||||
let verify_with_master_key =
|
||||
EddsaSignature.verify ~key:Config.master_public_key
|
||||
|
||||
let verify_with_signkey ~pub s ~msg =
|
||||
Miou.Mutex.protect t.lock @@ fun () ->
|
||||
(* check that [pub] is one of our own keys *)
|
||||
match Hashtbl.find_opt t.sk_ht pub with
|
||||
| None -> Error "secmod failure: public key not found."
|
||||
| Some signkey -> EddsaSignature.verify ~key:signkey.sk_data.pub s ~msg
|
||||
| None -> Fmt.failwith "secmod failure: signkey not found."
|
||||
| Some _priv -> EddsaSignature.verify ~key:pub s ~msg
|
||||
|
||||
let get_sm_key_pub () = t.sm_key_pub
|
||||
let get_signkeys () = t.sk_ht |> Hashtbl.to_seq_values |> List.of_seq
|
||||
let get_denominations () = t.dn_ht |> Hashtbl.to_seq_values |> List.of_seq
|
||||
|
||||
let get_signkeys () =
|
||||
Miou.Mutex.protect t.lock @@ fun () ->
|
||||
Hashtbl.to_seq_values t.sk_ht |> List.of_seq
|
||||
let get_future_signkeys () =
|
||||
t.future_sk_ht |> Hashtbl.to_seq_values |> List.of_seq
|
||||
|
||||
let get_denoms () =
|
||||
Miou.Mutex.protect t.lock @@ fun () ->
|
||||
Hashtbl.to_seq_values t.dn_ht |> List.of_seq
|
||||
let get_future_denominations () =
|
||||
t.future_dn_ht |> Hashtbl.to_seq_values |> List.of_seq
|
||||
|
||||
let find_signkey pub =
|
||||
Miou.Mutex.protect t.lock @@ fun () -> Hashtbl.find_opt t.sk_ht pub
|
||||
let find_signkey pub = Hashtbl.find_opt t.sk_ht pub
|
||||
let find_denomination pub = Hashtbl.find_opt t.dn_ht pub
|
||||
|
||||
let find_denom h_denom =
|
||||
Miou.Mutex.protect t.lock @@ fun () -> Hashtbl.find_opt t.dn_ht h_denom
|
||||
|
||||
let get_signkeys_data () = get_signkeys () |> List.map (fun v -> v.sk_data)
|
||||
let get_denoms_data () = get_denoms () |> List.map (fun v -> v.dn_data)
|
||||
|
||||
let find_signkey_data pub =
|
||||
find_signkey pub |> Option.map (fun v -> v.sk_data)
|
||||
|
||||
let find_denom_data h_denom =
|
||||
find_denom h_denom |> Option.map (fun v -> v.dn_data)
|
||||
|
||||
let find_denom_section_name h_denom =
|
||||
Miou.Mutex.protect t.lock @@ fun () ->
|
||||
Hashtbl.find_opt t.dn_section_name_ht h_denom
|
||||
|
||||
let add_signkey_master_signatures l =
|
||||
Miou.Mutex.protect t.lock @@ fun () ->
|
||||
list_iter
|
||||
(fun (pub, master_sig) ->
|
||||
let certify_future_signkey pub master_sig =
|
||||
match
|
||||
( Hashtbl.find_opt t.future_sk_ht pub,
|
||||
Hashtbl.find_opt t.future_sk_key_ht pub )
|
||||
with
|
||||
| None, _ | _, None -> Error "secmod failure: future signkey not found."
|
||||
| Some future_sk, Some priv -> (
|
||||
match Hashtbl.find_opt t.sk_ht pub with
|
||||
| None -> Error "secmod failure: public key not found."
|
||||
| Some signkey ->
|
||||
let sk_data =
|
||||
{ signkey.sk_data with master_sig= Some master_sig }
|
||||
| Some _sk ->
|
||||
Error "secmod failure: this signkey already has a master signature"
|
||||
| None ->
|
||||
let Api.FutureSignKey.
|
||||
{
|
||||
key;
|
||||
stamp_start;
|
||||
stamp_expire;
|
||||
stamp_end;
|
||||
signkey_secmod_sig= _;
|
||||
} =
|
||||
future_sk
|
||||
in
|
||||
let signkey = { signkey with sk_data } in
|
||||
let* () =
|
||||
Pg.insert_signkey (module Conn) sk_data |> unwrap_err_caqti
|
||||
let sk =
|
||||
Signkey.
|
||||
{
|
||||
pub= key;
|
||||
stamp_start;
|
||||
stamp_expire;
|
||||
stamp_end;
|
||||
master_sig;
|
||||
revoked_sig= None;
|
||||
}
|
||||
in
|
||||
Hashtbl.replace t.sk_ht pub signkey;
|
||||
Ok ())
|
||||
l
|
||||
Hashtbl.replace t.sk_ht pub sk;
|
||||
Hashtbl.replace t.sk_key_ht pub priv;
|
||||
Hashtbl.remove t.future_sk_ht pub;
|
||||
Hashtbl.remove t.future_sk_key_ht pub;
|
||||
|
||||
let add_denom_master_signatures l =
|
||||
Miou.Mutex.protect t.lock @@ fun () ->
|
||||
list_iter
|
||||
(fun (h_denom_pub, master_sig) ->
|
||||
match Hashtbl.find_opt t.dn_ht h_denom_pub with
|
||||
| None -> Error "secmod failure: denomination hash not found."
|
||||
| Some denom ->
|
||||
let dn_data = { denom.dn_data with master_sig= Some master_sig } in
|
||||
let denom = { denom with dn_data } in
|
||||
let* () =
|
||||
Pg.insert_denom (module Conn) dn_data |> unwrap_err_caqti
|
||||
in
|
||||
Hashtbl.replace t.dn_ht h_denom_pub denom;
|
||||
let* () = Pg.insert_signkey (module Conn) sk |> unwrap_err_caqti in
|
||||
Ok ())
|
||||
l
|
||||
|
||||
let revoke_signkey exchange_pub revoked_sig =
|
||||
Miou.Mutex.protect t.lock @@ fun () ->
|
||||
match Hashtbl.find_opt t.sk_ht exchange_pub with
|
||||
| None -> Error "secmod failure: denomination hash not found."
|
||||
| Some signkey ->
|
||||
let sk_data = { signkey.sk_data with revoked_sig= Some revoked_sig } in
|
||||
let signkey = { signkey with sk_data } in
|
||||
Hashtbl.replace t.sk_ht exchange_pub signkey;
|
||||
let certify_future_denomination h_pub master_sig =
|
||||
match
|
||||
( Hashtbl.find_opt t.future_dn_ht h_pub,
|
||||
Hashtbl.find_opt t.future_dn_key_ht h_pub )
|
||||
with
|
||||
| None, _ | _, None ->
|
||||
Error "secmod failure: future denomination not found."
|
||||
| Some future_dn, Some priv -> (
|
||||
match Hashtbl.find_opt t.dn_ht h_pub with
|
||||
| Some _dn ->
|
||||
Error
|
||||
"secmod failure: this denomination already has a master signature"
|
||||
| None ->
|
||||
let 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;
|
||||
denom_secmod_sig= _;
|
||||
} =
|
||||
future_dn
|
||||
in
|
||||
let rsa_pub =
|
||||
match denom_pub with
|
||||
| Rsa Api.RsaDenominationKey.{ age_mask= _; rsa_pub } -> rsa_pub
|
||||
in
|
||||
let dn =
|
||||
Denomination.
|
||||
{
|
||||
pub= rsa_pub;
|
||||
value;
|
||||
stamp_start;
|
||||
stamp_expire_withdraw;
|
||||
stamp_expire_deposit;
|
||||
stamp_expire_legal;
|
||||
fee_withdraw;
|
||||
fee_deposit;
|
||||
fee_refresh;
|
||||
fee_refund;
|
||||
age_mask= 0;
|
||||
h_pub;
|
||||
master_sig;
|
||||
revoked_sig= None;
|
||||
}
|
||||
in
|
||||
Hashtbl.replace t.dn_ht h_pub dn;
|
||||
Hashtbl.replace t.dn_key_ht h_pub priv;
|
||||
Hashtbl.replace t.dn_section_name_ht h_pub section_name;
|
||||
Hashtbl.remove t.future_dn_ht h_pub;
|
||||
Hashtbl.remove t.future_dn_key_ht h_pub;
|
||||
|
||||
let* () = Pg.insert_denom (module Conn) dn |> unwrap_err_caqti in
|
||||
Ok ())
|
||||
|
||||
let revoke_signkey pub revoked_sig =
|
||||
match Hashtbl.find_opt t.sk_ht pub with
|
||||
| None -> Error "secmod failure: signkey not found."
|
||||
| Some sk ->
|
||||
let sk = { sk with revoked_sig= Some revoked_sig } in
|
||||
Hashtbl.replace t.sk_ht pub sk;
|
||||
|
||||
(* TODO revoke, apply to database *)
|
||||
Ok ()
|
||||
|
||||
let revoke_denomination h_denom_pub revoked_sig =
|
||||
Miou.Mutex.protect t.lock @@ fun () ->
|
||||
match Hashtbl.find_opt t.dn_ht h_denom_pub with
|
||||
| None -> Error "secmod failure: denomination hash not found."
|
||||
| Some denom ->
|
||||
let dn_data = { denom.dn_data with revoked_sig= Some revoked_sig } in
|
||||
let denom = { denom with dn_data } in
|
||||
Hashtbl.replace t.dn_ht h_denom_pub denom;
|
||||
let revoke_denomination pub revoked_sig =
|
||||
match Hashtbl.find_opt t.dn_ht pub with
|
||||
| None -> Error "secmod failure: denomination not found."
|
||||
| Some dn ->
|
||||
let dn = { dn with revoked_sig= Some revoked_sig } in
|
||||
Hashtbl.replace t.dn_ht pub dn;
|
||||
|
||||
(* TODO revoke, apply to database *)
|
||||
Ok ()
|
||||
|
||||
let store () =
|
||||
Miou.Mutex.protect t.lock @@ fun () ->
|
||||
let save () =
|
||||
let* () = Data_file.write_eddsa sm_key_fname t.sm_key in
|
||||
let* () =
|
||||
Data_file.write_eddsa Fpath.(Config.secrets_dir / "sk_sm") t.sm_key_priv
|
||||
in
|
||||
let* () =
|
||||
Hashtbl.to_seq_values t.sk_ht
|
||||
Hashtbl.to_seq_values t.sk_key_ht
|
||||
|> List.of_seq
|
||||
|> List.mapi (fun i (key : signkey) ->
|
||||
let fname = Fpath.(Config.secrets_dir / Fmt.str "sk_%d" i) in
|
||||
(fname, key.priv))
|
||||
|> list_iter (fun (fname, key) -> Data_file.write_eddsa fname key)
|
||||
|> List.mapi (fun i priv -> Data_file.write_eddsa (sk_key_fname i) priv)
|
||||
|> list_iter Fun.id
|
||||
in
|
||||
let* () =
|
||||
let* l =
|
||||
Hashtbl.to_seq_values t.dn_ht
|
||||
|> List.of_seq
|
||||
|> Syntax.list_map (fun (key : denom) ->
|
||||
let+ section_name =
|
||||
match Hashtbl.find_opt t.dn_section_name_ht key.dn_data.h_pub with
|
||||
| None -> Error "invalid state, section_name not found"
|
||||
| Some s -> Ok s
|
||||
in
|
||||
let fname = Fpath.(Config.secrets_dir / section_name) in
|
||||
(fname, key.priv))
|
||||
in
|
||||
list_iter (fun (fname, key) -> Data_file.write_rsa fname key) l
|
||||
Hashtbl.to_seq t.dn_key_ht
|
||||
|> List.of_seq
|
||||
|> list_iter (fun (pub, priv) ->
|
||||
let* section_name =
|
||||
match Hashtbl.find_opt t.dn_section_name_ht pub with
|
||||
| None -> Error "invalid state, section_name not found"
|
||||
| Some s -> Ok s
|
||||
in
|
||||
Data_file.write_rsa (dn_key_fname section_name) priv)
|
||||
in
|
||||
Logs.info (fun m -> m "stored secmod data to file");
|
||||
Logs.info (fun m -> m "saved secmod private keys data");
|
||||
Ok ()
|
||||
end
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue