shadowsocks-crypto 0.7.0

Shadowsocks Crypto
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

#![allow(dead_code)]

use camellia::{
    cipher::{Block, BlockDecrypt, BlockEncrypt, BlockSizeUser, KeyInit, KeySizeUser, Unsigned},
    Camellia128 as CryptoCamellia128,
    Camellia192 as CryptoCamellia192,
    Camellia256 as CryptoCamellia256,
};

#[derive(Debug, Clone)]
pub struct Camellia128(CryptoCamellia128);

impl Camellia128 {
    pub const BLOCK_LEN: usize = <CryptoCamellia128 as BlockSizeUser>::BlockSize::USIZE;
    pub const KEY_LEN: usize = <CryptoCamellia128 as KeySizeUser>::KeySize::USIZE;

    pub fn new(key: &[u8]) -> Camellia128 {
        Camellia128(CryptoCamellia128::new_from_slice(key).expect("Camellia128"))
    }

    pub fn encrypt(&self, block: &mut [u8]) {
        let block = Block::<CryptoCamellia128>::from_mut_slice(block);
        self.0.encrypt_block(block);
    }

    pub fn decrypt(&self, block: &mut [u8]) {
        let block = Block::<CryptoCamellia128>::from_mut_slice(block);
        self.0.decrypt_block(block);
    }
}

#[derive(Debug, Clone)]
pub struct Camellia192(CryptoCamellia192);

impl Camellia192 {
    pub const BLOCK_LEN: usize = <CryptoCamellia192 as BlockSizeUser>::BlockSize::USIZE;
    pub const KEY_LEN: usize = <CryptoCamellia192 as KeySizeUser>::KeySize::USIZE;

    pub fn new(key: &[u8]) -> Camellia192 {
        Camellia192(CryptoCamellia192::new_from_slice(key).expect("Camellia192"))
    }

    pub fn encrypt(&self, block: &mut [u8]) {
        let block = Block::<CryptoCamellia192>::from_mut_slice(block);
        self.0.encrypt_block(block);
    }

    pub fn decrypt(&self, block: &mut [u8]) {
        let block = Block::<CryptoCamellia192>::from_mut_slice(block);
        self.0.decrypt_block(block);
    }
}

#[derive(Debug, Clone)]
pub struct Camellia256(CryptoCamellia256);

impl Camellia256 {
    pub const BLOCK_LEN: usize = <CryptoCamellia256 as BlockSizeUser>::BlockSize::USIZE;
    pub const KEY_LEN: usize = <CryptoCamellia256 as KeySizeUser>::KeySize::USIZE;

    pub fn new(key: &[u8]) -> Camellia256 {
        Camellia256(CryptoCamellia256::new_from_slice(key).expect("Camellia256"))
    }

    pub fn encrypt(&self, block: &mut [u8]) {
        let block = Block::<CryptoCamellia256>::from_mut_slice(block);
        self.0.encrypt_block(block);
    }

    pub fn decrypt(&self, block: &mut [u8]) {
        let block = Block::<CryptoCamellia256>::from_mut_slice(block);
        self.0.decrypt_block(block);
    }
}