Commit 4a2b9bf72f945501aee0513dfc1290ff6ff9f01d - libcryptx-perl

+6

-3

_generators/Mac.xs.inc.tt less more

20	20	int id;
21	21
22	22	id = find_hash(hash_name);
23		if(id==-1) croak("FATAL: find_hash failed for '%s'", hash_name);
	23	if (id == -1) croak("FATAL: find_hash failed for '%s'", hash_name);
24	24	[%-ELSIF lc_name == 'blake2s' \|\| lc_name == 'blake2b' %]
25	25	[%-ELSIF lc_name == 'pelican' \|\| lc_name == 'poly1305' %]
26	26	[%-ELSE%]
27	27	int id;
28	28
29	29	id = find_cipher(cipher_name);
30		if(id==-1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
	30	if (id == -1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
31	31	[%-END%]
32	32
33	33	if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");

43	43	[%-ELSE%]
44	44	rv = [%lc_name%]_init(&RETVAL->state, id, k, (unsigned long)k_len);
45	45	[%-END%]
46		if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_init failed: %s", error_to_string(rv));
	46	if (rv != CRYPT_OK) {
	47	Safefree(RETVAL);
	48	croak("FATAL: [%lc_name%]_init failed: %s", error_to_string(rv));
	49	}
47	50	}
48	51	OUTPUT:
49	52	RETVAL

+4

-1

_generators/Mode.xs.inc.tt less more

14	14	RETVAL->direction = 0;
15	15	RETVAL->cipher_rounds = rounds;
16	16	RETVAL->cipher_id = find_cipher(cipher_name);
17		if(RETVAL->cipher_id==-1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
	17	if (RETVAL->cipher_id == -1) {
	18	Safefree(RETVAL);
	19	croak("FATAL: find_cipfer failed for '%s'", cipher_name);
	20	}
18	21	[%-IF lc_name == 'ctr' %]
19	22	if (ctr_mode == 0) RETVAL->ctr_mode_param = CTR_COUNTER_LITTLE_ENDIAN;
20	23	if (ctr_mode == 1) RETVAL->ctr_mode_param = CTR_COUNTER_BIG_ENDIAN;

+25

-16

_generators/Mode_p.xs.inc.tt less more

12	12	RETVAL->direction = 0;
13	13	RETVAL->cipher_rounds = rounds;
14	14	RETVAL->cipher_id = find_cipher(cipher_name);
15		if(RETVAL->cipher_id==-1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
	15	if (RETVAL->cipher_id == -1) {
	16	Safefree(RETVAL);
	17	croak("FATAL: find_cipfer failed for '%s'", cipher_name);
	18	}
16	19	}
17	20	OUTPUT:
18	21	RETVAL

84	87	in_data_start = 0;
85	88	has_tmp_block = 0;
86	89	in_data = (unsigned char *)SvPVbyte(data, in_data_len);
87		if (in_data_len==0) {
	90	if (in_data_len == 0) {
88	91	RETVAL = newSVpvn("", 0);
89	92	}
90	93	else {
91		if(self->padlen > 0) {
	94	if (self->padlen > 0) {
92	95	i = (blen - self->padlen);
93	96	if (in_data_len >= i) { /* enough data to fill pad */
94	97	Copy(in_data, self->pad+self->padlen, i, unsigned char);

113	116	in_data_len -= i;
114	117	}
115	118
116		if (in_data_len>0) {
	119	if (in_data_len > 0) {
117	120	i = (unsigned long)(has_tmp_block ? in_data_len + blen : in_data_len);
118	121	RETVAL = NEWSV(0, i);
119	122	SvPOK_only(RETVAL);

124	127	out_data += blen;
125	128	}
126	129	rv = [%lc_name%]_encrypt(in_data+in_data_start, out_data, (unsigned long)in_data_len, &self->state);
127		if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_encrypt failed: %s", error_to_string(rv));
	130	if (rv != CRYPT_OK) {
	131	SvREFCNT_dec(RETVAL);
	132	croak("FATAL: [%lc_name%]_encrypt failed: %s", error_to_string(rv));
	133	}
128	134	} /* in_data_len>0 */
129	135	else if (has_tmp_block) {
130	136	RETVAL = newSVpvn((char*)tmp_block, blen);

147	153	blen = (&self->state)->blocklen;
148	154	if (self->padlen<0 \|\| self->padlen>=blen) croak("FATAL: invalid padlen");
149	155
150		if(self->padding_mode == 1) { /* pkcs5\|7 padding */
	156	if (self->padding_mode == 1) { /* pkcs5\|7 padding */
151	157	i = blen - self->padlen;
152	158	if (i == 0) i = blen;
153	159	for(j=self->padlen; j<blen; j++) self->pad[j] = (unsigned char)i;
154	160	rv = [%lc_name%]_encrypt(self->pad, tmp_block, blen, &self->state);
155	161	if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_encrypt failed: %s", error_to_string(rv));
156	162	}
157		else if(self->padding_mode == 2) { /* oneandzeroes padding */
	163	else if (self->padding_mode == 2) { /* oneandzeroes padding */
158	164	self->pad[self->padlen] = 0x80;
159	165	for(j=self->padlen+1; j<blen; j++) self->pad[j] = 0;
160	166	rv = [%lc_name%]_encrypt(self->pad, tmp_block, blen, &self->state);

186	192	in_data_start = 0;
187	193	has_tmp_block = 0;
188	194	in_data = (unsigned char *)SvPVbyte(data, in_data_len);
189		if (in_data_len==0) {
	195	if (in_data_len == 0) {
190	196	RETVAL = newSVpvn("", 0);
191	197	}
192	198	else {
193	199
194		if(self->padlen == blen) {
	200	if (self->padlen == blen) {
195	201	rv = [%lc_name%]_decrypt(self->pad, tmp_block, blen, &self->state);
196	202	if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_decrypt failed: %s", error_to_string(rv));
197	203	self->padlen = 0;
198	204	has_tmp_block = 1;
199	205	} /* padlen == blen */
200		else if(self->padlen > 0) {
	206	else if (self->padlen > 0) {
201	207	i = (blen - self->padlen); /* remaining bytes in padding buffer */
202	208	if (in_data_len >= i) { /* enough data to fill pad */
203	209	Copy(in_data, self->pad+self->padlen, i, unsigned char);

218	224	}
219	225	} /* padlen > 0 */
220	226
221		/* here: a/ padlen==1..16 && in_data_len==0; b/ padlen==0 && in_data_len>0 */
	227	/* here: a/ padlen == 1..16 && in_data_len == 0; b/ padlen == 0 && in_data_len > 0 */
222	228	if (in_data_len>0) {
223	229	i = (unsigned long)(in_data_len % blen);
224	230	if (i>0) { /* save tail of data into pad */

229	235	}
230	236
231	237	if (in_data_len>0) {
232		if(self->padlen == 0 && self->padding_mode !=0) {
	238	if (self->padlen == 0 && self->padding_mode !=0) {
233	239	/* in case of padding keep full pad if no more data */
234	240	Copy(in_data+in_data_start+in_data_len-blen, self->pad, blen, unsigned char);
235	241	self->padlen = blen;

249	255	out_data += blen;
250	256	}
251	257	rv = [%lc_name%]_decrypt(in_data+in_data_start, out_data, (unsigned long)in_data_len, &self->state);
252		if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_decrypt failed: %s", error_to_string(rv));
	258	if (rv != CRYPT_OK) {
	259	SvREFCNT_dec(RETVAL);
	260	croak("FATAL: [%lc_name%]_decrypt failed: %s", error_to_string(rv));
	261	}
253	262	}
254	263	} /* in_data_len>0 */
255	264	else if (has_tmp_block) {

278	287	if (self->padlen != blen) croak("FATAL: cipher text length has to be multiple of %d (%d)", blen, self->padlen);
279	288	rv = [%lc_name%]_decrypt(self->pad, tmp_block, blen, &self->state);
280	289	if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_decrypt failed: %s", error_to_string(rv));
281		if(self->padding_mode == 0) { /* no padding */
	290	if (self->padding_mode == 0) { /* no padding */
282	291	rv_len = blen;
283	292	}
284		else if(self->padding_mode == 1) { /* pkcs5\|7 padding */
	293	else if (self->padding_mode == 1) { /* pkcs5\|7 padding */
285	294	i = tmp_block[blen-1];
286	295	rv_len = blen - (i>blen ? blen : i);
287	296	}
288		else if(self->padding_mode == 2) { /* oneandzeroes padding */
	297	else if (self->padding_mode == 2) { /* oneandzeroes padding */
289	298	rv_len = blen;
290	299	while ((unsigned char)tmp_block[rv_len-1] == 0x00) rv_len--;
291	300	if ((unsigned char)tmp_block[rv_len-1] == 0x80) rv_len--;

+8

-4

inc/CryptX_AuthEnc_CCM.xs.inc less more

19	19	pt = (unsigned char *) SvPVbyte(plaintext, pt_len);
20	20
21	21	id = find_cipher(cipher_name);
22		if(id==-1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
	22	if (id == -1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
23	23
24	24	ct = NEWSV(0, pt_len);
25	25	SvPOK_only(ct);
26	26	SvCUR_set(ct, pt_len);
27	27
28		if(tag_len<4 \|\| tag_len>16) tag_len = 16;
	28	if (tag_len < 4 \|\| tag_len > 16) tag_len = 16;
29	29
30	30	rv = ccm_memory(id, k, (unsigned long)k_len, NULL, n, (unsigned long)n_len, h, (unsigned long)h_len,
31	31	pt, (unsigned long)pt_len, (unsigned char *)SvPVX(ct), tag, &tag_len, CCM_ENCRYPT);
32		if (rv != CRYPT_OK) croak("FATAL: ccm_memory failed: %s", error_to_string(rv));
	32	if (rv != CRYPT_OK) {
	33	SvREFCNT_dec(ct);
	34	croak("FATAL: ccm_memory failed: %s", error_to_string(rv));
	35	}
33	36
34	37	XPUSHs(sv_2mortal(ct));
35	38	XPUSHs(sv_2mortal(newSVpvn((char*)tag,tag_len)));

69	72	t = (unsigned char *) SvPVbyte(tag, t_len);
70	73
71	74	id = find_cipher(cipher_name);
72		if(id==-1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
	75	if (id == -1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
73	76
74	77	pt = NEWSV(0, ct_len);
75	78	SvPOK_only(pt);

81	84	rv = ccm_memory(id, k, (unsigned long)k_len, NULL, n, (unsigned long)n_len, h, (unsigned long)h_len,
82	85	(unsigned char *)SvPV_nolen(pt), (unsigned long)ct_len, ct, xtag, &xtag_len, CCM_DECRYPT);
83	86	if (rv != CRYPT_OK) {
	87	SvREFCNT_dec(pt);
84	88	XPUSHs(sv_2mortal(newSVpvn(NULL,0))); /* undef */
85	89	}
86	90	else {

+9

-3

inc/CryptX_AuthEnc_ChaCha20Poly1305.xs.inc less more

18	18	if (!RETVAL) croak("FATAL: Newz failed");
19	19
20	20	rv = chacha20poly1305_init(&RETVAL->state, k, (unsigned long)k_len);
21		if (rv != CRYPT_OK) croak("FATAL: chacha20poly1305_init failed: %s", error_to_string(rv));
	21	if (rv != CRYPT_OK) {
	22	Safefree(RETVAL);
	23	croak("FATAL: chacha20poly1305_init failed: %s", error_to_string(rv));
	24	}
22	25
23	26	if (iv && iv_len > 0) {
24	27	rv = chacha20poly1305_setiv(&RETVAL->state, iv, (unsigned long)iv_len);
25		if (rv != CRYPT_OK) croak("FATAL: chacha20poly1305_setiv failed: %s", error_to_string(rv));
	28	if (rv != CRYPT_OK) {
	29	Safefree(RETVAL);
	30	croak("FATAL: chacha20poly1305_setiv failed: %s", error_to_string(rv));
	31	}
26	32	}
27	33	}
28	34	OUTPUT:

169	175	XPUSHs(sv_2mortal(newSVpvn((char*)tag, tag_len)));
170	176	}
171	177	else {
172		if(!SvPOK(ST(1))) croak("FATAL: expected_tag must be string/buffer scalar");
	178	if (!SvPOK(ST(1))) croak("FATAL: expected_tag must be string/buffer scalar");
173	179	expected_tag = (unsigned char *) SvPVbyte(ST(1), expected_tag_len);
174	180	if (expected_tag_len!=tag_len) {
175	181	XPUSHs(sv_2mortal(newSViv(0))); /* false */

+9

-7

inc/CryptX_AuthEnc_EAX.xs.inc less more

9	9	STRLEN n_len=0;
10	10	unsigned char *h=NULL;
11	11	STRLEN h_len=0;
12		int id;
	12	int rv, id;
13	13
14	14	if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");
15	15	k = (unsigned char *) SvPVbyte(key, k_len);
16	16	if (!SvPOK(nonce)) croak("FATAL: nonce must be string/buffer scalar");
17	17	n = (unsigned char *) SvPVbyte(nonce, n_len);
18		if(SvOK(adata)) { /* adata is optional param */
19		if(!SvPOK(adata)) croak("FATAL: adata must be string/buffer scalar");
	18	if (SvOK(adata)) { /* adata is optional param */
	19	if (!SvPOK(adata)) croak("FATAL: adata must be string/buffer scalar");
20	20	h = (unsigned char *) SvPVbyte(adata, h_len);
21	21	}
22	22
23	23	id = find_cipher(cipher_name);
24		if(id==-1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
	24	if (id == -1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
25	25
26	26	Newz(0, RETVAL, 1, struct eax_struct);
27	27	if (!RETVAL) croak("FATAL: Newz failed");
28	28
29		if (eax_init(&RETVAL->state, id, k, (unsigned long)k_len, n, (unsigned long)n_len, h, (unsigned long)h_len) != CRYPT_OK) {
30		croak("FATAL: eax setup failed");
	29	rv = eax_init(&RETVAL->state, id, k, (unsigned long)k_len, n, (unsigned long)n_len, h, (unsigned long)h_len);
	30	if (rv != CRYPT_OK) {
	31	Safefree(RETVAL);
	32	croak("FATAL: eax setup failed: %s", error_to_string(rv));
31	33	}
32	34	}
33	35	OUTPUT:

130	132	XPUSHs(sv_2mortal(newSVpvn((char*)tag, tag_len)));
131	133	}
132	134	else {
133		if(!SvPOK(ST(1))) croak("FATAL: expected_tag must be string/buffer scalar");
	135	if (!SvPOK(ST(1))) croak("FATAL: expected_tag must be string/buffer scalar");
134	136	expected_tag = (unsigned char *) SvPVbyte(ST(1), expected_tag_len);
135	137	if (expected_tag_len!=tag_len) {
136	138	XPUSHs(sv_2mortal(newSViv(0))); /* false */

+9

-3

inc/CryptX_AuthEnc_GCM.xs.inc less more

21	21	if (!RETVAL) croak("FATAL: Newz failed");
22	22
23	23	rv = gcm_init(&RETVAL->state, id, k, (unsigned long)k_len);
24		if (rv != CRYPT_OK) croak("FATAL: gcm_init failed: %s", error_to_string(rv));
	24	if (rv != CRYPT_OK) {
	25	Safefree(RETVAL);
	26	croak("FATAL: gcm_init failed: %s", error_to_string(rv));
	27	}
25	28
26	29	if (iv && iv_len > 0) {
27	30	rv = gcm_add_iv(&RETVAL->state, iv, (unsigned long)iv_len);
28		if (rv != CRYPT_OK) croak("FATAL: gcm_add_iv failed: %s", error_to_string(rv));
	31	if (rv != CRYPT_OK) {
	32	Safefree(RETVAL);
	33	croak("FATAL: gcm_add_iv failed: %s", error_to_string(rv));
	34	}
29	35	}
30	36	}
31	37	OUTPUT:

168	174	XPUSHs(sv_2mortal(newSVpvn((char*)tag, tag_len)));
169	175	}
170	176	else {
171		if(!SvPOK(ST(1))) croak("FATAL: expected_tag must be string/buffer scalar");
	177	if (!SvPOK(ST(1))) croak("FATAL: expected_tag must be string/buffer scalar");
172	178	expected_tag = (unsigned char *) SvPVbyte(ST(1), expected_tag_len);
173	179	if (expected_tag_len!=tag_len) {
174	180	XPUSHs(sv_2mortal(newSViv(0))); /* false */

+43

-32

inc/CryptX_AuthEnc_OCB.xs.inc less more

7	7	unsigned char *k=NULL;
8	8	unsigned char *n=NULL;
9	9	STRLEN n_len=0;
10		int id;
	10	int rv, id;
11	11
12	12	if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");
13	13	k = (unsigned char *) SvPVbyte(key, k_len);

15	15	n = (unsigned char *) SvPVbyte(nonce, n_len);
16	16
17	17	id = find_cipher(cipher_name);
18		if(id==-1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
	18	if (id == -1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
19	19
20	20	Newz(0, RETVAL, 1, struct ocb_struct);
21	21	if (!RETVAL) croak("FATAL: Newz failed");
22	22
23		if (ocb3_init(&RETVAL->state, id, k, (unsigned long)k_len, n, (unsigned long)n_len, taglen) != CRYPT_OK) {
24		croak("FATAL: ocb setup failed");
	23	rv = ocb3_init(&RETVAL->state, id, k, (unsigned long)k_len, n, (unsigned long)n_len, taglen);
	24	if (rv != CRYPT_OK) {
	25	Safefree(RETVAL);
	26	croak("FATAL: ocb setup failed: %s", error_to_string(rv));
25	27	}
26	28	}
27	29	OUTPUT:

97	99	unsigned char in_data, out_data;
98	100
99	101	in_data = (unsigned char *)SvPVbyte(data, in_data_len);
100		if (in_data_len > 0) {
101		RETVAL = NEWSV(0, in_data_len);
102		SvPOK_only(RETVAL);
103		SvCUR_set(RETVAL, in_data_len);
104		out_data = (unsigned char *)SvPVX(RETVAL);
105		}
106		else {
107		RETVAL = newSVpvn("", 0);
108		out_data = NULL;
109		}
110		rv = ocb3_encrypt_last(&self->state, in_data, (unsigned long)in_data_len, out_data);
111		if (rv != CRYPT_OK) {
112		SvREFCNT_dec(RETVAL);
113		croak("FATAL: ocb3_encrypt_last failed: %s", error_to_string(rv));
	102	if (in_data_len == 0) {
	103	rv = ocb3_encrypt_last(&self->state, in_data, 0, NULL);
	104	if (rv != CRYPT_OK) {
	105	croak("FATAL: ocb3_encrypt_last failed: %s", error_to_string(rv));
	106	}
	107	RETVAL = newSVpvn("", 0);
	108	}
	109	else {
	110	RETVAL = NEWSV(0, in_data_len);
	111	SvPOK_only(RETVAL);
	112	SvCUR_set(RETVAL, in_data_len);
	113	out_data = (unsigned char *)SvPVX(RETVAL);
	114	rv = ocb3_encrypt_last(&self->state, in_data, (unsigned long)in_data_len, out_data);
	115	if (rv != CRYPT_OK) {
	116	SvREFCNT_dec(RETVAL);
	117	croak("FATAL: ocb3_encrypt_last failed: %s", error_to_string(rv));
	118	}
114	119	}
115	120	}
116	121	OUTPUT:

125	130	unsigned char in_data, out_data;
126	131
127	132	in_data = (unsigned char *)SvPVbyte(data, in_data_len);
128		if (in_data_len==0) {
	133	if (in_data_len == 0) {
129	134	RETVAL = newSVpvn("", 0);
130	135	}
131	136	else {

155	160	unsigned char in_data, out_data;
156	161
157	162	in_data = (unsigned char *)SvPVbyte(data, in_data_len);
158		if (in_data_len > 0) {
159		RETVAL = NEWSV(0, in_data_len);
160		SvPOK_only(RETVAL);
161		SvCUR_set(RETVAL, in_data_len);
162		out_data = (unsigned char *)SvPVX(RETVAL);
163		}
164		else {
165		RETVAL = newSVpvn("", 0);
166		out_data = NULL;
167		}
168		rv = ocb3_decrypt_last(&self->state, in_data, (unsigned long)in_data_len, out_data);
169		if (rv != CRYPT_OK) croak("FATAL: ocb3_encrypt_last failed: %s", error_to_string(rv));
	163	if (in_data_len == 0) {
	164	rv = ocb3_decrypt_last(&self->state, in_data, 0, NULL);
	165	if (rv != CRYPT_OK) {
	166	croak("FATAL: ocb3_encrypt_last failed: %s", error_to_string(rv));
	167	}
	168	RETVAL = newSVpvn("", 0);
	169	}
	170	else {
	171	RETVAL = NEWSV(0, in_data_len);
	172	SvPOK_only(RETVAL);
	173	SvCUR_set(RETVAL, in_data_len);
	174	out_data = (unsigned char *)SvPVX(RETVAL);
	175	rv = ocb3_decrypt_last(&self->state, in_data, (unsigned long)in_data_len, out_data);
	176	if (rv != CRYPT_OK) {
	177	SvREFCNT_dec(RETVAL);
	178	croak("FATAL: ocb3_encrypt_last failed: %s", error_to_string(rv));
	179	}
	180	}
170	181	}
171	182	OUTPUT:
172	183	RETVAL

201	212	XPUSHs(sv_2mortal(newSVpvn((char*)tag, tag_len)));
202	213	}
203	214	else {
204		if(!SvPOK(ST(1))) croak("FATAL: expected_tag must be string/buffer scalar");
	215	if (!SvPOK(ST(1))) croak("FATAL: expected_tag must be string/buffer scalar");
205	216	expected_tag = (unsigned char *) SvPVbyte(ST(1), expected_tag_len);
206	217	if (expected_tag_len!=tag_len) {
207	218	XPUSHs(sv_2mortal(newSViv(0))); /* false */

+9

-5

inc/CryptX_Checksum_Adler32.xs.inc less more

2	2	Crypt::Checksum::Adler32
3	3	new(Class)
4	4	CODE:
	5	{
5	6	Newz(0, RETVAL, 1, adler32_state);
6	7	if (!RETVAL) croak("FATAL: Newz failed");
7		adler32_init(RETVAL);
	8	adler32_init(RETVAL); /* returns void */
	9	}
8	10	OUTPUT:
9	11	RETVAL
10	12

17	19	reset(Crypt::Checksum::Adler32 self)
18	20	PPCODE:
19	21	{
20		adler32_init(self);
	22	adler32_init(self); /* returns void */
21	23	XPUSHs(ST(0)); /* return self */
22	24	}
23	25

39	41	unsigned char *in;
40	42	for(i=1; i<items; i++) {
41	43	in = (unsigned char *)SvPVbyte(ST(i), inlen);
42		if (inlen>0) adler32_update(self, in, (unsigned long)inlen);
	44	if (inlen > 0) {
	45	adler32_update(self, in, (unsigned long)inlen); /* returns void */
	46	}
43	47	}
44	48	XPUSHs(ST(0)); /* return self */
45	49	}

49	53	CODE:
50	54	{
51	55	unsigned char hash[4];
52		adler32_finish(self, hash, 4);
	56	adler32_finish(self, hash, 4); /* returns void */
53	57	RETVAL = newSVpvn((char *) hash, 4);
54	58	}
55	59	OUTPUT:

62	66	unsigned long i;
63	67	unsigned char hash[4];
64	68	char hash_hex[4*2 + 1];
65		adler32_finish(self, hash, 4);
	69	adler32_finish(self, hash, 4); /* returns void */
66	70	hash_hex[0] = '\0';
67	71	for(i=0; i<4; i++) sprintf(&hash_hex[2*i], "%02x", hash[i]);
68	72	RETVAL = newSVpvn(hash_hex, strlen(hash_hex));

+10

-5

inc/CryptX_Checksum_CRC32.xs.inc less more

2	2	Crypt::Checksum::CRC32
3	3	new(Class)
4	4	CODE:
	5	{
	6	int rv;
5	7	Newz(0, RETVAL, 1, crc32_state);
6	8	if (!RETVAL) croak("FATAL: Newz failed");
7		crc32_init(RETVAL);
	9	crc32_init(RETVAL); /* returns void */
	10	}
8	11	OUTPUT:
9	12	RETVAL
10	13

17	20	reset(Crypt::Checksum::CRC32 self)
18	21	PPCODE:
19	22	{
20		crc32_init(self);
	23	crc32_init(self); /* returns void */
21	24	XPUSHs(ST(0)); /* return self */
22	25	}
23	26

39	42	unsigned char *in;
40	43	for(i=1; i<items; i++) {
41	44	in = (unsigned char *)SvPVbyte(ST(i), inlen);
42		if (inlen>0) crc32_update(self, in, (unsigned long)inlen);
	45	if (inlen > 0) {
	46	crc32_update(self, in, (unsigned long)inlen); /* returns void */
	47	}
43	48	}
44	49	XPUSHs(ST(0)); /* return self */
45	50	}

49	54	CODE:
50	55	{
51	56	unsigned char hash[4];
52		crc32_finish(self, hash, 4);
	57	crc32_finish(self, hash, 4); /* returns void */
53	58	RETVAL = newSVpvn((char *) hash, 4);
54	59	}
55	60	OUTPUT:

62	67	unsigned long i;
63	68	unsigned char hash[4];
64	69	char hash_hex[4*2 + 1];
65		crc32_finish(self, hash, 4);
	70	crc32_finish(self, hash, 4); /* returns void */
66	71	hash_hex[0] = '\0';
67	72	for(i=0; i<4; i++) sprintf(&hash_hex[2*i], "%02x", hash[i]);
68	73	RETVAL = newSVpvn(hash_hex, strlen(hash_hex));

+9

-6

inc/CryptX_Cipher.xs.inc less more

15	15	key_data = (unsigned char *)SvPVbyte(key, key_len);
16	16
17	17	id = find_cipher(cipher_name);
18		if(id==-1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
	18	if (id == -1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
19	19
20	20	Newz(0, RETVAL, 1, struct cipher_struct);
21	21	if (!RETVAL) croak("FATAL: Newz failed");

23	23	RETVAL->id = id;
24	24	RETVAL->desc = &cipher_descriptor[id];
25	25	rv = RETVAL->desc->setup(key_data, (int)key_len, rounds, &RETVAL->skey);
26		if(rv!=CRYPT_OK) croak("FATAL: cipher setup failed: %s", error_to_string(rv));
	26	if (rv != CRYPT_OK) {
	27	Safefree(RETVAL);
	28	croak("FATAL: cipher setup failed: %s", error_to_string(rv));
	29	}
27	30	}
28	31	OUTPUT:
29	32	RETVAL

134	137	int rv, id;
135	138
136	139	id = find_cipher(cipher_name);
137		if(id==-1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
	140	if (id == -1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
138	141
139	142	rv = cipher_descriptor[id].block_length;
140	143	if (!rv) XSRETURN_UNDEF;

151	154	int rv, id;
152	155
153	156	id = find_cipher(cipher_name);
154		if(id==-1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
	157	if (id == -1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
155	158
156	159	rv = cipher_descriptor[id].min_key_length;
157	160	if (!rv) XSRETURN_UNDEF;

168	171	int rv, id;
169	172
170	173	id = find_cipher(cipher_name);
171		if(id==-1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
	174	if (id == -1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
172	175
173	176	rv = cipher_descriptor[id].max_key_length;
174	177	if (!rv) XSRETURN_UNDEF;

185	188	int rv, id;
186	189
187	190	id = find_cipher(cipher_name);
188		if(id==-1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
	191	if (id == -1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
189	192
190	193	rv = cipher_descriptor[id].default_rounds;
191	194	if (!rv) XSRETURN_UNDEF;

+7

-3

inc/CryptX_Digest.xs.inc less more

8	8	int id;
9	9
10	10	id = find_hash(digest_name);
11		if(id==-1) croak("FATAL: find_hash failed for '%s'", digest_name);
	11	if (id == -1) croak("FATAL: find_hash failed for '%s'", digest_name);
12	12
13	13	Newz(0, RETVAL, 1, struct digest_struct);
14	14	if (!RETVAL) croak("FATAL: Newz failed");

16	16	RETVAL->id = id;
17	17	RETVAL->desc = &hash_descriptor[id];
18	18	rv = RETVAL->desc->init(&RETVAL->state);
19		if(rv!=CRYPT_OK) croak("FATAL: digest setup failed: %s", error_to_string(rv));
	19	if (rv != CRYPT_OK) {
	20	Safefree(RETVAL);
	21	croak("FATAL: digest setup failed: %s", error_to_string(rv));
	22	}
20	23	}
21	24	OUTPUT:
22	25	RETVAL

43	46	Crypt::Digest self
44	47	CODE:
45	48	Newz(0, RETVAL, 1, struct digest_struct);
	49	if (!RETVAL) croak("FATAL: Newz failed");
46	50	Copy(&self->state, &RETVAL->state, 1, struct digest_struct);
47	51	OUTPUT:
48	52	RETVAL

159	163	int rv, id;
160	164
161	165	id = find_hash(digest_name);
162		if(id==-1) croak("FATAL: find_digest failed for '%s'", digest_name);
	166	if (id == -1) croak("FATAL: find_digest failed for '%s'", digest_name);
163	167
164	168	rv = hash_descriptor[id].hashsize;
165	169	if (!rv) croak("FATAL: invalid hashsize for '%s'", digest_name);;

+5

-1

inc/CryptX_Digest_SHAKE.xs.inc less more

10	10
11	11	RETVAL->num = num;
12	12	rv = sha3_shake_init(&RETVAL->state, RETVAL->num);
13		if (rv != CRYPT_OK) croak("FATAL: sha3_shake_init failed: %s", error_to_string(rv));
	13	if (rv != CRYPT_OK) {
	14	Safefree(RETVAL);
	15	croak("FATAL: sha3_shake_init failed: %s", error_to_string(rv));
	16	}
14	17	}
15	18	OUTPUT:
16	19	RETVAL

34	37	clone(Crypt::Digest::SHAKE self)
35	38	CODE:
36	39	Newz(0, RETVAL, 1, struct digest_shake_struct);
	40	if (!RETVAL) croak("FATAL: Newz failed");
37	41	Copy(&self->state, &RETVAL->state, 1, struct digest_shake_struct);
38	42	OUTPUT:
39	43	RETVAL

+44

-37

inc/CryptX_KeyDerivation.xs.inc less more

0	0	MODULE = CryptX PACKAGE = Crypt::KeyDerivation
1	1
2	2	SV *
3		_pkcs_5_alg1(SV * password, SV * salt, int iteration_count, char * hash_name, int len)
	3	_pkcs_5_alg1(SV * password, SV * salt, int iteration_count, char * hash_name, unsigned long output_len)
4	4	CODE:
5	5	{
6	6	/*

10	10	unsigned char out, unsigned long outlen)
11	11	*/
12	12	int rv, id;
13		unsigned long output_len;
14	13	unsigned char *output;
15	14	unsigned char *password_ptr=NULL;
16	15	STRLEN password_len=0;

18	17	STRLEN salt_len=0;
19	18
20	19	id = find_hash(hash_name);
21		if(id==-1) croak("FATAL: find_hash failed for '%s'", hash_name);
	20	if (id == -1) croak("FATAL: find_hash failed for '%s'", hash_name);
22	21
23	22	password_ptr = (unsigned char *)SvPVbyte(password, password_len);
24	23	salt_ptr = (unsigned char *)SvPVbyte(salt, salt_len);
25	24	if (salt_len < 8) croak("FATAL: salt_len has to be 8");
26	25
27		output_len = len;
28		Newz(0, output, output_len, unsigned char);
29		if (!output) croak("FATAL: Newz failed [%ld]", output_len);
	26	RETVAL = NEWSV(0, output_len);
	27	SvPOK_only(RETVAL);
	28	SvCUR_set(RETVAL, output_len);
	29	output = (unsigned char *)SvPVX(RETVAL);
30	30
31	31	rv = pkcs_5_alg1(password_ptr, (unsigned long)password_len, salt_ptr, iteration_count, id, output, &output_len);
32		if (rv != CRYPT_OK) croak("FATAL: pkcs_5_alg1 process failed: %s", error_to_string(rv));
33
34		RETVAL = newSVpvn((char *)output, output_len);
35		Safefree(output);
	32	if (rv != CRYPT_OK) {
	33	SvREFCNT_dec(RETVAL);
	34	croak("FATAL: pkcs_5_alg1 process failed: %s", error_to_string(rv));
	35	}
	36	SvCUR_set(RETVAL, output_len);
36	37	}
37	38	OUTPUT:
38	39	RETVAL
39	40
40	41	SV *
41		_pkcs_5_alg2(SV * password, SV * salt, int iteration_count, char * hash_name, int len)
	42	_pkcs_5_alg2(SV * password, SV * salt, int iteration_count, char * hash_name, unsigned long output_len)
42	43	CODE:
43	44	{
44	45	/*

48	49	unsigned char out, unsigned long outlen)
49	50	*/
50	51	int rv, id;
51		unsigned long output_len;
52	52	unsigned char *output;
53	53	unsigned char *password_ptr=NULL;
54	54	STRLEN password_len=0;

56	56	STRLEN salt_len=0;
57	57
58	58	id = find_hash(hash_name);
59		if(id==-1) croak("FATAL: find_hash failed for '%s'", hash_name);
	59	if (id == -1) croak("FATAL: find_hash failed for '%s'", hash_name);
60	60
61	61	password_ptr = (unsigned char *)SvPVbyte(password, password_len);
62	62	salt_ptr = (unsigned char *)SvPVbyte(salt, salt_len);
63	63
64		output_len = len;
65		Newz(0, output, output_len, unsigned char);
66		if (!output) croak("FATAL: Newz failed [%ld]", output_len);
	64	RETVAL = NEWSV(0, output_len);
	65	SvPOK_only(RETVAL);
	66	SvCUR_set(RETVAL, output_len);
	67	output = (unsigned char *)SvPVX(RETVAL);
67	68
68	69	rv = pkcs_5_alg2(password_ptr, (unsigned long)password_len, salt_ptr, (unsigned long)salt_len, iteration_count, id, output, &output_len);
69		if (rv != CRYPT_OK) croak("FATAL: pkcs_5_alg2 process failed: %s", error_to_string(rv));
70
71		RETVAL = newSVpvn((char *)output, output_len);
72		Safefree(output);
	70	if (rv != CRYPT_OK) {
	71	SvREFCNT_dec(RETVAL);
	72	croak("FATAL: pkcs_5_alg2 process failed: %s", error_to_string(rv));
	73	}
	74	SvCUR_set(RETVAL, output_len);
73	75	}
74	76	OUTPUT:
75	77	RETVAL

92	94	STRLEN salt_len=0;
93	95
94	96	id = find_hash(hash_name);
95		if(id==-1) croak("FATAL: find_hash failed for '%s'", hash_name);
	97	if (id == -1) croak("FATAL: find_hash failed for '%s'", hash_name);
96	98
97	99	in_ptr = (unsigned char *)SvPVbyte(in, in_len);
98	100	salt_ptr = (unsigned char *)SvPVbyte(salt, salt_len);

123	125	STRLEN info_len=0;
124	126
125	127	id = find_hash(hash_name);
126		if(id==-1) croak("FATAL: find_hash failed for '%s'", hash_name);
	128	if (id == -1) croak("FATAL: find_hash failed for '%s'", hash_name);
127	129
128	130	in_ptr = (unsigned char *)SvPVbyte(in, in_len);
129	131	info_ptr = (unsigned char *)SvPVbyte(info, info_len);
130	132
131		Newz(0, output, output_len, unsigned char);
132		if (!output) croak("FATAL: Newz failed [%ld]", output_len);
	133	RETVAL = NEWSV(0, output_len);
	134	SvPOK_only(RETVAL);
	135	SvCUR_set(RETVAL, output_len);
	136	output = (unsigned char *)SvPVX(RETVAL);
133	137
134	138	rv = hkdf_expand(id, info_ptr, (unsigned long)info_len, in_ptr, (unsigned long)in_len, output, output_len);
135		if (rv != CRYPT_OK) croak("FATAL: hkdf_expand process failed: %s", error_to_string(rv));
136
137		RETVAL = newSVpvn((char *)output, output_len);
138		Safefree(output);
	139	if (rv != CRYPT_OK) {
	140	SvREFCNT_dec(RETVAL);
	141	croak("FATAL: hkdf_expand process failed: %s", error_to_string(rv));
	142	}
	143	SvCUR_set(RETVAL, output_len);
139	144	}
140	145	OUTPUT:
141	146	RETVAL

160	165	STRLEN salt_len=0;
161	166
162	167	id = find_hash(hash_name);
163		if(id==-1) croak("FATAL: find_hash failed for '%s'", hash_name);
	168	if (id == -1) croak("FATAL: find_hash failed for '%s'", hash_name);
164	169
165		in_ptr = (unsigned char *)SvPVbyte(in, in_len);
	170	in_ptr = (unsigned char *)SvPVbyte(in, in_len);
166	171	info_ptr = (unsigned char *)SvPVbyte(info, info_len);
167	172	salt_ptr = (unsigned char *)SvPVbyte(salt, salt_len);
168	173
169		Newz(0, output, output_len, unsigned char);
170		if (!output) croak("FATAL: Newz failed [%ld]", output_len);
	174	RETVAL = NEWSV(0, output_len);
	175	SvPOK_only(RETVAL);
	176	SvCUR_set(RETVAL, output_len);
	177	output = (unsigned char *)SvPVX(RETVAL);
171	178
172	179	rv = hkdf(id, salt_ptr, (unsigned long)salt_len, info_ptr, (unsigned long)info_len, in_ptr, (unsigned long)in_len, output, output_len);
173		if (rv != CRYPT_OK) croak("FATAL: hkdf_expand process failed: %s", error_to_string(rv));
174
175		RETVAL = newSVpvn((char *)output, output_len);
176		Safefree(output);
	180	if (rv != CRYPT_OK) {
	181	SvREFCNT_dec(RETVAL);
	182	croak("FATAL: hkdf_expand process failed: %s", error_to_string(rv));
	183	}
	184	SvCUR_set(RETVAL, output_len);
177	185	}
178	186	OUTPUT:
179	187	RETVAL
180

+4

-1

inc/CryptX_Mac_BLAKE2b.xs.inc less more

16	16	if (!RETVAL) croak("FATAL: Newz failed");
17	17
18	18	rv = blake2bmac_init(&RETVAL->state, size, k, (unsigned long)k_len);
19		if (rv != CRYPT_OK) croak("FATAL: blake2b_init failed: %s", error_to_string(rv));
	19	if (rv != CRYPT_OK) {
	20	Safefree(RETVAL);
	21	croak("FATAL: blake2b_init failed: %s", error_to_string(rv));
	22	}
20	23	}
21	24	OUTPUT:
22	25	RETVAL

+4

-1

inc/CryptX_Mac_BLAKE2s.xs.inc less more

16	16	if (!RETVAL) croak("FATAL: Newz failed");
17	17
18	18	rv = blake2smac_init(&RETVAL->state, size, k, (unsigned long)k_len);
19		if (rv != CRYPT_OK) croak("FATAL: blake2s_init failed: %s", error_to_string(rv));
	19	if (rv != CRYPT_OK) {
	20	Safefree(RETVAL);
	21	croak("FATAL: blake2s_init failed: %s", error_to_string(rv));
	22	}
20	23	}
21	24	OUTPUT:
22	25	RETVAL

+5

-2

inc/CryptX_Mac_F9.xs.inc less more

11	11	int id;
12	12
13	13	id = find_cipher(cipher_name);
14		if(id==-1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
	14	if (id == -1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
15	15
16	16	if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");
17	17	k = (unsigned char *) SvPVbyte(key, k_len);

20	20	if (!RETVAL) croak("FATAL: Newz failed");
21	21
22	22	rv = f9_init(&RETVAL->state, id, k, (unsigned long)k_len);
23		if (rv != CRYPT_OK) croak("FATAL: f9_init failed: %s", error_to_string(rv));
	23	if (rv != CRYPT_OK) {
	24	Safefree(RETVAL);
	25	croak("FATAL: f9_init failed: %s", error_to_string(rv));
	26	}
24	27	}
25	28	OUTPUT:
26	29	RETVAL

+5

-2

inc/CryptX_Mac_HMAC.xs.inc less more

11	11	int id;
12	12
13	13	id = find_hash(hash_name);
14		if(id==-1) croak("FATAL: find_hash failed for '%s'", hash_name);
	14	if (id == -1) croak("FATAL: find_hash failed for '%s'", hash_name);
15	15
16	16	if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");
17	17	k = (unsigned char *) SvPVbyte(key, k_len);

20	20	if (!RETVAL) croak("FATAL: Newz failed");
21	21
22	22	rv = hmac_init(&RETVAL->state, id, k, (unsigned long)k_len);
23		if (rv != CRYPT_OK) croak("FATAL: hmac_init failed: %s", error_to_string(rv));
	23	if (rv != CRYPT_OK) {
	24	Safefree(RETVAL);
	25	croak("FATAL: hmac_init failed: %s", error_to_string(rv));
	26	}
24	27	}
25	28	OUTPUT:
26	29	RETVAL

+5

-2

inc/CryptX_Mac_OMAC.xs.inc less more

11	11	int id;
12	12
13	13	id = find_cipher(cipher_name);
14		if(id==-1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
	14	if (id == -1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
15	15
16	16	if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");
17	17	k = (unsigned char *) SvPVbyte(key, k_len);

20	20	if (!RETVAL) croak("FATAL: Newz failed");
21	21
22	22	rv = omac_init(&RETVAL->state, id, k, (unsigned long)k_len);
23		if (rv != CRYPT_OK) croak("FATAL: omac_init failed: %s", error_to_string(rv));
	23	if (rv != CRYPT_OK) {
	24	Safefree(RETVAL);
	25	croak("FATAL: omac_init failed: %s", error_to_string(rv));
	26	}
24	27	}
25	28	OUTPUT:
26	29	RETVAL

+5

-2

inc/CryptX_Mac_PMAC.xs.inc less more

11	11	int id;
12	12
13	13	id = find_cipher(cipher_name);
14		if(id==-1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
	14	if (id == -1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
15	15
16	16	if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");
17	17	k = (unsigned char *) SvPVbyte(key, k_len);

20	20	if (!RETVAL) croak("FATAL: Newz failed");
21	21
22	22	rv = pmac_init(&RETVAL->state, id, k, (unsigned long)k_len);
23		if (rv != CRYPT_OK) croak("FATAL: pmac_init failed: %s", error_to_string(rv));
	23	if (rv != CRYPT_OK) {
	24	Safefree(RETVAL);
	25	croak("FATAL: pmac_init failed: %s", error_to_string(rv));
	26	}
24	27	}
25	28	OUTPUT:
26	29	RETVAL

+4

-1

inc/CryptX_Mac_Pelican.xs.inc less more

16	16	if (!RETVAL) croak("FATAL: Newz failed");
17	17
18	18	rv = pelican_init(&RETVAL->state, k, (unsigned long)k_len);
19		if (rv != CRYPT_OK) croak("FATAL: pelican_init failed: %s", error_to_string(rv));
	19	if (rv != CRYPT_OK) {
	20	Safefree(RETVAL);
	21	croak("FATAL: pelican_init failed: %s", error_to_string(rv));
	22	}
20	23	}
21	24	OUTPUT:
22	25	RETVAL

+4

-1

inc/CryptX_Mac_Poly1305.xs.inc less more

16	16	if (!RETVAL) croak("FATAL: Newz failed");
17	17
18	18	rv = poly1305_init(&RETVAL->state, k, (unsigned long)k_len);
19		if (rv != CRYPT_OK) croak("FATAL: poly1305_init failed: %s", error_to_string(rv));
	19	if (rv != CRYPT_OK) {
	20	Safefree(RETVAL);
	21	croak("FATAL: poly1305_init failed: %s", error_to_string(rv));
	22	}
20	23	}
21	24	OUTPUT:
22	25	RETVAL

+5

-2

inc/CryptX_Mac_XCBC.xs.inc less more

11	11	int id;
12	12
13	13	id = find_cipher(cipher_name);
14		if(id==-1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
	14	if (id == -1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
15	15
16	16	if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");
17	17	k = (unsigned char *) SvPVbyte(key, k_len);

20	20	if (!RETVAL) croak("FATAL: Newz failed");
21	21
22	22	rv = xcbc_init(&RETVAL->state, id, k, (unsigned long)k_len);
23		if (rv != CRYPT_OK) croak("FATAL: xcbc_init failed: %s", error_to_string(rv));
	23	if (rv != CRYPT_OK) {
	24	Safefree(RETVAL);
	25	croak("FATAL: xcbc_init failed: %s", error_to_string(rv));
	26	}
24	27	}
25	28	OUTPUT:
26	29	RETVAL

+25

-16

inc/CryptX_Mode_CBC.xs.inc less more

12	12	RETVAL->direction = 0;
13	13	RETVAL->cipher_rounds = rounds;
14	14	RETVAL->cipher_id = find_cipher(cipher_name);
15		if(RETVAL->cipher_id==-1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
	15	if (RETVAL->cipher_id == -1) {
	16	Safefree(RETVAL);
	17	croak("FATAL: find_cipfer failed for '%s'", cipher_name);
	18	}
16	19	}
17	20	OUTPUT:
18	21	RETVAL

72	75	in_data_start = 0;
73	76	has_tmp_block = 0;
74	77	in_data = (unsigned char *)SvPVbyte(data, in_data_len);
75		if (in_data_len==0) {
	78	if (in_data_len == 0) {
76	79	RETVAL = newSVpvn("", 0);
77	80	}
78	81	else {
79		if(self->padlen > 0) {
	82	if (self->padlen > 0) {
80	83	i = (blen - self->padlen);
81	84	if (in_data_len >= i) { /* enough data to fill pad */
82	85	Copy(in_data, self->pad+self->padlen, i, unsigned char);

101	104	in_data_len -= i;
102	105	}
103	106
104		if (in_data_len>0) {
	107	if (in_data_len > 0) {
105	108	i = (unsigned long)(has_tmp_block ? in_data_len + blen : in_data_len);
106	109	RETVAL = NEWSV(0, i);
107	110	SvPOK_only(RETVAL);

112	115	out_data += blen;
113	116	}
114	117	rv = cbc_encrypt(in_data+in_data_start, out_data, (unsigned long)in_data_len, &self->state);
115		if (rv != CRYPT_OK) croak("FATAL: cbc_encrypt failed: %s", error_to_string(rv));
	118	if (rv != CRYPT_OK) {
	119	SvREFCNT_dec(RETVAL);
	120	croak("FATAL: cbc_encrypt failed: %s", error_to_string(rv));
	121	}
116	122	} /* in_data_len>0 */
117	123	else if (has_tmp_block) {
118	124	RETVAL = newSVpvn((char*)tmp_block, blen);

135	141	blen = (&self->state)->blocklen;
136	142	if (self->padlen<0 \|\| self->padlen>=blen) croak("FATAL: invalid padlen");
137	143
138		if(self->padding_mode == 1) { /* pkcs5\|7 padding */
	144	if (self->padding_mode == 1) { /* pkcs5\|7 padding */
139	145	i = blen - self->padlen;
140	146	if (i == 0) i = blen;
141	147	for(j=self->padlen; j<blen; j++) self->pad[j] = (unsigned char)i;
142	148	rv = cbc_encrypt(self->pad, tmp_block, blen, &self->state);
143	149	if (rv != CRYPT_OK) croak("FATAL: cbc_encrypt failed: %s", error_to_string(rv));
144	150	}
145		else if(self->padding_mode == 2) { /* oneandzeroes padding */
	151	else if (self->padding_mode == 2) { /* oneandzeroes padding */
146	152	self->pad[self->padlen] = 0x80;
147	153	for(j=self->padlen+1; j<blen; j++) self->pad[j] = 0;
148	154	rv = cbc_encrypt(self->pad, tmp_block, blen, &self->state);

174	180	in_data_start = 0;
175	181	has_tmp_block = 0;
176	182	in_data = (unsigned char *)SvPVbyte(data, in_data_len);
177		if (in_data_len==0) {
	183	if (in_data_len == 0) {
178	184	RETVAL = newSVpvn("", 0);
179	185	}
180	186	else {
181	187
182		if(self->padlen == blen) {
	188	if (self->padlen == blen) {
183	189	rv = cbc_decrypt(self->pad, tmp_block, blen, &self->state);
184	190	if (rv != CRYPT_OK) croak("FATAL: cbc_decrypt failed: %s", error_to_string(rv));
185	191	self->padlen = 0;
186	192	has_tmp_block = 1;
187	193	} /* padlen == blen */
188		else if(self->padlen > 0) {
	194	else if (self->padlen > 0) {
189	195	i = (blen - self->padlen); /* remaining bytes in padding buffer */
190	196	if (in_data_len >= i) { /* enough data to fill pad */
191	197	Copy(in_data, self->pad+self->padlen, i, unsigned char);

206	212	}
207	213	} /* padlen > 0 */
208	214
209		/* here: a/ padlen==1..16 && in_data_len==0; b/ padlen==0 && in_data_len>0 */
	215	/* here: a/ padlen == 1..16 && in_data_len == 0; b/ padlen == 0 && in_data_len > 0 */
210	216	if (in_data_len>0) {
211	217	i = (unsigned long)(in_data_len % blen);
212	218	if (i>0) { /* save tail of data into pad */

217	223	}
218	224
219	225	if (in_data_len>0) {
220		if(self->padlen == 0 && self->padding_mode !=0) {
	226	if (self->padlen == 0 && self->padding_mode !=0) {
221	227	/* in case of padding keep full pad if no more data */
222	228	Copy(in_data+in_data_start+in_data_len-blen, self->pad, blen, unsigned char);
223	229	self->padlen = blen;

237	243	out_data += blen;
238	244	}
239	245	rv = cbc_decrypt(in_data+in_data_start, out_data, (unsigned long)in_data_len, &self->state);
240		if (rv != CRYPT_OK) croak("FATAL: cbc_decrypt failed: %s", error_to_string(rv));
	246	if (rv != CRYPT_OK) {
	247	SvREFCNT_dec(RETVAL);
	248	croak("FATAL: cbc_decrypt failed: %s", error_to_string(rv));
	249	}
241	250	}
242	251	} /* in_data_len>0 */
243	252	else if (has_tmp_block) {

266	275	if (self->padlen != blen) croak("FATAL: cipher text length has to be multiple of %d (%d)", blen, self->padlen);
267	276	rv = cbc_decrypt(self->pad, tmp_block, blen, &self->state);
268	277	if (rv != CRYPT_OK) croak("FATAL: cbc_decrypt failed: %s", error_to_string(rv));
269		if(self->padding_mode == 0) { /* no padding */
	278	if (self->padding_mode == 0) { /* no padding */
270	279	rv_len = blen;
271	280	}
272		else if(self->padding_mode == 1) { /* pkcs5\|7 padding */
	281	else if (self->padding_mode == 1) { /* pkcs5\|7 padding */
273	282	i = tmp_block[blen-1];
274	283	rv_len = blen - (i>blen ? blen : i);
275	284	}
276		else if(self->padding_mode == 2) { /* oneandzeroes padding */
	285	else if (self->padding_mode == 2) { /* oneandzeroes padding */
277	286	rv_len = blen;
278	287	while ((unsigned char)tmp_block[rv_len-1] == 0x00) rv_len--;
279	288	if ((unsigned char)tmp_block[rv_len-1] == 0x80) rv_len--;

+4

-1

inc/CryptX_Mode_CFB.xs.inc less more

10	10	RETVAL->direction = 0;
11	11	RETVAL->cipher_rounds = rounds;
12	12	RETVAL->cipher_id = find_cipher(cipher_name);
13		if(RETVAL->cipher_id==-1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
	13	if (RETVAL->cipher_id == -1) {
	14	Safefree(RETVAL);
	15	croak("FATAL: find_cipfer failed for '%s'", cipher_name);
	16	}
14	17	}
15	18	OUTPUT:
16	19	RETVAL

+4

-1

inc/CryptX_Mode_CTR.xs.inc less more

10	10	RETVAL->direction = 0;
11	11	RETVAL->cipher_rounds = rounds;
12	12	RETVAL->cipher_id = find_cipher(cipher_name);
13		if(RETVAL->cipher_id==-1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
	13	if (RETVAL->cipher_id == -1) {
	14	Safefree(RETVAL);
	15	croak("FATAL: find_cipfer failed for '%s'", cipher_name);
	16	}
14	17	if (ctr_mode == 0) RETVAL->ctr_mode_param = CTR_COUNTER_LITTLE_ENDIAN;
15	18	if (ctr_mode == 1) RETVAL->ctr_mode_param = CTR_COUNTER_BIG_ENDIAN;
16	19	if (ctr_mode == 2) RETVAL->ctr_mode_param = CTR_COUNTER_LITTLE_ENDIAN\|LTC_CTR_RFC3686;

+25

-16

inc/CryptX_Mode_ECB.xs.inc less more

12	12	RETVAL->direction = 0;
13	13	RETVAL->cipher_rounds = rounds;
14	14	RETVAL->cipher_id = find_cipher(cipher_name);
15		if(RETVAL->cipher_id==-1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
	15	if (RETVAL->cipher_id == -1) {
	16	Safefree(RETVAL);
	17	croak("FATAL: find_cipfer failed for '%s'", cipher_name);
	18	}
16	19	}
17	20	OUTPUT:
18	21	RETVAL

65	68	in_data_start = 0;
66	69	has_tmp_block = 0;
67	70	in_data = (unsigned char *)SvPVbyte(data, in_data_len);
68		if (in_data_len==0) {
	71	if (in_data_len == 0) {
69	72	RETVAL = newSVpvn("", 0);
70	73	}
71	74	else {
72		if(self->padlen > 0) {
	75	if (self->padlen > 0) {
73	76	i = (blen - self->padlen);
74	77	if (in_data_len >= i) { /* enough data to fill pad */
75	78	Copy(in_data, self->pad+self->padlen, i, unsigned char);

94	97	in_data_len -= i;
95	98	}
96	99
97		if (in_data_len>0) {
	100	if (in_data_len > 0) {
98	101	i = (unsigned long)(has_tmp_block ? in_data_len + blen : in_data_len);
99	102	RETVAL = NEWSV(0, i);
100	103	SvPOK_only(RETVAL);

105	108	out_data += blen;
106	109	}
107	110	rv = ecb_encrypt(in_data+in_data_start, out_data, (unsigned long)in_data_len, &self->state);
108		if (rv != CRYPT_OK) croak("FATAL: ecb_encrypt failed: %s", error_to_string(rv));
	111	if (rv != CRYPT_OK) {
	112	SvREFCNT_dec(RETVAL);
	113	croak("FATAL: ecb_encrypt failed: %s", error_to_string(rv));
	114	}
109	115	} /* in_data_len>0 */
110	116	else if (has_tmp_block) {
111	117	RETVAL = newSVpvn((char*)tmp_block, blen);

128	134	blen = (&self->state)->blocklen;
129	135	if (self->padlen<0 \|\| self->padlen>=blen) croak("FATAL: invalid padlen");
130	136
131		if(self->padding_mode == 1) { /* pkcs5\|7 padding */
	137	if (self->padding_mode == 1) { /* pkcs5\|7 padding */
132	138	i = blen - self->padlen;
133	139	if (i == 0) i = blen;
134	140	for(j=self->padlen; j<blen; j++) self->pad[j] = (unsigned char)i;
135	141	rv = ecb_encrypt(self->pad, tmp_block, blen, &self->state);
136	142	if (rv != CRYPT_OK) croak("FATAL: ecb_encrypt failed: %s", error_to_string(rv));
137	143	}
138		else if(self->padding_mode == 2) { /* oneandzeroes padding */
	144	else if (self->padding_mode == 2) { /* oneandzeroes padding */
139	145	self->pad[self->padlen] = 0x80;
140	146	for(j=self->padlen+1; j<blen; j++) self->pad[j] = 0;
141	147	rv = ecb_encrypt(self->pad, tmp_block, blen, &self->state);

167	173	in_data_start = 0;
168	174	has_tmp_block = 0;
169	175	in_data = (unsigned char *)SvPVbyte(data, in_data_len);
170		if (in_data_len==0) {
	176	if (in_data_len == 0) {
171	177	RETVAL = newSVpvn("", 0);
172	178	}
173	179	else {
174	180
175		if(self->padlen == blen) {
	181	if (self->padlen == blen) {
176	182	rv = ecb_decrypt(self->pad, tmp_block, blen, &self->state);
177	183	if (rv != CRYPT_OK) croak("FATAL: ecb_decrypt failed: %s", error_to_string(rv));
178	184	self->padlen = 0;
179	185	has_tmp_block = 1;
180	186	} /* padlen == blen */
181		else if(self->padlen > 0) {
	187	else if (self->padlen > 0) {
182	188	i = (blen - self->padlen); /* remaining bytes in padding buffer */
183	189	if (in_data_len >= i) { /* enough data to fill pad */
184	190	Copy(in_data, self->pad+self->padlen, i, unsigned char);

199	205	}
200	206	} /* padlen > 0 */
201	207
202		/* here: a/ padlen==1..16 && in_data_len==0; b/ padlen==0 && in_data_len>0 */
	208	/* here: a/ padlen == 1..16 && in_data_len == 0; b/ padlen == 0 && in_data_len > 0 */
203	209	if (in_data_len>0) {
204	210	i = (unsigned long)(in_data_len % blen);
205	211	if (i>0) { /* save tail of data into pad */

210	216	}
211	217
212	218	if (in_data_len>0) {
213		if(self->padlen == 0 && self->padding_mode !=0) {
	219	if (self->padlen == 0 && self->padding_mode !=0) {
214	220	/* in case of padding keep full pad if no more data */
215	221	Copy(in_data+in_data_start+in_data_len-blen, self->pad, blen, unsigned char);
216	222	self->padlen = blen;

230	236	out_data += blen;
231	237	}
232	238	rv = ecb_decrypt(in_data+in_data_start, out_data, (unsigned long)in_data_len, &self->state);
233		if (rv != CRYPT_OK) croak("FATAL: ecb_decrypt failed: %s", error_to_string(rv));
	239	if (rv != CRYPT_OK) {
	240	SvREFCNT_dec(RETVAL);
	241	croak("FATAL: ecb_decrypt failed: %s", error_to_string(rv));
	242	}
234	243	}
235	244	} /* in_data_len>0 */
236	245	else if (has_tmp_block) {

259	268	if (self->padlen != blen) croak("FATAL: cipher text length has to be multiple of %d (%d)", blen, self->padlen);
260	269	rv = ecb_decrypt(self->pad, tmp_block, blen, &self->state);
261	270	if (rv != CRYPT_OK) croak("FATAL: ecb_decrypt failed: %s", error_to_string(rv));
262		if(self->padding_mode == 0) { /* no padding */
	271	if (self->padding_mode == 0) { /* no padding */
263	272	rv_len = blen;
264	273	}
265		else if(self->padding_mode == 1) { /* pkcs5\|7 padding */
	274	else if (self->padding_mode == 1) { /* pkcs5\|7 padding */
266	275	i = tmp_block[blen-1];
267	276	rv_len = blen - (i>blen ? blen : i);
268	277	}
269		else if(self->padding_mode == 2) { /* oneandzeroes padding */
	278	else if (self->padding_mode == 2) { /* oneandzeroes padding */
270	279	rv_len = blen;
271	280	while ((unsigned char)tmp_block[rv_len-1] == 0x00) rv_len--;
272	281	if ((unsigned char)tmp_block[rv_len-1] == 0x80) rv_len--;

+4

-1

inc/CryptX_Mode_OFB.xs.inc less more

10	10	RETVAL->direction = 0;
11	11	RETVAL->cipher_rounds = rounds;
12	12	RETVAL->cipher_id = find_cipher(cipher_name);
13		if(RETVAL->cipher_id==-1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
	13	if (RETVAL->cipher_id == -1) {
	14	Safefree(RETVAL);
	15	croak("FATAL: find_cipfer failed for '%s'", cipher_name);
	16	}
14	17	}
15	18	OUTPUT:
16	19	RETVAL

+16

-10

inc/CryptX_PK_DH.xs.inc less more

8	8	if (!RETVAL) croak("FATAL: Newz failed");
9	9	RETVAL->key.type = -1;
10	10	RETVAL->pindex = find_prng("chacha20");
11		if(RETVAL->pindex==-1) croak("FATAL: find_prng('chacha20') failed");
	11	if (RETVAL->pindex == -1) {
	12	Safefree(RETVAL);
	13	croak("FATAL: find_prng('chacha20') failed");
	14	}
12	15	rv = rng_make_prng(320, RETVAL->pindex, &RETVAL->pstate, NULL); /* 320bits = 40bytes */
13		if (rv != CRYPT_OK) croak("FATAL: rng_make_prng failed: %s", error_to_string(rv));
	16	if (rv != CRYPT_OK) {
	17	Safefree(RETVAL);
	18	croak("FATAL: rng_make_prng failed: %s", error_to_string(rv));
	19	}
14	20	}
15	21	OUTPUT:
16	22	RETVAL

148	154	CODE:
149	155	if (self->key.type == -1) XSRETURN_UNDEF;
150	156	rv_hash = newHV();
151		/* =====> x */
	157	/* x */
152	158	siz = (self->key.x) ? mp_unsigned_bin_size(self->key.x) : 0;
153	159	if (siz>10000) {
154	160	croak("FATAL: key2hash failed - 'x' too big number");

160	166	else{
161	167	not_used = hv_store(rv_hash, "x", 1, newSVpv("", 0), 0);
162	168	}
163		/* =====> y */
	169	/* y */
164	170	siz = (self->key.y) ? mp_unsigned_bin_size(self->key.y) : 0;
165	171	if (siz>10000) {
166	172	croak("FATAL: key2hash failed - 'y' too big number");

172	178	else{
173	179	not_used = hv_store(rv_hash, "y", 1, newSVpv("", 0), 0);
174	180	}
175		/* =====> p */
	181	/* p */
176	182	siz = (self->key.prime) ? mp_unsigned_bin_size(self->key.prime) : 0;
177	183	if (siz>10000) {
178	184	croak("FATAL: key2hash failed - 'p' too big number");

185	191	not_used = hv_store(rv_hash, "p", 1, newSVpv("", 0), 0);
186	192	}
187	193
188		/* =====> g */
	194	/* g */
189	195	siz = (self->key.base) ? mp_unsigned_bin_size(self->key.base) : 0;
190	196	if (siz>10000) {
191	197	croak("FATAL: key2hash failed - 'g' too big number");

197	203	else {
198	204	not_used = hv_store(rv_hash, "g", 1, newSVpv("", 0), 0);
199	205	}
200		/* =====> size */
	206	/* size */
201	207	not_used = hv_store(rv_hash, "size", 4, newSViv(dh_get_groupsize(&self->key)), 0);
202		/* =====> type */
	208	/* type */
203	209	not_used = hv_store(rv_hash, "type", 4, newSViv(self->key.type), 0);
204	210	if (not_used) not_used = NULL; /* just silence the warning: variable 'not_used' set but not used */
205	211	RETVAL = newRV_noinc((SV*)rv_hash);

216	222	CODE:
217	223	if (self->key.type == -1) XSRETURN_UNDEF;
218	224	rv_hash = newHV();
219		/* =====> p */
	225	/* p */
220	226	siz = (self->key.prime) ? mp_unsigned_bin_size(self->key.prime) : 0;
221	227	if (siz>10000) {
222	228	croak("FATAL: key2hash failed - 'p' too big number");

229	235	not_used = hv_store(rv_hash, "p", 1, newSVpv("", 0), 0);
230	236	}
231	237
232		/* =====> g */
	238	/* g */
233	239	siz = (self->key.base) ? mp_unsigned_bin_size(self->key.base) : 0;
234	240	if (siz>10000) {
235	241	croak("FATAL: key2hash failed - 'g' too big number");

+16

-10

inc/CryptX_PK_DSA.xs.inc less more

8	8	if (!RETVAL) croak("FATAL: Newz failed");
9	9	RETVAL->key.type = -1;
10	10	RETVAL->pindex = find_prng("chacha20");
11		if(RETVAL->pindex==-1) croak("FATAL: find_prng('chacha20') failed");
	11	if (RETVAL->pindex == -1) {
	12	Safefree(RETVAL);
	13	croak("FATAL: find_prng('chacha20') failed");
	14	}
12	15	rv = rng_make_prng(320, RETVAL->pindex, &RETVAL->pstate, NULL); /* 320bits = 40bytes */
13		if (rv != CRYPT_OK) croak("FATAL: rng_make_prng failed: %s", error_to_string(rv));
	16	if (rv != CRYPT_OK) {
	17	Safefree(RETVAL);
	18	croak("FATAL: rng_make_prng failed: %s", error_to_string(rv));
	19	}
14	20	}
15	21	OUTPUT:
16	22	RETVAL

158	164	qsize = mp_unsigned_bin_size(self->key.q);
159	165	psize = mp_unsigned_bin_size(self->key.p);
160	166	rv_hash = newHV();
161		/* =====> g */
	167	/* g */
162	168	siz = (self->key.g) ? mp_unsigned_bin_size(self->key.g) : 0;
163	169	if (siz>10000) {
164	170	croak("FATAL: key2hash failed - 'g' too big number");

170	176	else{
171	177	not_used = hv_store(rv_hash, "g", 1, newSVpv("", 0), 0);
172	178	}
173		/* =====> q */
	179	/* q */
174	180	siz = (self->key.q) ? mp_unsigned_bin_size(self->key.q) : 0;
175	181	if (siz>10000) {
176	182	croak("FATAL: key2hash failed - 'q' too big number");

182	188	else{
183	189	not_used = hv_store(rv_hash, "q", 1, newSVpv("", 0), 0);
184	190	}
185		/* =====> p */
	191	/* p */
186	192	siz = (self->key.p) ? mp_unsigned_bin_size(self->key.p) : 0;
187	193	if (siz>10000) {
188	194	croak("FATAL: key2hash failed - 'p' too big number");

194	200	else{
195	201	not_used = hv_store(rv_hash, "p", 1, newSVpv("", 0), 0);
196	202	}
197		/* =====> x */
	203	/* x */
198	204	siz = (self->key.x) ? mp_unsigned_bin_size(self->key.x) : 0;
199	205	if (siz>10000) {
200	206	croak("FATAL: key2hash failed - 'x' too big number");

206	212	else{
207	213	not_used = hv_store(rv_hash, "x", 1, newSVpv("", 0), 0);
208	214	}
209		/* =====> y */
	215	/* y */
210	216	siz = (self->key.y) ? mp_unsigned_bin_size(self->key.y) : 0;
211	217	if (siz>10000) {
212	218	croak("FATAL: key2hash failed - 'y' too big number");

218	224	else{
219	225	not_used = hv_store(rv_hash, "y", 1, newSVpv("", 0), 0);
220	226	}
221		/* =====> size */
	227	/* size */
222	228	not_used = hv_store(rv_hash, "size", 4, newSViv(qsize), 0);
223		/* =====> type */
	229	/* type */
224	230	not_used = hv_store(rv_hash, "type", 4, newSViv(self->key.type), 0);
225	231	if (not_used) not_used = NULL; /* just silence the warning: variable 'not_used' set but not used */
226	232	RETVAL = newRV_noinc((SV*)rv_hash);

266	272	data_ptr = (unsigned char *)SvPVbyte(data, data_len);
267	273
268	274	hash_id = find_hash(hash_name);
269		if(hash_id==-1) croak("FATAL: find_hash failed for '%s'", hash_name);
	275	if (hash_id == -1) croak("FATAL: find_hash failed for '%s'", hash_name);
270	276	rv = dsa_encrypt_key(data_ptr, (unsigned long)data_len, buffer, &buffer_len,
271	277	&self->pstate, self->pindex,
272	278	hash_id, &self->key);

+15

-9

inc/CryptX_PK_ECC.xs.inc less more

9	9	RETVAL->pindex = find_prng("chacha20");
10	10	RETVAL->key.type = -1;
11	11	ecc_dp_init(&RETVAL->dp);
12		if(RETVAL->pindex==-1) croak("FATAL: find_prng('chacha20') failed");
	12	if (RETVAL->pindex == -1) {
	13	Safefree(RETVAL);
	14	croak("FATAL: find_prng('chacha20') failed");
	15	}
13	16	rv = rng_make_prng(320, RETVAL->pindex, &RETVAL->pstate, NULL); /* 320bits = 40bytes */
14		if (rv != CRYPT_OK) croak("FATAL: rng_make_prng failed: %s", error_to_string(rv));
	17	if (rv != CRYPT_OK) {
	18	Safefree(RETVAL);
	19	croak("FATAL: rng_make_prng failed: %s", error_to_string(rv));
	20	}
15	21	}
16	22	OUTPUT:
17	23	RETVAL

107	113	if (self->key.type == -1) XSRETURN_UNDEF;
108	114	esize = ecc_get_size(&self->key);
109	115	rv_hash = newHV();
110		/* =====> k */
	116	/* k */
111	117	siz = (self->key.k) ? mp_unsigned_bin_size(self->key.k) : 0;
112	118	if (siz>10000) {
113	119	croak("FATAL: key2hash failed - 'k' too big number");

119	125	else{
120	126	not_used = hv_store(rv_hash, "k", 1, newSVpv("", 0), 0);
121	127	}
122		/* =====> pub_x */
	128	/* pub_x */
123	129	siz = (self->key.pubkey.x) ? mp_unsigned_bin_size(self->key.pubkey.x) : 0;
124	130	if (siz>10000) {
125	131	croak("FATAL: key2hash failed - 'pub_x' too big number");

131	137	else{
132	138	not_used = hv_store(rv_hash, "pub_x", 5, newSVpv("", 0), 0);
133	139	}
134		/* =====> pub_y */
	140	/* pub_y */
135	141	siz = (self->key.pubkey.y) ? mp_unsigned_bin_size(self->key.pubkey.y) : 0;
136	142	if (siz>10000) {
137	143	croak("FATAL: key2hash failed - 'pub_y' too big number");

143	149	else{
144	150	not_used = hv_store(rv_hash, "pub_y", 5, newSVpv("", 0), 0);
145	151	}
146		/* =====> curve_... */
	152	/* curve_... */
147	153	if (self->key.dp) {
148	154	not_used = hv_store(rv_hash, "curve_cofactor", 14, newSViv(self->key.dp->cofactor), 0);
149	155	/* prepend leading zero if we have odd number of hexadecimal digits */

194	200	not_used = hv_store(rv_hash, "curve_oid", 9, oid, 0);
195	201	}
196	202	}
197		/* =====> size */
	203	/* size */
198	204	not_used = hv_store(rv_hash, "size", 4, newSViv(esize), 0);
199		/* =====> type */
	205	/* type */
200	206	not_used = hv_store(rv_hash, "type", 4, newSViv(self->key.type), 0);
201	207	if (not_used) not_used = NULL; /* just silence the warning: variable 'not_used' set but not used */
202	208	RETVAL = newRV_noinc((SV*)rv_hash);

283	289	data_ptr = (unsigned char *)SvPVbyte(data, data_len);
284	290
285	291	hash_id = find_hash(hash_name);
286		if(hash_id==-1) croak("FATAL: find_hash failed for '%s'", hash_name);
	292	if (hash_id == -1) croak("FATAL: find_hash failed for '%s'", hash_name);
287	293	rv = ecc_encrypt_key(data_ptr, (unsigned long)data_len, buffer, &buffer_len,
288	294	&self->pstate, self->pindex,
289	295	hash_id, &self->key);

+24

-18

inc/CryptX_PK_RSA.xs.inc less more

8	8	if (!RETVAL) croak("FATAL: Newz failed");
9	9	RETVAL->key.type = -1;
10	10	RETVAL->pindex = find_prng("chacha20");
11		if(RETVAL->pindex==-1) croak("FATAL: find_prng('chacha20') failed");
	11	if (RETVAL->pindex == -1) {
	12	Safefree(RETVAL);
	13	croak("FATAL: find_prng('chacha20') failed");
	14	}
12	15	rv = rng_make_prng(320, RETVAL->pindex, &RETVAL->pstate, NULL); /* 320bits = 40bytes */
13		if (rv != CRYPT_OK) croak("FATAL: rng_make_prng failed: %s", error_to_string(rv));
	16	if (rv != CRYPT_OK) {
	17	Safefree(RETVAL);
	18	croak("FATAL: rng_make_prng failed: %s", error_to_string(rv));
	19	}
14	20	}
15	21	OUTPUT:
16	22	RETVAL

154	160	if (self->key.type == -1 \|\| self->key.N == NULL) XSRETURN_UNDEF;
155	161	nsize = mp_unsigned_bin_size(self->key.N);
156	162	rv_hash = newHV();
157		/* =====> e */
	163	/* e */
158	164	siz = (self->key.e) ? mp_unsigned_bin_size(self->key.e) : 0;
159	165	if (siz>10000) {
160	166	croak("FATAL: key2hash failed - 'e' too big number");

166	172	else{
167	173	not_used = hv_store(rv_hash, "e", 1, newSVpv("", 0), 0);
168	174	}
169		/* =====> d */
	175	/* d */
170	176	siz = (self->key.d) ? mp_unsigned_bin_size(self->key.d) : 0;
171	177	if (siz>10000) {
172	178	croak("FATAL: key2hash failed - 'd' too big number");

178	184	else{
179	185	not_used = hv_store(rv_hash, "d", 1, newSVpv("", 0), 0);
180	186	}
181		/* =====> N */
	187	/* N */
182	188	siz = (self->key.N) ? nsize : 0;
183	189	if (siz>10000) {
184	190	croak("FATAL: key2hash failed - 'N' too big number");

190	196	else{
191	197	not_used = hv_store(rv_hash, "N", 1, newSVpv("", 0), 0);
192	198	}
193		/* =====> q */
	199	/* q */
194	200	siz = (self->key.q) ? mp_unsigned_bin_size(self->key.q) : 0;
195	201	if (siz>10000) {
196	202	croak("FATAL: key2hash failed - 'q' too big number");

202	208	else{
203	209	not_used = hv_store(rv_hash, "q", 1, newSVpv("", 0), 0);
204	210	}
205		/* =====> p */
	211	/* p */
206	212	siz = (self->key.p) ? mp_unsigned_bin_size(self->key.p) : 0;
207	213	if (siz>10000) {
208	214	croak("FATAL: key2hash failed - 'p' too big number");

214	220	else{
215	221	not_used = hv_store(rv_hash, "p", 1, newSVpv("", 0), 0);
216	222	}
217		/* =====> qP */
	223	/* qP */
218	224	siz = (self->key.qP) ? mp_unsigned_bin_size(self->key.qP) : 0;
219	225	if (siz>10000) {
220	226	croak("FATAL: key2hash failed - 'qP' too big number");

226	232	else{
227	233	not_used = hv_store(rv_hash, "qP", 2, newSVpv("", 0), 0);
228	234	}
229		/* =====> dP */
	235	/* dP */
230	236	siz = (self->key.dP) ? mp_unsigned_bin_size(self->key.dP) : 0;
231	237	if (siz>10000) {
232	238	croak("FATAL: key2hash failed - 'dP' too big number");

238	244	else{
239	245	not_used = hv_store(rv_hash, "dP", 2, newSVpv("", 0), 0);
240	246	}
241		/* =====> dQ */
	247	/* dQ */
242	248	siz = (self->key.dQ) ? mp_unsigned_bin_size(self->key.dQ) : 0;
243	249	if (siz>10000) {
244	250	croak("FATAL: key2hash failed - 'dQ' too big number");

250	256	else{
251	257	not_used = hv_store(rv_hash, "dQ", 2, newSVpv("", 0), 0);
252	258	}
253		/* =====> size */
	259	/* size */
254	260	not_used = hv_store(rv_hash, "size", 4, newSViv(nsize), 0);
255		/* =====> type */
	261	/* type */
256	262	not_used = hv_store(rv_hash, "type", 4, newSViv(self->key.type), 0);
257	263	if (not_used) not_used = NULL; /* just silence the warning: variable 'not_used' set but not used */
258	264	RETVAL = newRV_noinc((SV*)rv_hash);

302	308	RETVAL = newSVpvn(NULL, 0); /* undef */
303	309	if (strnEQ(padding, "oaep", 4)) {
304	310	hash_id = find_hash(oaep_hash);
305		if(hash_id==-1) croak("FATAL: find_hash failed for '%s'", oaep_hash);
	311	if (hash_id == -1) croak("FATAL: find_hash failed for '%s'", oaep_hash);
306	312	lparam_ptr = (unsigned char *)SvPVbyte(oaep_lparam, lparam_len);
307	313	rv = rsa_encrypt_key_ex(data_ptr, (unsigned long)data_len, buffer, &buffer_len, lparam_ptr, (unsigned long)lparam_len,
308	314	&self->pstate, self->pindex,

347	353	RETVAL = newSVpvn(NULL, 0); /* undef */
348	354	if (strnEQ(padding, "oaep", 4)) {
349	355	hash_id = find_hash(oaep_hash);
350		if(hash_id==-1) croak("FATAL: find_hash failed for '%s'", oaep_hash);
	356	if (hash_id == -1) croak("FATAL: find_hash failed for '%s'", oaep_hash);
351	357	lparam_ptr = (unsigned char *)SvPVbyte(oaep_lparam, lparam_len);
352	358	rv = rsa_decrypt_key_ex(data_ptr, (unsigned long)data_len, buffer, &buffer_len, lparam_ptr, (unsigned long)lparam_len,
353	359	hash_id, LTC_PKCS_1_OAEP, &stat, &self->key);

390	396	RETVAL = newSVpvn(NULL, 0); /* undef */
391	397	if (strnEQ(padding, "pss", 3)) {
392	398	hash_id = find_hash(hash_name);
393		if(hash_id==-1) croak("FATAL: find_hash failed for '%s'", hash_name);
	399	if (hash_id == -1) croak("FATAL: find_hash failed for '%s'", hash_name);
394	400	rv = rsa_sign_hash_ex(data_ptr, (unsigned long)data_len, buffer, &buffer_len, LTC_PKCS_1_PSS,
395	401	&self->pstate, self->pindex,
396	402	hash_id, saltlen, &self->key);

399	405	}
400	406	else if (strnEQ(padding, "v1.5", 4)) {
401	407	hash_id = find_hash(hash_name);
402		if(hash_id==-1) croak("FATAL: find_hash failed for '%s'", hash_name);
	408	if (hash_id == -1) croak("FATAL: find_hash failed for '%s'", hash_name);
403	409	rv = rsa_sign_hash_ex(data_ptr, (unsigned long)data_len, buffer, &buffer_len, LTC_PKCS_1_V1_5,
404	410	&self->pstate, self->pindex,
405	411	hash_id, 0, &self->key);

438	444	stat = 0;
439	445	if (strnEQ(padding, "pss", 3)) {
440	446	hash_id = find_hash(hash_name);
441		if(hash_id==-1) croak("FATAL: find_hash failed for '%s'", hash_name);
	447	if (hash_id == -1) croak("FATAL: find_hash failed for '%s'", hash_name);
442	448	rv = rsa_verify_hash_ex(sig_ptr, (unsigned long)sig_len, data_ptr, (unsigned long)data_len, LTC_PKCS_1_PSS,
443	449	hash_id, saltlen, &stat, &self->key);
444	450	if (rv != CRYPT_OK \|\| stat != 1) RETVAL = 0;
445	451	}
446	452	else if (strnEQ(padding, "v1.5", 4)) {
447	453	hash_id = find_hash(hash_name);
448		if(hash_id==-1) croak("FATAL: find_hash failed for '%s'", hash_name);
	454	if (hash_id == -1) croak("FATAL: find_hash failed for '%s'", hash_name);
449	455	rv = rsa_verify_hash_ex(sig_ptr, (unsigned long)sig_len, data_ptr, (unsigned long)data_len, LTC_PKCS_1_V1_5,
450	456	hash_id, 0, &stat, &self->key);
451	457	if (rv != CRYPT_OK \|\| stat != 1) RETVAL = 0;

+26

-8

inc/CryptX_PRNG.xs.inc less more

12	12	if (!RETVAL) croak("FATAL: Newz failed");
13	13
14	14	id = find_prng(prng_name);
15		if(id==-1) croak("FATAL: find_prng failed for '%s'", prng_name);
	15	if (id == -1) {
	16	Safefree(RETVAL);
	17	croak("FATAL: find_prng failed for '%s'", prng_name);
	18	}
16	19	RETVAL->id = id;
17	20	RETVAL->last_pid = curpid;
18	21	RETVAL->desc = &prng_descriptor[id];
19	22
20	23	rv = RETVAL->desc->start(&RETVAL->state);
21		if (rv != CRYPT_OK) croak("FATAL: PRNG_start failed: %s", error_to_string(rv));
	24	if (rv != CRYPT_OK) {
	25	Safefree(RETVAL);
	26	croak("FATAL: PRNG_start failed: %s", error_to_string(rv));
	27	}
22	28
23		if(SvOK(entropy)) {
	29	if (SvOK(entropy)) {
24	30	ent = (unsigned char *) SvPVbyte(entropy, ent_len);
25	31	rv = RETVAL->desc->add_entropy(ent, (unsigned long)ent_len, &RETVAL->state);
26		if (rv != CRYPT_OK) croak("FATAL: PRNG_add_entropy failed: %s", error_to_string(rv));
	32	if (rv != CRYPT_OK) {
	33	Safefree(RETVAL);
	34	croak("FATAL: PRNG_add_entropy failed: %s", error_to_string(rv));
	35	}
27	36	}
28	37	else {
29		if (rng_get_bytes(entropy_buf, 40, NULL) != 40) croak("FATAL: rng_get_bytes failed: %s", error_to_string(rv));
	38	if (rng_get_bytes(entropy_buf, 40, NULL) != 40) {
	39	Safefree(RETVAL);
	40	croak("FATAL: rng_get_bytes failed: %s", error_to_string(rv));
	41	}
30	42	rv = RETVAL->desc->add_entropy(entropy_buf, 40, &RETVAL->state);
31		if (rv != CRYPT_OK) croak("FATAL: PRNG_add_entropy failed: %s", error_to_string(rv));
	43	if (rv != CRYPT_OK) {
	44	Safefree(RETVAL);
	45	croak("FATAL: PRNG_add_entropy failed: %s", error_to_string(rv));
	46	}
32	47	}
33	48	rv = RETVAL->desc->ready(&RETVAL->state);
34		if (rv != CRYPT_OK) croak("FATAL: PRNG_ready failed: %s", error_to_string(rv));
	49	if (rv != CRYPT_OK) {
	50	Safefree(RETVAL);
	51	croak("FATAL: PRNG_ready failed: %s", error_to_string(rv));
	52	}
35	53	}
36	54	OUTPUT:
37	55	RETVAL

51	69	unsigned char *in_buffer=NULL;
52	70	unsigned char entropy_buf[32];
53	71	int rv;
54		if(SvOK(entropy)) {
	72	if (SvOK(entropy)) {
55	73	in_buffer = (unsigned char *) SvPVbyte(entropy, in_len);
56	74	rv = self->desc->add_entropy(in_buffer, (unsigned long)in_len, &self->state);
57	75	if (rv != CRYPT_OK) croak("FATAL: PRNG_add_entropy failed: %s", error_to_string(rv));

+14

-4

inc/CryptX_Stream_ChaCha.xs.inc less more

16	16	if (!RETVAL) croak("FATAL: Newz failed");
17	17
18	18	rv = chacha_setup(&RETVAL->state, k, (unsigned long)k_len, rounds);
19		if (rv != CRYPT_OK) croak("FATAL: chacha_setup failed: %s", error_to_string(rv));
	19	if (rv != CRYPT_OK) {
	20	Safefree(RETVAL);
	21	croak("FATAL: chacha_setup failed: %s", error_to_string(rv));
	22	}
20	23
21	24	if (iv_len == 12) {
22	25	rv = chacha_ivctr32(&RETVAL->state, iv, (unsigned long)iv_len, (ulong32)counter);
23		if (rv != CRYPT_OK) croak("FATAL: chacha_ivctr32 failed: %s", error_to_string(rv));
	26	if (rv != CRYPT_OK) {
	27	Safefree(RETVAL);
	28	croak("FATAL: chacha_ivctr32 failed: %s", error_to_string(rv));
	29	}
24	30	}
25	31	else if (iv_len == 8) {
26	32	rv = chacha_ivctr64(&RETVAL->state, iv, (unsigned long)iv_len, (ulong64)counter);
27		if (rv != CRYPT_OK) croak("FATAL: chacha_ivctr64 failed: %s", error_to_string(rv));
	33	if (rv != CRYPT_OK) {
	34	Safefree(RETVAL);
	35	croak("FATAL: chacha_ivctr64 failed: %s", error_to_string(rv));
	36	}
28	37	}
29	38	else {
	39	Safefree(RETVAL);
30	40	croak("FATAL: chacha IV length must be 8 or 12 bytes");
31	41	}
32	42	}

77	87	unsigned char in_data, out_data;
78	88
79	89	in_data = (unsigned char *)SvPVbyte(data, in_data_len);
80		if (in_data_len==0) {
	90	if (in_data_len == 0) {
81	91	RETVAL = newSVpvn("", 0);
82	92	}
83	93	else {

+5

-2

inc/CryptX_Stream_RC4.xs.inc less more

14	14	if (!RETVAL) croak("FATAL: Newz failed");
15	15
16	16	rv = rc4_stream_setup(&RETVAL->state, k, (unsigned long)k_len);
17		if (rv != CRYPT_OK) croak("FATAL: rc4_stream_setup failed: %s", error_to_string(rv));
	17	if (rv != CRYPT_OK) {
	18	Safefree(RETVAL);
	19	croak("FATAL: rc4_stream_setup failed: %s", error_to_string(rv));
	20	}
18	21	}
19	22	OUTPUT:
20	23	RETVAL

63	66	unsigned char in_data, out_data;
64	67
65	68	in_data = (unsigned char *)SvPVbyte(data, in_data_len);
66		if (in_data_len==0) {
	69	if (in_data_len == 0) {
67	70	RETVAL = newSVpvn("", 0);
68	71	}
69	72	else {

+11

-10

inc/CryptX_Stream_Salsa20.xs.inc less more

9	9
10	10	if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");
11	11	if (!SvPOK(nonce)) croak("FATAL: nonce must be string/buffer scalar");
12		k = (unsigned char *) SvPVbyte(key, k_len);
13		iv = (unsigned char *) SvPVbyte(nonce, iv_len);
	12	k = (unsigned char *)SvPVbyte(key, k_len);
	13	iv = (unsigned char *)SvPVbyte(nonce, iv_len);
14	14
15	15	Newz(0, RETVAL, 1, struct salsa20_struct);
16	16	if (!RETVAL) croak("FATAL: Newz failed");
17	17
18	18	rv = salsa20_setup(&RETVAL->state, k, (unsigned long)k_len, rounds);
19		if (rv != CRYPT_OK) croak("FATAL: salsa20_setup failed: %s", error_to_string(rv));
	19	if (rv != CRYPT_OK) {
	20	Safefree(RETVAL);
	21	croak("FATAL: salsa20_setup failed: %s", error_to_string(rv));
	22	}
20	23
21		if (iv_len == 8) {
22		rv = salsa20_ivctr64(&RETVAL->state, iv, (unsigned long)iv_len, (ulong64)counter);
23		if (rv != CRYPT_OK) croak("FATAL: salsa20_ivctr64 failed: %s", error_to_string(rv));
24		}
25		else {
26		croak("FATAL: chacha IV length must be 8 or 12 bytes");
	24	rv = salsa20_ivctr64(&RETVAL->state, iv, (unsigned long)iv_len, (ulong64)counter);
	25	if (rv != CRYPT_OK) {
	26	Safefree(RETVAL);
	27	croak("FATAL: salsa20_ivctr64 failed: %s", error_to_string(rv));
27	28	}
28	29	}
29	30	OUTPUT:

73	74	unsigned char in_data, out_data;
74	75
75	76	in_data = (unsigned char *)SvPVbyte(data, in_data_len);
76		if (in_data_len==0) {
	77	if (in_data_len == 0) {
77	78	RETVAL = newSVpvn("", 0);
78	79	}
79	80	else {

+9

-3

inc/CryptX_Stream_Sober128.xs.inc less more

16	16	if (!RETVAL) croak("FATAL: Newz failed");
17	17
18	18	rv = sober128_stream_setup(&RETVAL->state, k, (unsigned long)k_len);
19		if (rv != CRYPT_OK) croak("FATAL: sober128_stream_setup failed: %s", error_to_string(rv));
	19	if (rv != CRYPT_OK) {
	20	Safefree(RETVAL);
	21	croak("FATAL: sober128_stream_setup failed: %s", error_to_string(rv));
	22	}
20	23
21	24	rv = sober128_stream_setiv(&RETVAL->state, iv, (unsigned long)iv_len);
22		if (rv != CRYPT_OK) croak("FATAL: sober128_stream_setiv failed: %s", error_to_string(rv));
	25	if (rv != CRYPT_OK) {
	26	Safefree(RETVAL);
	27	croak("FATAL: sober128_stream_setiv failed: %s", error_to_string(rv));
	28	}
23	29	}
24	30	OUTPUT:
25	31	RETVAL

68	74	unsigned char in_data, out_data;
69	75
70	76	in_data = (unsigned char *)SvPVbyte(data, in_data_len);
71		if (in_data_len==0) {
	77	if (in_data_len == 0) {
72	78	RETVAL = newSVpvn("", 0);
73	79	}
74	80	else {