Commit 5d507df65fe49edd28acc7f8b984fa3f1a817344 - libcryptx-perl

+102

-52

CryptX.xs less more

335	335	STRLEN in_len;
336	336	unsigned long out_len;
337	337	unsigned char out_data, in_data;
338		int rv;
339	338
340	339	if (!SvPOK(in)) XSRETURN_UNDEF;
341	340	in_data = (unsigned char *) SvPVbyte(in, in_len);
342		out_len = (unsigned long)(4 * ((in_len + 2) / 3) + 1);
343		Newz(0, out_data, out_len, unsigned char);
344		if (!out_data) croak("FATAL: Newz failed [%ld]", out_len);
345		rv = base64url_encode(in_data, (unsigned long)in_len, out_data, &out_len);
346		RETVAL = (rv == CRYPT_OK) ? newSVpvn((char *)out_data, out_len) : newSVpvn(NULL, 0);
347		Safefree(out_data);
	341	if (in_len == 0) {
	342	RETVAL = newSVpvn("", 0);
	343	}
	344	else {
	345	out_len = (unsigned long)(4 * ((in_len + 2) / 3) + 1);
	346	RETVAL = NEWSV(0, out_len);
	347	SvPOK_only(RETVAL);
	348	out_data = (unsigned char *)SvPVX(RETVAL);
	349	if (base64url_encode(in_data, (unsigned long)in_len, out_data, &out_len) != CRYPT_OK) {
	350	SvREFCNT_dec(RETVAL);
	351	XSRETURN_UNDEF;
	352	}
	353	SvCUR_set(RETVAL, out_len);
	354	}
348	355	}
349	356	OUTPUT:
350	357	RETVAL

356	363	STRLEN in_len;
357	364	unsigned long out_len;
358	365	unsigned char out_data, in_data;
359		int rv;
360	366
361	367	if (!SvPOK(in)) XSRETURN_UNDEF;
362	368	in_data = (unsigned char *) SvPVbyte(in, in_len);
363		out_len = (unsigned long)in_len;
364		Newz(0, out_data, out_len, unsigned char);
365		if (!out_data) croak("FATAL: Newz failed [%ld]", out_len);
366		rv = base64url_decode(in_data, (unsigned long)in_len, out_data, &out_len);
367		RETVAL = (rv == CRYPT_OK) ? newSVpvn((char *)out_data, out_len) : newSVpvn(NULL, 0);
368		Safefree(out_data);
	369	if (in_len == 0) {
	370	RETVAL = newSVpvn("", 0);
	371	}
	372	else {
	373	out_len = (unsigned long)in_len;
	374	RETVAL = NEWSV(0, out_len);
	375	SvPOK_only(RETVAL);
	376	out_data = (unsigned char *)SvPVX(RETVAL);
	377	if (base64url_decode(in_data, (unsigned long)in_len, out_data, &out_len) != CRYPT_OK) {
	378	SvREFCNT_dec(RETVAL);
	379	XSRETURN_UNDEF;
	380	}
	381	SvCUR_set(RETVAL, out_len);
	382	}
369	383	}
370	384	OUTPUT:
371	385	RETVAL

377	391	STRLEN in_len;
378	392	unsigned long out_len;
379	393	unsigned char out_data, in_data;
380		int rv;
381	394
382	395	if (!SvPOK(in)) XSRETURN_UNDEF;
383	396	in_data = (unsigned char *) SvPVbyte(in, in_len);
384		out_len = (unsigned long)(4 * ((in_len + 2) / 3) + 1);
385		Newz(0, out_data, out_len, unsigned char);
386		if (!out_data) croak("FATAL: Newz failed [%ld]", out_len);
387		rv = base64_encode(in_data, (unsigned long)in_len, out_data, &out_len);
388		RETVAL = (rv == CRYPT_OK) ? newSVpvn((char *)out_data, out_len) : newSVpvn(NULL, 0);
389		Safefree(out_data);
	397	if (in_len == 0) {
	398	RETVAL = newSVpvn("", 0);
	399	}
	400	else {
	401	out_len = (unsigned long)(4 * ((in_len + 2) / 3) + 1);
	402	RETVAL = NEWSV(0, out_len);
	403	SvPOK_only(RETVAL);
	404	out_data = (unsigned char *)SvPVX(RETVAL);
	405	if (base64_encode(in_data, (unsigned long)in_len, out_data, &out_len) != CRYPT_OK) {
	406	SvREFCNT_dec(RETVAL);
	407	XSRETURN_UNDEF;
	408	}
	409	SvCUR_set(RETVAL, out_len);
	410	}
390	411	}
391	412	OUTPUT:
392	413	RETVAL

398	419	STRLEN in_len;
399	420	unsigned long out_len;
400	421	unsigned char out_data, in_data;
401		int rv;
402	422
403	423	if (!SvPOK(in)) XSRETURN_UNDEF;
404		in_data = (unsigned char *) SvPVbyte(in, in_len);
405		out_len = (unsigned long)in_len;
406		Newz(0, out_data, out_len, unsigned char);
407		if (!out_data) croak("FATAL: Newz failed [%ld]", out_len);
408		rv = base64_decode(in_data, (unsigned long)in_len, out_data, &out_len);
409		RETVAL = (rv == CRYPT_OK) ? newSVpvn((char *)out_data, out_len) : newSVpvn(NULL, 0);
410		Safefree(out_data);
	424	in_data = (unsigned char *)SvPVbyte(in, in_len);
	425	if (in_len == 0) {
	426	RETVAL = newSVpvn("", 0);
	427	}
	428	else {
	429	out_len = (unsigned long)in_len;
	430	RETVAL = NEWSV(0, out_len);
	431	SvPOK_only(RETVAL);
	432	out_data = (unsigned char *)SvPVX(RETVAL);
	433	if (base64_decode(in_data, (unsigned long)in_len, out_data, &out_len) != CRYPT_OK) {
	434	SvREFCNT_dec(RETVAL);
	435	XSRETURN_UNDEF;
	436	}
	437	SvCUR_set(RETVAL, out_len);
	438	}
