Skip to main content

dm_pure/
crypto.rs

1//! 达梦登录加密(移植自 dm-pure Python 驱动 / dm-go-driver security 包)。
2//!
3//! - DH 密钥交换(固定参数 P/G)
4//! - 会话密钥 = serverPub ^ clientPriv mod P
5//! - 对称加密:DES/AES/3DES + ECB/CBC/CFB/OFB + PKCS5 + 固定 IV + MD5 摘要
6//! - 客户端登录实际使用 `DES_CFB`(算法 ID=132)
7
8use aes::cipher::generic_array::GenericArray;
9use aes::cipher::{BlockDecrypt, BlockEncrypt, KeyInit};
10use aes::{Aes128, Aes192, Aes256};
11use des::{Des, TdesEde3};
12use num_bigint::BigUint;
13use rand::RngCore;
14
15use crate::{DmError, Result};
16
17/// DH 固定参数 P(Go 源码 zzd.go)
18pub const DH_P_HEX: &str = "C009D877BAF5FAF416B7F778E6115DCB90D65217DCC2F08A9DFCB5A192C593EB\
19                           AB02929266B8DBFC2021039FDBD4B7FDE2B996E00008F57AE6EFB4ED3F17B6D3";
20pub const DH_G: u32 = 5;
21pub const DH_KEY_LENGTH: usize = 64;
22
23// 算法 ID(Go 源码 zzd.go)
24pub const WORK_MODE_MASK: u16 = 0x007F;
25pub const ECB_MODE: u16 = 0x1;
26pub const CBC_MODE: u16 = 0x2;
27pub const CFB_MODE: u16 = 0x4;
28pub const OFB_MODE: u16 = 0x8;
29pub const ALGO_MASK: u16 = 0xFF80;
30pub const DES_ID: u16 = 0x0080;
31pub const DES3_ID: u16 = 0x0100;
32pub const AES128: u16 = 0x0200;
33pub const AES192: u16 = 0x0400;
34pub const AES256: u16 = 0x0800;
35pub const RC4: u16 = 0x1000;
36
37/// 用户名密码加密:DES + CFB
38pub const DES_CFB: u16 = 132;
39pub const MD5_DIGEST_SIZE: usize = 16;
40
41/// 固定 IV(Go 源码 zzd.go defaultIV:跳过 0x22,末尾补 0x20)
42pub const DEFAULT_IV: [u8; 32] = [
43    0x20, 0x21, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
44    0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e,
45    0x3f, 0x20,
46];
47
48pub fn dh_p() -> BigUint {
49    BigUint::parse_bytes(DH_P_HEX.as_bytes(), 16).expect("DH_P 解析失败")
50}
51
52/// 生成客户端 DH 密钥对,返回 (私钥 x, 公钥 G^x mod P 的 64 字节大端编码)。
53pub fn new_client_keypair() -> (BigUint, Vec<u8>) {
54    let p = dh_p();
55    let mut buf = [0u8; DH_KEY_LENGTH];
56    rand::thread_rng().fill_bytes(&mut buf);
57    let x = BigUint::from_bytes_be(&buf) % (&p - 1u32) + 1u32;
58    let pub_bn = BigUint::from(DH_G).modpow(&x, &p);
59    (x, bn_to_64_bytes(&pub_bn))
60}
61
62/// 大整数转固定 64 字节大端(Go Bn2Bytes)
63pub fn bn_to_64_bytes(bn: &BigUint) -> Vec<u8> {
64    let raw = bn.to_bytes_be();
65    let mut out = vec![0u8; DH_KEY_LENGTH];
66    let n = raw.len().min(DH_KEY_LENGTH);
67    out[DH_KEY_LENGTH - n..].copy_from_slice(&raw[raw.len() - n..]);
68    out
69}
70
71/// 会话密钥 = serverPub^x mod P(Go Bn2Bytes(bn, 0):不补零,取有效字节)。
72pub fn compute_session_key(client_priv_x: &BigUint, server_pub: &[u8]) -> Vec<u8> {
73    let p = dh_p();
74    let srv = BigUint::from_bytes_be(server_pub);
75    let key = srv.modpow(client_priv_x, &p);
76    key.to_bytes_be()
77}
78
79/// PKCS5 padding(块大小:DES=8 / AES=16)
80pub fn pkcs5_pad(data: &[u8], block_size: usize) -> Vec<u8> {
81    let pad_len = block_size - (data.len() % block_size);
82    let mut out = data.to_vec();
83    out.extend(std::iter::repeat_n(pad_len as u8, pad_len));
84    out
85}
86
87/// PKCS5 unpad
88pub fn pkcs5_unpad(data: &[u8]) -> Result<Vec<u8>> {
89    if data.is_empty() {
90        return Err(DmError::protocol("pkcs5_unpad: 空数据"));
91    }
92    let pad_len = data[data.len() - 1] as usize;
93    if pad_len == 0 || pad_len > data.len() {
94        return Err(DmError::protocol("pkcs5_unpad: 非法填充"));
95    }
96    Ok(data[..data.len() - pad_len].to_vec())
97}
98
99/// 对称加密通道(对应 Go security.SymmCipher)
100pub struct SymmCipher {
101    algo: u16,
102    mode: u16,
103    key: Vec<u8>,
104}
105
106impl SymmCipher {
107    pub fn new(algorithm_id: u16, key: Vec<u8>) -> Self {
108        SymmCipher {
109            algo: algorithm_id & ALGO_MASK,
110            mode: algorithm_id & WORK_MODE_MASK,
111            key,
112        }
113    }
114
115    pub fn block_size(&self) -> usize {
116        match self.algo {
117            DES_ID | DES3_ID => 8,
118            AES128 | AES192 | AES256 => 16,
119            _ => 8,
120        }
121    }
122
123    fn need_padding(&self) -> bool {
124        self.mode == ECB_MODE || self.mode == CBC_MODE
125    }
126
127    /// 加密。`gen_digest=true` 时在尾部附加明文 MD5 摘要(Go 行为)。
128    pub fn encrypt(&self, plaintext: &[u8], gen_digest: bool) -> Result<Vec<u8>> {
129        let data = if self.need_padding() {
130            pkcs5_pad(plaintext, self.block_size())
131        } else {
132            plaintext.to_vec()
133        };
134        let mut ret = self.crypt(&data, true)?;
135        if gen_digest {
136            let digest = md5::compute(plaintext);
137            ret.extend_from_slice(&digest.0);
138        }
139        Ok(ret)
140    }
141
142    /// 解密。`check_digest=true` 时校验尾部 16 字节 MD5 摘要。
143    pub fn decrypt(&self, ciphertext: &[u8], check_digest: bool) -> Result<Vec<u8>> {
144        let (data, digest) = if check_digest {
145            if ciphertext.len() < MD5_DIGEST_SIZE {
146                return Err(DmError::protocol("密文过短,无摘要"));
147            }
148            ciphertext.split_at(ciphertext.len() - MD5_DIGEST_SIZE)
149        } else {
150            (ciphertext, &[][..])
151        };
152        let mut ret = self.crypt(data, false)?;
153        if self.need_padding() {
154            ret = pkcs5_unpad(&ret)?;
155        }
156        if check_digest {
157            let got = md5::compute(&ret);
158            if got.0.as_slice() != digest {
159                return Err(DmError::protocol("MD5 摘要校验失败"));
160            }
161        }
162        Ok(ret)
163    }
164
165    // ---------- 底层块/流加密 ----------
166
167    fn block_encrypt(&self, block: &[u8]) -> Result<Vec<u8>> {
168        match self.algo {
169            DES_ID => Ok(des_crypt(Des::new(GenericArray::from_slice(&self.key[..8])), block, true)),
170            DES3_ID => Ok(des_crypt(TdesEde3::new(GenericArray::from_slice(&self.key[..24])), block, true)),
171            AES128 => Ok(aes_crypt(Aes128::new(GenericArray::from_slice(&self.key[..16])), block, true)),
172            AES192 => Ok(aes_crypt(Aes192::new(GenericArray::from_slice(&self.key[..24])), block, true)),
173            AES256 => Ok(aes_crypt(Aes256::new(GenericArray::from_slice(&self.key[..32])), block, true)),
174            RC4 => Err(DmError::protocol("RC4 未在 Rust 版实现(登录仅用 DES_CFB)")),
175            _ => Err(DmError::protocol(format!("不支持的算法ID: {}", self.algo))),
176        }
177    }
178
179    fn block_decrypt(&self, block: &[u8]) -> Result<Vec<u8>> {
180        match self.algo {
181            DES_ID => Ok(des_crypt(Des::new(GenericArray::from_slice(&self.key[..8])), block, false)),
182            DES3_ID => Ok(des_crypt(TdesEde3::new(GenericArray::from_slice(&self.key[..24])), block, false)),
183            AES128 => Ok(aes_crypt(Aes128::new(GenericArray::from_slice(&self.key[..16])), block, false)),
184            AES192 => Ok(aes_crypt(Aes192::new(GenericArray::from_slice(&self.key[..24])), block, false)),
185            AES256 => Ok(aes_crypt(Aes256::new(GenericArray::from_slice(&self.key[..32])), block, false)),
186            RC4 => Err(DmError::protocol("RC4 未在 Rust 版实现(登录仅用 DES_CFB)")),
187            _ => Err(DmError::protocol(format!("不支持的算法ID: {}", self.algo))),
188        }
189    }
190
191    fn crypt(&self, data: &[u8], encrypt: bool) -> Result<Vec<u8>> {
192        let bs = self.block_size();
193        let iv = DEFAULT_IV[..bs].to_vec();
194        match self.mode {
195            ECB_MODE => {
196                let mut out = Vec::with_capacity(data.len());
197                for chunk in data.chunks(bs) {
198                    let b = if encrypt { self.block_encrypt(chunk)? } else { self.block_decrypt(chunk)? };
199                    out.extend_from_slice(&b);
200                }
201                Ok(out)
202            }
203            CBC_MODE => {
204                let mut out = Vec::with_capacity(data.len());
205                let mut prev = iv;
206                for chunk in data.chunks(bs) {
207                    if encrypt {
208                        let mut block = chunk.to_vec();
209                        for i in 0..bs {
210                            block[i] ^= prev[i];
211                        }
212                        let enc = self.block_encrypt(&block)?;
213                        prev = enc.clone();
214                        out.extend_from_slice(&enc);
215                    } else {
216                        let dec = self.block_decrypt(chunk)?;
217                        let mut d = dec.clone();
218                        for i in 0..bs {
219                            d[i] ^= prev[i];
220                        }
221                        prev = chunk.to_vec();
222                        out.extend_from_slice(&d);
223                    }
224                }
225                Ok(out)
226            }
227            CFB_MODE => {
228                // 标准 CFB(segment=块大小),与 Go cipher.NewCFBEncrypter/Decrypter 一致。
229                // 寄存器始终用密文更新;加解密仅 XOR 方向不同。
230                let mut reg = iv;
231                let mut out = Vec::with_capacity(data.len());
232                for chunk in data.chunks(bs) {
233                    let ks = self.block_encrypt(&reg)?;
234                    let n = chunk.len();
235                    let mut ct = vec![0u8; n];
236                    for i in 0..n {
237                        ct[i] = chunk[i] ^ ks[i];
238                    }
239                    out.extend_from_slice(&ct);
240                    if encrypt {
241                        reg[..n].copy_from_slice(&ct);
242                    } else {
243                        reg[..n].copy_from_slice(chunk);
244                    }
245                    if n < bs {
246                        reg[n..].copy_from_slice(&ks[n..]);
247                    }
248                }
249                Ok(out)
250            }
251            OFB_MODE => {
252                // Output Feedback:keystream 独立于明文,加解密相同
253                let mut ks_reg = iv;
254                let mut out = Vec::with_capacity(data.len());
255                for chunk in data.chunks(bs) {
256                    let next = self.block_encrypt(&ks_reg)?;
257                    for (i, &b) in chunk.iter().enumerate() {
258                        out.push(b ^ next[i]);
259                    }
260                    ks_reg = next[..bs].to_vec();
261                }
262                Ok(out)
263            }
264            _ => Err(DmError::protocol(format!("未实现的模式: {}", self.mode))),
265        }
266    }
267}
268
269fn des_crypt<C: BlockEncrypt + BlockDecrypt>(cipher: C, block: &[u8], encrypt: bool) -> Vec<u8> {
270    let mut b = GenericArray::clone_from_slice(block);
271    if encrypt {
272        cipher.encrypt_block(&mut b);
273    } else {
274        cipher.decrypt_block(&mut b);
275    }
276    b.to_vec()
277}
278
279fn aes_crypt<C: BlockEncrypt + BlockDecrypt>(cipher: C, block: &[u8], encrypt: bool) -> Vec<u8> {
280    let mut b = GenericArray::clone_from_slice(block);
281    if encrypt {
282        cipher.encrypt_block(&mut b);
283    } else {
284        cipher.decrypt_block(&mut b);
285    }
286    b.to_vec()
287}
288
289#[cfg(test)]
290mod tests {
291    use super::*;
292    use num_traits::One;
293
294    #[test]
295    fn des_cfb_matches_python_reference() {
296        // 与 Python dmpy.crypto 参考实现交叉验证(key=0x00..0x3f, IV=DEFAULT_IV[:8])
297        let key: Vec<u8> = (0u8..64).collect();
298        let c = SymmCipher::new(DES_CFB, key);
299        assert_eq!(c.encrypt(b"SYSDBA", false).unwrap().hex(), "c67b0c7a4a04");
300        assert_eq!(c.encrypt(b"password", false).unwrap().hex(), "e5432c4d7f2a6eb6");
301        assert_eq!(c.encrypt(b"12345678", false).unwrap().hex(), "a4106c0a3d732bea");
302        assert_eq!(c.encrypt(b"123456789", false).unwrap().hex(), "a4106c0a3d732bea3c");
303    }
304
305    #[test]
306    fn des_cfb_digest_roundtrip() {
307        let key: Vec<u8> = (0u8..64).collect();
308        let c = SymmCipher::new(DES_CFB, key);
309        let ct = c.encrypt(b"hello world", true).unwrap();
310        assert_eq!(
311            ct.hex(),
312            "fd47335267656bbd6bbf765eb63bbbe01eeed093cb22bb8f5acdc3"
313        );
314        assert_eq!(c.decrypt(&ct, true).unwrap(), b"hello world");
315    }
316
317    #[test]
318    fn dh_keypair_size() {
319        let (_x, pub_bn) = new_client_keypair();
320        assert_eq!(pub_bn.len(), 64);
321        // 公钥值域应在 (1, P)
322        let p = dh_p();
323        let val = BigUint::from_bytes_be(&pub_bn);
324        assert!(val > BigUint::one() && val < p);
325    }
326
327    #[test]
328    fn dh_session_key_symmetry() {
329        // 双方各自计算出的会话密钥应一致
330        let (xa, pub_a) = new_client_keypair();
331        let (xb, pub_b) = new_client_keypair();
332        let k1 = compute_session_key(&xa, &pub_b);
333        let k2 = compute_session_key(&xb, &pub_a);
334        assert_eq!(k1, k2);
335    }
336
337    #[test]
338    fn aes_modes_roundtrip() {
339        let key = vec![0x42u8; 32];
340        for (algo, mode) in [(AES128, CBC_MODE), (AES256, ECB_MODE), (AES128, CFB_MODE), (AES128, OFB_MODE)] {
341            let c = SymmCipher::new(algo | mode, key.clone());
342            let ct = c.encrypt(b"aes mode roundtrip data!", true).unwrap();
343            let pt = c.decrypt(&ct, true).unwrap();
344            assert_eq!(pt, b"aes mode roundtrip data!", "algo={algo} mode={mode}");
345        }
346    }
347
348    #[test]
349    fn des_modes_roundtrip() {
350        let key = vec![0x11u8; 64];
351        for mode in [ECB_MODE, CBC_MODE, CFB_MODE, OFB_MODE] {
352            let c = SymmCipher::new(DES_ID | mode, key.clone());
353            let ct = c.encrypt(b"des mode roundtrip!", true).unwrap();
354            let pt = c.decrypt(&ct, true).unwrap();
355            assert_eq!(pt, b"des mode roundtrip!", "mode={mode}");
356        }
357    }
358
359    trait Hex {
360        fn hex(&self) -> String;
361    }
362    impl Hex for [u8] {
363        fn hex(&self) -> String {
364            self.iter().map(|b| format!("{b:02x}")).collect()
365        }
366    }
367}