[catacomb-perl] / ec.xs

# ---?---
#
# $Id$
#
# Elliptic curves
#
# (c) 2001 Straylight/Edgeware
#

#----- Licensing notice -----------------------------------------------------
#
# This file is part of the Perl interface to Catacomb.
#
# Catacomb/Perl is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
# 
# Catacomb/Perl is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
# 
# You should have received a copy of the GNU General Public License
# along with Catacomb/Perl; if not, write to the Free Software Foundation,
# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

MODULE = Catacomb PACKAGE = Catacomb::EC::Point PREFIX = ec_

EC_Point *
new(x = 0, y = 0, z = 0)
	mp *x
	mp *y
	mp *z
	CODE:
	RETVAL = CREATE(EC_Point);
	EC_CREATE(RETVAL);
	if (x && y) {
	  RETVAL->x = MP_COPY(x);
	  RETVAL->y = MP_COPY(y);
	  if (z)
	    RETVAL->z = MP_COPY(z);
	}
	OUTPUT:	
	RETVAL

bool
atinfp(p)
	EC_Point *p
	CODE:
	RETVAL = EC_ATINF(p);
	OUTPUT:
	RETVAL

mp *
x(p)
	EC_Point *p
	CODE:
	RETVAL = p->x ? MP_COPY(p->x) : 0;
	OUTPUT:
	RETVAL
	
mp *
y(p)
	EC_Point *p
	CODE:
	RETVAL = p->y ? MP_COPY(p->y) : 0;
	OUTPUT:
	RETVAL
	
mp *
z(p)
	EC_Point *p
	CODE:
	RETVAL = p->z ? MP_COPY(p->z) : 0;
	OUTPUT:
	RETVAL

bool
ec_eq(p, q)
	EC_Point *p
	EC_Point *q

SV *
DESTROY(p)
	EC_Point *p
	CODE:
	EC_DESTROY(p);
	DESTROY(p);
	XSRETURN_YES;

MODULE = Catacomb PACKAGE = Catacomb::EC::Curve PREFIX = ec_

EC_Curve *
ec_prime(me, f, a, b)
	SV *me
	Field *f
	mp *a
	mp *b
	C_ARGS:
	f, a, b

EC_Curve *
ec_primeproj(me, f, a, b)
	SV *me
	Field *f
	mp *a
	mp *b
	C_ARGS:
	f, a, b

EC_Curve *
ec_bin(me, f, a, b)
	SV *me
	Field *f
	gf *a
	gf *b
	C_ARGS:
	f, a, b

EC_Curve *
ec_binproj(me, f, a, b)
	SV *me
	Field *f
	gf *a
	gf *b
	C_ARGS:
	f, a, b

char *
name(c)
	EC_Curve *c
	CODE:
	RETVAL = (char *)EC_NAME(c);
	OUTPUT:	
	RETVAL

bool
ec_samep(me, c)
	EC_Curve *me
	EC_Curve *c

EC_Point *
find(c, x)
	EC_Curve *c
	mp *x
	CODE:
	RETVAL = CREATE(EC_Point);
	if (!ec_find(c, RETVAL, x)) {
	  DESTROY(RETVAL);
	  RETVAL = 0;
	}
	OUTPUT:
	RETVAL

EC_Point *
rand(c, r = &rand_global)
	EC_Curve *c
	grand *r
	CODE:
	RETVAL = CREATE(EC_Point);
	ec_rand(c, RETVAL, r);
	OUTPUT:
	RETVAL

EC_Point *
neg(c, p)
	EC_Curve *c
	EC_Point *p
	CODE:
	RETVAL = CREATE(EC_Point);
	EC_CREATE(RETVAL);
	ec_neg(c, RETVAL, p);
	OUTPUT:
	RETVAL

EC_Point *
add(c, p, q)
	EC_Curve *c
	EC_Point *p
	EC_Point *q
	CODE:
	RETVAL = CREATE(EC_Point);
	EC_CREATE(RETVAL);
	ec_add(c, RETVAL, p, q);
	OUTPUT:
	RETVAL

EC_Point *
sub(c, p, q)
	EC_Curve *c
	EC_Point *p
	EC_Point *q
	CODE:
	RETVAL = CREATE(EC_Point);
	EC_CREATE(RETVAL);
	ec_sub(c, RETVAL, p, q);
	OUTPUT:
	RETVAL

EC_Point *
dbl(c, p)
	EC_Curve *c
	EC_Point *p
	CODE:
	RETVAL = CREATE(EC_Point);
	EC_CREATE(RETVAL);
	ec_dbl(c, RETVAL, p);
	OUTPUT:
	RETVAL

