Codebase list libcryptx-perl / 8bd1e9d
XS tuning Karel Miko 6 years ago
25 changed file(s) with 231 addition(s) and 342 deletion(s). Raw diff Collapse all Expand all
1111 #include "tomcrypt.h"
1212 #include "tommath.h"
1313
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;
1639
1740 typedef struct cipher_struct { /* used by Crypt::Cipher */
1841 symmetric_key skey;
19 int id;
2042 struct ltc_cipher_descriptor *desc;
2143 } *Crypt__Cipher;
2244
2345 typedef struct digest_struct { /* used by Crypt::Digest */
2446 hash_state state;
25 int id;
2647 struct ltc_hash_descriptor *desc;
2748 } *Crypt__Digest;
2849
3152 int num;
3253 } *Crypt__Digest__SHAKE;
3354
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
13755 typedef struct cbc_struct { /* used by Crypt::Mode::CBC */
13856 int cipher_id, cipher_rounds;
13957 symmetric_CBC state;
14159 int padlen;
14260 int padding_mode;
14361 int direction;
144 int id;
14562 } *Crypt__Mode__CBC;
14663
14764 typedef struct ecb_struct { /* used by Crypt::Mode::ECB */
15168 int padlen;
15269 int padding_mode;
15370 int direction;
154 int id;
15571 } *Crypt__Mode__ECB;
15672
15773 typedef struct cfb_struct { /* used by Crypt::Mode::CFB */
15874 int cipher_id, cipher_rounds;
15975 symmetric_CFB state;
16076 int direction;
161 int id;
16277 } *Crypt__Mode__CFB;
16378
16479 typedef struct ctr_struct { /* used by Crypt::Mode::CTR */
16681 int ctr_mode_param;
16782 symmetric_CTR state;
16883 int direction;
169 int id;
17084 } *Crypt__Mode__CTR;
17185
17286 typedef struct f8_struct { /* used by Crypt::Mode::F8 */
17387 int cipher_id, cipher_rounds;
17488 symmetric_F8 state;
17589 int direction;
176 int id;
17790 } *Crypt__Mode__F8;
17891
17992 typedef struct lrw_struct { /* used by Crypt::Mode::LRW */
18093 int cipher_id, cipher_rounds;
18194 symmetric_LRW state;
18295 int direction;
183 int id;
18496 } *Crypt__Mode__LRW;
18597
18698 typedef struct ofb_struct { /* used by Crypt::Mode::OFB */
18799 int cipher_id, cipher_rounds;
188100 symmetric_OFB state;
189101 int direction;
190 int id;
191102 } *Crypt__Mode__OFB;
192103
193104 typedef struct xts_struct { /* used by Crypt::Mode::XTS */
194105 int cipher_id, cipher_rounds;
195106 symmetric_xts state;
196107 int direction;
197 int id;
198108 } *Crypt__Mode__XTS;
199109
200110 typedef struct prng_struct { /* used by Crypt::PRNG */
201111 prng_state state;
202112 struct ltc_prng_descriptor *desc;
203113 IV last_pid;
204 int id;
205114 } *Crypt__PRNG;
206115
207116 typedef struct rsa_struct { /* used by Crypt::PK::RSA */
208117 prng_state pstate;
209118 int pindex;
210119 rsa_key key;
211 int id;
212120 } *Crypt__PK__RSA;
213121
214122 typedef struct dsa_struct { /* used by Crypt::PK::DSA */
215123 prng_state pstate;
216124 int pindex;
217125 dsa_key key;
218 int id;
219126 } *Crypt__PK__DSA;
220127
221128 typedef struct dh_struct { /* used by Crypt::PK::DH */
222129 prng_state pstate;
223130 int pindex;
224131 dh_key key;
225 int id;
226132 } *Crypt__PK__DH;
227133
228134 typedef struct ecc_struct { /* used by Crypt::PK::ECC */
230136 int pindex;
231137 ecc_key key;
232138 ltc_ecc_set_type dp;
233 int id;
234139 } *Crypt__PK__ECC;
235140
236141 int str_add_leading_zero(char *str, int maxlen, int minlen) {
3535 if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");
3636 k = (unsigned char *) SvPVbyte(key, k_len);
3737
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%]
3943 if (!RETVAL) croak("FATAL: Newz failed");
4044
4145 [%-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);
4751 [%-END%]
4852 if (rv != CRYPT_OK) {
4953 Safefree(RETVAL);
6165 Crypt::Mac::[%orig_name%]
6266 clone(Crypt::Mac::[%orig_name%] self)
6367 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);
6570 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%]
6777 OUTPUT:
6878 RETVAL
6979
7989 in_data = (unsigned char *)SvPVbyte(ST(i), in_data_len);
8090 if (in_data_len > 0) {
8191 [%-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);
8595 [%-END%]
8696 if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_process failed: %s", error_to_string(rv));
8797 }
104114
105115 [%-IF lc_name == 'pelican' %]
106116 maclen = 16;
107 rv = [%lc_name%]_done(&self->state, mac);
117 rv = [%lc_name%]_done(self, mac);
108118 if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_done failed: %s", error_to_string(rv));
109119 [%-ELSIF lc_name == 'blake2s' || lc_name == 'blake2b' %]
110120 maclen = sizeof(mac);
111 rv = [%lc_name%]mac_done(&self->state, mac, &maclen);
121 rv = [%lc_name%]mac_done(self, mac, &maclen);
112122 if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]mac_done failed: %s", error_to_string(rv));
113123 [%-ELSE%]
114124 maclen = sizeof(mac);
115 rv = [%lc_name%]_done(&self->state, mac, &maclen);
125 rv = [%lc_name%]_done(self, mac, &maclen);
116126 if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_done failed: %s", error_to_string(rv));
117127 [%-END%]
118128 outlen = sizeof(out);
2525 id = _find_cipher(cipher_name);
2626 if (id == -1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
2727
28 Newz(0, RETVAL, 1, struct ccm_struct);
28 Newz(0, RETVAL, 1, ccm_state);
2929 if (!RETVAL) croak("FATAL: Newz failed");
3030
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? */
3232 if (rv != CRYPT_OK) {
3333 Safefree(RETVAL);
3434 croak("FATAL: ccm_init failed: %s", error_to_string(rv));
3535 }
36 rv = ccm_add_nonce(&RETVAL->state, n, (unsigned long)n_len);
36 rv = ccm_add_nonce(RETVAL, n, (unsigned long)n_len);
3737 if (rv != CRYPT_OK) {
3838 Safefree(RETVAL);
3939 croak("FATAL: ccm_add_nonce failed: %s", error_to_string(rv));
4040 }
41 rv = ccm_add_aad(&RETVAL->state, h, (unsigned long)h_len);
41 rv = ccm_add_aad(RETVAL, h, (unsigned long)h_len);
4242 if (rv != CRYPT_OK) {
4343 Safefree(RETVAL);
4444 croak("FATAL: ccm_add_aad failed: %s", error_to_string(rv));
4545 }
46 RETVAL->direction = -1;
47 RETVAL->tag_len = tag_len;
48 RETVAL->pt_len = pt_len;
4946 }
5047 OUTPUT:
5148 RETVAL
5855 Crypt::AuthEnc::CCM
5956 clone(Crypt::AuthEnc::CCM self)
6057 CODE:
61 Newz(0, RETVAL, 1, struct ccm_struct);
58 Newz(0, RETVAL, 1, ccm_state);
6259 if (!RETVAL) croak("FATAL: Newz failed");
63 Copy(&self->state, &RETVAL->state, 1, struct ccm_struct);
60 Copy(self, RETVAL, 1, ccm_state);
6461 OUTPUT:
6562 RETVAL
6663
7774 RETVAL = newSVpvn("", 0);
7875 }
7976 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");
8577 RETVAL = NEWSV(0, in_data_len); /* avoid zero! */
8678 SvPOK_only(RETVAL);
8779 SvCUR_set(RETVAL, in_data_len);
8880 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);
9082 if (rv != CRYPT_OK) {
9183 SvREFCNT_dec(RETVAL);
9284 croak("FATAL: ccm_process failed: %s", error_to_string(rv));
9385 }
94 self->pt_len -= (unsigned long)in_data_len;
9586 }
9687 }
9788 OUTPUT:
110101 RETVAL = newSVpvn("", 0);
111102 }
112103 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");
118104 RETVAL = NEWSV(0, in_data_len); /* avoid zero! */
119105 SvPOK_only(RETVAL);
120106 SvCUR_set(RETVAL, in_data_len);
121107 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);
123109 if (rv != CRYPT_OK) {
124110 SvREFCNT_dec(RETVAL);
125111 croak("FATAL: ccm_process failed: %s", error_to_string(rv));
126112 }
127 self->pt_len -= (unsigned long)in_data_len;
128113 }
129114 }
130115 OUTPUT:
136121 {
137122 int rv;
138123 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);
146127 if (rv != CRYPT_OK) croak("FATAL: ccm_done failed: %s", error_to_string(rv));
147128 XPUSHs(sv_2mortal(newSVpvn((char*)tag, tag_len)));
148129 }
153134 {
154135 int rv;
155136 unsigned char tag[MAXBLOCKSIZE];
156 unsigned long tag_len = self->tag_len;
137 unsigned long tag_len = MAXBLOCKSIZE;
157138 STRLEN expected_tag_len;
158139 unsigned char *expected_tag;
159140
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);
165142 if (rv != CRYPT_OK) croak("FATAL: ccm_done failed: %s", error_to_string(rv));
166143 if (items == 1) {
167144 XPUSHs(sv_2mortal(newSVpvn((char*)tag, tag_len)));
1616 iv = (unsigned char *) SvPVbyte(nonce, iv_len);
1717 }
1818
19 Newz(0, RETVAL, 1, struct chacha20poly1305_struct);
19 Newz(0, RETVAL, 1, chacha20poly1305_state);
2020 if (!RETVAL) croak("FATAL: Newz failed");
2121
22 rv = chacha20poly1305_init(&RETVAL->state, k, (unsigned long)k_len);
22 rv = chacha20poly1305_init(RETVAL, k, (unsigned long)k_len);
2323 if (rv != CRYPT_OK) {
2424 Safefree(RETVAL);
2525 croak("FATAL: chacha20poly1305_init failed: %s", error_to_string(rv));
2626 }
2727
2828 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);
3030 if (rv != CRYPT_OK) {
3131 Safefree(RETVAL);
3232 croak("FATAL: chacha20poly1305_setiv failed: %s", error_to_string(rv));
4444 Crypt::AuthEnc::ChaCha20Poly1305
4545 clone(Crypt::AuthEnc::ChaCha20Poly1305 self)
4646 CODE:
47 Newz(0, RETVAL, 1, struct chacha20poly1305_struct);
47 Newz(0, RETVAL, 1, chacha20poly1305_state);
4848 if (!RETVAL) croak("FATAL: Newz failed");
49 Copy(&self->state, &RETVAL->state, 1, struct chacha20poly1305_struct);
49 Copy(self, RETVAL, 1, chacha20poly1305_state);
5050 OUTPUT:
5151 RETVAL
5252
6060
6161 if (!SvPOK(nonce)) croak("FATAL: nonce must be string/buffer scalar");
6262 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);
6464 if (rv != CRYPT_OK) croak("FATAL: chacha20poly1305_setiv failed: %s", error_to_string(rv));
6565 XPUSHs(ST(0)); /* return self */;
6666 }
7575
7676 if (!SvPOK(nonce)) croak("FATAL: nonce must be string/buffer scalar");
7777 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);
7979 if (rv != CRYPT_OK) croak("FATAL: chacha20poly1305_setiv_rfc7905 failed: %s", error_to_string(rv));
8080 XPUSHs(ST(0)); /* return self */
8181 }
8989 unsigned char *in_data;
9090
9191 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);
9393 if (rv != CRYPT_OK) croak("FATAL: chacha20poly1305_add_aad failed: %s", error_to_string(rv));
9494 XPUSHs(ST(0)); /* return self */
9595 }
111111 SvPOK_only(RETVAL);
112112 SvCUR_set(RETVAL, in_data_len);
113113 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);
115115 if (rv != CRYPT_OK) {
116116 SvREFCNT_dec(RETVAL);
117117 croak("FATAL: chacha20poly1305_decrypt failed: %s", error_to_string(rv));
138138 SvPOK_only(RETVAL);
139139 SvCUR_set(RETVAL, in_data_len);
140140 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);
142142 if (rv != CRYPT_OK) {
143143 SvREFCNT_dec(RETVAL);
144144 croak("FATAL: chacha20poly1305_encrypt failed: %s", error_to_string(rv));
156156 unsigned char tag[MAXBLOCKSIZE];
157157 unsigned long tag_len = sizeof(tag);
158158
159 rv = chacha20poly1305_done(&self->state, tag, &tag_len);
159 rv = chacha20poly1305_done(self, tag, &tag_len);
160160 if (rv != CRYPT_OK) croak("FATAL: chacha20poly1305_done failed: %s", error_to_string(rv));
161161 XPUSHs(sv_2mortal(newSVpvn((char*)tag, tag_len)));
162162 }
171171 STRLEN expected_tag_len;
172172 unsigned char *expected_tag;
173173
174 rv = chacha20poly1305_done(&self->state, tag, &tag_len);
174 rv = chacha20poly1305_done(self, tag, &tag_len);
175175 if (rv != CRYPT_OK) croak("FATAL: chacha20poly1305_done failed: %s", error_to_string(rv));
176176 if (items == 1) {
177177 XPUSHs(sv_2mortal(newSVpvn((char*)tag, tag_len)));
2525 id = _find_cipher(cipher_name);
2626 if (id == -1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
2727
28 Newz(0, RETVAL, 1, struct eax_struct);
28 Newz(0, RETVAL, 1, eax_state);
2929 if (!RETVAL) croak("FATAL: Newz failed");
3030
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);
3232 if (rv != CRYPT_OK) {
3333 Safefree(RETVAL);
3434 croak("FATAL: eax setup failed: %s", error_to_string(rv));
4545 Crypt::AuthEnc::EAX
4646 clone(Crypt::AuthEnc::EAX self)
4747 CODE:
48 Newz(0, RETVAL, 1, struct eax_struct);
48 Newz(0, RETVAL, 1, eax_state);
4949 if (!RETVAL) croak("FATAL: Newz failed");
50 Copy(&self->state, &RETVAL->state, 1, struct eax_struct);
50 Copy(self, RETVAL, 1, eax_state);
5151 OUTPUT:
5252 RETVAL
5353
6868 SvPOK_only(RETVAL);
6969 SvCUR_set(RETVAL, in_data_len);
7070 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);
7272 if (rv != CRYPT_OK) {
7373 SvREFCNT_dec(RETVAL);
7474 croak("FATAL: eax_encrypt failed: %s", error_to_string(rv));
9595 SvPOK_only(RETVAL);
9696 SvCUR_set(RETVAL, in_data_len);
9797 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);
9999 if (rv != CRYPT_OK) {
100100 SvREFCNT_dec(RETVAL);
101101 croak("FATAL: eax_decrypt failed: %s", error_to_string(rv));
113113 unsigned char tag[MAXBLOCKSIZE];
114114 unsigned long tag_len = sizeof(tag);
115115
116 rv = eax_done(&self->state, tag, &tag_len);
116 rv = eax_done(self, tag, &tag_len);
117117 if (rv != CRYPT_OK) croak("FATAL: eax_done failed: %s", error_to_string(rv));
118118 XPUSHs(sv_2mortal(newSVpvn((char*)tag, tag_len)));
119119 }
128128 STRLEN expected_tag_len;
129129 unsigned char *expected_tag;
130130
131 rv = eax_done(&self->state, tag, &tag_len);
131 rv = eax_done(self, tag, &tag_len);
132132 if (rv != CRYPT_OK) croak("FATAL: eax_done failed: %s", error_to_string(rv));
133133 if (items == 1) {
134134 XPUSHs(sv_2mortal(newSVpvn((char*)tag, tag_len)));
156156 int rv;
157157 unsigned char *h;
158158 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);
160160 if (rv != CRYPT_OK) croak("FATAL: eax_addheader failed: %s", error_to_string(rv));
161161 XPUSHs(ST(0)); /* return self */
162162 }
1919 id = _find_cipher(cipher_name);
2020 if (id == -1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
2121
22 Newz(0, RETVAL, 1, struct gcm_struct);
22 Newz(0, RETVAL, 1, gcm_state);
2323 if (!RETVAL) croak("FATAL: Newz failed");
2424
25 rv = gcm_init(&RETVAL->state, id, k, (unsigned long)k_len);
25 rv = gcm_init(RETVAL, id, k, (unsigned long)k_len);
2626 if (rv != CRYPT_OK) {
2727 Safefree(RETVAL);
2828 croak("FATAL: gcm_init failed: %s", error_to_string(rv));
2929 }
3030
3131 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);
3333 if (rv != CRYPT_OK) {
3434 Safefree(RETVAL);
3535 croak("FATAL: gcm_add_iv failed: %s", error_to_string(rv));
4747 Crypt::AuthEnc::GCM
4848 clone(Crypt::AuthEnc::GCM self)
4949 CODE:
50 Newz(0, RETVAL, 1, struct gcm_struct);
50 Newz(0, RETVAL, 1, gcm_state);
5151 if (!RETVAL) croak("FATAL: Newz failed");
52 Copy(&self->state, &RETVAL->state, 1, struct gcm_struct);
52 Copy(self, RETVAL, 1, gcm_state);
5353 OUTPUT:
5454 RETVAL
5555
5858 PPCODE:
5959 {
6060 int rv;
61 rv = gcm_reset(&self->state);
61 rv = gcm_reset(self);
6262 if (rv != CRYPT_OK) croak("FATAL: gcm_reset failed: %s", error_to_string(rv));
6363 XPUSHs(ST(0)); /* return self */
6464 }
8181 SvPOK_only(RETVAL);
8282 SvCUR_set(RETVAL, in_data_len);
8383 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);
8585 if (rv != CRYPT_OK) {
8686 SvREFCNT_dec(RETVAL);
8787 croak("FATAL: encrypt_add/gcm_process failed: %s", error_to_string(rv));
100100 unsigned char *in_data;
101101
102102 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);
104104 if (rv != CRYPT_OK) croak("FATAL: gcm_add_iv failed: %s", error_to_string(rv));
105105 XPUSHs(ST(0)); /* return self */
106106 }
114114 unsigned char *in_data;
115115
116116 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);
118118 if (rv != CRYPT_OK) croak("FATAL: gcm_add_aad failed: %s", error_to_string(rv));
119119 XPUSHs(ST(0)); /* return self */
120120 }
136136 SvPOK_only(RETVAL);
137137 SvCUR_set(RETVAL, in_data_len);
138138 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);
140140 if (rv != CRYPT_OK) {
141141 SvREFCNT_dec(RETVAL);
142142 croak("FATAL: encrypt_add/gcm_process failed: %s", error_to_string(rv));
155155 unsigned char tag[MAXBLOCKSIZE];
156156 unsigned long tag_len = sizeof(tag);
157157
158 rv = gcm_done(&self->state, tag, &tag_len);
158 rv = gcm_done(self, tag, &tag_len);
159159 if (rv != CRYPT_OK) croak("FATAL: gcm_done failed: %s", error_to_string(rv));
160160 XPUSHs(sv_2mortal(newSVpvn((char*)tag, tag_len)));
161161 }
170170 STRLEN expected_tag_len;
171171 unsigned char *expected_tag;
172172
173 rv = gcm_done(&self->state, tag, &tag_len);
173 rv = gcm_done(self, tag, &tag_len);
174174 if (rv != CRYPT_OK) croak("FATAL: gcm_done failed: %s", error_to_string(rv));
175175 if (items == 1) {
176176 XPUSHs(sv_2mortal(newSVpvn((char*)tag, tag_len)));
1919 id = _find_cipher(cipher_name);
2020 if (id == -1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
2121
22 Newz(0, RETVAL, 1, struct ocb_struct);
22 Newz(0, RETVAL, 1, ocb3_state);
2323 if (!RETVAL) croak("FATAL: Newz failed");
2424
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);
2626 if (rv != CRYPT_OK) {
2727 Safefree(RETVAL);
2828 croak("FATAL: ocb setup failed: %s", error_to_string(rv));
3939 Crypt::AuthEnc::OCB
4040 clone(Crypt::AuthEnc::OCB self)
4141 CODE:
42 Newz(0, RETVAL, 1, struct ocb_struct);
42 Newz(0, RETVAL, 1, ocb3_state);
4343 if (!RETVAL) croak("FATAL: Newz failed");
44 Copy(&self->state, &RETVAL->state, 1, struct ocb_struct);
44 Copy(self, RETVAL, 1, ocb3_state);
4545 OUTPUT:
4646 RETVAL
4747
5656 in_data = (unsigned char *)SvPVbyte(data, in_data_len);
5757
5858 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);
6060 if (rv != CRYPT_OK) croak("FATAL: ocb3_add_aad failed: %s", error_to_string(rv));
6161 }
6262 XPUSHs(ST(0)); /* return self */
8282 SvPOK_only(RETVAL);
8383 SvCUR_set(RETVAL, in_data_len);
8484 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);
8686 if (rv != CRYPT_OK) {
8787 SvREFCNT_dec(RETVAL);
8888 croak("FATAL: ocb3_encrypt failed: %s", error_to_string(rv));
102102
103103 in_data = (unsigned char *)SvPVbyte(data, in_data_len);
104104 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);
117117 if (rv != CRYPT_OK) {
118118 SvREFCNT_dec(RETVAL);
119119 croak("FATAL: ocb3_encrypt_last failed: %s", error_to_string(rv));
143143 SvPOK_only(RETVAL);
144144 SvCUR_set(RETVAL, in_data_len);
145145 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);
147147 if (rv != CRYPT_OK) {
148148 SvREFCNT_dec(RETVAL);
149149 croak("FATAL: ocb3_decrypt failed: %s", error_to_string(rv));
163163
164164 in_data = (unsigned char *)SvPVbyte(data, in_data_len);
165165 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);
178178 if (rv != CRYPT_OK) {
179179 SvREFCNT_dec(RETVAL);
180180 croak("FATAL: ocb3_encrypt_last failed: %s", error_to_string(rv));
192192 unsigned char tag[MAXBLOCKSIZE];
193193 unsigned long tag_len = sizeof(tag);
194194
195 rv = ocb3_done(&self->state, tag, &tag_len);
195 rv = ocb3_done(self, tag, &tag_len);
196196 if (rv != CRYPT_OK) croak("FATAL: ocb3_done_encrypt failed: %s", error_to_string(rv));
197197
198198 XPUSHs(sv_2mortal(newSVpvn((char*)tag, tag_len)));
208208 STRLEN expected_tag_len;
209209 unsigned char *expected_tag;
210210
211 rv = ocb3_done(&self->state, tag, &tag_len);
211 rv = ocb3_done(self, tag, &tag_len);
212212 if (rv != CRYPT_OK) croak("FATAL: ocb3_done_decrypt failed: %s", error_to_string(rv));
213213 if (items == 1) {
214214 XPUSHs(sv_2mortal(newSVpvn((char*)tag, tag_len)));
3030 Newz(0, RETVAL, 1, struct cipher_struct);
3131 if (!RETVAL) croak("FATAL: Newz failed");
3232
33 RETVAL->id = id;
3433 RETVAL->desc = &cipher_descriptor[id];
3534 rv = RETVAL->desc->setup(key_data, (int)key_len, rounds, &RETVAL->skey);
3635 if (rv != CRYPT_OK) {
1515 Newz(0, RETVAL, 1, struct digest_struct);
1616 if (!RETVAL) croak("FATAL: Newz failed");
1717
18 RETVAL->id = id;
1918 RETVAL->desc = &hash_descriptor[id];
2019 rv = RETVAL->desc->init(&RETVAL->state);
2120 if (rv != CRYPT_OK) {
1414 if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");
1515 k = (unsigned char *) SvPVbyte(key, k_len);
1616
17 Newz(0, RETVAL, 1, struct blake2b_struct);
17 Newz(0, RETVAL, 1, blake2bmac_state);
1818 if (!RETVAL) croak("FATAL: Newz failed");
1919
20 rv = blake2bmac_init(&RETVAL->state, size, k, (unsigned long)k_len);
20 rv = blake2bmac_init(RETVAL, size, k, (unsigned long)k_len);
2121 if (rv != CRYPT_OK) {
2222 Safefree(RETVAL);
2323 croak("FATAL: blake2b_init failed: %s", error_to_string(rv));
3434 Crypt::Mac::BLAKE2b
3535 clone(Crypt::Mac::BLAKE2b self)
3636 CODE:
37 Newz(0, RETVAL, 1, struct blake2b_struct);
37 Newz(0, RETVAL, 1, blake2bmac_state);
3838 if (!RETVAL) croak("FATAL: Newz failed");
39 Copy(&self->state, &RETVAL->state, 1, struct blake2b_struct);
39 Copy(self, RETVAL, 1, blake2bmac_state);
4040 OUTPUT:
4141 RETVAL
4242
5151 for(i = 1; i < items; i++) {
5252 in_data = (unsigned char *)SvPVbyte(ST(i), in_data_len);
5353 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);
5555 if (rv != CRYPT_OK) croak("FATAL: blake2b_process failed: %s", error_to_string(rv));
5656 }
5757 }
7272 char out[MAXBLOCKSIZE*2];
7373
7474 maclen = sizeof(mac);
75 rv = blake2bmac_done(&self->state, mac, &maclen);
75 rv = blake2bmac_done(self, mac, &maclen);
7676 if (rv != CRYPT_OK) croak("FATAL: blake2bmac_done failed: %s", error_to_string(rv));
7777 outlen = sizeof(out);
7878 if (ix == 3) {
1414 if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");
1515 k = (unsigned char *) SvPVbyte(key, k_len);
1616
17 Newz(0, RETVAL, 1, struct blake2s_struct);
17 Newz(0, RETVAL, 1, blake2smac_state);
1818 if (!RETVAL) croak("FATAL: Newz failed");
1919
20 rv = blake2smac_init(&RETVAL->state, size, k, (unsigned long)k_len);
20 rv = blake2smac_init(RETVAL, size, k, (unsigned long)k_len);
2121 if (rv != CRYPT_OK) {
2222 Safefree(RETVAL);
2323 croak("FATAL: blake2s_init failed: %s", error_to_string(rv));
3434 Crypt::Mac::BLAKE2s
3535 clone(Crypt::Mac::BLAKE2s self)
3636 CODE:
37 Newz(0, RETVAL, 1, struct blake2s_struct);
37 Newz(0, RETVAL, 1, blake2smac_state);
3838 if (!RETVAL) croak("FATAL: Newz failed");
39 Copy(&self->state, &RETVAL->state, 1, struct blake2s_struct);
39 Copy(self, RETVAL, 1, blake2smac_state);
4040 OUTPUT:
4141 RETVAL
4242
5151 for(i = 1; i < items; i++) {
5252 in_data = (unsigned char *)SvPVbyte(ST(i), in_data_len);
5353 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);
5555 if (rv != CRYPT_OK) croak("FATAL: blake2s_process failed: %s", error_to_string(rv));
5656 }
5757 }
7272 char out[MAXBLOCKSIZE*2];
7373
7474 maclen = sizeof(mac);
75 rv = blake2smac_done(&self->state, mac, &maclen);
75 rv = blake2smac_done(self, mac, &maclen);
7676 if (rv != CRYPT_OK) croak("FATAL: blake2smac_done failed: %s", error_to_string(rv));
7777 outlen = sizeof(out);
7878 if (ix == 3) {
1818 if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");
1919 k = (unsigned char *) SvPVbyte(key, k_len);
2020
21 Newz(0, RETVAL, 1, struct f9_struct);
21 Newz(0, RETVAL, 1, f9_state);
2222 if (!RETVAL) croak("FATAL: Newz failed");
2323
24 rv = f9_init(&RETVAL->state, id, k, (unsigned long)k_len);
24 rv = f9_init(RETVAL, id, k, (unsigned long)k_len);
2525 if (rv != CRYPT_OK) {
2626 Safefree(RETVAL);
2727 croak("FATAL: f9_init failed: %s", error_to_string(rv));
3838 Crypt::Mac::F9
3939 clone(Crypt::Mac::F9 self)
4040 CODE:
41 Newz(0, RETVAL, 1, struct f9_struct);
41 Newz(0, RETVAL, 1, f9_state);
4242 if (!RETVAL) croak("FATAL: Newz failed");
43 Copy(&self->state, &RETVAL->state, 1, struct f9_struct);
43 Copy(self, RETVAL, 1, f9_state);
4444 OUTPUT:
4545 RETVAL
4646
5555 for(i = 1; i < items; i++) {
5656 in_data = (unsigned char *)SvPVbyte(ST(i), in_data_len);
5757 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);
5959 if (rv != CRYPT_OK) croak("FATAL: f9_process failed: %s", error_to_string(rv));
6060 }
6161 }
7676 char out[MAXBLOCKSIZE*2];
7777
7878 maclen = sizeof(mac);
79 rv = f9_done(&self->state, mac, &maclen);
79 rv = f9_done(self, mac, &maclen);
8080 if (rv != CRYPT_OK) croak("FATAL: f9_done failed: %s", error_to_string(rv));
8181 outlen = sizeof(out);
8282 if (ix == 3) {
1818 if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");
1919 k = (unsigned char *) SvPVbyte(key, k_len);
2020
21 Newz(0, RETVAL, 1, struct hmac_struct);
21 Newz(0, RETVAL, 1, hmac_state);
2222 if (!RETVAL) croak("FATAL: Newz failed");
2323
24 rv = hmac_init(&RETVAL->state, id, k, (unsigned long)k_len);
24 rv = hmac_init(RETVAL, id, k, (unsigned long)k_len);
2525 if (rv != CRYPT_OK) {
2626 Safefree(RETVAL);
2727 croak("FATAL: hmac_init failed: %s", error_to_string(rv));
3838 Crypt::Mac::HMAC
3939 clone(Crypt::Mac::HMAC self)
4040 CODE:
41 Newz(0, RETVAL, 1, struct hmac_struct);
41 Newz(0, RETVAL, 1, hmac_state);
4242 if (!RETVAL) croak("FATAL: Newz failed");
43 Copy(&self->state, &RETVAL->state, 1, struct hmac_struct);
43 Copy(self, RETVAL, 1, hmac_state);
4444 OUTPUT:
4545 RETVAL
4646
5555 for(i = 1; i < items; i++) {
5656 in_data = (unsigned char *)SvPVbyte(ST(i), in_data_len);
5757 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);
5959 if (rv != CRYPT_OK) croak("FATAL: hmac_process failed: %s", error_to_string(rv));
6060 }
6161 }
7676 char out[MAXBLOCKSIZE*2];
7777
7878 maclen = sizeof(mac);
79 rv = hmac_done(&self->state, mac, &maclen);
79 rv = hmac_done(self, mac, &maclen);
8080 if (rv != CRYPT_OK) croak("FATAL: hmac_done failed: %s", error_to_string(rv));
8181 outlen = sizeof(out);
8282 if (ix == 3) {
1818 if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");
1919 k = (unsigned char *) SvPVbyte(key, k_len);
2020
21 Newz(0, RETVAL, 1, struct omac_struct);
21 Newz(0, RETVAL, 1, omac_state);
2222 if (!RETVAL) croak("FATAL: Newz failed");
2323
24 rv = omac_init(&RETVAL->state, id, k, (unsigned long)k_len);
24 rv = omac_init(RETVAL, id, k, (unsigned long)k_len);
2525 if (rv != CRYPT_OK) {
2626 Safefree(RETVAL);
2727 croak("FATAL: omac_init failed: %s", error_to_string(rv));
3838 Crypt::Mac::OMAC
3939 clone(Crypt::Mac::OMAC self)
4040 CODE:
41 Newz(0, RETVAL, 1, struct omac_struct);
41 Newz(0, RETVAL, 1, omac_state);
4242 if (!RETVAL) croak("FATAL: Newz failed");
43 Copy(&self->state, &RETVAL->state, 1, struct omac_struct);
43 Copy(self, RETVAL, 1, omac_state);
4444 OUTPUT:
4545 RETVAL
4646
5555 for(i = 1; i < items; i++) {
5656 in_data = (unsigned char *)SvPVbyte(ST(i), in_data_len);
5757 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);
5959 if (rv != CRYPT_OK) croak("FATAL: omac_process failed: %s", error_to_string(rv));
6060 }
6161 }
7676 char out[MAXBLOCKSIZE*2];
7777
7878 maclen = sizeof(mac);
79 rv = omac_done(&self->state, mac, &maclen);
79 rv = omac_done(self, mac, &maclen);
8080 if (rv != CRYPT_OK) croak("FATAL: omac_done failed: %s", error_to_string(rv));
8181 outlen = sizeof(out);
8282 if (ix == 3) {
1818 if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");
1919 k = (unsigned char *) SvPVbyte(key, k_len);
2020
21 Newz(0, RETVAL, 1, struct pmac_struct);
21 Newz(0, RETVAL, 1, pmac_state);
2222 if (!RETVAL) croak("FATAL: Newz failed");
2323
24 rv = pmac_init(&RETVAL->state, id, k, (unsigned long)k_len);
24 rv = pmac_init(RETVAL, id, k, (unsigned long)k_len);
2525 if (rv != CRYPT_OK) {
2626 Safefree(RETVAL);
2727 croak("FATAL: pmac_init failed: %s", error_to_string(rv));
3838 Crypt::Mac::PMAC
3939 clone(Crypt::Mac::PMAC self)
4040 CODE:
41 Newz(0, RETVAL, 1, struct pmac_struct);
41 Newz(0, RETVAL, 1, pmac_state);
4242 if (!RETVAL) croak("FATAL: Newz failed");
43 Copy(&self->state, &RETVAL->state, 1, struct pmac_struct);
43 Copy(self, RETVAL, 1, pmac_state);
4444 OUTPUT:
4545 RETVAL
4646
5555 for(i = 1; i < items; i++) {
5656 in_data = (unsigned char *)SvPVbyte(ST(i), in_data_len);
5757 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);
5959 if (rv != CRYPT_OK) croak("FATAL: pmac_process failed: %s", error_to_string(rv));
6060 }
6161 }
7676 char out[MAXBLOCKSIZE*2];
7777
7878 maclen = sizeof(mac);
79 rv = pmac_done(&self->state, mac, &maclen);
79 rv = pmac_done(self, mac, &maclen);
8080 if (rv != CRYPT_OK) croak("FATAL: pmac_done failed: %s", error_to_string(rv));
8181 outlen = sizeof(out);
8282 if (ix == 3) {
1414 if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");
1515 k = (unsigned char *) SvPVbyte(key, k_len);
1616
17 Newz(0, RETVAL, 1, struct pelican_struct);
17 Newz(0, RETVAL, 1, pelican_state);
1818 if (!RETVAL) croak("FATAL: Newz failed");
1919
20 rv = pelican_init(&RETVAL->state, k, (unsigned long)k_len);
20 rv = pelican_init(RETVAL, k, (unsigned long)k_len);
2121 if (rv != CRYPT_OK) {
2222 Safefree(RETVAL);
2323 croak("FATAL: pelican_init failed: %s", error_to_string(rv));
3434 Crypt::Mac::Pelican
3535 clone(Crypt::Mac::Pelican self)
3636 CODE:
37 Newz(0, RETVAL, 1, struct pelican_struct);
37 Newz(0, RETVAL, 1, pelican_state);
3838 if (!RETVAL) croak("FATAL: Newz failed");
39 Copy(&self->state, &RETVAL->state, 1, struct pelican_struct);
39 Copy(self, RETVAL, 1, pelican_state);
4040 OUTPUT:
4141 RETVAL
4242
5151 for(i = 1; i < items; i++) {
5252 in_data = (unsigned char *)SvPVbyte(ST(i), in_data_len);
5353 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);
5555 if (rv != CRYPT_OK) croak("FATAL: pelican_process failed: %s", error_to_string(rv));
5656 }
5757 }
7272 char out[MAXBLOCKSIZE*2];
7373
7474 maclen = 16;
75 rv = pelican_done(&self->state, mac);
75 rv = pelican_done(self, mac);
7676 if (rv != CRYPT_OK) croak("FATAL: pelican_done failed: %s", error_to_string(rv));
7777 outlen = sizeof(out);
7878 if (ix == 3) {
1414 if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");
1515 k = (unsigned char *) SvPVbyte(key, k_len);
1616
17 Newz(0, RETVAL, 1, struct poly1305_struct);
17 Newz(0, RETVAL, 1, poly1305_state);
1818 if (!RETVAL) croak("FATAL: Newz failed");
1919
20 rv = poly1305_init(&RETVAL->state, k, (unsigned long)k_len);
20 rv = poly1305_init(RETVAL, k, (unsigned long)k_len);
2121 if (rv != CRYPT_OK) {
2222 Safefree(RETVAL);
2323 croak("FATAL: poly1305_init failed: %s", error_to_string(rv));
3434 Crypt::Mac::Poly1305
3535 clone(Crypt::Mac::Poly1305 self)
3636 CODE:
37 Newz(0, RETVAL, 1, struct poly1305_struct);
37 Newz(0, RETVAL, 1, poly1305_state);
3838 if (!RETVAL) croak("FATAL: Newz failed");
39 Copy(&self->state, &RETVAL->state, 1, struct poly1305_struct);
39 Copy(self, RETVAL, 1, poly1305_state);
4040 OUTPUT:
4141 RETVAL
4242
5151 for(i = 1; i < items; i++) {
5252 in_data = (unsigned char *)SvPVbyte(ST(i), in_data_len);
5353 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);
5555 if (rv != CRYPT_OK) croak("FATAL: poly1305_process failed: %s", error_to_string(rv));
5656 }
5757 }
7272 char out[MAXBLOCKSIZE*2];
7373
7474 maclen = sizeof(mac);
75 rv = poly1305_done(&self->state, mac, &maclen);
75 rv = poly1305_done(self, mac, &maclen);
7676 if (rv != CRYPT_OK) croak("FATAL: poly1305_done failed: %s", error_to_string(rv));
7777 outlen = sizeof(out);
7878 if (ix == 3) {
1818 if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");
1919 k = (unsigned char *) SvPVbyte(key, k_len);
2020
21 Newz(0, RETVAL, 1, struct xcbc_struct);
21 Newz(0, RETVAL, 1, xcbc_state);
2222 if (!RETVAL) croak("FATAL: Newz failed");
2323
24 rv = xcbc_init(&RETVAL->state, id, k, (unsigned long)k_len);
24 rv = xcbc_init(RETVAL, id, k, (unsigned long)k_len);
2525 if (rv != CRYPT_OK) {
2626 Safefree(RETVAL);
2727 croak("FATAL: xcbc_init failed: %s", error_to_string(rv));
3838 Crypt::Mac::XCBC
3939 clone(Crypt::Mac::XCBC self)
4040 CODE:
41 Newz(0, RETVAL, 1, struct xcbc_struct);
41 Newz(0, RETVAL, 1, xcbc_state);
4242 if (!RETVAL) croak("FATAL: Newz failed");
43 Copy(&self->state, &RETVAL->state, 1, struct xcbc_struct);
43 Copy(self, RETVAL, 1, xcbc_state);
4444 OUTPUT:
4545 RETVAL
4646
5555 for(i = 1; i < items; i++) {
5656 in_data = (unsigned char *)SvPVbyte(ST(i), in_data_len);
5757 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);
5959 if (rv != CRYPT_OK) croak("FATAL: xcbc_process failed: %s", error_to_string(rv));
6060 }
6161 }
7676 char out[MAXBLOCKSIZE*2];
7777
7878 maclen = sizeof(mac);
79 rv = xcbc_done(&self->state, mac, &maclen);
79 rv = xcbc_done(self, mac, &maclen);
8080 if (rv != CRYPT_OK) croak("FATAL: xcbc_done failed: %s", error_to_string(rv));
8181 outlen = sizeof(out);
8282 if (ix == 3) {
2929 Safefree(RETVAL);
3030 croak("FATAL: find_prng failed for '%s'", prng_name);
3131 }
32 RETVAL->id = id;
3332 RETVAL->last_pid = curpid;
3433 RETVAL->desc = &prng_descriptor[id];
3534
1414 k = (unsigned char *) SvPVbyte(key, k_len);
1515 iv = (unsigned char *) SvPVbyte(nonce, iv_len);
1616
17 Newz(0, RETVAL, 1, struct chacha_struct);
17 Newz(0, RETVAL, 1, chacha_state);
1818 if (!RETVAL) croak("FATAL: Newz failed");
1919
20 rv = chacha_setup(&RETVAL->state, k, (unsigned long)k_len, rounds);
20 rv = chacha_setup(RETVAL, k, (unsigned long)k_len, rounds);
2121 if (rv != CRYPT_OK) {
2222 Safefree(RETVAL);
2323 croak("FATAL: chacha_setup failed: %s", error_to_string(rv));
2424 }
2525
2626 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);
2828 if (rv != CRYPT_OK) {
2929 Safefree(RETVAL);
3030 croak("FATAL: chacha_ivctr32 failed: %s", error_to_string(rv));
3131 }
3232 }
3333 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);
3535 if (rv != CRYPT_OK) {
3636 Safefree(RETVAL);
3737 croak("FATAL: chacha_ivctr64 failed: %s", error_to_string(rv));
4848 void
4949 DESTROY(Crypt::Stream::ChaCha self)
5050 CODE:
51 chacha_done(&self->state);
51 chacha_done(self);
5252 Safefree(self);
5353
5454 Crypt::Stream::ChaCha
5555 clone(Crypt::Stream::ChaCha self)
5656 CODE:
57 Newz(0, RETVAL, 1, struct chacha_struct);
57 Newz(0, RETVAL, 1, chacha_state);
5858 if (!RETVAL) croak("FATAL: Newz failed");
59 Copy(&self->state, &RETVAL->state, 1, struct chacha_struct);
59 Copy(self, RETVAL, 1, chacha_state);
6060 OUTPUT:
6161 RETVAL
6262
7575 SvPOK_only(RETVAL);
7676 SvCUR_set(RETVAL, out_len);
7777 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);
7979 if (rv != CRYPT_OK) {
8080 SvREFCNT_dec(RETVAL);
8181 croak("FATAL: chacha_keystream failed: %s", error_to_string(rv));
102102 SvPOK_only(RETVAL);
103103 SvCUR_set(RETVAL, in_data_len);
104104 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);
106106 if (rv != CRYPT_OK) {
107107 SvREFCNT_dec(RETVAL);
108108 croak("FATAL: chacha_crypt failed: %s", error_to_string(rv));
1212 if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");
1313 k = (unsigned char *) SvPVbyte(key, k_len);
1414
15 Newz(0, RETVAL, 1, struct rc4_struct);
15 Newz(0, RETVAL, 1, rc4_state);
1616 if (!RETVAL) croak("FATAL: Newz failed");
1717
18 rv = rc4_stream_setup(&RETVAL->state, k, (unsigned long)k_len);
18 rv = rc4_stream_setup(RETVAL, k, (unsigned long)k_len);
1919 if (rv != CRYPT_OK) {
2020 Safefree(RETVAL);
2121 croak("FATAL: rc4_stream_setup failed: %s", error_to_string(rv));
2727 void
2828 DESTROY(Crypt::Stream::RC4 self)
2929 CODE:
30 rc4_stream_done(&self->state);
30 rc4_stream_done(self);
3131 Safefree(self);
3232
3333 Crypt::Stream::RC4
3434 clone(Crypt::Stream::RC4 self)
3535 CODE:
36 Newz(0, RETVAL, 1, struct rc4_struct);
36 Newz(0, RETVAL, 1, rc4_state);
3737 if (!RETVAL) croak("FATAL: Newz failed");
38 Copy(&self->state, &RETVAL->state, 1, struct rc4_struct);
38 Copy(self, RETVAL, 1, rc4_state);
3939 OUTPUT:
4040 RETVAL
4141
5454 SvPOK_only(RETVAL);
5555 SvCUR_set(RETVAL, out_len);
5656 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);
5858 if (rv != CRYPT_OK) {
5959 SvREFCNT_dec(RETVAL);
6060 croak("FATAL: rc4_stream_keystream failed: %s", error_to_string(rv));
8181 SvPOK_only(RETVAL);
8282 SvCUR_set(RETVAL, in_data_len);
8383 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);
8585 if (rv != CRYPT_OK) {
8686 SvREFCNT_dec(RETVAL);
8787 croak("FATAL: rc4_stream_crypt failed: %s", error_to_string(rv));
1212 if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");
1313 k = (unsigned char *)SvPVbyte(key, k_len);
1414
15 Newz(0, RETVAL, 1, struct rabbit_struct);
15 Newz(0, RETVAL, 1, rabbit_state);
1616 if (!RETVAL) croak("FATAL: Newz failed");
1717
18 rv = rabbit_setup(&RETVAL->state, k, (unsigned long)k_len);
18 rv = rabbit_setup(RETVAL, k, (unsigned long)k_len);
1919 if (rv != CRYPT_OK) {
2020 Safefree(RETVAL);
2121 croak("FATAL: rabbit_setup failed: %s", error_to_string(rv));
2424 if (SvOK(nonce)) {
2525 if (!SvPOK(nonce)) croak("FATAL: nonce must be string/buffer scalar");
2626 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);
2828 if (rv != CRYPT_OK) {
2929 Safefree(RETVAL);
3030 croak("FATAL: rabbit_setiv failed: %s", error_to_string(rv));
3838 void
3939 DESTROY(Crypt::Stream::Rabbit self)
4040 CODE:
41 rabbit_done(&self->state);
41 rabbit_done(self);
4242 Safefree(self);
4343
4444 Crypt::Stream::Rabbit
4545 clone(Crypt::Stream::Rabbit self)
4646 CODE:
47 Newz(0, RETVAL, 1, struct rabbit_struct);
47 Newz(0, RETVAL, 1, rabbit_state);
4848 if (!RETVAL) croak("FATAL: Newz failed");
49 Copy(&self->state, &RETVAL->state, 1, struct rabbit_struct);
49 Copy(self, RETVAL, 1, rabbit_state);
5050 OUTPUT:
5151 RETVAL
5252
6565 SvPOK_only(RETVAL);
6666 SvCUR_set(RETVAL, out_len);
6767 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);
6969 if (rv != CRYPT_OK) {
7070 SvREFCNT_dec(RETVAL);
7171 croak("FATAL: rabbit_keystream failed: %s", error_to_string(rv));
9292 SvPOK_only(RETVAL);
9393 SvCUR_set(RETVAL, in_data_len);
9494 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);
9696 if (rv != CRYPT_OK) {
9797 SvREFCNT_dec(RETVAL);
9898 croak("FATAL: rabbit_crypt failed: %s", error_to_string(rv));
1414 k = (unsigned char *)SvPVbyte(key, k_len);
1515 iv = (unsigned char *)SvPVbyte(nonce, iv_len);
1616
17 Newz(0, RETVAL, 1, struct salsa20_struct);
17 Newz(0, RETVAL, 1, salsa20_state);
1818 if (!RETVAL) croak("FATAL: Newz failed");
1919
20 rv = salsa20_setup(&RETVAL->state, k, (unsigned long)k_len, rounds);
20 rv = salsa20_setup(RETVAL, k, (unsigned long)k_len, rounds);
2121 if (rv != CRYPT_OK) {
2222 Safefree(RETVAL);
2323 croak("FATAL: salsa20_setup failed: %s", error_to_string(rv));
2424 }
2525
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);
2727 if (rv != CRYPT_OK) {
2828 Safefree(RETVAL);
2929 croak("FATAL: salsa20_ivctr64 failed: %s", error_to_string(rv));
3535 void
3636 DESTROY(Crypt::Stream::Salsa20 self)
3737 CODE:
38 salsa20_done(&self->state);
38 salsa20_done(self);
3939 Safefree(self);
4040
4141 Crypt::Stream::Salsa20
4242 clone(Crypt::Stream::Salsa20 self)
4343 CODE:
44 Newz(0, RETVAL, 1, struct salsa20_struct);
44 Newz(0, RETVAL, 1, salsa20_state);
4545 if (!RETVAL) croak("FATAL: Newz failed");
46 Copy(&self->state, &RETVAL->state, 1, struct salsa20_struct);
46 Copy(self, RETVAL, 1, salsa20_state);
4747 OUTPUT:
4848 RETVAL
4949
6262 SvPOK_only(RETVAL);
6363 SvCUR_set(RETVAL, out_len);
6464 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);
6666 if (rv != CRYPT_OK) {
6767 SvREFCNT_dec(RETVAL);
6868 croak("FATAL: salsa20_keystream failed: %s", error_to_string(rv));
8989 SvPOK_only(RETVAL);
9090 SvCUR_set(RETVAL, in_data_len);
9191 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);
9393 if (rv != CRYPT_OK) {
9494 SvREFCNT_dec(RETVAL);
9595 croak("FATAL: salsa20_crypt failed: %s", error_to_string(rv));
1414 k = (unsigned char *) SvPVbyte(key, k_len);
1515 iv = (unsigned char *) SvPVbyte(nonce, iv_len);
1616
17 Newz(0, RETVAL, 1, struct sober128_struct);
17 Newz(0, RETVAL, 1, sober128_state);
1818 if (!RETVAL) croak("FATAL: Newz failed");
1919
20 rv = sober128_stream_setup(&RETVAL->state, k, (unsigned long)k_len);
20 rv = sober128_stream_setup(RETVAL, k, (unsigned long)k_len);
2121 if (rv != CRYPT_OK) {
2222 Safefree(RETVAL);
2323 croak("FATAL: sober128_stream_setup failed: %s", error_to_string(rv));
2424 }
2525
26 rv = sober128_stream_setiv(&RETVAL->state, iv, (unsigned long)iv_len);
26 rv = sober128_stream_setiv(RETVAL, iv, (unsigned long)iv_len);
2727 if (rv != CRYPT_OK) {
2828 Safefree(RETVAL);
2929 croak("FATAL: sober128_stream_setiv failed: %s", error_to_string(rv));
3535 void
3636 DESTROY(Crypt::Stream::Sober128 self)
3737 CODE:
38 sober128_stream_done(&self->state);
38 sober128_stream_done(self);
3939 Safefree(self);
4040
4141 Crypt::Stream::Sober128
4242 clone(Crypt::Stream::Sober128 self)
4343 CODE:
44 Newz(0, RETVAL, 1, struct sober128_struct);
44 Newz(0, RETVAL, 1, sober128_state);
4545 if (!RETVAL) croak("FATAL: Newz failed");
46 Copy(&self->state, &RETVAL->state, 1, struct sober128_struct);
46 Copy(self, RETVAL, 1, sober128_state);
4747 OUTPUT:
4848 RETVAL
4949
6262 SvPOK_only(RETVAL);
6363 SvCUR_set(RETVAL, out_len);
6464 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);
6666 if (rv != CRYPT_OK) {
6767 SvREFCNT_dec(RETVAL);
6868 croak("FATAL: sober128_stream_keystream failed: %s", error_to_string(rv));
8989 SvPOK_only(RETVAL);
9090 SvCUR_set(RETVAL, in_data_len);
9191 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);
9393 if (rv != CRYPT_OK) {
9494 SvREFCNT_dec(RETVAL);
9595 croak("FATAL: sober128_stream_crypt failed: %s", error_to_string(rv));
1212 if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");
1313 k = (unsigned char *)SvPVbyte(key, k_len);
1414
15 Newz(0, RETVAL, 1, struct sosemanuk_struct);
15 Newz(0, RETVAL, 1, sosemanuk_state);
1616 if (!RETVAL) croak("FATAL: Newz failed");
1717
18 rv = sosemanuk_setup(&RETVAL->state, k, (unsigned long)k_len);
18 rv = sosemanuk_setup(RETVAL, k, (unsigned long)k_len);
1919 if (rv != CRYPT_OK) {
2020 Safefree(RETVAL);
2121 croak("FATAL: sosemanuk_setup failed: %s", error_to_string(rv));
2424 if (SvOK(nonce)) {
2525 if (!SvPOK(nonce)) croak("FATAL: nonce must be string/buffer scalar");
2626 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);
2828 }
2929 else {
30 rv = sosemanuk_setiv(&RETVAL->state, NULL, 0);
30 rv = sosemanuk_setiv(RETVAL, NULL, 0);
3131 }
3232 if (rv != CRYPT_OK) {
3333 Safefree(RETVAL);
4141 void
4242 DESTROY(Crypt::Stream::Sosemanuk self)
4343 CODE:
44 sosemanuk_done(&self->state);
44 sosemanuk_done(self);
4545 Safefree(self);
4646
4747 Crypt::Stream::Sosemanuk
4848 clone(Crypt::Stream::Sosemanuk self)
4949 CODE:
50 Newz(0, RETVAL, 1, struct sosemanuk_struct);
50 Newz(0, RETVAL, 1, sosemanuk_state);
5151 if (!RETVAL) croak("FATAL: Newz failed");
52 Copy(&self->state, &RETVAL->state, 1, struct sosemanuk_struct);
52 Copy(self, RETVAL, 1, sosemanuk_state);
5353 OUTPUT:
5454 RETVAL
5555
6868 SvPOK_only(RETVAL);
6969 SvCUR_set(RETVAL, out_len);
7070 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);
7272 if (rv != CRYPT_OK) {
7373 SvREFCNT_dec(RETVAL);
7474 croak("FATAL: sosemanuk_keystream failed: %s", error_to_string(rv));
9595 SvPOK_only(RETVAL);
9696 SvCUR_set(RETVAL, in_data_len);
9797 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);
9999 if (rv != CRYPT_OK) {
100100 SvREFCNT_dec(RETVAL);
101101 croak("FATAL: sosemanuk_crypt failed: %s", error_to_string(rv));