[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

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
79	SV *
80	DESTROY(p)
81	EC_Point *p
82	CODE:
83	EC_DESTROY(p);
84	DESTROY(p);
85	XSRETURN_YES;
86
87	MODULE = Catacomb PACKAGE = Catacomb::EC::Curve PREFIX = ec_
88
89	EC_Curve *
90	ec_prime(me, f, a, b)
91	SV *me
92	Field *f
93	mp *a
94	mp *b
95	C_ARGS:
96	f, a, b
97
98	EC_Curve *
99	ec_primeproj(me, f, a, b)
100	SV *me
101	Field *f
102	mp *a
103	mp *b
104	C_ARGS:
105	f, a, b
106
107	EC_Curve *
108	ec_bin(me, f, a, b)
109	SV *me
110	Field *f
111	gf *a
112	gf *b
113	C_ARGS:
114	f, a, b
115
116	EC_Curve *
117	ec_binproj(me, f, a, b)
118	SV *me
119	Field *f
120	gf *a
121	gf *b
122	C_ARGS:
123	f, a, b
124
125	char *
126	name(c)
127	EC_Curve *c
128	CODE:
129	RETVAL = (char *)EC_NAME(c);
130	OUTPUT:
131	RETVAL
132
133	bool
134	ec_samep(me, c)
135	EC_Curve *me
136	EC_Curve *c
137
138	EC_Point *
139	find(c, x)
140	EC_Curve *c
141	mp *x
142	CODE:
143	RETVAL = CREATE(EC_Point);
144	if (!ec_find(c, RETVAL, x)) {
145	DESTROY(RETVAL);
146	RETVAL = 0;
147	}
148	OUTPUT:
149	RETVAL
150
151	EC_Point *
152	rand(c, r = &rand_global)
153	EC_Curve *c
154	grand *r
155	CODE:
156	RETVAL = CREATE(EC_Point);
157	ec_rand(c, RETVAL, r);
158	OUTPUT:
159	RETVAL
160
161	EC_Point *
162	neg(c, p)
163	EC_Curve *c
164	EC_Point *p
165	CODE:
166	RETVAL = CREATE(EC_Point);
167	EC_CREATE(RETVAL);
168	ec_neg(c, RETVAL, p);
169	OUTPUT:
170	RETVAL
171
172	EC_Point *
173	add(c, p, q)
174	EC_Curve *c
175	EC_Point *p
176	EC_Point *q
177	CODE:
178	RETVAL = CREATE(EC_Point);
179	EC_CREATE(RETVAL);
180	ec_add(c, RETVAL, p, q);
181	OUTPUT:
182	RETVAL
183
184	EC_Point *
185	sub(c, p, q)
186	EC_Curve *c
187	EC_Point *p
188	EC_Point *q
189	CODE:
190	RETVAL = CREATE(EC_Point);
191	EC_CREATE(RETVAL);
192	ec_sub(c, RETVAL, p, q);
193	OUTPUT:
194	RETVAL
195
196	EC_Point *
197	dbl(c, p)
198	EC_Curve *c
199	EC_Point *p
200	CODE:
201	RETVAL = CREATE(EC_Point);
202	EC_CREATE(RETVAL);
203	ec_dbl(c, RETVAL, p);
204	OUTPUT:
205	RETVAL
206
207	bool
208	ec_check(c, p)
209	EC_Curve *c
210	EC_Point *p
211
212	EC_Point *
213	mul(c, p, x)
214	EC_Curve *c
215	EC_Point *p
216	mp *x
217	CODE:
218	RETVAL = CREATE(EC_Point);
219	EC_CREATE(RETVAL);
220	ec_mul(c, RETVAL, p, x);
221	OUTPUT:
222	RETVAL
223
224	EC_Point *
225	mmul(c, ...)
226	EC_Curve *c
227	PREINIT:
228	ec_mulfactor *v;
229	size_t i, j, n;
230	CODE:
231	if (items < 3 \|\| !(items & 1)) {
232	croak("Usage: Catacomb::EC::Curve::mmul"
233	"(c, p_0, x_0, p_1, x_1, ...");
234	}
235	n = (items - 1)/2;
236	v = xmalloc(n * sizeof(mp_expfactor));
237	for (i = 1, j = 0; i < items; i += 2, j++) {
238	v[j].base = (ec )ptrfromsv(ST(i), "Catacomb::EC::Point", "p_i");
239	v[j].exp = mp_fromsv(ST(i + 1), "x_i", "Catacomb::MP", 0, 0);
240	}
241	RETVAL = CREATE(RETVAL);
242	EC_CREATE(RETVAL);
243	ec_mmul(c, RETVAL, v, n);
244	xfree(v);
245	OUTPUT:
246	RETVAL
247
248	EC_Point *
249	in(c, p)
250	EC_Curve *c
251	EC_Point *p
252	CODE:
253	RETVAL = CREATE(EC_Point);
254	EC_CREATE(RETVAL);
255	EC_IN(c, RETVAL, p);
256	OUTPUT:
257	RETVAL
258
259	EC_Point *
260	out(c, p)
261	EC_Curve *c
262	EC_Point *p
263	CODE:
264	RETVAL = CREATE(EC_Point);
265	EC_CREATE(RETVAL);
266	EC_OUT(c, RETVAL, p);
267	OUTPUT:
268	RETVAL
269
270	EC_Point *
271	fix(c, p)
272	EC_Curve *c
273	EC_Point *p
274	CODE:
275	RETVAL = CREATE(EC_Point);
276	EC_CREATE(RETVAL);
277	EC_FIX(c, RETVAL, p);
278	OUTPUT:
279	RETVAL
280
281	EC_Point *
282	ifind(c, x)
283	EC_Curve *c
284	mp *x
285	CODE:
286	RETVAL = CREATE(EC_Point);
287	if (!EC_FIND(c, RETVAL, x)) {
288	DESTROY(RETVAL);
289	RETVAL = 0;
290	}
291	OUTPUT:
292	RETVAL
293
294	EC_Point *
295	ineg(c, p)
296	EC_Curve *c
297	EC_Point *p
298	CODE:
299	RETVAL = CREATE(EC_Point);
300	EC_CREATE(RETVAL);
301	EC_NEG(c, RETVAL, p);
302	OUTPUT:
303	RETVAL
304
305	EC_Point *
306	iadd(c, p, q)
307	EC_Curve *c
308	EC_Point *p
309	EC_Point *q
310	CODE:
311	RETVAL = CREATE(EC_Point);
312	EC_CREATE(RETVAL);
313	EC_ADD(c, RETVAL, p, q);
314	OUTPUT:
315	RETVAL
316
317	EC_Point *
318	isub(c, p, q)
319	EC_Curve *c
320	EC_Point *p
321	EC_Point *q
322	CODE:
323	RETVAL = CREATE(EC_Point);
324	EC_CREATE(RETVAL);
325	EC_SUB(c, RETVAL, p, q);
326	OUTPUT:
327	RETVAL
328
329	EC_Point *
330	idbl(c, p)
331	EC_Curve *c
332	EC_Point *p
333	CODE:
334	RETVAL = CREATE(EC_Point);
335	EC_CREATE(RETVAL);
336	EC_DBL(c, RETVAL, p);
337	OUTPUT:
338	RETVAL
339
340	bool
341	icheck(c, p)
342	EC_Curve *c
343	EC_Point *p
344	CODE:
345	RETVAL = EC_CHECK(c, p);
346	OUTPUT:
347	RETVAL
348
349	EC_Point *
350	imul(c, p, x)
351	EC_Curve *c
352	EC_Point *p
353	mp *x
354	CODE:
355	RETVAL = CREATE(EC_Point);
356	EC_CREATE(RETVAL);
357	ec_imul(c, RETVAL, p, x);
358	OUTPUT:
359	RETVAL
360
361	EC_Point *
362	immul(c, ...)
363	EC_Curve *c
364	PREINIT:
365	ec_mulfactor *v;
366	size_t i, j, n;
367	CODE:
368	if (items < 3 \|\| !(items & 1)) {
369	croak("Usage: Catacomb::EC::Curve::immul"
370	"(c, p_0, x_0, p_1, x_1, ...");
371	}
372	n = (items - 1)/2;
373	v = xmalloc(n * sizeof(mp_expfactor));
374	for (i = 1, j = 0; i < items; i += 2, j++) {
375	v[j].base = (ec )ptrfromsv(ST(i), "Catacomb::EC::Point", "p_i");
376	v[j].exp = mp_fromsv(ST(i + 1), "x_i", "Catacomb::MP", 0, 0);
377	}
378	RETVAL = CREATE(RETVAL);
379	EC_CREATE(RETVAL);
380	ec_mmul(c, RETVAL, v, n);
381	xfree(v);
382	OUTPUT:
383	RETVAL
384
385	void
386	getinfo(me, p)
387	char *p
388	PREINIT:
389	ec_info i;
390	const char *e;
391	EC_Point *pt;
392	PPCODE:
393	if ((e = ec_getinfo(&i, p)) != 0)
394	croak("bad curve spec: %s", e);
395	pt = CREATE(EC_Point);
396	*pt = i.g;
397	XPUSHs(RET(i.c, "Catacomb::EC::Curve"));
398	XPUSHs(RET(pt, "Catacomb::EC::Point"));
399	XPUSHs(RET(i.r, "Catacomb::MP"));
400	XPUSHs(RET(i.h, "Catacomb::MP"));
401