bool
ec_check(c, p)
	EC_Curve *c
	EC_Point *p

EC_Point *
mul(c, p, x)
	EC_Curve *c
	EC_Point *p
	mp *x
	CODE:
	RETVAL = CREATE(EC_Point);
	EC_CREATE(RETVAL);
	ec_mul(c, RETVAL, p, x);
	OUTPUT:
	RETVAL

EC_Point *
mmul(c, ...)
	EC_Curve *c
	PREINIT:
	ec_mulfactor *v;
	size_t i, j, n;
	CODE:
	if (items < 3 || !(items & 1)) {
	  croak("Usage: Catacomb::EC::Curve::mmul"
		"(c, p_0, x_0, p_1, x_1, ...");
	}
	n = (items - 1)/2;
	v = xmalloc(n * sizeof(mp_expfactor));
	for (i = 1, j = 0; i < items; i += 2, j++) {
	  v[j].base = *(ec *)ptrfromsv(ST(i), "Catacomb::EC::Point", "p_i");
	  v[j].exp = mp_fromsv(ST(i + 1), "x_i", "Catacomb::MP", 0, 0);
	}
	RETVAL = CREATE(RETVAL);
	EC_CREATE(RETVAL);
	ec_mmul(c, RETVAL, v, n);
	xfree(v);
	OUTPUT:
	RETVAL

EC_Point *
in(c, p)
	EC_Curve *c
	EC_Point *p
	CODE:
	RETVAL = CREATE(EC_Point);
	EC_CREATE(RETVAL);
	EC_IN(c, RETVAL, p);
	OUTPUT:
	RETVAL

EC_Point *
out(c, p)
	EC_Curve *c
	EC_Point *p
	CODE:
	RETVAL = CREATE(EC_Point);
	EC_CREATE(RETVAL);
	EC_OUT(c, RETVAL, p);
	OUTPUT:
	RETVAL

EC_Point *
fix(c, p)
	EC_Curve *c
	EC_Point *p
	CODE:
	RETVAL = CREATE(EC_Point);
	EC_CREATE(RETVAL);
	EC_FIX(c, RETVAL, p);
	OUTPUT:
	RETVAL

EC_Point *
ifind(c, x)
	EC_Curve *c
	mp *x
	CODE:
	RETVAL = CREATE(EC_Point);
	if (!EC_FIND(c, RETVAL, x)) {
	  DESTROY(RETVAL);
	  RETVAL = 0;
	}
	OUTPUT:
	RETVAL

EC_Point *
ineg(c, p)
	EC_Curve *c
	EC_Point *p
	CODE:
	RETVAL = CREATE(EC_Point);
	EC_CREATE(RETVAL);
	EC_NEG(c, RETVAL, p);
	OUTPUT:
	RETVAL

EC_Point *
iadd(c, p, q)
	EC_Curve *c
	EC_Point *p
	EC_Point *q
	CODE:
	RETVAL = CREATE(EC_Point);
	EC_CREATE(RETVAL);
	EC_ADD(c, RETVAL, p, q);
	OUTPUT:
	RETVAL

EC_Point *
isub(c, p, q)
	EC_Curve *c
	EC_Point *p
	EC_Point *q
	CODE:
	RETVAL = CREATE(EC_Point);
	EC_CREATE(RETVAL);
	EC_SUB(c, RETVAL, p, q);
	OUTPUT:
	RETVAL

EC_Point *
idbl(c, p)
	EC_Curve *c
	EC_Point *p
	CODE:
	RETVAL = CREATE(EC_Point);
	EC_CREATE(RETVAL);
	EC_DBL(c, RETVAL, p);
	OUTPUT:
	RETVAL

bool
icheck(c, p)
	EC_Curve *c
	EC_Point *p
	CODE:
	RETVAL = EC_CHECK(c, p);
	OUTPUT:
	RETVAL

EC_Point *
imul(c, p, x)
	EC_Curve *c
	EC_Point *p
	mp *x
	CODE:
	RETVAL = CREATE(EC_Point);
	EC_CREATE(RETVAL);
	ec_imul(c, RETVAL, p, x);
	OUTPUT:
	RETVAL

