ntru 0.5.6

Implementation of the NTRUEncrypt algorithm. Interface to libntru. 
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

use libc::{uint16_t, int16_t, uint8_t};

use encparams::EncParams;
use types::{IntPoly, ProdPoly, TernPoly, KeyPair, PrivPoly, PublicKey, PrivateKey};
use rand::{RandContext, RandGen};

extern "C" {
    // ntru.h
    pub fn ntru_gen_key_pair(params: *const EncParams,
                             kp: *mut KeyPair,
                             rand_ctx: *const RandContext)
                             -> uint8_t;
    pub fn ntru_gen_key_pair_multi(params: *const EncParams,
                                   private: *mut PrivateKey,
                                   public: *mut PublicKey,
                                   rand_ctx: *const RandContext,
                                   num_pub: u32)
                                   -> uint8_t;
    pub fn ntru_gen_pub(params: *const EncParams,
                        private: *const PrivateKey,
                        public: *mut PublicKey,
                        rand_ctx: *const RandContext)
                        -> uint8_t;
    pub fn ntru_encrypt(msg: *const uint8_t,
                        msg_len: uint16_t,
                        public: *const PublicKey,
                        params: *const EncParams,
                        rand_ctx: *const RandContext,
                        enc: *mut uint8_t)
                        -> uint8_t;
    pub fn ntru_decrypt(enc: *const uint8_t,
                        kp: *const KeyPair,
                        params: *const EncParams,
                        dec: *mut uint8_t,
                        dec_len: *mut uint16_t)
                        -> uint8_t;

    // hash.h
    pub fn ntru_sha1(input: *const uint8_t, input_len: uint16_t, digest: *mut uint8_t);
    pub fn ntru_sha1_4way(input: *const *const uint8_t,
                          input_len: uint16_t,
                          digest: *mut *mut uint8_t);
    pub fn ntru_sha1_8way(input: *const *const uint8_t,
                          input_len: uint16_t,
                          digest: *mut *mut uint8_t);
    pub fn ntru_sha256(input: *const uint8_t, input_len: uint16_t, digest: *mut uint8_t);
    pub fn ntru_sha256_4way(input: *const *const uint8_t,
                            input_len: uint16_t,
                            digest: *mut *mut uint8_t);
    pub fn ntru_sha256_8way(input: *const *const uint8_t,
                            input_len: uint16_t,
                            digest: *mut *mut uint8_t);

    // rand.h
    pub fn ntru_rand_init(rand_ctx: *mut RandContext, rand_gen: *const RandGen) -> uint8_t;
    pub fn ntru_rand_init_det(rand_ctx: *mut RandContext,
                              rand_gen: *const RandGen,
                              seed: *const uint8_t,
                              seed_len: uint16_t)
                              -> uint8_t;
    pub fn ntru_rand_generate(rand_data: *mut uint8_t,
                              len: uint16_t,
                              rand_ctx: *const RandContext)
                              -> uint8_t;
    pub fn ntru_rand_release(rand_ctx: *mut RandContext) -> uint8_t;

    #[cfg(target_os = "windows")]
    pub fn ntru_rand_wincrypt_init(rand_ctx: *mut RandContext,
                                   rand_gen: *const RandGen)
                                   -> uint8_t;
    #[cfg(target_os = "windows")]
    pub fn ntru_rand_wincrypt_generate(rand_data: *mut uint8_t,
                                       len: uint16_t,
                                       rand_ctx: *const RandContext)
                                       -> uint8_t;
    #[cfg(target_os = "windows")]
    pub fn ntru_rand_wincrypt_release(rand_ctx: *mut RandContext) -> uint8_t;

    #[cfg(not(target_os = "windows"))]
    pub fn ntru_rand_devrandom_init(rand_ctx: *mut RandContext,
                                    rand_gen: *const RandGen)
                                    -> uint8_t;
    #[cfg(not(target_os = "windows"))]
    pub fn ntru_rand_devrandom_generate(rand_data: *mut uint8_t,
                                        len: uint16_t,
                                        rand_ctx: *const RandContext)
                                        -> uint8_t;
    #[cfg(not(target_os = "windows"))]
    pub fn ntru_rand_devrandom_release(rand_ctx: *mut RandContext) -> uint8_t;

    #[cfg(not(target_os = "windows"))]
    pub fn ntru_rand_devurandom_init(rand_ctx: *mut RandContext,
                                     rand_gen: *const RandGen)
                                     -> uint8_t;
    #[cfg(not(target_os = "windows"))]
    pub fn ntru_rand_devurandom_generate(rand_data: *mut uint8_t,
                                         len: uint16_t,
                                         rand_ctx: *const RandContext)
                                         -> uint8_t;
    #[cfg(not(target_os = "windows"))]
    pub fn ntru_rand_devurandom_release(rand_ctx: *mut RandContext) -> uint8_t;

    pub fn ntru_rand_default_init(rand_ctx: *mut RandContext, rand_gen: *const RandGen) -> uint8_t;
    pub fn ntru_rand_default_generate(rand_data: *mut uint8_t,
                                      len: uint16_t,
                                      rand_ctx: *const RandContext)
                                      -> uint8_t;
    pub fn ntru_rand_default_release(rand_ctx: *mut RandContext) -> uint8_t;

    pub fn ntru_rand_ctr_drbg_init(rand_ctx: *mut RandContext,
                                   rand_gen: *const RandGen)
                                   -> uint8_t;
    pub fn ntru_rand_ctr_drbg_generate(rand_data: *mut uint8_t,
                                       len: uint16_t,
                                       rand_ctx: *const RandContext)
                                       -> uint8_t;
    pub fn ntru_rand_ctr_drbg_release(rand_ctx: *mut RandContext) -> uint8_t;

    // poly.h
    pub fn ntru_rand_tern(n: uint16_t,
                          num_ones: uint16_t,
                          num_neg_ones: uint16_t,
                          poly: *mut TernPoly,
                          rand_ctx: *const RandContext)
                          -> uint8_t;
    pub fn ntru_mult_tern(a: *const IntPoly,
                          b: *const TernPoly,
                          c: *mut IntPoly,
                          mod_mask: uint16_t)
                          -> uint8_t;
    pub fn ntru_mult_prod(a: *const IntPoly,
                          b: *const ProdPoly,
                          c: *mut IntPoly,
                          mod_mask: uint16_t)
                          -> uint8_t;
    pub fn ntru_mult_priv(a: *const PrivPoly,
                          b: *const IntPoly,
                          c: *mut IntPoly,
                          mod_mask: uint16_t)
                          -> uint8_t;
    pub fn ntru_mult_int(a: *const IntPoly,
                         b: *const IntPoly,
                         c: *mut IntPoly,
                         mod_mask: uint16_t)
                         -> uint8_t;
    pub fn ntru_add(a: *mut IntPoly, b: *const IntPoly);
    pub fn ntru_sub(a: *mut IntPoly, b: *const IntPoly);
    pub fn ntru_mod_mask(p: *mut IntPoly, mod_mask: uint16_t);
    pub fn ntru_mult_fac(a: *mut IntPoly, factor: int16_t);
    pub fn ntru_mod_center(p: *mut IntPoly, modulus: uint16_t);
    pub fn ntru_mod3(p: *mut IntPoly);
    pub fn ntru_to_arr(p: *const IntPoly, q: uint16_t, a: *mut uint8_t);
    pub fn ntru_from_arr(arr: *const uint8_t, n: uint16_t, q: uint16_t, p: *mut IntPoly);
    pub fn ntru_invert(a: *const PrivPoly, mod_mask: uint16_t, fq: *mut IntPoly) -> uint8_t;

    // key.h
    pub fn ntru_export_pub(key: *const PublicKey, arr: *mut uint8_t);
    pub fn ntru_import_pub(arr: *const uint8_t, key: *mut PublicKey) -> uint16_t;

    pub fn ntru_export_priv(key: *const PrivateKey, arr: *mut uint8_t) -> uint16_t;
    pub fn ntru_import_priv(arr: *const uint8_t, key: *mut PrivateKey);

    pub fn ntru_params_from_priv_key(key: *const PrivateKey, params: *mut EncParams) -> uint8_t;
}