subsoil 0.2.0

Soil primitives foundation crate
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
156
157
158
159
160

// This file is part of Soil.

// Copyright (C) Soil contributors.
// Copyright (C) Parity Technologies (UK) Ltd.
// SPDX-License-Identifier: Apache-2.0 OR GPL-3.0-or-later WITH Classpath-exception-2.0

//! ECDSA and BLS12-381 paired crypto applications.

use super::{KeyTypeId, RuntimePublic};
use alloc::vec::Vec;

pub use crate::core::paired_crypto::ecdsa_bls381::*;
use crate::core::{
	bls381,
	crypto::CryptoType,
	ecdsa, ecdsa_bls381,
	proof_of_possession::{NonAggregatable, ProofOfPossessionVerifier},
};

mod app {
	crate::app_crypto!(super, crate::core::testing::ECDSA_BLS381);
}

#[cfg(feature = "full_crypto")]
pub use app::Pair as AppPair;
pub use app::{
	ProofOfPossession as AppProofOfPossession, Public as AppPublic, Signature as AppSignature,
};

impl RuntimePublic for Public {
	type Signature = Signature;
	type ProofOfPossession = ecdsa_bls381::ProofOfPossession;

	/// Dummy implementation. Returns an empty vector.
	fn all(_key_type: KeyTypeId) -> Vec<Self> {
		Vec::new()
	}

	fn generate_pair(key_type: KeyTypeId, seed: Option<Vec<u8>>) -> Self {
		crate::io::crypto::ecdsa_bls381_generate(key_type, seed)
	}

	/// Dummy implementation. Returns `None`.
	fn sign<M: AsRef<[u8]>>(&self, _key_type: KeyTypeId, _msg: &M) -> Option<Self::Signature> {
		None
	}

	/// Dummy implementation. Returns `false`.
	fn verify<M: AsRef<[u8]>>(&self, _msg: &M, _signature: &Self::Signature) -> bool {
		false
	}

	fn generate_proof_of_possession(
		&mut self,
		key_type: KeyTypeId,
		owner: &[u8],
	) -> Option<Self::ProofOfPossession> {
		let pub_key_as_bytes = self.to_raw_vec();
		let (ecdsa_pub_as_bytes, bls381_pub_as_bytes) = split_pub_key_bytes(&pub_key_as_bytes)?;
		let ecdsa_proof_of_possession =
			generate_ecdsa_proof_of_possession(key_type, ecdsa_pub_as_bytes, owner)?;
		let bls381_proof_of_possession =
			generate_bls381_proof_of_possession(key_type, bls381_pub_as_bytes, owner)?;
		let combined_proof_of_possession_raw =
			combine_proof_of_possession(&ecdsa_proof_of_possession, &bls381_proof_of_possession)?;
		Some(Self::ProofOfPossession::from_raw(combined_proof_of_possession_raw))
	}

	fn verify_proof_of_possession(
		&self,
		owner: &[u8],
		proof_of_possession: &Self::ProofOfPossession,
	) -> bool {
		let pub_key = AppPublic::from(*self);
		<AppPublic as CryptoType>::Pair::verify_proof_of_possession(
			owner,
			&proof_of_possession,
			&pub_key,
		)
	}

	fn to_raw_vec(&self) -> Vec<u8> {
		crate::core::crypto::ByteArray::to_raw_vec(self)
	}
}

/// Helper: Split public key bytes into ECDSA and BLS381 parts
fn split_pub_key_bytes(
	pub_key_as_bytes: &[u8],
) -> Option<([u8; ecdsa::PUBLIC_KEY_SERIALIZED_SIZE], [u8; bls381::PUBLIC_KEY_SERIALIZED_SIZE])> {
	let ecdsa_pub_as_bytes =
		pub_key_as_bytes[..ecdsa::PUBLIC_KEY_SERIALIZED_SIZE].try_into().ok()?;
	let bls381_pub_as_bytes =
		pub_key_as_bytes[ecdsa::PUBLIC_KEY_SERIALIZED_SIZE..].try_into().ok()?;
	Some((ecdsa_pub_as_bytes, bls381_pub_as_bytes))
}

/// Helper: Generate ECDSA proof of possession
fn generate_ecdsa_proof_of_possession(
	key_type: KeyTypeId,
	ecdsa_pub_as_bytes: [u8; ecdsa::PUBLIC_KEY_SERIALIZED_SIZE],
	owner: &[u8],
) -> Option<ecdsa::Signature> {
	let ecdsa_pub = ecdsa::Public::from_raw(ecdsa_pub_as_bytes);
	let proof_of_possession_statement = ecdsa::Pair::proof_of_possession_statement(owner);
	crate::io::crypto::ecdsa_sign(key_type, &ecdsa_pub, &proof_of_possession_statement)
}

/// Helper: Generate BLS381 proof of possession
fn generate_bls381_proof_of_possession(
	key_type: KeyTypeId,
	bls381_pub_as_bytes: [u8; bls381::PUBLIC_KEY_SERIALIZED_SIZE],
	owner: &[u8],
) -> Option<bls381::ProofOfPossession> {
	let bls381_pub = bls381::Public::from_raw(bls381_pub_as_bytes);
	crate::io::crypto::bls381_generate_proof_of_possession(key_type, &bls381_pub, owner)
}

/// Helper: Combine ECDSA and BLS381 proof_of_possessions into a single raw proof_of_possession
fn combine_proof_of_possession(
	ecdsa_proof_of_possession: &ecdsa::Signature,
	bls381_proof_of_possession: &bls381::ProofOfPossession,
) -> Option<[u8; ecdsa_bls381::POP_LEN]> {
	let mut combined_proof_of_possession_raw = [0u8; ecdsa_bls381::POP_LEN];
	combined_proof_of_possession_raw[..ecdsa::SIGNATURE_SERIALIZED_SIZE]
		.copy_from_slice(ecdsa_proof_of_possession.as_ref());
	combined_proof_of_possession_raw[ecdsa::SIGNATURE_SERIALIZED_SIZE..]
		.copy_from_slice(bls381_proof_of_possession.as_ref());
	Some(combined_proof_of_possession_raw)
}

#[cfg(test)]
mod tests {
	use super::*;
	use crate::core::{bls381, crypto::Pair, ecdsa};

	/// Helper function to generate test public keys for ECDSA and BLS381
	fn generate_test_keys(
	) -> ([u8; ecdsa::PUBLIC_KEY_SERIALIZED_SIZE], [u8; bls381::PUBLIC_KEY_SERIALIZED_SIZE]) {
		let ecdsa_pair = ecdsa::Pair::generate().0;
		let bls381_pair = bls381::Pair::generate().0;

		let ecdsa_pub = ecdsa_pair.public();
		let bls381_pub = bls381_pair.public();

		(ecdsa_pub.to_raw_vec().try_into().unwrap(), bls381_pub.to_raw_vec().try_into().unwrap())
	}

	#[test]
	fn test_split_pub_key_bytes() {
		let (ecdsa_pub, bls381_pub) = generate_test_keys();
		let mut combined_pub_key = Vec::new();
		combined_pub_key.extend_from_slice(&ecdsa_pub);
		combined_pub_key.extend_from_slice(&bls381_pub);

		let result = split_pub_key_bytes(&combined_pub_key).unwrap();
		assert_eq!(result.0, ecdsa_pub, "ECDSA public key does not match");
		assert_eq!(result.1, bls381_pub, "BLS381 public key does not match");
	}
}