EC_Point *
immul(c, ...)
	EC_Curve *c
	PREINIT:
	ec_mulfactor *v;
	size_t i, j, n;
	CODE:
	if (items < 3 || !(items & 1)) {
	  croak("Usage: Catacomb::EC::Curve::immul"
		"(c, p_0, x_0, p_1, x_1, ...");
	}
	n = (items - 1)/2;
	v = xmalloc(n * sizeof(mp_expfactor));
	for (i = 1, j = 0; i < items; i += 2, j++) {
	  v[j].base = *(ec *)ptrfromsv(ST(i), "Catacomb::EC::Point", "p_i");
	  v[j].exp = mp_fromsv(ST(i + 1), "x_i", "Catacomb::MP", 0, 0);
	}
	RETVAL = CREATE(RETVAL);
	EC_CREATE(RETVAL);
	ec_mmul(c, RETVAL, v, n);
	xfree(v);
	OUTPUT:
	RETVAL

void
getinfo(me, p)
	char *p
	PREINIT:
	ec_info i;
	const char *e;
	EC_Point *pt;
	PPCODE:
	if ((e = ec_getinfo(&i, p)) != 0)
	  croak("bad curve spec: %s", e);
	pt = CREATE(EC_Point);
	*pt = i.g;
	XPUSHs(RET(i.c, "Catacomb::EC::Curve"));
	XPUSHs(RET(pt, "Catacomb::EC::Point"));
	XPUSHs(RET(i.r, "Catacomb::MP"));
	XPUSHs(RET(i.h, "Catacomb::MP"));
Commit	Line	Data
a1a90aaf	1	# ---?---
	2	#
	3	# $Id$
	4	#
	5	# Elliptic curves
	6	#
	7	# (c) 2001 Straylight/Edgeware
	8	#
	9
	10	#----- Licensing notice -----------------------------------------------------
	11	#
	12	# This file is part of the Perl interface to Catacomb.
	13	#
	14	# Catacomb/Perl is free software; you can redistribute it and/or modify
	15	# it under the terms of the GNU General Public License as published by
	16	# the Free Software Foundation; either version 2 of the License, or
	17	# (at your option) any later version.
	18	#
	19	# Catacomb/Perl is distributed in the hope that it will be useful,
	20	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	21	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	22	# GNU General Public License for more details.
	23	#
	24	# You should have received a copy of the GNU General Public License
	25	# along with Catacomb/Perl; if not, write to the Free Software Foundation,
	26	# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	27
	28	MODULE = Catacomb PACKAGE = Catacomb::EC::Point PREFIX = ec_
	29
	30	EC_Point *
	31	new(x = 0, y = 0, z = 0)
	32	mp *x
	33	mp *y
	34	mp *z
	35	CODE:
	36	RETVAL = CREATE(EC_Point);
	37	EC_CREATE(RETVAL);
	38	if (x && y) {
	39	RETVAL->x = MP_COPY(x);
	40	RETVAL->y = MP_COPY(y);
	41	if (z)
	42	RETVAL->z = MP_COPY(z);
	43	}
	44	OUTPUT:
	45	RETVAL
	46
	47	bool
	48	atinfp(p)
	49	EC_Point *p
	50	CODE:
	51	RETVAL = EC_ATINF(p);
	52	OUTPUT:
	53	RETVAL
	54
	55	mp *
	56	x(p)
	57	EC_Point *p
	58	CODE:
	59	RETVAL = p->x ? MP_COPY(p->x) : 0;
	60	OUTPUT:
	61	RETVAL
	62
	63	mp *
	64	y(p)
65	EC_Point *p
66	CODE:
67	RETVAL = p->y ? MP_COPY(p->y) : 0;
68	OUTPUT:
69	RETVAL
70
71	mp *
72	z(p)
73	EC_Point *p
74	CODE:
75	RETVAL = p->z ? MP_COPY(p->z) : 0;
76	OUTPUT:
77	RETVAL
78
f9952aec	79	bool
	80	ec_eq(p, q)
	81	EC_Point *p
	82	EC_Point *q
	83
