deltachat/
key.rs

1//! Cryptographic key module.
2
3use std::collections::BTreeMap;
4use std::fmt;
5use std::io::Cursor;
6
7use anyhow::{bail, ensure, Context as _, Result};
8use base64::Engine as _;
9use deltachat_contact_tools::EmailAddress;
10use pgp::composed::Deserializable;
11pub use pgp::composed::{SignedPublicKey, SignedSecretKey};
12use pgp::ser::Serialize;
13use pgp::types::{PublicKeyTrait, SecretKeyTrait};
14use rand::thread_rng;
15use tokio::runtime::Handle;
16
17use crate::context::Context;
18use crate::log::LogExt;
19use crate::pgp::KeyPair;
20use crate::tools::{self, time_elapsed};
21
22/// Convenience trait for working with keys.
23///
24/// This trait is implemented for rPGP's [SignedPublicKey] and
25/// [SignedSecretKey] types and makes working with them a little
26/// easier in the deltachat world.
27pub(crate) trait DcKey: Serialize + Deserializable + PublicKeyTrait + Clone {
28    /// Create a key from some bytes.
29    fn from_slice(bytes: &[u8]) -> Result<Self> {
30        let res = <Self as Deserializable>::from_bytes(Cursor::new(bytes));
31        if let Ok(res) = res {
32            return Ok(res);
33        }
34
35        // Workaround for keys imported using
36        // Delta Chat core < 1.0.0.
37        // Old Delta Chat core had a bug
38        // that resulted in treating CRC24 checksum
39        // as part of the key when reading ASCII Armor.
40        // Some users that started using Delta Chat in 2019
41        // have such corrupted keys with garbage bytes at the end.
42        //
43        // Garbage is at least 3 bytes long
44        // and may be longer due to padding
45        // at the end of the real key data
46        // and importing the key multiple times.
47        //
48        // If removing 10 bytes is not enough,
49        // the key is likely actually corrupted.
50        for garbage_bytes in 3..std::cmp::min(bytes.len(), 10) {
51            let res = <Self as Deserializable>::from_bytes(Cursor::new(
52                bytes
53                    .get(..bytes.len().saturating_sub(garbage_bytes))
54                    .unwrap_or_default(),
55            ));
56            if let Ok(res) = res {
57                return Ok(res);
58            }
59        }
60
61        // Removing garbage bytes did not help, return the error.
62        Ok(res?)
63    }
64
65    /// Create a key from a base64 string.
66    fn from_base64(data: &str) -> Result<Self> {
67        // strip newlines and other whitespace
68        let cleaned: String = data.split_whitespace().collect();
69        let bytes = base64::engine::general_purpose::STANDARD.decode(cleaned.as_bytes())?;
70        Self::from_slice(&bytes)
71    }
72
73    /// Create a key from an ASCII-armored string.
74    ///
75    /// Returns the key and a map of any headers which might have been set in
76    /// the ASCII-armored representation.
77    fn from_asc(data: &str) -> Result<(Self, BTreeMap<String, String>)> {
78        let bytes = data.as_bytes();
79        let res = Self::from_armor_single(Cursor::new(bytes));
80        let (key, headers) = match res {
81            Err(pgp::errors::Error::NoMatchingPacket) => match Self::is_private() {
82                true => bail!("No private key packet found"),
83                false => bail!("No public key packet found"),
84            },
85            _ => res.context("rPGP error")?,
86        };
87        let headers = headers
88            .into_iter()
89            .map(|(key, values)| {
90                (
91                    key.trim().to_lowercase(),
92                    values
93                        .last()
94                        .map_or_else(String::new, |s| s.trim().to_string()),
95                )
96            })
97            .collect();
98        Ok((key, headers))
99    }
100
101    /// Serialise the key as bytes.
102    fn to_bytes(&self) -> Vec<u8> {
103        // Not using Serialize::to_bytes() to make clear *why* it is
104        // safe to ignore this error.
105        // Because we write to a Vec<u8> the io::Write impls never
106        // fail and we can hide this error.
107        let mut buf = Vec::new();
108        self.to_writer(&mut buf).unwrap();
109        buf
110    }
111
112    /// Serialise the key to a base64 string.
113    fn to_base64(&self) -> String {
114        base64::engine::general_purpose::STANDARD.encode(DcKey::to_bytes(self))
115    }
116
117    /// Serialise the key to ASCII-armored representation.
118    ///
119    /// Each header line must be terminated by `\r\n`.  Only allows setting one
120    /// header as a simplification since that's the only way it's used so far.
121    // Since .to_armored_string() are actual methods on SignedPublicKey and
122    // SignedSecretKey we can not generically implement this.
123    fn to_asc(&self, header: Option<(&str, &str)>) -> String;
124
125    /// The fingerprint for the key.
126    fn dc_fingerprint(&self) -> Fingerprint {
127        PublicKeyTrait::fingerprint(self).into()
128    }
129
130    fn is_private() -> bool;
131}
132
133pub(crate) async fn load_self_public_key(context: &Context) -> Result<SignedPublicKey> {
134    let public_key = context
135        .sql
136        .query_row_optional(
137            "SELECT public_key
138             FROM keypairs
139             WHERE id=(SELECT value FROM config WHERE keyname='key_id')",
140            (),
141            |row| {
142                let bytes: Vec<u8> = row.get(0)?;
143                Ok(bytes)
144            },
145        )
146        .await?;
147    match public_key {
148        Some(bytes) => SignedPublicKey::from_slice(&bytes),
149        None => {
150            let keypair = generate_keypair(context).await?;
151            Ok(keypair.public)
152        }
153    }
154}
155
156/// Returns our own public keyring.
157pub(crate) async fn load_self_public_keyring(context: &Context) -> Result<Vec<SignedPublicKey>> {
158    let keys = context
159        .sql
160        .query_map(
161            r#"SELECT public_key
162               FROM keypairs
163               ORDER BY id=(SELECT value FROM config WHERE keyname='key_id') DESC"#,
164            (),
165            |row| row.get::<_, Vec<u8>>(0),
166            |keys| keys.collect::<Result<Vec<_>, _>>().map_err(Into::into),
167        )
168        .await?
169        .into_iter()
170        .filter_map(|bytes| SignedPublicKey::from_slice(&bytes).log_err(context).ok())
171        .collect();
172    Ok(keys)
173}
174
175pub(crate) async fn load_self_secret_key(context: &Context) -> Result<SignedSecretKey> {
176    let private_key = context
177        .sql
178        .query_row_optional(
179            "SELECT private_key
180             FROM keypairs
181             WHERE id=(SELECT value FROM config WHERE keyname='key_id')",
182            (),
183            |row| {
184                let bytes: Vec<u8> = row.get(0)?;
185                Ok(bytes)
186            },
187        )
188        .await?;
189    match private_key {
190        Some(bytes) => SignedSecretKey::from_slice(&bytes),
191        None => {
192            let keypair = generate_keypair(context).await?;
193            Ok(keypair.secret)
194        }
195    }
196}
197
198pub(crate) async fn load_self_secret_keyring(context: &Context) -> Result<Vec<SignedSecretKey>> {
199    let keys = context
200        .sql
201        .query_map(
202            r#"SELECT private_key
203               FROM keypairs
204               ORDER BY id=(SELECT value FROM config WHERE keyname='key_id') DESC"#,
205            (),
206            |row| row.get::<_, Vec<u8>>(0),
207            |keys| keys.collect::<Result<Vec<_>, _>>().map_err(Into::into),
208        )
209        .await?
210        .into_iter()
211        .filter_map(|bytes| SignedSecretKey::from_slice(&bytes).log_err(context).ok())
212        .collect();
213    Ok(keys)
214}
215
216impl DcKey for SignedPublicKey {
217    fn to_asc(&self, header: Option<(&str, &str)>) -> String {
218        // Not using .to_armored_string() to make clear *why* it is
219        // safe to ignore this error.
220        // Because we write to a Vec<u8> the io::Write impls never
221        // fail and we can hide this error.
222        let headers =
223            header.map(|(key, value)| BTreeMap::from([(key.to_string(), vec![value.to_string()])]));
224        let mut buf = Vec::new();
225        self.to_armored_writer(&mut buf, headers.as_ref().into())
226            .unwrap_or_default();
227        std::string::String::from_utf8(buf).unwrap_or_default()
228    }
229
230    fn is_private() -> bool {
231        false
232    }
233}
234
235impl DcKey for SignedSecretKey {
236    fn to_asc(&self, header: Option<(&str, &str)>) -> String {
237        // Not using .to_armored_string() to make clear *why* it is
238        // safe to do these unwraps.
239        // Because we write to a Vec<u8> the io::Write impls never
240        // fail and we can hide this error.  The string is always ASCII.
241        let headers =
242            header.map(|(key, value)| BTreeMap::from([(key.to_string(), vec![value.to_string()])]));
243        let mut buf = Vec::new();
244        self.to_armored_writer(&mut buf, headers.as_ref().into())
245            .unwrap_or_default();
246        std::string::String::from_utf8(buf).unwrap_or_default()
247    }
248
249    fn is_private() -> bool {
250        true
251    }
252}
253
254/// Deltachat extension trait for secret keys.
255///
256/// Provides some convenience wrappers only applicable to [SignedSecretKey].
257pub(crate) trait DcSecretKey {
258    /// Create a public key from a private one.
259    fn split_public_key(&self) -> Result<SignedPublicKey>;
260}
261
262impl DcSecretKey for SignedSecretKey {
263    fn split_public_key(&self) -> Result<SignedPublicKey> {
264        self.verify()?;
265        let unsigned_pubkey = SecretKeyTrait::public_key(self);
266        let mut rng = thread_rng();
267        let signed_pubkey = unsigned_pubkey.sign(&mut rng, self, || "".into())?;
268        Ok(signed_pubkey)
269    }
270}
271
272async fn generate_keypair(context: &Context) -> Result<KeyPair> {
273    let addr = context.get_primary_self_addr().await?;
274    let addr = EmailAddress::new(&addr)?;
275    let _guard = context.generating_key_mutex.lock().await;
276
277    // Check if the key appeared while we were waiting on the lock.
278    match load_keypair(context).await? {
279        Some(key_pair) => Ok(key_pair),
280        None => {
281            let start = tools::Time::now();
282            info!(context, "Generating keypair.");
283            let keypair = Handle::current()
284                .spawn_blocking(move || crate::pgp::create_keypair(addr))
285                .await??;
286
287            store_self_keypair(context, &keypair).await?;
288            info!(
289                context,
290                "Keypair generated in {:.3}s.",
291                time_elapsed(&start).as_secs(),
292            );
293            Ok(keypair)
294        }
295    }
296}
297
298pub(crate) async fn load_keypair(context: &Context) -> Result<Option<KeyPair>> {
299    let res = context
300        .sql
301        .query_row_optional(
302            "SELECT public_key, private_key
303             FROM keypairs
304             WHERE id=(SELECT value FROM config WHERE keyname='key_id')",
305            (),
306            |row| {
307                let pub_bytes: Vec<u8> = row.get(0)?;
308                let sec_bytes: Vec<u8> = row.get(1)?;
309                Ok((pub_bytes, sec_bytes))
310            },
311        )
312        .await?;
313
314    Ok(if let Some((pub_bytes, sec_bytes)) = res {
315        Some(KeyPair {
316            public: SignedPublicKey::from_slice(&pub_bytes)?,
317            secret: SignedSecretKey::from_slice(&sec_bytes)?,
318        })
319    } else {
320        None
321    })
322}
323
324/// Store the keypair as an owned keypair for addr in the database.
325///
326/// This will save the keypair as keys for the given address.  The
327/// "self" here refers to the fact that this DC instance owns the
328/// keypair.  Usually `addr` will be [Config::ConfiguredAddr].
329///
330/// If either the public or private keys are already present in the
331/// database, this entry will be removed first regardless of the
332/// address associated with it.  Practically this means saving the
333/// same key again overwrites it.
334///
335/// [Config::ConfiguredAddr]: crate::config::Config::ConfiguredAddr
336pub(crate) async fn store_self_keypair(context: &Context, keypair: &KeyPair) -> Result<()> {
337    let mut config_cache_lock = context.sql.config_cache.write().await;
338    let new_key_id = context
339        .sql
340        .transaction(|transaction| {
341            let public_key = DcKey::to_bytes(&keypair.public);
342            let secret_key = DcKey::to_bytes(&keypair.secret);
343
344            // private_key and public_key columns
345            // are UNIQUE since migration 107,
346            // so this fails if we already have this key.
347            transaction
348                .execute(
349                    "INSERT INTO keypairs (public_key, private_key)
350                     VALUES (?,?)",
351                    (&public_key, &secret_key),
352                )
353                .context("Failed to insert keypair")?;
354
355            let new_key_id = transaction.last_insert_rowid();
356
357            // This will fail if we already have `key_id`.
358            //
359            // Setting default key is only possible if we don't
360            // have a key already.
361            transaction.execute(
362                "INSERT INTO config (keyname, value) VALUES ('key_id', ?)",
363                (new_key_id,),
364            )?;
365            Ok(Some(new_key_id))
366        })
367        .await?;
368
369    if let Some(new_key_id) = new_key_id {
370        // Update config cache if transaction succeeded and changed current default key.
371        config_cache_lock.insert("key_id".to_string(), Some(new_key_id.to_string()));
372    }
373
374    Ok(())
375}
376
377/// Saves a keypair as the default keys.
378///
379/// This API is used for testing purposes
380/// to avoid generating the key in tests.
381/// Use import/export APIs instead.
382pub async fn preconfigure_keypair(context: &Context, secret_data: &str) -> Result<()> {
383    let secret = SignedSecretKey::from_asc(secret_data)?.0;
384    let public = secret.split_public_key()?;
385    let keypair = KeyPair { public, secret };
386    store_self_keypair(context, &keypair).await?;
387    Ok(())
388}
389
390/// A key fingerprint
391#[derive(Clone, Eq, PartialEq, Hash, serde::Serialize, serde::Deserialize)]
392pub struct Fingerprint(Vec<u8>);
393
394impl Fingerprint {
395    /// Creates new 160-bit (20 bytes) fingerprint.
396    pub fn new(v: Vec<u8>) -> Fingerprint {
397        debug_assert_eq!(v.len(), 20);
398        Fingerprint(v)
399    }
400
401    /// Make a hex string from the fingerprint.
402    ///
403    /// Use [std::fmt::Display] or [ToString::to_string] to get a
404    /// human-readable formatted string.
405    pub fn hex(&self) -> String {
406        hex::encode_upper(&self.0)
407    }
408}
409
410impl From<pgp::types::Fingerprint> for Fingerprint {
411    fn from(fingerprint: pgp::types::Fingerprint) -> Fingerprint {
412        Self::new(fingerprint.as_bytes().into())
413    }
414}
415
416impl fmt::Debug for Fingerprint {
417    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
418        f.debug_struct("Fingerprint")
419            .field("hex", &self.hex())
420            .finish()
421    }
422}
423
424/// Make a human-readable fingerprint.
425impl fmt::Display for Fingerprint {
426    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
427        // Split key into chunks of 4 with space and newline at 20 chars
428        for (i, c) in self.hex().chars().enumerate() {
429            if i > 0 && i % 20 == 0 {
430                writeln!(f)?;
431            } else if i > 0 && i % 4 == 0 {
432                write!(f, " ")?;
433            }
434            write!(f, "{c}")?;
435        }
436        Ok(())
437    }
438}
439
440/// Parse a human-readable or otherwise formatted fingerprint.
441impl std::str::FromStr for Fingerprint {
442    type Err = anyhow::Error;
443
444    fn from_str(input: &str) -> Result<Self> {
445        let hex_repr: String = input
446            .to_uppercase()
447            .chars()
448            .filter(|&c| c.is_ascii_hexdigit())
449            .collect();
450        let v: Vec<u8> = hex::decode(&hex_repr)?;
451        ensure!(v.len() == 20, "wrong fingerprint length: {}", hex_repr);
452        let fp = Fingerprint::new(v);
453        Ok(fp)
454    }
455}
456
457#[cfg(test)]
458mod tests {
459    use std::sync::{Arc, LazyLock};
460
461    use super::*;
462    use crate::config::Config;
463    use crate::test_utils::{alice_keypair, TestContext};
464
465    static KEYPAIR: LazyLock<KeyPair> = LazyLock::new(alice_keypair);
466
467    #[test]
468    fn test_from_armored_string() {
469        let (private_key, _) = SignedSecretKey::from_asc(
470            "-----BEGIN PGP PRIVATE KEY BLOCK-----
471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525=KZk/
526-----END PGP PRIVATE KEY BLOCK-----",
527        )
528        .expect("failed to decode");
529        let binary = DcKey::to_bytes(&private_key);
530        SignedSecretKey::from_slice(&binary).expect("invalid private key");
531    }
532
533    #[test]
534    fn test_asc_roundtrip() {
535        let key = KEYPAIR.public.clone();
536        let asc = key.to_asc(Some(("spam", "ham")));
537        let (key2, hdrs) = SignedPublicKey::from_asc(&asc).unwrap();
538        assert_eq!(key, key2);
539        assert_eq!(hdrs.len(), 1);
540        assert_eq!(hdrs.get("spam"), Some(&String::from("ham")));
541
542        let key = KEYPAIR.secret.clone();
543        let asc = key.to_asc(Some(("spam", "ham")));
544        let (key2, hdrs) = SignedSecretKey::from_asc(&asc).unwrap();
545        assert_eq!(key, key2);
546        assert_eq!(hdrs.len(), 1);
547        assert_eq!(hdrs.get("spam"), Some(&String::from("ham")));
548    }
549
550    #[test]
551    fn test_from_slice_roundtrip() {
552        let public_key = KEYPAIR.public.clone();
553        let private_key = KEYPAIR.secret.clone();
554
555        let binary = DcKey::to_bytes(&public_key);
556        let public_key2 = SignedPublicKey::from_slice(&binary).expect("invalid public key");
557        assert_eq!(public_key, public_key2);
558
559        let binary = DcKey::to_bytes(&private_key);
560        let private_key2 = SignedSecretKey::from_slice(&binary).expect("invalid private key");
561        assert_eq!(private_key, private_key2);
562    }
563
564    #[test]
565    fn test_from_slice_bad_data() {
566        let mut bad_data: [u8; 4096] = [0; 4096];
567        for (i, v) in bad_data.iter_mut().enumerate() {
568            *v = (i & 0xff) as u8;
569        }
570        for j in 0..(4096 / 40) {
571            let slice = &bad_data.get(j..j + 4096 / 2 + j).unwrap();
572            assert!(SignedPublicKey::from_slice(slice).is_err());
573            assert!(SignedSecretKey::from_slice(slice).is_err());
574        }
575    }
576
577    /// Tests workaround for Delta Chat core < 1.0.0
578    /// which parsed CRC24 at the end of ASCII Armor
579    /// as the part of the key.
580    /// Depending on the alignment and the number of
581    /// `=` characters at the end of the key,
582    /// this resulted in various number of garbage
583    /// octets at the end of the key, starting from 3 octets,
584    /// but possibly 4 or 5 and maybe more octets
585    /// if the key is imported or transferred
586    /// using Autocrypt Setup Message multiple times.
587    #[test]
588    fn test_ignore_trailing_garbage() {
589        // Test several variants of garbage.
590        for garbage in [
591            b"\x02\xfc\xaa\x38\x4b\x5c".as_slice(),
592            b"\x02\xfc\xaa".as_slice(),
593            b"\x01\x02\x03\x04\x05".as_slice(),
594        ] {
595            let private_key = KEYPAIR.secret.clone();
596
597            let mut binary = DcKey::to_bytes(&private_key);
598            binary.extend(garbage);
599
600            let private_key2 =
601                SignedSecretKey::from_slice(&binary).expect("Failed to ignore garbage");
602
603            assert_eq!(private_key.dc_fingerprint(), private_key2.dc_fingerprint());
604        }
605    }
606
607    #[test]
608    fn test_base64_roundtrip() {
609        let key = KEYPAIR.public.clone();
610        let base64 = key.to_base64();
611        let key2 = SignedPublicKey::from_base64(&base64).unwrap();
612        assert_eq!(key, key2);
613    }
614
615    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
616    async fn test_load_self_generate_public() {
617        let t = TestContext::new().await;
618        t.set_config(Config::ConfiguredAddr, Some("alice@example.org"))
619            .await
620            .unwrap();
621        let key = load_self_public_key(&t).await;
622        assert!(key.is_ok());
623    }
624
625    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
626    async fn test_load_self_generate_secret() {
627        let t = TestContext::new().await;
628        t.set_config(Config::ConfiguredAddr, Some("alice@example.org"))
629            .await
630            .unwrap();
631        let key = load_self_secret_key(&t).await;
632        assert!(key.is_ok());
633    }
634
635    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
636    async fn test_load_self_generate_concurrent() {
637        use std::thread;
638
639        let t = TestContext::new().await;
640        t.set_config(Config::ConfiguredAddr, Some("alice@example.org"))
641            .await
642            .unwrap();
643        let thr0 = {
644            let ctx = t.clone();
645            thread::spawn(move || {
646                tokio::runtime::Runtime::new()
647                    .unwrap()
648                    .block_on(load_self_public_key(&ctx))
649            })
650        };
651        let thr1 = {
652            let ctx = t.clone();
653            thread::spawn(move || {
654                tokio::runtime::Runtime::new()
655                    .unwrap()
656                    .block_on(load_self_public_key(&ctx))
657            })
658        };
659        let res0 = thr0.join().unwrap();
660        let res1 = thr1.join().unwrap();
661        assert_eq!(res0.unwrap(), res1.unwrap());
662    }
663
664    #[test]
665    fn test_split_key() {
666        let pubkey = KEYPAIR.secret.split_public_key().unwrap();
667        assert_eq!(pubkey.primary_key, KEYPAIR.public.primary_key);
668    }
669
670    /// Tests that setting a default key second time is not allowed.
671    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
672    async fn test_save_self_key_twice() {
673        // Saving the same key twice should result in only one row in
674        // the keypairs table.
675        let t = TestContext::new().await;
676        let ctx = Arc::new(t);
677
678        let nrows = || async {
679            ctx.sql
680                .count("SELECT COUNT(*) FROM keypairs;", ())
681                .await
682                .unwrap()
683        };
684        assert_eq!(nrows().await, 0);
685        store_self_keypair(&ctx, &KEYPAIR).await.unwrap();
686        assert_eq!(nrows().await, 1);
687
688        // Saving a second key fails.
689        let res = store_self_keypair(&ctx, &KEYPAIR).await;
690        assert!(res.is_err());
691
692        assert_eq!(nrows().await, 1);
693    }
694
695    #[test]
696    fn test_fingerprint_from_str() {
697        let res = Fingerprint::new(vec![
698            1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
699        ]);
700
701        let fp: Fingerprint = "0102030405060708090A0B0c0d0e0F1011121314".parse().unwrap();
702        assert_eq!(fp, res);
703
704        let fp: Fingerprint = "zzzz 0102 0304 0506\n0708090a0b0c0D0E0F1011121314 yyy"
705            .parse()
706            .unwrap();
707        assert_eq!(fp, res);
708
709        assert!("1".parse::<Fingerprint>().is_err());
710    }
711
712    #[test]
713    fn test_fingerprint_hex() {
714        let fp = Fingerprint::new(vec![
715            1, 2, 4, 8, 16, 32, 64, 128, 255, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
716        ]);
717        assert_eq!(fp.hex(), "0102040810204080FF0A0B0C0D0E0F1011121314");
718    }
719
720    #[test]
721    fn test_fingerprint_to_string() {
722        let fp = Fingerprint::new(vec![
723            1, 2, 4, 8, 16, 32, 64, 128, 255, 1, 2, 4, 8, 16, 32, 64, 128, 255, 19, 20,
724        ]);
725        assert_eq!(
726            fp.to_string(),
727            "0102 0408 1020 4080 FF01\n0204 0810 2040 80FF 1314"
728        );
729    }
730}
deltachat/key.rs

deltachat/
key.rs