411	439	}
412	440	OUTPUT:
413	441	RETVAL

419	447	STRLEN in_len;
420	448	unsigned long out_len;
421	449	unsigned char out_data, in_data;
422		int rv, id = -1;
	450	int id = -1;
423	451
424	452	if (!SvPOK(in)) XSRETURN_UNDEF;
425	453	if (idx == 0) id = BASE32_RFC4648;

428	456	if (idx == 3) id = BASE32_CROCKFORD;
429	457	if (id == -1) XSRETURN_UNDEF;
430	458	in_data = (unsigned char *) SvPVbyte(in, in_len);
431		out_len = (unsigned long)((8 * in_len + 4) / 5);
432		Newz(0, out_data, out_len, unsigned char);
433		if (!out_data) croak("FATAL: Newz failed [%ld]", out_len);
434		rv = base32_encode(in_data, (unsigned long)in_len, out_data, &out_len, id);
435		RETVAL = (rv == CRYPT_OK) ? newSVpvn((char *)out_data, out_len) : newSVpvn(NULL, 0);
436		Safefree(out_data);
	459	if (in_len == 0) {
	460	RETVAL = newSVpvn("", 0);
	461	}
	462	else {
	463	out_len = (unsigned long)((8 * in_len + 4) / 5);
	464	RETVAL = NEWSV(0, out_len);
	465	SvPOK_only(RETVAL);
	466	out_data = (unsigned char *)SvPVX(RETVAL);
	467	if (base32_encode(in_data, (unsigned long)in_len, out_data, &out_len, id) != CRYPT_OK) {
	468	SvREFCNT_dec(RETVAL);
	469	XSRETURN_UNDEF;
	470	}
	471	SvCUR_set(RETVAL, out_len);
	472	}
437	473	}
438	474	OUTPUT:
439	475	RETVAL

445	481	STRLEN in_len;
446	482	unsigned long out_len;
447	483	unsigned char out_data, in_data;
448		int rv, id = -1;
	484	int id = -1;
449	485
450	486	if (!SvPOK(in)) XSRETURN_UNDEF;
451	487	if (idx == 0) id = BASE32_RFC4648;

453	489	if (idx == 2) id = BASE32_ZBASE32;
454	490	if (idx == 3) id = BASE32_CROCKFORD;
455	491	if (id == -1) XSRETURN_UNDEF;
456		in_data = (unsigned char *) SvPVbyte(in, in_len);
457		out_len = (unsigned long)in_len;
458		Newz(0, out_data, out_len, unsigned char);
459		if (!out_data) croak("FATAL: Newz failed [%ld]", out_len);
460		rv = base32_decode(in_data, (unsigned long)in_len, out_data, &out_len, id);
461		RETVAL = (rv == CRYPT_OK) ? newSVpvn((char *)out_data, out_len) : newSVpvn(NULL, 0);
462		Safefree(out_data);
	492	in_data = (unsigned char *)SvPVbyte(in, in_len);
	493	if (in_len == 0) {
	494	RETVAL = newSVpvn("", 0);
	495	}
	496	else {
	497	out_len = (unsigned long)in_len;
	498	RETVAL = NEWSV(0, out_len);
	499	SvPOK_only(RETVAL);
	500	out_data = (unsigned char *)SvPVX(RETVAL);
	501	if (base32_decode(in_data, (unsigned long)in_len, out_data, &out_len, id) != CRYPT_OK) {
	502	SvREFCNT_dec(RETVAL);
	503	XSRETURN_UNDEF;
	504	}
	505	SvCUR_set(RETVAL, out_len);
	506	}
463	507	}
464	508	OUTPUT:
465	509	RETVAL

472	516	unsigned char out_data, in_data;
473	517
474	518	if (!SvPOK(in)) XSRETURN_UNDEF;
475		in_data = (unsigned char *) SvPVbyte(in, len);
	519	in_data = (unsigned char *)SvPVbyte(in, len);
476	520	if (len == 0) XSRETURN_UNDEF;
477	521
478	522	RETVAL = NEWSV(0, len);
479	523	SvPOK_only(RETVAL);
480	524	SvCUR_set(RETVAL, len);
481		out_data = (unsigned char *)SvPV_nolen(RETVAL);
	525	out_data = (unsigned char *)SvPVX(RETVAL);
482	526	Copy(in_data, out_data, len, unsigned char);
483	527	while (i < len) {
484	528	out_data[i]++;
485	529	if (0 != out_data[i]) break;
486	530	i++;
487	531	}
488		if (i == len) croak("FATAL: increment_octets_le overflow");
	532	if (i == len) {
	533	SvREFCNT_dec(RETVAL);
	534	croak("FATAL: increment_octets_le overflow");
	535	}
489	536	}
490	537	OUTPUT:
491	538	RETVAL

498	545	unsigned char out_data, in_data;
499	546
500	547	if (!SvPOK(in)) XSRETURN_UNDEF;
501		in_data = (unsigned char *) SvPVbyte(in, len);
	548	in_data = (unsigned char *)SvPVbyte(in, len);