a1a90aaf	84	SV *
	85	DESTROY(p)
	86	EC_Point *p
	87	CODE:
	88	EC_DESTROY(p);
	89	DESTROY(p);
	90	XSRETURN_YES;
	91
	92	MODULE = Catacomb PACKAGE = Catacomb::EC::Curve PREFIX = ec_
	93
	94	EC_Curve *
	95	ec_prime(me, f, a, b)
	96	SV *me
	97	Field *f
	98	mp *a
	99	mp *b
	100	C_ARGS:
	101	f, a, b
	102
	103	EC_Curve *
	104	ec_primeproj(me, f, a, b)
	105	SV *me
	106	Field *f
	107	mp *a
	108	mp *b
	109	C_ARGS:
	110	f, a, b
	111
	112	EC_Curve *
	113	ec_bin(me, f, a, b)
	114	SV *me
	115	Field *f
	116	gf *a
	117	gf *b
	118	C_ARGS:
	119	f, a, b
	120
	121	EC_Curve *
	122	ec_binproj(me, f, a, b)
	123	SV *me
	124	Field *f
	125	gf *a
	126	gf *b
	127	C_ARGS:
	128	f, a, b
	129
	130	char *
	131	name(c)
	132	EC_Curve *c
	133	CODE:
	134	RETVAL = (char *)EC_NAME(c);
	135	OUTPUT:
	136	RETVAL
	137
	138	bool
	139	ec_samep(me, c)
	140	EC_Curve *me
	141	EC_Curve *c
	142
	143	EC_Point *
	144	find(c, x)
	145	EC_Curve *c
	146	mp *x
	147	CODE:
