inc/CryptX_Mode_CBC.xs.inc

filter: Statementstmt 86.6% 143 / 165 Branchbran 65.0% 104 / 160 Conditioncond n/a MC/DCmcdc n/a Subroutinesub n/a Podpod n/a totaltotal 76.0% 247 / 325 CC 0 SCAR 0
CC
0
Cov
0%
CRAP 0
« inc/CryptX_Mode_ECB.xs.inc ↑ Summary inc/CryptX_AuthEnc_SIV.xs.inc »
1 MODULE = CryptX PACKAGE = Crypt::Mode::CBC
2  
3 PROTOTYPES: DISABLE
4  
5 ### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
6  
7 Crypt::Mode::CBC
8 new(Class, char * cipher_name, int padding=1, int rounds=0)
9 CODE:
10 {
11 140 Newz(0, RETVAL, 1, struct cbc_struct);
12 140 ▶ if (!RETVAL) croak("FATAL: Newz failed");
Branch: 1 branch
BranchTrueFalseTotal
if (!RETVAL) croak("FATAL: Newz failed"); 0 140 140
13 140 RETVAL->padding_mode = padding;
14 140 RETVAL->padlen = 0;
15 140 RETVAL->direction = 0;
16 140 RETVAL->cipher_rounds = rounds;
17 140 RETVAL->cipher_id = cryptx_internal_find_cipher(cipher_name);
18 140 ▶ if (RETVAL->cipher_id == -1) {
Branch: 1 branch
BranchTrueFalseTotal
if (RETVAL->cipher_id == -1) { 0 140 140
19 0 Safefree(RETVAL);
20 0 croak("FATAL: find_cipher failed for '%s'", cipher_name);
21 }
22 }
23 OUTPUT:
24 RETVAL
25  
26 void
27 DESTROY(Crypt::Mode::CBC self)
28 CODE:
29 {
30 140 zeromem(&self->state, sizeof(symmetric_CBC));
31 140 zeromem(self->pad, sizeof(self->pad));
32 140 Safefree(self);
33 }
34  
35 void
36 start_decrypt(Crypt::Mode::CBC self, SV * key, SV * iv)
37 ALIAS:
38 start_encrypt = 1
39 PPCODE:
40 {
41 int rv;
42 334 STRLEN k_len=0;
43 334 unsigned char *k=NULL;
44 334 STRLEN i_len=0;
45 334 unsigned char *i=NULL;
46  
47 334 ▶ if (!SvPOK_spec(key)) croak("FATAL: key must be string/buffer scalar");
Branch: 5 branches
BranchTrueFalseTotal
if (!SvPOK_spec(key)) croak("FATAL: key must be string/buffer scalar"); 334 0 334
if (!SvPOK_spec(key)) croak("FATAL: key must be string/buffer scalar"); 0 334 334
if (!SvPOK_spec(key)) croak("FATAL: key must be string/buffer scalar"); 0 0 0
if (!SvPOK_spec(key)) croak("FATAL: key must be string/buffer scalar"); 0 0 0
if (!SvPOK_spec(key)) croak("FATAL: key must be string/buffer scalar"); 0 0 0
48 334 k = (unsigned char *) SvPVbyte(key, k_len);
49  
50 334 ▶ if (!SvPOK_spec(iv)) croak("FATAL: iv must be string/buffer scalar");
Branch: 5 branches
BranchTrueFalseTotal
if (!SvPOK_spec(iv)) croak("FATAL: iv must be string/buffer scalar"); 334 0 334
if (!SvPOK_spec(iv)) croak("FATAL: iv must be string/buffer scalar"); 0 334 334
if (!SvPOK_spec(iv)) croak("FATAL: iv must be string/buffer scalar"); 0 0 0
if (!SvPOK_spec(iv)) croak("FATAL: iv must be string/buffer scalar"); 0 0 0
if (!SvPOK_spec(iv)) croak("FATAL: iv must be string/buffer scalar"); 0 0 0
51 334 i = (unsigned char *) SvPVbyte(iv, i_len);
52 334 ▶ if (i_len != (STRLEN)cipher_descriptor[self->cipher_id].block_length) {
Branch: 1 branch
BranchTrueFalseTotal
if (i_len != (STRLEN)cipher_descriptor[self->cipher_id].block_length) { 0 334 334
53 0 croak ("FATAL: sizeof(iv) should be equal to blocksize (%d)", cipher_descriptor[self->cipher_id].block_length);
54 }
55 334 rv = cbc_start(self->cipher_id, i, k, (int)k_len, self->cipher_rounds, &self->state);
56 334 ▶ if (rv != CRYPT_OK) {
Branch: 1 branch
BranchTrueFalseTotal
if (rv != CRYPT_OK) { 0 334 334
57 0 croak("FATAL: cbc_start failed: %s", error_to_string(rv));
58 }
59  
60 334 ▶ self->direction = ix == 1 ? 1 : -1;
Branch: 1 branch
BranchTrueFalseTotal
self->direction = ix == 1 ? 1 : -1; 171 163 334
61 334 self->padlen = 0;
62 334 ▶ XPUSHs(ST(0)); /* return self */
Branch: 1 branch
BranchTrueFalseTotal
XPUSHs(ST(0)); /* return self */ 0 334 334
63 }
64  
65 SV *
66 add(Crypt::Mode::CBC self, ...)
67 CODE:
68 {
69 int rv, has_tmp_block, blen, j;
70 unsigned long i;
71 3501 STRLEN in_data_len, in_data_start, out_len = 0;
72 unsigned char *in_data, *out_data, tmp_block[MAXBLOCKSIZE];
73  
74 3501 RETVAL = newSVpvn("", 0);
75 7001 ▶ for (j = 1; j < items; j++) {
Branch: 1 branch
BranchTrueFalseTotal
for (j = 1; j < items; j++) { 3501 3500 7001
76 3501 in_data = (unsigned char *)SvPVbyte(ST(j), in_data_len);
77 3501 blen = (&self->state)->ecb.blocklen;
78 3501 in_data_start = 0;
79 3501 has_tmp_block = 0;
80 3501 ▶ if (in_data_len > 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (in_data_len > 0) { 3498 3 3501
81 3498 ▶ if (self->direction == 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (self->direction == 1) { 1698 1800 3498
82 /* handle non-empty self->pad buffer */
83 1698 ▶ if (self->padlen > 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (self->padlen > 0) { 1360 338 1698
84 1360 i = (blen - self->padlen);
85 1360 ▶ if (in_data_len >= i) { /* enough data to fill pad */
Branch: 1 branch
BranchTrueFalseTotal
if (in_data_len >= i) { /* enough data to fill pad */ 585 775 1360
86 585 Copy(in_data, self->pad+self->padlen, i, unsigned char);
87 585 in_data_len -= i;
88 585 in_data_start = i;
89 585 rv = cbc_encrypt(self->pad, tmp_block, blen, &self->state);
90 585 ▶ if (rv != CRYPT_OK) {
Branch: 1 branch
BranchTrueFalseTotal
if (rv != CRYPT_OK) { 0 585 585
91 0 SvREFCNT_dec(RETVAL);
92 0 croak("FATAL: cbc_encrypt failed: %s", error_to_string(rv));
93 }
94 585 self->padlen = 0;
95 585 has_tmp_block = 1;
96 }
97 else { /* not enough data to fill pad */
98 775 Copy(in_data, self->pad+self->padlen, in_data_len, unsigned char);
99 775 self->padlen += (int)in_data_len;
100 775 in_data_len = 0;
101 }
102 }
103  
104 1698 i = (unsigned long)(in_data_len % blen);
105 1698 ▶ if (in_data_len > 0 && i > 0) { /* save tail of data into pad */
Branch: 2 branches
BranchTrueFalseTotal
if (in_data_len > 0 && i > 0) { /* save tail of data into pad */ 775 923 1698
if (in_data_len > 0 && i > 0) { /* save tail of data into pad */ 678 97 775
106 678 Copy(in_data + in_data_start + in_data_len - i, self->pad, i, unsigned char);
107 678 self->padlen = i;
108 678 in_data_len -= i;
109 }
110  
111 1698 ▶ if (in_data_len > 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (in_data_len > 0) { 256 1442 1698
112 256 ▶ i = (unsigned long)(has_tmp_block ? in_data_len + blen : in_data_len);
Branch: 1 branch
BranchTrueFalseTotal
i = (unsigned long)(has_tmp_block ? in_data_len + blen : in_data_len); 96 160 256
113 256 ▶ out_data = (unsigned char*)SvGROW(RETVAL, out_len + i + 1) + out_len;
Branch: 2 branches
BranchTrueFalseTotal
out_data = (unsigned char*)SvGROW(RETVAL, out_len + i + 1) + out_len; 256 0 256
out_data = (unsigned char*)SvGROW(RETVAL, out_len + i + 1) + out_len; 256 0 256
114 256 out_len += i;
115 256 ▶ if (has_tmp_block) {
Branch: 1 branch
BranchTrueFalseTotal
if (has_tmp_block) { 96 160 256
116 96 Copy(tmp_block, out_data, blen, unsigned char);
117 96 out_data += blen;
118 }
119 256 rv = cbc_encrypt(in_data+in_data_start, out_data, (unsigned long)in_data_len, &self->state);
120 256 ▶ if (rv != CRYPT_OK) {
Branch: 1 branch
BranchTrueFalseTotal
if (rv != CRYPT_OK) { 0 256 256
121 0 SvREFCNT_dec(RETVAL);
122 0 croak("FATAL: cbc_encrypt failed: %s", error_to_string(rv));
123 }
124 } /* in_data_len > 0 */
125 1442 ▶ else if (has_tmp_block) {
Branch: 1 branch
BranchTrueFalseTotal
else if (has_tmp_block) { 489 953 1442
126 489 ▶ out_data = (unsigned char*)SvGROW(RETVAL, out_len + blen + 1) + out_len;
Branch: 2 branches
BranchTrueFalseTotal
out_data = (unsigned char*)SvGROW(RETVAL, out_len + blen + 1) + out_len; 489 0 489
out_data = (unsigned char*)SvGROW(RETVAL, out_len + blen + 1) + out_len; 489 0 489
127 489 out_len += blen;
128 489 Copy(tmp_block, out_data, blen, unsigned char);
129 }
130 }
131 1800 ▶ else if (self->direction == -1) {
Branch: 1 branch
BranchTrueFalseTotal
else if (self->direction == -1) { 1799 1 1800
132 1799 ▶ if (self->padlen == blen) {
Branch: 1 branch
BranchTrueFalseTotal
if (self->padlen == blen) { 116 1683 1799
133 116 rv = cbc_decrypt(self->pad, tmp_block, blen, &self->state);
134 116 ▶ if (rv != CRYPT_OK) {
Branch: 1 branch
BranchTrueFalseTotal
if (rv != CRYPT_OK) { 0 116 116
135 0 SvREFCNT_dec(RETVAL);
136 0 croak("FATAL: cbc_decrypt failed: %s", error_to_string(rv));
137 }
138 116 self->padlen = 0;
139 116 has_tmp_block = 1;
140 } /* padlen == blen */
141 1683 ▶ else if (self->padlen > 0) {
Branch: 1 branch
BranchTrueFalseTotal
else if (self->padlen > 0) { 1470 213 1683
142 1470 i = (blen - self->padlen); /* remaining bytes in padding buffer */
143 1470 ▶ if (in_data_len >= i) { /* enough data to fill pad */
Branch: 1 branch
BranchTrueFalseTotal
if (in_data_len >= i) { /* enough data to fill pad */ 633 837 1470
144 633 Copy(in_data, self->pad+self->padlen, i, unsigned char);
145 633 self->padlen += i;
146 633 in_data_len -= i;
147 633 in_data_start = i;
148 633 ▶ if (in_data_len>0 || self->padding_mode == 0) {
Branch: 2 branches
BranchTrueFalseTotal
if (in_data_len>0 || self->padding_mode == 0) { 196 437 633
if (in_data_len>0 || self->padding_mode == 0) { 64 132 196
149 501 rv = cbc_decrypt(self->pad, tmp_block, blen, &self->state);
150 501 ▶ if (rv != CRYPT_OK) {
Branch: 1 branch
BranchTrueFalseTotal
if (rv != CRYPT_OK) { 0 501 501
151 0 SvREFCNT_dec(RETVAL);
152 0 croak("FATAL: cbc_decrypt failed: %s", error_to_string(rv));
153 }
154 501 self->padlen = 0;
155 501 has_tmp_block = 1;
156 }
157 }
158 else { /* not enough data to fill pad */
159 837 Copy(in_data, self->pad+self->padlen, in_data_len, unsigned char);
160 837 self->padlen += (int)in_data_len;
161 837 in_data_len = 0;
162 }
163 } /* padlen > 0 */
164  
165 /* here: a/ padlen == 1..16 && in_data_len == 0; b/ padlen == 0 && in_data_len > 0 */
166 1799 ▶ if (in_data_len>0) {
Branch: 1 branch
BranchTrueFalseTotal
if (in_data_len>0) { 766 1033 1799
167 766 i = (unsigned long)(in_data_len % blen);
168 766 ▶ if (i>0) { /* save tail of data into pad */
Branch: 1 branch
BranchTrueFalseTotal
if (i>0) { /* save tail of data into pad */ 633 133 766
169 633 Copy(in_data+in_data_start+in_data_len-i, self->pad, i, unsigned char);
170 633 self->padlen = i;
171 633 in_data_len -= i;
172 }
173 }
174  
175 1799 ▶ if (in_data_len>0) {
Branch: 1 branch
BranchTrueFalseTotal
if (in_data_len>0) { 272 1527 1799
176 272 ▶ if (self->padlen == 0 && self->padding_mode !=0) {
Branch: 2 branches
BranchTrueFalseTotal
if (self->padlen == 0 && self->padding_mode !=0) { 133 139 272
if (self->padlen == 0 && self->padding_mode !=0) { 82 51 133
177 /* in case of padding keep full pad if no more data */
178 82 Copy(in_data+in_data_start+in_data_len-blen, self->pad, blen, unsigned char);
179 82 self->padlen = blen;
180 82 in_data_len -= blen;
181 }
182 272 ▶ i = (unsigned long)(has_tmp_block ? in_data_len + blen : in_data_len);
Branch: 1 branch
BranchTrueFalseTotal
i = (unsigned long)(has_tmp_block ? in_data_len + blen : in_data_len); 142 130 272
183 272 ▶ if (i > 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (i > 0) { 263 9 272
184 263 ▶ out_data = (unsigned char*)SvGROW(RETVAL, out_len + i + 1) + out_len;
Branch: 2 branches
BranchTrueFalseTotal
out_data = (unsigned char*)SvGROW(RETVAL, out_len + i + 1) + out_len; 263 0 263
out_data = (unsigned char*)SvGROW(RETVAL, out_len + i + 1) + out_len; 263 0 263
185 263 out_len += i;
186 263 ▶ if (has_tmp_block) {
Branch: 1 branch
BranchTrueFalseTotal
if (has_tmp_block) { 142 121 263
187 142 Copy(tmp_block, out_data, blen, unsigned char);
188 142 out_data += blen;
189 }
190 263 rv = cbc_decrypt(in_data+in_data_start, out_data, (unsigned long)in_data_len, &self->state);
191 263 ▶ if (rv != CRYPT_OK) {
Branch: 1 branch
BranchTrueFalseTotal
if (rv != CRYPT_OK) { 0 263 263
192 0 SvREFCNT_dec(RETVAL);
193 0 croak("FATAL: cbc_decrypt failed: %s", error_to_string(rv));
194 }
195 }
196 } /* in_data_len>0 */
197 1527 ▶ else if (has_tmp_block) {
Branch: 1 branch
BranchTrueFalseTotal
else if (has_tmp_block) { 475 1052 1527
198 475 ▶ out_data = (unsigned char*)SvGROW(RETVAL, out_len + blen + 1) + out_len;
Branch: 2 branches
BranchTrueFalseTotal
out_data = (unsigned char*)SvGROW(RETVAL, out_len + blen + 1) + out_len; 475 0 475
out_data = (unsigned char*)SvGROW(RETVAL, out_len + blen + 1) + out_len; 475 0 475
199 475 out_len += blen;
200 475 Copy(tmp_block, out_data, blen, unsigned char);
201 }
202 }
203 else {
204 1 SvREFCNT_dec(RETVAL);
205 1 croak("FATAL: call start_decrypt or start_encrypt first (%d)", self->direction);
206 }
207 }
208 }
209 3500 ▶ if (out_len > 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (out_len > 0) { 1483 2017 3500
210 1483 SvCUR_set(RETVAL, out_len);
211 1483 *SvEND(RETVAL) = '\0';
212 }
213 }
214 OUTPUT:
215 RETVAL
216  
217 SV *
218 finish(Crypt::Mode::CBC self)
219 CODE:
220 {
221 unsigned char tmp_block[MAXBLOCKSIZE];
222 int rv;
223 325 unsigned long blen = (&self->state)->ecb.blocklen;
224 unsigned long padmode;
225  
226 325 ▶ if (self->direction == 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (self->direction == 1) { 161 164 325
227 161 ▶ if (self->padlen < 0 || self->padlen >= (int)blen) croak("FATAL: invalid padlen");
Branch: 2 branches
BranchTrueFalseTotal
if (self->padlen < 0 || self->padlen >= (int)blen) croak("FATAL: invalid padlen"); 161 0 161
if (self->padlen < 0 || self->padlen >= (int)blen) croak("FATAL: invalid padlen"); 0 161 161
228 161 ▶ if (self->padding_mode != 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (self->padding_mode != 0) { 98 63 161
229 98 ▶ if (self->padding_mode == 1) { padmode = LTC_PAD_PKCS7 | (&self->state)->ecb.blocklen; }
Branch: 1 branch
BranchTrueFalseTotal
if (self->padding_mode == 1) { padmode = LTC_PAD_PKCS7 | (&self->state)->ecb.blocklen; } 53 45 98
230 45 ▶ else if (self->padding_mode == 2) { padmode = LTC_PAD_ONE_AND_ZERO | (&self->state)->ecb.blocklen; }
Branch: 1 branch
BranchTrueFalseTotal
else if (self->padding_mode == 2) { padmode = LTC_PAD_ONE_AND_ZERO | (&self->state)->ecb.blocklen; } 45 0 45
231 0 ▶ else if (self->padding_mode == 3) { padmode = LTC_PAD_ANSI_X923 | (&self->state)->ecb.blocklen; }
Branch: 1 branch
BranchTrueFalseTotal
else if (self->padding_mode == 3) { padmode = LTC_PAD_ANSI_X923 | (&self->state)->ecb.blocklen; } 0 0 0
232 0 ▶ else if (self->padding_mode == 4) { padmode = LTC_PAD_ZERO | (&self->state)->ecb.blocklen; }
Branch: 1 branch
BranchTrueFalseTotal
else if (self->padding_mode == 4) { padmode = LTC_PAD_ZERO | (&self->state)->ecb.blocklen; } 0 0 0
233 0 ▶ else if (self->padding_mode == 5) { padmode = LTC_PAD_ZERO_ALWAYS | (&self->state)->ecb.blocklen; }
Branch: 1 branch
BranchTrueFalseTotal
else if (self->padding_mode == 5) { padmode = LTC_PAD_ZERO_ALWAYS | (&self->state)->ecb.blocklen; } 0 0 0
234 0 else { croak("FATAL: unknown padding"); }
235 98 blen = sizeof(self->pad);
236 98 rv = padding_pad(self->pad, self->padlen, &blen, padmode);
237 98 ▶ if (rv != CRYPT_OK) croak("FATAL: padding_pad failed: %s", error_to_string(rv));
Branch: 1 branch
BranchTrueFalseTotal
if (rv != CRYPT_OK) croak("FATAL: padding_pad failed: %s", error_to_string(rv)); 0 98 98
238 98 rv = cbc_encrypt(self->pad, tmp_block, blen, &self->state);
239 98 ▶ if (rv != CRYPT_OK) croak("FATAL: cbc_encrypt failed: %s", error_to_string(rv));
Branch: 1 branch
BranchTrueFalseTotal
if (rv != CRYPT_OK) croak("FATAL: cbc_encrypt failed: %s", error_to_string(rv)); 0 98 98
240 }
241 else {
242 63 ▶ if (self->padlen > 0) croak("FATAL: cbc_encrypt, input data length not multiple of %d", (int)blen);
Branch: 1 branch
BranchTrueFalseTotal
if (self->padlen > 0) croak("FATAL: cbc_encrypt, input data length not multiple of %d", (int)blen); 0 63 63
243 63 blen = 0;
244 }
245 }
246 164 ▶ else if (self->direction == -1) {
Branch: 1 branch
BranchTrueFalseTotal
else if (self->direction == -1) { 163 1 164
247 163 ▶ if (self->padlen > 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (self->padlen > 0) { 98 65 163
248 98 ▶ if (self->padlen != (int)blen) croak("FATAL: cipher text length has to be multiple of %d (%d)", (int)blen, self->padlen);
Branch: 1 branch
BranchTrueFalseTotal
if (self->padlen != (int)blen) croak("FATAL: cipher text length has to be multiple of %d (%d)", (int)blen, self->padlen); 0 98 98
249 98 rv = cbc_decrypt(self->pad, tmp_block, blen, &self->state);
250 98 ▶ if (rv != CRYPT_OK) croak("FATAL: cbc_decrypt failed: %s", error_to_string(rv));
Branch: 1 branch
BranchTrueFalseTotal
if (rv != CRYPT_OK) croak("FATAL: cbc_decrypt failed: %s", error_to_string(rv)); 0 98 98
251 98 ▶ if (self->padding_mode != 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (self->padding_mode != 0) { 98 0 98
252 98 ▶ if (self->padding_mode == 1) { padmode = LTC_PAD_PKCS7 | (&self->state)->ecb.blocklen; }
Branch: 1 branch
BranchTrueFalseTotal
if (self->padding_mode == 1) { padmode = LTC_PAD_PKCS7 | (&self->state)->ecb.blocklen; } 53 45 98
253 45 ▶ else if (self->padding_mode == 2) { padmode = LTC_PAD_ONE_AND_ZERO | (&self->state)->ecb.blocklen; }
Branch: 1 branch
BranchTrueFalseTotal
else if (self->padding_mode == 2) { padmode = LTC_PAD_ONE_AND_ZERO | (&self->state)->ecb.blocklen; } 45 0 45
254 0 ▶ else if (self->padding_mode == 3) { padmode = LTC_PAD_ANSI_X923 | (&self->state)->ecb.blocklen; }
Branch: 1 branch
BranchTrueFalseTotal
else if (self->padding_mode == 3) { padmode = LTC_PAD_ANSI_X923 | (&self->state)->ecb.blocklen; } 0 0 0
255 0 ▶ else if (self->padding_mode == 4) { padmode = LTC_PAD_ZERO | (&self->state)->ecb.blocklen; }
Branch: 1 branch
BranchTrueFalseTotal
else if (self->padding_mode == 4) { padmode = LTC_PAD_ZERO | (&self->state)->ecb.blocklen; } 0 0 0
256 0 ▶ else if (self->padding_mode == 5) { padmode = LTC_PAD_ZERO_ALWAYS | (&self->state)->ecb.blocklen; }
Branch: 1 branch
BranchTrueFalseTotal
else if (self->padding_mode == 5) { padmode = LTC_PAD_ZERO_ALWAYS | (&self->state)->ecb.blocklen; } 0 0 0
257 0 else { croak("FATAL: unknown padding"); }
258 98 rv = padding_depad(tmp_block, &blen, padmode);
259 98 ▶ if (rv != CRYPT_OK) croak("FATAL: padding_depad failed: %s", error_to_string(rv));
Branch: 1 branch
BranchTrueFalseTotal
if (rv != CRYPT_OK) croak("FATAL: padding_depad failed: %s", error_to_string(rv)); 1 97 98
260 }
261 else {
262 /* "no padding" == there is no need to do anything */
263 }
264 }
265 else {
266 65 ▶ if (self->padding_mode != 0) croak("FATAL: cipher text length has to be at least one block with padding");
Branch: 1 branch
BranchTrueFalseTotal
if (self->padding_mode != 0) croak("FATAL: cipher text length has to be at least one block with padding"); 1 64 65
267 64 blen = 0;
268 }
269 }
270 else {
271 1 croak("FATAL: mode not active; call start_decrypt or start_encrypt first");
272 }
273  
274 322 self->direction = 0;
275 322 RETVAL = newSVpvn((char*)tmp_block, blen);
276 }
277 OUTPUT:
278 RETVAL
« inc/CryptX_Mode_ECB.xs.inc ↑ Summary inc/CryptX_AuthEnc_SIV.xs.inc »