inc/CryptX_Mode_ECB.xs.inc

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