148	RETVAL = CREATE(EC_Point);
149	if (!ec_find(c, RETVAL, x)) {
150	DESTROY(RETVAL);
151	RETVAL = 0;
152	}
153	OUTPUT:
154	RETVAL
155
156	EC_Point *
157	rand(c, r = &rand_global)
158	EC_Curve *c
159	grand *r
160	CODE:
161	RETVAL = CREATE(EC_Point);
162	ec_rand(c, RETVAL, r);
163	OUTPUT:
164	RETVAL
165
166	EC_Point *
167	neg(c, p)
168	EC_Curve *c
169	EC_Point *p
170	CODE:
171	RETVAL = CREATE(EC_Point);
172	EC_CREATE(RETVAL);
173	ec_neg(c, RETVAL, p);
174	OUTPUT:
175	RETVAL
176
177	EC_Point *
178	add(c, p, q)
179	EC_Curve *c
180	EC_Point *p
181	EC_Point *q
182	CODE:
183	RETVAL = CREATE(EC_Point);
184	EC_CREATE(RETVAL);
185	ec_add(c, RETVAL, p, q);
186	OUTPUT:
187	RETVAL
188
189	EC_Point *
190	sub(c, p, q)
191	EC_Curve *c
192	EC_Point *p
193	EC_Point *q
194	CODE:
195	RETVAL = CREATE(EC_Point);
196	EC_CREATE(RETVAL);
197	ec_sub(c, RETVAL, p, q);
198	OUTPUT:
199	RETVAL
200
201	EC_Point *
202	dbl(c, p)
203	EC_Curve *c
204	EC_Point *p
205	CODE:
206	RETVAL = CREATE(EC_Point);
207	EC_CREATE(RETVAL);
208	ec_dbl(c, RETVAL, p);
209	OUTPUT:
210	RETVAL
211
212	bool
213	ec_check(c, p)
214	EC_Curve *c
215	EC_Point *p
216
217	EC_Point *
218	mul(c, p, x)
219	EC_Curve *c
220	EC_Point *p
221	mp *x
222	CODE:
223	RETVAL = CREATE(EC_Point);
224	EC_CREATE(RETVAL);
225	ec_mul(c, RETVAL, p, x);
226	OUTPUT:
227	RETVAL
228
229	EC_Point *
230	mmul(c, ...)
231	EC_Curve *c
232	PREINIT:
233	ec_mulfactor *v;
234	size_t i, j, n;
235	CODE:
236	if (items < 3 \|\| !(items & 1)) {
237	croak("Usage: Catacomb::EC::Curve::mmul"
238	"(c, p_0, x_0, p_1, x_1, ...");
239	}
240	n = (items - 1)/2;
241	v = xmalloc(n * sizeof(mp_expfactor));
242	for (i = 1, j = 0; i < items; i += 2, j++) {
243	v[j].base = (ec )ptrfromsv(ST(i), "Catacomb::EC::Point", "p_i");
244	v[j].exp = mp_fromsv(ST(i + 1), "x_i", "Catacomb::MP", 0, 0);
245	}
246	RETVAL = CREATE(RETVAL);
247	EC_CREATE(RETVAL);
248	ec_mmul(c, RETVAL, v, n);
249	xfree(v);
250	OUTPUT:
251	RETVAL
252
253	EC_Point *
254	in(c, p)
255	EC_Curve *c
256	EC_Point *p
257	CODE:
258	RETVAL = CREATE(EC_Point);
259	EC_CREATE(RETVAL);
260	EC_IN(c, RETVAL, p);
261	OUTPUT:
262	RETVAL
263
264	EC_Point *
265	out(c, p)
266	EC_Curve *c
267	EC_Point *p
268	CODE:
269	RETVAL = CREATE(EC_Point);
270	EC_CREATE(RETVAL);
271	EC_OUT(c, RETVAL, p);
272	OUTPUT:
273	RETVAL
274
275	EC_Point *
276	fix(c, p)
277	EC_Curve *c
278	EC_Point *p
279	CODE:
280	RETVAL = CREATE(EC_Point);
281	EC_CREATE(RETVAL);
282	EC_FIX(c, RETVAL, p);
283	OUTPUT:
284	RETVAL
285
286	EC_Point *
287	ifind(c, x)
288	EC_Curve *c
289	mp *x
290	CODE:
291	RETVAL = CREATE(EC_Point);
292	if (!EC_FIND(c, RETVAL, x)) {
293	DESTROY(RETVAL);
294	RETVAL = 0;
295	}
296	OUTPUT:
297	RETVAL
298
299	EC_Point *
300	ineg(c, p)
301	EC_Curve *c
302	EC_Point *p
303	CODE:
304	RETVAL = CREATE(EC_Point);
305	EC_CREATE(RETVAL);
306	EC_NEG(c, RETVAL, p);
307	OUTPUT:
308	RETVAL
309
310	EC_Point *
311	iadd(c, p, q)
312	EC_Curve *c
313	EC_Point *p
314	EC_Point *q
315	CODE:
316	RETVAL = CREATE(EC_Point);
317	EC_CREATE(RETVAL);
318	EC_ADD(c, RETVAL, p, q);
319	OUTPUT:
320	RETVAL
321
322	EC_Point *
323	isub(c, p, q)
324	EC_Curve *c
325	EC_Point *p
326	EC_Point *q
327	CODE:
328	RETVAL = CREATE(EC_Point);
329	EC_CREATE(RETVAL);
330	EC_SUB(c, RETVAL, p, q);
331	OUTPUT:
332	RETVAL
333
334	EC_Point *
335	idbl(c, p)
336	EC_Curve *c
337	EC_Point *p
338	CODE:
339	RETVAL = CREATE(EC_Point);
340	EC_CREATE(RETVAL);
341	EC_DBL(c, RETVAL, p);
342	OUTPUT:
343	RETVAL
344
345	bool
346	icheck(c, p)
347	EC_Curve *c
348	EC_Point *p
349	CODE:
350	RETVAL = EC_CHECK(c, p);
351	OUTPUT:
352	RETVAL
353
354	EC_Point *
355	imul(c, p, x)
356	EC_Curve *c
357	EC_Point *p
358	mp *x
359	CODE:
360	RETVAL = CREATE(EC_Point);
361	EC_CREATE(RETVAL);
362	ec_imul(c, RETVAL, p, x);
363	OUTPUT:
364	RETVAL
365
366	EC_Point *
367	immul(c, ...)
368	EC_Curve *c
369	PREINIT:
370	ec_mulfactor *v;
371	size_t i, j, n;
372	CODE:
373	if (items < 3 \|\| !(items & 1)) {
374	croak("Usage: Catacomb::EC::Curve::immul"
375	"(c, p_0, x_0, p_1, x_1, ...");
376	}
377	n = (items - 1)/2;
378	v = xmalloc(n * sizeof(mp_expfactor));
379	for (i = 1, j = 0; i < items; i += 2, j++) {
380	v[j].base = (ec )ptrfromsv(ST(i), "Catacomb::EC::Point", "p_i");
381	v[j].exp = mp_fromsv(ST(i + 1), "x_i", "Catacomb::MP", 0, 0);
382	}
383	RETVAL = CREATE(RETVAL);
384	EC_CREATE(RETVAL);
385	ec_mmul(c, RETVAL, v, n);
386	xfree(v);
387	OUTPUT:
388	RETVAL
389
390	void
391	getinfo(me, p)
392	char *p
393	PREINIT:
394	ec_info i;
395	const char *e;
396	EC_Point *pt;
397	PPCODE:
398	if ((e = ec_getinfo(&i, p)) != 0)
399	croak("bad curve spec: %s", e);
400	pt = CREATE(EC_Point);
401	*pt = i.g;
402	XPUSHs(RET(i.c, "Catacomb::EC::Curve"));
403	XPUSHs(RET(pt, "Catacomb::EC::Point"));
404	XPUSHs(RET(i.r, "Catacomb::MP"));
405	XPUSHs(RET(i.h, "Catacomb::MP"));
406