502	549	if (len == 0) XSRETURN_UNDEF;
503	550
504	551	RETVAL = NEWSV(0, len);
505	552	SvPOK_only(RETVAL);
506	553	SvCUR_set(RETVAL, len);
507		out_data = (unsigned char *)SvPV_nolen(RETVAL);
	554	out_data = (unsigned char *)SvPVX(RETVAL);
508	555	Copy(in_data, out_data, len, unsigned char);
509	556	while (i < len) {
510	557	out_data[len - 1 - i]++;
511	558	if (0 != out_data[len - 1 - i]) break;
512	559	i++;
513	560	}
514		if (i == len) croak("FATAL: increment_octets_le overflow");
	561	if (i == len) {
	562	SvREFCNT_dec(RETVAL);
	563	croak("FATAL: increment_octets_be overflow");
	564	}
515	565	}
516	566	OUTPUT:
517	567	RETVAL

533	583	RETVAL = NEWSV(0, len);
534	584	SvPOK_only(RETVAL);
535	585	SvCUR_set(RETVAL, len);
536		out_data = (unsigned char *)SvPV_nolen(RETVAL);
	586	out_data = (unsigned char *)SvPVX(RETVAL);
537	587	mp_to_unsigned_bin(&mpi, out_data);
538	588	mp_clear(&mpi);
539	589	}

570	620
571	621	RETVAL = NEWSV(0, digits + 1);
572	622	SvPOK_only(RETVAL);
573		out_data = SvPV_nolen(RETVAL);
	623	out_data = SvPVX(RETVAL);
574	624	mp_toradix(&mpi, out_data, radix);
575	625	SvCUR_set(RETVAL, digits);
576	626	mp_clear(&mpi);

+11

-4

_generators/Mode.xs.inc.tt less more

