XS tuning
Karel Miko
6 years ago
11 | 11 | #include "tomcrypt.h" |
12 | 12 | #include "tommath.h" |
13 | 13 | |
14 | typedef adler32_state *Crypt__Checksum__Adler32; | |
15 | typedef crc32_state *Crypt__Checksum__CRC32; | |
14 | typedef adler32_state *Crypt__Checksum__Adler32; | |
15 | typedef crc32_state *Crypt__Checksum__CRC32; | |
16 | ||
17 | typedef ccm_state *Crypt__AuthEnc__CCM; | |
18 | typedef eax_state *Crypt__AuthEnc__EAX; | |
19 | typedef gcm_state *Crypt__AuthEnc__GCM; | |
20 | typedef chacha20poly1305_state *Crypt__AuthEnc__ChaCha20Poly1305; | |
21 | typedef ocb3_state *Crypt__AuthEnc__OCB; | |
22 | ||
23 | typedef chacha_state *Crypt__Stream__ChaCha; | |
24 | typedef salsa20_state *Crypt__Stream__Salsa20; | |
25 | typedef sosemanuk_state *Crypt__Stream__Sosemanuk; | |
26 | typedef rabbit_state *Crypt__Stream__Rabbit; | |
27 | typedef rc4_state *Crypt__Stream__RC4; | |
28 | typedef sober128_state *Crypt__Stream__Sober128; | |
29 | ||
30 | typedef f9_state *Crypt__Mac__F9; | |
31 | typedef hmac_state *Crypt__Mac__HMAC; | |
32 | typedef omac_state *Crypt__Mac__OMAC; | |
33 | typedef pelican_state *Crypt__Mac__Pelican; | |
34 | typedef pmac_state *Crypt__Mac__PMAC; | |
35 | typedef xcbc_state *Crypt__Mac__XCBC; | |
36 | typedef poly1305_state *Crypt__Mac__Poly1305; | |
37 | typedef blake2smac_state *Crypt__Mac__BLAKE2s; | |
38 | typedef blake2bmac_state *Crypt__Mac__BLAKE2b; | |
16 | 39 | |
17 | 40 | typedef struct cipher_struct { /* used by Crypt::Cipher */ |
18 | 41 | symmetric_key skey; |
19 | int id; | |
20 | 42 | struct ltc_cipher_descriptor *desc; |
21 | 43 | } *Crypt__Cipher; |
22 | 44 | |
23 | 45 | typedef struct digest_struct { /* used by Crypt::Digest */ |
24 | 46 | hash_state state; |
25 | int id; | |
26 | 47 | struct ltc_hash_descriptor *desc; |
27 | 48 | } *Crypt__Digest; |
28 | 49 | |
31 | 52 | int num; |
32 | 53 | } *Crypt__Digest__SHAKE; |
33 | 54 | |
34 | typedef struct ccm_struct { /* used by Crypt::AuthEnc::CCM */ | |
35 | ccm_state state; | |
36 | int direction; | |
37 | int tag_len; | |
38 | unsigned long pt_len; | |
39 | int id; | |
40 | } *Crypt__AuthEnc__CCM; | |
41 | ||
42 | typedef struct eax_struct { /* used by Crypt::AuthEnc::EAX */ | |
43 | eax_state state; | |
44 | int id; | |
45 | } *Crypt__AuthEnc__EAX; | |
46 | ||
47 | typedef struct gcm_struct { /* used by Crypt::AuthEnc::GCM */ | |
48 | gcm_state state; | |
49 | int id; | |
50 | } *Crypt__AuthEnc__GCM; | |
51 | ||
52 | typedef struct chacha20poly1305_struct {/* used by Crypt::AuthEnc::ChaCha20Poly1305 */ | |
53 | chacha20poly1305_state state; | |
54 | int id; | |
55 | } *Crypt__AuthEnc__ChaCha20Poly1305; | |
56 | ||
57 | typedef struct ocb_struct { /* used by Crypt::AuthEnc::OCB */ | |
58 | ocb3_state state; | |
59 | int id; | |
60 | } *Crypt__AuthEnc__OCB; | |
61 | ||
62 | typedef struct chacha_struct { /* used by Crypt::Stream::ChaCha */ | |
63 | chacha_state state; | |
64 | int id; | |
65 | } *Crypt__Stream__ChaCha; | |
66 | ||
67 | typedef struct salsa20_struct { /* used by Crypt::Stream::Salsa20 */ | |
68 | salsa20_state state; | |
69 | int id; | |
70 | } *Crypt__Stream__Salsa20; | |
71 | ||
72 | typedef struct sosemanuk_struct { /* used by Crypt::Stream::Sosemanuk */ | |
73 | sosemanuk_state state; | |
74 | int id; | |
75 | } *Crypt__Stream__Sosemanuk; | |
76 | ||
77 | typedef struct rabbit_struct { /* used by Crypt::Stream::Rabbit */ | |
78 | rabbit_state state; | |
79 | int id; | |
80 | } *Crypt__Stream__Rabbit; | |
81 | ||
82 | typedef struct rc4_struct { /* used by Crypt::Stream::RC4 */ | |
83 | rc4_state state; | |
84 | int id; | |
85 | } *Crypt__Stream__RC4; | |
86 | ||
87 | typedef struct sober128_struct { /* used by Crypt::Stream::Sober128 */ | |
88 | sober128_state state; | |
89 | int id; | |
90 | } *Crypt__Stream__Sober128; | |
91 | ||
92 | typedef struct f9_struct { /* used by Crypt::Mac::F9 */ | |
93 | f9_state state; | |
94 | int id; | |
95 | } *Crypt__Mac__F9; | |
96 | ||
97 | typedef struct hmac_struct { /* used by Crypt::Mac::HMAC */ | |
98 | hmac_state state; | |
99 | int id; | |
100 | } *Crypt__Mac__HMAC; | |
101 | ||
102 | typedef struct omac_struct { /* used by Crypt::Mac::OMAC */ | |
103 | omac_state state; | |
104 | int id; | |
105 | } *Crypt__Mac__OMAC; | |
106 | ||
107 | typedef struct pelican_struct { /* used by Crypt::Mac::Pelican */ | |
108 | pelican_state state; | |
109 | int id; | |
110 | } *Crypt__Mac__Pelican; | |
111 | ||
112 | typedef struct pmac_struct { /* used by Crypt::Mac::PMAC */ | |
113 | pmac_state state; | |
114 | int id; | |
115 | } *Crypt__Mac__PMAC; | |
116 | ||
117 | typedef struct xcbc_struct { /* used by Crypt::Mac::XCBC */ | |
118 | xcbc_state state; | |
119 | int id; | |
120 | } *Crypt__Mac__XCBC; | |
121 | ||
122 | typedef struct poly1305_struct { /* used by Crypt::Mac::Poly1305 */ | |
123 | poly1305_state state; | |
124 | int id; | |
125 | } *Crypt__Mac__Poly1305; | |
126 | ||
127 | typedef struct blake2s_struct { /* used by Crypt::Mac::BLAKE2s */ | |
128 | blake2smac_state state; | |
129 | int id; | |
130 | } *Crypt__Mac__BLAKE2s; | |
131 | ||
132 | typedef struct blake2b_struct { /* used by Crypt::Mac::BLAKE2b */ | |
133 | blake2bmac_state state; | |
134 | int id; | |
135 | } *Crypt__Mac__BLAKE2b; | |
136 | ||
137 | 55 | typedef struct cbc_struct { /* used by Crypt::Mode::CBC */ |
138 | 56 | int cipher_id, cipher_rounds; |
139 | 57 | symmetric_CBC state; |
141 | 59 | int padlen; |
142 | 60 | int padding_mode; |
143 | 61 | int direction; |
144 | int id; | |
145 | 62 | } *Crypt__Mode__CBC; |
146 | 63 | |
147 | 64 | typedef struct ecb_struct { /* used by Crypt::Mode::ECB */ |
151 | 68 | int padlen; |
152 | 69 | int padding_mode; |
153 | 70 | int direction; |
154 | int id; | |
155 | 71 | } *Crypt__Mode__ECB; |
156 | 72 | |
157 | 73 | typedef struct cfb_struct { /* used by Crypt::Mode::CFB */ |
158 | 74 | int cipher_id, cipher_rounds; |
159 | 75 | symmetric_CFB state; |
160 | 76 | int direction; |
161 | int id; | |
162 | 77 | } *Crypt__Mode__CFB; |
163 | 78 | |
164 | 79 | typedef struct ctr_struct { /* used by Crypt::Mode::CTR */ |
166 | 81 | int ctr_mode_param; |
167 | 82 | symmetric_CTR state; |
168 | 83 | int direction; |
169 | int id; | |
170 | 84 | } *Crypt__Mode__CTR; |
171 | 85 | |
172 | 86 | typedef struct f8_struct { /* used by Crypt::Mode::F8 */ |
173 | 87 | int cipher_id, cipher_rounds; |
174 | 88 | symmetric_F8 state; |
175 | 89 | int direction; |
176 | int id; | |
177 | 90 | } *Crypt__Mode__F8; |
178 | 91 | |
179 | 92 | typedef struct lrw_struct { /* used by Crypt::Mode::LRW */ |
180 | 93 | int cipher_id, cipher_rounds; |
181 | 94 | symmetric_LRW state; |
182 | 95 | int direction; |
183 | int id; | |
184 | 96 | } *Crypt__Mode__LRW; |
185 | 97 | |
186 | 98 | typedef struct ofb_struct { /* used by Crypt::Mode::OFB */ |
187 | 99 | int cipher_id, cipher_rounds; |
188 | 100 | symmetric_OFB state; |
189 | 101 | int direction; |
190 | int id; | |
191 | 102 | } *Crypt__Mode__OFB; |
192 | 103 | |
193 | 104 | typedef struct xts_struct { /* used by Crypt::Mode::XTS */ |
194 | 105 | int cipher_id, cipher_rounds; |
195 | 106 | symmetric_xts state; |
196 | 107 | int direction; |
197 | int id; | |
198 | 108 | } *Crypt__Mode__XTS; |
199 | 109 | |
200 | 110 | typedef struct prng_struct { /* used by Crypt::PRNG */ |
201 | 111 | prng_state state; |
202 | 112 | struct ltc_prng_descriptor *desc; |
203 | 113 | IV last_pid; |
204 | int id; | |
205 | 114 | } *Crypt__PRNG; |
206 | 115 | |
207 | 116 | typedef struct rsa_struct { /* used by Crypt::PK::RSA */ |
208 | 117 | prng_state pstate; |
209 | 118 | int pindex; |
210 | 119 | rsa_key key; |
211 | int id; | |
212 | 120 | } *Crypt__PK__RSA; |
213 | 121 | |
214 | 122 | typedef struct dsa_struct { /* used by Crypt::PK::DSA */ |
215 | 123 | prng_state pstate; |
216 | 124 | int pindex; |
217 | 125 | dsa_key key; |
218 | int id; | |
219 | 126 | } *Crypt__PK__DSA; |
220 | 127 | |
221 | 128 | typedef struct dh_struct { /* used by Crypt::PK::DH */ |
222 | 129 | prng_state pstate; |
223 | 130 | int pindex; |
224 | 131 | dh_key key; |
225 | int id; | |
226 | 132 | } *Crypt__PK__DH; |
227 | 133 | |
228 | 134 | typedef struct ecc_struct { /* used by Crypt::PK::ECC */ |
230 | 136 | int pindex; |
231 | 137 | ecc_key key; |
232 | 138 | ltc_ecc_set_type dp; |
233 | int id; | |
234 | 139 | } *Crypt__PK__ECC; |
235 | 140 | |
236 | 141 | int str_add_leading_zero(char *str, int maxlen, int minlen) { |
35 | 35 | if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar"); |
36 | 36 | k = (unsigned char *) SvPVbyte(key, k_len); |
37 | 37 | |
38 | Newz(0, RETVAL, 1, struct [%lc_name%]_struct); | |
38 | [%-IF lc_name == 'blake2s' || lc_name == 'blake2b' %] | |
39 | Newz(0, RETVAL, 1, [%lc_name%]mac_state); | |
40 | [%-ELSE%] | |
41 | Newz(0, RETVAL, 1, [%lc_name%]_state); | |
42 | [%-END%] | |
39 | 43 | if (!RETVAL) croak("FATAL: Newz failed"); |
40 | 44 | |
41 | 45 | [%-IF lc_name == 'pelican' || lc_name == 'poly1305' %] |
42 | rv = [%lc_name%]_init(&RETVAL->state, k, (unsigned long)k_len); | |
43 | [%-ELSIF lc_name == 'blake2s' || lc_name == 'blake2b' %] | |
44 | rv = [%lc_name%]mac_init(&RETVAL->state, size, k, (unsigned long)k_len); | |
45 | [%-ELSE%] | |
46 | rv = [%lc_name%]_init(&RETVAL->state, id, k, (unsigned long)k_len); | |
46 | rv = [%lc_name%]_init(RETVAL, k, (unsigned long)k_len); | |
47 | [%-ELSIF lc_name == 'blake2s' || lc_name == 'blake2b' %] | |
48 | rv = [%lc_name%]mac_init(RETVAL, size, k, (unsigned long)k_len); | |
49 | [%-ELSE%] | |
50 | rv = [%lc_name%]_init(RETVAL, id, k, (unsigned long)k_len); | |
47 | 51 | [%-END%] |
48 | 52 | if (rv != CRYPT_OK) { |
49 | 53 | Safefree(RETVAL); |
61 | 65 | Crypt::Mac::[%orig_name%] |
62 | 66 | clone(Crypt::Mac::[%orig_name%] self) |
63 | 67 | CODE: |
64 | Newz(0, RETVAL, 1, struct [%lc_name%]_struct); | |
68 | [%-IF lc_name == 'blake2s' || lc_name == 'blake2b' %] | |
69 | Newz(0, RETVAL, 1, [%lc_name%]mac_state); | |
65 | 70 | if (!RETVAL) croak("FATAL: Newz failed"); |
66 | Copy(&self->state, &RETVAL->state, 1, struct [%lc_name%]_struct); | |
71 | Copy(self, RETVAL, 1, [%lc_name%]mac_state); | |
72 | [%-ELSE%] | |
73 | Newz(0, RETVAL, 1, [%lc_name%]_state); | |
74 | if (!RETVAL) croak("FATAL: Newz failed"); | |
75 | Copy(self, RETVAL, 1, [%lc_name%]_state); | |
76 | [%-END%] | |
67 | 77 | OUTPUT: |
68 | 78 | RETVAL |
69 | 79 | |
79 | 89 | in_data = (unsigned char *)SvPVbyte(ST(i), in_data_len); |
80 | 90 | if (in_data_len > 0) { |
81 | 91 | [%-IF lc_name == 'blake2s' || lc_name == 'blake2b' %] |
82 | rv = [%lc_name%]mac_process(&self->state, in_data, (unsigned long)in_data_len); | |
83 | [%-ELSE%] | |
84 | rv = [%lc_name%]_process(&self->state, in_data, (unsigned long)in_data_len); | |
92 | rv = [%lc_name%]mac_process(self, in_data, (unsigned long)in_data_len); | |
93 | [%-ELSE%] | |
94 | rv = [%lc_name%]_process(self, in_data, (unsigned long)in_data_len); | |
85 | 95 | [%-END%] |
86 | 96 | if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_process failed: %s", error_to_string(rv)); |
87 | 97 | } |
104 | 114 | |
105 | 115 | [%-IF lc_name == 'pelican' %] |
106 | 116 | maclen = 16; |
107 | rv = [%lc_name%]_done(&self->state, mac); | |
117 | rv = [%lc_name%]_done(self, mac); | |
108 | 118 | if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_done failed: %s", error_to_string(rv)); |
109 | 119 | [%-ELSIF lc_name == 'blake2s' || lc_name == 'blake2b' %] |
110 | 120 | maclen = sizeof(mac); |
111 | rv = [%lc_name%]mac_done(&self->state, mac, &maclen); | |
121 | rv = [%lc_name%]mac_done(self, mac, &maclen); | |
112 | 122 | if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]mac_done failed: %s", error_to_string(rv)); |
113 | 123 | [%-ELSE%] |
114 | 124 | maclen = sizeof(mac); |
115 | rv = [%lc_name%]_done(&self->state, mac, &maclen); | |
125 | rv = [%lc_name%]_done(self, mac, &maclen); | |
116 | 126 | if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_done failed: %s", error_to_string(rv)); |
117 | 127 | [%-END%] |
118 | 128 | outlen = sizeof(out); |
25 | 25 | id = _find_cipher(cipher_name); |
26 | 26 | if (id == -1) croak("FATAL: find_cipfer failed for '%s'", cipher_name); |
27 | 27 | |
28 | Newz(0, RETVAL, 1, struct ccm_struct); | |
28 | Newz(0, RETVAL, 1, ccm_state); | |
29 | 29 | if (!RETVAL) croak("FATAL: Newz failed"); |
30 | 30 | |
31 | rv = ccm_init(&RETVAL->state, id, k, (int)k_len, (int)pt_len, (int)tag_len, (int)h_len); /* XXX-TODO why int? */ | |
31 | rv = ccm_init(RETVAL, id, k, (int)k_len, (int)pt_len, (int)tag_len, (int)h_len); /* XXX-TODO why int? */ | |
32 | 32 | if (rv != CRYPT_OK) { |
33 | 33 | Safefree(RETVAL); |
34 | 34 | croak("FATAL: ccm_init failed: %s", error_to_string(rv)); |
35 | 35 | } |
36 | rv = ccm_add_nonce(&RETVAL->state, n, (unsigned long)n_len); | |
36 | rv = ccm_add_nonce(RETVAL, n, (unsigned long)n_len); | |
37 | 37 | if (rv != CRYPT_OK) { |
38 | 38 | Safefree(RETVAL); |
39 | 39 | croak("FATAL: ccm_add_nonce failed: %s", error_to_string(rv)); |
40 | 40 | } |
41 | rv = ccm_add_aad(&RETVAL->state, h, (unsigned long)h_len); | |
41 | rv = ccm_add_aad(RETVAL, h, (unsigned long)h_len); | |
42 | 42 | if (rv != CRYPT_OK) { |
43 | 43 | Safefree(RETVAL); |
44 | 44 | croak("FATAL: ccm_add_aad failed: %s", error_to_string(rv)); |
45 | 45 | } |
46 | RETVAL->direction = -1; | |
47 | RETVAL->tag_len = tag_len; | |
48 | RETVAL->pt_len = pt_len; | |
49 | 46 | } |
50 | 47 | OUTPUT: |
51 | 48 | RETVAL |
58 | 55 | Crypt::AuthEnc::CCM |
59 | 56 | clone(Crypt::AuthEnc::CCM self) |
60 | 57 | CODE: |
61 | Newz(0, RETVAL, 1, struct ccm_struct); | |
58 | Newz(0, RETVAL, 1, ccm_state); | |
62 | 59 | if (!RETVAL) croak("FATAL: Newz failed"); |
63 | Copy(&self->state, &RETVAL->state, 1, struct ccm_struct); | |
60 | Copy(self, RETVAL, 1, ccm_state); | |
64 | 61 | OUTPUT: |
65 | 62 | RETVAL |
66 | 63 | |
77 | 74 | RETVAL = newSVpvn("", 0); |
78 | 75 | } |
79 | 76 | else { |
80 | if (self->direction == -1) self->direction = CCM_ENCRYPT; | |
81 | if (self->direction != CCM_ENCRYPT) { | |
82 | croak("FATAL: encrypt_add failed: wrong direction"); | |
83 | } | |
84 | if (self->pt_len < in_data_len) croak("FATAL: encrypt_add failed: pt_len mismatch"); | |
85 | 77 | RETVAL = NEWSV(0, in_data_len); /* avoid zero! */ |
86 | 78 | SvPOK_only(RETVAL); |
87 | 79 | SvCUR_set(RETVAL, in_data_len); |
88 | 80 | out_data = (unsigned char *)SvPVX(RETVAL); |
89 | rv = ccm_process(&self->state, in_data, (unsigned long)in_data_len, out_data, self->direction); | |
81 | rv = ccm_process(self, in_data, (unsigned long)in_data_len, out_data, CCM_ENCRYPT); | |
90 | 82 | if (rv != CRYPT_OK) { |
91 | 83 | SvREFCNT_dec(RETVAL); |
92 | 84 | croak("FATAL: ccm_process failed: %s", error_to_string(rv)); |
93 | 85 | } |
94 | self->pt_len -= (unsigned long)in_data_len; | |
95 | 86 | } |
96 | 87 | } |
97 | 88 | OUTPUT: |
110 | 101 | RETVAL = newSVpvn("", 0); |
111 | 102 | } |
112 | 103 | else { |
113 | if (self->direction == -1) self->direction = CCM_DECRYPT; | |
114 | if (self->direction != CCM_DECRYPT) { | |
115 | croak("FATAL: decrypt_add failed: wrong direction"); | |
116 | } | |
117 | if (self->pt_len < in_data_len) croak("FATAL: decrypt_add failed: pt_len mismatch"); | |
118 | 104 | RETVAL = NEWSV(0, in_data_len); /* avoid zero! */ |
119 | 105 | SvPOK_only(RETVAL); |
120 | 106 | SvCUR_set(RETVAL, in_data_len); |
121 | 107 | out_data = (unsigned char *)SvPVX(RETVAL); |
122 | rv = ccm_process(&self->state, out_data, (unsigned long)in_data_len, in_data, CCM_DECRYPT); | |
108 | rv = ccm_process(self, out_data, (unsigned long)in_data_len, in_data, CCM_DECRYPT); | |
123 | 109 | if (rv != CRYPT_OK) { |
124 | 110 | SvREFCNT_dec(RETVAL); |
125 | 111 | croak("FATAL: ccm_process failed: %s", error_to_string(rv)); |
126 | 112 | } |
127 | self->pt_len -= (unsigned long)in_data_len; | |
128 | 113 | } |
129 | 114 | } |
130 | 115 | OUTPUT: |
136 | 121 | { |
137 | 122 | int rv; |
138 | 123 | unsigned char tag[MAXBLOCKSIZE]; |
139 | unsigned long tag_len = self->tag_len; | |
140 | ||
141 | if (self->direction != CCM_ENCRYPT) { | |
142 | croak("FATAL: encrypt_done failed: wrong direction"); | |
143 | } | |
144 | if (self->pt_len != 0) croak("FATAL: encrypt_done failed: pt_len mismatch"); | |
145 | rv = ccm_done(&self->state, tag, &tag_len); | |
124 | unsigned long tag_len = MAXBLOCKSIZE; | |
125 | ||
126 | rv = ccm_done(self, tag, &tag_len); | |
146 | 127 | if (rv != CRYPT_OK) croak("FATAL: ccm_done failed: %s", error_to_string(rv)); |
147 | 128 | XPUSHs(sv_2mortal(newSVpvn((char*)tag, tag_len))); |
148 | 129 | } |
153 | 134 | { |
154 | 135 | int rv; |
155 | 136 | unsigned char tag[MAXBLOCKSIZE]; |
156 | unsigned long tag_len = self->tag_len; | |
137 | unsigned long tag_len = MAXBLOCKSIZE; | |
157 | 138 | STRLEN expected_tag_len; |
158 | 139 | unsigned char *expected_tag; |
159 | 140 | |
160 | if (self->direction != CCM_DECRYPT) { | |
161 | croak("FATAL: decrypt_done failed: wrong direction"); | |
162 | } | |
163 | if (self->pt_len != 0) croak("FATAL: decrypt_done failed: pt_len mismatch"); | |
164 | rv = ccm_done(&self->state, tag, &tag_len); | |
141 | rv = ccm_done(self, tag, &tag_len); | |
165 | 142 | if (rv != CRYPT_OK) croak("FATAL: ccm_done failed: %s", error_to_string(rv)); |
166 | 143 | if (items == 1) { |
167 | 144 | XPUSHs(sv_2mortal(newSVpvn((char*)tag, tag_len))); |
16 | 16 | iv = (unsigned char *) SvPVbyte(nonce, iv_len); |
17 | 17 | } |
18 | 18 | |
19 | Newz(0, RETVAL, 1, struct chacha20poly1305_struct); | |
19 | Newz(0, RETVAL, 1, chacha20poly1305_state); | |
20 | 20 | if (!RETVAL) croak("FATAL: Newz failed"); |
21 | 21 | |
22 | rv = chacha20poly1305_init(&RETVAL->state, k, (unsigned long)k_len); | |
22 | rv = chacha20poly1305_init(RETVAL, k, (unsigned long)k_len); | |
23 | 23 | if (rv != CRYPT_OK) { |
24 | 24 | Safefree(RETVAL); |
25 | 25 | croak("FATAL: chacha20poly1305_init failed: %s", error_to_string(rv)); |
26 | 26 | } |
27 | 27 | |
28 | 28 | if (iv && iv_len > 0) { |
29 | rv = chacha20poly1305_setiv(&RETVAL->state, iv, (unsigned long)iv_len); | |
29 | rv = chacha20poly1305_setiv(RETVAL, iv, (unsigned long)iv_len); | |
30 | 30 | if (rv != CRYPT_OK) { |
31 | 31 | Safefree(RETVAL); |
32 | 32 | croak("FATAL: chacha20poly1305_setiv failed: %s", error_to_string(rv)); |
44 | 44 | Crypt::AuthEnc::ChaCha20Poly1305 |
45 | 45 | clone(Crypt::AuthEnc::ChaCha20Poly1305 self) |
46 | 46 | CODE: |
47 | Newz(0, RETVAL, 1, struct chacha20poly1305_struct); | |
47 | Newz(0, RETVAL, 1, chacha20poly1305_state); | |
48 | 48 | if (!RETVAL) croak("FATAL: Newz failed"); |
49 | Copy(&self->state, &RETVAL->state, 1, struct chacha20poly1305_struct); | |
49 | Copy(self, RETVAL, 1, chacha20poly1305_state); | |
50 | 50 | OUTPUT: |
51 | 51 | RETVAL |
52 | 52 | |
60 | 60 | |
61 | 61 | if (!SvPOK(nonce)) croak("FATAL: nonce must be string/buffer scalar"); |
62 | 62 | iv = (unsigned char *) SvPVbyte(nonce, iv_len); |
63 | rv = chacha20poly1305_setiv(&self->state, iv, (unsigned long)iv_len); | |
63 | rv = chacha20poly1305_setiv(self, iv, (unsigned long)iv_len); | |
64 | 64 | if (rv != CRYPT_OK) croak("FATAL: chacha20poly1305_setiv failed: %s", error_to_string(rv)); |
65 | 65 | XPUSHs(ST(0)); /* return self */; |
66 | 66 | } |
75 | 75 | |
76 | 76 | if (!SvPOK(nonce)) croak("FATAL: nonce must be string/buffer scalar"); |
77 | 77 | iv = (unsigned char *) SvPVbyte(nonce, iv_len); |
78 | rv = chacha20poly1305_setiv_rfc7905(&self->state, iv, (unsigned long)iv_len, (ulong64)seqnum); | |
78 | rv = chacha20poly1305_setiv_rfc7905(self, iv, (unsigned long)iv_len, (ulong64)seqnum); | |
79 | 79 | if (rv != CRYPT_OK) croak("FATAL: chacha20poly1305_setiv_rfc7905 failed: %s", error_to_string(rv)); |
80 | 80 | XPUSHs(ST(0)); /* return self */ |
81 | 81 | } |
89 | 89 | unsigned char *in_data; |
90 | 90 | |
91 | 91 | in_data = (unsigned char *)SvPVbyte(data, in_data_len); |
92 | rv = chacha20poly1305_add_aad(&self->state, in_data, (unsigned long)in_data_len); | |
92 | rv = chacha20poly1305_add_aad(self, in_data, (unsigned long)in_data_len); | |
93 | 93 | if (rv != CRYPT_OK) croak("FATAL: chacha20poly1305_add_aad failed: %s", error_to_string(rv)); |
94 | 94 | XPUSHs(ST(0)); /* return self */ |
95 | 95 | } |
111 | 111 | SvPOK_only(RETVAL); |
112 | 112 | SvCUR_set(RETVAL, in_data_len); |
113 | 113 | out_data = (unsigned char *)SvPVX(RETVAL); |
114 | rv = chacha20poly1305_decrypt(&self->state, in_data, (unsigned long)in_data_len, out_data); | |
114 | rv = chacha20poly1305_decrypt(self, in_data, (unsigned long)in_data_len, out_data); | |
115 | 115 | if (rv != CRYPT_OK) { |
116 | 116 | SvREFCNT_dec(RETVAL); |
117 | 117 | croak("FATAL: chacha20poly1305_decrypt failed: %s", error_to_string(rv)); |
138 | 138 | SvPOK_only(RETVAL); |
139 | 139 | SvCUR_set(RETVAL, in_data_len); |
140 | 140 | out_data = (unsigned char *)SvPVX(RETVAL); |
141 | rv = chacha20poly1305_encrypt(&self->state, in_data, (unsigned long)in_data_len, out_data); | |
141 | rv = chacha20poly1305_encrypt(self, in_data, (unsigned long)in_data_len, out_data); | |
142 | 142 | if (rv != CRYPT_OK) { |
143 | 143 | SvREFCNT_dec(RETVAL); |
144 | 144 | croak("FATAL: chacha20poly1305_encrypt failed: %s", error_to_string(rv)); |
156 | 156 | unsigned char tag[MAXBLOCKSIZE]; |
157 | 157 | unsigned long tag_len = sizeof(tag); |
158 | 158 | |
159 | rv = chacha20poly1305_done(&self->state, tag, &tag_len); | |
159 | rv = chacha20poly1305_done(self, tag, &tag_len); | |
160 | 160 | if (rv != CRYPT_OK) croak("FATAL: chacha20poly1305_done failed: %s", error_to_string(rv)); |
161 | 161 | XPUSHs(sv_2mortal(newSVpvn((char*)tag, tag_len))); |
162 | 162 | } |
171 | 171 | STRLEN expected_tag_len; |
172 | 172 | unsigned char *expected_tag; |
173 | 173 | |
174 | rv = chacha20poly1305_done(&self->state, tag, &tag_len); | |
174 | rv = chacha20poly1305_done(self, tag, &tag_len); | |
175 | 175 | if (rv != CRYPT_OK) croak("FATAL: chacha20poly1305_done failed: %s", error_to_string(rv)); |
176 | 176 | if (items == 1) { |
177 | 177 | XPUSHs(sv_2mortal(newSVpvn((char*)tag, tag_len))); |
25 | 25 | id = _find_cipher(cipher_name); |
26 | 26 | if (id == -1) croak("FATAL: find_cipfer failed for '%s'", cipher_name); |
27 | 27 | |
28 | Newz(0, RETVAL, 1, struct eax_struct); | |
28 | Newz(0, RETVAL, 1, eax_state); | |
29 | 29 | if (!RETVAL) croak("FATAL: Newz failed"); |
30 | 30 | |
31 | rv = eax_init(&RETVAL->state, id, k, (unsigned long)k_len, n, (unsigned long)n_len, h, (unsigned long)h_len); | |
31 | rv = eax_init(RETVAL, id, k, (unsigned long)k_len, n, (unsigned long)n_len, h, (unsigned long)h_len); | |
32 | 32 | if (rv != CRYPT_OK) { |
33 | 33 | Safefree(RETVAL); |
34 | 34 | croak("FATAL: eax setup failed: %s", error_to_string(rv)); |
45 | 45 | Crypt::AuthEnc::EAX |
46 | 46 | clone(Crypt::AuthEnc::EAX self) |
47 | 47 | CODE: |
48 | Newz(0, RETVAL, 1, struct eax_struct); | |
48 | Newz(0, RETVAL, 1, eax_state); | |
49 | 49 | if (!RETVAL) croak("FATAL: Newz failed"); |
50 | Copy(&self->state, &RETVAL->state, 1, struct eax_struct); | |
50 | Copy(self, RETVAL, 1, eax_state); | |
51 | 51 | OUTPUT: |
52 | 52 | RETVAL |
53 | 53 | |
68 | 68 | SvPOK_only(RETVAL); |
69 | 69 | SvCUR_set(RETVAL, in_data_len); |
70 | 70 | out_data = (unsigned char *)SvPVX(RETVAL); |
71 | rv = eax_encrypt(&self->state, in_data, out_data, (unsigned long)in_data_len); | |
71 | rv = eax_encrypt(self, in_data, out_data, (unsigned long)in_data_len); | |
72 | 72 | if (rv != CRYPT_OK) { |
73 | 73 | SvREFCNT_dec(RETVAL); |
74 | 74 | croak("FATAL: eax_encrypt failed: %s", error_to_string(rv)); |
95 | 95 | SvPOK_only(RETVAL); |
96 | 96 | SvCUR_set(RETVAL, in_data_len); |
97 | 97 | out_data = (unsigned char *)SvPVX(RETVAL); |
98 | rv = eax_decrypt(&self->state, in_data, out_data, (unsigned long)in_data_len); | |
98 | rv = eax_decrypt(self, in_data, out_data, (unsigned long)in_data_len); | |
99 | 99 | if (rv != CRYPT_OK) { |
100 | 100 | SvREFCNT_dec(RETVAL); |
101 | 101 | croak("FATAL: eax_decrypt failed: %s", error_to_string(rv)); |
113 | 113 | unsigned char tag[MAXBLOCKSIZE]; |
114 | 114 | unsigned long tag_len = sizeof(tag); |
115 | 115 | |
116 | rv = eax_done(&self->state, tag, &tag_len); | |
116 | rv = eax_done(self, tag, &tag_len); | |
117 | 117 | if (rv != CRYPT_OK) croak("FATAL: eax_done failed: %s", error_to_string(rv)); |
118 | 118 | XPUSHs(sv_2mortal(newSVpvn((char*)tag, tag_len))); |
119 | 119 | } |
128 | 128 | STRLEN expected_tag_len; |
129 | 129 | unsigned char *expected_tag; |
130 | 130 | |
131 | rv = eax_done(&self->state, tag, &tag_len); | |
131 | rv = eax_done(self, tag, &tag_len); | |
132 | 132 | if (rv != CRYPT_OK) croak("FATAL: eax_done failed: %s", error_to_string(rv)); |
133 | 133 | if (items == 1) { |
134 | 134 | XPUSHs(sv_2mortal(newSVpvn((char*)tag, tag_len))); |
156 | 156 | int rv; |
157 | 157 | unsigned char *h; |
158 | 158 | h = (unsigned char *)SvPVbyte(adata, h_len); |
159 | rv = eax_addheader(&self->state, h, (unsigned long)h_len); | |
159 | rv = eax_addheader(self, h, (unsigned long)h_len); | |
160 | 160 | if (rv != CRYPT_OK) croak("FATAL: eax_addheader failed: %s", error_to_string(rv)); |
161 | 161 | XPUSHs(ST(0)); /* return self */ |
162 | 162 | } |
19 | 19 | id = _find_cipher(cipher_name); |
20 | 20 | if (id == -1) croak("FATAL: find_cipfer failed for '%s'", cipher_name); |
21 | 21 | |
22 | Newz(0, RETVAL, 1, struct gcm_struct); | |
22 | Newz(0, RETVAL, 1, gcm_state); | |
23 | 23 | if (!RETVAL) croak("FATAL: Newz failed"); |
24 | 24 | |
25 | rv = gcm_init(&RETVAL->state, id, k, (unsigned long)k_len); | |
25 | rv = gcm_init(RETVAL, id, k, (unsigned long)k_len); | |
26 | 26 | if (rv != CRYPT_OK) { |
27 | 27 | Safefree(RETVAL); |
28 | 28 | croak("FATAL: gcm_init failed: %s", error_to_string(rv)); |
29 | 29 | } |
30 | 30 | |
31 | 31 | if (iv && iv_len > 0) { |
32 | rv = gcm_add_iv(&RETVAL->state, iv, (unsigned long)iv_len); | |
32 | rv = gcm_add_iv(RETVAL, iv, (unsigned long)iv_len); | |
33 | 33 | if (rv != CRYPT_OK) { |
34 | 34 | Safefree(RETVAL); |
35 | 35 | croak("FATAL: gcm_add_iv failed: %s", error_to_string(rv)); |
47 | 47 | Crypt::AuthEnc::GCM |
48 | 48 | clone(Crypt::AuthEnc::GCM self) |
49 | 49 | CODE: |
50 | Newz(0, RETVAL, 1, struct gcm_struct); | |
50 | Newz(0, RETVAL, 1, gcm_state); | |
51 | 51 | if (!RETVAL) croak("FATAL: Newz failed"); |
52 | Copy(&self->state, &RETVAL->state, 1, struct gcm_struct); | |
52 | Copy(self, RETVAL, 1, gcm_state); | |
53 | 53 | OUTPUT: |
54 | 54 | RETVAL |
55 | 55 | |
58 | 58 | PPCODE: |
59 | 59 | { |
60 | 60 | int rv; |
61 | rv = gcm_reset(&self->state); | |
61 | rv = gcm_reset(self); | |
62 | 62 | if (rv != CRYPT_OK) croak("FATAL: gcm_reset failed: %s", error_to_string(rv)); |
63 | 63 | XPUSHs(ST(0)); /* return self */ |
64 | 64 | } |
81 | 81 | SvPOK_only(RETVAL); |
82 | 82 | SvCUR_set(RETVAL, in_data_len); |
83 | 83 | out_data = (unsigned char *)SvPVX(RETVAL); |
84 | rv = gcm_process(&self->state, in_data, (unsigned long)in_data_len, out_data, GCM_ENCRYPT); | |
84 | rv = gcm_process(self, in_data, (unsigned long)in_data_len, out_data, GCM_ENCRYPT); | |
85 | 85 | if (rv != CRYPT_OK) { |
86 | 86 | SvREFCNT_dec(RETVAL); |
87 | 87 | croak("FATAL: encrypt_add/gcm_process failed: %s", error_to_string(rv)); |
100 | 100 | unsigned char *in_data; |
101 | 101 | |
102 | 102 | in_data = (unsigned char *)SvPVbyte(data, in_data_len); |
103 | rv = gcm_add_iv(&self->state, in_data, (unsigned long)in_data_len); | |
103 | rv = gcm_add_iv(self, in_data, (unsigned long)in_data_len); | |
104 | 104 | if (rv != CRYPT_OK) croak("FATAL: gcm_add_iv failed: %s", error_to_string(rv)); |
105 | 105 | XPUSHs(ST(0)); /* return self */ |
106 | 106 | } |
114 | 114 | unsigned char *in_data; |
115 | 115 | |
116 | 116 | in_data = (unsigned char *)SvPVbyte(data, in_data_len); |
117 | rv = gcm_add_aad(&self->state, in_data, (unsigned long)in_data_len); | |
117 | rv = gcm_add_aad(self, in_data, (unsigned long)in_data_len); | |
118 | 118 | if (rv != CRYPT_OK) croak("FATAL: gcm_add_aad failed: %s", error_to_string(rv)); |
119 | 119 | XPUSHs(ST(0)); /* return self */ |
120 | 120 | } |
136 | 136 | SvPOK_only(RETVAL); |
137 | 137 | SvCUR_set(RETVAL, in_data_len); |
138 | 138 | out_data = (unsigned char *)SvPVX(RETVAL); |
139 | rv = gcm_process(&self->state, out_data, (unsigned long)in_data_len, in_data, GCM_DECRYPT); | |
139 | rv = gcm_process(self, out_data, (unsigned long)in_data_len, in_data, GCM_DECRYPT); | |
140 | 140 | if (rv != CRYPT_OK) { |
141 | 141 | SvREFCNT_dec(RETVAL); |
142 | 142 | croak("FATAL: encrypt_add/gcm_process failed: %s", error_to_string(rv)); |
155 | 155 | unsigned char tag[MAXBLOCKSIZE]; |
156 | 156 | unsigned long tag_len = sizeof(tag); |
157 | 157 | |
158 | rv = gcm_done(&self->state, tag, &tag_len); | |
158 | rv = gcm_done(self, tag, &tag_len); | |
159 | 159 | if (rv != CRYPT_OK) croak("FATAL: gcm_done failed: %s", error_to_string(rv)); |
160 | 160 | XPUSHs(sv_2mortal(newSVpvn((char*)tag, tag_len))); |
161 | 161 | } |
170 | 170 | STRLEN expected_tag_len; |
171 | 171 | unsigned char *expected_tag; |
172 | 172 | |
173 | rv = gcm_done(&self->state, tag, &tag_len); | |
173 | rv = gcm_done(self, tag, &tag_len); | |
174 | 174 | if (rv != CRYPT_OK) croak("FATAL: gcm_done failed: %s", error_to_string(rv)); |
175 | 175 | if (items == 1) { |
176 | 176 | XPUSHs(sv_2mortal(newSVpvn((char*)tag, tag_len))); |
19 | 19 | id = _find_cipher(cipher_name); |
20 | 20 | if (id == -1) croak("FATAL: find_cipfer failed for '%s'", cipher_name); |
21 | 21 | |
22 | Newz(0, RETVAL, 1, struct ocb_struct); | |
22 | Newz(0, RETVAL, 1, ocb3_state); | |
23 | 23 | if (!RETVAL) croak("FATAL: Newz failed"); |
24 | 24 | |
25 | rv = ocb3_init(&RETVAL->state, id, k, (unsigned long)k_len, n, (unsigned long)n_len, taglen); | |
25 | rv = ocb3_init(RETVAL, id, k, (unsigned long)k_len, n, (unsigned long)n_len, taglen); | |
26 | 26 | if (rv != CRYPT_OK) { |
27 | 27 | Safefree(RETVAL); |
28 | 28 | croak("FATAL: ocb setup failed: %s", error_to_string(rv)); |
39 | 39 | Crypt::AuthEnc::OCB |
40 | 40 | clone(Crypt::AuthEnc::OCB self) |
41 | 41 | CODE: |
42 | Newz(0, RETVAL, 1, struct ocb_struct); | |
42 | Newz(0, RETVAL, 1, ocb3_state); | |
43 | 43 | if (!RETVAL) croak("FATAL: Newz failed"); |
44 | Copy(&self->state, &RETVAL->state, 1, struct ocb_struct); | |
44 | Copy(self, RETVAL, 1, ocb3_state); | |
45 | 45 | OUTPUT: |
46 | 46 | RETVAL |
47 | 47 | |
56 | 56 | in_data = (unsigned char *)SvPVbyte(data, in_data_len); |
57 | 57 | |
58 | 58 | if (in_data_len>0) { |
59 | rv = ocb3_add_aad(&self->state, in_data, (unsigned long)in_data_len); | |
59 | rv = ocb3_add_aad(self, in_data, (unsigned long)in_data_len); | |
60 | 60 | if (rv != CRYPT_OK) croak("FATAL: ocb3_add_aad failed: %s", error_to_string(rv)); |
61 | 61 | } |
62 | 62 | XPUSHs(ST(0)); /* return self */ |
82 | 82 | SvPOK_only(RETVAL); |
83 | 83 | SvCUR_set(RETVAL, in_data_len); |
84 | 84 | out_data = (unsigned char *)SvPVX(RETVAL); |
85 | rv = ocb3_encrypt(&self->state, in_data, (unsigned long)in_data_len, out_data); | |
85 | rv = ocb3_encrypt(self, in_data, (unsigned long)in_data_len, out_data); | |
86 | 86 | if (rv != CRYPT_OK) { |
87 | 87 | SvREFCNT_dec(RETVAL); |
88 | 88 | croak("FATAL: ocb3_encrypt failed: %s", error_to_string(rv)); |
102 | 102 | |
103 | 103 | in_data = (unsigned char *)SvPVbyte(data, in_data_len); |
104 | 104 | if (in_data_len == 0) { |
105 | rv = ocb3_encrypt_last(&self->state, in_data, 0, NULL); | |
106 | if (rv != CRYPT_OK) { | |
107 | croak("FATAL: ocb3_encrypt_last failed: %s", error_to_string(rv)); | |
108 | } | |
109 | RETVAL = newSVpvn("", 0); | |
110 | } | |
111 | else { | |
112 | RETVAL = NEWSV(0, in_data_len); /* avoid zero! */ | |
113 | SvPOK_only(RETVAL); | |
114 | SvCUR_set(RETVAL, in_data_len); | |
115 | out_data = (unsigned char *)SvPVX(RETVAL); | |
116 | rv = ocb3_encrypt_last(&self->state, in_data, (unsigned long)in_data_len, out_data); | |
105 | rv = ocb3_encrypt_last(self, in_data, 0, NULL); | |
106 | if (rv != CRYPT_OK) { | |
107 | croak("FATAL: ocb3_encrypt_last failed: %s", error_to_string(rv)); | |
108 | } | |
109 | RETVAL = newSVpvn("", 0); | |
110 | } | |
111 | else { | |
112 | RETVAL = NEWSV(0, in_data_len); /* avoid zero! */ | |
113 | SvPOK_only(RETVAL); | |
114 | SvCUR_set(RETVAL, in_data_len); | |
115 | out_data = (unsigned char *)SvPVX(RETVAL); | |
116 | rv = ocb3_encrypt_last(self, in_data, (unsigned long)in_data_len, out_data); | |
117 | 117 | if (rv != CRYPT_OK) { |
118 | 118 | SvREFCNT_dec(RETVAL); |
119 | 119 | croak("FATAL: ocb3_encrypt_last failed: %s", error_to_string(rv)); |
143 | 143 | SvPOK_only(RETVAL); |
144 | 144 | SvCUR_set(RETVAL, in_data_len); |
145 | 145 | out_data = (unsigned char *)SvPVX(RETVAL); |
146 | rv = ocb3_decrypt(&self->state, in_data, (unsigned long)in_data_len, out_data); | |
146 | rv = ocb3_decrypt(self, in_data, (unsigned long)in_data_len, out_data); | |
147 | 147 | if (rv != CRYPT_OK) { |
148 | 148 | SvREFCNT_dec(RETVAL); |
149 | 149 | croak("FATAL: ocb3_decrypt failed: %s", error_to_string(rv)); |
163 | 163 | |
164 | 164 | in_data = (unsigned char *)SvPVbyte(data, in_data_len); |
165 | 165 | if (in_data_len == 0) { |
166 | rv = ocb3_decrypt_last(&self->state, in_data, 0, NULL); | |
167 | if (rv != CRYPT_OK) { | |
168 | croak("FATAL: ocb3_encrypt_last failed: %s", error_to_string(rv)); | |
169 | } | |
170 | RETVAL = newSVpvn("", 0); | |
171 | } | |
172 | else { | |
173 | RETVAL = NEWSV(0, in_data_len); /* avoid zero! */ | |
174 | SvPOK_only(RETVAL); | |
175 | SvCUR_set(RETVAL, in_data_len); | |
176 | out_data = (unsigned char *)SvPVX(RETVAL); | |
177 | rv = ocb3_decrypt_last(&self->state, in_data, (unsigned long)in_data_len, out_data); | |
166 | rv = ocb3_decrypt_last(self, in_data, 0, NULL); | |
167 | if (rv != CRYPT_OK) { | |
168 | croak("FATAL: ocb3_encrypt_last failed: %s", error_to_string(rv)); | |
169 | } | |
170 | RETVAL = newSVpvn("", 0); | |
171 | } | |
172 | else { | |
173 | RETVAL = NEWSV(0, in_data_len); /* avoid zero! */ | |
174 | SvPOK_only(RETVAL); | |
175 | SvCUR_set(RETVAL, in_data_len); | |
176 | out_data = (unsigned char *)SvPVX(RETVAL); | |
177 | rv = ocb3_decrypt_last(self, in_data, (unsigned long)in_data_len, out_data); | |
178 | 178 | if (rv != CRYPT_OK) { |
179 | 179 | SvREFCNT_dec(RETVAL); |
180 | 180 | croak("FATAL: ocb3_encrypt_last failed: %s", error_to_string(rv)); |
192 | 192 | unsigned char tag[MAXBLOCKSIZE]; |
193 | 193 | unsigned long tag_len = sizeof(tag); |
194 | 194 | |
195 | rv = ocb3_done(&self->state, tag, &tag_len); | |
195 | rv = ocb3_done(self, tag, &tag_len); | |
196 | 196 | if (rv != CRYPT_OK) croak("FATAL: ocb3_done_encrypt failed: %s", error_to_string(rv)); |
197 | 197 | |
198 | 198 | XPUSHs(sv_2mortal(newSVpvn((char*)tag, tag_len))); |
208 | 208 | STRLEN expected_tag_len; |
209 | 209 | unsigned char *expected_tag; |
210 | 210 | |
211 | rv = ocb3_done(&self->state, tag, &tag_len); | |
211 | rv = ocb3_done(self, tag, &tag_len); | |
212 | 212 | if (rv != CRYPT_OK) croak("FATAL: ocb3_done_decrypt failed: %s", error_to_string(rv)); |
213 | 213 | if (items == 1) { |
214 | 214 | XPUSHs(sv_2mortal(newSVpvn((char*)tag, tag_len))); |
30 | 30 | Newz(0, RETVAL, 1, struct cipher_struct); |
31 | 31 | if (!RETVAL) croak("FATAL: Newz failed"); |
32 | 32 | |
33 | RETVAL->id = id; | |
34 | 33 | RETVAL->desc = &cipher_descriptor[id]; |
35 | 34 | rv = RETVAL->desc->setup(key_data, (int)key_len, rounds, &RETVAL->skey); |
36 | 35 | if (rv != CRYPT_OK) { |
15 | 15 | Newz(0, RETVAL, 1, struct digest_struct); |
16 | 16 | if (!RETVAL) croak("FATAL: Newz failed"); |
17 | 17 | |
18 | RETVAL->id = id; | |
19 | 18 | RETVAL->desc = &hash_descriptor[id]; |
20 | 19 | rv = RETVAL->desc->init(&RETVAL->state); |
21 | 20 | if (rv != CRYPT_OK) { |
14 | 14 | if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar"); |
15 | 15 | k = (unsigned char *) SvPVbyte(key, k_len); |
16 | 16 | |
17 | Newz(0, RETVAL, 1, struct blake2b_struct); | |
17 | Newz(0, RETVAL, 1, blake2bmac_state); | |
18 | 18 | if (!RETVAL) croak("FATAL: Newz failed"); |
19 | 19 | |
20 | rv = blake2bmac_init(&RETVAL->state, size, k, (unsigned long)k_len); | |
20 | rv = blake2bmac_init(RETVAL, size, k, (unsigned long)k_len); | |
21 | 21 | if (rv != CRYPT_OK) { |
22 | 22 | Safefree(RETVAL); |
23 | 23 | croak("FATAL: blake2b_init failed: %s", error_to_string(rv)); |
34 | 34 | Crypt::Mac::BLAKE2b |
35 | 35 | clone(Crypt::Mac::BLAKE2b self) |
36 | 36 | CODE: |
37 | Newz(0, RETVAL, 1, struct blake2b_struct); | |
37 | Newz(0, RETVAL, 1, blake2bmac_state); | |
38 | 38 | if (!RETVAL) croak("FATAL: Newz failed"); |
39 | Copy(&self->state, &RETVAL->state, 1, struct blake2b_struct); | |
39 | Copy(self, RETVAL, 1, blake2bmac_state); | |
40 | 40 | OUTPUT: |
41 | 41 | RETVAL |
42 | 42 | |
51 | 51 | for(i = 1; i < items; i++) { |
52 | 52 | in_data = (unsigned char *)SvPVbyte(ST(i), in_data_len); |
53 | 53 | if (in_data_len > 0) { |
54 | rv = blake2bmac_process(&self->state, in_data, (unsigned long)in_data_len); | |
54 | rv = blake2bmac_process(self, in_data, (unsigned long)in_data_len); | |
55 | 55 | if (rv != CRYPT_OK) croak("FATAL: blake2b_process failed: %s", error_to_string(rv)); |
56 | 56 | } |
57 | 57 | } |
72 | 72 | char out[MAXBLOCKSIZE*2]; |
73 | 73 | |
74 | 74 | maclen = sizeof(mac); |
75 | rv = blake2bmac_done(&self->state, mac, &maclen); | |
75 | rv = blake2bmac_done(self, mac, &maclen); | |
76 | 76 | if (rv != CRYPT_OK) croak("FATAL: blake2bmac_done failed: %s", error_to_string(rv)); |
77 | 77 | outlen = sizeof(out); |
78 | 78 | if (ix == 3) { |
14 | 14 | if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar"); |
15 | 15 | k = (unsigned char *) SvPVbyte(key, k_len); |
16 | 16 | |
17 | Newz(0, RETVAL, 1, struct blake2s_struct); | |
17 | Newz(0, RETVAL, 1, blake2smac_state); | |
18 | 18 | if (!RETVAL) croak("FATAL: Newz failed"); |
19 | 19 | |
20 | rv = blake2smac_init(&RETVAL->state, size, k, (unsigned long)k_len); | |
20 | rv = blake2smac_init(RETVAL, size, k, (unsigned long)k_len); | |
21 | 21 | if (rv != CRYPT_OK) { |
22 | 22 | Safefree(RETVAL); |
23 | 23 | croak("FATAL: blake2s_init failed: %s", error_to_string(rv)); |
34 | 34 | Crypt::Mac::BLAKE2s |
35 | 35 | clone(Crypt::Mac::BLAKE2s self) |
36 | 36 | CODE: |
37 | Newz(0, RETVAL, 1, struct blake2s_struct); | |
37 | Newz(0, RETVAL, 1, blake2smac_state); | |
38 | 38 | if (!RETVAL) croak("FATAL: Newz failed"); |
39 | Copy(&self->state, &RETVAL->state, 1, struct blake2s_struct); | |
39 | Copy(self, RETVAL, 1, blake2smac_state); | |
40 | 40 | OUTPUT: |
41 | 41 | RETVAL |
42 | 42 | |
51 | 51 | for(i = 1; i < items; i++) { |
52 | 52 | in_data = (unsigned char *)SvPVbyte(ST(i), in_data_len); |
53 | 53 | if (in_data_len > 0) { |
54 | rv = blake2smac_process(&self->state, in_data, (unsigned long)in_data_len); | |
54 | rv = blake2smac_process(self, in_data, (unsigned long)in_data_len); | |
55 | 55 | if (rv != CRYPT_OK) croak("FATAL: blake2s_process failed: %s", error_to_string(rv)); |
56 | 56 | } |
57 | 57 | } |
72 | 72 | char out[MAXBLOCKSIZE*2]; |
73 | 73 | |
74 | 74 | maclen = sizeof(mac); |
75 | rv = blake2smac_done(&self->state, mac, &maclen); | |
75 | rv = blake2smac_done(self, mac, &maclen); | |
76 | 76 | if (rv != CRYPT_OK) croak("FATAL: blake2smac_done failed: %s", error_to_string(rv)); |
77 | 77 | outlen = sizeof(out); |
78 | 78 | if (ix == 3) { |
18 | 18 | if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar"); |
19 | 19 | k = (unsigned char *) SvPVbyte(key, k_len); |
20 | 20 | |
21 | Newz(0, RETVAL, 1, struct f9_struct); | |
21 | Newz(0, RETVAL, 1, f9_state); | |
22 | 22 | if (!RETVAL) croak("FATAL: Newz failed"); |
23 | 23 | |
24 | rv = f9_init(&RETVAL->state, id, k, (unsigned long)k_len); | |
24 | rv = f9_init(RETVAL, id, k, (unsigned long)k_len); | |
25 | 25 | if (rv != CRYPT_OK) { |
26 | 26 | Safefree(RETVAL); |
27 | 27 | croak("FATAL: f9_init failed: %s", error_to_string(rv)); |
38 | 38 | Crypt::Mac::F9 |
39 | 39 | clone(Crypt::Mac::F9 self) |
40 | 40 | CODE: |
41 | Newz(0, RETVAL, 1, struct f9_struct); | |
41 | Newz(0, RETVAL, 1, f9_state); | |
42 | 42 | if (!RETVAL) croak("FATAL: Newz failed"); |
43 | Copy(&self->state, &RETVAL->state, 1, struct f9_struct); | |
43 | Copy(self, RETVAL, 1, f9_state); | |
44 | 44 | OUTPUT: |
45 | 45 | RETVAL |
46 | 46 | |
55 | 55 | for(i = 1; i < items; i++) { |
56 | 56 | in_data = (unsigned char *)SvPVbyte(ST(i), in_data_len); |
57 | 57 | if (in_data_len > 0) { |
58 | rv = f9_process(&self->state, in_data, (unsigned long)in_data_len); | |
58 | rv = f9_process(self, in_data, (unsigned long)in_data_len); | |
59 | 59 | if (rv != CRYPT_OK) croak("FATAL: f9_process failed: %s", error_to_string(rv)); |
60 | 60 | } |
61 | 61 | } |
76 | 76 | char out[MAXBLOCKSIZE*2]; |
77 | 77 | |
78 | 78 | maclen = sizeof(mac); |
79 | rv = f9_done(&self->state, mac, &maclen); | |
79 | rv = f9_done(self, mac, &maclen); | |
80 | 80 | if (rv != CRYPT_OK) croak("FATAL: f9_done failed: %s", error_to_string(rv)); |
81 | 81 | outlen = sizeof(out); |
82 | 82 | if (ix == 3) { |
18 | 18 | if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar"); |
19 | 19 | k = (unsigned char *) SvPVbyte(key, k_len); |
20 | 20 | |
21 | Newz(0, RETVAL, 1, struct hmac_struct); | |
21 | Newz(0, RETVAL, 1, hmac_state); | |
22 | 22 | if (!RETVAL) croak("FATAL: Newz failed"); |
23 | 23 | |
24 | rv = hmac_init(&RETVAL->state, id, k, (unsigned long)k_len); | |
24 | rv = hmac_init(RETVAL, id, k, (unsigned long)k_len); | |
25 | 25 | if (rv != CRYPT_OK) { |
26 | 26 | Safefree(RETVAL); |
27 | 27 | croak("FATAL: hmac_init failed: %s", error_to_string(rv)); |
38 | 38 | Crypt::Mac::HMAC |
39 | 39 | clone(Crypt::Mac::HMAC self) |
40 | 40 | CODE: |
41 | Newz(0, RETVAL, 1, struct hmac_struct); | |
41 | Newz(0, RETVAL, 1, hmac_state); | |
42 | 42 | if (!RETVAL) croak("FATAL: Newz failed"); |
43 | Copy(&self->state, &RETVAL->state, 1, struct hmac_struct); | |
43 | Copy(self, RETVAL, 1, hmac_state); | |
44 | 44 | OUTPUT: |
45 | 45 | RETVAL |
46 | 46 | |
55 | 55 | for(i = 1; i < items; i++) { |
56 | 56 | in_data = (unsigned char *)SvPVbyte(ST(i), in_data_len); |
57 | 57 | if (in_data_len > 0) { |
58 | rv = hmac_process(&self->state, in_data, (unsigned long)in_data_len); | |
58 | rv = hmac_process(self, in_data, (unsigned long)in_data_len); | |
59 | 59 | if (rv != CRYPT_OK) croak("FATAL: hmac_process failed: %s", error_to_string(rv)); |
60 | 60 | } |
61 | 61 | } |
76 | 76 | char out[MAXBLOCKSIZE*2]; |
77 | 77 | |
78 | 78 | maclen = sizeof(mac); |
79 | rv = hmac_done(&self->state, mac, &maclen); | |
79 | rv = hmac_done(self, mac, &maclen); | |
80 | 80 | if (rv != CRYPT_OK) croak("FATAL: hmac_done failed: %s", error_to_string(rv)); |
81 | 81 | outlen = sizeof(out); |
82 | 82 | if (ix == 3) { |
18 | 18 | if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar"); |
19 | 19 | k = (unsigned char *) SvPVbyte(key, k_len); |
20 | 20 | |
21 | Newz(0, RETVAL, 1, struct omac_struct); | |
21 | Newz(0, RETVAL, 1, omac_state); | |
22 | 22 | if (!RETVAL) croak("FATAL: Newz failed"); |
23 | 23 | |
24 | rv = omac_init(&RETVAL->state, id, k, (unsigned long)k_len); | |
24 | rv = omac_init(RETVAL, id, k, (unsigned long)k_len); | |
25 | 25 | if (rv != CRYPT_OK) { |
26 | 26 | Safefree(RETVAL); |
27 | 27 | croak("FATAL: omac_init failed: %s", error_to_string(rv)); |
38 | 38 | Crypt::Mac::OMAC |
39 | 39 | clone(Crypt::Mac::OMAC self) |
40 | 40 | CODE: |
41 | Newz(0, RETVAL, 1, struct omac_struct); | |
41 | Newz(0, RETVAL, 1, omac_state); | |
42 | 42 | if (!RETVAL) croak("FATAL: Newz failed"); |
43 | Copy(&self->state, &RETVAL->state, 1, struct omac_struct); | |
43 | Copy(self, RETVAL, 1, omac_state); | |
44 | 44 | OUTPUT: |
45 | 45 | RETVAL |
46 | 46 | |
55 | 55 | for(i = 1; i < items; i++) { |
56 | 56 | in_data = (unsigned char *)SvPVbyte(ST(i), in_data_len); |
57 | 57 | if (in_data_len > 0) { |
58 | rv = omac_process(&self->state, in_data, (unsigned long)in_data_len); | |
58 | rv = omac_process(self, in_data, (unsigned long)in_data_len); | |
59 | 59 | if (rv != CRYPT_OK) croak("FATAL: omac_process failed: %s", error_to_string(rv)); |
60 | 60 | } |
61 | 61 | } |
76 | 76 | char out[MAXBLOCKSIZE*2]; |
77 | 77 | |
78 | 78 | maclen = sizeof(mac); |
79 | rv = omac_done(&self->state, mac, &maclen); | |
79 | rv = omac_done(self, mac, &maclen); | |
80 | 80 | if (rv != CRYPT_OK) croak("FATAL: omac_done failed: %s", error_to_string(rv)); |
81 | 81 | outlen = sizeof(out); |
82 | 82 | if (ix == 3) { |
18 | 18 | if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar"); |
19 | 19 | k = (unsigned char *) SvPVbyte(key, k_len); |
20 | 20 | |
21 | Newz(0, RETVAL, 1, struct pmac_struct); | |
21 | Newz(0, RETVAL, 1, pmac_state); | |
22 | 22 | if (!RETVAL) croak("FATAL: Newz failed"); |
23 | 23 | |
24 | rv = pmac_init(&RETVAL->state, id, k, (unsigned long)k_len); | |
24 | rv = pmac_init(RETVAL, id, k, (unsigned long)k_len); | |
25 | 25 | if (rv != CRYPT_OK) { |
26 | 26 | Safefree(RETVAL); |
27 | 27 | croak("FATAL: pmac_init failed: %s", error_to_string(rv)); |
38 | 38 | Crypt::Mac::PMAC |
39 | 39 | clone(Crypt::Mac::PMAC self) |
40 | 40 | CODE: |
41 | Newz(0, RETVAL, 1, struct pmac_struct); | |
41 | Newz(0, RETVAL, 1, pmac_state); | |
42 | 42 | if (!RETVAL) croak("FATAL: Newz failed"); |
43 | Copy(&self->state, &RETVAL->state, 1, struct pmac_struct); | |
43 | Copy(self, RETVAL, 1, pmac_state); | |
44 | 44 | OUTPUT: |
45 | 45 | RETVAL |
46 | 46 | |
55 | 55 | for(i = 1; i < items; i++) { |
56 | 56 | in_data = (unsigned char *)SvPVbyte(ST(i), in_data_len); |
57 | 57 | if (in_data_len > 0) { |
58 | rv = pmac_process(&self->state, in_data, (unsigned long)in_data_len); | |
58 | rv = pmac_process(self, in_data, (unsigned long)in_data_len); | |
59 | 59 | if (rv != CRYPT_OK) croak("FATAL: pmac_process failed: %s", error_to_string(rv)); |
60 | 60 | } |
61 | 61 | } |
76 | 76 | char out[MAXBLOCKSIZE*2]; |
77 | 77 | |
78 | 78 | maclen = sizeof(mac); |
79 | rv = pmac_done(&self->state, mac, &maclen); | |
79 | rv = pmac_done(self, mac, &maclen); | |
80 | 80 | if (rv != CRYPT_OK) croak("FATAL: pmac_done failed: %s", error_to_string(rv)); |
81 | 81 | outlen = sizeof(out); |
82 | 82 | if (ix == 3) { |
14 | 14 | if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar"); |
15 | 15 | k = (unsigned char *) SvPVbyte(key, k_len); |
16 | 16 | |
17 | Newz(0, RETVAL, 1, struct pelican_struct); | |
17 | Newz(0, RETVAL, 1, pelican_state); | |
18 | 18 | if (!RETVAL) croak("FATAL: Newz failed"); |
19 | 19 | |
20 | rv = pelican_init(&RETVAL->state, k, (unsigned long)k_len); | |
20 | rv = pelican_init(RETVAL, k, (unsigned long)k_len); | |
21 | 21 | if (rv != CRYPT_OK) { |
22 | 22 | Safefree(RETVAL); |
23 | 23 | croak("FATAL: pelican_init failed: %s", error_to_string(rv)); |
34 | 34 | Crypt::Mac::Pelican |
35 | 35 | clone(Crypt::Mac::Pelican self) |
36 | 36 | CODE: |
37 | Newz(0, RETVAL, 1, struct pelican_struct); | |
37 | Newz(0, RETVAL, 1, pelican_state); | |
38 | 38 | if (!RETVAL) croak("FATAL: Newz failed"); |
39 | Copy(&self->state, &RETVAL->state, 1, struct pelican_struct); | |
39 | Copy(self, RETVAL, 1, pelican_state); | |
40 | 40 | OUTPUT: |
41 | 41 | RETVAL |
42 | 42 | |
51 | 51 | for(i = 1; i < items; i++) { |
52 | 52 | in_data = (unsigned char *)SvPVbyte(ST(i), in_data_len); |
53 | 53 | if (in_data_len > 0) { |
54 | rv = pelican_process(&self->state, in_data, (unsigned long)in_data_len); | |
54 | rv = pelican_process(self, in_data, (unsigned long)in_data_len); | |
55 | 55 | if (rv != CRYPT_OK) croak("FATAL: pelican_process failed: %s", error_to_string(rv)); |
56 | 56 | } |
57 | 57 | } |
72 | 72 | char out[MAXBLOCKSIZE*2]; |
73 | 73 | |
74 | 74 | maclen = 16; |
75 | rv = pelican_done(&self->state, mac); | |
75 | rv = pelican_done(self, mac); | |
76 | 76 | if (rv != CRYPT_OK) croak("FATAL: pelican_done failed: %s", error_to_string(rv)); |
77 | 77 | outlen = sizeof(out); |
78 | 78 | if (ix == 3) { |
14 | 14 | if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar"); |
15 | 15 | k = (unsigned char *) SvPVbyte(key, k_len); |
16 | 16 | |
17 | Newz(0, RETVAL, 1, struct poly1305_struct); | |
17 | Newz(0, RETVAL, 1, poly1305_state); | |
18 | 18 | if (!RETVAL) croak("FATAL: Newz failed"); |
19 | 19 | |
20 | rv = poly1305_init(&RETVAL->state, k, (unsigned long)k_len); | |
20 | rv = poly1305_init(RETVAL, k, (unsigned long)k_len); | |
21 | 21 | if (rv != CRYPT_OK) { |
22 | 22 | Safefree(RETVAL); |
23 | 23 | croak("FATAL: poly1305_init failed: %s", error_to_string(rv)); |
34 | 34 | Crypt::Mac::Poly1305 |
35 | 35 | clone(Crypt::Mac::Poly1305 self) |
36 | 36 | CODE: |
37 | Newz(0, RETVAL, 1, struct poly1305_struct); | |
37 | Newz(0, RETVAL, 1, poly1305_state); | |
38 | 38 | if (!RETVAL) croak("FATAL: Newz failed"); |
39 | Copy(&self->state, &RETVAL->state, 1, struct poly1305_struct); | |
39 | Copy(self, RETVAL, 1, poly1305_state); | |
40 | 40 | OUTPUT: |
41 | 41 | RETVAL |
42 | 42 | |
51 | 51 | for(i = 1; i < items; i++) { |
52 | 52 | in_data = (unsigned char *)SvPVbyte(ST(i), in_data_len); |
53 | 53 | if (in_data_len > 0) { |
54 | rv = poly1305_process(&self->state, in_data, (unsigned long)in_data_len); | |
54 | rv = poly1305_process(self, in_data, (unsigned long)in_data_len); | |
55 | 55 | if (rv != CRYPT_OK) croak("FATAL: poly1305_process failed: %s", error_to_string(rv)); |
56 | 56 | } |
57 | 57 | } |
72 | 72 | char out[MAXBLOCKSIZE*2]; |
73 | 73 | |
74 | 74 | maclen = sizeof(mac); |
75 | rv = poly1305_done(&self->state, mac, &maclen); | |
75 | rv = poly1305_done(self, mac, &maclen); | |
76 | 76 | if (rv != CRYPT_OK) croak("FATAL: poly1305_done failed: %s", error_to_string(rv)); |
77 | 77 | outlen = sizeof(out); |
78 | 78 | if (ix == 3) { |
18 | 18 | if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar"); |
19 | 19 | k = (unsigned char *) SvPVbyte(key, k_len); |
20 | 20 | |
21 | Newz(0, RETVAL, 1, struct xcbc_struct); | |
21 | Newz(0, RETVAL, 1, xcbc_state); | |
22 | 22 | if (!RETVAL) croak("FATAL: Newz failed"); |
23 | 23 | |
24 | rv = xcbc_init(&RETVAL->state, id, k, (unsigned long)k_len); | |
24 | rv = xcbc_init(RETVAL, id, k, (unsigned long)k_len); | |
25 | 25 | if (rv != CRYPT_OK) { |
26 | 26 | Safefree(RETVAL); |
27 | 27 | croak("FATAL: xcbc_init failed: %s", error_to_string(rv)); |
38 | 38 | Crypt::Mac::XCBC |
39 | 39 | clone(Crypt::Mac::XCBC self) |
40 | 40 | CODE: |
41 | Newz(0, RETVAL, 1, struct xcbc_struct); | |
41 | Newz(0, RETVAL, 1, xcbc_state); | |
42 | 42 | if (!RETVAL) croak("FATAL: Newz failed"); |
43 | Copy(&self->state, &RETVAL->state, 1, struct xcbc_struct); | |
43 | Copy(self, RETVAL, 1, xcbc_state); | |
44 | 44 | OUTPUT: |
45 | 45 | RETVAL |
46 | 46 | |
55 | 55 | for(i = 1; i < items; i++) { |
56 | 56 | in_data = (unsigned char *)SvPVbyte(ST(i), in_data_len); |
57 | 57 | if (in_data_len > 0) { |
58 | rv = xcbc_process(&self->state, in_data, (unsigned long)in_data_len); | |
58 | rv = xcbc_process(self, in_data, (unsigned long)in_data_len); | |
59 | 59 | if (rv != CRYPT_OK) croak("FATAL: xcbc_process failed: %s", error_to_string(rv)); |
60 | 60 | } |
61 | 61 | } |
76 | 76 | char out[MAXBLOCKSIZE*2]; |
77 | 77 | |
78 | 78 | maclen = sizeof(mac); |
79 | rv = xcbc_done(&self->state, mac, &maclen); | |
79 | rv = xcbc_done(self, mac, &maclen); | |
80 | 80 | if (rv != CRYPT_OK) croak("FATAL: xcbc_done failed: %s", error_to_string(rv)); |
81 | 81 | outlen = sizeof(out); |
82 | 82 | if (ix == 3) { |
29 | 29 | Safefree(RETVAL); |
30 | 30 | croak("FATAL: find_prng failed for '%s'", prng_name); |
31 | 31 | } |
32 | RETVAL->id = id; | |
33 | 32 | RETVAL->last_pid = curpid; |
34 | 33 | RETVAL->desc = &prng_descriptor[id]; |
35 | 34 |
14 | 14 | k = (unsigned char *) SvPVbyte(key, k_len); |
15 | 15 | iv = (unsigned char *) SvPVbyte(nonce, iv_len); |
16 | 16 | |
17 | Newz(0, RETVAL, 1, struct chacha_struct); | |
17 | Newz(0, RETVAL, 1, chacha_state); | |
18 | 18 | if (!RETVAL) croak("FATAL: Newz failed"); |
19 | 19 | |
20 | rv = chacha_setup(&RETVAL->state, k, (unsigned long)k_len, rounds); | |
20 | rv = chacha_setup(RETVAL, k, (unsigned long)k_len, rounds); | |
21 | 21 | if (rv != CRYPT_OK) { |
22 | 22 | Safefree(RETVAL); |
23 | 23 | croak("FATAL: chacha_setup failed: %s", error_to_string(rv)); |
24 | 24 | } |
25 | 25 | |
26 | 26 | if (iv_len == 12) { |
27 | rv = chacha_ivctr32(&RETVAL->state, iv, (unsigned long)iv_len, (ulong32)counter); | |
27 | rv = chacha_ivctr32(RETVAL, iv, (unsigned long)iv_len, (ulong32)counter); | |
28 | 28 | if (rv != CRYPT_OK) { |
29 | 29 | Safefree(RETVAL); |
30 | 30 | croak("FATAL: chacha_ivctr32 failed: %s", error_to_string(rv)); |
31 | 31 | } |
32 | 32 | } |
33 | 33 | else if (iv_len == 8) { |
34 | rv = chacha_ivctr64(&RETVAL->state, iv, (unsigned long)iv_len, (ulong64)counter); | |
34 | rv = chacha_ivctr64(RETVAL, iv, (unsigned long)iv_len, (ulong64)counter); | |
35 | 35 | if (rv != CRYPT_OK) { |
36 | 36 | Safefree(RETVAL); |
37 | 37 | croak("FATAL: chacha_ivctr64 failed: %s", error_to_string(rv)); |
48 | 48 | void |
49 | 49 | DESTROY(Crypt::Stream::ChaCha self) |
50 | 50 | CODE: |
51 | chacha_done(&self->state); | |
51 | chacha_done(self); | |
52 | 52 | Safefree(self); |
53 | 53 | |
54 | 54 | Crypt::Stream::ChaCha |
55 | 55 | clone(Crypt::Stream::ChaCha self) |
56 | 56 | CODE: |
57 | Newz(0, RETVAL, 1, struct chacha_struct); | |
57 | Newz(0, RETVAL, 1, chacha_state); | |
58 | 58 | if (!RETVAL) croak("FATAL: Newz failed"); |
59 | Copy(&self->state, &RETVAL->state, 1, struct chacha_struct); | |
59 | Copy(self, RETVAL, 1, chacha_state); | |
60 | 60 | OUTPUT: |
61 | 61 | RETVAL |
62 | 62 | |
75 | 75 | SvPOK_only(RETVAL); |
76 | 76 | SvCUR_set(RETVAL, out_len); |
77 | 77 | out_data = (unsigned char *)SvPVX(RETVAL); |
78 | rv = chacha_keystream(&self->state, out_data, (unsigned long)out_len); | |
78 | rv = chacha_keystream(self, out_data, (unsigned long)out_len); | |
79 | 79 | if (rv != CRYPT_OK) { |
80 | 80 | SvREFCNT_dec(RETVAL); |
81 | 81 | croak("FATAL: chacha_keystream failed: %s", error_to_string(rv)); |
102 | 102 | SvPOK_only(RETVAL); |
103 | 103 | SvCUR_set(RETVAL, in_data_len); |
104 | 104 | out_data = (unsigned char *)SvPVX(RETVAL); |
105 | rv = chacha_crypt(&self->state, in_data, (unsigned long)in_data_len, out_data); | |
105 | rv = chacha_crypt(self, in_data, (unsigned long)in_data_len, out_data); | |
106 | 106 | if (rv != CRYPT_OK) { |
107 | 107 | SvREFCNT_dec(RETVAL); |
108 | 108 | croak("FATAL: chacha_crypt failed: %s", error_to_string(rv)); |
12 | 12 | if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar"); |
13 | 13 | k = (unsigned char *) SvPVbyte(key, k_len); |
14 | 14 | |
15 | Newz(0, RETVAL, 1, struct rc4_struct); | |
15 | Newz(0, RETVAL, 1, rc4_state); | |
16 | 16 | if (!RETVAL) croak("FATAL: Newz failed"); |
17 | 17 | |
18 | rv = rc4_stream_setup(&RETVAL->state, k, (unsigned long)k_len); | |
18 | rv = rc4_stream_setup(RETVAL, k, (unsigned long)k_len); | |
19 | 19 | if (rv != CRYPT_OK) { |
20 | 20 | Safefree(RETVAL); |
21 | 21 | croak("FATAL: rc4_stream_setup failed: %s", error_to_string(rv)); |
27 | 27 | void |
28 | 28 | DESTROY(Crypt::Stream::RC4 self) |
29 | 29 | CODE: |
30 | rc4_stream_done(&self->state); | |
30 | rc4_stream_done(self); | |
31 | 31 | Safefree(self); |
32 | 32 | |
33 | 33 | Crypt::Stream::RC4 |
34 | 34 | clone(Crypt::Stream::RC4 self) |
35 | 35 | CODE: |
36 | Newz(0, RETVAL, 1, struct rc4_struct); | |
36 | Newz(0, RETVAL, 1, rc4_state); | |
37 | 37 | if (!RETVAL) croak("FATAL: Newz failed"); |
38 | Copy(&self->state, &RETVAL->state, 1, struct rc4_struct); | |
38 | Copy(self, RETVAL, 1, rc4_state); | |
39 | 39 | OUTPUT: |
40 | 40 | RETVAL |
41 | 41 | |
54 | 54 | SvPOK_only(RETVAL); |
55 | 55 | SvCUR_set(RETVAL, out_len); |
56 | 56 | out_data = (unsigned char *)SvPVX(RETVAL); |
57 | rv = rc4_stream_keystream(&self->state, out_data, (unsigned long)out_len); | |
57 | rv = rc4_stream_keystream(self, out_data, (unsigned long)out_len); | |
58 | 58 | if (rv != CRYPT_OK) { |
59 | 59 | SvREFCNT_dec(RETVAL); |
60 | 60 | croak("FATAL: rc4_stream_keystream failed: %s", error_to_string(rv)); |
81 | 81 | SvPOK_only(RETVAL); |
82 | 82 | SvCUR_set(RETVAL, in_data_len); |
83 | 83 | out_data = (unsigned char *)SvPVX(RETVAL); |
84 | rv = rc4_stream_crypt(&self->state, in_data, (unsigned long)in_data_len, out_data); | |
84 | rv = rc4_stream_crypt(self, in_data, (unsigned long)in_data_len, out_data); | |
85 | 85 | if (rv != CRYPT_OK) { |
86 | 86 | SvREFCNT_dec(RETVAL); |
87 | 87 | croak("FATAL: rc4_stream_crypt failed: %s", error_to_string(rv)); |
12 | 12 | if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar"); |
13 | 13 | k = (unsigned char *)SvPVbyte(key, k_len); |
14 | 14 | |
15 | Newz(0, RETVAL, 1, struct rabbit_struct); | |
15 | Newz(0, RETVAL, 1, rabbit_state); | |
16 | 16 | if (!RETVAL) croak("FATAL: Newz failed"); |
17 | 17 | |
18 | rv = rabbit_setup(&RETVAL->state, k, (unsigned long)k_len); | |
18 | rv = rabbit_setup(RETVAL, k, (unsigned long)k_len); | |
19 | 19 | if (rv != CRYPT_OK) { |
20 | 20 | Safefree(RETVAL); |
21 | 21 | croak("FATAL: rabbit_setup failed: %s", error_to_string(rv)); |
24 | 24 | if (SvOK(nonce)) { |
25 | 25 | if (!SvPOK(nonce)) croak("FATAL: nonce must be string/buffer scalar"); |
26 | 26 | iv = (unsigned char *)SvPVbyte(nonce, iv_len); |
27 | rv = rabbit_setiv(&RETVAL->state, iv, (unsigned long)iv_len); | |
27 | rv = rabbit_setiv(RETVAL, iv, (unsigned long)iv_len); | |
28 | 28 | if (rv != CRYPT_OK) { |
29 | 29 | Safefree(RETVAL); |
30 | 30 | croak("FATAL: rabbit_setiv failed: %s", error_to_string(rv)); |
38 | 38 | void |
39 | 39 | DESTROY(Crypt::Stream::Rabbit self) |
40 | 40 | CODE: |
41 | rabbit_done(&self->state); | |
41 | rabbit_done(self); | |
42 | 42 | Safefree(self); |
43 | 43 | |
44 | 44 | Crypt::Stream::Rabbit |
45 | 45 | clone(Crypt::Stream::Rabbit self) |
46 | 46 | CODE: |
47 | Newz(0, RETVAL, 1, struct rabbit_struct); | |
47 | Newz(0, RETVAL, 1, rabbit_state); | |
48 | 48 | if (!RETVAL) croak("FATAL: Newz failed"); |
49 | Copy(&self->state, &RETVAL->state, 1, struct rabbit_struct); | |
49 | Copy(self, RETVAL, 1, rabbit_state); | |
50 | 50 | OUTPUT: |
51 | 51 | RETVAL |
52 | 52 | |
65 | 65 | SvPOK_only(RETVAL); |
66 | 66 | SvCUR_set(RETVAL, out_len); |
67 | 67 | out_data = (unsigned char *)SvPVX(RETVAL); |
68 | rv = rabbit_keystream(&self->state, out_data, (unsigned long)out_len); | |
68 | rv = rabbit_keystream(self, out_data, (unsigned long)out_len); | |
69 | 69 | if (rv != CRYPT_OK) { |
70 | 70 | SvREFCNT_dec(RETVAL); |
71 | 71 | croak("FATAL: rabbit_keystream failed: %s", error_to_string(rv)); |
92 | 92 | SvPOK_only(RETVAL); |
93 | 93 | SvCUR_set(RETVAL, in_data_len); |
94 | 94 | out_data = (unsigned char *)SvPVX(RETVAL); |
95 | rv = rabbit_crypt(&self->state, in_data, (unsigned long)in_data_len, out_data); | |
95 | rv = rabbit_crypt(self, in_data, (unsigned long)in_data_len, out_data); | |
96 | 96 | if (rv != CRYPT_OK) { |
97 | 97 | SvREFCNT_dec(RETVAL); |
98 | 98 | croak("FATAL: rabbit_crypt failed: %s", error_to_string(rv)); |
14 | 14 | k = (unsigned char *)SvPVbyte(key, k_len); |
15 | 15 | iv = (unsigned char *)SvPVbyte(nonce, iv_len); |
16 | 16 | |
17 | Newz(0, RETVAL, 1, struct salsa20_struct); | |
17 | Newz(0, RETVAL, 1, salsa20_state); | |
18 | 18 | if (!RETVAL) croak("FATAL: Newz failed"); |
19 | 19 | |
20 | rv = salsa20_setup(&RETVAL->state, k, (unsigned long)k_len, rounds); | |
20 | rv = salsa20_setup(RETVAL, k, (unsigned long)k_len, rounds); | |
21 | 21 | if (rv != CRYPT_OK) { |
22 | 22 | Safefree(RETVAL); |
23 | 23 | croak("FATAL: salsa20_setup failed: %s", error_to_string(rv)); |
24 | 24 | } |
25 | 25 | |
26 | rv = salsa20_ivctr64(&RETVAL->state, iv, (unsigned long)iv_len, (ulong64)counter); | |
26 | rv = salsa20_ivctr64(RETVAL, iv, (unsigned long)iv_len, (ulong64)counter); | |
27 | 27 | if (rv != CRYPT_OK) { |
28 | 28 | Safefree(RETVAL); |
29 | 29 | croak("FATAL: salsa20_ivctr64 failed: %s", error_to_string(rv)); |
35 | 35 | void |
36 | 36 | DESTROY(Crypt::Stream::Salsa20 self) |
37 | 37 | CODE: |
38 | salsa20_done(&self->state); | |
38 | salsa20_done(self); | |
39 | 39 | Safefree(self); |
40 | 40 | |
41 | 41 | Crypt::Stream::Salsa20 |
42 | 42 | clone(Crypt::Stream::Salsa20 self) |
43 | 43 | CODE: |
44 | Newz(0, RETVAL, 1, struct salsa20_struct); | |
44 | Newz(0, RETVAL, 1, salsa20_state); | |
45 | 45 | if (!RETVAL) croak("FATAL: Newz failed"); |
46 | Copy(&self->state, &RETVAL->state, 1, struct salsa20_struct); | |
46 | Copy(self, RETVAL, 1, salsa20_state); | |
47 | 47 | OUTPUT: |
48 | 48 | RETVAL |
49 | 49 | |
62 | 62 | SvPOK_only(RETVAL); |
63 | 63 | SvCUR_set(RETVAL, out_len); |
64 | 64 | out_data = (unsigned char *)SvPVX(RETVAL); |
65 | rv = salsa20_keystream(&self->state, out_data, (unsigned long)out_len); | |
65 | rv = salsa20_keystream(self, out_data, (unsigned long)out_len); | |
66 | 66 | if (rv != CRYPT_OK) { |
67 | 67 | SvREFCNT_dec(RETVAL); |
68 | 68 | croak("FATAL: salsa20_keystream failed: %s", error_to_string(rv)); |
89 | 89 | SvPOK_only(RETVAL); |
90 | 90 | SvCUR_set(RETVAL, in_data_len); |
91 | 91 | out_data = (unsigned char *)SvPVX(RETVAL); |
92 | rv = salsa20_crypt(&self->state, in_data, (unsigned long)in_data_len, out_data); | |
92 | rv = salsa20_crypt(self, in_data, (unsigned long)in_data_len, out_data); | |
93 | 93 | if (rv != CRYPT_OK) { |
94 | 94 | SvREFCNT_dec(RETVAL); |
95 | 95 | croak("FATAL: salsa20_crypt failed: %s", error_to_string(rv)); |
14 | 14 | k = (unsigned char *) SvPVbyte(key, k_len); |
15 | 15 | iv = (unsigned char *) SvPVbyte(nonce, iv_len); |
16 | 16 | |
17 | Newz(0, RETVAL, 1, struct sober128_struct); | |
17 | Newz(0, RETVAL, 1, sober128_state); | |
18 | 18 | if (!RETVAL) croak("FATAL: Newz failed"); |
19 | 19 | |
20 | rv = sober128_stream_setup(&RETVAL->state, k, (unsigned long)k_len); | |
20 | rv = sober128_stream_setup(RETVAL, k, (unsigned long)k_len); | |
21 | 21 | if (rv != CRYPT_OK) { |
22 | 22 | Safefree(RETVAL); |
23 | 23 | croak("FATAL: sober128_stream_setup failed: %s", error_to_string(rv)); |
24 | 24 | } |
25 | 25 | |
26 | rv = sober128_stream_setiv(&RETVAL->state, iv, (unsigned long)iv_len); | |
26 | rv = sober128_stream_setiv(RETVAL, iv, (unsigned long)iv_len); | |
27 | 27 | if (rv != CRYPT_OK) { |
28 | 28 | Safefree(RETVAL); |
29 | 29 | croak("FATAL: sober128_stream_setiv failed: %s", error_to_string(rv)); |
35 | 35 | void |
36 | 36 | DESTROY(Crypt::Stream::Sober128 self) |
37 | 37 | CODE: |
38 | sober128_stream_done(&self->state); | |
38 | sober128_stream_done(self); | |
39 | 39 | Safefree(self); |
40 | 40 | |
41 | 41 | Crypt::Stream::Sober128 |
42 | 42 | clone(Crypt::Stream::Sober128 self) |
43 | 43 | CODE: |
44 | Newz(0, RETVAL, 1, struct sober128_struct); | |
44 | Newz(0, RETVAL, 1, sober128_state); | |
45 | 45 | if (!RETVAL) croak("FATAL: Newz failed"); |
46 | Copy(&self->state, &RETVAL->state, 1, struct sober128_struct); | |
46 | Copy(self, RETVAL, 1, sober128_state); | |
47 | 47 | OUTPUT: |
48 | 48 | RETVAL |
49 | 49 | |
62 | 62 | SvPOK_only(RETVAL); |
63 | 63 | SvCUR_set(RETVAL, out_len); |
64 | 64 | out_data = (unsigned char *)SvPVX(RETVAL); |
65 | rv = sober128_stream_keystream(&self->state, out_data, (unsigned long)out_len); | |
65 | rv = sober128_stream_keystream(self, out_data, (unsigned long)out_len); | |
66 | 66 | if (rv != CRYPT_OK) { |
67 | 67 | SvREFCNT_dec(RETVAL); |
68 | 68 | croak("FATAL: sober128_stream_keystream failed: %s", error_to_string(rv)); |
89 | 89 | SvPOK_only(RETVAL); |
90 | 90 | SvCUR_set(RETVAL, in_data_len); |
91 | 91 | out_data = (unsigned char *)SvPVX(RETVAL); |
92 | rv = sober128_stream_crypt(&self->state, in_data, (unsigned long)in_data_len, out_data); | |
92 | rv = sober128_stream_crypt(self, in_data, (unsigned long)in_data_len, out_data); | |
93 | 93 | if (rv != CRYPT_OK) { |
94 | 94 | SvREFCNT_dec(RETVAL); |
95 | 95 | croak("FATAL: sober128_stream_crypt failed: %s", error_to_string(rv)); |
12 | 12 | if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar"); |
13 | 13 | k = (unsigned char *)SvPVbyte(key, k_len); |
14 | 14 | |
15 | Newz(0, RETVAL, 1, struct sosemanuk_struct); | |
15 | Newz(0, RETVAL, 1, sosemanuk_state); | |
16 | 16 | if (!RETVAL) croak("FATAL: Newz failed"); |
17 | 17 | |
18 | rv = sosemanuk_setup(&RETVAL->state, k, (unsigned long)k_len); | |
18 | rv = sosemanuk_setup(RETVAL, k, (unsigned long)k_len); | |
19 | 19 | if (rv != CRYPT_OK) { |
20 | 20 | Safefree(RETVAL); |
21 | 21 | croak("FATAL: sosemanuk_setup failed: %s", error_to_string(rv)); |
24 | 24 | if (SvOK(nonce)) { |
25 | 25 | if (!SvPOK(nonce)) croak("FATAL: nonce must be string/buffer scalar"); |
26 | 26 | iv = (unsigned char *)SvPVbyte(nonce, iv_len); |
27 | rv = sosemanuk_setiv(&RETVAL->state, iv, (unsigned long)iv_len); | |
27 | rv = sosemanuk_setiv(RETVAL, iv, (unsigned long)iv_len); | |
28 | 28 | } |
29 | 29 | else { |
30 | rv = sosemanuk_setiv(&RETVAL->state, NULL, 0); | |
30 | rv = sosemanuk_setiv(RETVAL, NULL, 0); | |
31 | 31 | } |
32 | 32 | if (rv != CRYPT_OK) { |
33 | 33 | Safefree(RETVAL); |
41 | 41 | void |
42 | 42 | DESTROY(Crypt::Stream::Sosemanuk self) |
43 | 43 | CODE: |
44 | sosemanuk_done(&self->state); | |
44 | sosemanuk_done(self); | |
45 | 45 | Safefree(self); |
46 | 46 | |
47 | 47 | Crypt::Stream::Sosemanuk |
48 | 48 | clone(Crypt::Stream::Sosemanuk self) |
49 | 49 | CODE: |
50 | Newz(0, RETVAL, 1, struct sosemanuk_struct); | |
50 | Newz(0, RETVAL, 1, sosemanuk_state); | |
51 | 51 | if (!RETVAL) croak("FATAL: Newz failed"); |
52 | Copy(&self->state, &RETVAL->state, 1, struct sosemanuk_struct); | |
52 | Copy(self, RETVAL, 1, sosemanuk_state); | |
53 | 53 | OUTPUT: |
54 | 54 | RETVAL |
55 | 55 | |
68 | 68 | SvPOK_only(RETVAL); |
69 | 69 | SvCUR_set(RETVAL, out_len); |
70 | 70 | out_data = (unsigned char *)SvPVX(RETVAL); |
71 | rv = sosemanuk_keystream(&self->state, out_data, (unsigned long)out_len); | |
71 | rv = sosemanuk_keystream(self, out_data, (unsigned long)out_len); | |
72 | 72 | if (rv != CRYPT_OK) { |
73 | 73 | SvREFCNT_dec(RETVAL); |
74 | 74 | croak("FATAL: sosemanuk_keystream failed: %s", error_to_string(rv)); |
95 | 95 | SvPOK_only(RETVAL); |
96 | 96 | SvCUR_set(RETVAL, in_data_len); |
97 | 97 | out_data = (unsigned char *)SvPVX(RETVAL); |
98 | rv = sosemanuk_crypt(&self->state, in_data, (unsigned long)in_data_len, out_data); | |
98 | rv = sosemanuk_crypt(self, in_data, (unsigned long)in_data_len, out_data); | |
99 | 99 | if (rv != CRYPT_OK) { |
100 | 100 | SvREFCNT_dec(RETVAL); |
101 | 101 | croak("FATAL: sosemanuk_crypt failed: %s", error_to_string(rv)); |