From 7fb4fc0147c44c9e391f3c95be750b1a1a7b0ca4 Mon Sep 17 00:00:00 2001 From: Michael Kuhn Date: Fri, 20 Nov 2026 23:15:54 +0100 Subject: [PATCH 1/2] client, server: Fix padding with OpenSSL backend libsecret sometimes doesn't find stored secrets, for example, when using `git-credential-libsecret`: ``` libsecret-CRITICAL **: secret_value_get_text: assertion 'value' failed libsecret-CRITICAL **: secret_value_unref: assertion 'value != NULL' failed ``` `client/src/crypto/openssl.rs::generate_aes_key()` uses rust-openssl's `Dh::compute_key()`. It allocates a `DH_size()` buffer (128 bytes), calls `DH_compute_key()` and ignores the returned length. `DH_compute_key()` strips leading zero bytes: it moves the secret to the front of the buffer and zero-fills the tail. If the shared secret starts with a zero byte (about 1 in 256), oo7 gets `secret||00`, sees a 128-byte value and adds no padding. libsecret (>= 0.21.8, and gcrypt builds) uses the correct `00||secret`. HKDF then produces different AES keys, and that session can't decrypt anything. `server/src/gnome/crypto/openssl.rs::generate_aes_key_for_secret_exchange()` has the same bug with the 1536-bit group. It's used for the key exchange with the GNOME prompter, so occasionally an unlock prompt probably fails. --- client/src/crypto/openssl.rs | 30 +++++++++++++---------- server/src/gnome/crypto/openssl.rs | 38 ++++++++++++++++++++---------- 2 files changed, 42 insertions(+), 26 deletions(-) diff --git a/client/src/crypto/openssl.rs b/client/src/crypto/openssl.rs index ec7a1ebb..e626050d 100644 --- a/client/src/crypto/openssl.rs +++ b/client/src/crypto/openssl.rs @@ -1,5 +1,5 @@ use openssl::{ - bn::BigNum, + bn::{BigNum, BigNumContext}, dh::Dh, hash::{Hasher, MessageDigest, hash}, md::Md, @@ -108,18 +108,22 @@ pub(crate) fn generate_aes_key( ) -> Result>, super::Error> { let private_key_bn = BigNum::from_slice(private_key.as_ref()).unwrap(); let server_public_key_bn = BigNum::from_slice(server_public_key.as_ref()).unwrap(); - let dh = Dh::from_pqg( - BigNum::get_rfc2409_prime_1024().unwrap(), - None, - BigNum::from_u32(2).unwrap(), - )?; - let mut common_secret_bytes = dh - .set_private_key(private_key_bn)? - .compute_key(&server_public_key_bn)?; - - let mut common_secret_padded = vec![0; 128 - common_secret_bytes.len()]; - // inefficient, but ok for now - common_secret_padded.append(&mut common_secret_bytes); + // Don't use `Dh::compute_key()`: it returns `DH_compute_key()`'s whole + // buffer, in which OpenSSL has moved the secret to the front and appended + // zeros for every stripped leading zero byte. Compute the shared secret + // directly and left-pad it to the length of the prime instead. + let prime = BigNum::get_rfc2409_prime_1024()?; + // Same range check as DH_compute_key(): 1 < y < p - 1 + let one = BigNum::from_u32(1)?; + let mut p_minus_one = BigNum::new()?; + p_minus_one.checked_sub(&prime, &one)?; + if server_public_key_bn <= one || server_public_key_bn >= p_minus_one { + return Err(super::Error::Other("Invalid DH public key".to_owned())); + } + let mut bn_ctx = BigNumContext::new_secure()?; + let mut common_secret = BigNum::new_secure()?; + common_secret.mod_exp(&server_public_key_bn, &private_key_bn, &prime, &mut bn_ctx)?; + let common_secret_padded = Zeroizing::new(common_secret.to_vec_padded(128)?); // hkdf // input_keying_material diff --git a/server/src/gnome/crypto/openssl.rs b/server/src/gnome/crypto/openssl.rs index 40856669..95c01cef 100644 --- a/server/src/gnome/crypto/openssl.rs +++ b/server/src/gnome/crypto/openssl.rs @@ -1,4 +1,10 @@ -use openssl::{bn::BigNum, dh::Dh, md::Md, pkey::Id, pkey_ctx::PkeyCtx}; +use openssl::{ + bn::{BigNum, BigNumContext}, + dh::Dh, + md::Md, + pkey::Id, + pkey_ctx::PkeyCtx, +}; use zeroize::Zeroizing; pub fn generate_public_key_for_secret_exchange( @@ -19,18 +25,24 @@ pub fn generate_aes_key_for_secret_exchange( ) -> Result>, oo7::crypto::Error> { let private_key_bn = BigNum::from_slice(private_key.as_ref()).unwrap(); let server_public_key_bn = BigNum::from_slice(server_public_key.as_ref()).unwrap(); - let dh = Dh::from_pqg( - BigNum::get_rfc3526_prime_1536().unwrap(), - None, - BigNum::from_u32(2).unwrap(), - )?; - let mut common_secret_bytes = Zeroizing::new( - dh.set_private_key(private_key_bn)? - .compute_key(&server_public_key_bn)?, - ); - - let mut common_secret_padded = Zeroizing::new(vec![0; 192 - common_secret_bytes.len()]); - common_secret_padded.append(&mut common_secret_bytes); + // Don't use `Dh::compute_key()`: it returns `DH_compute_key()`'s whole + // buffer, in which OpenSSL has moved the secret to the front and appended + // zeros for every stripped leading zero byte. Compute the shared secret + // directly and left-pad it to the length of the prime instead. + let prime = BigNum::get_rfc3526_prime_1536()?; + // Same range check as DH_compute_key(): 1 < y < p - 1 + let one = BigNum::from_u32(1)?; + let mut p_minus_one = BigNum::new()?; + p_minus_one.checked_sub(&prime, &one)?; + if server_public_key_bn <= one || server_public_key_bn >= p_minus_one { + return Err(oo7::crypto::Error::Other( + "Invalid DH public key".to_owned(), + )); + } + let mut bn_ctx = BigNumContext::new_secure()?; + let mut common_secret = BigNum::new_secure()?; + common_secret.mod_exp(&server_public_key_bn, &private_key_bn, &prime, &mut bn_ctx)?; + let common_secret_padded = Zeroizing::new(common_secret.to_vec_padded(192)?); // hkdf // input_keying_material From 0989e39795caece3fae3ed671c0f6ed3346df81b Mon Sep 17 00:00:00 2001 From: Michael Kuhn Date: Fri, 20 Nov 2026 23:47:22 +0100 Subject: [PATCH 2/2] client, server: Add tests to check correct padding --- client/src/key.rs | 35 +++++++++++++++++++++++++--------- server/src/gnome/crypto/mod.rs | 35 +++++++++++++++++++++++++--------- 2 files changed, 52 insertions(+), 18 deletions(-) diff --git a/client/src/key.rs b/client/src/key.rs index 21b4aae1..9a9f2f8b 100644 --- a/client/src/key.rs +++ b/client/src/key.rs @@ -130,17 +130,19 @@ impl TryFrom for Key { mod tests { use super::*; + const PRIVATE_KEY: [u8; 128] = [ + 41, 20, 63, 236, 246, 132, 109, 70, 172, 121, 45, 66, 129, 21, 247, 91, 96, 217, 56, 201, + 205, 56, 17, 178, 202, 81, 71, 104, 233, 89, 87, 32, 88, 146, 107, 224, 56, 103, 111, 74, + 143, 80, 170, 40, 5, 52, 48, 90, 75, 71, 193, 224, 222, 57, 91, 81, 66, 1, 6, 88, 137, 66, + 102, 207, 55, 95, 67, 92, 140, 227, 242, 153, 185, 195, 89, 236, 146, 242, 88, 215, 1, 7, + 135, 254, 85, 165, 236, 110, 22, 79, 107, 254, 149, 164, 243, 94, 129, 198, 45, 208, 132, + 166, 0, 153, 243, 160, 255, 188, 59, 216, 99, 221, 85, 162, 116, 210, 160, 117, 201, 39, + 179, 123, 107, 8, 242, 139, 207, 250, + ]; + #[test] fn private_public_pair() { - let private_key = Key::new(vec![ - 41, 20, 63, 236, 246, 132, 109, 70, 172, 121, 45, 66, 129, 21, 247, 91, 96, 217, 56, - 201, 205, 56, 17, 178, 202, 81, 71, 104, 233, 89, 87, 32, 88, 146, 107, 224, 56, 103, - 111, 74, 143, 80, 170, 40, 5, 52, 48, 90, 75, 71, 193, 224, 222, 57, 91, 81, 66, 1, 6, - 88, 137, 66, 102, 207, 55, 95, 67, 92, 140, 227, 242, 153, 185, 195, 89, 236, 146, 242, - 88, 215, 1, 7, 135, 254, 85, 165, 236, 110, 22, 79, 107, 254, 149, 164, 243, 94, 129, - 198, 45, 208, 132, 166, 0, 153, 243, 160, 255, 188, 59, 216, 99, 221, 85, 162, 116, - 210, 160, 117, 201, 39, 179, 123, 107, 8, 242, 139, 207, 250, - ]); + let private_key = Key::new(PRIVATE_KEY.to_vec()); let server_public_key = Key::new(vec![ 50, 233, 76, 88, 47, 206, 235, 107, 9, 232, 98, 14, 188, 214, 209, 77, 35, 66, 109, 119, 24, 191, 120, 90, 242, 198, 240, 115, 200, 66, 51, 180, 8, 164, 89, 9, 229, 31, @@ -171,6 +173,21 @@ mod tests { assert_eq!(aes_key.unwrap().as_ref(), expected_aes_key); } + #[test] + fn aes_key_with_leading_zero_in_shared_secret() { + // With this peer public key (179^2, a valid group element), the shared + // secret starts with a zero byte, which has to be kept for HKDF + let private_key = Key::new(PRIVATE_KEY.to_vec()); + let server_public_key = Key::new(vec![125, 41]); + let expected_aes_key = &[ + 45, 9, 43, 36, 239, 251, 6, 77, 119, 146, 59, 198, 169, 6, 54, 11, + ]; + + let aes_key = Key::generate_aes_key(&private_key, &server_public_key); + + assert_eq!(aes_key.unwrap().as_ref(), expected_aes_key); + } + #[test] fn key_debug_is_redacted() { let key = Key::new(vec![1, 2, 3, 4]); diff --git a/server/src/gnome/crypto/mod.rs b/server/src/gnome/crypto/mod.rs index b2c3737c..d6bfb134 100644 --- a/server/src/gnome/crypto/mod.rs +++ b/server/src/gnome/crypto/mod.rs @@ -29,17 +29,19 @@ pub fn generate_aes_key( mod tests { use super::*; + const PRIVATE_KEY: [u8; 128] = [ + 191, 143, 254, 234, 148, 241, 169, 47, 207, 248, 155, 147, 31, 135, 9, 252, 203, 38, 111, + 153, 120, 220, 173, 131, 233, 139, 1, 243, 247, 232, 70, 77, 196, 244, 247, 67, 232, 254, + 100, 194, 155, 37, 248, 243, 70, 206, 170, 133, 192, 248, 253, 74, 74, 194, 238, 165, 102, + 235, 143, 235, 218, 48, 229, 250, 61, 149, 201, 144, 222, 3, 137, 67, 253, 250, 90, 228, + 209, 56, 237, 242, 250, 100, 156, 123, 104, 67, 175, 211, 113, 52, 152, 107, 69, 13, 70, + 30, 89, 146, 193, 149, 62, 100, 247, 37, 57, 44, 71, 49, 101, 29, 80, 151, 240, 155, 160, + 221, 64, 62, 189, 137, 218, 236, 24, 104, 230, 80, 245, 162, + ]; + #[test] fn private_public_pair() { - let private_key = Key::new(vec![ - 191, 143, 254, 234, 148, 241, 169, 47, 207, 248, 155, 147, 31, 135, 9, 252, 203, 38, - 111, 153, 120, 220, 173, 131, 233, 139, 1, 243, 247, 232, 70, 77, 196, 244, 247, 67, - 232, 254, 100, 194, 155, 37, 248, 243, 70, 206, 170, 133, 192, 248, 253, 74, 74, 194, - 238, 165, 102, 235, 143, 235, 218, 48, 229, 250, 61, 149, 201, 144, 222, 3, 137, 67, - 253, 250, 90, 228, 209, 56, 237, 242, 250, 100, 156, 123, 104, 67, 175, 211, 113, 52, - 152, 107, 69, 13, 70, 30, 89, 146, 193, 149, 62, 100, 247, 37, 57, 44, 71, 49, 101, 29, - 80, 151, 240, 155, 160, 221, 64, 62, 189, 137, 218, 236, 24, 104, 230, 80, 245, 162, - ]); + let private_key = Key::new(PRIVATE_KEY.to_vec()); let client_public_key = Key::new(vec![ 90, 240, 105, 52, 245, 225, 112, 238, 63, 100, 6, 129, 215, 27, 199, 53, 210, 16, 60, 140, 121, 222, 20, 224, 196, 152, 123, 154, 90, 212, 82, 183, 160, 222, 206, 83, 74, @@ -73,4 +75,19 @@ mod tests { assert_eq!(public_key.unwrap().as_ref(), expected_public_key); assert_eq!(aes_key.unwrap().as_ref(), expected_aes_key); } + + #[test] + fn aes_key_with_leading_zero_in_shared_secret() { + // With this peer public key (273^2, a valid group element), the shared + // secret starts with a zero byte, which has to be kept for HKDF + let private_key = Key::new(PRIVATE_KEY.to_vec()); + let client_public_key = Key::new(vec![1, 35, 33]); + let expected_aes_key = &[ + 50, 213, 186, 140, 94, 189, 52, 75, 137, 14, 75, 68, 123, 187, 127, 87, + ]; + + let aes_key = generate_aes_key(&private_key, &client_public_key); + + assert_eq!(aes_key.unwrap().as_ref(), expected_aes_key); + } }