92	92	unsigned char in_data, out_data;
93	93
94	94	in_data = (unsigned char *)SvPVbyte(data, in_data_len);
95		if (in_data_len==0) {
	95	if (in_data_len == 0) {
96	96	RETVAL = newSVpvn("", 0);
97	97	}
98	98	else {
99	99	RETVAL = NEWSV(0, in_data_len);
100	100	SvPOK_only(RETVAL);
101	101	SvCUR_set(RETVAL, in_data_len);
102		out_data = (unsigned char *)SvPV_nolen(RETVAL);
	102	out_data = (unsigned char *)SvPVX(RETVAL);
103	103
104	104	if (self->direction == 1) {
105	105	rv = [%lc_name%]_encrypt(in_data, out_data, (unsigned long)in_data_len, &self->state);
106		if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_encrypt failed: %s", error_to_string(rv));
	106	if (rv != CRYPT_OK) {
	107	SvREFCNT_dec(RETVAL);
	108	croak("FATAL: [%lc_name%]_encrypt failed: %s", error_to_string(rv));
	109	}
107	110	}
108	111	else if (self->direction == -1) {
109	112	rv = [%lc_name%]_decrypt(in_data, out_data, (unsigned long)in_data_len, &self->state);
110		if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_decrypt failed: %s", error_to_string(rv));
	113	if (rv != CRYPT_OK) {
	114	SvREFCNT_dec(RETVAL);
	115	croak("FATAL: [%lc_name%]_decrypt failed: %s", error_to_string(rv));
	116	}
111	117	}
112	118	else {
	119	SvREFCNT_dec(RETVAL);
113	120	croak("FATAL: [%lc_name%]_crypt failed: call start_encrypt or start_decrypt first");
114	121	}
115	122	}

+2

-3

_generators/Mode_p.xs.inc.tt less more

118	118	RETVAL = NEWSV(0, i);
119	119	SvPOK_only(RETVAL);
120	120	SvCUR_set(RETVAL, i);
121		out_data = (unsigned char *)SvPV_nolen(RETVAL);
122
	121	out_data = (unsigned char *)SvPVX(RETVAL);
123	122	if (has_tmp_block) {
124	123	Copy(tmp_block, out_data, blen, unsigned char);
125	124	out_data += blen;

244	243	RETVAL = NEWSV(0, i);
245	244	SvPOK_only(RETVAL);
246	245	SvCUR_set(RETVAL, i);
247		out_data = (unsigned char *)SvPV_nolen(RETVAL);
	246	out_data = (unsigned char *)SvPVX(RETVAL);
248	247	if (has_tmp_block) {
249	248	Copy(tmp_block, out_data, blen, unsigned char);
250	249	out_data += blen;

+1

-1

inc/CryptX_AuthEnc_CCM.xs.inc less more

28	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		pt, (unsigned long)pt_len, (unsigned char *)SvPV_nolen(ct), tag, &tag_len, CCM_ENCRYPT);
	31	pt, (unsigned long)pt_len, (unsigned char *)SvPVX(ct), tag, &tag_len, CCM_ENCRYPT);
32	32	if (rv != CRYPT_OK) croak("FATAL: ccm_memory failed: %s", error_to_string(rv));
33	33
34	34	XPUSHs(sv_2mortal(ct));

+12

-6

inc/CryptX_AuthEnc_ChaCha20Poly1305.xs.inc less more

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

119	122	unsigned char in_data, out_data;
120	123
121	124	in_data = (unsigned char *)SvPVbyte(data, in_data_len);
122		if (in_data_len==0) {
	125	if (in_data_len == 0) {
123	126	RETVAL = newSVpvn("", 0);
124	127	}
125	128	else {
126	129	RETVAL = NEWSV(0, in_data_len);
127	130	SvPOK_only(RETVAL);
128	131	SvCUR_set(RETVAL, in_data_len);
129		out_data = (unsigned char *)SvPV_nolen(RETVAL);
	132	out_data = (unsigned char *)SvPVX(RETVAL);
130	133	rv = chacha20poly1305_encrypt(&self->state, in_data, (unsigned long)in_data_len, out_data);
131		if (rv != CRYPT_OK) croak("FATAL: chacha20poly1305_encrypt failed: %s", error_to_string(rv));
	134	if (rv != CRYPT_OK) {
	135	SvREFCNT_dec(RETVAL);
	136	croak("FATAL: chacha20poly1305_encrypt failed: %s", error_to_string(rv));
	137	}
132	138	}
133	139	}
134	140	OUTPUT:

+12

-6

inc/CryptX_AuthEnc_EAX.xs.inc less more

56	56	unsigned char in_data, out_data;
57	57
58	58	in_data = (unsigned char *)SvPVbyte(data, in_data_len);
59		if (in_data_len==0) {
	59	if (in_data_len == 0) {
60	60	RETVAL = newSVpvn("", 0);
61	61	}
62	62	else {
63	63	RETVAL = NEWSV(0, in_data_len);
64	64	SvPOK_only(RETVAL);
65	65	SvCUR_set(RETVAL, in_data_len);
66		out_data = (unsigned char *)SvPV_nolen(RETVAL);
	66	out_data = (unsigned char *)SvPVX(RETVAL);
67	67	rv = eax_encrypt(&self->state, in_data, out_data, (unsigned long)in_data_len);
68		if (rv != CRYPT_OK) croak("FATAL: eax_encrypt failed: %s", error_to_string(rv));
	68	if (rv != CRYPT_OK) {
	69	SvREFCNT_dec(RETVAL);
	70	croak("FATAL: eax_encrypt failed: %s", error_to_string(rv));
	71	}
69	72	}
70	73	}
71	74	OUTPUT:

80	83	unsigned char in_data, out_data;
81	84
82	85	in_data = (unsigned char *)SvPVbyte(data, in_data_len);
83		if (in_data_len==0) {
	86	if (in_data_len == 0) {
84	87	RETVAL = newSVpvn("", 0);
85	88	}
86	89	else {
87	90	RETVAL = NEWSV(0, in_data_len);
88	91	SvPOK_only(RETVAL);
89	92	SvCUR_set(RETVAL, in_data_len);
90		out_data = (unsigned char *)SvPV_nolen(RETVAL);
	93	out_data = (unsigned char *)SvPVX(RETVAL);
91	94	rv = eax_decrypt(&self->state, in_data, out_data, (unsigned long)in_data_len);
92		if (rv != CRYPT_OK) croak("FATAL: eax_decrypt failed: %s", error_to_string(rv));
	95	if (rv != CRYPT_OK) {
	96	SvREFCNT_dec(RETVAL);
	97	croak("FATAL: eax_decrypt failed: %s", error_to_string(rv));
	98	}
93	99	}
94	100	}
95	101	OUTPUT:

+12

-6

inc/CryptX_AuthEnc_GCM.xs.inc less more

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

72	72	RETVAL = NEWSV(0, in_data_len);
73	73	SvPOK_only(RETVAL);
74	74	SvCUR_set(RETVAL, in_data_len);
75		out_data = (unsigned char *)SvPV_nolen(RETVAL);
	75	out_data = (unsigned char *)SvPVX(RETVAL);
76	76	rv = gcm_process(&self->state, in_data, (unsigned long)in_data_len, out_data, GCM_ENCRYPT);
77		if (rv != CRYPT_OK) croak("FATAL: encrypt_add/gcm_process failed: %s", error_to_string(rv));
	77	if (rv != CRYPT_OK) {
	78	SvREFCNT_dec(RETVAL);
	79	croak("FATAL: encrypt_add/gcm_process failed: %s", error_to_string(rv));
	80	}
78	81	}
79	82	}
80	83	OUTPUT:

117	120	unsigned char in_data, out_data;
118	121
119	122	in_data = (unsigned char *)SvPVbyte(data, in_data_len);
120		if (in_data_len==0) {
	123	if (in_data_len == 0) {
121	124	RETVAL = newSVpvn("", 0);
122	125	}
123	126	else {
124	127	RETVAL = NEWSV(0, in_data_len);
125	128	SvPOK_only(RETVAL);
126	129	SvCUR_set(RETVAL, in_data_len);
127		out_data = (unsigned char *)SvPV_nolen(RETVAL);
	130	out_data = (unsigned char *)SvPVX(RETVAL);
128	131	rv = gcm_process(&self->state, out_data, (unsigned long)in_data_len, in_data, GCM_DECRYPT);
129		if (rv != CRYPT_OK) croak("FATAL: encrypt_add/gcm_process failed: %s", error_to_string(rv));
	132	if (rv != CRYPT_OK) {
	133	SvREFCNT_dec(RETVAL);
	134	croak("FATAL: encrypt_add/gcm_process failed: %s", error_to_string(rv));
	135	}
130	136	}
131	137	}
132	138	OUTPUT:

+73

-66

inc/CryptX_AuthEnc_OCB.xs.inc less more

