diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..6985cf1 --- /dev/null +++ b/.gitignore @@ -0,0 +1,14 @@ +# Generated by Cargo +# will have compiled files and executables +debug/ +target/ + +# Remove Cargo.lock from gitignore if creating an executable, leave it for libraries +# More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html +Cargo.lock + +# These are backup files generated by rustfmt +**/*.rs.bk + +# MSVC Windows builds of rustc generate these, which store debugging information +*.pdb diff --git a/Cargo.toml b/Cargo.toml new file mode 100644 index 0000000..6aa3f31 --- /dev/null +++ b/Cargo.toml @@ -0,0 +1,23 @@ +[package] +name = "sdk_common" +version = "0.1.0" +edition = "2021" + +[lib] +crate-type = ["cdylib", "rlib"] + +[dependencies] +wasm-bindgen = "0.2.90" +serde = { version = "1.0.193", features = ["derive"] } +serde_json = "1.0.108" +# sp_backend = { git = "https://github.com/Sosthene00/sp-backend.git", branch = "master" } +# silentpayments = { git = "https://github.com/Sosthene00/rust-silentpayments", branch = "utils" } +rand = "0.8.5" +hex = "0.4.3" +uuid = { version = "1.6.1", features = ["serde", "v4"] } +sha2 = "0.10.8" +chrono = "0.4.31" +aes-gcm = "0.10.3" +aes = "0.8.3" +base64 = "0.21.7" +rocket = { version = "0.5.0", features = ["json"] } diff --git a/migrations.toml b/migrations.toml new file mode 100644 index 0000000..e69de29 diff --git a/src/lib.rs b/src/lib.rs new file mode 100644 index 0000000..c21f7c9 --- /dev/null +++ b/src/lib.rs @@ -0,0 +1,3 @@ +pub mod models; +pub mod wallet; +pub mod workflows; diff --git a/src/main.rs b/src/main.rs new file mode 100644 index 0000000..95f7962 --- /dev/null +++ b/src/main.rs @@ -0,0 +1,5 @@ +use sdk_common::models; +use sdk_common::wallet; +use sdk_common::workflows; + +fn main() {} diff --git a/src/models/commitment_method.rs b/src/models/commitment_method.rs new file mode 100644 index 0000000..17c2b3a --- /dev/null +++ b/src/models/commitment_method.rs @@ -0,0 +1,14 @@ +use rocket::FromForm; +use serde::{Deserialize, Serialize}; + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] +pub struct CommitmentMethod { + pub method: String, +} +impl CommitmentMethod { + pub fn new(method: String) -> Self { + CommitmentMethod { method } + } +} diff --git a/src/models/condition_cap.rs b/src/models/condition_cap.rs new file mode 100644 index 0000000..02901b1 --- /dev/null +++ b/src/models/condition_cap.rs @@ -0,0 +1,28 @@ +use rocket::FromForm; +use serde::{Deserialize, Serialize}; + +use super::role::TransactionMode; + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] +pub struct ConditionCap { + pub role_deposit: String, + pub role_transaction: TransactionMode, +} + +impl ConditionCap { + pub fn new(role_deposit: String, role_transaction: TransactionMode) -> Self { + ConditionCap { + role_deposit, + role_transaction, + } + } + // Affiche les informations de la structure + pub fn display_info(&self) { + println!("ConditionCap:"); + println!("Role Deposit: {}", self.role_deposit); + println!("Role Transaction:"); + self.role_transaction.display_info(); // Appelle display_info sur role_transaction + } +} diff --git a/src/models/condition_commitment.rs b/src/models/condition_commitment.rs new file mode 100644 index 0000000..b31f8fc --- /dev/null +++ b/src/models/condition_commitment.rs @@ -0,0 +1,26 @@ +use rocket::FromForm; +use serde::{Deserialize, Serialize}; + +use super::role::TransactionMode; +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] +pub struct ConditionCommitment { + pub role_artefact: String, + pub role_transaction: TransactionMode, +} + +impl ConditionCommitment { + pub fn new(role_artefact: String, role_transaction: TransactionMode) -> Self { + ConditionCommitment { + role_artefact, + role_transaction, + } + } + pub fn display_info(&self) { + println!("ConditionCommitment:"); + println!("Role Artefact: {}", self.role_artefact); + println!("Role Transaction:"); + self.role_transaction.display_info(); // Appelle display_info sur role_transaction + } +} diff --git a/src/models/condition_deposit.rs b/src/models/condition_deposit.rs new file mode 100644 index 0000000..a7f05ce --- /dev/null +++ b/src/models/condition_deposit.rs @@ -0,0 +1,27 @@ +use rocket::FromForm; +use serde::{Deserialize, Serialize}; + +use super::role::TransactionMode; +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct ConditionDeposit { + pub role_deposit: String, + pub role_transaction: TransactionMode, +} + +impl ConditionDeposit { + pub fn new(role_deposit: String, role_transaction: TransactionMode) -> Self { + ConditionDeposit { + role_deposit, + role_transaction, + } + } + pub fn display_info(&self) { + println!("ConditionDeposit:"); + println!("Role Deposit: {}", self.role_deposit); + println!("Role Transaction:"); + self.role_transaction.display_info(); // Appelle display_info sur role_transaction + } +} diff --git a/src/models/condition_orchestration.rs b/src/models/condition_orchestration.rs new file mode 100644 index 0000000..c0a9a94 --- /dev/null +++ b/src/models/condition_orchestration.rs @@ -0,0 +1,22 @@ +use rocket::FromForm; +use serde::{Deserialize, Serialize}; + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct ConditionOrchestration { + pub role_ok: String, + pub role_ko: String, +} + +impl ConditionOrchestration { + pub fn new(role_ok: String, role_ko: String) -> Self { + ConditionOrchestration { role_ok, role_ko } + } + pub fn display_info(&self) { + println!("ConditionOrchestration:"); + println!("Role OK: {}", self.role_ok); + println!("Role KO: {}", self.role_ko); + } +} diff --git a/src/models/condition_payment.rs b/src/models/condition_payment.rs new file mode 100644 index 0000000..2743d35 --- /dev/null +++ b/src/models/condition_payment.rs @@ -0,0 +1,28 @@ +use rocket::FromForm; +use serde::{Deserialize, Serialize}; + +use super::role::TransactionMode; + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct ConditionPayment { + pub role_payment: String, + pub role_transaction: TransactionMode, +} + +impl ConditionPayment { + pub fn new(role_payment: String, role_transaction: TransactionMode) -> Self { + ConditionPayment { + role_payment, + role_transaction, + } + } + pub fn display_info(&self) { + println!("ConditionPayment:"); + println!("Role Payment: {}", self.role_payment); + println!("Role Transaction:"); + self.role_transaction.display_info(); // Appelle display_info sur role_transaction + } +} diff --git a/src/models/condition_prd_address_set.rs b/src/models/condition_prd_address_set.rs new file mode 100644 index 0000000..8b89f31 --- /dev/null +++ b/src/models/condition_prd_address_set.rs @@ -0,0 +1,144 @@ +use rocket::FromForm; +use serde::{Deserialize, Serialize}; + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct ConditionPrdAddressSet { + pub from_role: String, + pub prd_sp_address_list: Vec, + pub prd_sp_address_required_list: Vec, + pub prd_sp_address_quota: i32, + pub prd_prd_value_ok_list: Vec, + pub prd_value_ko_list: Vec, + pub prd_value_none_list: Vec, + pub prd_sp_address_value_min: i64, + pub prd_sp_address_value_min_per: i64, + pub prd_sp_address_value_min_ok: bool, + pub prd_sp_adddress_value_ok_min_per: i64, + pub prd_sp_address_value_ok_max: i64, + pub prd_sp_adderss_value_ko_max_per: i64, + pub prd_sp_address_value_none_max: i64, + pub prd_sp_adderss_value_none_max_per: i64, + pub prd_sp_address_score_min: i32, + pub prd_sp_address_score_min_min_required: i32, + pub prd_sp_address_score_min_min_ok: bool, + pub prd_sp_address_score_min_min_per: i64, + pub prd_value_auto_ok: bool, + pub prd_value_auto_ko: bool, + pub prd_value_auto_none: bool, +} + +impl ConditionPrdAddressSet { + // Constructor for PrdAddressSet with all fields + pub fn new( + from_role: String, + prd_sp_address_list: Vec, + prd_sp_address_required_list: Vec, + prd_sp_address_quota: i32, + prd_prd_value_ok_list: Vec, + prd_value_ko_list: Vec, + prd_value_none_list: Vec, + prd_sp_address_value_min: i64, + prd_sp_address_value_min_per: i64, + prd_sp_address_value_min_ok: bool, + prd_sp_adddress_value_ok_min_per: i64, + prd_sp_address_value_ok_max: i64, + prd_sp_adderss_value_ko_max_per: i64, + prd_sp_address_value_none_max: i64, + prd_sp_adderss_value_none_max_per: i64, + prd_sp_address_score_min: i32, + prd_sp_address_score_min_min_required: i32, + prd_sp_address_score_min_min_ok: bool, + prd_sp_address_score_min_min_per: i64, + prd_value_auto_ok: bool, + prd_value_auto_ko: bool, + prd_value_auto_none: bool, + ) -> Self { + ConditionPrdAddressSet { + from_role, + prd_sp_address_list, + prd_sp_address_required_list, + prd_sp_address_quota, + prd_prd_value_ok_list, + prd_value_ko_list, + prd_value_none_list, + prd_sp_address_value_min, + prd_sp_address_value_min_per, + prd_sp_address_value_min_ok, + prd_sp_adddress_value_ok_min_per, + prd_sp_address_value_ok_max, + prd_sp_adderss_value_ko_max_per, + prd_sp_address_value_none_max, + prd_sp_adderss_value_none_max_per, + prd_sp_address_score_min, + prd_sp_address_score_min_min_required, + prd_sp_address_score_min_min_ok, + prd_sp_address_score_min_min_per, + prd_value_auto_ok, + prd_value_auto_ko, + prd_value_auto_none, + } + } + pub fn display_info(&self) { + println!("ConditionPrdAddressSet:"); + println!("From Role: {}", self.from_role); + println!("SP Address List: {:?}", self.prd_sp_address_list); + println!( + "SP Address Required List: {:?}", + self.prd_sp_address_required_list + ); + println!("SP Address Quota: {}", self.prd_sp_address_quota); + println!("PRD Value OK List: {:?}", self.prd_prd_value_ok_list); + println!("Value KO List: {:?}", self.prd_value_ko_list); + println!("Value None List: {:?}", self.prd_value_none_list); + println!("SP Address Value Min: {}", self.prd_sp_address_value_min); + println!( + "SP Address Value Min Percentage: {}", + self.prd_sp_address_value_min_per + ); + println!( + "SP Address Value Min OK: {}", + self.prd_sp_address_value_min_ok + ); + println!( + "SP Address Value OK Min Percentage: {}", + self.prd_sp_adddress_value_ok_min_per + ); + println!( + "SP Address Value OK Max: {}", + self.prd_sp_address_value_ok_max + ); + println!( + "SP Address Value KO Max Percentage: {}", + self.prd_sp_adderss_value_ko_max_per + ); + println!( + "SP Address Value None Max: {}", + self.prd_sp_address_value_none_max + ); + println!( + "SP Address Value None Max Percentage: {}", + self.prd_sp_adderss_value_none_max_per + ); + println!("SP Address Score Min: {}", self.prd_sp_address_score_min); + println!( + "SP Address Score Min Required: {}", + self.prd_sp_address_score_min_min_required + ); + println!( + "SP Address Score Min OK: {}", + self.prd_sp_address_score_min_min_ok + ); + println!( + "SP Address Score Min Percentage: {}", + self.prd_sp_address_score_min_min_per + ); + println!("Value Auto OK: {}", self.prd_value_auto_ok); + println!("Value Auto KO: {}", self.prd_value_auto_ko); + println!("Value Auto None: {}", self.prd_value_auto_none); + } + + // Methods for manipulating the struct can be added here as needed. +} diff --git a/src/models/condition_publish.rs b/src/models/condition_publish.rs new file mode 100644 index 0000000..8170329 --- /dev/null +++ b/src/models/condition_publish.rs @@ -0,0 +1,49 @@ +use rocket::FromForm; +use serde::{Deserialize, Serialize}; + +use super::metadata::Amount; +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct ConditionPublish { + pub pcd_data_size_max_unit: String, + pub pcd_data_size_max_total: i64, + pub pcd_number_min: i32, + pub pcd_number_max: i32, + pub pcd_amount_max_total: Amount, + pub prd_waiting_timeout: u64, + pub pcd_waiting_timeout: u64, +} + +impl ConditionPublish { + pub fn new( + pcd_data_size_max_unit: String, + pcd_data_size_max_total: i64, + pcd_number_min: i32, + pcd_number_max: i32, + pcd_amount_max_total: Amount, + prd_waiting_timeout: u64, + pcd_waiting_timeout: u64, + ) -> Self { + ConditionPublish { + pcd_data_size_max_unit, + pcd_data_size_max_total, + pcd_number_min, + pcd_number_max, + pcd_amount_max_total, + prd_waiting_timeout, + pcd_waiting_timeout, + } + } + pub fn display_info(&self) { + println!("ConditionPublish:"); + println!("PCD Data Size Max Unit: {}", self.pcd_data_size_max_unit); + println!("PCD Data Size Max Total: {}", self.pcd_data_size_max_total); + println!("PCD Number Min: {}", self.pcd_number_min); + println!("PCD Number Max: {}", self.pcd_number_max); + self.pcd_amount_max_total.display_info(); + println!("PRD Waiting Timeout: {}", self.prd_waiting_timeout); + println!("PCD Waiting Timeout: {}", self.pcd_waiting_timeout); + } +} diff --git a/src/models/deposit_method.rs b/src/models/deposit_method.rs new file mode 100644 index 0000000..2cf953d --- /dev/null +++ b/src/models/deposit_method.rs @@ -0,0 +1,11 @@ +use rocket::FromForm; +use serde::{Deserialize, Serialize}; + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct DepositMethod { + pub method: String, +} +impl DepositMethod {} diff --git a/src/models/item.rs b/src/models/item.rs new file mode 100644 index 0000000..0a06b6b --- /dev/null +++ b/src/models/item.rs @@ -0,0 +1,97 @@ +use rocket::FromForm; +use serde::{Deserialize, Serialize}; + +use uuid::Uuid; + +use super::{ + key_encryption::KeyEncryption, metadata_contract_public::MetadataContractPublic, + metadata_private::MetadataPrivate, metadata_role_confidential::MetadataRoleConfidential, + pcd_item_enc::PcdItemEnc, +}; + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct Item { + pub uuid: String, + pub version: i64, + pub hash: Option, + pub item_type: String, // `type` is a reserved keyword in Rust, renamed to `item_type` + pub name: String, + pub pagination_number_per_pcd: u32, + pub metadata_contract_public: MetadataContractPublic, + pub metadata_role_confidential: MetadataRoleConfidential, + pub metadata_private: MetadataPrivate, +} + +impl Item { + pub fn new( + version: i64, + item_type: String, + name: String, + pagination_number_per_pcd: u32, + metadata_contract_public: MetadataContractPublic, + metadata_role_confidential: MetadataRoleConfidential, + metadata_private: MetadataPrivate, + ) -> Self { + let uuid: String = Uuid::new_v4().to_string(); + Item { + uuid, + version, + item_type, + name, + pagination_number_per_pcd, + metadata_contract_public, + metadata_role_confidential, + metadata_private, + hash: None, + } + } + pub fn display_info(&self) { + println!("Item:"); + println!("UUID: {}", self.uuid); + println!("Version: {}", self.version); + println!("Item Type: {}", self.item_type); + println!("Name: {}", self.name); + println!( + "Pagination Number Per PCD: {}", + self.pagination_number_per_pcd + ); + + println!("Metadata Contract Public:"); + self.metadata_contract_public.display_info(); // Display information for `metadata_contract_public` + + println!("Metadata Role Confidential:"); + self.metadata_role_confidential.display_info(); // Display information for `metadata_role_confidential` + + println!("Metadata Private:"); + self.metadata_private.display_info(); // Display information for `metadata_private` + } + + pub fn enc( + &self, + process_public_enc_key: KeyEncryption, + member_private_enc_key: KeyEncryption, + ) -> PcdItemEnc { + let enc_metadata_contract_public = self + .metadata_contract_public + .enc_list(process_public_enc_key); + + let enc_metadata_role_confidential = self.metadata_role_confidential.enc_list(); + + let enc_metadata_private = self.metadata_private.enc_list(member_private_enc_key); + + PcdItemEnc::new( + self.version, + self.item_type.clone(), + self.name.clone(), + self.pagination_number_per_pcd, + enc_metadata_contract_public, + enc_metadata_role_confidential, + enc_metadata_private, + ) + } + + // Additional methods for Item can be added here +} diff --git a/src/models/item_artefact.rs b/src/models/item_artefact.rs new file mode 100644 index 0000000..bb4d513 --- /dev/null +++ b/src/models/item_artefact.rs @@ -0,0 +1,134 @@ +use rocket::FromForm; +use serde::{Deserialize, Serialize}; +use serde_json::json; +use std::hash::Hash; + +use super::item::Item; +use super::key_encryption::KeyEncryption; +use super::pcd_item_enc_attribute_private::PcdItemEncAttributePrivate; +use super::pcd_item_enc_attribute_public::PcdItemEncAttributePublic; +use super::pcd_item_enc_attribute_role_confidential::PcdItemEncAttributeRoleConfidential; +use super::pcd_item_generic_enc::PcdItemGenericEnc; + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, FromForm, Hash, PartialOrd, Ord, +)] +pub struct ItemArtefact { + pub item: Item, + pub public_attribute_group: Vec, // Assuming list of attributes + pub role_confidential_attribute_group: Vec, + pub private_attribute_group: Vec, +} + +impl ItemArtefact { + pub fn new( + item: Item, + public_attribute_group: Vec, + role_confidential_attribute_group: Vec, + private_attribute_group: Vec, + ) -> Self { + ItemArtefact { + item, + public_attribute_group, + role_confidential_attribute_group, + private_attribute_group, + } + } + pub fn enc_public_attribute_group( + &self, + process_public_enc_key: KeyEncryption, + ) -> Vec { + let mut enc_attribute_list: Vec = Vec::new(); + + let mut count = 0; + for public_attribute in &self.public_attribute_group { + let name = "index".to_owned() + &count.to_string(); + let value = serde_json::to_value(public_attribute).unwrap_or_else(|_| json!({})); + let enc_attribute = + PcdItemEncAttributePublic::new(name, process_public_enc_key.enc(value)); + enc_attribute_list.push(enc_attribute); + count += 1; + } + + enc_attribute_list + } + pub fn enc_role_confidential_attribute_group( + &self, + ) -> Vec { + let mut enc_attribute_list: Vec = Vec::new(); + + let mut count = 0; + for role_confidential_attribute in &self.role_confidential_attribute_group { + let name = "index".to_owned() + &count.to_string(); + let value = + serde_json::to_value(role_confidential_attribute).unwrap_or_else(|_| json!({})); + let mut role_confidential_attribute_key = + KeyEncryption::new(Some(name.clone()), None, None); + if let Ok(_new) = role_confidential_attribute_key.key_new_random() { + let enc_attribute = PcdItemEncAttributeRoleConfidential::new( + name, + role_confidential_attribute_key.enc(value), + role_confidential_attribute_key, + ); + enc_attribute_list.push(enc_attribute); + } + count += 1; + } + + enc_attribute_list + } + pub fn enc_private_attribute_group( + &self, + member_private_enc_key: KeyEncryption, + ) -> Vec { + let mut enc_attribute_list: Vec = Vec::new(); + + let mut count = 0; + for private_attribute in &self.public_attribute_group { + let name = "index".to_owned() + &count.to_string(); + let value = serde_json::to_value(private_attribute).unwrap_or_else(|_| json!({})); + let enc_attribute = + PcdItemEncAttributePrivate::new(name, member_private_enc_key.enc(value)); + enc_attribute_list.push(enc_attribute); + count += 1; + } + + enc_attribute_list + } + + pub fn enc( + &self, + process_public_enc_key: KeyEncryption, + member_private_enc_key: KeyEncryption, + ) -> PcdItemGenericEnc { + let enc_metadata_contract_public = + self.enc_public_attribute_group(process_public_enc_key.clone()); + + let enc_role_confidential_attribute_group = self.enc_role_confidential_attribute_group(); + + let enc_metadata_private = self.enc_private_attribute_group(member_private_enc_key.clone()); + + PcdItemGenericEnc::new( + self.item + .enc(process_public_enc_key, member_private_enc_key), + Some(enc_metadata_contract_public), + Some(enc_role_confidential_attribute_group), + Some(enc_metadata_private), + ) + } + pub fn display_info(&self) { + println!("ItemArtefact:"); + println!("Item:"); + self.item.display_info(); // Appelle display_info sur item + + println!("Public Attribute Group: {:?}", self.public_attribute_group); + println!( + "Role Confidential Attribute Group: {:?}", + self.role_confidential_attribute_group + ); + println!( + "Private Attribute Group: {:?}", + self.private_attribute_group + ); + } +} diff --git a/src/models/item_commitment.rs b/src/models/item_commitment.rs new file mode 100644 index 0000000..78c9ee9 --- /dev/null +++ b/src/models/item_commitment.rs @@ -0,0 +1,248 @@ +use rocket::FromForm; +use serde::{Deserialize, Serialize}; + +use super::{ + item::Item, key_encryption::KeyEncryption, + pcd_item_enc_attribute_private::PcdItemEncAttributePrivate, + pcd_item_enc_attribute_public::PcdItemEncAttributePublic, + pcd_item_enc_attribute_role_confidential::PcdItemEncAttributeRoleConfidential, + pcd_item_generic_enc::PcdItemGenericEnc, +}; + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct ItemCommitmentPublicAttributeGroup { + pub for_sp_address_list: Vec, + pub goal_list: Vec, + pub provider_type: String, + pub commitment_pcd_hash_list: Vec, + pub ref_item_hash_list: Vec, + pub ref_pcd_hash_list: Vec, + pub payload_public_list: Vec, +} + +impl ItemCommitmentPublicAttributeGroup { + pub fn new( + for_sp_address_list: Vec, + goal_list: Vec, + provider_type: String, + commitment_pcd_hash_list: Vec, + ref_item_hash_list: Vec, + ref_pcd_hash_list: Vec, + payload_public_list: Vec, + ) -> Self { + ItemCommitmentPublicAttributeGroup { + for_sp_address_list, + goal_list, + provider_type, + commitment_pcd_hash_list, + ref_item_hash_list, + ref_pcd_hash_list, + payload_public_list, + } + } + pub fn enc_group( + &self, + process_public_enc_key: KeyEncryption, + ) -> Vec { + let mut enc_attribute_list: Vec = Vec::new(); + + let for_sp_address_list_enc = PcdItemEncAttributePublic::new( + "for_sp_address_list".to_owned(), + process_public_enc_key.enc_vec_string(self.for_sp_address_list.clone()), + ); + enc_attribute_list.push(for_sp_address_list_enc); + + let goal_list_enc = PcdItemEncAttributePublic::new( + "goal_list".to_owned(), + process_public_enc_key.enc_vec_string(self.goal_list.clone()), + ); + enc_attribute_list.push(goal_list_enc); + + let provider_type_enc = PcdItemEncAttributePublic::new( + "provider_type".to_owned(), + process_public_enc_key.enc_string(self.provider_type.clone()), + ); + enc_attribute_list.push(provider_type_enc); + + let commitment_pcd_hash_list_enc = PcdItemEncAttributePublic::new( + "commitment_pcd_hash_list".to_owned(), + process_public_enc_key.enc_vec_string(self.commitment_pcd_hash_list.clone()), + ); + enc_attribute_list.push(commitment_pcd_hash_list_enc); + + let ref_item_hash_list_enc = PcdItemEncAttributePublic::new( + "ref_item_hash_list".to_owned(), + process_public_enc_key.enc_vec_string(self.ref_item_hash_list.clone()), + ); + enc_attribute_list.push(ref_item_hash_list_enc); + + let ref_pcd_hash_list_enc = PcdItemEncAttributePublic::new( + "ref_pcd_hash_list".to_owned(), + process_public_enc_key.enc_vec_string(self.ref_pcd_hash_list.clone()), + ); + enc_attribute_list.push(ref_pcd_hash_list_enc); + + let payload_public_list_enc = PcdItemEncAttributePublic::new( + "payload_public_list".to_owned(), + process_public_enc_key.enc_vec_string(self.payload_public_list.clone()), + ); + enc_attribute_list.push(payload_public_list_enc); + + enc_attribute_list + } + pub fn display_info(&self) { + println!("ItemCommitmentPublicAttributeGroup:"); + println!("For SP Address List: {:?}", self.for_sp_address_list); + println!("Goal List: {:?}", self.goal_list); + println!("Provider Type: {}", self.provider_type); + println!( + "Commitment PCD Hash List: {:?}", + self.commitment_pcd_hash_list + ); + println!("Ref Item Hash List: {:?}", self.ref_item_hash_list); + println!("Ref PCD Hash List: {:?}", self.ref_pcd_hash_list); + println!("Payload Public List: {:?}", self.payload_public_list); + } +} + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct ItemCommitmentRoleConfidentialAttributeGroup { + pub payload_list_confidential: Vec, +} + +impl ItemCommitmentRoleConfidentialAttributeGroup { + pub fn new(payload_list_confidential: Vec) -> Self { + ItemCommitmentRoleConfidentialAttributeGroup { + payload_list_confidential, + } + } + pub fn enc_group(&self) -> Vec { + let mut enc_attribute_list: Vec = Vec::new(); + + let mut payload_list_confidential_key = + KeyEncryption::new(Some("payload_list_confidential".to_owned()), None, None); + if let Ok(_new) = payload_list_confidential_key.key_new_random() { + let payload_list_confidential_enc = PcdItemEncAttributeRoleConfidential::new( + "payload_list_confidential".to_owned(), + payload_list_confidential_key + .enc_vec_string(self.payload_list_confidential.clone()), + payload_list_confidential_key, + ); + enc_attribute_list.push(payload_list_confidential_enc); + } + + return enc_attribute_list; + } + pub fn display_info(&self) { + println!("ItemCommitmentRoleConfidentialAttributeGroup:"); + for (index, payload) in self.payload_list_confidential.iter().enumerate() { + println!("Confidential Payload {}: {}", index + 1, payload); + } + } +} + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct ItemCommitmentPrivateAttributeGroup { + pub payload_list_private: Vec, +} + +impl ItemCommitmentPrivateAttributeGroup { + pub fn new(payload_list_private: Vec) -> Self { + ItemCommitmentPrivateAttributeGroup { + payload_list_private, + } + } + pub fn enc_group(&self, member_enc_key: KeyEncryption) -> Vec { + let mut enc_attribute_list: Vec = Vec::new(); + + let payload_list_private_enc = PcdItemEncAttributePrivate::new( + "payload_list_private".to_owned(), + member_enc_key.enc_vec_string(self.payload_list_private.clone()), + ); + enc_attribute_list.push(payload_list_private_enc); + + enc_attribute_list + } + pub fn display_info(&self) { + println!("ItemCommitmentRoleConfidentialAttributeGroup:"); + for (index, payload) in self.payload_list_private.iter().enumerate() { + println!("Private Payload {}: {}", index + 1, payload); + } + } +} + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct ItemCommitment { + pub item: Item, + pub public_attribute_group: ItemCommitmentPublicAttributeGroup, + pub role_confidential_attribute_group: ItemCommitmentRoleConfidentialAttributeGroup, + pub private_attribute_group: ItemCommitmentPrivateAttributeGroup, +} + +impl ItemCommitment { + pub const ITEM_NAME: &'static str = "commitment"; + pub fn new( + mut item: Item, + public_attribute_group: ItemCommitmentPublicAttributeGroup, + role_confidential_attribute_group: ItemCommitmentRoleConfidentialAttributeGroup, + private_attribute_group: ItemCommitmentPrivateAttributeGroup, + ) -> Self { + item.name = Self::ITEM_NAME.to_string(); + ItemCommitment { + item, + public_attribute_group, + role_confidential_attribute_group, + private_attribute_group, + } + } + pub fn enc( + &self, + process_public_enc_key: KeyEncryption, + member_private_enc_key: KeyEncryption, + ) -> PcdItemGenericEnc { + let enc_metadata_contract_public = self + .public_attribute_group + .enc_group(process_public_enc_key.clone()); + + let enc_role_confidential_attribute_group = + self.role_confidential_attribute_group.enc_group(); + + let enc_metadata_private = self + .private_attribute_group + .enc_group(member_private_enc_key.clone()); + + PcdItemGenericEnc::new( + self.item + .enc(process_public_enc_key, member_private_enc_key), + Some(enc_metadata_contract_public), + Some(enc_role_confidential_attribute_group), + Some(enc_metadata_private), + ) + } + pub fn display_info(&self) { + println!("ItemCommitment:"); + println!("Item:"); + self.item.display_info(); // Affiche les informations de `item` + + println!("Public Attribute Group:"); + self.public_attribute_group.display_info(); // Affiche les informations de `public_attribute_group` + + println!("Role Confidential Attribute Group:"); + self.role_confidential_attribute_group.display_info(); // Affiche les informations de `role_confidential_attribute_group` + + println!("Private Attribute Group:"); + self.private_attribute_group.display_info(); // Affiche les informations de `private_attribute_group` + } +} diff --git a/src/models/item_deposit.rs b/src/models/item_deposit.rs new file mode 100644 index 0000000..6b736e4 --- /dev/null +++ b/src/models/item_deposit.rs @@ -0,0 +1,286 @@ +use rocket::FromForm; +use serde::{Deserialize, Serialize}; + +use super::{ + item::Item, key_encryption::KeyEncryption, + pcd_item_enc_attribute_private::PcdItemEncAttributePrivate, + pcd_item_enc_attribute_public::PcdItemEncAttributePublic, + pcd_item_enc_attribute_role_confidential::PcdItemEncAttributeRoleConfidential, + pcd_item_generic_enc::PcdItemGenericEnc, +}; + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct ItemDepositPublicAttributeGroup { + pub for_sp_address_list: Vec, + pub for_address_list: Vec, + pub goal_list: Vec, + pub provider_type: String, + pub ref_item_hash_list: Vec, + pub ref_pcd_hash_list: Vec, + pub payload_list_public: Vec, + pub audit_code_list_public: Vec, +} + +impl ItemDepositPublicAttributeGroup { + pub fn new( + for_sp_address_list: Vec, + for_address_list: Vec, + goal_list: Vec, + provider_type: String, + ref_item_hash_list: Vec, + ref_pcd_hash_list: Vec, + payload_list_public: Vec, + audit_code_list_public: Vec, + ) -> Self { + ItemDepositPublicAttributeGroup { + for_sp_address_list, + for_address_list, + goal_list, + provider_type, + ref_item_hash_list, + ref_pcd_hash_list, + payload_list_public, + audit_code_list_public, + } + } + pub fn enc_group( + &self, + process_public_enc_key: KeyEncryption, + ) -> Vec { + let mut enc_attribute_list: Vec = Vec::new(); + + let for_sp_address_list_enc = PcdItemEncAttributePublic::new( + "for_sp_address_list".to_owned(), + process_public_enc_key.enc_vec_string(self.for_sp_address_list.clone()), + ); + enc_attribute_list.push(for_sp_address_list_enc); + + let for_address_list_enc = PcdItemEncAttributePublic::new( + "for_address_list".to_owned(), + process_public_enc_key.enc_vec_string(self.for_address_list.clone()), + ); + enc_attribute_list.push(for_address_list_enc); + + let goal_list_enc = PcdItemEncAttributePublic::new( + "goal_list".to_owned(), + process_public_enc_key.enc_vec_string(self.goal_list.clone()), + ); + enc_attribute_list.push(goal_list_enc); + + let provider_type_enc = PcdItemEncAttributePublic::new( + "provider_type".to_owned(), + process_public_enc_key.enc_string(self.provider_type.clone()), + ); + enc_attribute_list.push(provider_type_enc); + + let ref_item_hash_list_enc = PcdItemEncAttributePublic::new( + "ref_item_hash_list".to_owned(), + process_public_enc_key.enc_vec_string(self.ref_item_hash_list.clone()), + ); + enc_attribute_list.push(ref_item_hash_list_enc); + + let ref_pcd_hash_list_enc = PcdItemEncAttributePublic::new( + "ref_pcd_hash_list".to_owned(), + process_public_enc_key.enc_vec_string(self.ref_pcd_hash_list.clone()), + ); + enc_attribute_list.push(ref_pcd_hash_list_enc); + + let payload_list_public_enc = PcdItemEncAttributePublic::new( + "payload_list_public".to_owned(), + process_public_enc_key.enc_vec_string(self.payload_list_public.clone()), + ); + enc_attribute_list.push(payload_list_public_enc); + + let audit_code_list_public_enc = PcdItemEncAttributePublic::new( + "audit_code_list_public".to_owned(), + process_public_enc_key.enc_vec_string(self.audit_code_list_public.clone()), + ); + enc_attribute_list.push(audit_code_list_public_enc); + + enc_attribute_list + } + pub fn display_info(&self) { + println!("ItemDepositPublicAttributeGroup:"); + println!("For SP Address List: {:?}", self.for_sp_address_list); + println!("For Address List: {:?}", self.for_address_list); + println!("Goal List: {:?}", self.goal_list); + println!("Provider Type: {}", self.provider_type); + println!("Ref Item Hash List: {:?}", self.ref_item_hash_list); + println!("Ref PCD Hash List: {:?}", self.ref_pcd_hash_list); + println!("Payload List Public: {:?}", self.payload_list_public); + println!("Audit Code List Public: {:?}", self.audit_code_list_public); + } +} + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct ItemDepositRoleConfidentialAttributeGroup { + pub payload_list_confidential: Vec, + pub audit_code_list_confidential: Vec, +} + +impl ItemDepositRoleConfidentialAttributeGroup { + pub fn new( + payload_list_confidential: Vec, + audit_code_list_confidential: Vec, + ) -> Self { + ItemDepositRoleConfidentialAttributeGroup { + payload_list_confidential, + audit_code_list_confidential, + } + } + pub fn enc_group(&self) -> Vec { + let mut enc_attribute_list: Vec = Vec::new(); + + let mut payload_list_confidential_key = + KeyEncryption::new(Some("payload_list_confidential".to_owned()), None, None); + + if let Ok(_new) = payload_list_confidential_key.key_new_random() { + let payload_list_confidential_enc = PcdItemEncAttributeRoleConfidential::new( + "payload_list_confidential".to_owned(), + payload_list_confidential_key + .enc_vec_string(self.payload_list_confidential.clone()), + payload_list_confidential_key, + ); + enc_attribute_list.push(payload_list_confidential_enc); + } + + let mut audit_code_list_confidential_key = + KeyEncryption::new(Some("audit_code_list_confidential".to_owned()), None, None); + if let Ok(_new) = audit_code_list_confidential_key.key_new_random() { + let audit_code_list_confidential_enc = PcdItemEncAttributeRoleConfidential::new( + "audit_code_list_confidential".to_owned(), + audit_code_list_confidential_key + .enc_vec_string(self.audit_code_list_confidential.clone()), + audit_code_list_confidential_key, + ); + enc_attribute_list.push(audit_code_list_confidential_enc); + } + + return enc_attribute_list; + } + pub fn display_info(&self) { + println!("ItemDepositRoleConfidentialAttributeGroup:"); + println!( + "Confidential Payload List: {:?}", + self.payload_list_confidential + ); + println!( + "Confidential Audit Code List: {:?}", + self.audit_code_list_confidential + ); + } +} + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct ItemDepositPrivateAttributeGroup { + pub payload_list_private: Vec, + pub audit_code_private: String, +} + +impl ItemDepositPrivateAttributeGroup { + pub fn new(payload_list_private: Vec, audit_code_private: String) -> Self { + ItemDepositPrivateAttributeGroup { + payload_list_private, + audit_code_private, + } + } + + pub fn enc_group(&self, member_enc_key: KeyEncryption) -> Vec { + let mut enc_attribute_list: Vec = Vec::new(); + + let payload_list_private_enc = PcdItemEncAttributePrivate::new( + "payload_list_private".to_owned(), + member_enc_key.enc_vec_string(self.payload_list_private.clone()), + ); + enc_attribute_list.push(payload_list_private_enc); + + let audit_code_private_enc = PcdItemEncAttributePrivate::new( + "audit_code_private".to_owned(), + member_enc_key.enc_string(self.audit_code_private.clone()), + ); + enc_attribute_list.push(audit_code_private_enc); + + enc_attribute_list + } + pub fn display_info(&self) { + println!("ItemDepositPrivateAttributeGroup:"); + println!("Private Payload List: {:?}", self.payload_list_private); + println!("Private Audit Code: {}", self.audit_code_private); + } +} + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct ItemDeposit { + pub item: Item, + pub public_attribute_group: ItemDepositPublicAttributeGroup, + pub role_confidential_attribute_group: ItemDepositRoleConfidentialAttributeGroup, + pub private_attribute_group: ItemDepositPrivateAttributeGroup, +} + +impl ItemDeposit { + pub const ITEM_NAME: &'static str = "deposit"; + pub fn new( + mut item: Item, + public_attribute_group: ItemDepositPublicAttributeGroup, + role_confidential_attribute_group: ItemDepositRoleConfidentialAttributeGroup, + private_attribute_group: ItemDepositPrivateAttributeGroup, + ) -> Self { + item.name = Self::ITEM_NAME.to_string(); + ItemDeposit { + item, + public_attribute_group, + role_confidential_attribute_group, + private_attribute_group, + } + } + pub fn enc( + &self, + process_public_enc_key: KeyEncryption, + member_private_enc_key: KeyEncryption, + ) -> PcdItemGenericEnc { + let enc_metadata_contract_public = self + .public_attribute_group + .enc_group(process_public_enc_key.clone()); + + let enc_role_confidential_attribute_group = + self.role_confidential_attribute_group.enc_group(); + + let enc_metadata_private = self + .private_attribute_group + .enc_group(member_private_enc_key.clone()); + + PcdItemGenericEnc::new( + self.item + .enc(process_public_enc_key, member_private_enc_key), + Some(enc_metadata_contract_public), + Some(enc_role_confidential_attribute_group), + Some(enc_metadata_private), + ) + } + pub fn display_info(&self) { + println!("ItemDeposit:"); + println!("Item:"); + self.item.display_info(); // Affiche les informations de l'objet `item` + + println!("Public Attribute Group:"); + self.public_attribute_group.display_info(); // Affiche les informations du groupe d'attributs publics + + println!("Role Confidential Attribute Group:"); + self.role_confidential_attribute_group.display_info(); // Affiche les informations du groupe d'attributs confidentiels + + println!("Private Attribute Group:"); + self.private_attribute_group.display_info(); // Affiche les informations du groupe d'attributs privés + } +} diff --git a/src/models/item_enum.rs b/src/models/item_enum.rs new file mode 100644 index 0000000..355d063 --- /dev/null +++ b/src/models/item_enum.rs @@ -0,0 +1,18 @@ +use serde::{Deserialize, Serialize}; + +use super::{ + item_artefact::ItemArtefact, item_commitment::ItemCommitment, item_deposit::ItemDeposit, + item_member::ItemMember, item_payment::ItemPayment, item_peer::ItemPeer, + item_process::ItemProcess, +}; + +#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)] +pub enum ItemEnum { + Process(ItemProcess), + Peer(ItemPeer), + Member(ItemMember), + Payment(ItemPayment), + Deposit(ItemDeposit), + Artefact(ItemArtefact), + Commitment(ItemCommitment), +} diff --git a/src/models/item_member.rs b/src/models/item_member.rs new file mode 100644 index 0000000..fa7cd06 --- /dev/null +++ b/src/models/item_member.rs @@ -0,0 +1,383 @@ +use rocket::FromForm; +use serde::{Deserialize, Serialize}; + +use super::{ + item::Item, key_encryption::KeyEncryption, + pcd_item_enc_attribute_private::PcdItemEncAttributePrivate, + pcd_item_enc_attribute_public::PcdItemEncAttributePublic, + pcd_item_enc_attribute_role_confidential::PcdItemEncAttributeRoleConfidential, + pcd_item_generic_enc::PcdItemGenericEnc, +}; +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct ItemMemberPublicAttributeGroup { + pub sp_address_public: String, + pub sp_address_public_sig: String, + pub sp_address_revoke_public: String, + pub sp_address_revoke_public_sig: String, + pub third_sp_address_list_public: Vec, + pub data_size_max: i64, + pub payment_method_list_public: Vec, + pub succession_process_hash: String, +} + +impl ItemMemberPublicAttributeGroup { + pub fn new( + sp_address_public: String, + sp_address_public_sig: String, + sp_address_revoke_public: String, + sp_address_revoke_public_sig: String, + third_sp_address_list_public: Vec, + data_size_max: i64, + payment_method_list_public: Vec, + succession_process_hash: String, + ) -> Self { + ItemMemberPublicAttributeGroup { + sp_address_public, + sp_address_public_sig, + sp_address_revoke_public, + sp_address_revoke_public_sig, + third_sp_address_list_public, + data_size_max, + payment_method_list_public, + succession_process_hash, + } + } + pub fn enc_group( + &self, + process_public_enc_key: KeyEncryption, + ) -> Vec { + let mut enc_attribute_list: Vec = Vec::new(); + + let sp_address_public_enc = PcdItemEncAttributePublic::new( + "sp_address_public".to_owned(), + process_public_enc_key.enc_string(self.sp_address_public.clone()), + ); + enc_attribute_list.push(sp_address_public_enc); + + let sp_address_public_sig_enc = PcdItemEncAttributePublic::new( + "sp_address_public_sig".to_owned(), + process_public_enc_key.enc_string(self.sp_address_public_sig.clone()), + ); + enc_attribute_list.push(sp_address_public_sig_enc); + + let sp_address_revoke_public_enc = PcdItemEncAttributePublic::new( + "sp_address_revoke_public".to_owned(), + process_public_enc_key.enc_string(self.sp_address_revoke_public.clone()), + ); + enc_attribute_list.push(sp_address_revoke_public_enc); + + let sp_address_revoke_public_sig_enc = PcdItemEncAttributePublic::new( + "sp_address_revoke_public_sig".to_owned(), + process_public_enc_key.enc_string(self.sp_address_revoke_public_sig.clone()), + ); + enc_attribute_list.push(sp_address_revoke_public_sig_enc); + + let third_sp_address_list_public_enc = PcdItemEncAttributePublic::new( + "third_sp_address_list_public".to_owned(), + process_public_enc_key.enc_vec_string(self.third_sp_address_list_public.clone()), + ); + enc_attribute_list.push(third_sp_address_list_public_enc); + + let data_size_max_enc = PcdItemEncAttributePublic::new( + "data_size_max".to_owned(), + process_public_enc_key.enc_i64(self.data_size_max), + ); + enc_attribute_list.push(data_size_max_enc); + + let payment_method_list_public_enc = PcdItemEncAttributePublic::new( + "payment_method_list_public".to_owned(), + process_public_enc_key.enc_vec_string(self.payment_method_list_public.clone()), + ); + enc_attribute_list.push(payment_method_list_public_enc); + + let succession_process_hash_enc = PcdItemEncAttributePublic::new( + "succession_process_hash".to_owned(), + process_public_enc_key.enc_string(self.succession_process_hash.clone()), + ); + enc_attribute_list.push(succession_process_hash_enc); + + enc_attribute_list + } + pub fn display_info(&self) { + println!("ItemMemberPublicAttributeGroup:"); + println!("SP Address Public: {}", self.sp_address_public); + println!( + "SP Address Public Signature: {}", + self.sp_address_public_sig + ); + println!( + "SP Address Revoke Public: {}", + self.sp_address_revoke_public + ); + println!( + "SP Address Revoke Public Signature: {}", + self.sp_address_revoke_public_sig + ); + println!( + "Third SP Address List Public: {:?}", + self.third_sp_address_list_public + ); + println!("Data Size Max: {}", self.data_size_max); + println!( + "Payment Method List Public: {:?}", + self.payment_method_list_public + ); + println!("Succession Process Hash: {}", self.succession_process_hash); + } +} + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct ItemMemberRoleConfidentialAttributeGroup { + pub payment_method_list_confidential: Vec, + pub id_shard_info: String, +} + +impl ItemMemberRoleConfidentialAttributeGroup { + pub fn new(payment_method_list_confidential: Vec, id_shard_info: String) -> Self { + ItemMemberRoleConfidentialAttributeGroup { + payment_method_list_confidential, + id_shard_info, + } + } + + pub fn enc_group(&self) -> Vec { + let mut enc_attribute_list: Vec = Vec::new(); + + let mut enc_payment_method_list_confidential_key = KeyEncryption::new( + Some("payment_method_list_confidential".to_owned()), + None, + None, + ); + if let Ok(_new) = enc_payment_method_list_confidential_key.key_new_random() { + let payment_method_list_confidential_enc = PcdItemEncAttributeRoleConfidential::new( + "payment_method_list_confidential".to_owned(), + enc_payment_method_list_confidential_key + .enc_vec_string(self.payment_method_list_confidential.clone()), + enc_payment_method_list_confidential_key, + ); + enc_attribute_list.push(payment_method_list_confidential_enc); + } + + let mut enc_id_shard_info_key = + KeyEncryption::new(Some("id_shard_info".to_owned()), None, None); + + if let Ok(_new) = enc_id_shard_info_key.key_new_random() { + let id_shard_info_enc = PcdItemEncAttributeRoleConfidential::new( + "id_shard_info".to_owned(), + enc_id_shard_info_key.enc_string(self.id_shard_info.clone()), + enc_id_shard_info_key, + ); + enc_attribute_list.push(id_shard_info_enc); + } + + return enc_attribute_list; + } + pub fn display_info(&self) { + println!("ItemMemberRoleConfidentialAttributeGroup:"); + println!( + "Confidential Payment Method List: {:?}", + self.payment_method_list_confidential + ); + println!("ID Shard Info: {}", self.id_shard_info); + } +} + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct ItemMemberPrivateAttributeGroup { + pub payment_method_list_private: Vec, + pub pcd_list: Vec, // Assuming this is a list of strings + pub prd_list_list: Vec, + pub prd_update_list: Vec, + pub prd_response_list: Vec, + pub prd_message_list: Vec, + pub prd_confirm_list: Vec, + pub prd_key_backup_list: Vec, + pub prd_key_hello_list: Vec, + pub tx_sp_list: Vec, +} + +impl ItemMemberPrivateAttributeGroup { + pub fn new( + payment_method_list_private: Vec, + pcd_list: Vec, + prd_list_list: Vec, + prd_update_list: Vec, + prd_response_list: Vec, + prd_message_list: Vec, + prd_confirm_list: Vec, + prd_key_backup_list: Vec, + prd_key_hello_list: Vec, + tx_sp_list: Vec, + ) -> Self { + ItemMemberPrivateAttributeGroup { + payment_method_list_private, + pcd_list, + prd_list_list, + prd_update_list, + prd_response_list, + prd_message_list, + prd_confirm_list, + prd_key_backup_list, + prd_key_hello_list, + tx_sp_list, + } + } + + pub fn enc_group(&self, member_enc_key: KeyEncryption) -> Vec { + let mut enc_attribute_list: Vec = Vec::new(); + + let payment_method_list_private_enc = PcdItemEncAttributePrivate::new( + "payment_method_list_private".to_owned(), + member_enc_key.enc_vec_string(self.payment_method_list_private.clone()), + ); + enc_attribute_list.push(payment_method_list_private_enc); + + let pcd_list_enc = PcdItemEncAttributePrivate::new( + "pcd_list".to_owned(), + member_enc_key.enc_vec_string(self.pcd_list.clone()), + ); + enc_attribute_list.push(pcd_list_enc); + + let prd_list_list_enc = PcdItemEncAttributePrivate::new( + "prd_list_list".to_owned(), + member_enc_key.enc_vec_string(self.prd_list_list.clone()), + ); + enc_attribute_list.push(prd_list_list_enc); + + let prd_update_list_enc = PcdItemEncAttributePrivate::new( + "prd_update_list".to_owned(), + member_enc_key.enc_vec_string(self.prd_update_list.clone()), + ); + enc_attribute_list.push(prd_update_list_enc); + + let prd_response_list_enc = PcdItemEncAttributePrivate::new( + "prd_response_list".to_owned(), + member_enc_key.enc_vec_string(self.prd_response_list.clone()), + ); + enc_attribute_list.push(prd_response_list_enc); + + let prd_message_list_enc = PcdItemEncAttributePrivate::new( + "prd_message_list".to_owned(), + member_enc_key.enc_vec_string(self.prd_message_list.clone()), + ); + enc_attribute_list.push(prd_message_list_enc); + + let prd_confirm_list_enc = PcdItemEncAttributePrivate::new( + "prd_confirm_list".to_owned(), + member_enc_key.enc_vec_string(self.prd_confirm_list.clone()), + ); + enc_attribute_list.push(prd_confirm_list_enc); + + let prd_key_backup_list_enc = PcdItemEncAttributePrivate::new( + "prd_key_backup_list".to_owned(), + member_enc_key.enc_vec_string(self.prd_key_backup_list.clone()), + ); + enc_attribute_list.push(prd_key_backup_list_enc); + + let prd_key_hello_list_enc = PcdItemEncAttributePrivate::new( + "prd_key_hello_list".to_owned(), + member_enc_key.enc_vec_string(self.prd_key_hello_list.clone()), + ); + enc_attribute_list.push(prd_key_hello_list_enc); + + let tx_sp_list_enc = PcdItemEncAttributePrivate::new( + "tx_sp_list".to_owned(), + member_enc_key.enc_vec_string(self.tx_sp_list.clone()), + ); + enc_attribute_list.push(tx_sp_list_enc); + + enc_attribute_list + } + pub fn display_info(&self) { + println!("ItemMemberPrivateAttributeGroup:"); + println!( + "Private Payment Method List: {:?}", + self.payment_method_list_private + ); + println!("PCD List: {:?}", self.pcd_list); + println!("PRD List List: {:?}", self.prd_list_list); + println!("PRD Update List: {:?}", self.prd_update_list); + println!("PRD Response List: {:?}", self.prd_response_list); + println!("PRD Message List: {:?}", self.prd_message_list); + println!("PRD Confirm List: {:?}", self.prd_confirm_list); + println!("PRD Key Backup List: {:?}", self.prd_key_backup_list); + println!("PRD Key Hello List: {:?}", self.prd_key_hello_list); + println!("TX SP List: {:?}", self.tx_sp_list); + } +} + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct ItemMember { + pub item: Item, + pub public_attribute_group: ItemMemberPublicAttributeGroup, + pub role_confidential_attribute_group: ItemMemberRoleConfidentialAttributeGroup, + pub private_attribute_group: ItemMemberPrivateAttributeGroup, +} + +impl ItemMember { + pub const ITEM_NAME: &'static str = "member"; + pub fn new( + mut item: Item, + public_attribute_group: ItemMemberPublicAttributeGroup, + role_confidential_attribute_group: ItemMemberRoleConfidentialAttributeGroup, + private_attribute_group: ItemMemberPrivateAttributeGroup, + ) -> Self { + item.name = Self::ITEM_NAME.to_string(); + ItemMember { + item, + public_attribute_group, + role_confidential_attribute_group, + private_attribute_group, + } + } + pub fn enc( + &self, + process_public_enc_key: KeyEncryption, + member_private_enc_key: KeyEncryption, + ) -> PcdItemGenericEnc { + let enc_metadata_contract_public = self + .public_attribute_group + .enc_group(process_public_enc_key.clone()); + + let enc_role_confidential_attribute_group = + self.role_confidential_attribute_group.enc_group(); + + let enc_metadata_private = self + .private_attribute_group + .enc_group(member_private_enc_key.clone()); + + PcdItemGenericEnc::new( + self.item + .enc(process_public_enc_key, member_private_enc_key), + Some(enc_metadata_contract_public), + Some(enc_role_confidential_attribute_group), + Some(enc_metadata_private), + ) + } + pub fn display_info(&self) { + println!("ItemMember:"); + println!("Item:"); + self.item.display_info(); // Affiche les informations de l'objet `item` + + println!("Member Public Attribute Group:"); + self.public_attribute_group.display_info(); // Affiche les informations du groupe d'attributs publics + + println!("Member Role Confidential Attribute Group:"); + self.role_confidential_attribute_group.display_info(); // Affiche les informations du groupe d'attributs confidentiels + + println!("Member Private Attribute Group:"); + self.private_attribute_group.display_info(); // Affiche les informations du groupe d'attributs privés + } +} diff --git a/src/models/item_payment.rs b/src/models/item_payment.rs new file mode 100644 index 0000000..afe0440 --- /dev/null +++ b/src/models/item_payment.rs @@ -0,0 +1,324 @@ +use rocket::FromForm; +use serde::{Deserialize, Serialize}; + +use super::{ + item::Item, key_encryption::KeyEncryption, + pcd_item_enc_attribute_private::PcdItemEncAttributePrivate, + pcd_item_enc_attribute_public::PcdItemEncAttributePublic, + pcd_item_enc_attribute_role_confidential::PcdItemEncAttributeRoleConfidential, + pcd_item_generic_enc::PcdItemGenericEnc, +}; +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct ItemPaymentPublicAttributeGroup { + pub for_sp_address_list: Vec, + pub goal_list: Vec, + pub provider_type: String, + pub commitment_pcd_hash_list: Vec, + pub order_pcd_hash_list: Vec, + pub invoice_pcd_hash_list: Vec, + pub pay_pcd_hash_list: Vec, + pub ref_item_hash_list: Vec, + pub ref_pcd_hash_list: Vec, + pub payload_list_public: Vec, + pub audit_code_list_public: Vec, +} + +impl ItemPaymentPublicAttributeGroup { + pub fn new( + for_sp_address_list: Vec, + goal_list: Vec, + provider_type: String, + commitment_pcd_hash_list: Vec, + order_pcd_hash_list: Vec, + invoice_pcd_hash_list: Vec, + pay_pcd_hash_list: Vec, + ref_item_hash_list: Vec, + ref_pcd_hash_list: Vec, + payload_list_public: Vec, + audit_code_list_public: Vec, + ) -> Self { + ItemPaymentPublicAttributeGroup { + for_sp_address_list, + goal_list, + provider_type, + commitment_pcd_hash_list, + order_pcd_hash_list, + invoice_pcd_hash_list, + pay_pcd_hash_list, + ref_item_hash_list, + ref_pcd_hash_list, + payload_list_public, + audit_code_list_public, + } + } + pub fn enc_group( + &self, + process_public_enc_key: KeyEncryption, + ) -> Vec { + let mut enc_attribute_list: Vec = Vec::new(); + + let for_sp_address_list_enc = PcdItemEncAttributePublic::new( + "for_sp_address_list".to_owned(), + process_public_enc_key.enc_vec_string(self.for_sp_address_list.clone()), + ); + enc_attribute_list.push(for_sp_address_list_enc); + + let goal_list_enc = PcdItemEncAttributePublic::new( + "goal_list".to_owned(), + process_public_enc_key.enc_vec_string(self.goal_list.clone()), + ); + enc_attribute_list.push(goal_list_enc); + + let provider_type_enc = PcdItemEncAttributePublic::new( + "provider_type".to_owned(), + process_public_enc_key.enc_string(self.provider_type.clone()), + ); + enc_attribute_list.push(provider_type_enc); + + let commitment_pcd_hash_list_enc = PcdItemEncAttributePublic::new( + "commitment_pcd_hash_list".to_owned(), + process_public_enc_key.enc_vec_string(self.commitment_pcd_hash_list.clone()), + ); + enc_attribute_list.push(commitment_pcd_hash_list_enc); + + let order_pcd_hash_list_enc = PcdItemEncAttributePublic::new( + "order_pcd_hash_list".to_owned(), + process_public_enc_key.enc_vec_string(self.order_pcd_hash_list.clone()), + ); + enc_attribute_list.push(order_pcd_hash_list_enc); + + let invoice_pcd_hash_list_enc = PcdItemEncAttributePublic::new( + "invoice_pcd_hash_list".to_owned(), + process_public_enc_key.enc_vec_string(self.invoice_pcd_hash_list.clone()), + ); + enc_attribute_list.push(invoice_pcd_hash_list_enc); + + let pay_pcd_hash_list_enc = PcdItemEncAttributePublic::new( + "pay_pcd_hash_list".to_owned(), + process_public_enc_key.enc_vec_string(self.pay_pcd_hash_list.clone()), + ); + enc_attribute_list.push(pay_pcd_hash_list_enc); + + let ref_item_hash_list_enc = PcdItemEncAttributePublic::new( + "ref_item_hash_list".to_owned(), + process_public_enc_key.enc_vec_string(self.ref_item_hash_list.clone()), + ); + enc_attribute_list.push(ref_item_hash_list_enc); + + let ref_pcd_hash_list_enc = PcdItemEncAttributePublic::new( + "ref_pcd_hash_list".to_owned(), + process_public_enc_key.enc_vec_string(self.ref_pcd_hash_list.clone()), + ); + enc_attribute_list.push(ref_pcd_hash_list_enc); + + let payload_list_public_enc = PcdItemEncAttributePublic::new( + "payload_list_public".to_owned(), + process_public_enc_key.enc_vec_string(self.payload_list_public.clone()), + ); + enc_attribute_list.push(payload_list_public_enc); + + let audit_code_list_public_enc = PcdItemEncAttributePublic::new( + "audit_code_list_public".to_owned(), + process_public_enc_key.enc_vec_string(self.audit_code_list_public.clone()), + ); + enc_attribute_list.push(audit_code_list_public_enc); + + enc_attribute_list + } + pub fn display_info(&self) { + println!("ItemPaymentPublicAttributeGroup:"); + println!("For SP Address List: {:?}", self.for_sp_address_list); + println!("Goal List: {:?}", self.goal_list); + println!("Provider Type: {}", self.provider_type); + println!( + "Commitment PCD Hash List: {:?}", + self.commitment_pcd_hash_list + ); + println!("Order PCD Hash List: {:?}", self.order_pcd_hash_list); + println!("Invoice PCD Hash List: {:?}", self.invoice_pcd_hash_list); + println!("Pay PCD Hash List: {:?}", self.pay_pcd_hash_list); + println!("Ref Item Hash List: {:?}", self.ref_item_hash_list); + println!("Ref PCD Hash List: {:?}", self.ref_pcd_hash_list); + println!("Payload List Public: {:?}", self.payload_list_public); + println!("Audit Code List Public: {:?}", self.audit_code_list_public); + } +} + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct ItemPaymentRoleConfidentialAttributeGroup { + pub payload_list_confidential: Vec, + pub audit_code_list_confidential: Vec, +} + +impl ItemPaymentRoleConfidentialAttributeGroup { + pub fn new( + payload_list_confidential: Vec, + audit_code_list_confidential: Vec, + ) -> Self { + ItemPaymentRoleConfidentialAttributeGroup { + payload_list_confidential, + audit_code_list_confidential, + } + } + pub fn display_info(&self) { + println!("ItemPaymentRoleConfidentialAttributeGroup:"); + println!( + "Confidential Payload List: {:?}", + self.payload_list_confidential + ); + println!( + "Confidential Audit Code List: {:?}", + self.audit_code_list_confidential + ); + } + + pub fn enc_group(&self) -> Vec { + let mut enc_attribute_list: Vec = Vec::new(); + + // tag_list + let mut enc_payload_list_confidential = + KeyEncryption::new(Some("payload_list_confidential".to_owned()), None, None); + if let Ok(_new) = enc_payload_list_confidential.key_new_random() { + let enc_attribute_payload_list_confidential = PcdItemEncAttributeRoleConfidential::new( + "payload_list_confidential".to_owned(), + enc_payload_list_confidential + .enc_vec_string(self.payload_list_confidential.clone()), + enc_payload_list_confidential, + ); + enc_attribute_list.push(enc_attribute_payload_list_confidential); + } + + // zone_listaudit_code_list_confidential + let mut enc_attribute_audit_code_list_confidential_key = + KeyEncryption::new(Some("zone_list".to_owned()), None, None); + if let Ok(_new) = enc_attribute_audit_code_list_confidential_key.key_new_random() { + let enc_attribute_audit_code_list_confidential = + PcdItemEncAttributeRoleConfidential::new( + "zone_list".to_owned(), + enc_attribute_audit_code_list_confidential_key + .enc_vec_string(self.audit_code_list_confidential.clone()), + enc_attribute_audit_code_list_confidential_key, + ); + enc_attribute_list.push(enc_attribute_audit_code_list_confidential); + } + + return enc_attribute_list; + } +} + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct ItemPaymentPrivateAttributeGroup { + pub payload_list_private: Vec, + pub audit_code_private: String, +} + +impl ItemPaymentPrivateAttributeGroup { + pub fn new(payload_list_private: Vec, audit_code_private: String) -> Self { + ItemPaymentPrivateAttributeGroup { + payload_list_private, + audit_code_private, + } + } + pub fn display_info(&self) { + println!("ItemPaymentRoleConfidentialAttributeGroup:"); + println!("Confidential Payload List: {:?}", self.payload_list_private); + println!( + "Confidential Audit Code List: {:?}", + self.audit_code_private + ); + } + + pub fn enc_group(&self, member_enc_key: KeyEncryption) -> Vec { + let mut enc_attribute_list: Vec = Vec::new(); + + let payload_list_private_enc = PcdItemEncAttributePrivate::new( + "payload_list".to_owned(), + member_enc_key.enc_vec_string(self.payload_list_private.clone()), + ); + enc_attribute_list.push(payload_list_private_enc); + + let audit_code_private_enc = PcdItemEncAttributePrivate::new( + "audit_code_private".to_owned(), + member_enc_key.enc_string(self.audit_code_private.clone()), + ); + enc_attribute_list.push(audit_code_private_enc); + + enc_attribute_list + } +} + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct ItemPayment { + pub item: Item, + pub public_attribute_group: ItemPaymentPublicAttributeGroup, + pub role_confidential_attribute_group: ItemPaymentRoleConfidentialAttributeGroup, + pub private_attribute_group: ItemPaymentPrivateAttributeGroup, +} + +impl ItemPayment { + pub const ITEM_NAME: &'static str = "payment"; + pub fn new( + mut item: Item, + public_attribute_group: ItemPaymentPublicAttributeGroup, + role_confidential_attribute_group: ItemPaymentRoleConfidentialAttributeGroup, + private_attribute_group: ItemPaymentPrivateAttributeGroup, + ) -> Self { + item.name = Self::ITEM_NAME.to_string(); + ItemPayment { + item, + public_attribute_group, + role_confidential_attribute_group, + private_attribute_group, + } + } + pub fn enc( + &self, + process_public_enc_key: KeyEncryption, + member_private_enc_key: KeyEncryption, + ) -> PcdItemGenericEnc { + let enc_metadata_contract_public = self + .public_attribute_group + .enc_group(process_public_enc_key.clone()); + + let enc_role_confidential_attribute_group = + self.role_confidential_attribute_group.enc_group(); + + let enc_metadata_private = self + .private_attribute_group + .enc_group(member_private_enc_key.clone()); + + PcdItemGenericEnc::new( + self.item + .enc(process_public_enc_key, member_private_enc_key), + Some(enc_metadata_contract_public), + Some(enc_role_confidential_attribute_group), + Some(enc_metadata_private), + ) + } + pub fn display_info(&self) { + println!("ItemPayment:"); + println!("Item:"); + self.item.display_info(); // Affiche les informations de l'objet `item` + + println!("Public Attribute Group:"); + self.public_attribute_group.display_info(); // Affiche les informations du groupe d'attributs publics + + println!("Role Confidential Attribute Group:"); + self.role_confidential_attribute_group.display_info(); // Affiche les informations du groupe d'attributs confidentiels + + println!("Private Attribute Group:"); + self.private_attribute_group.display_info(); // Affiche les informations du groupe d'attributs privés + } +} diff --git a/src/models/item_peer.rs b/src/models/item_peer.rs new file mode 100644 index 0000000..aa2ce13 --- /dev/null +++ b/src/models/item_peer.rs @@ -0,0 +1,240 @@ +use rocket::FromForm; +use serde::{Deserialize, Serialize}; + +use super::{ + item::Item, key_encryption::KeyEncryption, + pcd_item_enc_attribute_private::PcdItemEncAttributePrivate, + pcd_item_enc_attribute_public::PcdItemEncAttributePublic, + pcd_item_generic_enc::PcdItemGenericEnc, +}; +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct ItemPeerPublicAttributeGroup { + pub sp_address: String, + pub domain: String, + pub ip_address: String, + pub pow_difficulty: u32, + pub pow_pattern: String, + pub pow_prefix: String, + pub data_size_max: i64, + pub timestamp_delay_max: u64, + pub daily_hash_list: Vec, + pub daily_sp_tx_mine_list: Vec, + pub daily_sp_tx_mine_reward_list: Vec, +} + +impl ItemPeerPublicAttributeGroup { + pub fn new( + sp_address: String, + domain: String, + ip_address: String, + pow_difficulty: u32, + pow_pattern: String, + pow_prefix: String, + data_size_max: i64, + timestamp_delay_max: u64, + daily_hash_list: Vec, + daily_sp_tx_mine_list: Vec, + daily_sp_tx_mine_reward_list: Vec, + ) -> Self { + ItemPeerPublicAttributeGroup { + sp_address, + domain, + ip_address, + pow_difficulty, + pow_pattern, + pow_prefix, + data_size_max, + timestamp_delay_max, + daily_hash_list, + daily_sp_tx_mine_list, + daily_sp_tx_mine_reward_list, + } + } + pub fn enc_group( + &self, + process_public_enc_key: KeyEncryption, + ) -> Vec { + let mut enc_attribute_list: Vec = Vec::new(); + + let sp_address_enc = PcdItemEncAttributePublic::new( + "sp_address".to_owned(), + process_public_enc_key.enc_string(self.sp_address.clone()), + ); + enc_attribute_list.push(sp_address_enc); + + let domain_enc = PcdItemEncAttributePublic::new( + "domain".to_owned(), + process_public_enc_key.enc_string(self.domain.clone()), + ); + enc_attribute_list.push(domain_enc); + + let ip_address_enc = PcdItemEncAttributePublic::new( + "ip_address".to_owned(), + process_public_enc_key.enc_string(self.ip_address.clone()), + ); + enc_attribute_list.push(ip_address_enc); + + let pow_difficulty_enc = PcdItemEncAttributePublic::new( + "pow_difficulty".to_owned(), + process_public_enc_key.enc_u32(self.pow_difficulty), + ); + enc_attribute_list.push(pow_difficulty_enc); + + let pow_pattern_enc = PcdItemEncAttributePublic::new( + "pow_pattern".to_owned(), + process_public_enc_key.enc_string(self.pow_pattern.clone()), + ); + enc_attribute_list.push(pow_pattern_enc); + + let pow_prefix_enc = PcdItemEncAttributePublic::new( + "pow_prefix".to_owned(), + process_public_enc_key.enc_string(self.pow_prefix.clone()), + ); + enc_attribute_list.push(pow_prefix_enc); + + let data_size_max_enc = PcdItemEncAttributePublic::new( + "data_size_max".to_owned(), + process_public_enc_key.enc_i64(self.data_size_max), + ); + enc_attribute_list.push(data_size_max_enc); + + let timestamp_delay_max_enc = PcdItemEncAttributePublic::new( + "timestamp_delay_max".to_owned(), + process_public_enc_key.enc_u64(self.timestamp_delay_max), + ); + enc_attribute_list.push(timestamp_delay_max_enc); + + let daily_hash_list_enc = PcdItemEncAttributePublic::new( + "daily_hash_list".to_owned(), + process_public_enc_key.enc_vec_string(self.daily_hash_list.clone()), + ); + enc_attribute_list.push(daily_hash_list_enc); + + let daily_sp_tx_mine_list_enc = PcdItemEncAttributePublic::new( + "daily_sp_tx_mine_list".to_owned(), + process_public_enc_key.enc_vec_string(self.daily_sp_tx_mine_list.clone()), + ); + enc_attribute_list.push(daily_sp_tx_mine_list_enc); + + let daily_sp_tx_mine_reward_list_enc = PcdItemEncAttributePublic::new( + "daily_sp_tx_mine_reward_list".to_owned(), + process_public_enc_key.enc_vec_string(self.daily_sp_tx_mine_reward_list.clone()), + ); + enc_attribute_list.push(daily_sp_tx_mine_reward_list_enc); + + enc_attribute_list + } + pub fn display_info(&self) { + println!("ItemPeerPublicAttributeGroup:"); + println!("SP Address: {}", self.sp_address); + println!("Domain: {}", self.domain); + println!("IP Address: {}", self.ip_address); + println!("PoW Difficulty: {}", self.pow_difficulty); + println!("PoW Pattern: {}", self.pow_pattern); + println!("PoW Prefix: {}", self.pow_prefix); + println!("Data Size Max: {}", self.data_size_max); + println!("Timestamp Delay Max: {}", self.timestamp_delay_max); + println!("Daily Hash List: {:?}", self.daily_hash_list); + println!("Daily SP Tx Mine List: {:?}", self.daily_sp_tx_mine_list); + println!( + "Daily SP Tx Mine Reward List: {:?}", + self.daily_sp_tx_mine_reward_list + ); + } +} + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct ItemPeerPrivateAttributeGroup { + pub config: String, // Assuming it's a simple string for now +} + +impl ItemPeerPrivateAttributeGroup { + pub fn new(config: String) -> Self { + ItemPeerPrivateAttributeGroup { config } + } + pub fn display_info(&self) { + println!("ItemPeerPrivateAttributeGroup:"); + println!("Config: {}", self.config); + } + + pub fn enc_group(&self, member_enc_key: KeyEncryption) -> Vec { + let mut enc_attribute_list: Vec = Vec::new(); + + let config_enc = PcdItemEncAttributePrivate::new( + "config".to_owned(), + member_enc_key.enc_string(self.config.clone()), + ); + enc_attribute_list.push(config_enc); + + enc_attribute_list + } +} + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct ItemPeer { + pub item: Item, + pub layer_list: Vec, + pub public_attribute_group: ItemPeerPublicAttributeGroup, + pub private_attribute_group: ItemPeerPrivateAttributeGroup, +} + +impl ItemPeer { + pub const ITEM_NAME: &'static str = "peer"; + pub fn new( + mut item: Item, + layer_list: Vec, + public_attribute_group: ItemPeerPublicAttributeGroup, + private_attribute_group: ItemPeerPrivateAttributeGroup, + ) -> Self { + item.name = Self::ITEM_NAME.to_string(); + ItemPeer { + item, + layer_list, + public_attribute_group, + private_attribute_group, + } + } + pub fn enc( + &self, + process_public_enc_key: KeyEncryption, + member_private_enc_key: KeyEncryption, + ) -> PcdItemGenericEnc { + let enc_metadata_contract_public = self + .public_attribute_group + .enc_group(process_public_enc_key.clone()); + + let enc_metadata_private = self + .private_attribute_group + .enc_group(member_private_enc_key.clone()); + + PcdItemGenericEnc::new( + self.item + .enc(process_public_enc_key, member_private_enc_key), + Some(enc_metadata_contract_public), + None, + Some(enc_metadata_private), + ) + } + pub fn display_info(&self) { + println!("ItemPeer:"); + println!("Item:"); + self.item.display_info(); // Affiche les informations de l'objet `item` + + println!("Layer List: {:?}", self.layer_list); + + println!("Peer Public Attribute Group:"); + self.public_attribute_group.display_info(); // Affiche les informations du groupe d'attributs publics + + println!("Peer Private Attribute Group:"); + self.private_attribute_group.display_info(); // Affiche les informations du groupe d'attributs privés + } +} diff --git a/src/models/item_process.rs b/src/models/item_process.rs new file mode 100644 index 0000000..f62355e --- /dev/null +++ b/src/models/item_process.rs @@ -0,0 +1,91 @@ +use rocket::FromForm; +use serde::{Deserialize, Serialize}; + +use super::{ + item::Item, key_encryption::KeyEncryption, + pcd_item_enc_attribute_public::PcdItemEncAttributePublic, + pcd_item_generic_enc::PcdItemGenericEnc, roles_group::RolesGroup, +}; + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct ItemProcessPublicAttributeGroup { + // Fields for public attributes + // Example field + pub roles_group: RolesGroup, +} + +impl ItemProcessPublicAttributeGroup { + pub fn new(roles_group: RolesGroup) -> Self { + ItemProcessPublicAttributeGroup { roles_group } + } + pub fn display_info(&self) { + println!("ItemProcessPublicAttributeGroup:"); + println!("Roles Group:"); + self.roles_group.display_info(); // Display information for `roles_group` + } + pub fn enc_group( + &self, + process_public_enc_key: KeyEncryption, + ) -> Vec { + let mut enc_attribute_list: Vec = Vec::new(); + let roles_group_enc = PcdItemEncAttributePublic::new( + "roles_group".to_owned(), + process_public_enc_key.enc_roles_group(self.roles_group.clone()), + ); + enc_attribute_list.push(roles_group_enc); + enc_attribute_list + } +} + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct ItemProcess { + pub item: Item, + pub item_process_public_attribute_group: ItemProcessPublicAttributeGroup, +} + +impl ItemProcess { + pub const ITEM_NAME: &'static str = "process"; + pub fn new( + mut item: Item, + item_process_public_attribute_group: ItemProcessPublicAttributeGroup, + ) -> Self { + item.name = Self::ITEM_NAME.to_string(); + ItemProcess { + item, + item_process_public_attribute_group, + } + } + pub fn display_info(&self) { + println!("ItemProcess:"); + println!("Item:"); + self.item.display_info(); // Display information for `item` + + println!("Process Public Attribute Group:"); + self.item_process_public_attribute_group.display_info(); // Display information for `item_process_public_attribute_group` + } + pub fn enc( + &self, + process_public_enc_key: KeyEncryption, + member_private_enc_key: KeyEncryption, + ) -> PcdItemGenericEnc { + let enc_metadata_contract_public = self + .item_process_public_attribute_group + .enc_group(process_public_enc_key.clone()); + + PcdItemGenericEnc::new( + self.item + .enc(process_public_enc_key, member_private_enc_key), + Some(enc_metadata_contract_public), + None, + None, + ) + } + + // Additional methods for ItemProcess can be added here +} diff --git a/src/models/key_encryption.rs b/src/models/key_encryption.rs new file mode 100644 index 0000000..5db5ca2 --- /dev/null +++ b/src/models/key_encryption.rs @@ -0,0 +1,250 @@ +use rand::RngCore; +use rocket::FromForm; +use serde::{Deserialize, Serialize}; +use serde_json::{json, Value}; + +use core::result::Result as CoreResult; + +use super::metadata::Amount; +use super::metadata::Number; +use super::request_pcd::RequestPcd; +use super::request_prd_confirm::RequestPrdConfirm; +use super::request_prd_key_backup::RequestPrdKeyBackup; +use super::request_prd_key_hello::RequestPrdKeyHello; +use super::request_prd_list::RequestPrdList; +use super::request_prd_message::RequestPrdMessage; +use super::request_prd_response::RequestPrdResponse; +use super::request_prd_update::RequestPrdUpdate; +use super::roles_group::RolesGroup; + +use aes::cipher::consts::U32; +use aes::cipher::generic_array::GenericArray; +use aes_gcm::{ + aead::{AeadInPlace, KeyInit}, + Aes256Gcm, +}; +use rand::rngs::OsRng; + +pub struct Aes256GcmIv96Bit { + pub key: GenericArray, +} + +impl Aes256GcmIv96Bit { + pub fn new() -> Self { + let mut key_bytes = [0u8; 32]; + OsRng.fill_bytes(&mut key_bytes); + let key = GenericArray::from_slice(&key_bytes); + Aes256GcmIv96Bit { key: key.clone() } + } + + pub fn encrypt(&self, data: &[u8]) -> CoreResult, aes_gcm::Error> { + let cipher = Aes256Gcm::new(&self.key); + let mut nonce = [0u8; 12]; + OsRng.fill_bytes(&mut nonce); + + let mut buffer = data.to_vec(); + cipher.encrypt_in_place(GenericArray::from_slice(&nonce), b"", &mut buffer)?; + + Ok([nonce.to_vec(), buffer].concat()) + } + + pub fn decrypt(&self, data: &[u8]) -> CoreResult, aes_gcm::Error> { + if data.len() < 12 { + return Err(aes_gcm::Error); // Remplacer par une erreur appropriée + } + + let (nonce, encrypted_data) = data.split_at(12); + let mut buffer = encrypted_data.to_vec(); + let cipher = Aes256Gcm::new(&self.key); + cipher.decrypt_in_place(GenericArray::from_slice(nonce), b"", &mut buffer)?; + + Ok(buffer) + } + pub fn encrypt_string(&self, data: &str) -> CoreResult { + match self.encrypt(data.as_bytes()) { + Ok(encrypted_data) => Ok(base64::encode(encrypted_data)), + Err(_) => Err("Erreur de chiffrement".to_string()), + } + } + + pub fn decrypt_string(&self, data: &str) -> CoreResult { + let decoded_data = match base64::decode(data) { + Ok(data) => data, + Err(_) => return Err("Erreur de décodage Base64".to_string()), + }; + + match self.decrypt(&decoded_data) { + Ok(decrypted_data) => match String::from_utf8(decrypted_data) { + Ok(text) => Ok(text), + Err(_) => Err("Erreur de conversion UTF-8".to_string()), + }, + Err(_) => Err("Erreur de déchiffrement".to_string()), + } + } + pub fn export_key(&self) -> String { + base64::encode(&self.key) + } + + pub fn import_key(encoded_key: &str) -> CoreResult { + match base64::decode(encoded_key) { + Ok(decoded_key) => { + if decoded_key.len() == 32 { + let key = GenericArray::from_slice(&decoded_key); + Ok(Aes256GcmIv96Bit { key: key.clone() }) + } else { + Err("La taille de la clé n'est pas valide".to_string()) + } + } + Err(_) => Err("Échec du décodage de la clé".to_string()), + } + } +} + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] +pub struct KeyEncryption { + pub attribute_name: Option, + pub key: Option, + pub algorithm: Option, +} + +impl KeyEncryption { + pub fn new( + attribute_name: Option, + key: Option, + algorithm: Option, + ) -> Self { + KeyEncryption { + attribute_name, + key, + algorithm, + } + } + pub fn key_new_random(&mut self) -> CoreResult { + let new_key = Aes256GcmIv96Bit::new().export_key(); + self.key = Some(new_key.clone()); + Ok(new_key) + } + pub fn encode(&self, data: String) -> CoreResult { + if let Some(ref key) = self.key { + let decoded_key = Aes256GcmIv96Bit::import_key(key)?; + let encrypted_data = decoded_key.encrypt_string(&data)?; + Ok(encrypted_data) + } else { + Err("Aucune clé n'est définie".to_string()) + } + } + + pub fn decode(&self, encrypted_data: String) -> CoreResult { + if let Some(ref key) = self.key { + let decoded_key = Aes256GcmIv96Bit::import_key(key)?; + let decrypted_data = decoded_key.decrypt_string(&encrypted_data)?; + Ok(decrypted_data) + } else { + Err("Aucune clé n'est définie".to_string()) + } + } + + pub fn display_info(&self) { + println!("KeyEncryption:"); + println!("Attribute Name: {:?}", self.attribute_name); + println!("Key: {:?}", self.key); + println!("Algorithm: {:?}", self.algorithm); + } + pub fn enc(&self, data: Value) -> String { + let data_string = serde_json::to_string(&data).unwrap_or_else(|_| "".to_string()); + self.encode(data_string).unwrap_or_else(|_| "".to_string()) + } + pub fn enc_string(&self, data: String) -> String { + self.enc(Value::String(data)) + } + pub fn enc_i64(&self, data: i64) -> String { + self.enc(Value::Number(data.into())) + } + pub fn enc_u64(&self, data: u64) -> String { + self.enc(Value::Number(data.into())) + } + pub fn enc_u32(&self, data: u32) -> String { + self.enc(Value::Number(data.into())) + } + pub fn enc_vec_string(&self, list: Vec) -> String { + self.enc(Value::Array(list.into_iter().map(Value::String).collect())) + } + pub fn enc_vec_key_encryption(&self, list: Vec) -> String { + // Utilisez `serde_json::to_value` pour convertir chaque `KeyEncryption` en `Value` + let json_list: Vec = list + .into_iter() + .map(|key_enc| serde_json::to_value(key_enc).unwrap_or_else(|_| json!({}))) + .collect(); + + self.enc(Value::Array(json_list)) + } + pub fn enc_amount(&self, amount: Amount) -> String { + let amount_value = serde_json::to_value(amount).unwrap_or_else(|_| json!({})); + self.enc(amount_value) + } + pub fn enc_number(&self, number: Number) -> String { + let number_value = serde_json::to_value(number).unwrap_or_else(|_| json!({})); + self.enc(number_value) + } + pub fn enc_bool(&self, data: bool) -> String { + self.enc(Value::Bool(data)) + } + pub fn enc_vec_u32(&self, list: Vec) -> String { + let number_list: Vec = list + .into_iter() + .map(|num| Value::Number(serde_json::Number::from(num))) + .collect(); + + self.enc(Value::Array(number_list)) + } + + pub fn enc_vec_i64(&self, list: Vec) -> String { + let number_list: Vec = list + .into_iter() + .map(|num| Value::Number(serde_json::Number::from(num))) + .collect(); + + self.enc(Value::Array(number_list)) + } + pub fn enc_vec_bool(&self, list: Vec) -> String { + self.enc(Value::Array(list.into_iter().map(Value::Bool).collect())) + } + pub fn enc_pcd(&self, pcd: RequestPcd) -> String { + let pcd_value = serde_json::to_value(pcd).unwrap_or_else(|_| json!({})); + self.enc(pcd_value) + } + pub fn enc_prd_update(&self, prd: RequestPrdUpdate) -> String { + let prd_value = serde_json::to_value(prd).unwrap_or_else(|_| json!({})); + self.enc(prd_value) + } + pub fn enc_prd_list(&self, pcd: RequestPrdList) -> String { + let prd_value = serde_json::to_value(pcd).unwrap_or_else(|_| json!({})); + self.enc(prd_value) + } + pub fn enc_prd_response(&self, prd: RequestPrdResponse) -> String { + let prd_value = serde_json::to_value(prd).unwrap_or_else(|_| json!({})); + self.enc(prd_value) + } + pub fn enc_prd_confirm(&self, prd: RequestPrdConfirm) -> String { + let prd_value = serde_json::to_value(prd).unwrap_or_else(|_| json!({})); + self.enc(prd_value) + } + pub fn enc_prd_message(&self, prd: RequestPrdMessage) -> String { + let prd_value = serde_json::to_value(prd).unwrap_or_else(|_| json!({})); + self.enc(prd_value) + } + pub fn enc_prd_key_backup(&self, prd: RequestPrdKeyBackup) -> String { + let prd_value = serde_json::to_value(prd).unwrap_or_else(|_| json!({})); + self.enc(prd_value) + } + pub fn enc_prd_key_hello(&self, prd: RequestPrdKeyHello) -> String { + let prd_value = serde_json::to_value(prd).unwrap_or_else(|_| json!({})); + self.enc(prd_value) + } + pub fn enc_roles_group(&self, roles: RolesGroup) -> String { + let roles_value = serde_json::to_value(roles).unwrap_or_else(|_| json!({})); + self.enc(roles_value) + } +} diff --git a/src/models/message.rs b/src/models/message.rs new file mode 100644 index 0000000..529528b --- /dev/null +++ b/src/models/message.rs @@ -0,0 +1,113 @@ +use chrono::Utc; + +use rocket::FromForm; +use sha2::{Digest, Sha256}; + +use serde::{Deserialize, Serialize}; + +use super::shared_peer::SharedPeer; +use super::shared_process::SharedProcess; +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct Pow { + pub data_hash: String, + timestamp: Option, + pub nonce: Option, + pub pathern: String, + pub difficulty: usize, +} + +impl Pow { + pub fn new(data_hash: String, pathern: String, difficulty: usize) -> Self { + let mut pow = Pow { + data_hash, + nonce: None, + timestamp: None, + pathern, + difficulty, + }; + pow.find(); + return pow; + } + pub fn display_info(&self) { + println!("Pow:"); + println!("Data Hash: {}", self.data_hash); + println!("Timestamp: {}", self.timestamp.as_ref().unwrap_or(&0)); + println!("Nonce: {}", self.nonce.as_ref().unwrap_or(&0)); + println!("Pathern: {}", self.pathern); + println!("Difficulty: {}", self.difficulty); + } + pub fn find(&mut self) { + let mut nonce: u64 = 0; + loop { + // Mise à jour du timestamp à chaque itération + let current_timestamp = Utc::now().timestamp() as u64; + self.timestamp = Some(current_timestamp); + + // Créer une chaîne avec le hash actuel, le timestamp et le nonce + let data: String = format!("{}{}{}", self.data_hash, current_timestamp, nonce); + + // Calculer le hash SHA-256 + let mut hasher = Sha256::new(); + hasher.update(data); + let result = hasher.finalize(); + let hash_str: String = format!("{:x}", result); + + // Vérifier si le hash correspond au motif de difficulté + if hash_str.starts_with(&"0".repeat(self.difficulty as usize)) { + self.nonce = Some(nonce); + break; + } + + nonce += 1; + } + } +} + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct Message { + pub shared_peer_list: Vec, + pub shared_process_list: Vec, + pub faucet_sp_address: String, + pub pow: Pow, // Assuming Pow is a predefined struct +} + +impl Message { + pub fn new( + shared_peer_list: Vec, + shared_process_list: Vec, + faucet_sp_address: String, + pow_data_hash: String, + pow_pathern: String, + pow_difficulty: usize, + ) -> Self { + let pow: Pow = Pow::new(pow_data_hash, pow_pathern, pow_difficulty); + Message { + shared_peer_list, + shared_process_list, + faucet_sp_address, + pow, + } + } + pub fn display_info(&self) { + println!("Message:"); + println!("Shared Peer List:"); + for shared_peer in &self.shared_peer_list { + shared_peer.display_info(); // Assuming SharedPeers has a display_info method + } + + println!("Shared Process List:"); + for shared_process in &self.shared_process_list { + shared_process.display_info(); // Assuming SharedProcess has a display_info method + } + + println!("Faucet SP Address: {}", self.faucet_sp_address); + println!("PoW:"); + self.pow.display_info(); // Assuming Pow has a display_info method + } +} diff --git a/src/models/message_client.rs b/src/models/message_client.rs new file mode 100644 index 0000000..5face2f --- /dev/null +++ b/src/models/message_client.rs @@ -0,0 +1,54 @@ +use super::{message::Message, shared_peer::SharedPeer, shared_process::SharedProcess}; + +use rocket::FromForm; +use serde::{Deserialize, Serialize}; + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct MessageClient { + pub message: Message, // Assuming Message is a predefined struct + pub request_enc: String, + pub request_hash: String, +} + +impl MessageClient { + pub fn new( + request_enc: String, + request_hash: String, + message_shared_peer_list: Vec, + message_shared_process_list: Vec, + message_faucet_sp_address: String, + pow_pathern: String, + pow_difficulty: usize, + ) -> Self { + let pow_data_hash = request_hash; + let message: Message = Message::new( + message_shared_peer_list, + message_shared_process_list, + message_faucet_sp_address, + pow_data_hash.clone(), + pow_pathern, + pow_difficulty, + ); + MessageClient { + message, + request_enc, + request_hash: pow_data_hash, + } + } + pub fn send(&self) { + for shared_peer in &self.message.shared_peer_list { + shared_peer.send_message_client(self.clone()); // Assuming SharedPeers has a send method + } + } + pub fn display_info(&self) { + println!("MessageClient:"); + println!("Message:"); + self.message.display_info(); // Assuming Message has a display_info method + println!("Message Hash: {}", self.request_hash); + + println!("Request Enc: {}", self.request_enc); + } +} diff --git a/src/models/message_connect.rs b/src/models/message_connect.rs new file mode 100644 index 0000000..f714754 --- /dev/null +++ b/src/models/message_connect.rs @@ -0,0 +1,22 @@ +use rocket::FromForm; +use serde::{Deserialize, Serialize}; + +use super::message::Message; +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct MessageConnect { + pub message: Message, // Assuming Message is a predefined struct +} + +impl MessageConnect { + pub fn new(message: Message) -> Self { + MessageConnect { message } + } + pub fn display_info(&self) { + println!("MessageConnect:"); + println!("Message:"); + self.message.display_info(); // Assuming Message has a display_info method + } +} diff --git a/src/models/metadata.rs b/src/models/metadata.rs new file mode 100644 index 0000000..d86d66c --- /dev/null +++ b/src/models/metadata.rs @@ -0,0 +1,152 @@ +use rocket::FromForm; +use serde::{Deserialize, Serialize}; + +use super::key_encryption::KeyEncryption; +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct Number { + pub fixed_state: bool, + pub number: i32, + pub number_unit: String, +} + +impl Number { + // Constructor for Number struct + pub fn new(fixed_state: bool, number: i32, number_unit: String) -> Self { + Number { + fixed_state, + number, + number_unit, + } + } + pub fn display_info(&self) { + println!("Number:"); + println!("Fixed State: {}", self.fixed_state); + println!("Number: {}", self.number); + println!("Number Unit: {}", self.number_unit); + } + + // Additional methods for Number can be added here. +} + +// Struct for representing an amount with various attributes. +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct Amount { + pub timestamp: u64, + pub change_source_list: Vec, + pub amount_cent: i64, + pub amount_unit: String, + pub amount_unit_ref: String, // This can be a reference to an external unit system. +} + +impl Amount { + // Constructor for Amount struct + pub fn new( + timestamp: u64, + change_source_list: Vec, + amount_cent: i64, + amount_unit: String, + amount_unit_ref: String, + ) -> Self { + Amount { + timestamp, + change_source_list, + amount_cent, + amount_unit, + amount_unit_ref, + } + } + pub fn display(&self) -> String { + format!( + "Amount: {} {} {} {} {}", + self.timestamp, + self.change_source_list.join(","), + self.amount_cent, + self.amount_unit, + self.amount_unit_ref + ) + } + pub fn display_info(&self) { + println!("Amount:"); + println!("Timestamp: {}", self.timestamp); + println!("Change Source List: {:?}", self.change_source_list); + println!("Amount cent: {}", self.amount_cent); + println!("Amount Unit: {}", self.amount_unit); + println!("Amount Unit Reference: {}", self.amount_unit_ref); + } + // Additional methods for Amount can be added here. +} + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct MetaData { + pub tag_list: Vec, + pub zone_list: Vec, + pub label_list: Vec, + pub ref_list: Vec, + pub data_list: Vec, + pub amount: Amount, + pub number: Number, + pub render_template_list: Vec, + pub legal_text_list: Vec, + pub key_list: Vec, +} + +impl MetaData { + pub fn new( + tag_list: Vec, + zone_list: Vec, + label_list: Vec, + ref_list: Vec, + data_list: Vec, + amount: Amount, + number: Number, + render_template_list: Vec, + legal_text_list: Vec, + key_list: Vec, + ) -> Self { + MetaData { + tag_list, + zone_list, + label_list, + ref_list, + data_list, + amount, + number, + render_template_list, + legal_text_list, + key_list, + } + } + pub fn display_info(&self) { + println!("MetaData:"); + println!("Tag List: {:?}", self.tag_list); + println!("Zone List: {:?}", self.zone_list); + println!("Label List: {:?}", self.label_list); + println!("Ref List: {:?}", self.ref_list); + println!("Data List: {:?}", self.data_list); + + println!("Amount:"); + self.amount.display_info(); // Assuming Amount has a display_info method + + println!("Number:"); + self.number.display_info(); // Assuming Number has a display_info method + + println!("Render Template List: {:?}", self.render_template_list); + println!("Legal Text List: {:?}", self.legal_text_list); + + println!("Key List:"); + for key in &self.key_list { + key.display_info(); // Assuming KeyEncryption has a display_info method + } + } + + // Methods for manipulating MetaData can be added here. +} diff --git a/src/models/metadata_contract_public.rs b/src/models/metadata_contract_public.rs new file mode 100644 index 0000000..4e65dfd --- /dev/null +++ b/src/models/metadata_contract_public.rs @@ -0,0 +1,146 @@ +use rocket::FromForm; +use serde::{Deserialize, Serialize}; + +use super::{ + key_encryption::KeyEncryption, metadata::MetaData, + pcd_item_enc_attribute_public::PcdItemEncAttributePublic, +}; + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct MetadataContractPublic { + pub meta_data: MetaData, +} + +impl MetadataContractPublic { + pub fn new(meta_data: MetaData) -> Self { + MetadataContractPublic { meta_data } + } + pub fn display_info(&self) { + println!("MetadataContractPublic:"); + // Assuming MetaData has a display_info method + self.meta_data.display_info(); // Display information for `meta_data` + } + pub fn enc_list( + &self, + process_public_enc_key: KeyEncryption, + ) -> Vec { + let mut enc_attribute_list: Vec = Vec::new(); + + let enc_attribute_tag_list_key = KeyEncryption::new( + Some("tag_list".to_owned()), + process_public_enc_key.key.clone(), + process_public_enc_key.algorithm.clone(), + ); + let enc_attribute_tag_list = PcdItemEncAttributePublic::new( + "tag_list".to_owned(), + enc_attribute_tag_list_key.enc_vec_string(self.meta_data.tag_list.clone()), + ); + enc_attribute_list.push(enc_attribute_tag_list); + + let enc_attribute_zone_list_key = KeyEncryption::new( + Some("zone_list".to_owned()), + process_public_enc_key.key.clone(), + process_public_enc_key.algorithm.clone(), + ); + let enc_attribute_zone_list = PcdItemEncAttributePublic::new( + "zone_list".to_owned(), + enc_attribute_zone_list_key.enc_vec_string(self.meta_data.zone_list.clone()), + ); + enc_attribute_list.push(enc_attribute_zone_list); + + let enc_attribute_label_list_key = KeyEncryption::new( + Some("label_list".to_owned()), + process_public_enc_key.key.clone(), + process_public_enc_key.algorithm.clone(), + ); + let enc_attribute_label_list = PcdItemEncAttributePublic::new( + "label_list".to_owned(), + enc_attribute_label_list_key.enc_vec_string(self.meta_data.label_list.clone()), + ); + enc_attribute_list.push(enc_attribute_label_list); + + let enc_attribute_ref_list_key = KeyEncryption::new( + Some("ref_list".to_owned()), + process_public_enc_key.key.clone(), + process_public_enc_key.algorithm.clone(), + ); + let enc_attribute_ref_list = PcdItemEncAttributePublic::new( + "ref_list".to_owned(), + enc_attribute_ref_list_key.enc_vec_string(self.meta_data.ref_list.clone()), + ); + enc_attribute_list.push(enc_attribute_ref_list); + + let enc_attribute_data_list_key = KeyEncryption::new( + Some("data_list".to_owned()), + process_public_enc_key.key.clone(), + process_public_enc_key.algorithm.clone(), + ); + let enc_attribute_data_list = PcdItemEncAttributePublic::new( + "data_list".to_owned(), + enc_attribute_data_list_key.enc_vec_string(self.meta_data.data_list.clone()), + ); + enc_attribute_list.push(enc_attribute_data_list); + + let enc_attribute_amount_key = KeyEncryption::new( + Some("amount".to_owned()), + process_public_enc_key.key.clone(), + process_public_enc_key.algorithm.clone(), + ); + let enc_attribute_amount = PcdItemEncAttributePublic::new( + "amount".to_owned(), + enc_attribute_amount_key.enc_amount(self.meta_data.amount.clone()), + ); + enc_attribute_list.push(enc_attribute_amount); + + let enc_attribute_number_key = KeyEncryption::new( + Some("number".to_owned()), + process_public_enc_key.key.clone(), + process_public_enc_key.algorithm.clone(), + ); + let enc_attribute_number = PcdItemEncAttributePublic::new( + "number".to_owned(), + enc_attribute_number_key.enc_number(self.meta_data.number.clone()), + ); + enc_attribute_list.push(enc_attribute_number); + + let enc_attribute_render_template_list_key = KeyEncryption::new( + Some("render_template_list".to_owned()), + process_public_enc_key.key.clone(), + process_public_enc_key.algorithm.clone(), + ); + let enc_attribute_render_template_list = PcdItemEncAttributePublic::new( + "render_template_list".to_owned(), + enc_attribute_render_template_list_key + .enc_vec_string(self.meta_data.render_template_list.clone()), + ); + enc_attribute_list.push(enc_attribute_render_template_list); + + let enc_attribute_legal_text_list_key = KeyEncryption::new( + Some("legal_text_list".to_owned()), + process_public_enc_key.key.clone(), + process_public_enc_key.algorithm.clone(), + ); + let enc_attribute_legal_text_list = PcdItemEncAttributePublic::new( + "legal_text_list".to_owned(), + enc_attribute_legal_text_list_key + .enc_vec_string(self.meta_data.legal_text_list.clone()), + ); + enc_attribute_list.push(enc_attribute_legal_text_list); + + let enc_attribute_key_list_key = KeyEncryption::new( + Some("key_list".to_owned()), + process_public_enc_key.key.clone(), + process_public_enc_key.algorithm.clone(), + ); + let enc_attribute_key_list = PcdItemEncAttributePublic::new( + "key_list".to_owned(), + enc_attribute_key_list_key.enc_vec_key_encryption(self.meta_data.key_list.clone()), + ); + enc_attribute_list.push(enc_attribute_key_list); + + return enc_attribute_list; + } +} diff --git a/src/models/metadata_private.rs b/src/models/metadata_private.rs new file mode 100644 index 0000000..8905dba --- /dev/null +++ b/src/models/metadata_private.rs @@ -0,0 +1,146 @@ +use rocket::FromForm; +use serde::{Deserialize, Serialize}; + +use super::{ + key_encryption::KeyEncryption, metadata::MetaData, + pcd_item_enc_attribute_private::PcdItemEncAttributePrivate, +}; + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct MetadataPrivate { + pub meta_data: MetaData, +} + +impl MetadataPrivate { + pub fn new(meta_data: MetaData) -> Self { + MetadataPrivate { meta_data } + } + pub fn display_info(&self) { + println!("MetadataPrivate:"); + // Assuming MetaData has a display_info method + self.meta_data.display_info(); // Display information for `meta_data` + } + pub fn enc_list( + &self, + member_private_enc_key: KeyEncryption, + ) -> Vec { + let mut enc_attribute_list: Vec = Vec::new(); + + let enc_attribute_tag_list_key = KeyEncryption::new( + Some("tag_list".to_owned()), + member_private_enc_key.key.clone(), + member_private_enc_key.algorithm.clone(), + ); + let enc_attribute_tag_list = PcdItemEncAttributePrivate::new( + "tag_list".to_owned(), + enc_attribute_tag_list_key.enc_vec_string(self.meta_data.tag_list.clone()), + ); + enc_attribute_list.push(enc_attribute_tag_list); + + let enc_attribute_zone_list_key = KeyEncryption::new( + Some("zone_list".to_owned()), + member_private_enc_key.key.clone(), + member_private_enc_key.algorithm.clone(), + ); + let enc_attribute_zone_list = PcdItemEncAttributePrivate::new( + "zone_list".to_owned(), + enc_attribute_zone_list_key.enc_vec_string(self.meta_data.zone_list.clone()), + ); + enc_attribute_list.push(enc_attribute_zone_list); + + let enc_attribute_label_list_key = KeyEncryption::new( + Some("label_list".to_owned()), + member_private_enc_key.key.clone(), + member_private_enc_key.algorithm.clone(), + ); + let enc_attribute_label_list = PcdItemEncAttributePrivate::new( + "label_list".to_owned(), + enc_attribute_label_list_key.enc_vec_string(self.meta_data.label_list.clone()), + ); + enc_attribute_list.push(enc_attribute_label_list); + + let enc_attribute_ref_list_key = KeyEncryption::new( + Some("ref_list".to_owned()), + member_private_enc_key.key.clone(), + member_private_enc_key.algorithm.clone(), + ); + let enc_attribute_ref_list = PcdItemEncAttributePrivate::new( + "ref_list".to_owned(), + enc_attribute_ref_list_key.enc_vec_string(self.meta_data.ref_list.clone()), + ); + enc_attribute_list.push(enc_attribute_ref_list); + + let enc_attribute_data_list_key = KeyEncryption::new( + Some("data_list".to_owned()), + member_private_enc_key.key.clone(), + member_private_enc_key.algorithm.clone(), + ); + let enc_attribute_data_list = PcdItemEncAttributePrivate::new( + "data_list".to_owned(), + enc_attribute_data_list_key.enc_vec_string(self.meta_data.data_list.clone()), + ); + enc_attribute_list.push(enc_attribute_data_list); + + let enc_attribute_amount_key = KeyEncryption::new( + Some("amount".to_owned()), + member_private_enc_key.key.clone(), + member_private_enc_key.algorithm.clone(), + ); + let enc_attribute_amount = PcdItemEncAttributePrivate::new( + "amount".to_owned(), + enc_attribute_amount_key.enc_amount(self.meta_data.amount.clone()), + ); + enc_attribute_list.push(enc_attribute_amount); + + let enc_attribute_number_key = KeyEncryption::new( + Some("number".to_owned()), + member_private_enc_key.key.clone(), + member_private_enc_key.algorithm.clone(), + ); + let enc_attribute_number = PcdItemEncAttributePrivate::new( + "number".to_owned(), + enc_attribute_number_key.enc_number(self.meta_data.number.clone()), + ); + enc_attribute_list.push(enc_attribute_number); + + let enc_attribute_render_template_list_key = KeyEncryption::new( + Some("render_template_list".to_owned()), + member_private_enc_key.key.clone(), + member_private_enc_key.algorithm.clone(), + ); + let enc_attribute_render_template_list = PcdItemEncAttributePrivate::new( + "render_template_list".to_owned(), + enc_attribute_render_template_list_key + .enc_vec_string(self.meta_data.render_template_list.clone()), + ); + enc_attribute_list.push(enc_attribute_render_template_list); + + let enc_attribute_legal_text_list_key = KeyEncryption::new( + Some("legal_text_list".to_owned()), + member_private_enc_key.key.clone(), + member_private_enc_key.algorithm.clone(), + ); + let enc_attribute_legal_text_list = PcdItemEncAttributePrivate::new( + "legal_text_list".to_owned(), + enc_attribute_legal_text_list_key + .enc_vec_string(self.meta_data.legal_text_list.clone()), + ); + enc_attribute_list.push(enc_attribute_legal_text_list); + + let enc_attribute_key_list_key = KeyEncryption::new( + Some("key_list".to_owned()), + member_private_enc_key.key.clone(), + member_private_enc_key.algorithm.clone(), + ); + let enc_attribute_key_list = PcdItemEncAttributePrivate::new( + "key_list".to_owned(), + enc_attribute_key_list_key.enc_vec_key_encryption(self.meta_data.key_list.clone()), + ); + enc_attribute_list.push(enc_attribute_key_list); + + return enc_attribute_list; + } +} diff --git a/src/models/metadata_role_confidential.rs b/src/models/metadata_role_confidential.rs new file mode 100644 index 0000000..6ad8b21 --- /dev/null +++ b/src/models/metadata_role_confidential.rs @@ -0,0 +1,155 @@ +use rocket::FromForm; +use serde::{Deserialize, Serialize}; + +use super::{ + key_encryption::KeyEncryption, metadata::MetaData, + pcd_item_enc_attribute_role_confidential::PcdItemEncAttributeRoleConfidential, +}; + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct MetadataRoleConfidential { + pub meta_data: MetaData, +} + +impl MetadataRoleConfidential { + pub fn new(meta_data: MetaData) -> Self { + MetadataRoleConfidential { meta_data } + } + pub fn display_info(&self) { + println!("MetadataRoleConfidential:"); + // Assuming MetaData has a display_info method + self.meta_data.display_info(); // Display information for `meta_data` + } + pub fn enc_list(&self) -> Vec { + let mut enc_attribute_list: Vec = Vec::new(); + + // tag_list + let mut enc_attribute_tag_list_key = + KeyEncryption::new(Some("tag_list".to_owned()), None, None); + if let Ok(_new) = enc_attribute_tag_list_key.key_new_random() { + let enc_attribute_tag_list = PcdItemEncAttributeRoleConfidential::new( + "tag_list".to_owned(), + enc_attribute_tag_list_key.enc_vec_string(self.meta_data.tag_list.clone()), + enc_attribute_tag_list_key, + ); + enc_attribute_list.push(enc_attribute_tag_list); + } + + // zone_list + let mut enc_attribute_zone_list_key = + KeyEncryption::new(Some("zone_list".to_owned()), None, None); + if let Ok(_new) = enc_attribute_zone_list_key.key_new_random() { + let enc_attribute_zone_list = PcdItemEncAttributeRoleConfidential::new( + "zone_list".to_owned(), + enc_attribute_zone_list_key.enc_vec_string(self.meta_data.zone_list.clone()), + enc_attribute_zone_list_key, + ); + enc_attribute_list.push(enc_attribute_zone_list); + } + + // label_list + let mut enc_attribute_label_list_key = + KeyEncryption::new(Some("label_list".to_owned()), None, None); + if let Ok(_new) = enc_attribute_label_list_key.key_new_random() { + let enc_attribute_label_list = PcdItemEncAttributeRoleConfidential::new( + "label_list".to_owned(), + enc_attribute_label_list_key.enc_vec_string(self.meta_data.label_list.clone()), + enc_attribute_label_list_key, + ); + enc_attribute_list.push(enc_attribute_label_list); + } + + // ref_list + let mut enc_attribute_ref_list_key = + KeyEncryption::new(Some("ref_list".to_owned()), None, None); + if let Ok(_new) = enc_attribute_ref_list_key.key_new_random() { + let enc_attribute_ref_list = PcdItemEncAttributeRoleConfidential::new( + "ref_list".to_owned(), + enc_attribute_ref_list_key.enc_vec_string(self.meta_data.ref_list.clone()), + enc_attribute_ref_list_key, + ); + enc_attribute_list.push(enc_attribute_ref_list); + } + + // data_list + let mut enc_attribute_data_list_key = + KeyEncryption::new(Some("data_list".to_owned()), None, None); + if let Ok(_new) = enc_attribute_data_list_key.key_new_random() { + let enc_attribute_data_list = PcdItemEncAttributeRoleConfidential::new( + "data_list".to_owned(), + enc_attribute_data_list_key.enc_vec_string(self.meta_data.data_list.clone()), + enc_attribute_data_list_key, + ); + enc_attribute_list.push(enc_attribute_data_list); + } + + // amount + let mut enc_attribute_amount_key = + KeyEncryption::new(Some("amount".to_owned()), None, None); + if let Ok(_new) = enc_attribute_amount_key.key_new_random() { + let enc_attribute_amount = PcdItemEncAttributeRoleConfidential::new( + "amount".to_owned(), + enc_attribute_amount_key.enc_amount(self.meta_data.amount.clone()), + enc_attribute_amount_key, + ); + enc_attribute_list.push(enc_attribute_amount); + } + + // number + let mut enc_attribute_number_key = + KeyEncryption::new(Some("number".to_owned()), None, None); + if let Ok(_new) = enc_attribute_number_key.key_new_random() { + let enc_attribute_number = PcdItemEncAttributeRoleConfidential::new( + "number".to_owned(), + enc_attribute_number_key.enc_number(self.meta_data.number.clone()), + enc_attribute_number_key, + ); + enc_attribute_list.push(enc_attribute_number); + } + + // render_template_list + let mut enc_attribute_render_template_list_key = + KeyEncryption::new(Some("render_template_list".to_owned()), None, None); + if let Ok(_new) = enc_attribute_render_template_list_key.key_new_random() { + let enc_attribute_render_template_list = PcdItemEncAttributeRoleConfidential::new( + "render_template_list".to_owned(), + enc_attribute_render_template_list_key + .enc_vec_string(self.meta_data.render_template_list.clone()), + enc_attribute_render_template_list_key, + ); + enc_attribute_list.push(enc_attribute_render_template_list); + } + + // legal_text_list + let mut enc_attribute_legal_text_list_key = + KeyEncryption::new(Some("legal_text_list".to_owned()), None, None); + if let Ok(_new) = enc_attribute_legal_text_list_key.key_new_random() { + let enc_attribute_legal_text_list = PcdItemEncAttributeRoleConfidential::new( + "legal_text_list".to_owned(), + enc_attribute_legal_text_list_key + .enc_vec_string(self.meta_data.legal_text_list.clone()), + enc_attribute_legal_text_list_key, + ); + enc_attribute_list.push(enc_attribute_legal_text_list); + } + + // key_list + let mut enc_attribute_key_list_key = + KeyEncryption::new(Some("key_list".to_owned()), None, None); + if let Ok(_new) = enc_attribute_key_list_key.key_new_random() { + let enc_attribute_key_list = PcdItemEncAttributeRoleConfidential::new( + "key_list".to_owned(), + enc_attribute_key_list_key.enc_vec_key_encryption(self.meta_data.key_list.clone()), + enc_attribute_key_list_key, + ); + enc_attribute_list.push(enc_attribute_key_list); + } + + return enc_attribute_list; + } + + // Additional +} diff --git a/src/models/mod.rs b/src/models/mod.rs new file mode 100644 index 0000000..05e722e --- /dev/null +++ b/src/models/mod.rs @@ -0,0 +1,54 @@ +pub mod commitment_method; +pub mod condition_cap; +pub mod condition_commitment; +pub mod condition_deposit; +pub mod condition_orchestration; +pub mod condition_payment; +pub mod condition_prd_address_set; +pub mod condition_publish; +pub mod deposit_method; +pub mod item; +pub mod item_artefact; +pub mod item_commitment; +pub mod item_deposit; +pub mod item_enum; +pub mod item_member; +pub mod item_payment; +pub mod item_peer; +pub mod item_process; +pub mod key_encryption; +pub mod message; +pub mod message_client; +pub mod message_connect; +pub mod metadata; +pub mod metadata_contract_public; +pub mod metadata_private; +pub mod metadata_role_confidential; +pub mod pagination; +pub mod payment_method; +pub mod pcd_item_enc; +pub mod pcd_item_enc_attribute_private; +pub mod pcd_item_enc_attribute_public; +pub mod pcd_item_enc_attribute_role_confidential; +pub mod pcd_item_generic_enc; +pub mod request; +pub mod request_pcd; +pub mod request_prd; +pub mod request_prd_confirm; +pub mod request_prd_key_backup; +pub mod request_prd_key_hello; +pub mod request_prd_list; +pub mod request_prd_message; +pub mod request_prd_response; +pub mod request_prd_update; +pub mod role; +pub mod role_artefact; +pub mod role_commitment; +pub mod role_deposit; +pub mod role_member; +pub mod role_payment; +pub mod role_peer; +pub mod role_process; +pub mod roles_group; +pub mod shared_peer; +pub mod shared_process; diff --git a/src/models/pagination.rs b/src/models/pagination.rs new file mode 100644 index 0000000..ed5e08a --- /dev/null +++ b/src/models/pagination.rs @@ -0,0 +1,28 @@ +use rocket::FromForm; +use serde::{Deserialize, Serialize}; + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct Pagination { + pub start: usize, + pub number: usize, + pub page_index: usize, +} + +impl Pagination { + pub fn new(start: usize, number: usize, page_index: usize) -> Self { + Pagination { + start, + number, + page_index, + } + } + pub fn display_info(&self) { + println!("Pagination:"); + println!("Start: {}", self.start); + println!("Number: {}", self.number); + println!("Page Index: {}", self.page_index); + } +} diff --git a/src/models/payment_method.rs b/src/models/payment_method.rs new file mode 100644 index 0000000..1c5acf7 --- /dev/null +++ b/src/models/payment_method.rs @@ -0,0 +1,11 @@ +use rocket::FromForm; +use serde::{Deserialize, Serialize}; + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct PaymentMethod { + pub method: String, +} +impl PaymentMethod {} diff --git a/src/models/pcd_item_enc.rs b/src/models/pcd_item_enc.rs new file mode 100644 index 0000000..9089b7f --- /dev/null +++ b/src/models/pcd_item_enc.rs @@ -0,0 +1,66 @@ +use rocket::FromForm; +use std::hash::Hash; + +use serde::{Deserialize, Serialize}; + +use super::{ + pcd_item_enc_attribute_private::PcdItemEncAttributePrivate, + pcd_item_enc_attribute_public::PcdItemEncAttributePublic, + pcd_item_enc_attribute_role_confidential::PcdItemEncAttributeRoleConfidential, +}; + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct PcdItemEnc { + pub version: i64, + pub item_type: String, + pub name: String, + pub pagination_number_per_pcd: u32, + pub pcd_item_enc_attribute_public_list: Vec, + pub pcd_item_enc_attribute_role_confidential_list: Vec, + pub pcd_item_enc_attribute_private_list: Vec, +} + +impl PcdItemEnc { + pub fn new( + version: i64, + item_type: String, + name: String, + pagination_number_per_pcd: u32, + pcd_item_enc_attribute_public_list: Vec, + pcd_item_enc_attribute_role_confidential_list: Vec, + pcd_item_enc_attribute_private_list: Vec, + ) -> Self { + PcdItemEnc { + version, + item_type, + name, + pagination_number_per_pcd, + pcd_item_enc_attribute_public_list, + pcd_item_enc_attribute_role_confidential_list, + pcd_item_enc_attribute_private_list, + } + } + + pub fn display_info(&self) { + println!("PcdItemEnc:"); + println!("Public Attributes:"); + for attr in &self.pcd_item_enc_attribute_public_list { + attr.display_info(); + } + + println!("Role Confidential Attributes:"); + for attr in &self.pcd_item_enc_attribute_role_confidential_list { + attr.display_info(); + } + + println!("Private Attributes:"); + for attr in &self.pcd_item_enc_attribute_private_list { + attr.display_info(); + } + } + + // Additional methods for PcdItemEnc can be added here +} diff --git a/src/models/pcd_item_enc_attribute_private.rs b/src/models/pcd_item_enc_attribute_private.rs new file mode 100644 index 0000000..e3064be --- /dev/null +++ b/src/models/pcd_item_enc_attribute_private.rs @@ -0,0 +1,30 @@ +use rocket::FromForm; +use std::hash::Hash; + +use serde::{Deserialize, Serialize}; + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, FromForm, Hash, PartialOrd, Ord, +)] + +pub struct PcdItemEncAttributePrivate { + pub attribute_name: String, + pub data_enc: String, // Assuming the encrypted data is represented as a String +} + +impl PcdItemEncAttributePrivate { + pub fn new(attribute_name: String, data_enc: String) -> Self { + PcdItemEncAttributePrivate { + attribute_name, + data_enc, + } + } + // Method to display information + pub fn display_info(&self) { + println!("PcdItemEncAttributePrivate:"); + println!("Attribute Name: {}", self.attribute_name); + println!("Data Enc: {}", self.data_enc); + } + + // Additional methods for PcdItemEncAttributePrivate can be added here +} diff --git a/src/models/pcd_item_enc_attribute_public.rs b/src/models/pcd_item_enc_attribute_public.rs new file mode 100644 index 0000000..243f6f4 --- /dev/null +++ b/src/models/pcd_item_enc_attribute_public.rs @@ -0,0 +1,28 @@ +use rocket::FromForm; +use std::hash::Hash; + +use serde::{Deserialize, Serialize}; + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, FromForm, Hash, PartialOrd, Ord, +)] + +pub struct PcdItemEncAttributePublic { + pub attribute_name: String, + pub data_enc: String, // Assuming the encrypted data is represented as a String +} +impl PcdItemEncAttributePublic { + pub fn new(attribute_name: String, data_enc: String) -> Self { + PcdItemEncAttributePublic { + attribute_name, + data_enc, + } + } + pub fn display_info(&self) { + println!("PcdItemEncAttributePublic:"); + println!("Attribute Name: {}", self.attribute_name); + println!("Data Enc: {}", self.data_enc); + } + + // Additional methods for PcdItemEncAttributePublic can be added here +} diff --git a/src/models/pcd_item_enc_attribute_role_confidential.rs b/src/models/pcd_item_enc_attribute_role_confidential.rs new file mode 100644 index 0000000..3a4a3ac --- /dev/null +++ b/src/models/pcd_item_enc_attribute_role_confidential.rs @@ -0,0 +1,32 @@ +use rocket::FromForm; +use std::hash::Hash; + +use serde::{Deserialize, Serialize}; + +use super::key_encryption::KeyEncryption; + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, FromForm, Hash, PartialOrd, Ord, +)] + +pub struct PcdItemEncAttributeRoleConfidential { + pub attribute_name: String, + pub data_enc: String, // Assuming the encrypted data is represented as a String + pub key: KeyEncryption, // Assuming the encrypted data is represented as a String +} + +impl PcdItemEncAttributeRoleConfidential { + pub fn new(attribute_name: String, data_enc: String, key: KeyEncryption) -> Self { + PcdItemEncAttributeRoleConfidential { + attribute_name, + data_enc, + key, + } + } + pub fn display_info(&self) { + println!("PcdItemEncAttributeRoleConfidential:"); + println!("Attribute Name: {}", self.attribute_name); + println!("Data Enc: {}", self.data_enc); + self.key.display_info(); + } +} diff --git a/src/models/pcd_item_generic_enc.rs b/src/models/pcd_item_generic_enc.rs new file mode 100644 index 0000000..5b52c60 --- /dev/null +++ b/src/models/pcd_item_generic_enc.rs @@ -0,0 +1,66 @@ +use rocket::FromForm; +use std::hash::Hash; + +use serde::{Deserialize, Serialize}; + +use super::{ + pcd_item_enc::PcdItemEnc, pcd_item_enc_attribute_private::PcdItemEncAttributePrivate, + pcd_item_enc_attribute_public::PcdItemEncAttributePublic, + pcd_item_enc_attribute_role_confidential::PcdItemEncAttributeRoleConfidential, +}; + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct PcdItemGenericEnc { + pub item_enc: PcdItemEnc, + pub pcd_item_enc_attribute_public_list: Option>, + pub pcd_item_enc_attribute_role_confidential_list: + Option>, + pub pcd_item_enc_attribute_private_list: Option>, +} + +impl PcdItemGenericEnc { + pub fn new( + item_enc: PcdItemEnc, + pcd_item_enc_attribute_public_list: Option>, + pcd_item_enc_attribute_role_confidential_list: Option< + Vec, + >, + pcd_item_enc_attribute_private_list: Option>, + ) -> Self { + PcdItemGenericEnc { + item_enc, + pcd_item_enc_attribute_public_list, + pcd_item_enc_attribute_role_confidential_list, + pcd_item_enc_attribute_private_list, + } + } + + pub fn display_info(&self) { + println!("PcdItemEnc:"); + println!("Public Attributes:"); + for attr in &self.pcd_item_enc_attribute_public_list { + for attr_sub in attr { + attr_sub.display_info(); + } + } + + println!("Role Confidential Attributes:"); + for attr in &self.pcd_item_enc_attribute_role_confidential_list { + for attr_sub in attr { + attr_sub.display_info(); + } + } + + println!("Private Attributes:"); + for attr in &self.pcd_item_enc_attribute_private_list { + for attr_sub in attr { + attr_sub.display_info(); + } + } + } + + // Additional methods for PcdItemEnc can be added here +} diff --git a/src/models/request.rs b/src/models/request.rs new file mode 100644 index 0000000..624fc6f --- /dev/null +++ b/src/models/request.rs @@ -0,0 +1,49 @@ +use rocket::FromForm; +use serde::{Deserialize, Serialize}; + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct Request { + pub item_name: Option, + pub request_type: String, // `type` is a reserved keyword in Rust, renamed to `request_type` + pub version: i64, + pub process_hash: String, + pub pcd_reference_hash: Option, + pub item_reference_hash: Option, +} + +impl Request { + pub fn new( + item_name: Option, + request_type: String, + version: i64, + process_hash: String, + pcd_reference_hash: Option, + item_reference_hash: Option, + ) -> Self { + let req = Request { + item_name, + request_type, + version, + process_hash, + pcd_reference_hash, + item_reference_hash, + }; + return req; + } + + // Fonction pour afficher ou retourner les informations + pub fn display_info(&self) -> String { + format!( + "Item Name: {}, Request Type: {}, Version: {}, Process Hash: {}, PCD Reference Hash: {}, Item Reference Hash: {}", + self.item_name.as_ref().unwrap_or(&"None".to_string()), + self.request_type, + self.version, + self.process_hash, + self.pcd_reference_hash.as_ref().unwrap_or(&"None".to_string()), + self.item_reference_hash.as_ref().unwrap_or(&"None".to_string()), + ) + } +} diff --git a/src/models/request_pcd.rs b/src/models/request_pcd.rs new file mode 100644 index 0000000..cf0811d --- /dev/null +++ b/src/models/request_pcd.rs @@ -0,0 +1,146 @@ +use rocket::FromForm; +use std::{ + collections::hash_map::DefaultHasher, + hash::{Hash, Hasher}, +}; + +use serde::{Deserialize, Serialize}; + +use super::{ + item_enum::ItemEnum, key_encryption::KeyEncryption, message_client::MessageClient, + pagination::Pagination, pcd_item_generic_enc::PcdItemGenericEnc, request::Request, + shared_peer::SharedPeer, shared_process::SharedProcess, +}; + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct RequestPcd { + pub request: Request, // Assuming Request is a predefined struct + pub item_list: Vec, + pub pagination: Pagination, // Assuming Pagination is a predefined struct +} + +impl RequestPcd { + pub const TYPE: &'static str = "pcd"; + pub fn new( + request_item_name: Option, + request_version: i64, + request_process_hash: String, + request_pcd_reference_hash: Option, + request_item_reference_hash: Option, + item_list: Vec, + pagination: Pagination, + process_public_enc_key: KeyEncryption, + member_private_enc_key: KeyEncryption, + ) -> Self { + let request = Request::new( + request_item_name, + Self::TYPE.to_string(), + request_version, + request_process_hash, + request_pcd_reference_hash, + request_item_reference_hash, + ); + + // TODO: encrypt item_list + let mut item_enc_list: Vec = Vec::new(); + + item_list.iter().for_each(|item| match item { + ItemEnum::Process(item_process) => { + let item_enc = item_process.enc( + process_public_enc_key.clone(), + member_private_enc_key.clone(), + ); + item_enc_list.push(item_enc); + } + ItemEnum::Member(item_member) => { + let item_enc = item_member.enc( + process_public_enc_key.clone(), + member_private_enc_key.clone(), + ); + item_enc_list.push(item_enc); + } + ItemEnum::Artefact(item_artefact) => { + let item_enc = item_artefact.enc( + process_public_enc_key.clone(), + member_private_enc_key.clone(), + ); + item_enc_list.push(item_enc); + } + ItemEnum::Peer(item_peer) => { + let item_enc = item_peer.enc( + process_public_enc_key.clone(), + member_private_enc_key.clone(), + ); + item_enc_list.push(item_enc); + } + ItemEnum::Payment(item_payment) => { + let item_enc = item_payment.enc( + process_public_enc_key.clone(), + member_private_enc_key.clone(), + ); + item_enc_list.push(item_enc); + } + ItemEnum::Deposit(item_deposit) => { + let item_enc = item_deposit.enc( + process_public_enc_key.clone(), + member_private_enc_key.clone(), + ); + item_enc_list.push(item_enc); + } + ItemEnum::Commitment(item_commitment) => { + let item_enc = item_commitment.enc( + process_public_enc_key.clone(), + member_private_enc_key.clone(), + ); + item_enc_list.push(item_enc); + } + }); + + RequestPcd { + request, + item_list: item_enc_list, + pagination, + } + } + pub fn display_info(&self) { + println!("RequestPcd:"); + println!("Request:"); + self.request.display_info(); + + println!("Item List:"); + for item in &self.item_list { + item.display_info(); + } + + println!("Pagination:"); + self.pagination.display_info(); + } + + pub fn to_message( + &self, + process_public_enc_key: KeyEncryption, + message_shared_peer_list: Vec, + message_shared_process_list: Vec, + message_faucet_sp_address: String, + pow_pathern: String, + pow_difficulty: usize, + ) -> MessageClient { + let mut hasher: DefaultHasher = DefaultHasher::new(); + self.hash(&mut hasher); + let request_hash = hasher.finish().to_string(); + let request_enc: String = process_public_enc_key.enc_pcd(self.clone()).to_string(); + + MessageClient::new( + request_enc, + request_hash, + message_shared_peer_list, + message_shared_process_list, + message_faucet_sp_address, + pow_pathern, + pow_difficulty, + ) + } +} diff --git a/src/models/request_prd.rs b/src/models/request_prd.rs new file mode 100644 index 0000000..92e973e --- /dev/null +++ b/src/models/request_prd.rs @@ -0,0 +1,113 @@ +use rocket::FromForm; +use serde::{Deserialize, Serialize}; +use std::hash::Hash; + +use super::{key_encryption::KeyEncryption, request::Request}; +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] +pub struct KeyRoleConfidential { + pub attribute_name: String, + pub key: KeyEncryption, + pub algorithm_name: String, +} + +impl KeyRoleConfidential { + pub fn new(attribute_name: String, key: KeyEncryption, algorithm_name: String) -> Self { + KeyRoleConfidential { + attribute_name, + key, + algorithm_name, + } + } + + // Fonction pour afficher ou retourner les informations + pub fn display_info(&self) -> String { + format!( + "Attribute Name: {}, Key: {:?}, Algorithm: {}", + self.attribute_name, + self.key, // Utilise {:?} si KeyEncryption implémente Debug + self.algorithm_name + ) + } + + // Additional methods for KeyRoleConfidential can be added here +} + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, FromForm, Hash, PartialOrd, Ord, +)] +pub struct RequestPrd { + pub request: Request, // Assuming Request is a predefined struct + pub pcd_keys_role_confidential_list_enc_by_shared_secret: String, + pub message_public: Option, + pub message_confidential: Option, + pub message_private: Option, + pub sp_address_to: String, + pub sp_address_from: String, + pub sp_address_reply: String, + pub timestamp_declared: u64, // Assuming a Unix timestamp + pub role_name_from: String, + pub role_name_to: String, +} + +impl RequestPrd { + pub const TYPE: &'static str = "prd"; + pub fn new( + request_item_name: Option, + request_type: String, + request_version: i64, + request_process_hash: String, + request_pcd_reference_hash: Option, + request_item_reference_hash: Option, + pcd_keys_role_confidential_list_enc_by_shared_secret: String, + message_public: Option, + message_confidential: Option, + message_private: Option, + sp_address_to: String, + sp_address_from: String, + sp_address_reply: String, + timestamp_declared: u64, + role_name_from: String, + role_name_to: String, + ) -> Self { + let request = Request::new( + request_item_name, + request_type, + request_version, + request_process_hash, + request_pcd_reference_hash, + request_item_reference_hash, + ); + RequestPrd { + request, + pcd_keys_role_confidential_list_enc_by_shared_secret, + message_public, + message_confidential, + message_private, + sp_address_to, + sp_address_from, + sp_address_reply, + timestamp_declared, + role_name_from, + role_name_to, + } + } + + // Fonction pour afficher ou retourner les informations + pub fn display_info(&self) -> String { + format!( + "Request: {:?}, PCD Keys Role Confidential: {:?}, Message Public: {}, Message Confidential: {}, Message Private: {}, SP Address From: {}, SP Address Reply: {}, Timestamp Declared: {}, Role Name From: {}, Role Name To: {}", + self.request, + self.pcd_keys_role_confidential_list_enc_by_shared_secret, + self.message_public.as_ref().unwrap(), + self.message_confidential.as_ref().unwrap(), + self.message_private.as_ref().unwrap(), + self.sp_address_from, + self.sp_address_reply, + self.timestamp_declared, + self.role_name_from, + self.role_name_to, + ) + } +} diff --git a/src/models/request_prd_confirm.rs b/src/models/request_prd_confirm.rs new file mode 100644 index 0000000..5f6a5cb --- /dev/null +++ b/src/models/request_prd_confirm.rs @@ -0,0 +1,103 @@ +use rocket::FromForm; +use std::{ + collections::hash_map::DefaultHasher, + hash::{Hash, Hasher}, +}; + +use serde::{Deserialize, Serialize}; + +use super::{ + key_encryption::KeyEncryption, message_client::MessageClient, request_prd::RequestPrd, + shared_peer::SharedPeer, shared_process::SharedProcess, +}; +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct RequestPrdConfirm { + pub prd: RequestPrd, + pub code_confirm_enc_by_shared_secret: String, +} + +impl RequestPrdConfirm { + pub const TYPE: &'static str = "prd_confirm"; + pub fn new( + request_item_name: Option, + request_version: i64, + request_process_hash: String, + request_pcd_reference_hash: Option, + request_item_reference_hash: Option, + pcd_keys_role_confidential_list_enc_by_shared_secret: String, + message_public: Option, + message_confidential: Option, + message_private: Option, + sp_address_to: String, + sp_address_from: String, + sp_address_reply: String, + timestamp_declared: u64, + role_name_from: String, + role_name_to: String, + code_confirm_enc_by_shared_secret: String, + ) -> Self { + let request_type = Self::TYPE.to_string(); + let prd = RequestPrd::new( + request_item_name, + request_type, + request_version, + request_process_hash, + request_pcd_reference_hash, + request_item_reference_hash, + pcd_keys_role_confidential_list_enc_by_shared_secret, + message_public, + message_confidential, + message_private, + sp_address_to, + sp_address_from, + sp_address_reply, + timestamp_declared, + role_name_from, + role_name_to, + ); + RequestPrdConfirm { + prd, + code_confirm_enc_by_shared_secret, + } + } + + pub fn to_message( + &self, + process_public_enc_key: KeyEncryption, + message_shared_peer_list: Vec, + message_shared_process_list: Vec, + message_faucet_sp_address: String, + pow_pathern: String, + pow_difficulty: usize, + ) -> MessageClient { + let mut hasher: DefaultHasher = DefaultHasher::new(); + self.hash(&mut hasher); + let request_hash = hasher.finish().to_string(); + let request_enc: String = process_public_enc_key + .enc_prd_confirm(self.clone()) + .to_string(); + + MessageClient::new( + request_enc, + request_hash, + message_shared_peer_list, + message_shared_process_list, + message_faucet_sp_address, + pow_pathern, + pow_difficulty, + ) + } + // display_info method + pub fn display_info(&self) { + println!("RequestPrdConfirm:"); + println!("PRD:"); + self.prd.display_info(); // Display information of RequestPrd + println!( + "Code Confirm (Encrypted by Shared Secret): {}", + self.code_confirm_enc_by_shared_secret + ); + } +} diff --git a/src/models/request_prd_key_backup.rs b/src/models/request_prd_key_backup.rs new file mode 100644 index 0000000..72a873d --- /dev/null +++ b/src/models/request_prd_key_backup.rs @@ -0,0 +1,111 @@ +use rocket::FromForm; +use std::{ + collections::hash_map::DefaultHasher, + hash::{Hash, Hasher}, +}; + +use serde::{Deserialize, Serialize}; + +use super::{ + key_encryption::KeyEncryption, message_client::MessageClient, request_prd::RequestPrd, + shared_peer::SharedPeer, shared_process::SharedProcess, +}; +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct RequestPrdKeyBackup { + pub prd: RequestPrd, + pub device_footprint_enc_by_sp_shared_secret: String, + pub part_1_enc_hash_enc_by_sp_shared_secret: String, + pub shard_enc_by_sp_shared_secret: String, +} + +impl RequestPrdKeyBackup { + pub const TYPE: &'static str = "prd_key_backup"; + pub fn new( + request_item_name: Option, + request_version: i64, + request_process_hash: String, + request_pcd_reference_hash: Option, + request_item_reference_hash: Option, + pcd_keys_role_confidential_list_enc_by_shared_secret: String, + message_public: Option, + message_confidential: Option, + message_private: Option, + sp_address_to: String, + sp_address_from: String, + sp_address_reply: String, + timestamp_declared: u64, + role_name_from: String, + role_name_to: String, + + device_footprint_enc_by_sp_shared_secret: String, + part_1_enc_hash_enc_by_sp_shared_secret: String, + shard_enc_by_sp_shared_secret: String, + ) -> Self { + let request_type = Self::TYPE.to_string(); + let prd = RequestPrd::new( + request_item_name, + request_type, + request_version, + request_process_hash, + request_pcd_reference_hash, + request_item_reference_hash, + pcd_keys_role_confidential_list_enc_by_shared_secret, + message_public, + message_confidential, + message_private, + sp_address_to, + sp_address_from, + sp_address_reply, + timestamp_declared, + role_name_from, + role_name_to, + ); + RequestPrdKeyBackup { + prd, + device_footprint_enc_by_sp_shared_secret, + part_1_enc_hash_enc_by_sp_shared_secret, + shard_enc_by_sp_shared_secret, + } + } + + pub fn to_message( + &self, + process_public_enc_key: KeyEncryption, + message_shared_peer_list: Vec, + message_shared_process_list: Vec, + message_faucet_sp_address: String, + pow_pathern: String, + pow_difficulty: usize, + ) -> MessageClient { + let mut hasher: DefaultHasher = DefaultHasher::new(); + self.hash(&mut hasher); + let request_hash = hasher.finish().to_string(); + let request_enc: String = process_public_enc_key + .enc_prd_key_backup(self.clone()) + .to_string(); + + MessageClient::new( + request_enc, + request_hash, + message_shared_peer_list, + message_shared_process_list, + message_faucet_sp_address, + pow_pathern, + pow_difficulty, + ) + } + + // Fonction pour afficher ou retourner les informations + pub fn display_info(&self) -> String { + format!( + "PRD: {:?}, Device Footprint Encrypted: {}, Part 1 Encrypted Hash: {}, Shard Encrypted: {}", + self.prd, + self.device_footprint_enc_by_sp_shared_secret, + self.part_1_enc_hash_enc_by_sp_shared_secret, + self.shard_enc_by_sp_shared_secret + ) + } +} diff --git a/src/models/request_prd_key_hello.rs b/src/models/request_prd_key_hello.rs new file mode 100644 index 0000000..a99f8e5 --- /dev/null +++ b/src/models/request_prd_key_hello.rs @@ -0,0 +1,101 @@ +use rocket::FromForm; +use std::{ + collections::hash_map::DefaultHasher, + hash::{Hash, Hasher}, +}; + +use serde::{Deserialize, Serialize}; + +use super::{ + key_encryption::KeyEncryption, message_client::MessageClient, request_prd::RequestPrd, + shared_peer::SharedPeer, shared_process::SharedProcess, +}; +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct RequestPrdKeyHello { + pub prd: RequestPrd, + pub part_1_enc_hash_enc_by_sp_shared_secret: String, +} + +impl RequestPrdKeyHello { + pub const TYPE: &'static str = "prd_key_hello"; + pub fn new( + request_item_name: Option, + request_version: i64, + request_process_hash: String, + request_pcd_reference_hash: Option, + request_item_reference_hash: Option, + pcd_keys_role_confidential_list_enc_by_shared_secret: String, + message_public: Option, + message_confidential: Option, + message_private: Option, + sp_address_to: String, + sp_address_from: String, + sp_address_reply: String, + timestamp_declared: u64, + role_name_from: String, + role_name_to: String, + part_1_enc_hash_enc_by_sp_shared_secret: String, + ) -> Self { + let request_type = Self::TYPE.to_string(); + let prd = RequestPrd::new( + request_item_name, + request_type, + request_version, + request_process_hash, + request_pcd_reference_hash, + request_item_reference_hash, + pcd_keys_role_confidential_list_enc_by_shared_secret, + message_public, + message_confidential, + message_private, + sp_address_to, + sp_address_from, + sp_address_reply, + timestamp_declared, + role_name_from, + role_name_to, + ); + RequestPrdKeyHello { + prd, + part_1_enc_hash_enc_by_sp_shared_secret, + } + } + + pub fn to_message( + &self, + process_public_enc_key: KeyEncryption, + message_shared_peer_list: Vec, + message_shared_process_list: Vec, + message_faucet_sp_address: String, + pow_pathern: String, + pow_difficulty: usize, + ) -> MessageClient { + let mut hasher: DefaultHasher = DefaultHasher::new(); + self.hash(&mut hasher); + let request_hash = hasher.finish().to_string(); + let request_enc: String = process_public_enc_key + .enc_prd_key_hello(self.clone()) + .to_string(); + + MessageClient::new( + request_enc, + request_hash, + message_shared_peer_list, + message_shared_process_list, + message_faucet_sp_address, + pow_pathern, + pow_difficulty, + ) + } + + // Fonction pour afficher ou retourner les informations + pub fn display_info(&self) -> String { + format!( + "PRD: {:?}, Part 1 Encrypted Hash: {}", + self.prd, self.part_1_enc_hash_enc_by_sp_shared_secret + ) + } +} diff --git a/src/models/request_prd_list.rs b/src/models/request_prd_list.rs new file mode 100644 index 0000000..4728e14 --- /dev/null +++ b/src/models/request_prd_list.rs @@ -0,0 +1,93 @@ +use rocket::FromForm; +use std::{ + collections::hash_map::DefaultHasher, + hash::{Hash, Hasher}, +}; + +use serde::{Deserialize, Serialize}; + +use super::{ + key_encryption::KeyEncryption, message_client::MessageClient, request_prd::RequestPrd, + shared_peer::SharedPeer, shared_process::SharedProcess, +}; +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct RequestPrdList { + pub prd: RequestPrd, +} + +impl RequestPrdList { + pub const TYPE: &'static str = "prd_list"; + pub fn new( + request_item_name: Option, + request_version: i64, + request_process_hash: String, + request_pcd_reference_hash: Option, + request_item_reference_hash: Option, + pcd_keys_role_confidential_list_enc_by_shared_secret: String, + message_public: Option, + message_confidential: Option, + message_private: Option, + sp_address_to: String, + sp_address_from: String, + sp_address_reply: String, + timestamp_declared: u64, + role_name_from: String, + role_name_to: String, + ) -> Self { + let request_type = Self::TYPE.to_string(); + let prd = RequestPrd::new( + request_item_name, + request_type, + request_version, + request_process_hash, + request_pcd_reference_hash, + request_item_reference_hash, + pcd_keys_role_confidential_list_enc_by_shared_secret, + message_public, + message_confidential, + message_private, + sp_address_to, + sp_address_from, + sp_address_reply, + timestamp_declared, + role_name_from, + role_name_to, + ); + RequestPrdList { prd } + } + + pub fn to_message( + &self, + process_public_enc_key: KeyEncryption, + message_shared_peer_list: Vec, + message_shared_process_list: Vec, + message_faucet_sp_address: String, + pow_pathern: String, + pow_difficulty: usize, + ) -> MessageClient { + let mut hasher: DefaultHasher = DefaultHasher::new(); + self.hash(&mut hasher); + let request_hash = hasher.finish().to_string(); + let request_enc: String = process_public_enc_key + .enc_prd_list(self.clone()) + .to_string(); + + MessageClient::new( + request_enc, + request_hash, + message_shared_peer_list, + message_shared_process_list, + message_faucet_sp_address, + pow_pathern, + pow_difficulty, + ) + } + + // Fonction pour afficher ou retourner les informations + pub fn display_info(&self) -> String { + format!("PRD: {:?}", self.prd) + } +} diff --git a/src/models/request_prd_message.rs b/src/models/request_prd_message.rs new file mode 100644 index 0000000..381f93f --- /dev/null +++ b/src/models/request_prd_message.rs @@ -0,0 +1,92 @@ +use rocket::FromForm; +use std::{ + collections::hash_map::DefaultHasher, + hash::{Hash, Hasher}, +}; + +use serde::{Deserialize, Serialize}; + +use super::{ + key_encryption::KeyEncryption, message_client::MessageClient, request_prd::RequestPrd, + shared_peer::SharedPeer, shared_process::SharedProcess, +}; +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct RequestPrdMessage { + pub prd: RequestPrd, +} + +impl RequestPrdMessage { + pub const TYPE: &'static str = "prd_message"; + pub fn new( + request_item_name: Option, + request_version: i64, + request_process_hash: String, + request_pcd_reference_hash: Option, + request_item_reference_hash: Option, + pcd_keys_role_confidential_list_enc_by_shared_secret: String, + message_public: Option, + message_confidential: Option, + message_private: Option, + sp_address_to: String, + sp_address_from: String, + sp_address_reply: String, + timestamp_declared: u64, + role_name_from: String, + role_name_to: String, + ) -> Self { + let request_type = Self::TYPE.to_string(); + let prd = RequestPrd::new( + request_item_name, + request_type, + request_version, + request_process_hash, + request_pcd_reference_hash, + request_item_reference_hash, + pcd_keys_role_confidential_list_enc_by_shared_secret, + message_public, + message_confidential, + message_private, + sp_address_to, + sp_address_from, + sp_address_reply, + timestamp_declared, + role_name_from, + role_name_to, + ); + RequestPrdMessage { prd } + } + + pub fn to_message( + &self, + process_public_enc_key: KeyEncryption, + message_shared_peer_list: Vec, + message_shared_process_list: Vec, + message_faucet_sp_address: String, + pow_pathern: String, + pow_difficulty: usize, + ) -> MessageClient { + let mut hasher: DefaultHasher = DefaultHasher::new(); + self.hash(&mut hasher); + let request_hash = hasher.finish().to_string(); + let request_enc: String = process_public_enc_key + .enc_prd_message(self.clone()) + .to_string(); + + MessageClient::new( + request_enc, + request_hash, + message_shared_peer_list, + message_shared_process_list, + message_faucet_sp_address, + pow_pathern, + pow_difficulty, + ) + } + // Fonction pour afficher ou retourner les informations + pub fn display_info(&self) -> String { + format!("PRD: {:?}", self.prd) + } +} diff --git a/src/models/request_prd_response.rs b/src/models/request_prd_response.rs new file mode 100644 index 0000000..cf7a491 --- /dev/null +++ b/src/models/request_prd_response.rs @@ -0,0 +1,181 @@ +use rocket::FromForm; +use serde_json::json; +use std::{collections::hash_map::DefaultHasher, hash::Hash, hash::Hasher}; + +use serde::{Deserialize, Serialize}; + +use crate::workflows::workflow_pcd_create_and_send_all::PcdItemEncAttributeRoleConfidentialExportKey; + +use super::{ + commitment_method::CommitmentMethod, deposit_method::DepositMethod, + key_encryption::KeyEncryption, message_client::MessageClient, payment_method::PaymentMethod, + request_prd::RequestPrd, shared_peer::SharedPeer, shared_process::SharedProcess, +}; +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, FromForm, Hash, PartialOrd, Ord, +)] + +pub struct RequestPrdResponse { + pub prd: RequestPrd, + pub sig_value: String, + pub pcd_origin_hash: Option, + pub payment_method_enc_by_shared_secret: Option, + pub deposit_method_enc_by_shared_secret: Option, + pub commitment_method_enc_by_shared_secret: Option, + pub certif_key_enc_by_shared_secret: Option, + pub shared_secret_key: Option, +} + +impl RequestPrdResponse { + pub const TYPE: &'static str = "prd_response"; + pub fn new( + process_public_enc_key: KeyEncryption, + member_private_enc_key: KeyEncryption, + + request_item_name: Option, + request_version: i64, + request_process_hash: String, + request_pcd_reference_hash: Option, + request_item_reference_hash: Option, + pcd_keys_role_confidential_list: Vec, + + message_public_string: Option, + message_confidential_string: Option, + message_private_string: Option, + + sp_address_to: String, + sp_address_from: String, + sp_address_reply: String, + timestamp_declared: u64, + role_name_from: String, + role_name_to: String, + + sig_value: String, + pcd_origin_hash: Option, + + payment_method: Option, + deposit_method: Option, + commitment_method: Option, + certif_key: Option, + ) -> Self { + let mut shared_secret_key = + KeyEncryption::new(Some("secret_shared".to_owned()), None, None); + + if let Ok(_new) = shared_secret_key.key_new_random() { + let payment_method_enc_by_shared_secret = match payment_method { + Some(ref _msg) => { + Some(shared_secret_key.enc(serde_json::to_value(payment_method).unwrap())) + } + None => None, + }; + + let deposit_method_enc_by_shared_secret = match deposit_method { + Some(ref _msg) => { + Some(shared_secret_key.enc(serde_json::to_value(deposit_method).unwrap())) + } + None => None, + }; + + let commitment_method_enc_by_shared_secret = match commitment_method { + Some(ref _msg) => { + Some(shared_secret_key.enc(serde_json::to_value(commitment_method).unwrap())) + } + None => None, + }; + + let certif_key_enc_by_shared_secret = match certif_key { + Some(ref _msg) => { + Some(shared_secret_key.enc(serde_json::to_value(certif_key).unwrap())) + } + None => None, + }; + + let message_confidential = message_confidential_string + .as_ref() + .map(|msg| shared_secret_key.enc_string(msg.clone())); + let message_public = message_public_string + .as_ref() + .map(|msg| process_public_enc_key.enc_string(msg.clone())); + let message_private = message_private_string + .as_ref() + .map(|msg| member_private_enc_key.enc_string(msg.clone())); + + let pcd_keys_role_confidential_list_enc_by_shared_secret = shared_secret_key.enc( + serde_json::to_value(pcd_keys_role_confidential_list).unwrap_or_else(|_| json!({})), + ); + + let request_type = Self::TYPE.to_string(); + let prd = RequestPrd::new( + request_item_name, + request_type, + request_version, + request_process_hash, + request_pcd_reference_hash, + request_item_reference_hash, + pcd_keys_role_confidential_list_enc_by_shared_secret, + message_public, + message_confidential, + message_private, + sp_address_to, + sp_address_from, + sp_address_reply, + timestamp_declared, + role_name_from, + role_name_to, + ); + RequestPrdResponse { + prd, + sig_value, + pcd_origin_hash, + payment_method_enc_by_shared_secret, + deposit_method_enc_by_shared_secret, + commitment_method_enc_by_shared_secret, + certif_key_enc_by_shared_secret, + shared_secret_key: Some(shared_secret_key), + } + } else { + panic!("Error: Could not create shared secret key"); + } + } + + pub fn to_message( + &self, + process_public_enc_key: KeyEncryption, + message_shared_peer_list: Vec, + message_shared_process_list: Vec, + message_faucet_sp_address: String, + pow_pathern: String, + pow_difficulty: usize, + ) -> MessageClient { + let mut hasher: DefaultHasher = DefaultHasher::new(); + self.hash(&mut hasher); + let request_hash = hasher.finish().to_string(); + let request_enc: String = process_public_enc_key + .enc_prd_response(self.clone()) + .to_string(); + + MessageClient::new( + request_enc, + request_hash, + message_shared_peer_list, + message_shared_process_list, + message_faucet_sp_address, + pow_pathern, + pow_difficulty, + ) + } + + // Fonction pour afficher ou retourner les informations + pub fn display_info(&self) -> String { + format!( + "PRD: {:?}, Sig Value: {}, PCD Origin Hash: {}, Payment Method Encrypted: {}, Deposit Method Encrypted: {}, Commitment Method Encrypted: {}, Certification Key Encrypted: {}", + self.prd, + self.sig_value, + self.pcd_origin_hash.as_ref().unwrap(), + self.payment_method_enc_by_shared_secret.as_ref().unwrap(), + self.deposit_method_enc_by_shared_secret.as_ref().unwrap(), + self.commitment_method_enc_by_shared_secret.as_ref().unwrap(), + self.certif_key_enc_by_shared_secret.as_ref().unwrap() + ) + } +} diff --git a/src/models/request_prd_update.rs b/src/models/request_prd_update.rs new file mode 100644 index 0000000..aaec519 --- /dev/null +++ b/src/models/request_prd_update.rs @@ -0,0 +1,130 @@ +use rocket::FromForm; +use std::{ + collections::hash_map::DefaultHasher, + hash::{Hash, Hasher}, +}; + +use super::{ + key_encryption::KeyEncryption, message_client::MessageClient, request_prd::RequestPrd, + shared_peer::SharedPeer, shared_process::SharedProcess, +}; +use serde::{Deserialize, Serialize}; +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct RequestPrdUpdate { + pub prd: RequestPrd, + pub pcd_new_version_hash: String, + pub payment_pcd_hash_list: Vec, + pub cap_pcd_hash_list: Vec, + pub deposit_pcd_hash_list: Vec, + pub commitment_pcd_hash_list: Vec, + pub ask_payment_method: String, + pub ask_deposit_method: String, + pub ask_commitment_method: String, +} + +impl RequestPrdUpdate { + pub const TYPE: &'static str = "prd_update"; + pub fn new( + request_item_name: Option, + request_version: i64, + request_process_hash: String, + request_pcd_reference_hash: Option, + request_item_reference_hash: Option, + pcd_keys_role_confidential_list_enc_by_shared_secret: String, + message_public: Option, + message_confidential: Option, + message_private: Option, + sp_address_to: String, + sp_address_from: String, + sp_address_reply: String, + timestamp_declared: u64, + role_name_from: String, + role_name_to: String, + + pcd_new_version_hash: String, + payment_pcd_hash_list: Vec, + cap_pcd_hash_list: Vec, + deposit_pcd_hash_list: Vec, + commitment_pcd_hash_list: Vec, + ask_payment_method: String, + ask_deposit_method: String, + ask_commitment_method: String, + ) -> Self { + let request_type = Self::TYPE.to_string(); + let prd = RequestPrd::new( + request_item_name, + request_type, + request_version, + request_process_hash, + request_pcd_reference_hash, + request_item_reference_hash, + pcd_keys_role_confidential_list_enc_by_shared_secret, + message_public, + message_confidential, + message_private, + sp_address_to, + sp_address_from, + sp_address_reply, + timestamp_declared, + role_name_from, + role_name_to, + ); + RequestPrdUpdate { + prd, + pcd_new_version_hash, + payment_pcd_hash_list, + cap_pcd_hash_list, + deposit_pcd_hash_list, + commitment_pcd_hash_list, + ask_payment_method, + ask_deposit_method, + ask_commitment_method, + } + } + + pub fn to_message( + &self, + process_public_enc_key: KeyEncryption, + message_shared_peer_list: Vec, + message_shared_process_list: Vec, + message_faucet_sp_address: String, + pow_pathern: String, + pow_difficulty: usize, + ) -> MessageClient { + let mut hasher: DefaultHasher = DefaultHasher::new(); + self.hash(&mut hasher); + let request_hash = hasher.finish().to_string(); + let request_enc: String = process_public_enc_key + .enc_prd_update(self.clone()) + .to_string(); + + MessageClient::new( + request_enc, + request_hash, + message_shared_peer_list, + message_shared_process_list, + message_faucet_sp_address, + pow_pathern, + pow_difficulty, + ) + } + + // Fonction pour afficher ou retourner les informations + pub fn display_info(&self) -> String { + format!( + "PRD: {:?}, PCD New Version Hash: {}, Payment PCD Hash List: {:?}, Cap PCD Hash List: {:?}, Deposit PCD Hash List: {:?}, Commitment PCD Hash List: {:?}, Ask Payment Method: {}, Ask Deposit Method: {}, Ask Commitment Method: {}", + self.prd, + self.pcd_new_version_hash, + self.payment_pcd_hash_list, + self.cap_pcd_hash_list, + self.deposit_pcd_hash_list, + self.commitment_pcd_hash_list, + self.ask_payment_method, + self.ask_deposit_method, + self.ask_commitment_method, + ) + } +} diff --git a/src/models/role.rs b/src/models/role.rs new file mode 100644 index 0000000..7673fa8 --- /dev/null +++ b/src/models/role.rs @@ -0,0 +1,210 @@ +use rocket::FromForm; +use serde::{Deserialize, Serialize}; + +use super::{ + condition_cap::ConditionCap, condition_commitment::ConditionCommitment, + condition_orchestration::ConditionOrchestration, condition_payment::ConditionPayment, + condition_prd_address_set::ConditionPrdAddressSet, condition_publish::ConditionPublish, + item::Item, metadata::Amount, +}; +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct TransactionModeDistribution { + pub from_prd_update_from: String, + pub from_role_list: Vec, + pub to_role_list: Vec, + pub from_prd_address_list: Vec, + pub to_prd_address_list: Vec, + pub method: String, +} + +impl TransactionModeDistribution { + pub fn new( + from_prd_update_from: String, + from_role_list: Vec, + to_role_list: Vec, + from_prd_address_list: Vec, + to_prd_address_list: Vec, + method: String, + ) -> Self { + TransactionModeDistribution { + from_prd_update_from, + from_role_list, + to_role_list, + from_prd_address_list, + to_prd_address_list, + method, + } + } + // display_info method + pub fn display_info(&self) { + println!("TransactionModeDistribution:"); + println!("From PRD Update From: {}", self.from_prd_update_from); + println!("From Role List: {:?}", self.from_role_list); + println!("To Role List: {:?}", self.to_role_list); + println!("From PRD Address List: {:?}", self.from_prd_address_list); + println!("To PRD Address List: {:?}", self.to_prd_address_list); + println!("Method: {}", self.method); + } +} + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct TransactionModeDirect { + pub from_prd_update_from: String, + pub to_role_owner: String, +} + +impl TransactionModeDirect { + pub fn new(from_prd_update_from: String, to_role_owner: String) -> Self { + TransactionModeDirect { + from_prd_update_from, + to_role_owner, + } + } + + // display_info method + pub fn display_info(&self) { + println!("TransactionModeDirect:"); + println!("From PRD Update From: {}", self.from_prd_update_from); + println!("To Role Owner: {}", self.to_role_owner); + } +} + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] +pub struct TransactionMode { + pub amount: Amount, + pub role_transaction_distribution: TransactionModeDistribution, + pub role_transaction_direct: TransactionModeDirect, +} + +impl TransactionMode { + pub fn new( + amount: Amount, + role_transaction_distribution: TransactionModeDistribution, + role_transaction_direct: TransactionModeDirect, + ) -> Self { + TransactionMode { + amount, + role_transaction_distribution, + role_transaction_direct, + } + } + + // display_info method + pub fn display_info(&self) { + println!("TransactionMode:"); + + println!("Amount:"); + self.amount.display_info(); // Assuming Amount has a display_info method + + println!("Role Transaction Distribution:"); + self.role_transaction_distribution.display_info(); // Assuming TransactionModeDistribution has a display_info method + + println!("Role Transaction Direct:"); + self.role_transaction_direct.display_info(); // Assuming TransactionModeDirect has a display_info method + } +} + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct Role { + pub item: Item, + pub required_2fa: bool, + pub validation_timeout: u64, + pub condition_prd_address_set_list: Vec, // Assuming ConditionPrdAddressSet is a predefined struct + pub condition_publish: ConditionPublish, // Assuming ConditionPublish is a predefined struct + pub condition_cap_list: Vec, // Assuming ConditionCap is a predefined struct + pub condition_payment_list: Vec, // Assuming ConditionPayment is a predefined struct + pub condition_commitment_list: Vec, // Assuming ConditionCommitment is a predefined struct + pub condition_attribute_encryption_list: Vec, + pub condition_orchestration: ConditionOrchestration, // Assuming ConditionOrchestration is a predefined struct + pub role_succession: Option, + pub role_resolve: Option, + pub role_renew: Option, +} + +impl Role { + pub fn new( + item: Item, + required_2fa: bool, + validation_timeout: u64, + condition_prd_address_set_list: Vec, + condition_publish: ConditionPublish, + condition_cap_list: Vec, + condition_payment_list: Vec, + condition_commitment_list: Vec, + condition_attribute_encryption_list: Vec, + condition_orchestration: ConditionOrchestration, + role_succession: Option, + role_resolve: Option, + role_renew: Option, + ) -> Self { + Role { + item, + required_2fa, + validation_timeout, + condition_prd_address_set_list, + condition_publish, + condition_cap_list, + condition_payment_list, + condition_commitment_list, + condition_attribute_encryption_list, + condition_orchestration, + role_succession, + role_resolve, + role_renew, + } + } + // display_info method + pub fn display_info(&self) { + println!("Role:"); + println!("Item: {:?}", self.item); // Assuming `Item` implements Debug trait + println!("Validation Timeout: {}", self.validation_timeout); + + println!("ConditionPrdAddressSet List:"); + for condition in &self.condition_prd_address_set_list { + condition.display_info(); // Assuming `ConditionPrdAddressSet` has a display_info method + } + + println!("ConditionPublish:"); + self.condition_publish.display_info(); // Assuming `ConditionPublish` has a display_info method + + println!("ConditionCap List:"); + for condition in &self.condition_cap_list { + condition.display_info(); // Assuming `ConditionCap` has a display_info method + } + + println!("ConditionPayment List:"); + for condition in &self.condition_payment_list { + condition.display_info(); // Assuming `ConditionPayment` has a display_info method + } + + println!("ConditionCommitment List:"); + for condition in &self.condition_commitment_list { + condition.display_info(); // Assuming `ConditionCommitment` has a display_info method + } + + println!("ConditionAttributeEncryption:"); + for condition in &self.condition_attribute_encryption_list { + println!("ConditionAttributeEncryption: {:?}", condition); + } + + println!("ConditionOrchestration:"); + self.condition_orchestration.display_info(); // Assuming `ConditionOrchestration` has a display_info method + + println!("Role Succession: {:?}", self.role_succession); + println!("Role Resolve: {:?}", self.role_resolve); + println!("Role Renew: {:?}", self.role_renew); + } + + // Additional methods for Role can be added here +} diff --git a/src/models/role_artefact.rs b/src/models/role_artefact.rs new file mode 100644 index 0000000..16fe541 --- /dev/null +++ b/src/models/role_artefact.rs @@ -0,0 +1,23 @@ +use rocket::FromForm; +use serde::{Deserialize, Serialize}; + +use super::role::Role; +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct RoleArtefact { + pub item_name: String, + pub role: Role, +} + +impl RoleArtefact { + pub fn new(item_name: String, role: Role) -> Self { + RoleArtefact { item_name, role } + } + + // Fonction pour afficher ou retourner les informations + pub fn display_info(&self) -> String { + format!("Item Name: {}, Role: {:?}", self.item_name, self.role) + } +} diff --git a/src/models/role_commitment.rs b/src/models/role_commitment.rs new file mode 100644 index 0000000..f3cfe90 --- /dev/null +++ b/src/models/role_commitment.rs @@ -0,0 +1,23 @@ +use rocket::FromForm; +use serde::{Deserialize, Serialize}; + +use super::role::Role; +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct RoleCommitment { + pub item_name: String, + pub role: Role, +} + +impl RoleCommitment { + pub fn new(item_name: String, role: Role) -> Self { + RoleCommitment { item_name, role } + } + + // Fonction pour afficher ou retourner les informations + pub fn display_info(&self) -> String { + format!("Item Name: {}, Role: {:?}", self.item_name, self.role) + } +} diff --git a/src/models/role_deposit.rs b/src/models/role_deposit.rs new file mode 100644 index 0000000..ef75fc4 --- /dev/null +++ b/src/models/role_deposit.rs @@ -0,0 +1,23 @@ +use rocket::FromForm; +use serde::{Deserialize, Serialize}; + +use super::role::Role; +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct RoleDeposit { + pub item_name: String, + pub role: Role, +} + +impl RoleDeposit { + pub fn new(item_name: String, role: Role) -> Self { + RoleDeposit { item_name, role } + } + + // Fonction pour afficher ou retourner les informations + pub fn display_info(&self) -> String { + format!("Item Name: {}, Role: {:?}", self.item_name, self.role) + } +} diff --git a/src/models/role_member.rs b/src/models/role_member.rs new file mode 100644 index 0000000..0081191 --- /dev/null +++ b/src/models/role_member.rs @@ -0,0 +1,21 @@ +use rocket::FromForm; +use serde::{Deserialize, Serialize}; + +use super::role::Role; +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct RoleMember { + pub item_name: String, + pub role: Role, +} + +impl RoleMember { + pub fn new(item_name: String, role: Role) -> Self { + RoleMember { item_name, role } + } + pub fn display_info(&self) -> String { + format!("Item Name: {}, Role: {:?}", self.item_name, self.role) + } +} diff --git a/src/models/role_payment.rs b/src/models/role_payment.rs new file mode 100644 index 0000000..f0465d6 --- /dev/null +++ b/src/models/role_payment.rs @@ -0,0 +1,23 @@ +use rocket::FromForm; +use serde::{Deserialize, Serialize}; + +use super::role::Role; +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct RolePayment { + pub item_name: String, + pub role: Role, +} + +impl RolePayment { + pub fn new(item_name: String, role: Role) -> Self { + RolePayment { item_name, role } + } + + // Fonction pour afficher ou retourner les informations + pub fn display_info(&self) -> String { + format!("Item Name: {}, Role: {:?}", self.item_name, self.role) + } +} diff --git a/src/models/role_peer.rs b/src/models/role_peer.rs new file mode 100644 index 0000000..c1876a7 --- /dev/null +++ b/src/models/role_peer.rs @@ -0,0 +1,23 @@ +use rocket::FromForm; +use serde::{Deserialize, Serialize}; + +use super::role::Role; +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct RolePeer { + pub item_name: String, + pub role: Role, +} + +impl RolePeer { + pub fn new(item_name: String, role: Role) -> Self { + RolePeer { item_name, role } + } + + // Fonction pour afficher ou retourner les informations + pub fn display_info(&self) -> String { + format!("Item Name: {}, Role: {:?}", self.item_name, self.role) + } +} diff --git a/src/models/role_process.rs b/src/models/role_process.rs new file mode 100644 index 0000000..d1e52db --- /dev/null +++ b/src/models/role_process.rs @@ -0,0 +1,21 @@ +use rocket::FromForm; +use serde::{Deserialize, Serialize}; + +use super::role::Role; +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct RoleProcess { + pub item_name: String, + pub role: Role, +} + +impl RoleProcess { + pub fn new(item_name: String, role: Role) -> Self { + RoleProcess { item_name, role } + } + pub fn display_info(&self) -> String { + format!("Item Name: {}, Role: {:?}", self.item_name, self.role) + } +} diff --git a/src/models/roles_group.rs b/src/models/roles_group.rs new file mode 100644 index 0000000..1662df5 --- /dev/null +++ b/src/models/roles_group.rs @@ -0,0 +1,132 @@ +use rocket::FromForm; +use serde::{Deserialize, Serialize}; + +use crate::workflows::workflow_pcd_create_and_send_all::PcdItemEncAttributeRoleConfidentialExportKey; + +use super::{ + commitment_method::CommitmentMethod, deposit_method::DepositMethod, + key_encryption::KeyEncryption, payment_method::PaymentMethod, + request_prd_response::RequestPrdResponse, role_artefact::RoleArtefact, role_member::RoleMember, + role_peer::RolePeer, role_process::RoleProcess, +}; + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct RolesGroup { + pub role_peer: RolePeer, + pub role_member: RoleMember, + pub role_process: RoleProcess, + pub role_artefact_list: Vec, +} + +impl RolesGroup { + pub fn new( + role_peer: RolePeer, + role_member: RoleMember, + role_process: RoleProcess, + role_artefact_list: Vec, + ) -> Self { + RolesGroup { + role_peer, + role_member, + role_process, + role_artefact_list, + } + } + pub fn filter_keys( + condition_attribute_encryption: &Vec, + pcd_keys_role_confidential_list: &mut Vec, + ) { + for key_item in pcd_keys_role_confidential_list.iter_mut() { + if !condition_attribute_encryption.contains(&key_item.attribute_name) { + key_item.key = None; + } + } + } + pub fn to_prd_response_list( + &self, + process_public_enc_key: KeyEncryption, + member_private_enc_key: KeyEncryption, + request_item_name: Option, + request_version: i64, + request_process_hash: String, + request_pcd_reference_hash: Option, + request_item_reference_hash: Option, + pcd_keys_role_confidential_list: Vec, + message_public_string: Option, + message_confidential_string: Option, + message_private_string: Option, + sp_address_from: String, + sp_address_reply: String, + timestamp_declared: u64, + role_name_from: String, + role_name_to: String, + sig_value: String, + pcd_origin_hash: Option, + + payment_method: Option, + deposit_method: Option, + commitment_method: Option, + certif_key: Option, + ) -> Vec { + let mut request_prd_response_list: Vec = Vec::new(); + + for cond in &self.role_peer.role.condition_prd_address_set_list { + let mut pcd_keys_role_confidential_list_tmp = pcd_keys_role_confidential_list.clone(); + + RolesGroup::filter_keys( + &self.role_peer.role.condition_attribute_encryption_list, + &mut pcd_keys_role_confidential_list_tmp, + ); + + for address in &cond.prd_sp_address_list { + let prd_response = RequestPrdResponse::new( + process_public_enc_key.clone(), + member_private_enc_key.clone(), + request_item_name.clone(), + request_version.clone(), + request_process_hash.clone(), + request_pcd_reference_hash.clone(), + request_item_reference_hash.clone(), + pcd_keys_role_confidential_list.clone(), + message_public_string.clone(), + message_confidential_string.clone(), + message_private_string.clone(), + address.to_string(), + sp_address_from.clone(), + sp_address_reply.clone(), + timestamp_declared.clone(), + role_name_from.clone(), + role_name_to.clone(), + sig_value.clone(), + pcd_origin_hash.clone(), + payment_method.clone(), + deposit_method.clone(), + commitment_method.clone(), + certif_key.clone(), + ); + request_prd_response_list.push(prd_response); + } + } + request_prd_response_list + } + pub fn display_info(&self) { + println!("RolesGroup:"); + println!("Role Peer:"); + self.role_peer.display_info(); // Affiche les informations de `role_peer` + + println!("Role Member:"); + self.role_member.display_info(); // Affiche les informations de `role_member` + + println!("Role Process:"); + self.role_process.display_info(); // Affiche les informations de `role_process` + + println!("Role Artefact List:"); + for (index, role_artefact) in self.role_artefact_list.iter().enumerate() { + println!("Artefact {}: ", index + 1); + role_artefact.display_info(); // Affiche les informations de chaque `role_artefact` + } + } +} diff --git a/src/models/shared_peer.rs b/src/models/shared_peer.rs new file mode 100644 index 0000000..50bc390 --- /dev/null +++ b/src/models/shared_peer.rs @@ -0,0 +1,226 @@ +use rocket::FromForm; +use serde::{Deserialize, Serialize}; + +use super::message_client::MessageClient; +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct Relay { + pub address_port: u16, + pub data_max_size: usize, + pub pow_difficulty: u32, + pub pow_pattern: String, + pub pow_prefix: String, +} + +impl Relay { + pub fn new( + address_port: u16, + data_max_size: usize, + pow_difficulty: u32, + pow_pattern: String, + pow_prefix: String, + ) -> Self { + Relay { + address_port, + data_max_size, + pow_difficulty, + pow_pattern, + pow_prefix, + } + } + // display_info method + pub fn display_info(&self) { + println!("Relay:"); + println!("Address Port: {}", self.address_port); + println!("Data Max Size: {}", self.data_max_size); + println!("PoW Difficulty: {}", self.pow_difficulty); + println!("PoW Pattern: {}", self.pow_pattern); + println!("PoW Prefix: {}", self.pow_prefix); + } +} + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct L1Node { + pub address_port: u16, + pub explorer_base_url: String, + pub sp_address_anchorage: String, + pub sp_address_reward: String, +} + +impl L1Node { + pub fn new( + address_port: u16, + explorer_base_url: String, + sp_address_anchorage: String, + sp_address_reward: String, + ) -> Self { + L1Node { + address_port, + explorer_base_url, + sp_address_anchorage, + sp_address_reward, + } + } // display_info method + pub fn display_info(&self) { + println!("L1Node:"); + println!("Address Port: {}", self.address_port); + println!("Explorer Base URL: {}", self.explorer_base_url); + println!("SP Address Anchorage: {}", self.sp_address_anchorage); + println!("SP Address Reward: {}", self.sp_address_reward); + } +} + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct L1Miner { + pub sp_address_rewarder: String, +} + +impl L1Miner { + pub fn new(sp_address_rewarder: String) -> Self { + L1Miner { + sp_address_rewarder, + } + } + + // display_info method + pub fn display_info(&self) { + println!("L1Miner:"); + println!("SP Address Rewarder: {}", self.sp_address_rewarder); + } +} + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct L2Node { + pub address_port: u16, + pub explorer_base_url: String, + pub sp_address_anchorage: String, + pub sp_address_reward: String, + pub nbits: u32, + pub magic_number: u32, + pub challenge: String, +} + +impl L2Node { + pub fn new( + address_port: u16, + explorer_base_url: String, + sp_address_anchorage: String, + sp_address_reward: String, + nbits: u32, + magic_number: u32, + challenge: String, + ) -> Self { + L2Node { + address_port, + explorer_base_url, + sp_address_anchorage, + sp_address_reward, + nbits, + magic_number, + challenge, + } + } + + // display_info method + pub fn display_info(&self) { + println!("L2Node:"); + println!("Address Port: {}", self.address_port); + println!("Explorer Base URL: {}", self.explorer_base_url); + println!("SP Address Anchorage: {}", self.sp_address_anchorage); + println!("SP Address Reward: {}", self.sp_address_reward); + println!("Nbits: {}", self.nbits); + println!("Magic Number: {}", self.magic_number); + println!("Challenge: {}", self.challenge); + } +} + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct L2Certif { + pub sp_address_certif: String, +} + +impl L2Certif { + pub fn new(sp_address_certif: String) -> Self { + L2Certif { sp_address_certif } + } + // display_info method + pub fn display_info(&self) { + println!("L2Certif:"); + println!("SP Address Certif: {}", self.sp_address_certif); + } +} + +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct SharedPeer { + pub domain: String, + pub address_ip: String, + pub relay: Relay, + pub l1_node: L1Node, + pub l1_miner: L1Miner, + pub l2_node: L2Node, + pub l2_certif: L2Certif, +} + +impl SharedPeer { + pub fn new( + domain: String, + address_ip: String, + relay: Relay, + l1_node: L1Node, + l1_miner: L1Miner, + l2_node: L2Node, + l2_certif: L2Certif, + ) -> Self { + SharedPeer { + domain, + address_ip, + relay, + l1_node, + l1_miner, + l2_node, + l2_certif, + } + } + pub fn send_message_client(&self, _message_client: MessageClient) { + // TODO + } + + // display_info method + pub fn display_info(&self) { + println!("SharedPeer:"); + println!("Domain: {}", self.domain); + println!("IP Address: {}", self.address_ip); + + println!("Relay:"); + self.relay.display_info(); // Assuming Relay has a display_info method + + println!("L1 Node:"); + self.l1_node.display_info(); // Assuming L1Node has a display_info method + + println!("L1 Miner:"); + self.l1_miner.display_info(); // Assuming L1Miner has a display_info method + + println!("L2 Node:"); + self.l2_node.display_info(); // Assuming L2Node has a display_info method + + println!("L2 Certif:"); + self.l2_certif.display_info(); // Assuming L2Certif has a display_info method + } +} diff --git a/src/models/shared_process.rs b/src/models/shared_process.rs new file mode 100644 index 0000000..13f2567 --- /dev/null +++ b/src/models/shared_process.rs @@ -0,0 +1,38 @@ +use rocket::FromForm; +use serde::{Deserialize, Serialize}; + +use super::key_encryption::KeyEncryption; +#[derive( + Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm, +)] + +pub struct SharedProcess { + pub hash: String, + pub key: KeyEncryption, + pub role_process_sp_address_list: Vec, +} + +impl SharedProcess { + pub fn new( + hash: String, + key: KeyEncryption, + role_process_sp_address_list: Vec, + ) -> Self { + SharedProcess { + hash, + key, + role_process_sp_address_list, + } + } + // display_info method + pub fn display_info(&self) { + println!("SharedProcess:"); + println!("Hash: {}", self.hash); + println!("Key Encryption:"); + self.key.display_info(); // Assuming KeyEncryption has a display_info method + println!( + "Role Process SP Address List: {:?}", + self.role_process_sp_address_list + ); + } +} diff --git a/src/wallet.rs b/src/wallet.rs new file mode 100644 index 0000000..4d0d106 --- /dev/null +++ b/src/wallet.rs @@ -0,0 +1,27 @@ +// use rand::{rngs::ThreadRng, thread_rng}; +// use silentpayments::secp256k1::{self, Secp256k1, SecretKey}; + +// use sp_backend::SpClient; +/* +pub struct Wallet { + pub client: SpClient, + pub secp: Secp256k1, + pub seckey_spend: SecretKey, + pub seckey_scan: SecretKey, +} + +impl Wallet { + pub fn new() -> Wallet { + let secp: Secp256k1 = Secp256k1::new(); + let mut rng: ThreadRng = thread_rng(); + let seckey_spend: SecretKey = SecretKey::new(rng); + let seckey_scan: SecretKey = SecretKey::new(rng); + Wallet { + client: SpClient::new(), + secp, + seckey_spend, + seckey_scan, + } + } +} +*/ diff --git a/src/workflows/lib.rs b/src/workflows/lib.rs new file mode 100644 index 0000000..e69de29 diff --git a/src/workflows/mod.rs b/src/workflows/mod.rs new file mode 100644 index 0000000..60d256c --- /dev/null +++ b/src/workflows/mod.rs @@ -0,0 +1 @@ +pub mod workflow_pcd_create_and_send_all; diff --git a/src/workflows/workflow_pcd_create_and_send_all.rs b/src/workflows/workflow_pcd_create_and_send_all.rs new file mode 100644 index 0000000..8518153 --- /dev/null +++ b/src/workflows/workflow_pcd_create_and_send_all.rs @@ -0,0 +1,254 @@ +use crate::models::{ + commitment_method::CommitmentMethod, deposit_method::DepositMethod, item_enum::ItemEnum, + message_client::MessageClient, payment_method::PaymentMethod, roles_group::RolesGroup, +}; + +use rocket::FromForm; +use serde::{Deserialize, Serialize}; +use std::hash::Hash; + +use crate::models::{ + key_encryption::KeyEncryption, pagination::Pagination, request_pcd::RequestPcd, + shared_peer::SharedPeer, shared_process::SharedProcess, +}; + +#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm)] +pub struct ProcessRoleSpAddressGroup { + pub sp_address_list: Vec, + pub role_name: String, +} +impl ProcessRoleSpAddressGroup { + pub fn new(sp_address_list: Vec, role_name: String) -> Self { + ProcessRoleSpAddressGroup { + sp_address_list, + role_name, + } + } + pub fn display_info(&self) { + println!("ProcessRoleSpAddressGroup:"); + println!("SP Address List: {:?}", self.sp_address_list); + println!("Role Name: {}", self.role_name); + } +} + +#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, FromForm)] + +pub struct PcdItemEncAttributeRoleConfidentialExportKey { + pub attribute_name: String, + pub key: Option, + pub item_index: usize, +} + +pub struct WorkflowPcdCreateAndSendAll { + pub item_name: String, + pub item_list: Vec, + pub pcd_pagination: Pagination, + pub pcd_version: i64, + pub process_hash: String, + pub pcd_reference_hash: Option, + pub pcd_item_reference_hash: Option, + pub member_private_enc_key: KeyEncryption, + pub process_public_enc_key: KeyEncryption, + pub roles: RolesGroup, + pub pow_pathern: String, + pub pow_difficulty: usize, + pub message_shared_peer_list: Vec, + pub message_shared_process_list: Vec, + pub message_faucet_sp_address: String, + + pub message_public_string: Option, + pub message_confidential_string: Option, + pub message_private_string: Option, + pub sp_address_from: String, + pub sp_address_reply: String, + pub timestamp_declared: u64, + pub role_name_from: String, + pub role_name_to: String, + pub sig_value: String, + pub pcd_origin_hash: Option, + + pub payment_method: Option, + pub deposit_method: Option, + pub commitment_method: Option, + pub certif_key: Option, +} + +impl WorkflowPcdCreateAndSendAll { + pub fn new( + item_name: String, + item_list: Vec, + pcd_pagination: Pagination, + pcd_version: i64, + process_hash: String, + pcd_reference_hash: Option, + pcd_item_reference_hash: Option, + member_private_enc_key: KeyEncryption, + process_public_enc_key: KeyEncryption, + roles: RolesGroup, + pow_pathern: String, + pow_difficulty: usize, + message_shared_peer_list: Vec, + message_shared_process_list: Vec, + message_faucet_sp_address: String, + message_public_string: Option, + message_confidential_string: Option, + message_private_string: Option, + sp_address_from: String, + sp_address_reply: String, + timestamp_declared: u64, + role_name_from: String, + role_name_to: String, + sig_value: String, + pcd_origin_hash: Option, + + payment_method: Option, + deposit_method: Option, + commitment_method: Option, + certif_key: Option, + ) -> Self { + WorkflowPcdCreateAndSendAll { + item_name, + item_list, + pcd_pagination, + pcd_version, + process_hash, + pcd_reference_hash, + pcd_item_reference_hash, + member_private_enc_key, + process_public_enc_key, + roles, + pow_pathern, + pow_difficulty, + message_shared_peer_list, + message_shared_process_list, + message_faucet_sp_address, + + message_public_string, + message_confidential_string, + message_private_string, + sp_address_from, + sp_address_reply, + timestamp_declared, + role_name_from, + role_name_to, + sig_value, + pcd_origin_hash, + payment_method, + deposit_method, + commitment_method, + certif_key, + } + } + pub fn run(&self) { + // walk item list and encrypt attributes + + // create pcd + let pcd: RequestPcd = RequestPcd::new( + Some(self.item_name.clone()), + self.pcd_version, + self.process_hash.clone(), + self.pcd_reference_hash.clone(), + self.pcd_item_reference_hash.clone(), + self.item_list.clone(), + self.pcd_pagination.clone(), + self.process_public_enc_key.clone(), + self.member_private_enc_key.clone(), + ); + + let pcd_message: MessageClient = pcd.to_message( + self.process_public_enc_key.clone(), + self.message_shared_peer_list.clone(), + self.message_shared_process_list.clone(), + self.message_faucet_sp_address.clone(), + self.pow_pathern.clone(), + self.pow_difficulty, + ); + + let mut pcd_keys_role_confidential_list: Vec = + Vec::new(); + + let mut item_index = 0; + for item in &pcd.item_list { + for enc_attribute_list in &item.pcd_item_enc_attribute_role_confidential_list { + for enc_attribute in enc_attribute_list { + let exp = PcdItemEncAttributeRoleConfidentialExportKey { + attribute_name: enc_attribute.attribute_name.clone(), + key: Some(enc_attribute.key.clone()), + item_index, + }; + pcd_keys_role_confidential_list.push(exp); + } + } + item_index += 1; + } + + let prd_list = self.roles.to_prd_response_list( + self.process_public_enc_key.clone(), + self.member_private_enc_key.clone(), + Some(self.item_name.clone()), + 0, + self.process_hash.clone(), + self.pcd_reference_hash.clone(), + self.pcd_item_reference_hash.clone(), + pcd_keys_role_confidential_list.clone(), + self.message_public_string.clone(), + self.message_confidential_string.clone(), + self.message_private_string.clone(), + self.sp_address_from.clone(), + self.sp_address_reply.clone(), + self.timestamp_declared.clone(), + self.role_name_from.clone(), + self.role_name_to.clone(), + self.sig_value.clone(), + Some(pcd_message.request_hash), + self.payment_method.clone(), + self.deposit_method.clone(), + self.commitment_method.clone(), + self.certif_key.clone(), + ); + + for prd in prd_list { + let _prd_message_list = prd.to_message( + self.process_public_enc_key.clone(), + self.message_shared_peer_list.clone(), + self.message_shared_process_list.clone(), + self.message_faucet_sp_address.clone(), + self.pow_pathern.clone(), + self.pow_difficulty, + ); + } + // todo + // send + } + pub fn display_info(&self) { + println!("PcdCreateAndSend:"); + println!("Item Name: {}", self.item_name); + println!("Item List: {:?}", self.item_list); + println!("Pagination: {:?}", self.pcd_pagination); + println!("Version: {}", self.pcd_version); + println!("Process Hash: {}", self.process_hash); + println!("Reference Hash: {:?}", self.pcd_reference_hash); + println!("Item Reference Hash: {:?}", self.pcd_item_reference_hash); + println!( + "Member Private Encryption Key: {:?}", + self.member_private_enc_key + ); + println!( + "Process Public Encryption Key: {:?}", + self.process_public_enc_key + ); + println!("Process roles: {:?}", self.roles); + println!( + "Message Shared Peer List: {:?}", + self.message_shared_peer_list + ); + println!( + "Message Shared Process List: {:?}", + self.message_shared_process_list + ); + println!( + "Message Faucet SP Address: {:?}", + self.message_faucet_sp_address + ); + } +}