The inability to import keys raises suspicions that you are cooperating with intelligence agencies

link2xt · March 2, 2026, 12:15am

For context, the reason for not importing the keys is in FAQ and was already answered at How can I import my keys? and is a follow-up to your other previous topic Could you please comment on this deltachat message?

If you don’t trust the code that generates keys in Delta Chat then it does not matter if you can import your own key anyway because other users of Delta Chat that you communicate with are unlikely to import their own key.

Code that generates keys is fully open source, we use the same random number generator as most of other Rust projects, there is a single line that instantiates it:

github.com/chatmail/core

src/pgp.rs

8df9b9e4d


      
                      SubkeyParamsBuilder::default()
                          .key_type(encryption_key_type)
                          .can_encrypt(EncryptionCaps::All)
                          .passphrase(None)
                          .build()
                          .context("failed to build subkey parameters")?,
                  )
                  .build()
                  .context("failed to build key parameters")?;
          
              let mut rng = thread_rng();
              let secret_key = key_params
                  .generate(&mut rng)
                  .context("Failed to generate the key")?;
              secret_key
                  .verify_bindings()
                  .context("Invalid secret key generated")?;
          
              Ok(secret_key)
          }

OpenPGP is a hybrid cryptosystem, when the message is encrypted it is encrypted with a newly generated symmetric session key and then this session key is encrypted to the recipients OpenPGP keys. So you need to trust the same generator that is used to generate session keys here:

github.com/chatmail/core

src/pgp.rs

8df9b9e4d


      
          pub async fn pk_encrypt(
              plain: Vec<u8>,
              public_keys_for_encryption: Vec<SignedPublicKey>,
              private_key_for_signing: SignedSecretKey,
              compress: bool,
              anonymous_recipients: bool,
              seipd_version: SeipdVersion,
          ) -> Result<String> {
              Handle::current()
                  .spawn_blocking(move || {
                      let mut rng = thread_rng();
          
                      let pkeys = public_keys_for_encryption
                          .iter()
                          .filter_map(select_pk_for_encryption);
                      let subpkts = {
                          let mut hashed = Vec::with_capacity(1 + public_keys_for_encryption.len() + 1);
                          hashed.push(Subpacket::critical(SubpacketData::SignatureCreationTime(
                              pgp::types::Timestamp::now(),
                          ))?);
                          // Test "elena" uses old Delta Chat.

If you don’t trust this generator to generate persistent asymmetric keys, you should not trust it to generate symmetric keys as well, at this point you better not use Delta Chat to encrypt your messages.

All releases of chatmail core are reproducibly built, this includes the binaries used in Delta Chat Desktop downloaded from npm, you can rebuild them with a single nix build command and verify that you get the same binary. For F-Droid builds you can check status here, they build the core from source as well as a part of build process: Delta Chat Reproducibility Status