67	67	unsigned char in_data, out_data;
68	68
69	69	in_data = (unsigned char *)SvPVbyte(data, in_data_len);
	70	if (in_data_len == 0) {
	71	RETVAL = newSVpvn("", 0);
	72	}
	73	else {
	74	if (in_data_len % (&self->state)->block_len) {
	75	croak ("FATAL: sizeof(data) should be multiple of blocksize (%d)", (&self->state)->block_len);
	76	}
	77	RETVAL = NEWSV(0, in_data_len);
	78	SvPOK_only(RETVAL);
	79	SvCUR_set(RETVAL, in_data_len);
	80	out_data = (unsigned char *)SvPVX(RETVAL);
	81	rv = ocb3_encrypt(&self->state, in_data, (unsigned long)in_data_len, out_data);
	82	if (rv != CRYPT_OK) {
	83	SvREFCNT_dec(RETVAL);
	84	croak("FATAL: ocb3_encrypt failed: %s", error_to_string(rv));
	85	}
	86	}
	87	}
	88	OUTPUT:
	89	RETVAL
	90
	91	SV *
	92	encrypt_last(Crypt::AuthEnc::OCB self, SV * data)
	93	CODE:
	94	{
	95	int rv;
	96	STRLEN in_data_len;
	97	unsigned char in_data, out_data;
	98
	99	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));
	114	}
	115	}
	116	OUTPUT:
	117	RETVAL
	118
	119	SV *
	120	decrypt_add(Crypt::AuthEnc::OCB self, SV * data)
	121	CODE:
	122	{
	123	int rv;
	124	STRLEN in_data_len;
	125	unsigned char in_data, out_data;
	126
	127	in_data = (unsigned char *)SvPVbyte(data, in_data_len);
70	128	if (in_data_len==0) {
71	129	RETVAL = newSVpvn("", 0);
72	130	}
73	131	else {
74		RETVAL = NEWSV(0, in_data_len);
75		SvPOK_only(RETVAL);
76		SvCUR_set(RETVAL, in_data_len);
77		out_data = (unsigned char *)SvPV_nolen(RETVAL);
78
79		if (in_data_len % (&self->state)->block_len)
	132	if (in_data_len % (&self->state)->block_len) {
80	133	croak ("FATAL: sizeof(data) should be multiple of blocksize (%d)", (&self->state)->block_len);
81
82		rv = ocb3_encrypt(&self->state, in_data, (unsigned long)in_data_len, out_data);
83		if (rv != CRYPT_OK) croak("FATAL: ocb3_encrypt failed: %s", error_to_string(rv));
84		}
85		}
86		OUTPUT:
87		RETVAL
88
89		SV *
90		encrypt_last(Crypt::AuthEnc::OCB self, SV * data)
91		CODE:
92		{
93		int rv;
94		STRLEN in_data_len;
95		unsigned char in_data, out_data;
96
97		in_data = (unsigned char *)SvPVbyte(data, in_data_len);
98		if (in_data_len>0) {
99		RETVAL = NEWSV(0, in_data_len);
100		SvPOK_only(RETVAL);
101		SvCUR_set(RETVAL, in_data_len);
102		out_data = (unsigned char *)SvPV_nolen(RETVAL);
103		}
104		else {
105		RETVAL = newSVpvn("", 0);
106		out_data = NULL;
107		}
108		rv = ocb3_encrypt_last(&self->state, in_data, (unsigned long)in_data_len, out_data);
109		if (rv != CRYPT_OK) croak("FATAL: ocb3_encrypt_last failed: %s", error_to_string(rv));
110		}
111		OUTPUT:
112		RETVAL
113
114		SV *
115		decrypt_add(Crypt::AuthEnc::OCB self, SV * data)
116		CODE:
117		{
118		int rv;
119		STRLEN in_data_len;
120		unsigned char in_data, out_data;
121
122		in_data = (unsigned char *)SvPVbyte(data, in_data_len);
123		if (in_data_len==0) {
124		RETVAL = newSVpvn("", 0);
125		}
126		else {
127		RETVAL = NEWSV(0, in_data_len);
128		SvPOK_only(RETVAL);
129		SvCUR_set(RETVAL, in_data_len);
130		out_data = (unsigned char *)SvPV_nolen(RETVAL);
131
132		if (in_data_len % (&self->state)->block_len)
133		croak ("FATAL: sizeof(data) should be multiple of blocksize (%d)", (&self->state)->block_len);
134
	134	}
	135	RETVAL = NEWSV(0, in_data_len);
	136	SvPOK_only(RETVAL);
	137	SvCUR_set(RETVAL, in_data_len);
	138	out_data = (unsigned char *)SvPVX(RETVAL);
135	139	rv = ocb3_decrypt(&self->state, in_data, (unsigned long)in_data_len, out_data);
136		if (rv != CRYPT_OK) croak("FATAL: ocb3_decrypt failed: %s", error_to_string(rv));
	140	if (rv != CRYPT_OK) {
	141	SvREFCNT_dec(RETVAL);
	142	croak("FATAL: ocb3_decrypt failed: %s", error_to_string(rv));
	143	}
137	144	}
138	145	}
139	146	OUTPUT:

148	155	unsigned char in_data, out_data;
149	156
150	157	in_data = (unsigned char *)SvPVbyte(data, in_data_len);
151		if (in_data_len>0) {
152		RETVAL = NEWSV(0, in_data_len);
153		SvPOK_only(RETVAL);
154		SvCUR_set(RETVAL, in_data_len);
155		out_data = (unsigned char *)SvPV_nolen(RETVAL);
	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);
