1use 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
17pub const DH_P_HEX: &str = "C009D877BAF5FAF416B7F778E6115DCB90D65217DCC2F08A9DFCB5A192C593EB\
19 AB02929266B8DBFC2021039FDBD4B7FDE2B996E00008F57AE6EFB4ED3F17B6D3";
20pub const DH_G: u32 = 5;
21pub const DH_KEY_LENGTH: usize = 64;
22
23pub 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
37pub const DES_CFB: u16 = 132;
39pub const MD5_DIGEST_SIZE: usize = 16;
40
41pub 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
52pub 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
62pub 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
71pub 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
79pub 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
87pub 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
99pub 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 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 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 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 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(®)?;
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 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 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 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 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}