mcl 0.5.0-alpha

Rust FFI bindings for the MCL pairing-based cryptography.
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
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200

//! Bindings to all functions (WIP) defined in https://github.com/herumi/mcl/blob/master/api.md

use libc::{c_int, size_t};
use std::os::raw::{c_char, c_void};

pub const BN254: i32 = 0;
pub const BLS12_381: i32 = 5;
pub const MCLBN_FR_UNIT_SIZE: i32 = 4;
pub const MCLBN_FP_UNIT_SIZE: i32 = 6;

pub const FR_SIZE: i32 = MCLBN_FR_UNIT_SIZE;
pub const G1_SIZE: i32 = MCLBN_FP_UNIT_SIZE * 3;
pub const G2_SIZE: i32 = MCLBN_FP_UNIT_SIZE * 6;
pub const GT_SIZE: i32 = MCLBN_FP_UNIT_SIZE * 12;

pub const SEC_SIZE: i32 = FR_SIZE * 2;
pub const PUB_SIZE: i32 = G1_SIZE + G2_SIZE;
pub const G1_CIPHER_SIZE: i32 = G1_SIZE * 2;
pub const G2_CIPHER_SIZE: i32 = G2_SIZE * 2;
pub const GT_CIPHER_SIZE: i32 = GT_SIZE * 4;

pub const MCLBN_COMPILED_TIME_VAR: i32 = (MCLBN_FR_UNIT_SIZE * 10) + MCLBN_FP_UNIT_SIZE;