156	163	}
157	164	else {
158	165	RETVAL = newSVpvn("", 0);

+22

-14

inc/CryptX_Cipher.xs.inc less more

76	76	STRLEN len;
77	77	void *plaintext = SvPVbyte(data, len);
78	78
79		if (len==0)
	79	if (len == 0) {
80	80	RETVAL = newSVpvn("", 0);
81		else if (len % self->desc->block_length)
82		croak ("FATAL: sizeof(data) should be multiple of blocksize (%d)", self->desc->block_length);
83		else {
84		/* idea from Crypt::Rijndael */
	81	}
	82	else if (len == self->desc->block_length) {
85	83	RETVAL = NEWSV(0, len);
86	84	SvPOK_only(RETVAL);
87	85	SvCUR_set(RETVAL, len);
88		rv = self->desc->ecb_encrypt((unsigned char )plaintext, (unsigned char )SvPV_nolen(RETVAL), &self->skey);
89		if (rv!=CRYPT_OK) croak("FATAL: encrypt failed: %s", error_to_string(rv));
	86	rv = self->desc->ecb_encrypt((unsigned char )plaintext, (unsigned char )SvPVX(RETVAL), &self->skey);
	87	if (rv!=CRYPT_OK) {
	88	SvREFCNT_dec(RETVAL);
	89	croak("FATAL: encrypt failed: %s", error_to_string(rv));
	90	}
	91	}
	92	else {
	93	croak ("FATAL: input size not equal to blocksize (%d)", self->desc->block_length);
90	94	}
91	95	}
92	96	OUTPUT:

102	106	STRLEN len;
103	107	void *ciphertext = SvPVbyte(data, len);
104	108
105		if (len==0)
	109	if (len == 0) {
106	110	RETVAL = newSVpvn("", 0);
107		else if (len % self->desc->block_length)
108		croak ("FATAL: sizeof(data) should be multiple of blocksize (%d)", self->desc->block_length);
109		else {
110		/* idea from Crypt::Rijndael */
	111	}
	112	else if (len == self->desc->block_length) {
111	113	RETVAL = NEWSV(0, len);
112	114	SvPOK_only(RETVAL);
113	115	SvCUR_set(RETVAL, len);
114		rv = self->desc->ecb_decrypt((unsigned char )ciphertext, (unsigned char )SvPV_nolen(RETVAL), &self->skey);
115		if (rv!=CRYPT_OK) croak("FATAL: decrypt failed: %s", error_to_string(rv));
	116	rv = self->desc->ecb_decrypt((unsigned char )ciphertext, (unsigned char )SvPVX(RETVAL), &self->skey);
	117	if (rv!=CRYPT_OK) {
	118	SvREFCNT_dec(RETVAL);
	119	croak("FATAL: decrypt failed: %s", error_to_string(rv));
	120	}
	121	}
	122	else {
	123	croak ("FATAL: input size not equal to blocksize (%d)", self->desc->block_length);
116	124	}
117	125	}
118	126	OUTPUT:

+5

-2

inc/CryptX_Digest_SHAKE.xs.inc less more

66	66	RETVAL = NEWSV(0, out_len);
67	67	SvPOK_only(RETVAL);
68	68	SvCUR_set(RETVAL, out_len);
69		out_data = (unsigned char *)SvPV_nolen(RETVAL);
	69	out_data = (unsigned char *)SvPVX(RETVAL);
70	70	rv = sha3_shake_done(&self->state, out_data, out_len);
71		if (rv != CRYPT_OK) croak("FATAL: sha3_shake_done failed: %s", error_to_string(rv));
	71	if (rv != CRYPT_OK) {
	72	SvREFCNT_dec(RETVAL);
	73	croak("FATAL: sha3_shake_done failed: %s", error_to_string(rv));
	74	}
72	75	}
73	76	OUTPUT:
74	77	RETVAL

+2

-3

inc/CryptX_Mode_CBC.xs.inc less more

106	106	RETVAL = NEWSV(0, i);
107	107	SvPOK_only(RETVAL);
108	108	SvCUR_set(RETVAL, i);
109		out_data = (unsigned char *)SvPV_nolen(RETVAL);
110
	109	out_data = (unsigned char *)SvPVX(RETVAL);
