ligo/vendors/ocaml-uecc/test/test.ml

open Alcotest
open Uecc

let nb_iterations = 10

let checki = check int

let test_sksize () =
  checki __LOC__ 21 (sk_size secp160r1) ;
  checki __LOC__ 24 (sk_size secp192r1) ;
  checki __LOC__ 28 (sk_size secp224r1) ;
  checki __LOC__ 32 (sk_size secp256r1) ;
  checki __LOC__ 32 (sk_size secp256k1) ;
  ()

let test_pksize () =
  checki __LOC__ 40 (pk_size secp160r1) ;
  checki __LOC__ 48 (pk_size secp192r1) ;
  checki __LOC__ 56 (pk_size secp224r1) ;
  checki __LOC__ 64 (pk_size secp256r1) ;
  checki __LOC__ 64 (pk_size secp256k1) ;
  ()

let test_export_curve curve =
  match keypair curve with
  | None -> assert false
  | Some (sk, pk) ->
      let sk_bytes = to_bytes ~compress:false sk in
      let pk_bytes = to_bytes ~compress:false pk in
      checki __LOC__ (sk_size curve) (Bigstring.length sk_bytes) ;
      checki __LOC__ (pk_size curve + 1) (Bigstring.length pk_bytes) ;
      match sk_of_bytes curve sk_bytes,
            pk_of_bytes curve pk_bytes with
      | Some (sk', pk'), Some pk'' ->
          assert (equal sk sk') ;
          assert (equal pk pk') ;
          assert (equal pk pk'') ;
          assert (equal pk' pk') ;
      | _ -> assert false

let test_export_curve curve =
  for _i = 0 to nb_iterations - 1 do
    test_export_curve curve
  done

let test_export () =
  test_export_curve secp160r1 ;
  test_export_curve secp192r1 ;
  test_export_curve secp224r1 ;
  test_export_curve secp256r1 ;
  test_export_curve secp256k1 ;
  ()

let test_export_curve_compressed curve =
  match keypair curve with
  | None -> assert false
  | Some (sk, pk) ->
      let sk_bytes = to_bytes sk in
      let pk_bytes = to_bytes pk in
      checki __LOC__ (sk_size curve) (Bigstring.length sk_bytes) ;
      checki __LOC__ (compressed_size curve) (Bigstring.length pk_bytes) ;
      match sk_of_bytes curve sk_bytes,
            pk_of_bytes curve pk_bytes with
      | Some (sk', pk'), Some pk'' ->
          assert (equal sk sk') ;
          assert (equal pk pk') ;
          assert (equal pk pk'') ;
          assert (equal pk' pk') ;
      | _ -> assert false

let test_export_curve_compressed curve =
  for _i = 0 to nb_iterations - 1 do
    test_export_curve_compressed curve
  done

let test_export_compressed () =
  test_export_curve_compressed secp160r1 ;
  test_export_curve_compressed secp192r1 ;
  test_export_curve_compressed secp224r1 ;
  test_export_curve_compressed secp256r1 ;
  test_export_curve_compressed secp256k1 ;
  ()

let test_keypair_curve curve =
  match keypair curve with
  | None -> assert false
  | Some (sk, pk) ->
      assert (equal sk sk) ;
      assert (equal pk pk) ;
      let pk' = neuterize sk in
      assert (equal pk pk')

let test_keypair_curve curve =
  for _i = 0 to nb_iterations - 1 do
    test_keypair_curve curve
  done

let test_keypair () =
  test_keypair_curve secp160r1 ;
  test_keypair_curve secp192r1 ;
  test_keypair_curve secp224r1 ;
  test_keypair_curve secp256r1 ;
  test_keypair_curve secp256k1 ;
  ()

let test_dh_curve curve =
  match keypair curve, keypair curve with
  | Some (sk, pk), Some (sk', pk') ->
      begin match dh sk pk', dh sk' pk with
        | Some secret, Some secret' ->
            assert (Bigstring.equal secret secret')
        | _ -> assert false
      end
  | _ -> assert false

let test_dh_curve curve =
  for _i = 0 to nb_iterations - 1 do
    test_dh_curve curve
  done

let test_dh () =
  test_dh_curve secp160r1 ;
  test_dh_curve secp192r1 ;
  test_dh_curve secp224r1 ;
  test_dh_curve secp256r1 ;
  test_dh_curve secp256k1 ;
  ()

let msg =
  Bigstring.of_string "Voulez-vous coucher avec moi, ce soir ?"

let test_sign_curve curve =
  match keypair curve with
  | None -> assert false
  | Some (sk, pk) ->
      let signature = Bigstring.create (pk_size curve) in
      begin match write_sign sk signature ~msg with
        | nb_written when nb_written = (pk_size curve) ->
            assert (verify pk ~msg ~signature)
        | _ -> assert false
      end ;
      match sign sk msg with
      | None -> assert false
      | Some signature ->
          assert (verify pk ~msg ~signature)

let test_sign_curve curve =
  for _i = 0 to nb_iterations - 1 do
    test_sign_curve curve
  done

let test_sign () =
  test_sign_curve secp160r1 ;
  test_sign_curve secp192r1 ;
  test_sign_curve secp224r1 ;
  test_sign_curve secp256r1 ;
  test_sign_curve secp256k1 ;
  ()

let basic = [
  "sksize", `Quick, test_sksize ;
  "pksize", `Quick, test_pksize ;
  "export", `Quick, test_export ;
  "export_compressed", `Quick, test_export_compressed ;
  "keypair", `Quick, test_keypair ;
  "dh", `Quick, test_dh ;
  (* "sign", `Quick, test_sign ; *)
]

let () =
  Alcotest.run "uecc" [
    "basic", basic ;
  ]