mirror of
https://github.com/pezkuwichain/pezkuwi-subxt.git
synced 2026-04-26 11:07:56 +00:00
Move cryptographic hashing procedures to crypto folder. (#2306)
Step towards https://github.com/paritytech/polkadot-sdk/issues/1975 As reported https://github.com/paritytech/polkadot-sdk/issues/1975#issuecomment-1774534225 I'd like to encapsulate crypto related stuff in a dedicated folder. Currently all cryptographic primitive wrappers are all sparsed in `substrate/core` which contains "misc core" stuff. To simplify the process, as the first step with this PR I propose to move the cryptographic hashing there. The `substrate/crypto` folder was already created to contains `ec-utils` crate. Notes: - rename `sp-core-hashing` to `sp-crypto-hashing` - rename `sp-core-hashing-proc-macro` to `sp-crypto-hashing-proc-macro` - As the crates name is changed I took the freedom to restart fresh from version 0.1.0 for both crates --------- Co-authored-by: Robert Hambrock <roberthambrock@gmail.com>
This commit is contained in:
Davide Galassi
@@ -0,0 +1,124 @@
|
||||
// This file is part of Substrate.
|
||||
|
||||
// Copyright (C) Parity Technologies (UK) Ltd.
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
use quote::quote;
|
||||
use syn::parse::{Parse, ParseStream};
|
||||
|
||||
use proc_macro::TokenStream;
|
||||
|
||||
pub(super) struct InputBytes(pub Vec<u8>);
|
||||
|
||||
pub(super) struct MultipleInputBytes(pub Vec<Vec<u8>>);
|
||||
|
||||
impl MultipleInputBytes {
|
||||
pub(super) fn concatenated(mut self) -> Vec<u8> {
|
||||
if self.0.is_empty() {
|
||||
Vec::new()
|
||||
} else {
|
||||
let mut result = core::mem::take(&mut self.0[0]);
|
||||
for other in self.0[1..].iter_mut() {
|
||||
result.append(other);
|
||||
}
|
||||
result
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Parse for InputBytes {
|
||||
fn parse(input: ParseStream) -> syn::Result<Self> {
|
||||
match syn::ExprArray::parse(input) {
|
||||
Ok(array) => {
|
||||
let mut bytes = Vec::<u8>::new();
|
||||
for expr in array.elems.iter() {
|
||||
match expr {
|
||||
syn::Expr::Lit(lit) => match &lit.lit {
|
||||
syn::Lit::Int(b) => bytes.push(b.base10_parse()?),
|
||||
syn::Lit::Byte(b) => bytes.push(b.value()),
|
||||
_ =>
|
||||
return Err(syn::Error::new(
|
||||
input.span(),
|
||||
"Expected array of u8 elements.".to_string(),
|
||||
)),
|
||||
},
|
||||
_ =>
|
||||
return Err(syn::Error::new(
|
||||
input.span(),
|
||||
"Expected array of u8 elements.".to_string(),
|
||||
)),
|
||||
}
|
||||
}
|
||||
return Ok(InputBytes(bytes))
|
||||
},
|
||||
Err(_e) => (),
|
||||
}
|
||||
// use rust names as a vec of their utf8 bytecode.
|
||||
match syn::Ident::parse(input) {
|
||||
Ok(ident) => return Ok(InputBytes(ident.to_string().as_bytes().to_vec())),
|
||||
Err(_e) => (),
|
||||
}
|
||||
Ok(InputBytes(syn::LitByteStr::parse(input)?.value()))
|
||||
}
|
||||
}
|
||||
|
||||
impl Parse for MultipleInputBytes {
|
||||
fn parse(input: ParseStream) -> syn::Result<Self> {
|
||||
let elts =
|
||||
syn::punctuated::Punctuated::<InputBytes, syn::token::Comma>::parse_terminated(input)?;
|
||||
Ok(MultipleInputBytes(elts.into_iter().map(|elt| elt.0).collect()))
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn twox_64(bytes: Vec<u8>) -> TokenStream {
|
||||
bytes_to_array(sp_crypto_hashing::twox_64(bytes.as_slice()))
|
||||
}
|
||||
|
||||
pub(super) fn twox_128(bytes: Vec<u8>) -> TokenStream {
|
||||
bytes_to_array(sp_crypto_hashing::twox_128(bytes.as_slice()))
|
||||
}
|
||||
|
||||
pub(super) fn blake2b_512(bytes: Vec<u8>) -> TokenStream {
|
||||
bytes_to_array(sp_crypto_hashing::blake2_512(bytes.as_slice()))
|
||||
}
|
||||
|
||||
pub(super) fn blake2b_256(bytes: Vec<u8>) -> TokenStream {
|
||||
bytes_to_array(sp_crypto_hashing::blake2_256(bytes.as_slice()))
|
||||
}
|
||||
|
||||
pub(super) fn blake2b_64(bytes: Vec<u8>) -> TokenStream {
|
||||
bytes_to_array(sp_crypto_hashing::blake2_64(bytes.as_slice()))
|
||||
}
|
||||
|
||||
pub(super) fn keccak_256(bytes: Vec<u8>) -> TokenStream {
|
||||
bytes_to_array(sp_crypto_hashing::keccak_256(bytes.as_slice()))
|
||||
}
|
||||
|
||||
pub(super) fn keccak_512(bytes: Vec<u8>) -> TokenStream {
|
||||
bytes_to_array(sp_crypto_hashing::keccak_512(bytes.as_slice()))
|
||||
}
|
||||
|
||||
pub(super) fn sha2_256(bytes: Vec<u8>) -> TokenStream {
|
||||
bytes_to_array(sp_crypto_hashing::sha2_256(bytes.as_slice()))
|
||||
}
|
||||
|
||||
fn bytes_to_array(bytes: impl IntoIterator<Item = u8>) -> TokenStream {
|
||||
let bytes = bytes.into_iter();
|
||||
|
||||
quote!(
|
||||
[ #( #bytes ),* ]
|
||||
)
|
||||
.into()
|
||||
}
|
||||
@@ -0,0 +1,129 @@
|
||||
// This file is part of Substrate.
|
||||
|
||||
// Copyright (C) Parity Technologies (UK) Ltd.
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//! Macros to calculate constant hash bytes result.
|
||||
//!
|
||||
//! Macros from this crate does apply a specific hash function on input.
|
||||
//! Input can be literal byte array as `b"content"` or array of bytes
|
||||
//! as `[1, 2, 3]`.
|
||||
//! Rust identifier can also be use, in this case we use their utf8 string
|
||||
//! byte representation, for instance if the ident is `MyStruct`, then
|
||||
//! `b"MyStruct"` will be hashed.
|
||||
//! If multiple arguments comma separated are passed, they are concatenated
|
||||
//! then hashed.
|
||||
//!
|
||||
//! Examples:
|
||||
//!
|
||||
//! ```rust
|
||||
//! assert_eq!(
|
||||
//! sp_crypto_hashing_proc_macro::blake2b_256!(b"test"),
|
||||
//! sp_crypto_hashing::blake2_256(b"test"),
|
||||
//! );
|
||||
//! assert_eq!(
|
||||
//! sp_crypto_hashing_proc_macro::blake2b_256!([1u8]),
|
||||
//! sp_crypto_hashing::blake2_256(&[1u8]),
|
||||
//! );
|
||||
//! assert_eq!(
|
||||
//! sp_crypto_hashing_proc_macro::blake2b_256!([1, 2, 3]),
|
||||
//! sp_crypto_hashing::blake2_256(&[1, 2, 3]),
|
||||
//! );
|
||||
//! assert_eq!(
|
||||
//! sp_crypto_hashing_proc_macro::blake2b_256!(identifier),
|
||||
//! sp_crypto_hashing::blake2_256(b"identifier"),
|
||||
//! );
|
||||
//! assert_eq!(
|
||||
//! sp_crypto_hashing_proc_macro::blake2b_256!(identifier, b"/string"),
|
||||
//! sp_crypto_hashing::blake2_256(b"identifier/string"),
|
||||
//! );
|
||||
//! ```
|
||||
|
||||
mod impls;
|
||||
|
||||
use impls::MultipleInputBytes;
|
||||
use proc_macro::TokenStream;
|
||||
|
||||
/// Process a Blake2 64-bit hash of bytes parameter outputs a `[u8; 8]`.
|
||||
/// Multiple inputs are concatenated before hashing.
|
||||
/// Input can be identifier (name of identifier as bytes is used), byte string or
|
||||
/// array of bytes.
|
||||
#[proc_macro]
|
||||
pub fn blake2b_64(input: TokenStream) -> TokenStream {
|
||||
impls::blake2b_64(syn::parse_macro_input!(input as MultipleInputBytes).concatenated())
|
||||
}
|
||||
|
||||
/// Apply a Blake2 256-bit hash of bytes parameter, outputs a `[u8; 32]`.
|
||||
/// Multiple inputs are concatenated before hashing.
|
||||
/// Input can be identifier (name of identifier as bytes is used), byte string or
|
||||
/// array of bytes.
|
||||
#[proc_macro]
|
||||
pub fn blake2b_256(input: TokenStream) -> TokenStream {
|
||||
impls::blake2b_256(syn::parse_macro_input!(input as MultipleInputBytes).concatenated())
|
||||
}
|
||||
|
||||
/// Apply a Blake2 512-bit hash of bytes parameter, outputs a `[u8; 64]`.
|
||||
/// Multiple inputs are concatenated before hashing.
|
||||
/// Input can be identifier (name of identifier as bytes is used), byte string or
|
||||
/// array of bytes.
|
||||
#[proc_macro]
|
||||
pub fn blake2b_512(input: TokenStream) -> TokenStream {
|
||||
impls::blake2b_512(syn::parse_macro_input!(input as MultipleInputBytes).concatenated())
|
||||
}
|
||||
|
||||
/// Apply a XX 64-bit hash on its bytes parameter, outputs a `[u8; 8]`.
|
||||
/// Multiple inputs are concatenated before hashing.
|
||||
/// Input can be identifier (name of identifier as bytes is used), byte string or
|
||||
/// array of bytes.
|
||||
#[proc_macro]
|
||||
pub fn twox_64(input: TokenStream) -> TokenStream {
|
||||
impls::twox_64(syn::parse_macro_input!(input as MultipleInputBytes).concatenated())
|
||||
}
|
||||
|
||||
/// Apply a XX 128-bit hash on its bytes parameter, outputs a `[u8; 16]`.
|
||||
/// Multiple inputs are concatenated before hashing.
|
||||
/// Input can be identifier (name of identifier as bytes is used), byte string or
|
||||
/// array of bytes.
|
||||
#[proc_macro]
|
||||
pub fn twox_128(input: TokenStream) -> TokenStream {
|
||||
impls::twox_128(syn::parse_macro_input!(input as MultipleInputBytes).concatenated())
|
||||
}
|
||||
|
||||
/// Apply a keccak 256-bit hash on its bytes parameter, outputs a `[u8; 32]`.
|
||||
/// Multiple inputs are concatenated before hashing.
|
||||
/// Input can be identifier (name of identifier as bytes is used), byte string or
|
||||
/// array of bytes.
|
||||
#[proc_macro]
|
||||
pub fn keccak_256(input: TokenStream) -> TokenStream {
|
||||
impls::keccak_256(syn::parse_macro_input!(input as MultipleInputBytes).concatenated())
|
||||
}
|
||||
|
||||
/// Apply a keccak 512-bit hash on its bytes parameter, outputs a `[u8; 64]`.
|
||||
/// Multiple inputs are concatenated before hashing.
|
||||
/// Input can be identifier (name of identifier as bytes is used), byte string or
|
||||
/// array of bytes.
|
||||
#[proc_macro]
|
||||
pub fn keccak_512(input: TokenStream) -> TokenStream {
|
||||
impls::keccak_512(syn::parse_macro_input!(input as MultipleInputBytes).concatenated())
|
||||
}
|
||||
|
||||
/// Apply a sha2 256-bit hash on its bytes parameter, outputs a `[u8; 32]`.
|
||||
/// Multiple inputs are concatenated before hashing.
|
||||
/// Input can be identifier (name of identifier as bytes is used), byte string or
|
||||
/// array of bytes.
|
||||
#[proc_macro]
|
||||
pub fn sha2_256(input: TokenStream) -> TokenStream {
|
||||
impls::sha2_256(syn::parse_macro_input!(input as MultipleInputBytes).concatenated())
|
||||
}
|
||||
Reference in New Issue
Block a user