111	110	if (has_tmp_block) {
112	111	Copy(tmp_block, out_data, blen, unsigned char);
113	112	out_data += blen;

232	231	RETVAL = NEWSV(0, i);
233	232	SvPOK_only(RETVAL);
234	233	SvCUR_set(RETVAL, i);
235		out_data = (unsigned char *)SvPV_nolen(RETVAL);
	234	out_data = (unsigned char *)SvPVX(RETVAL);
236	235	if (has_tmp_block) {
237	236	Copy(tmp_block, out_data, blen, unsigned char);
238	237	out_data += blen;

+11

-4

inc/CryptX_Mode_CFB.xs.inc less more

63	63	unsigned char in_data, out_data;
64	64
65	65	in_data = (unsigned char *)SvPVbyte(data, in_data_len);
66		if (in_data_len==0) {
	66	if (in_data_len == 0) {
67	67	RETVAL = newSVpvn("", 0);
68	68	}
69	69	else {
70	70	RETVAL = NEWSV(0, in_data_len);
71	71	SvPOK_only(RETVAL);
72	72	SvCUR_set(RETVAL, in_data_len);
73		out_data = (unsigned char *)SvPV_nolen(RETVAL);
	73	out_data = (unsigned char *)SvPVX(RETVAL);
74	74
75	75	if (self->direction == 1) {
76	76	rv = cfb_encrypt(in_data, out_data, (unsigned long)in_data_len, &self->state);
77		if (rv != CRYPT_OK) croak("FATAL: cfb_encrypt failed: %s", error_to_string(rv));
	77	if (rv != CRYPT_OK) {
	78	SvREFCNT_dec(RETVAL);
	79	croak("FATAL: cfb_encrypt failed: %s", error_to_string(rv));
	80	}
78	81	}
79	82	else if (self->direction == -1) {
80	83	rv = cfb_decrypt(in_data, out_data, (unsigned long)in_data_len, &self->state);
81		if (rv != CRYPT_OK) croak("FATAL: cfb_decrypt failed: %s", error_to_string(rv));
	84	if (rv != CRYPT_OK) {
	85	SvREFCNT_dec(RETVAL);
	86	croak("FATAL: cfb_decrypt failed: %s", error_to_string(rv));
	87	}
82	88	}
83	89	else {
	90	SvREFCNT_dec(RETVAL);
84	91	croak("FATAL: cfb_crypt failed: call start_encrypt or start_decrypt first");
85	92	}
86	93	}

+11

-4

inc/CryptX_Mode_CTR.xs.inc less more

68	68	unsigned char in_data, out_data;
69	69
70	70	in_data = (unsigned char *)SvPVbyte(data, in_data_len);
71		if (in_data_len==0) {
	71	if (in_data_len == 0) {
72	72	RETVAL = newSVpvn("", 0);
73	73	}
74	74	else {
75	75	RETVAL = NEWSV(0, in_data_len);
76	76	SvPOK_only(RETVAL);
77	77	SvCUR_set(RETVAL, in_data_len);
78		out_data = (unsigned char *)SvPV_nolen(RETVAL);
	78	out_data = (unsigned char *)SvPVX(RETVAL);
79	79
80	80	if (self->direction == 1) {
81	81	rv = ctr_encrypt(in_data, out_data, (unsigned long)in_data_len, &self->state);
82		if (rv != CRYPT_OK) croak("FATAL: ctr_encrypt failed: %s", error_to_string(rv));
	82	if (rv != CRYPT_OK) {
	83	SvREFCNT_dec(RETVAL);
	84	croak("FATAL: ctr_encrypt failed: %s", error_to_string(rv));
	85	}
83	86	}
84	87	else if (self->direction == -1) {
85	88	rv = ctr_decrypt(in_data, out_data, (unsigned long)in_data_len, &self->state);
86		if (rv != CRYPT_OK) croak("FATAL: ctr_decrypt failed: %s", error_to_string(rv));
	89	if (rv != CRYPT_OK) {
	90	SvREFCNT_dec(RETVAL);
	91	croak("FATAL: ctr_decrypt failed: %s", error_to_string(rv));
	92	}
87	93	}
88	94	else {
	95	SvREFCNT_dec(RETVAL);
89	96	croak("FATAL: ctr_crypt failed: call start_encrypt or start_decrypt first");
90	97	}
91	98	}

+2

-3

inc/CryptX_Mode_ECB.xs.inc less more

99	99	RETVAL = NEWSV(0, i);
100	100	SvPOK_only(RETVAL);
101	101	SvCUR_set(RETVAL, i);
102		out_data = (unsigned char *)SvPV_nolen(RETVAL);
103
	102	out_data = (unsigned char *)SvPVX(RETVAL);
104	103	if (has_tmp_block) {
105	104	Copy(tmp_block, out_data, blen, unsigned char);
106	105	out_data += blen;

225	224	RETVAL = NEWSV(0, i);
226	225	SvPOK_only(RETVAL);
227	226	SvCUR_set(RETVAL, i);
228		out_data = (unsigned char *)SvPV_nolen(RETVAL);
	227	out_data = (unsigned char *)SvPVX(RETVAL);
229	228	if (has_tmp_block) {
230	229	Copy(tmp_block, out_data, blen, unsigned char);
231	230	out_data += blen;

+11

-4

inc/CryptX_Mode_OFB.xs.inc less more

63	63	unsigned char in_data, out_data;
64	64
65	65	in_data = (unsigned char *)SvPVbyte(data, in_data_len);
66		if (in_data_len==0) {
	66	if (in_data_len == 0) {
67	67	RETVAL = newSVpvn("", 0);
68	68	}
69	69	else {
70	70	RETVAL = NEWSV(0, in_data_len);
71	71	SvPOK_only(RETVAL);
72	72	SvCUR_set(RETVAL, in_data_len);
73		out_data = (unsigned char *)SvPV_nolen(RETVAL);
	73	out_data = (unsigned char *)SvPVX(RETVAL);
74	74
75	75	if (self->direction == 1) {
76	76	rv = ofb_encrypt(in_data, out_data, (unsigned long)in_data_len, &self->state);
77		if (rv != CRYPT_OK) croak("FATAL: ofb_encrypt failed: %s", error_to_string(rv));
	77	if (rv != CRYPT_OK) {
	78	SvREFCNT_dec(RETVAL);
	79	croak("FATAL: ofb_encrypt failed: %s", error_to_string(rv));
	80	}
78	81	}
79	82	else if (self->direction == -1) {
80	83	rv = ofb_decrypt(in_data, out_data, (unsigned long)in_data_len, &self->state);
81		if (rv != CRYPT_OK) croak("FATAL: ofb_decrypt failed: %s", error_to_string(rv));
	84	if (rv != CRYPT_OK) {
	85	SvREFCNT_dec(RETVAL);
	86	croak("FATAL: ofb_decrypt failed: %s", error_to_string(rv));
	87	}
82	88	}
83	89	else {
	90	SvREFCNT_dec(RETVAL);
84	91	croak("FATAL: ofb_crypt failed: call start_encrypt or start_decrypt first");
85	92	}
86	93	}

+5

-2

inc/CryptX_PRNG.xs.inc less more

83	83	RETVAL = NEWSV(0, output_len);
84	84	SvPOK_only(RETVAL);
85	85	SvCUR_set(RETVAL, output_len);
86		rdata = (unsigned char *)SvPV_nolen(RETVAL);
	86	rdata = (unsigned char *)SvPVX(RETVAL);
87	87	rv_len = (self->desc->read)(rdata, (unsigned long)output_len, &self->state);
88		if ((UV)rv_len != output_len) croak("FATAL: PRNG_read failed");
	88	if ((UV)rv_len != output_len) {
	89	SvREFCNT_dec(RETVAL);
	90	croak("FATAL: PRNG_read failed");
	91	}
89	92	}
90	93	OUTPUT:
91	94	RETVAL

+10

-4

inc/CryptX_Stream_ChaCha.xs.inc less more

58	58	RETVAL = NEWSV(0, out_len);
59	59	SvPOK_only(RETVAL);
60	60	SvCUR_set(RETVAL, out_len);
61		out_data = (unsigned char *)SvPV_nolen(RETVAL);
	61	out_data = (unsigned char *)SvPVX(RETVAL);
62	62	rv = chacha_keystream(&self->state, out_data, out_len);
63		if (rv != CRYPT_OK) croak("FATAL: chacha_keystream failed: %s", error_to_string(rv));
	63	if (rv != CRYPT_OK) {
	64	SvREFCNT_dec(RETVAL);
	65	croak("FATAL: chacha_keystream failed: %s", error_to_string(rv));
	66	}
64	67	}
65	68	OUTPUT:
66	69	RETVAL

81	84	RETVAL = NEWSV(0, in_data_len);
82	85	SvPOK_only(RETVAL);
83	86	SvCUR_set(RETVAL, in_data_len);
84		out_data = (unsigned char *)SvPV_nolen(RETVAL);
	87	out_data = (unsigned char *)SvPVX(RETVAL);
85	88	rv = chacha_crypt(&self->state, in_data, (unsigned long)in_data_len, out_data);
86		if (rv != CRYPT_OK) croak("FATAL: chacha_crypt failed: %s", error_to_string(rv));
	89	if (rv != CRYPT_OK) {
	90	SvREFCNT_dec(RETVAL);
	91	croak("FATAL: chacha_crypt failed: %s", error_to_string(rv));
	92	}
87	93	}
88	94	}
89	95	OUTPUT:

+10

-4

inc/CryptX_Stream_RC4.xs.inc less more

44	44	RETVAL = NEWSV(0, out_len);
45	45	SvPOK_only(RETVAL);
46	46	SvCUR_set(RETVAL, out_len);
47		out_data = (unsigned char *)SvPV_nolen(RETVAL);
	47	out_data = (unsigned char *)SvPVX(RETVAL);
48	48	rv = rc4_stream_keystream(&self->state, out_data, out_len);
49		if (rv != CRYPT_OK) croak("FATAL: rc4_stream_keystream failed: %s", error_to_string(rv));
	49	if (rv != CRYPT_OK) {
	50	SvREFCNT_dec(RETVAL);
	51	croak("FATAL: rc4_stream_keystream failed: %s", error_to_string(rv));
	52	}
50	53	}
51	54	OUTPUT:
52	55	RETVAL

67	70	RETVAL = NEWSV(0, in_data_len);
68	71	SvPOK_only(RETVAL);
69	72	SvCUR_set(RETVAL, in_data_len);
70		out_data = (unsigned char *)SvPV_nolen(RETVAL);
	73	out_data = (unsigned char *)SvPVX(RETVAL);
71	74	rv = rc4_stream_crypt(&self->state, in_data, (unsigned long)in_data_len, out_data);
72		if (rv != CRYPT_OK) croak("FATAL: rc4_stream_crypt failed: %s", error_to_string(rv));
	75	if (rv != CRYPT_OK) {
	76	SvREFCNT_dec(RETVAL);
	77	croak("FATAL: rc4_stream_crypt failed: %s", error_to_string(rv));
	78	}
73	79	}
74	80	}
75	81	OUTPUT:

