1use crate::error::Error;
8
9#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
11#[non_exhaustive]
12pub enum KeyCodec {
13 Ed25519Pub,
15 X25519Pub,
17 Secp256k1Pub,
20}
21
22impl KeyCodec {
23 pub const fn multicodec(self) -> u64 {
25 match self {
26 KeyCodec::Ed25519Pub => 0xed,
27 KeyCodec::X25519Pub => 0xec,
28 KeyCodec::Secp256k1Pub => 0xe7,
29 }
30 }
31
32 pub const fn key_len(self) -> usize {
34 match self {
35 KeyCodec::Ed25519Pub => 32,
36 KeyCodec::X25519Pub => 32,
37 KeyCodec::Secp256k1Pub => 33,
38 }
39 }
40
41 pub const fn multibase_prefix(self) -> &'static str {
44 match self {
45 KeyCodec::Ed25519Pub => "z6Mk",
46 KeyCodec::X25519Pub => "z6LS",
47 KeyCodec::Secp256k1Pub => "zQ3s",
48 }
49 }
50
51 fn from_multicodec(code: u64) -> Option<KeyCodec> {
52 match code {
53 0xed => Some(KeyCodec::Ed25519Pub),
54 0xec => Some(KeyCodec::X25519Pub),
55 0xe7 => Some(KeyCodec::Secp256k1Pub),
56 _ => None,
57 }
58 }
59}
60
61fn write_uvarint(out: &mut Vec<u8>, mut value: u64) {
64 loop {
65 let byte = (value & 0x7f) as u8;
66 value >>= 7;
67 if value == 0 {
68 out.push(byte);
69 return;
70 }
71 out.push(byte | 0x80);
72 }
73}
74
75fn read_uvarint(bytes: &[u8]) -> Result<(u64, usize), Error> {
79 let mut value: u64 = 0;
80 for (i, &byte) in bytes.iter().enumerate().take(9) {
81 value |= u64::from(byte & 0x7f) << (7 * i);
82 if byte & 0x80 == 0 {
83 if i > 0 && byte == 0 {
84 return Err(Error::InvalidMultikey(
85 "multicodec varint is not minimally encoded",
86 ));
87 }
88 return Ok((value, i + 1));
89 }
90 }
91 Err(Error::InvalidMultikey("malformed multicodec varint"))
92}
93
94pub fn encode(codec: KeyCodec, key: &[u8]) -> Result<String, Error> {
107 if key.len() != codec.key_len() {
108 return Err(Error::InvalidKeyLength {
109 expected: codec.key_len(),
110 actual: key.len(),
111 });
112 }
113 let mut bytes = Vec::with_capacity(2 + key.len());
114 write_uvarint(&mut bytes, codec.multicodec());
115 bytes.extend_from_slice(key);
116 Ok(format!("z{}", bs58::encode(bytes).into_string()))
117}
118
119pub fn decode(multikey: &str) -> Result<(KeyCodec, Vec<u8>), Error> {
125 let encoded = multikey.strip_prefix('z').ok_or(Error::InvalidMultikey(
126 "expected multibase `z` (base58btc) header",
127 ))?;
128 let bytes = bs58::decode(encoded)
129 .into_vec()
130 .map_err(|_| Error::InvalidMultikey("invalid base58btc payload"))?;
131 let (code, consumed) = read_uvarint(&bytes)?;
132 let codec = KeyCodec::from_multicodec(code)
133 .ok_or(Error::InvalidMultikey("unknown multicodec key prefix"))?;
134 let key = &bytes[consumed..];
135 if key.len() != codec.key_len() {
136 return Err(Error::InvalidKeyLength {
137 expected: codec.key_len(),
138 actual: key.len(),
139 });
140 }
141 Ok((codec, key.to_vec()))
142}
143
144#[cfg(test)]
145mod tests {
146 use super::*;
147
148 #[test]
149 fn varint_two_byte_prefixes() {
150 let mut out = Vec::new();
151 write_uvarint(&mut out, 0xed);
152 assert_eq!(out, [0xed, 0x01]);
153 assert_eq!(read_uvarint(&[0xed, 0x01]).unwrap(), (0xed, 2));
154 assert_eq!(read_uvarint(&[0x7f]).unwrap(), (0x7f, 1));
155 assert_eq!(read_uvarint(&[0x00]).unwrap(), (0, 1));
156 assert!(read_uvarint(&[0x80]).is_err());
157 assert!(read_uvarint(&[0xed, 0x81, 0x00]).is_err());
159 assert!(read_uvarint(&[0x80, 0x00]).is_err());
160 }
161
162 #[test]
163 fn roundtrip_all_codecs() {
164 for codec in [
165 KeyCodec::Ed25519Pub,
166 KeyCodec::X25519Pub,
167 KeyCodec::Secp256k1Pub,
168 ] {
169 let key = vec![7u8; codec.key_len()];
170 let encoded = encode(codec, &key).unwrap();
171 assert!(encoded.starts_with(codec.multibase_prefix()), "{encoded}");
172 let (decoded_codec, decoded_key) = decode(&encoded).unwrap();
173 assert_eq!(decoded_codec, codec);
174 assert_eq!(decoded_key, key);
175 }
176 }
177
178 #[test]
179 fn rejects_wrong_lengths_and_headers() {
180 assert!(matches!(
181 encode(KeyCodec::Ed25519Pub, &[0u8; 31]),
182 Err(Error::InvalidKeyLength {
183 expected: 32,
184 actual: 31
185 })
186 ));
187 assert!(decode("m6Mk").is_err());
188 assert!(decode("z0OIl").is_err());
189 let mut overlong = vec![0xed, 0x81, 0x00];
192 overlong.extend_from_slice(&[7u8; 32]);
193 let overlong = format!("z{}", bs58::encode(overlong).into_string());
194 assert!(matches!(
195 decode(&overlong),
196 Err(Error::InvalidMultikey(
197 "multicodec varint is not minimally encoded"
198 ))
199 ));
200 let mut bytes = vec![0xed, 0x01];
202 bytes.extend_from_slice(&[0u8; 31]);
203 let bad = format!("z{}", bs58::encode(bytes).into_string());
204 assert!(matches!(decode(&bad), Err(Error::InvalidKeyLength { .. })));
205 }
206}