aegis 0.9.9

AEGIS authenticated ciphers (AEGIS-128, AEGIS-256, AEGIS-128X, AEGIS-256X)
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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

use core::ffi::c_int;

use super::ffi;

mod sealed {
    pub trait Sealed {}
}

pub trait Algorithm: sealed::Sealed {
    type Key: AsRef<[u8]>;
    const ALG_ID: u8;

    unsafe fn ffi_scratch_size(chunk_size: u32) -> usize;
    unsafe fn ffi_create(
        ctx: *mut u8,
        io: *const ffi::aegis_raf_io,
        rng: *const ffi::aegis_raf_rng,
        cfg: *const ffi::aegis_raf_config,
        key: *const u8,
    ) -> c_int;
    unsafe fn ffi_open(
        ctx: *mut u8,
        io: *const ffi::aegis_raf_io,
        rng: *const ffi::aegis_raf_rng,
        cfg: *const ffi::aegis_raf_config,
        key: *const u8,
    ) -> c_int;
    unsafe fn ffi_read(
        ctx: *mut u8,
        out: *mut u8,
        bytes_read: *mut usize,
        len: usize,
        offset: u64,
    ) -> c_int;
    unsafe fn ffi_write(
        ctx: *mut u8,
        bytes_written: *mut usize,
        data: *const u8,
        len: usize,
        offset: u64,
    ) -> c_int;
    unsafe fn ffi_truncate(ctx: *mut u8, size: u64) -> c_int;
    unsafe fn ffi_get_size(ctx: *const u8, size: *mut u64) -> c_int;
    unsafe fn ffi_sync(ctx: *mut u8) -> c_int;
    unsafe fn ffi_close(ctx: *mut u8);
    unsafe fn ffi_merkle_rebuild(ctx: *mut u8) -> c_int;
    unsafe fn ffi_merkle_verify(ctx: *mut u8, corrupted: *mut u64) -> c_int;
    unsafe fn ffi_merkle_commitment(ctx: *const u8, out: *mut u8, len: usize) -> c_int;
}

macro_rules! impl_algorithm {
    ($name:ident, $key_len:literal, $alg_id:literal, $prefix:ident, $ctx:ident) => {
        pub struct $name;

        impl sealed::Sealed for $name {}

        impl Algorithm for $name {
            type Key = [u8; $key_len];
            const ALG_ID: u8 = $alg_id;

            unsafe fn ffi_scratch_size(chunk_size: u32) -> usize {
                paste::paste! { ffi::[<$prefix _raf_scratch_size>](chunk_size) }
            }

            unsafe fn ffi_create(
                ctx: *mut u8,
                io: *const ffi::aegis_raf_io,
                rng: *const ffi::aegis_raf_rng,
                cfg: *const ffi::aegis_raf_config,
                key: *const u8,
            ) -> c_int {
                paste::paste! { ffi::[<$prefix _raf_create>](ctx as *mut ffi::$ctx, io, rng, cfg, key) }
            }

            unsafe fn ffi_open(
                ctx: *mut u8,
                io: *const ffi::aegis_raf_io,
                rng: *const ffi::aegis_raf_rng,
                cfg: *const ffi::aegis_raf_config,
                key: *const u8,
            ) -> c_int {
                paste::paste! { ffi::[<$prefix _raf_open>](ctx as *mut ffi::$ctx, io, rng, cfg, key) }
            }

            unsafe fn ffi_read(
                ctx: *mut u8,
                out: *mut u8,
                bytes_read: *mut usize,
                len: usize,
                offset: u64,
            ) -> c_int {
                paste::paste! { ffi::[<$prefix _raf_read>](ctx as *mut ffi::$ctx, out, bytes_read, len, offset) }
            }

            unsafe fn ffi_write(
                ctx: *mut u8,
                bytes_written: *mut usize,
                data: *const u8,
                len: usize,
                offset: u64,
            ) -> c_int {
                paste::paste! { ffi::[<$prefix _raf_write>](ctx as *mut ffi::$ctx, bytes_written, data, len, offset) }
            }

            unsafe fn ffi_truncate(ctx: *mut u8, size: u64) -> c_int {
                paste::paste! { ffi::[<$prefix _raf_truncate>](ctx as *mut ffi::$ctx, size) }
            }

            unsafe fn ffi_get_size(ctx: *const u8, size: *mut u64) -> c_int {
                paste::paste! { ffi::[<$prefix _raf_get_size>](ctx as *const ffi::$ctx, size) }
            }

            unsafe fn ffi_sync(ctx: *mut u8) -> c_int {
                paste::paste! { ffi::[<$prefix _raf_sync>](ctx as *mut ffi::$ctx) }
            }

            unsafe fn ffi_close(ctx: *mut u8) {
                paste::paste! { ffi::[<$prefix _raf_close>](ctx as *mut ffi::$ctx) }
            }

            unsafe fn ffi_merkle_rebuild(ctx: *mut u8) -> c_int {
                paste::paste! { ffi::[<$prefix _raf_merkle_rebuild>](ctx as *mut ffi::$ctx) }
            }

            unsafe fn ffi_merkle_verify(ctx: *mut u8, corrupted: *mut u64) -> c_int {
                paste::paste! { ffi::[<$prefix _raf_merkle_verify>](ctx as *mut ffi::$ctx, corrupted) }
            }

            unsafe fn ffi_merkle_commitment(ctx: *const u8, out: *mut u8, len: usize) -> c_int {
                paste::paste! { ffi::[<$prefix _raf_merkle_commitment>](ctx as *const ffi::$ctx, out, len) }
            }
        }
    };
}

impl_algorithm!(Aegis128L, 16, 1, aegis128l, aegis128l_raf_ctx);
impl_algorithm!(Aegis128X2, 16, 2, aegis128x2, aegis128x2_raf_ctx);
impl_algorithm!(Aegis128X4, 16, 3, aegis128x4, aegis128x4_raf_ctx);
impl_algorithm!(Aegis256, 32, 4, aegis256, aegis256_raf_ctx);
impl_algorithm!(Aegis256X2, 32, 5, aegis256x2, aegis256x2_raf_ctx);
impl_algorithm!(Aegis256X4, 32, 6, aegis256x4, aegis256x4_raf_ctx);