#[link(name = "mclbn384_256")]
extern "C" {
    pub fn mclBn_init(curve: c_int, compiledTimeVar: c_int) -> c_int;
    pub fn mclBnFr_setStr(x: *mut MclBnFr, buf: *const c_char, bufSize: size_t, ioMode: c_int)
        -> c_int;
    pub fn mclBnG1_setStr(x: *mut MclBnG1, buf: *const c_char, bufSize: size_t, ioMode: c_int)
        -> c_int;
    pub fn mclBnG2_setStr(x: *mut MclBnG2, buf: *const c_char, bufSize: size_t, ioMode: c_int)
        -> c_int;
    pub fn mclBnGT_setStr(x: *mut MclBnGT, buf: *const c_char, bufSize: size_t, ioMode: c_int)
        -> c_int;
    pub fn mclBnFr_getStr(
        buf: *mut c_char,
        maxBufSize: size_t,
        x: *const MclBnFr,
        ioMode: c_int,
    ) -> size_t;
    pub fn mclBnG1_getStr(
        buf: *mut c_char,
        maxBufSize: size_t,
        x: *const MclBnG1,
        ioMode: c_int,
    ) -> size_t;
    pub fn mclBnG2_getStr(
        buf: *mut c_char,
        maxBufSize: size_t,
        x: *const MclBnG2,
        ioMode: c_int,
    ) -> size_t;
    pub fn mclBnGT_getStr(
        buf: *mut c_char,
        maxBufSize: size_t,
        x: *const MclBnGT,
        ioMode: c_int,
    ) -> size_t;

    // Hash and map
    pub fn mclBnG1_hashAndMapTo(x: *mut MclBnG1, buf: *const c_void, bufSize: size_t) -> c_int;
    pub fn mclBnG2_hashAndMapTo(x: *mut MclBnG2, buf: *const c_void, bufSize: size_t) -> c_int;

    // Arithmetic operations
    // Multiplication
    pub fn mclBnFr_mul(z: *mut MclBnFr, x: *const MclBnFr, y: *const MclBnFr);
    pub fn mclBnFp_mul(z: *mut MclBnFp, x: *const MclBnFp, y: *const MclBnFp);
    pub fn mclBnFp2_mul(z: *mut MclBnFp2, x: *const MclBnFp2, y: *const MclBnFp2);
    pub fn mclBnGT_mul(z: *mut MclBnGT, x: *const MclBnGT, y: *const MclBnGT);

    // Addition
    pub fn mclBnFr_add(z: *mut MclBnFr, x: *const MclBnFr, y: *const MclBnFr);
    pub fn mclBnFp_add(z: *mut MclBnFp, x: *const MclBnFp, y: *const MclBnFp);
    pub fn mclBnFp2_add(z: *mut MclBnFp2, x: *const MclBnFp2, y: *const MclBnFp2);

    // Division
    pub fn mclBnFr_div(z: *mut MclBnFr, x: *const MclBnFr, y: *const MclBnFr);
    pub fn mclBnFp_div(z: *mut MclBnFp, x: *const MclBnFp, y: *const MclBnFp);
    pub fn mclBnFp2_div(z: *mut MclBnFp2, x: *const MclBnFp2, y: *const MclBnFp2);

    // Substraction
    pub fn mclBnFr_sub(z: *mut MclBnFr, x: *const MclBnFr, y: *const MclBnFr);
    pub fn mclBnFp_sub(z: *mut MclBnFp, x: *const MclBnFp, y: *const MclBnFp);
    pub fn mclBnFp2_sub(z: *mut MclBnFp2, x: *const MclBnFp2, y: *const MclBnFp2);
    pub fn mclBnG1_sub(z: *mut MclBnG1, x: *const MclBnG1, y: *const MclBnG1);
    pub fn mclBnG2_sub(z: *mut MclBnG2, x: *const MclBnG2, y: *const MclBnG2);

    // Inversion
    pub fn mclBnFr_inv(z: *mut MclBnFr, x: *const MclBnFr);
    pub fn mclBnFp_inv(z: *mut MclBnFp, x: *const MclBnFp);
    pub fn mclBnFp2_inv(z: *mut MclBnFp2, x: *const MclBnFp2);

    // Square
    pub fn mclBnFr_sqr(z: *mut MclBnFr, x: *const MclBnFr);
    pub fn mclBnFp_sqr(z: *mut MclBnFp, x: *const MclBnFp);
    pub fn mclBnFp2_sqr(z: *mut MclBnFp2, x: *const MclBnFp2);

    // Negation
    pub fn mclBnFr_neg(z: *mut MclBnFr, x: *const MclBnFr);
    pub fn mclBnFp_neg(z: *mut MclBnFp, x: *const MclBnFp);
    pub fn mclBnFp2_neg(z: *mut MclBnFp2, x: *const MclBnFp2);
    pub fn mclBnG1_neg(z: *mut MclBnG1, x: *const MclBnG1);
    pub fn mclBnG2_neg(z: *mut MclBnG2, x: *const MclBnG2);

    // Point multiplication by scalar
    pub fn mclBnG1_mul(z: *mut MclBnG1, x: *const MclBnG1, y: *const MclBnFr);
    pub fn mclBnG2_mul(z: *mut MclBnG2, x: *const MclBnG2, y: *const MclBnFr);

    // Point addition
    pub fn mclBnG1_add(z: *mut MclBnG1, x: *const MclBnG1, y: *const MclBnG1);
    pub fn mclBnG2_add(z: *mut MclBnG2, x: *const MclBnG2, y: *const MclBnG2);

    // Point double
    pub fn mclBnG1_dbl(z: *mut MclBnG1, x: *const MclBnG1);
    pub fn mclBnG2_dbl(z: *mut MclBnG2, x: *const MclBnG2);

    // GT arithmetic
    pub fn mclBnGT_pow(z: *mut MclBnGT, x: *const MclBnGT, y: *const MclBnFr);

    // equality functions
    pub fn mclBnG1_isEqual(x: *const MclBnG1, y: *const MclBnG1) -> c_int;
    pub fn mclBnG2_isEqual(x: *const MclBnG2, y: *const MclBnG2) -> c_int;
    pub fn mclBnGT_isEqual(x: *const MclBnGT, y: *const MclBnGT) -> c_int;
    pub fn mclBnFp_isEqual(x: *const MclBnFp, y: *const MclBnFp) -> c_int;
    pub fn mclBnFr_isEqual(x: *const MclBnFr, y: *const MclBnFr) -> c_int;
    pub fn mclBnFp2_isEqual(x: *const MclBnFp2, y: *const MclBnFp2) -> c_int;

    // pairing
    pub fn mclBn_pairing(z: *mut MclBnGT, x: *const MclBnG1, y: *const MclBnG2);

    pub fn mclBnFr_setByCSPRNG(x: *mut MclBnFr);
    pub fn mclBnFp_setByCSPRNG(x: *mut MclBnFp);

    // Set to zero
    pub fn mclBnFp_clear(x: *mut MclBnFp);
    pub fn mclBnFr_clear(x: *mut MclBnFr);
    pub fn mclBnFp2_clear(x: *mut MclBnFp2);
    pub fn mclBnG1_clear(x: *mut MclBnG1);
    pub fn mclBnG2_clear(x: *mut MclBnG2);
    pub fn mclBnGT_clear(x: *mut MclBnGT);

    // serialization
    // ret byte count, 0 == error
    pub fn mclBnFr_serialize(buf: *mut c_void, maxBufSize: size_t, x: *const MclBnFr) -> size_t;
    pub fn mclBnG1_serialize(buf: *mut c_void, maxBufSize: size_t, x: *const MclBnG1) -> size_t;
    pub fn mclBnG2_serialize(buf: *mut c_void, maxBufSize: size_t, x: *const MclBnG2) -> size_t;
    pub fn mclBnGT_serialize(buf: *mut c_void, maxBufSize: size_t, x: *const MclBnGT) -> size_t;
    pub fn mclBnFp_serialize(buf: *mut c_void, maxBufSize: size_t, x: *const MclBnFp) -> size_t;
    pub fn mclBnFp2_serialize(buf: *mut c_void, maxBufSize: size_t, x: *const MclBnFp2) -> size_t;

    // deserialization
    // ret byte count, 0 == error
    pub fn mclBnFr_deserialize(x: *mut MclBnFr, buf: *const c_void, bufSize: size_t) -> size_t;
    pub fn mclBnG1_deserialize(x: *mut MclBnG1, buf: *const c_void, bufSize: size_t) -> size_t;
    pub fn mclBnG2_deserialize(x: *mut MclBnG2, buf: *const c_void, bufSize: size_t) -> size_t;
    pub fn mclBnGT_deserialize(x: *mut MclBnGT, buf: *const c_void, bufSize: size_t) -> size_t;
    pub fn mclBnFp_deserialize(x: *mut MclBnFp, buf: *const c_void, bufSize: size_t) -> size_t;
    pub fn mclBnFp2_deserialize(x: *mut MclBnFp2, buf: *const c_void, bufSize: size_t) -> size_t;
}

#[derive(Default, Debug, Clone, Copy)]
#[repr(C)]
pub struct MclBnFp {
    d: [u64; MCLBN_FP_UNIT_SIZE as usize],
}

#[derive(Default, Debug, Clone, Copy)]
#[repr(C)]
pub struct MclBnFp2 {
    d: [MclBnFp; 2],
}

#[derive(Default, Debug, Clone, Copy)]
#[repr(C)]
pub struct MclBnFr {
    d: [u64; MCLBN_FR_UNIT_SIZE as usize],
}

#[derive(Default, Debug, Clone, Copy)]
#[repr(C)]
pub struct MclBnG1 {
    x: MclBnFp,
    y: MclBnFp,
    z: MclBnFp,
}

#[derive(Default, Debug, Clone, Copy)]
#[repr(C)]
pub struct MclBnG2 {
    x: MclBnFp2,
    y: MclBnFp2,
    z: MclBnFp2,
}

#[derive(Default, Debug, Clone, Copy)]
#[repr(C)]
pub struct MclBnGT {
    d: [MclBnFp; 12],
}