+10

-4

inc/CryptX_Stream_Sober128.xs.inc less more

49	49	RETVAL = NEWSV(0, out_len);
50	50	SvPOK_only(RETVAL);
51	51	SvCUR_set(RETVAL, out_len);
52		out_data = (unsigned char *)SvPV_nolen(RETVAL);
	52	out_data = (unsigned char *)SvPVX(RETVAL);
53	53	rv = sober128_stream_keystream(&self->state, out_data, out_len);
54		if (rv != CRYPT_OK) croak("FATAL: sober128_stream_keystream failed: %s", error_to_string(rv));
	54	if (rv != CRYPT_OK) {
	55	SvREFCNT_dec(RETVAL);
	56	croak("FATAL: sober128_stream_keystream failed: %s", error_to_string(rv));
	57	}
55	58	}
56	59	OUTPUT:
57	60	RETVAL

72	75	RETVAL = NEWSV(0, in_data_len);
73	76	SvPOK_only(RETVAL);
74	77	SvCUR_set(RETVAL, in_data_len);
75		out_data = (unsigned char *)SvPV_nolen(RETVAL);
	78	out_data = (unsigned char *)SvPVX(RETVAL);
76	79	rv = sober128_stream_crypt(&self->state, in_data, (unsigned long)in_data_len, out_data);
77		if (rv != CRYPT_OK) croak("FATAL: sober128_stream_crypt failed: %s", error_to_string(rv));
	80	if (rv != CRYPT_OK) {
	81	SvREFCNT_dec(RETVAL);
	82	croak("FATAL: sober128_stream_crypt failed: %s", error_to_string(rv));
	83	}
78	84	}
79	85	}
80	86	OUTPUT: