ligo/src/lib_crypto/crypto_box.mli

(**************************************************************************)
(*                                                                        *)
(*    Copyright (c) 2014 - 2018.                                          *)
(*    Dynamic Ledger Solutions, Inc. <contact@tezos.com>                  *)
(*                                                                        *)
(*    All rights reserved. No warranty, explicit or implicit, provided.   *)
(*                                                                        *)
(**************************************************************************)

(** Tezos - X25519/XSalsa20-Poly1305 cryptography *)

type nonce

val random_nonce : unit -> nonce
val increment_nonce : ?step:int -> nonce -> nonce
val nonce_encoding : nonce Data_encoding.t

type target
val default_target : target
val make_target : float -> target

type secret_key
type public_key
module Public_key_hash : S.INTERNAL_HASH
type channel_key

val public_key_encoding : public_key Data_encoding.t
val secret_key_encoding : secret_key Data_encoding.t

val hash : public_key -> Public_key_hash.t

val zerobytes : int
val boxzerobytes : int

val random_keypair : unit -> secret_key * public_key * Public_key_hash.t

val box : secret_key -> public_key -> MBytes.t -> nonce -> MBytes.t
val box_open : secret_key -> public_key -> MBytes.t -> nonce -> MBytes.t option

val box_noalloc : secret_key -> public_key -> nonce -> MBytes.t -> unit
val box_open_noalloc : secret_key -> public_key -> nonce -> MBytes.t -> bool

val precompute : secret_key -> public_key -> channel_key

val fast_box        : channel_key -> MBytes.t -> nonce -> MBytes.t
val fast_box_open   : channel_key -> MBytes.t -> nonce -> MBytes.t option

val fast_box_noalloc : channel_key -> nonce -> MBytes.t -> unit
val fast_box_open_noalloc : channel_key -> nonce -> MBytes.t -> bool

val check_proof_of_work : public_key -> nonce -> target -> bool
val generate_proof_of_work : ?max:int -> public_key -> target -> nonce
crypto box initial utility functions for encrypted communication using crypto box (X25519/XSalsa20-Poly1305) 2016-11-03 22:15:31 +04:00			`(**************************************************************************)`
			`(* *)`
Update copyright notice (2018) 2018-02-06 00:17:03 +04:00			`(* Copyright (c) 2014 - 2018. *)`
crypto box initial utility functions for encrypted communication using crypto box (X25519/XSalsa20-Poly1305) 2016-11-03 22:15:31 +04:00			`(* Dynamic Ledger Solutions, Inc. <contact@tezos.com> *)`
			`(* *)`
			`(* All rights reserved. No warranty, explicit or implicit, provided. *)`
			`(* *)`
			`(**************************************************************************)`

			`(** Tezos - X25519/XSalsa20-Poly1305 cryptography *)`

			`type nonce`

			`val random_nonce : unit -> nonce`
			`val increment_nonce : ?step:int -> nonce -> nonce`
Merge remote-tracking branch 'ocp/crypto-box' 2016-11-16 04:19:13 +04:00			`val nonce_encoding : nonce Data_encoding.t`

use 256 bit target for proof of work * SHA256 produces 256 bits pseudo-randomly uniformly, so you may compare to a 256 bit target to get a proof of work * If you pretend that the hash and targets are both integers between 0 and 2^256 - 1, then the target partitions the range into passing and failing segments. * In order to match the use of the `get_uint16` function from `ocplib-endian`, the easiest way to encode `target` is as a `int list` which works if not ideal * This seems like the same thing bitcoin does; difficulty there is actually not a primary notion but is calculated from a 256 bit target, which is what gets adjusted over time 2016-11-18 00:02:32 +04:00			`type target`
default target takes a couple seconds on my laptop to generate a proof of work with this target 2016-11-19 02:07:27 +04:00			`val default_target : target`
Shell: Add `Cryptobox.target_of_float` [target_of_float f] is `2 ^ (256 - f)`. 2017-01-23 14:09:51 +04:00			`val make_target : float -> target`
use 256 bit target for proof of work * SHA256 produces 256 bits pseudo-randomly uniformly, so you may compare to a 256 bit target to get a proof of work * If you pretend that the hash and targets are both integers between 0 and 2^256 - 1, then the target partitions the range into passing and failing segments. * In order to match the use of the `get_uint16` function from `ocplib-endian`, the easiest way to encode `target` is as a `int list` which works if not ideal * This seems like the same thing bitcoin does; difficulty there is actually not a primary notion but is calculated from a 256 bit target, which is what gets adjusted over time 2016-11-18 00:02:32 +04:00
Merge remote-tracking branch 'ocp/crypto-box' 2016-11-16 04:19:13 +04:00			`type secret_key`
			`type public_key`
