aria 0.2.0

Pure Rust implementation of the ARIA Encryption Algorithm
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

use crate::{
    Aria256,
    consts::{C1, C2, C3},
    utils::{a, fe, fo},
};
use cipher::{AlgorithmName, Key, KeyInit, KeySizeUser, consts::U32};
use core::fmt;

impl KeySizeUser for Aria256 {
    type KeySize = U32;
}

impl KeyInit for Aria256 {
    fn new(key: &Key<Self>) -> Self {
        let kl = u128::from_be_bytes(key[0..16].try_into().unwrap());
        let kr = u128::from_be_bytes(key[16..32].try_into().unwrap());

        let w0 = kl;
        let w1 = fo(w0 ^ C3) ^ kr;
        let w2 = fe(w1 ^ C1) ^ w0;
        let w3 = fo(w2 ^ C2) ^ w1;

        let ek = [
            w0 ^ w1.rotate_right(19),
            w1 ^ w2.rotate_right(19),
            w2 ^ w3.rotate_right(19),
            w3 ^ w0.rotate_right(19),
            w0 ^ w1.rotate_right(31),
            w1 ^ w2.rotate_right(31),
            w2 ^ w3.rotate_right(31),
            w3 ^ w0.rotate_right(31),
            w0 ^ w1.rotate_left(61),
            w1 ^ w2.rotate_left(61),
            w2 ^ w3.rotate_left(61),
            w3 ^ w0.rotate_left(61),
            w0 ^ w1.rotate_left(31),
            w1 ^ w2.rotate_left(31),
            w2 ^ w3.rotate_left(31),
            w3 ^ w0.rotate_left(31),
            w0 ^ w1.rotate_left(19),
        ];

        let dk = [
            ek[16],
            a(ek[15]),
            a(ek[14]),
            a(ek[13]),
            a(ek[12]),
            a(ek[11]),
            a(ek[10]),
            a(ek[9]),
            a(ek[8]),
            a(ek[7]),
            a(ek[6]),
            a(ek[5]),
            a(ek[4]),
            a(ek[3]),
            a(ek[2]),
            a(ek[1]),
            ek[0],
        ];

        Self { ek, dk }
    }
}

impl fmt::Debug for Aria256 {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str("Aria256 { ... }")
    }
}

impl AlgorithmName for Aria256 {
    fn write_alg_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str("Aria256")
    }
}