kcptun-rust 1.1.0

A Rust implementation of kcptun, a fast and reliable tunnel based on KCP protocol
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

use anyhow::Result;
use pbkdf2::pbkdf2_hmac;
use rust_tokio_kcp::NoneBlockCrypt;
use sha1::Sha1;
use std::sync::Arc;

pub use rust_tokio_kcp::BlockCrypt;

pub const SALT: &[u8] = b"kcp-go";

/// 从密码派生密钥
pub fn derive_key(password: &str) -> Vec<u8> {
    let mut key = vec![0u8; 32];
    pbkdf2_hmac::<Sha1>(password.as_bytes(), SALT, 4096, &mut key);
    key
}

/// 根据加密算法名称和密钥创建加密器
pub fn create_block_crypt(crypt: &str, key: &[u8]) -> Result<Option<Arc<dyn BlockCrypt>>> {
    match crypt.to_lowercase().as_str() {
        "auto" => {
            Ok(None)
        }

        "none" => {
            // 不加密
            let crypt = NoneBlockCrypt::new(b"dummy_key").map_err(|e| anyhow::anyhow!("Failed to create None: {}", e))?;
            Ok(Some(crypt))
        }
        "aes" | "aes-128" => {
            let crypt = rust_tokio_kcp::Aes128BlockCrypt::new(&key[..16])
                .map_err(|e| anyhow::anyhow!("Failed to create AES-128: {}", e))?;
            Ok(Some(Arc::new(crypt)))
        }
        "aes-192" => {
            let crypt = rust_tokio_kcp::Aes192BlockCrypt::new(&key[..24])
                .map_err(|e| anyhow::anyhow!("Failed to create AES-192: {}", e))?;
            Ok(Some(Arc::new(crypt)))
        }
        "aes-256" => {
            let crypt = rust_tokio_kcp::Aes256BlockCrypt::new(&key[..32])
                .map_err(|e| anyhow::anyhow!("Failed to create AES-256: {}", e))?;
            Ok(Some(Arc::new(crypt)))
        }
        "tea" => {
            let crypt = rust_tokio_kcp::TeaBlockCrypt::new(&key[..16])
                .map_err(|e| anyhow::anyhow!("Failed to create TEA: {}", e))?;
            Ok(Some(Arc::new(crypt)))
        }
        "xtea" => {
            let crypt = rust_tokio_kcp::XteaBlockCrypt::new(&key[..16])
                .map_err(|e| anyhow::anyhow!("Failed to create XTEA: {}", e))?;
            Ok(Some(Arc::new(crypt)))
        }
        "xor" | "simple_xor" => {
            let crypt = rust_tokio_kcp::SimpleXorBlockCrypt::new(key)
                .map_err(|e| anyhow::anyhow!("Failed to create SimpleXOR: {}", e))?;
            Ok(Some(Arc::new(crypt)))
        }
        "blowfish" => {
            let crypt = rust_tokio_kcp::BlowfishBlockCrypt::new(key)
                .map_err(|e| anyhow::anyhow!("Failed to create Blowfish: {}", e))?;
            Ok(Some(Arc::new(crypt)))
        }
        "cast5" => {
            let crypt = rust_tokio_kcp::Cast5BlockCrypt::new(&key[..16])
                .map_err(|e| anyhow::anyhow!("Failed to create CAST5: {}", e))?;
            Ok(Some(Arc::new(crypt)))
        }
        "3des" | "triple_des" => {
            let crypt = rust_tokio_kcp::TripleDesBlockCrypt::new(&key[..24])
                .map_err(|e| anyhow::anyhow!("Failed to create 3DES: {}", e))?;
            Ok(Some(Arc::new(crypt)))
        }
        "twofish" => {
            let crypt = rust_tokio_kcp::TwofishBlockCrypt::new(key)
                .map_err(|e| anyhow::anyhow!("Failed to create Twofish: {}", e))?;
            Ok(Some(Arc::new(crypt)))
        }
        "salsa20" => {
            let crypt = rust_tokio_kcp::Salsa20BlockCrypt::new(key)
                .map_err(|e| anyhow::anyhow!("Failed to create Salsa20: {}", e))?;
            Ok(Some(Arc::new(crypt)))
        }
        "sm4" => {
            let crypt = rust_tokio_kcp::Sm4BlockCrypt::new(&key[..16])
                .map_err(|e| anyhow::anyhow!("Failed to create SM4: {}", e))?;
            Ok(Some(Arc::new(crypt)))
        }
        "aes-128-gcm" => {
            let crypt = rust_tokio_kcp::AesGcmBlockCrypt::new(&key[..16])
                .map_err(|e| anyhow::anyhow!("Failed to create AES-128-GCM: {}", e))?;
            Ok(Some(Arc::new(crypt)))
        }
        _ => {
            match key.len(){
                16 => {
                    let crypt = rust_tokio_kcp::Aes128BlockCrypt::new(&key[..16])
                        .map_err(|e| anyhow::anyhow!("Failed to create AES-128: {}", e))?;
                    Ok(Some(Arc::new(crypt)))
                }
                24 => {
                    let crypt = rust_tokio_kcp::Aes192BlockCrypt::new(&key[..24])
                        .map_err(|e| anyhow::anyhow!("Failed to create AES-192: {}", e))?;
                    Ok(Some(Arc::new(crypt)))
                }
                32 => {
                    let crypt = rust_tokio_kcp::Aes256BlockCrypt::new(&key[..32])
                        .map_err(|e| anyhow::anyhow!("Failed to create AES-256: {}", e))?;
                    Ok(Some(Arc::new(crypt)))
                }
                _ => {
                    anyhow::bail!("Unsupported key length: {}", key.len())
                }
            }
            //anyhow::bail!("Unsupported encryption algorithm: {}", crypt)
        }
    }
}