Jbuilder: split `src/utils/` in multiple OPAM packages * `lib_stdlib`: basic extended OCaml stdlib and generic data structures * `lib_data_encoding`: almost independant 'Data_encoding' * `lib_error_monad`: almost independant 'Error_monad' * `lib_stdlib_lwt`: extended Lwt library * `lib_crypto`: all the crypto stuff (hashing, signing, cryptobox). * `lib_base`: - basic type definitions (Block_header, Operation, ...) - a module `TzPervasives` to bind them all and to be the single module opened everywhere. In the process, I splitted `Tezos_data` and `Hash` in multiple submodules, thus removing a lot of `-open`. The following two modules may not have found their place yet: - Base58 (currently in `lib_crypto`) - Cli_entries (currently in `lib_stdlib_lwt`) 2017-11-27 09:13:12 +04:00			`module Public_key_hash : S.INTERNAL_HASH`
Shell: add `Crypto_box.Public_key_hash` 2017-01-14 16:13:49 +04:00			`type channel_key`
Merge remote-tracking branch 'ocp/crypto-box' 2016-11-16 04:19:13 +04:00
			`val public_key_encoding : public_key Data_encoding.t`
			`val secret_key_encoding : secret_key Data_encoding.t`

Shell: add `Crypto_box.Public_key_hash` 2017-01-14 16:13:49 +04:00			`val hash : public_key -> Public_key_hash.t`
Crypto: drop libsodium We now use simpler OCaml bindings much easier to review. 2018-02-04 21:39:34 +04:00
			`val zerobytes : int`
			`val boxzerobytes : int`

Shell: add `Crypto_box.Public_key_hash` 2017-01-14 16:13:49 +04:00			`val random_keypair : unit -> secret_key * public_key * Public_key_hash.t`
Merge remote-tracking branch 'ocp/crypto-box' 2016-11-16 04:19:13 +04:00
crypto box initial utility functions for encrypted communication using crypto box (X25519/XSalsa20-Poly1305) 2016-11-03 22:15:31 +04:00			`val box : secret_key -> public_key -> MBytes.t -> nonce -> MBytes.t`
handle decryption exceptions 2016-11-08 02:38:02 +04:00			`val box_open : secret_key -> public_key -> MBytes.t -> nonce -> MBytes.t option`
Merge remote-tracking branch 'ocp/crypto-box' 2016-11-16 04:19:13 +04:00
Crypto: drop libsodium We now use simpler OCaml bindings much easier to review. 2018-02-04 21:39:34 +04:00			`val box_noalloc : secret_key -> public_key -> nonce -> MBytes.t -> unit`
			`val box_open_noalloc : secret_key -> public_key -> nonce -> MBytes.t -> bool`

Shell: add `Crypto_box.Public_key_hash` 2017-01-14 16:13:49 +04:00			`val precompute : secret_key -> public_key -> channel_key`
Crypto: drop libsodium We now use simpler OCaml bindings much easier to review. 2018-02-04 21:39:34 +04:00
Shell: add `Crypto_box.Public_key_hash` 2017-01-14 16:13:49 +04:00			`val fast_box : channel_key -> MBytes.t -> nonce -> MBytes.t`
			`val fast_box_open : channel_key -> MBytes.t -> nonce -> MBytes.t option`

Crypto: drop libsodium We now use simpler OCaml bindings much easier to review. 2018-02-04 21:39:34 +04:00			`val fast_box_noalloc : channel_key -> nonce -> MBytes.t -> unit`
			`val fast_box_open_noalloc : channel_key -> nonce -> MBytes.t -> bool`

use 256 bit target for proof of work * SHA256 produces 256 bits pseudo-randomly uniformly, so you may compare to a 256 bit target to get a proof of work * If you pretend that the hash and targets are both integers between 0 and 2^256 - 1, then the target partitions the range into passing and failing segments. * In order to match the use of the `get_uint16` function from `ocplib-endian`, the easiest way to encode `target` is as a `int list` which works if not ideal * This seems like the same thing bitcoin does; difficulty there is actually not a primary notion but is calculated from a 256 bit target, which is what gets adjusted over time 2016-11-18 00:02:32 +04:00			`val check_proof_of_work : public_key -> nonce -> target -> bool`
Shell: animated generation of `P2p.Identity` 2017-01-23 14:09:48 +04:00			`val generate_proof_of_work : ?max:int -> public_key -> target -> nonce`
Shell: add `Crypto_box.Public_key_hash` 2017-01-14 16:13:49 +04:00
Crypto: drop libsodium We now use simpler OCaml bindings much easier to review. 2018-02-04 21:39:34 +04:00