updated dependencies, release 1.0.15 (#94)

CMakeLists.txt

@@ -16,7 +16,7 @@ else()
     set(BUILD_SHARED_LIBS ON)
 endif()
 
-project(ecc VERSION 1.0.12)
+project(ecc VERSION 1.0.15)
 project(ecc LANGUAGES C)
 
 list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules)

bindings/js/dist/oprf.d.ts

@@ -2,41 +2,35 @@
  * Evaluates serialized representations of blinded group elements from the
  * client as inputs.
  *
- * See https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-voprf-08#section-3.3.1.1
- *
  * @param {Uint8Array} skS private key
  * @param {Uint8Array} blindedElement blinded element
  * @param {Uint8Array} info
- * @return {Promise<Uint8Array>} evaluated element
+ * @return {Uint8Array} evaluated element
  */
-export function oprf_ristretto255_sha512_Evaluate(skS: Uint8Array, blindedElement: Uint8Array, info: Uint8Array): Promise<Uint8Array>;
+export function oprf_Evaluate(skS: Uint8Array, blindedElement: Uint8Array, info: Uint8Array): Uint8Array;
 /**
- * Same as calling `oprf_ristretto255_sha512_Blind` with an
+ * Same as calling `oprf_Blind` with a
  * specified scalar blind.
  *
- * See https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-voprf-08#section-3.3.3.1
- *
  * @param {Uint8Array} input message to blind
  * @param {Uint8Array} blind scalar to use in the blind operation
  * @return {Uint8Array} blinded element
  */
-export function oprf_ristretto255_sha512_BlindWithScalar(input: Uint8Array, blind: Uint8Array): Uint8Array;
+export function oprf_BlindWithScalar(input: Uint8Array, blind: Uint8Array): Uint8Array;
 /**
- * See https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-voprf-08#section-3.3.3.1
  *
  * @param {Uint8Array} input message to blind
  * @return object {blind, blindedElement}
  */
-export function oprf_ristretto255_sha512_Blind(input: Uint8Array): Promise<{
+export function oprf_Blind(input: Uint8Array): {
     blind: Uint8Array;
     blindedElement: Uint8Array;
-}>;
+};
 /**
- * See https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-voprf-08#section-3.3.3.2
  *
  * @param input the input message
  * @param blind
  * @param evaluatedElement
  * @param {Uint8Array} info
  */
-export function oprf_ristretto255_sha512_Finalize(input: any, blind: any, evaluatedElement: any, info: Uint8Array): Promise<Uint8Array>;
+export function oprf_Finalize(input: any, blind: any, evaluatedElement: any, info: Uint8Array): Uint8Array;

bindings/js/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aldenml/ecc",
-  "version": "1.0.13",
+  "version": "1.0.15",
   "description": "elliptic curves crypto functions",
   "main": "index.js",
   "types": "./dist/index.d.ts",

bindings/jvm/build.gradle

@@ -12,7 +12,7 @@ plugins {
 }
 
 group = "org.ssohub"
-version = "1.0.13-RC1"
+version = "1.0.15"
 
 java {
     sourceCompatibility = JavaVersion.VERSION_1_8

bindings/jvm/gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.1.1-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.0.1-all.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

bindings/python/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2021-2022 Alden Torres
+Copyright (c) 2021-2023 Alden Torres
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

bindings/python/README.md

@@ -7,51 +7,52 @@
 
 This is the python binding of the [ecc](https://github.com/aldenml/ecc) library.
 
-It is a WebAssembly compilation with a thin layer on
-top to expose the cryptographic primitives.
-
 ### Features
 
-- [OPRF](#oprf-oblivious-pseudo-random-functions-using-ristretto255)
+- [OPRF](#oprf-oblivious-pseudo-random-functions)
 - [OPAQUE](#opaque-the-opaque-asymmetric-pake-protocol)
 - [Two-Round Threshold Schnorr Signatures with FROST](#two-round-threshold-schnorr-signatures-with-frost)
 - [Ethereum BLS Signature](#ethereum-bls-signature)
 - [BLS12-381 Pairing](#bls12-381-pairing)
 - [Proxy Re-Encryption (PRE)](#proxy-re-encryption-pre)
 
-### OPRF Oblivious pseudo-random functions using ristretto255
+### OPRF Oblivious pseudo-random functions
 
-This is an implementation of [draft-irtf-cfrg-voprf-16](https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-voprf-16)
+This is an implementation of [draft-irtf-cfrg-voprf-20](https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-voprf-20)
 ciphersuite **OPRF(ristretto255, SHA-512)** using `libsodium`.
 
-There are two variants in this protocol: a *base* mode and *verifiable* mode. In the
-base mode, a client and server interact to compute `output = F(skS, input, info)`,
-where `input` is the client's private input, `skS` is the server's private key, `info`
-is the public input, and `output` is the computation output. The client learns `output`
-and the server learns nothing. In the verifiable mode, the client also receives proof
-that the server used `skS` in computing the function.
+An Oblivious Pseudorandom Function (OPRF) is a two-party protocol between client
+and server for computing the output of a Pseudorandom Function (PRF). The server
+provides the PRF secret key, and the client provides the PRF input. At the end
+of the protocol, the client learns the PRF output without learning anything
+about the PRF secret key, and the server learns neither the PRF input nor
+output.
+
+There are two variations of the basic protocol:
+
+- VOPRF: is OPRF with the notion of verifiability. Clients can verify that the
+  server used a specific private key during the execution of the protocol.
+- POPRF: is a partially-oblivious VOPRF that allows clients and servers to
+  provide public input to the PRF computation.
 
-The flow is shown below (from the irtf draft):
+The OPRF flow is shown below (from the IRTF draft):
 ```
-  Client(input, info)                               Server(skS, info)
-  ----------------------------------------------------------------------
+    Client(input)                                        Server(skS)
+  -------------------------------------------------------------------
   blind, blindedElement = Blind(input)
 
                              blindedElement
                                ---------->
 
-                 evaluatedElement = Evaluate(skS, blindedElement, info)
+                evaluatedElement = BlindEvaluate(skS, blindedElement)
 
                              evaluatedElement
                                <----------
 
-  output = Finalize(input, blind, evaluatedElement, blindedElement, info)
+  output = Finalize(input, blind, evaluatedElement)
 ```
 
-In the verifiable mode of the protocol, the server additionally
-computes a proof in Evaluate. The client verifies this proof using
-the server's expected public key before completing the protocol and
-producing the protocol output.
+For the advanced modes VOPRF and POPRF refer to the published draft.
 
 ### OPAQUE The OPAQUE Asymmetric PAKE Protocol
 

bindings/python/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = libecc
-version = 1.0.12
+version = 1.0.15
 author = Alden Torres
 author_email = [email protected]
 description = elliptic curves crypto functions