Updated to t-variant and new protocol

src/cryptoservice.rs

@@ -3,40 +3,50 @@
 extern crate bls12_381;
 extern crate rand;
 
+use std::sync::RwLock;
+use bls12_381::pairing;
+use bls12_381::G2Affine;
+use std::sync::Mutex;
+use std::sync::Arc;
 use rocket_okapi::settings::UrlObject;
 use rocket_okapi::{openapi, openapi_get_routes, rapidoc::*, swagger_ui::*};
 use rocket::serde::json::Json;
 use rocket::Request;
 
-use ophe::core::{RatelimiterRequest,RatelimiterResponse};
+use ophe::core::{RatelimiterRequest,RatelimiterResponse,SetKeyHelper};
 use ophe::core;
 use ophe::utils;
 use rocket::State;
 use bls12_381::Scalar;
+use bls12_381::G1Affine;
 
 
 
-fn make_public_parameters() -> (Vec<Scalar>,core::PublicParameters){
-    let bytes = 32;
-    let k = 2;
-    let keysize = bytes*8/k;
-    let generator = utils::random_gt();
-    let keys = (0..keysize).map(|_|utils::random_scalar()).collect::<Vec<_>>();
-    let public_keys = keys.iter().map(|x|generator*x).collect::<Vec<_>>();
-    let space = utils::prepare_messages_to_space(k);
+fn make_public_parameters(key: Scalar) -> CryptoserviceState{
+    let generator = pairing(&G1Affine::generator(), &G2Affine::generator());
+    let public_key = generator * key;
 
-    (keys,core::PublicParameters{space, ratelimiter_public_keys:public_keys,gt_gen:generator,k})
+    let pp = core::PublicParameters{ratelimiter_public_key:public_key,gt_gen:generator};
+    CryptoserviceState{key,pp}
 }
 
 
+struct CryptoserviceState {
+    key: Scalar,
+    pp: core::PublicParameters,
+}
+
+type CryptoserviceStatePointer = Arc<RwLock<CryptoserviceState>>;
+
+
 #[rocket::main]
 async fn main() {
-    let (keys,pp) = make_public_parameters();
+    let c = make_public_parameters(utils::random_scalar());
+    let c_p:CryptoserviceStatePointer = Arc::new(RwLock::new(c));
 
     let launch_result = rocket::build()
-    .manage(pp)
-    .manage(keys)
-    .mount("/", openapi_get_routes![phe_help,get_public_parameters])
+    .manage(c_p)
+    .mount("/", openapi_get_routes![phe_help,get_public_parameters,set_key])
     .mount(
         "/swagger-ui/",
         make_swagger_ui(&SwaggerUIConfig {
@@ -69,16 +79,38 @@ async fn main() {
 
 #[openapi()]
 #[post("/phe_help",format = "json", data = "<request>")]
-fn phe_help(request: Json<RatelimiterRequest>,pp: &State<core::PublicParameters>,keys: &State<Vec<Scalar>>) -> Json<RatelimiterResponse> {
-    Json(core::phe_ratelimiter(keys,&request,pp))
+fn phe_help(request: Json<RatelimiterRequest>,c_state: &State<CryptoserviceStatePointer>) -> Json<RatelimiterResponse> {
+    
+    let (key,pp) = {
+        let c_state = c_state.read().unwrap();
+        (c_state.key.clone(),c_state.pp.clone())
+    };
+
+
+    Json(core::phe_ratelimiter(&key,&request,&pp))
 }
 
 #[openapi()]
 #[get("/get_public_parameters")]
-fn get_public_parameters(pp: &State<core::PublicParameters>) -> Json<&core::PublicParameters>{
+fn get_public_parameters(c_state: &State<CryptoserviceStatePointer>) -> Json<core::PublicParameters>{
+    let pp = c_state.read().unwrap().pp.clone();
     Json(pp)
 }
 
+
+#[openapi()]
+#[post("/set_key",format = "json", data = "<request>")]
+fn set_key(request: Json<SetKeyHelper>,c_state: &State<CryptoserviceStatePointer>) -> Json<core::PublicParameters> {
+    let new_c = make_public_parameters(request.key);
+
+    let mut c_state = c_state.write().unwrap();
+    c_state.key = new_c.key;
+    c_state.pp = new_c.pp;
+    
+
+    Json(new_c.pp)
+}
+
 #[catch(422)]
 fn serialize_failed(_req: &Request) -> String {
     format!("Malformed Request")