sentc-crypto-utils 0.15.0

Common types and functions for sentc sdk and sdk light
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

#[cfg(feature = "encryption")]
mod crypto;
mod macros;

use alloc::string::String;
use core::str::FromStr;

#[cfg(feature = "encryption")]
pub use crypto::*;
use sentc_crypto_core::cryptomat::{
	Pk,
	SignK,
	SignKeyComposer,
	SignKeyPair,
	Sk,
	SkComposer,
	StaticKeyPair,
	SymKey,
	SymKeyComposer,
	SymKeyGen,
	VerifyK,
};

use crate::error::SdkUtilError;

macro_rules! wrapper_trait {
	($name:ident, $inner:ident) => {
		pub trait $name: FromStr + KeyToString
		{
			type Inner: $inner;

			fn get_id(&self) -> &str;

			fn get_key(&self) -> &Self::Inner;
		}
	};
	($name:ident, $inner:ident, $crypto:ident) => {
		pub trait $name: FromStr + KeyToString + $crypto
		{
			type Inner: $inner;

			fn get_id(&self) -> &str;

			fn get_key(&self) -> &Self::Inner;
		}
	};
}

pub trait KeyToString
{
	fn to_string(self) -> Result<String, SdkUtilError>;

	fn to_string_ref(&self) -> Result<String, SdkUtilError>;
}

//__________________________________________________________________________________________________
//symmetric

#[cfg(not(feature = "encryption"))]
wrapper_trait!(SymKeyWrapper, SymKey);

#[cfg(feature = "encryption")]
wrapper_trait!(SymKeyWrapper, SymKey, SymKeyCrypto);

pub trait SymKeyGenWrapper
{
	type SymmetricKeyWrapper: SymKeyWrapper;
	type KeyGen: SymKeyGen;

	fn from_inner(inner: <<Self as SymKeyGenWrapper>::KeyGen as SymKeyGen>::SymmetricKey, id: String) -> Self::SymmetricKeyWrapper;
}

pub trait SymKeyComposerWrapper
{
	type SymmetricKeyWrapper: SymKeyWrapper;
	type Composer: SymKeyComposer;

	fn from_inner(inner: <<Self as SymKeyComposerWrapper>::Composer as SymKeyComposer>::SymmetricKey, id: String) -> Self::SymmetricKeyWrapper;
}

//__________________________________________________________________________________________________
//asymmetric

#[cfg(not(feature = "encryption"))]
wrapper_trait!(SkWrapper, Sk);

#[cfg(feature = "encryption")]
wrapper_trait!(SkWrapper, Sk, SkCryptoWrapper);

wrapper_trait!(PkWrapper, Pk, Clone);

pub trait StaticKeyPairWrapper
{
	// type SkWrapper: SkWrapper;
	type PkWrapper: PkWrapper;
	type KeyGen: StaticKeyPair;

	// fn sk_from_inner(inner: <<Self as StaticKeyPairWrapper>::KeyGen as StaticKeyPair>::SecretKey, id: String) -> Self::SkWrapper;

	fn pk_from_inner(inner: <<Self as StaticKeyPairWrapper>::KeyGen as StaticKeyPair>::PublicKey, id: String) -> Self::PkWrapper;

	fn pk_inner_to_pem(inner: &<<Self as StaticKeyPairWrapper>::KeyGen as StaticKeyPair>::PublicKey) -> Result<String, SdkUtilError>;
}

pub trait StaticKeyComposerWrapper
{
	type SkWrapper: SkWrapper;
	type PkWrapper: PkWrapper;
	type InnerPk: Pk;
	type Composer: SkComposer;

	fn sk_from_inner(inner: <<Self as StaticKeyComposerWrapper>::Composer as SkComposer>::SecretKey, id: String) -> Self::SkWrapper;

	fn pk_from_pem(public_key: &str, alg: &str, id: String) -> Result<Self::PkWrapper, SdkUtilError>;

	fn pk_inner_from_pem(public_key: &str, alg: &str) -> Result<Self::InnerPk, SdkUtilError>;
}

//__________________________________________________________________________________________________
//sign

#[cfg(not(feature = "encryption"))]
wrapper_trait!(SignKWrapper, SignK);

#[cfg(feature = "encryption")]
wrapper_trait!(SignKWrapper, SignK, SignKCryptoWrapper);

wrapper_trait!(VerifyKWrapper, VerifyK);

pub trait SignKeyPairWrapper
{
	type KeyGen: SignKeyPair;

	fn vk_inner_to_pem(inner: &<<Self as SignKeyPairWrapper>::KeyGen as SignKeyPair>::VerifyKey) -> Result<String, SdkUtilError>;

	fn sig_to_string(sig: <<<Self as SignKeyPairWrapper>::KeyGen as SignKeyPair>::SignKey as SignK>::Signature) -> String;
}

pub trait SignComposerWrapper
{
	type SignKWrapper: SignKWrapper;
	type VerifyKWrapper: VerifyKWrapper;
	type InnerVk: VerifyK;
	type Composer: SignKeyComposer;

	fn sk_from_inner(inner: <<Self as SignComposerWrapper>::Composer as SignKeyComposer>::Key, id: String) -> Self::SignKWrapper;

	fn vk_from_pem(public_key: &str, alg: &str, id: String) -> Result<Self::VerifyKWrapper, SdkUtilError>;

	fn vk_inner_from_pem(public_key: &str, alg: &str) -> Result<Self::InnerVk, SdkUtilError>;

	fn sig_to_string(sig: <<<Self as SignComposerWrapper>::SignKWrapper as SignKWrapper>::Inner as SignK>::Signature) -> String;

	fn sig_from_string(sig: &str, alg: &str) -> Result<<<Self as SignComposerWrapper>::InnerVk as VerifyK>::Signature, SdkUtilError>;
}