diff --git a/Cargo.lock b/Cargo.lock
index 7854042ddbcf132de94a4b94dc0f211ab1bf255e..64da4b8996ca62b58fe273e1c5f1f9b216415b9b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -7408,6 +7408,17 @@ dependencies = [
"rle-decode-fast",
]
+[[package]]
+name = "libfuzzer-sys"
+version = "0.4.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a96cfd5557eb82f2b83fed4955246c988d331975a002961b07c81584d107e7f7"
+dependencies = [
+ "arbitrary",
+ "cc",
+ "once_cell",
+]
+
[[package]]
name = "libloading"
version = "0.7.4"
@@ -8182,9 +8193,9 @@ dependencies = [
[[package]]
name = "memchr"
-version = "2.5.0"
+version = "2.6.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
+checksum = "f665ee40bc4a3c5590afb1e9677db74a508659dfd71e126420da8274909a0167"
[[package]]
name = "memfd"
@@ -14297,14 +14308,14 @@ dependencies = [
[[package]]
name = "regex"
-version = "1.9.3"
+version = "1.10.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "81bc1d4caf89fac26a70747fe603c130093b53c773888797a6329091246d651a"
+checksum = "380b951a9c5e80ddfd6136919eef32310721aa4aacd4889a8d39124b026ab343"
dependencies = [
"aho-corasick",
"memchr",
- "regex-automata 0.3.6",
- "regex-syntax 0.7.4",
+ "regex-automata 0.4.3",
+ "regex-syntax 0.8.2",
]
[[package]]
@@ -14321,10 +14332,16 @@ name = "regex-automata"
version = "0.3.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fed1ceff11a1dddaee50c9dc8e4938bd106e9d89ae372f192311e7da498e3b69"
+
+[[package]]
+name = "regex-automata"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f804c7828047e88b2d32e2d7fe5a105da8ee3264f01902f796c8e067dc2483f"
dependencies = [
"aho-corasick",
"memchr",
- "regex-syntax 0.7.4",
+ "regex-syntax 0.8.2",
]
[[package]]
@@ -14335,9 +14352,9 @@ checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1"
[[package]]
name = "regex-syntax"
-version = "0.7.4"
+version = "0.8.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5ea92a5b6195c6ef2a0295ea818b312502c6fc94dde986c5553242e18fd4ce2"
+checksum = "c08c74e62047bb2de4ff487b251e4a92e24f48745648451635cec7d591162d9f"
[[package]]
name = "remote-ext-tests-bags-list"
@@ -17535,6 +17552,16 @@ dependencies = [
"zeroize",
]
+[[package]]
+name = "sp-core-fuzz"
+version = "0.0.0"
+dependencies = [
+ "lazy_static",
+ "libfuzzer-sys",
+ "regex",
+ "sp-core",
+]
+
[[package]]
name = "sp-core-hashing"
version = "9.0.0"
diff --git a/Cargo.toml b/Cargo.toml
index ed252e07053ff0fd52c5d3728741e652841afaf2..57079aa4d03dcc2584bff350a7ed00216a7ac6b2 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -405,6 +405,7 @@ members = [
"substrate/primitives/consensus/sassafras",
"substrate/primitives/consensus/slots",
"substrate/primitives/core",
+ "substrate/primitives/core/fuzz",
"substrate/primitives/core/hashing",
"substrate/primitives/core/hashing/proc-macro",
"substrate/primitives/crypto/ec-utils",
diff --git a/substrate/frame/support/test/tests/pallet_ui/storage_ensure_span_are_ok_on_wrong_gen.stderr b/substrate/frame/support/test/tests/pallet_ui/storage_ensure_span_are_ok_on_wrong_gen.stderr
index 7375bcd2f16af03cfa76aab8c9779d8b26554c8f..b5d108275249e5c2deb95bc0336165aa5a8ba8c1 100644
--- a/substrate/frame/support/test/tests/pallet_ui/storage_ensure_span_are_ok_on_wrong_gen.stderr
+++ b/substrate/frame/support/test/tests/pallet_ui/storage_ensure_span_are_ok_on_wrong_gen.stderr
@@ -6,8 +6,8 @@ error[E0277]: the trait bound `Bar: WrapperTypeDecode` is not satisfied
|
= help: the following other types implement trait `WrapperTypeDecode`:
Box<T>
- frame_support::sp_runtime::sp_application_crypto::sp_core::Bytes
Rc<T>
+ frame_support::sp_runtime::sp_application_crypto::sp_core::Bytes
Arc<T>
= note: required for `Bar` to implement `Decode`
= note: required for `Bar` to implement `FullCodec`
@@ -44,8 +44,8 @@ error[E0277]: the trait bound `Bar: WrapperTypeEncode` is not satisfied
bytes::bytes::Bytes
Cow<'a, T>
parity_scale_codec::Ref<'a, T, U>
- frame_support::sp_runtime::sp_application_crypto::sp_core::Bytes
Rc<T>
+ frame_support::sp_runtime::sp_application_crypto::sp_core::Bytes
Arc<T>
Vec<T>
and $N others
@@ -81,8 +81,8 @@ error[E0277]: the trait bound `Bar: WrapperTypeDecode` is not satisfied
|
= help: the following other types implement trait `WrapperTypeDecode`:
Box<T>
- frame_support::sp_runtime::sp_application_crypto::sp_core::Bytes
Rc<T>
+ frame_support::sp_runtime::sp_application_crypto::sp_core::Bytes
Arc<T>
= note: required for `Bar` to implement `Decode`
= note: required for `Bar` to implement `FullCodec`
@@ -119,8 +119,8 @@ error[E0277]: the trait bound `Bar: WrapperTypeEncode` is not satisfied
bytes::bytes::Bytes
Cow<'a, T>
parity_scale_codec::Ref<'a, T, U>
- frame_support::sp_runtime::sp_application_crypto::sp_core::Bytes
Rc<T>
+ frame_support::sp_runtime::sp_application_crypto::sp_core::Bytes
Arc<T>
Vec<T>
and $N others
@@ -137,8 +137,8 @@ error[E0277]: the trait bound `Bar: WrapperTypeDecode` is not satisfied
|
= help: the following other types implement trait `WrapperTypeDecode`:
Box<T>
- frame_support::sp_runtime::sp_application_crypto::sp_core::Bytes
Rc<T>
+ frame_support::sp_runtime::sp_application_crypto::sp_core::Bytes
Arc<T>
= note: required for `Bar` to implement `Decode`
= note: required for `Bar` to implement `FullCodec`
@@ -177,8 +177,8 @@ error[E0277]: the trait bound `Bar: WrapperTypeEncode` is not satisfied
bytes::bytes::Bytes
Cow<'a, T>
parity_scale_codec::Ref<'a, T, U>
- frame_support::sp_runtime::sp_application_crypto::sp_core::Bytes
Rc<T>
+ frame_support::sp_runtime::sp_application_crypto::sp_core::Bytes
Arc<T>
Vec<T>
and $N others
diff --git a/substrate/frame/support/test/tests/pallet_ui/storage_ensure_span_are_ok_on_wrong_gen_unnamed.stderr b/substrate/frame/support/test/tests/pallet_ui/storage_ensure_span_are_ok_on_wrong_gen_unnamed.stderr
index 3a0a25712aafc3587fb5cc290c7e7f9773b35eba..b58902590b8560f5d8d5e6bbc5bdb652aeb82b44 100644
--- a/substrate/frame/support/test/tests/pallet_ui/storage_ensure_span_are_ok_on_wrong_gen_unnamed.stderr
+++ b/substrate/frame/support/test/tests/pallet_ui/storage_ensure_span_are_ok_on_wrong_gen_unnamed.stderr
@@ -6,8 +6,8 @@ error[E0277]: the trait bound `Bar: WrapperTypeDecode` is not satisfied
|
= help: the following other types implement trait `WrapperTypeDecode`:
Box<T>
- frame_support::sp_runtime::sp_application_crypto::sp_core::Bytes
Rc<T>
+ frame_support::sp_runtime::sp_application_crypto::sp_core::Bytes
Arc<T>
= note: required for `Bar` to implement `Decode`
= note: required for `Bar` to implement `FullCodec`
@@ -44,8 +44,8 @@ error[E0277]: the trait bound `Bar: WrapperTypeEncode` is not satisfied
bytes::bytes::Bytes
Cow<'a, T>
parity_scale_codec::Ref<'a, T, U>
- frame_support::sp_runtime::sp_application_crypto::sp_core::Bytes
Rc<T>
+ frame_support::sp_runtime::sp_application_crypto::sp_core::Bytes
Arc<T>
Vec<T>
and $N others
@@ -81,8 +81,8 @@ error[E0277]: the trait bound `Bar: WrapperTypeDecode` is not satisfied
|
= help: the following other types implement trait `WrapperTypeDecode`:
Box<T>
- frame_support::sp_runtime::sp_application_crypto::sp_core::Bytes
Rc<T>
+ frame_support::sp_runtime::sp_application_crypto::sp_core::Bytes
Arc<T>
= note: required for `Bar` to implement `Decode`
= note: required for `Bar` to implement `FullCodec`
@@ -119,8 +119,8 @@ error[E0277]: the trait bound `Bar: WrapperTypeEncode` is not satisfied
bytes::bytes::Bytes
Cow<'a, T>
parity_scale_codec::Ref<'a, T, U>
- frame_support::sp_runtime::sp_application_crypto::sp_core::Bytes
Rc<T>
+ frame_support::sp_runtime::sp_application_crypto::sp_core::Bytes
Arc<T>
Vec<T>
and $N others
@@ -137,8 +137,8 @@ error[E0277]: the trait bound `Bar: WrapperTypeDecode` is not satisfied
|
= help: the following other types implement trait `WrapperTypeDecode`:
Box<T>
- frame_support::sp_runtime::sp_application_crypto::sp_core::Bytes
Rc<T>
+ frame_support::sp_runtime::sp_application_crypto::sp_core::Bytes
Arc<T>
= note: required for `Bar` to implement `Decode`
= note: required for `Bar` to implement `FullCodec`
@@ -177,8 +177,8 @@ error[E0277]: the trait bound `Bar: WrapperTypeEncode` is not satisfied
bytes::bytes::Bytes
Cow<'a, T>
parity_scale_codec::Ref<'a, T, U>
- frame_support::sp_runtime::sp_application_crypto::sp_core::Bytes
Rc<T>
+ frame_support::sp_runtime::sp_application_crypto::sp_core::Bytes
Arc<T>
Vec<T>
and $N others
diff --git a/substrate/primitives/core/Cargo.toml b/substrate/primitives/core/Cargo.toml
index 79df81e62c6670a1b33ca5f54120cdbb7a01109e..9ecce0a22f5ff7a9027c055fc69f54cc5fa8f349 100644
--- a/substrate/primitives/core/Cargo.toml
+++ b/substrate/primitives/core/Cargo.toml
@@ -26,10 +26,8 @@ bs58 = { version = "0.5.0", default-features = false, optional = true }
rand = { version = "0.8.5", features = ["small_rng"], optional = true }
substrate-bip39 = { version = "0.4.4", optional = true }
bip39 = { version = "2.0.0", default-features = false }
-regex = { version = "1.6.0", optional = true }
zeroize = { version = "1.4.3", default-features = false }
secrecy = { version = "0.8.0", default-features = false }
-lazy_static = { version = "1.4.0", default-features = false, optional = true }
parking_lot = { version = "0.12.1", optional = true }
ss58-registry = { version = "1.34.0", default-features = false }
sp-std = { path = "../std", default-features = false}
@@ -63,6 +61,8 @@ bandersnatch_vrfs = { git = "https://github.com/w3f/ring-vrf", rev = "cbc342e",
[dev-dependencies]
criterion = "0.4.0"
serde_json = "1.0.108"
+lazy_static = "1.4.0"
+regex = "1.6.0"
sp-core-hashing-proc-macro = { path = "hashing/proc-macro" }
[[bench]]
@@ -92,7 +92,6 @@ std = [
"hash256-std-hasher/std",
"impl-serde/std",
"itertools",
- "lazy_static",
"libsecp256k1/std",
"log/std",
"merlin/std",
@@ -102,7 +101,6 @@ std = [
"primitive-types/serde",
"primitive-types/std",
"rand",
- "regex",
"scale-info/std",
"schnorrkel/std",
"secp256k1/global-context",
diff --git a/substrate/primitives/core/fuzz/Cargo.toml b/substrate/primitives/core/fuzz/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..9a094b07d4a10ad8632ab656deb6e618e0f2d5e3
--- /dev/null
+++ b/substrate/primitives/core/fuzz/Cargo.toml
@@ -0,0 +1,20 @@
+[package]
+name = "sp-core-fuzz"
+version = "0.0.0"
+publish = false
+
+[package.metadata]
+cargo-fuzz = true
+
+[dependencies]
+lazy_static = "1.4.0"
+libfuzzer-sys = "0.4"
+regex = "1.10.2"
+
+sp-core = { path = ".." }
+
+[[bin]]
+name = "fuzz_address_uri"
+path = "fuzz_targets/fuzz_address_uri.rs"
+test = false
+doc = false
diff --git a/substrate/primitives/core/fuzz/fuzz_targets/fuzz_address_uri.rs b/substrate/primitives/core/fuzz/fuzz_targets/fuzz_address_uri.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e2d9e2fc8b0822ae9d984683cdaaf71a97bd7c2e
--- /dev/null
+++ b/substrate/primitives/core/fuzz/fuzz_targets/fuzz_address_uri.rs
@@ -0,0 +1,53 @@
+// 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.
+
+#![no_main]
+
+extern crate libfuzzer_sys;
+extern crate regex;
+extern crate sp_core;
+
+use libfuzzer_sys::fuzz_target;
+use regex::Regex;
+use sp_core::crypto::AddressUri;
+
+lazy_static::lazy_static! {
+ static ref SECRET_PHRASE_REGEX: Regex = Regex::new(r"^(?P<phrase>[a-zA-Z0-9 ]+)?(?P<path>(//?[^/]+)*)(///(?P<password>.*))?$")
+ .expect("constructed from known-good static value; qed");
+}
+
+fuzz_target!(|input: &str| {
+ let regex_result = SECRET_PHRASE_REGEX.captures(input);
+ let manual_result = AddressUri::parse(input);
+ assert_eq!(regex_result.is_some(), manual_result.is_ok());
+ if manual_result.is_err() {
+ let _ = format!("{}", manual_result.as_ref().err().unwrap());
+ }
+ if let (Some(regex_result), Ok(manual_result)) = (regex_result, manual_result) {
+ assert_eq!(regex_result.name("phrase").map(|p| p.as_str()), manual_result.phrase);
+
+ let manual_paths = manual_result
+ .paths
+ .iter()
+ .map(|s| "/".to_string() + s)
+ .collect::<Vec<_>>()
+ .join("");
+
+ assert_eq!(regex_result.name("path").unwrap().as_str().to_string(), manual_paths);
+ assert_eq!(regex_result.name("password").map(|pass| pass.as_str()), manual_result.pass);
+ }
+});
diff --git a/substrate/primitives/core/src/address_uri.rs b/substrate/primitives/core/src/address_uri.rs
new file mode 100644
index 0000000000000000000000000000000000000000..862747c9a4b69947905f384ab0be52e4b776c066
--- /dev/null
+++ b/substrate/primitives/core/src/address_uri.rs
@@ -0,0 +1,432 @@
+// 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.
+
+//! Little util for parsing an address URI. Replaces regular expressions.
+
+#[cfg(all(not(feature = "std"), any(feature = "serde", feature = "full_crypto")))]
+use sp_std::{
+ alloc::string::{String, ToString},
+ vec::Vec,
+};
+
+/// A container for results of parsing the address uri string.
+///
+/// Intended to be equivalent of:
+/// `Regex::new(r"^(?P<phrase>[a-zA-Z0-9 ]+)?(?P<path>(//?[^/]+)*)(///(?P<password>.*))?$")`
+/// which also handles soft and hard derivation paths:
+/// `Regex::new(r"/(/?[^/]+)")`
+///
+/// Example:
+/// ```
+/// use sp_core::crypto::AddressUri;
+/// let manual_result = AddressUri::parse("hello world/s//h///pass");
+/// assert_eq!(
+/// manual_result.unwrap(),
+/// AddressUri { phrase: Some("hello world"), paths: vec!["s", "/h"], pass: Some("pass") }
+/// );
+/// ```
+#[derive(Debug, PartialEq)]
+pub struct AddressUri<'a> {
+ /// Phrase, hexadecimal string, or ss58-compatible string.
+ pub phrase: Option<&'a str>,
+ /// Key derivation paths, ordered as in input string,
+ pub paths: Vec<&'a str>,
+ /// Password.
+ pub pass: Option<&'a str>,
+}
+
+/// Errors that are possible during parsing the address URI.
+#[allow(missing_docs)]
+#[cfg_attr(feature = "std", derive(thiserror::Error))]
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub enum Error {
+ #[cfg_attr(feature = "std", error("Invalid character in phrase:\n{0}"))]
+ InvalidCharacterInPhrase(InvalidCharacterInfo),
+ #[cfg_attr(feature = "std", error("Invalid character in password:\n{0}"))]
+ InvalidCharacterInPass(InvalidCharacterInfo),
+ #[cfg_attr(feature = "std", error("Missing character in hard path:\n{0}"))]
+ MissingCharacterInHardPath(InvalidCharacterInfo),
+ #[cfg_attr(feature = "std", error("Missing character in soft path:\n{0}"))]
+ MissingCharacterInSoftPath(InvalidCharacterInfo),
+}
+
+impl Error {
+ /// Creates an instance of `Error::InvalidCharacterInPhrase` using given parameters.
+ pub fn in_phrase(input: &str, pos: usize) -> Self {
+ Self::InvalidCharacterInPhrase(InvalidCharacterInfo::new(input, pos))
+ }
+ /// Creates an instance of `Error::InvalidCharacterInPass` using given parameters.
+ pub fn in_pass(input: &str, pos: usize) -> Self {
+ Self::InvalidCharacterInPass(InvalidCharacterInfo::new(input, pos))
+ }
+ /// Creates an instance of `Error::MissingCharacterInHardPath` using given parameters.
+ pub fn in_hard_path(input: &str, pos: usize) -> Self {
+ Self::MissingCharacterInHardPath(InvalidCharacterInfo::new(input, pos))
+ }
+ /// Creates an instance of `Error::MissingCharacterInSoftPath` using given parameters.
+ pub fn in_soft_path(input: &str, pos: usize) -> Self {
+ Self::MissingCharacterInSoftPath(InvalidCharacterInfo::new(input, pos))
+ }
+}
+
+/// Complementary error information.
+///
+/// Strucutre contains complementary information about parsing address URI string.
+/// String contains a copy of an original URI string, 0-based integer indicates position of invalid
+/// character.
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub struct InvalidCharacterInfo(String, usize);
+
+impl InvalidCharacterInfo {
+ fn new(info: &str, pos: usize) -> Self {
+ Self(info.to_string(), pos)
+ }
+}
+
+impl sp_std::fmt::Display for InvalidCharacterInfo {
+ fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+ let (s, pos) = escape_string(&self.0, self.1);
+ write!(f, "{s}\n{i}^", i = sp_std::iter::repeat(" ").take(pos).collect::<String>())
+ }
+}
+
+/// Escapes the control characters in given string, and recomputes the position if some characters
+/// were actually escaped.
+fn escape_string(input: &str, pos: usize) -> (String, usize) {
+ let mut out = String::with_capacity(2 * input.len());
+ let mut out_pos = 0;
+ input
+ .chars()
+ .enumerate()
+ .map(|(i, c)| {
+ let esc = |c| (i, Some('\\'), c, 2);
+ match c {
+ '\t' => esc('t'),
+ '\n' => esc('n'),
+ '\r' => esc('r'),
+ '\x07' => esc('a'),
+ '\x08' => esc('b'),
+ '\x0b' => esc('v'),
+ '\x0c' => esc('f'),
+ _ => (i, None, c, 1),
+ }
+ })
+ .for_each(|(i, maybe_escape, c, increment)| {
+ maybe_escape.map(|e| out.push(e));
+ out.push(c);
+ if i < pos {
+ out_pos += increment;
+ }
+ });
+ (out, out_pos)
+}
+
+fn extract_prefix<'a>(input: &mut &'a str, is_allowed: &dyn Fn(char) -> bool) -> Option<&'a str> {
+ let output = input.trim_start_matches(is_allowed);
+ let prefix_len = input.len() - output.len();
+ let prefix = if prefix_len > 0 { Some(&input[..prefix_len]) } else { None };
+ *input = output;
+ prefix
+}
+
+fn strip_prefix(input: &mut &str, prefix: &str) -> bool {
+ if let Some(stripped_input) = input.strip_prefix(prefix) {
+ *input = stripped_input;
+ true
+ } else {
+ false
+ }
+}
+
+impl<'a> AddressUri<'a> {
+ /// Parses the given string.
+ pub fn parse(mut input: &'a str) -> Result<Self, Error> {
+ let initial_input = input;
+ let initial_input_len = input.len();
+ let phrase = extract_prefix(&mut input, &|ch: char| {
+ ch.is_ascii_digit() || ch.is_ascii_alphabetic() || ch == ' '
+ });
+
+ let mut pass = None;
+ let mut paths = Vec::new();
+ while !input.is_empty() {
+ let unstripped_input = input;
+ if strip_prefix(&mut input, "///") {
+ pass = Some(extract_prefix(&mut input, &|ch: char| ch != '\n').unwrap_or(""));
+ } else if strip_prefix(&mut input, "//") {
+ let path = extract_prefix(&mut input, &|ch: char| ch != '/')
+ .ok_or(Error::in_hard_path(initial_input, initial_input_len - input.len()))?;
+ assert!(path.len() > 0);
+ // hard path shall contain leading '/', so take it from unstripped input.
+ paths.push(&unstripped_input[1..path.len() + 2]);
+ } else if strip_prefix(&mut input, "/") {
+ paths.push(
+ extract_prefix(&mut input, &|ch: char| ch != '/').ok_or(
+ Error::in_soft_path(initial_input, initial_input_len - input.len()),
+ )?,
+ );
+ } else {
+ return Err(if pass.is_some() {
+ Error::in_pass(initial_input, initial_input_len - input.len())
+ } else {
+ Error::in_phrase(initial_input, initial_input_len - input.len())
+ });
+ }
+ }
+
+ Ok(Self { phrase, paths, pass })
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use regex::Regex;
+
+ lazy_static::lazy_static! {
+ static ref SECRET_PHRASE_REGEX: Regex = Regex::new(r"^(?P<phrase>[a-zA-Z0-9 ]+)?(?P<path>(//?[^/]+)*)(///(?P<password>.*))?$")
+ .expect("constructed from known-good static value; qed");
+ }
+
+ fn check_with_regex(input: &str) {
+ let regex_result = SECRET_PHRASE_REGEX.captures(input);
+ let manual_result = AddressUri::parse(input);
+ assert_eq!(regex_result.is_some(), manual_result.is_ok());
+ if let (Some(regex_result), Ok(manual_result)) = (regex_result, manual_result) {
+ assert_eq!(
+ regex_result.name("phrase").map(|phrase| phrase.as_str()),
+ manual_result.phrase
+ );
+
+ let manual_paths = manual_result
+ .paths
+ .iter()
+ .map(|s| "/".to_string() + s)
+ .collect::<Vec<_>>()
+ .join("");
+
+ assert_eq!(regex_result.name("path").unwrap().as_str().to_string(), manual_paths);
+ assert_eq!(
+ regex_result.name("password").map(|phrase| phrase.as_str()),
+ manual_result.pass
+ );
+ }
+ }
+
+ fn check(input: &str, result: Result<AddressUri, Error>) {
+ let manual_result = AddressUri::parse(input);
+ assert_eq!(manual_result, result);
+ check_with_regex(input);
+ }
+
+ #[test]
+ fn test00() {
+ check("///", Ok(AddressUri { phrase: None, pass: Some(""), paths: vec![] }));
+ }
+
+ #[test]
+ fn test01() {
+ check("////////", Ok(AddressUri { phrase: None, pass: Some("/////"), paths: vec![] }))
+ }
+
+ #[test]
+ fn test02() {
+ check(
+ "sdasd///asda",
+ Ok(AddressUri { phrase: Some("sdasd"), pass: Some("asda"), paths: vec![] }),
+ );
+ }
+
+ #[test]
+ fn test03() {
+ check(
+ "sdasd//asda",
+ Ok(AddressUri { phrase: Some("sdasd"), pass: None, paths: vec!["/asda"] }),
+ );
+ }
+
+ #[test]
+ fn test04() {
+ check("sdasd//a", Ok(AddressUri { phrase: Some("sdasd"), pass: None, paths: vec!["/a"] }));
+ }
+
+ #[test]
+ fn test05() {
+ let input = "sdasd//";
+ check(input, Err(Error::in_hard_path(input, 7)));
+ }
+
+ #[test]
+ fn test06() {
+ check(
+ "sdasd/xx//asda",
+ Ok(AddressUri { phrase: Some("sdasd"), pass: None, paths: vec!["xx", "/asda"] }),
+ );
+ }
+
+ #[test]
+ fn test07() {
+ check(
+ "sdasd/xx//a/b//c///pass",
+ Ok(AddressUri {
+ phrase: Some("sdasd"),
+ pass: Some("pass"),
+ paths: vec!["xx", "/a", "b", "/c"],
+ }),
+ );
+ }
+
+ #[test]
+ fn test08() {
+ check(
+ "sdasd/xx//a",
+ Ok(AddressUri { phrase: Some("sdasd"), pass: None, paths: vec!["xx", "/a"] }),
+ );
+ }
+
+ #[test]
+ fn test09() {
+ let input = "sdasd/xx//";
+ check(input, Err(Error::in_hard_path(input, 10)));
+ }
+
+ #[test]
+ fn test10() {
+ check(
+ "sdasd/asda",
+ Ok(AddressUri { phrase: Some("sdasd"), pass: None, paths: vec!["asda"] }),
+ );
+ }
+
+ #[test]
+ fn test11() {
+ check(
+ "sdasd/asda//x",
+ Ok(AddressUri { phrase: Some("sdasd"), pass: None, paths: vec!["asda", "/x"] }),
+ );
+ }
+
+ #[test]
+ fn test12() {
+ check("sdasd/a", Ok(AddressUri { phrase: Some("sdasd"), pass: None, paths: vec!["a"] }));
+ }
+
+ #[test]
+ fn test13() {
+ let input = "sdasd/";
+ check(input, Err(Error::in_soft_path(input, 6)));
+ }
+
+ #[test]
+ fn test14() {
+ check("sdasd", Ok(AddressUri { phrase: Some("sdasd"), pass: None, paths: vec![] }));
+ }
+
+ #[test]
+ fn test15() {
+ let input = "sdasd.";
+ check(input, Err(Error::in_phrase(input, 5)));
+ }
+
+ #[test]
+ fn test16() {
+ let input = "sd.asd/asd.a";
+ check(input, Err(Error::in_phrase(input, 2)));
+ }
+
+ #[test]
+ fn test17() {
+ let input = "sd.asd//asd.a";
+ check(input, Err(Error::in_phrase(input, 2)));
+ }
+
+ #[test]
+ fn test18() {
+ check(
+ "sdasd/asd.a",
+ Ok(AddressUri { phrase: Some("sdasd"), pass: None, paths: vec!["asd.a"] }),
+ );
+ }
+
+ #[test]
+ fn test19() {
+ check(
+ "sdasd//asd.a",
+ Ok(AddressUri { phrase: Some("sdasd"), pass: None, paths: vec!["/asd.a"] }),
+ );
+ }
+
+ #[test]
+ fn test20() {
+ let input = "///\n";
+ check(input, Err(Error::in_pass(input, 3)));
+ }
+
+ #[test]
+ fn test21() {
+ let input = "///a\n";
+ check(input, Err(Error::in_pass(input, 4)));
+ }
+
+ #[test]
+ fn test22() {
+ let input = "sd asd///asd.a\n";
+ check(input, Err(Error::in_pass(input, 14)));
+ }
+
+ #[test]
+ fn test_invalid_char_info_1() {
+ let expected = "01234\n^";
+ let f = format!("{}", InvalidCharacterInfo::new("01234", 0));
+ assert_eq!(expected, f);
+ }
+
+ #[test]
+ fn test_invalid_char_info_2() {
+ let expected = "01\n ^";
+ let f = format!("{}", InvalidCharacterInfo::new("01", 1));
+ assert_eq!(expected, f);
+ }
+
+ #[test]
+ fn test_invalid_char_info_3() {
+ let expected = "01234\n ^";
+ let f = format!("{}", InvalidCharacterInfo::new("01234", 2));
+ assert_eq!(expected, f);
+ }
+
+ #[test]
+ fn test_invalid_char_info_4() {
+ let expected = "012\\n456\n ^";
+ let f = format!("{}", InvalidCharacterInfo::new("012\n456", 3));
+ assert_eq!(expected, f);
+ }
+
+ #[test]
+ fn test_invalid_char_info_5() {
+ let expected = "012\\n456\n ^";
+ let f = format!("{}", InvalidCharacterInfo::new("012\n456", 5));
+ assert_eq!(expected, f);
+ }
+
+ #[test]
+ fn test_invalid_char_info_6() {
+ let expected = "012\\f456\\t89\n ^";
+ let f = format!("{}", InvalidCharacterInfo::new("012\x0c456\t89", 9));
+ assert_eq!(expected, f);
+ }
+}
diff --git a/substrate/primitives/core/src/crypto.rs b/substrate/primitives/core/src/crypto.rs
index d369de5a1c0115b0e0385fe903c6f3e8a16bbaa4..c9719e344d3e208f8f9b81dddad10acf2eedfebb 100644
--- a/substrate/primitives/core/src/crypto.rs
+++ b/substrate/primitives/core/src/crypto.rs
@@ -25,8 +25,6 @@ use codec::{Decode, Encode, MaxEncodedLen};
use itertools::Itertools;
#[cfg(feature = "std")]
use rand::{rngs::OsRng, RngCore};
-#[cfg(feature = "std")]
-use regex::Regex;
use scale_info::TypeInfo;
#[cfg(feature = "std")]
pub use secrecy::{ExposeSecret, SecretString};
@@ -43,6 +41,11 @@ pub use ss58_registry::{from_known_address_format, Ss58AddressFormat, Ss58Addres
/// Trait to zeroize a memory buffer.
pub use zeroize::Zeroize;
+#[cfg(feature = "std")]
+pub use crate::address_uri::AddressUri;
+#[cfg(any(feature = "std", feature = "full_crypto"))]
+pub use crate::address_uri::Error as AddressUriError;
+
/// The root phrase for our publicly known keys.
pub const DEV_PHRASE: &str =
"bottom drive obey lake curtain smoke basket hold race lonely fit walk";
@@ -82,8 +85,8 @@ impl<S, T: UncheckedFrom<S>> UncheckedInto<T> for S {
#[cfg(feature = "full_crypto")]
pub enum SecretStringError {
/// The overall format was invalid (e.g. the seed phrase contained symbols).
- #[cfg_attr(feature = "std", error("Invalid format"))]
- InvalidFormat,
+ #[cfg_attr(feature = "std", error("Invalid format {0}"))]
+ InvalidFormat(AddressUriError),
/// The seed phrase provided is not a valid BIP39 phrase.
#[cfg_attr(feature = "std", error("Invalid phrase"))]
InvalidPhrase,
@@ -101,6 +104,13 @@ pub enum SecretStringError {
InvalidPath,
}
+#[cfg(any(feature = "std", feature = "full_crypto"))]
+impl From<AddressUriError> for SecretStringError {
+ fn from(e: AddressUriError) -> Self {
+ Self::InvalidFormat(e)
+ }
+}
+
/// An error when deriving a key.
#[cfg_attr(feature = "std", derive(thiserror::Error))]
#[derive(Debug, Clone, PartialEq, Eq)]
@@ -208,7 +218,7 @@ impl<T: AsRef<str>> From<T> for DeriveJunction {
/// An error type for SS58 decoding.
#[cfg_attr(feature = "std", derive(thiserror::Error))]
#[cfg_attr(not(feature = "std"), derive(Debug))]
-#[derive(Clone, Copy, Eq, PartialEq)]
+#[derive(Clone, Eq, PartialEq)]
#[allow(missing_docs)]
#[cfg(any(feature = "full_crypto", feature = "serde"))]
pub enum PublicError {
@@ -235,6 +245,11 @@ pub enum PublicError {
InvalidPath,
#[cfg_attr(feature = "std", error("Disallowed SS58 Address Format for this datatype."))]
FormatNotAllowed,
+ #[cfg_attr(feature = "std", error("Password not allowed."))]
+ PasswordNotAllowed,
+ #[cfg(feature = "std")]
+ #[cfg_attr(feature = "std", error("Incorrect URI syntax {0}."))]
+ MalformedUri(#[from] AddressUriError),
}
#[cfg(feature = "std")]
@@ -414,47 +429,40 @@ pub fn set_default_ss58_version(new_default: Ss58AddressFormat) {
DEFAULT_VERSION.store(new_default.into(), core::sync::atomic::Ordering::Relaxed);
}
-#[cfg(feature = "std")]
-lazy_static::lazy_static! {
- static ref SS58_REGEX: Regex = Regex::new(r"^(?P<ss58>[\w\d ]+)?(?P<path>(//?[^/]+)*)$")
- .expect("constructed from known-good static value; qed");
- static ref SECRET_PHRASE_REGEX: Regex = Regex::new(r"^(?P<phrase>[\d\w ]+)?(?P<path>(//?[^/]+)*)(///(?P<password>.*))?$")
- .expect("constructed from known-good static value; qed");
- static ref JUNCTION_REGEX: Regex = Regex::new(r"/(/?[^/]+)")
- .expect("constructed from known-good static value; qed");
-}
-
#[cfg(feature = "std")]
impl<T: Sized + AsMut<[u8]> + AsRef<[u8]> + Public + Derive> Ss58Codec for T {
fn from_string(s: &str) -> Result<Self, PublicError> {
- let cap = SS58_REGEX.captures(s).ok_or(PublicError::InvalidFormat)?;
- let s = cap.name("ss58").map(|r| r.as_str()).unwrap_or(DEV_ADDRESS);
+ let cap = AddressUri::parse(s)?;
+ if cap.pass.is_some() {
+ return Err(PublicError::PasswordNotAllowed);
+ }
+ let s = cap.phrase.unwrap_or(DEV_ADDRESS);
let addr = if let Some(stripped) = s.strip_prefix("0x") {
let d = array_bytes::hex2bytes(stripped).map_err(|_| PublicError::InvalidFormat)?;
Self::from_slice(&d).map_err(|()| PublicError::BadLength)?
} else {
Self::from_ss58check(s)?
};
- if cap["path"].is_empty() {
+ if cap.paths.is_empty() {
Ok(addr)
} else {
- let path =
- JUNCTION_REGEX.captures_iter(&cap["path"]).map(|f| DeriveJunction::from(&f[1]));
- addr.derive(path).ok_or(PublicError::InvalidPath)
+ addr.derive(cap.paths.iter().map(DeriveJunction::from))
+ .ok_or(PublicError::InvalidPath)
}
}
fn from_string_with_version(s: &str) -> Result<(Self, Ss58AddressFormat), PublicError> {
- let cap = SS58_REGEX.captures(s).ok_or(PublicError::InvalidFormat)?;
- let (addr, v) = Self::from_ss58check_with_version(
- cap.name("ss58").map(|r| r.as_str()).unwrap_or(DEV_ADDRESS),
- )?;
- if cap["path"].is_empty() {
+ let cap = AddressUri::parse(s)?;
+ if cap.pass.is_some() {
+ return Err(PublicError::PasswordNotAllowed);
+ }
+ let (addr, v) = Self::from_ss58check_with_version(cap.phrase.unwrap_or(DEV_ADDRESS))?;
+ if cap.paths.is_empty() {
Ok((addr, v))
} else {
- let path =
- JUNCTION_REGEX.captures_iter(&cap["path"]).map(|f| DeriveJunction::from(&f[1]));
- addr.derive(path).ok_or(PublicError::InvalidPath).map(|a| (a, v))
+ addr.derive(cap.paths.iter().map(DeriveJunction::from))
+ .ok_or(PublicError::InvalidPath)
+ .map(|a| (a, v))
}
}
}
@@ -817,22 +825,15 @@ impl sp_std::str::FromStr for SecretUri {
type Err = SecretStringError;
fn from_str(s: &str) -> Result<Self, Self::Err> {
- let cap = SECRET_PHRASE_REGEX.captures(s).ok_or(SecretStringError::InvalidFormat)?;
-
- let junctions = JUNCTION_REGEX
- .captures_iter(&cap["path"])
- .map(|f| DeriveJunction::from(&f[1]))
- .collect::<Vec<_>>();
-
- let phrase = cap.name("phrase").map(|r| r.as_str()).unwrap_or(DEV_PHRASE);
- let password = cap.name("password");
+ let cap = AddressUri::parse(s)?;
+ let phrase = cap.phrase.unwrap_or(DEV_PHRASE);
Ok(Self {
phrase: SecretString::from_str(phrase).expect("Returns infallible error; qed"),
- password: password.map(|v| {
- SecretString::from_str(v.as_str()).expect("Returns infallible error; qed")
- }),
- junctions,
+ password: cap
+ .pass
+ .map(|v| SecretString::from_str(v).expect("Returns infallible error; qed")),
+ junctions: cap.paths.iter().map(DeriveJunction::from).collect::<Vec<_>>(),
})
}
}
diff --git a/substrate/primitives/core/src/lib.rs b/substrate/primitives/core/src/lib.rs
index ec0641c54668b8b54613dc7b9a1c188489b9dfc4..4873d1a2112744e2e5ebbcd5c06c5f4b186f04ff 100644
--- a/substrate/primitives/core/src/lib.rs
+++ b/substrate/primitives/core/src/lib.rs
@@ -55,6 +55,8 @@ pub mod crypto;
pub mod hexdisplay;
pub use paste;
+#[cfg(any(feature = "full_crypto", feature = "std"))]
+mod address_uri;
#[cfg(feature = "bandersnatch-experimental")]
pub mod bandersnatch;
#[cfg(feature = "bls-experimental")]