balsoft/ligo
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
daf3343dc1
ligo/src/utils/crypto_box.ml

81 lines
2.8 KiB
OCaml
Raw Normal View History

crypto box initial utility functions for encrypted communication using crypto box (X25519/XSalsa20-Poly1305)
2016-11-03 22:15:31 +04:00
(**************************************************************************)
(* *)
(* Copyright (c) 2014 - 2016. *)
(* Dynamic Ledger Solutions, Inc. <contact@tezos.com> *)
(* *)
(* All rights reserved. No warranty, explicit or implicit, provided. *)
(* *)
(**************************************************************************)
Merge remote-tracking branch 'ocp/crypto-box'
2016-11-16 04:19:13 +04:00
open Utils
crypto box initial utility functions for encrypted communication using crypto box (X25519/XSalsa20-Poly1305)
2016-11-03 22:15:31 +04:00
(** Tezos - X25519/XSalsa20-Poly1305 cryptography *)
type secret_key = Sodium.Box.secret_key
type public_key = Sodium.Box.public_key
type channel_key = Sodium.Box.channel_key
type nonce = Sodium.Box.nonce
Shell: reduce difficulty for P2P identity... ... until we properly store the nonce in the configuration file, together with the expected difficulty.
2016-11-25 21:03:57 +04:00
type target = int64 list (* used as unsigned intergers... *)
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
exception TargetNot256Bit
crypto box initial utility functions for encrypted communication using crypto box (X25519/XSalsa20-Poly1305)
2016-11-03 22:15:31 +04:00
let random_keypair = Sodium.Box.random_keypair
let random_nonce = Sodium.Box.random_nonce
let increment_nonce = Sodium.Box.increment_nonce
let box = Sodium.Box.Bigbytes.box
handle decryption exceptions
2016-11-08 02:38:02 +04:00
let box_open sk pk msg nonce =
try Some (Sodium.Box.Bigbytes.box_open sk pk msg nonce) with
| Sodium.Verification_failure -> None
Merge remote-tracking branch 'ocp/crypto-box'
2016-11-16 04:19:13 +04:00
Shell: reduce difficulty for P2P identity... ... until we properly store the nonce in the configuration file, together with the expected difficulty.
2016-11-25 21:03:57 +04:00
let make_target target =
if List.length target > 8 then raise TargetNot256Bit ;
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
Shell: reduce difficulty for P2P identity... ... until we properly store the nonce in the configuration file, together with the expected difficulty.
2016-11-25 21:03:57 +04:00
(* Compare a SHA256 hash to a 256bits-target prefix.
The prefix is a list of "unsigned" int64. *)
let compare_target hash target =
let rec check offset = function
| [] -> true
| x :: xs ->
Compare.Uint64.(EndianString.BigEndian.get_int64 hash offset < x)
&& check (offset + 8) xs in
check 0 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
let default_target =
Shell: reduce difficulty for P2P identity... ... until we properly store the nonce in the configuration file, together with the expected difficulty.
2016-11-25 21:03:57 +04:00
(* FIXME we use an easy target until we allow custom configuration. *)
[ Int64.shift_left 1L 48 ]
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
let check_proof_of_work pk nonce target =
Shell: reduce difficulty for P2P identity... ... until we properly store the nonce in the configuration file, together with the expected difficulty.
2016-11-25 21:03:57 +04:00
let hash =
let hash = Cryptokit.Hash.sha256 () in
hash#add_string (Bytes.to_string @@ Sodium.Box.Bytes.of_public_key pk) ;
hash#add_string (Bytes.to_string @@ Sodium.Box.Bytes.of_nonce nonce) ;
let r = hash#result in hash#wipe ; r in
compare_target hash 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
let generate_proof_of_work pk target =
proof of work start
2016-11-09 06:18:09 +04:00
let rec loop nonce =
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
if check_proof_of_work pk nonce target then nonce
proof of work start
2016-11-09 06:18:09 +04:00
else loop (increment_nonce nonce) in
loop (random_nonce ())
Merge remote-tracking branch 'ocp/crypto-box'
2016-11-16 04:19:13 +04:00
let public_key_encoding =
let open Data_encoding in
conv
Sodium.Box.Bigbytes.of_public_key
Sodium.Box.Bigbytes.to_public_key
(Fixed.bytes Sodium.Box.public_key_size)
let secret_key_encoding =
let open Data_encoding in
conv
Sodium.Box.Bigbytes.of_secret_key
Sodium.Box.Bigbytes.to_secret_key
(Fixed.bytes Sodium.Box.secret_key_size)
let nonce_encoding =
let open Data_encoding in
conv
Sodium.Box.Bigbytes.of_nonce
Sodium.Box.Bigbytes.to_nonce
(Fixed.bytes Sodium.Box.nonce_size)
Reference in New Issue Copy Permalink