Skip to content

Commit d2202e4

Browse files
adecaroadecaro
committed
custom curves
Signed-off-by: Angelo De Caro <adc@zurich.ibm.com>
1 parent a138079 commit d2202e4

File tree

3 files changed

+75
-75
lines changed

3 files changed

+75
-75
lines changed

‎math.go‎

Lines changed: 42 additions & 42 deletions
Original file line numberDiff line numberDiff line change
@@ -57,7 +57,7 @@ func CurveIDToString(id CurveID) string {
5757

5858
var Curves []*Curve = []*Curve{
5959
{
60-
c: amcl.NewFp256bn(),
60+
C: amcl.NewFp256bn(),
6161
GenG1: &G1{g1: (&amcl.Fp256bn{}).GenG1(), curveID: FP256BN_AMCL},
6262
GenG2: &G2{g2: (&amcl.Fp256bn{}).GenG2(), curveID: FP256BN_AMCL},
6363
GenGt: &Gt{gt: (&amcl.Fp256bn{}).GenGt(), curveID: FP256BN_AMCL},
@@ -68,10 +68,10 @@ var Curves []*Curve = []*Curve{
6868
G2ByteSize: (&amcl.Fp256bn{}).G2ByteSize(),
6969
CompressedG2ByteSize: (&amcl.Fp256bn{}).CompressedG2ByteSize(),
7070
ScalarByteSize: (&amcl.Fp256bn{}).ScalarByteSize(),
71-
curveID: FP256BN_AMCL,
71+
CurveID: FP256BN_AMCL,
7272
},
7373
{
74-
c: gurvy.NewBn254(),
74+
C: gurvy.NewBn254(),
7575
GenG1: &G1{g1: (&gurvy.Bn254{}).GenG1(), curveID: BN254},
7676
GenG2: &G2{g2: (&gurvy.Bn254{}).GenG2(), curveID: BN254},
7777
GenGt: &Gt{gt: (&gurvy.Bn254{}).GenGt(), curveID: BN254},
@@ -82,10 +82,10 @@ var Curves []*Curve = []*Curve{
8282
G2ByteSize: (&gurvy.Bn254{}).G2ByteSize(),
8383
CompressedG2ByteSize: (&gurvy.Bn254{}).CompressedG2ByteSize(),
8484
ScalarByteSize: (&gurvy.Bn254{}).ScalarByteSize(),
85-
curveID: BN254,
85+
CurveID: BN254,
8686
},
8787
{
88-
c: amcl.NewFp256Miraclbn(),
88+
C: amcl.NewFp256Miraclbn(),
8989
GenG1: &G1{g1: (&amcl.Fp256Miraclbn{}).GenG1(), curveID: FP256BN_AMCL_MIRACL},
9090
GenG2: &G2{g2: (&amcl.Fp256Miraclbn{}).GenG2(), curveID: FP256BN_AMCL_MIRACL},
9191
GenGt: &Gt{gt: (&amcl.Fp256Miraclbn{}).GenGt(), curveID: FP256BN_AMCL_MIRACL},
@@ -96,10 +96,10 @@ var Curves []*Curve = []*Curve{
9696
G2ByteSize: (&amcl.Fp256Miraclbn{}).G2ByteSize(),
9797
CompressedG2ByteSize: (&amcl.Fp256Miraclbn{}).CompressedG2ByteSize(),
9898
ScalarByteSize: (&amcl.Fp256Miraclbn{}).ScalarByteSize(),
99-
curveID: FP256BN_AMCL_MIRACL,
99+
CurveID: FP256BN_AMCL_MIRACL,
100100
},
101101
{
102-
c: kilic.NewBls12_381(),
102+
C: kilic.NewBls12_381(),
103103
GenG1: &G1{g1: (&kilic.Bls12_381{}).GenG1(), curveID: BLS12_381},
104104
GenG2: &G2{g2: (&kilic.Bls12_381{}).GenG2(), curveID: BLS12_381},
105105
GenGt: &Gt{gt: (&kilic.Bls12_381{}).GenGt(), curveID: BLS12_381},
@@ -110,10 +110,10 @@ var Curves []*Curve = []*Curve{
110110
G2ByteSize: (&kilic.Bls12_381{}).G2ByteSize(),
111111
CompressedG2ByteSize: (&kilic.Bls12_381{}).CompressedG2ByteSize(),
112112
ScalarByteSize: (&kilic.Bls12_381{}).ScalarByteSize(),
113-
curveID: BLS12_381,
113+
CurveID: BLS12_381,
114114
},
115115
{
116-
c: gurvy.NewBls12_377(),
116+
C: gurvy.NewBls12_377(),
117117
GenG1: &G1{g1: (&gurvy.Bls12_377{}).GenG1(), curveID: BLS12_377_GURVY},
118118
GenG2: &G2{g2: (&gurvy.Bls12_377{}).GenG2(), curveID: BLS12_377_GURVY},
119119
GenGt: &Gt{gt: (&gurvy.Bls12_377{}).GenGt(), curveID: BLS12_377_GURVY},
@@ -124,10 +124,10 @@ var Curves []*Curve = []*Curve{
124124
G2ByteSize: (&gurvy.Bls12_377{}).G2ByteSize(),
125125
CompressedG2ByteSize: (&gurvy.Bls12_377{}).CompressedG2ByteSize(),
126126
ScalarByteSize: (&gurvy.Bls12_377{}).ScalarByteSize(),
127-
curveID: BLS12_377_GURVY,
127+
CurveID: BLS12_377_GURVY,
128128
},
129129
{
130-
c: gurvy.NewBls12_381(),
130+
C: gurvy.NewBls12_381(),
131131
GenG1: &G1{g1: (&gurvy.Bls12_381{}).GenG1(), curveID: BLS12_381_GURVY},
132132
GenG2: &G2{g2: (&gurvy.Bls12_381{}).GenG2(), curveID: BLS12_381_GURVY},
133133
GenGt: &Gt{gt: (&gurvy.Bls12_381{}).GenGt(), curveID: BLS12_381_GURVY},
@@ -138,10 +138,10 @@ var Curves []*Curve = []*Curve{
138138
G2ByteSize: (&gurvy.Bls12_381{}).G2ByteSize(),
139139
CompressedG2ByteSize: (&gurvy.Bls12_381{}).CompressedG2ByteSize(),
140140
ScalarByteSize: (&gurvy.Bls12_381{}).ScalarByteSize(),
141-
curveID: BLS12_381_GURVY,
141+
CurveID: BLS12_381_GURVY,
142142
},
143143
{
144-
c: kilic.NewBls12_381BBS(),
144+
C: kilic.NewBls12_381BBS(),
145145
GenG1: &G1{g1: kilic.NewBls12_381BBS().GenG1(), curveID: BLS12_381_BBS},
146146
GenG2: &G2{g2: kilic.NewBls12_381BBS().GenG2(), curveID: BLS12_381_BBS},
147147
GenGt: &Gt{gt: kilic.NewBls12_381BBS().GenGt(), curveID: BLS12_381_BBS},
@@ -152,10 +152,10 @@ var Curves []*Curve = []*Curve{
152152
G2ByteSize: kilic.NewBls12_381BBS().G2ByteSize(),
153153
CompressedG2ByteSize: kilic.NewBls12_381BBS().CompressedG2ByteSize(),
154154
ScalarByteSize: kilic.NewBls12_381BBS().ScalarByteSize(),
155-
curveID: BLS12_381_BBS,
155+
CurveID: BLS12_381_BBS,
156156
},
157157
{
158-
c: gurvy.NewBls12_381BBS(),
158+
C: gurvy.NewBls12_381BBS(),
159159
GenG1: &G1{g1: gurvy.NewBls12_381BBS().GenG1(), curveID: BLS12_381_BBS_GURVY},
160160
GenG2: &G2{g2: gurvy.NewBls12_381BBS().GenG2(), curveID: BLS12_381_BBS_GURVY},
161161
GenGt: &Gt{gt: gurvy.NewBls12_381BBS().GenGt(), curveID: BLS12_381_BBS_GURVY},
@@ -166,7 +166,7 @@ var Curves []*Curve = []*Curve{
166166
G2ByteSize: gurvy.NewBls12_381BBS().G2ByteSize(),
167167
CompressedG2ByteSize: gurvy.NewBls12_381BBS().CompressedG2ByteSize(),
168168
ScalarByteSize: gurvy.NewBls12_381BBS().ScalarByteSize(),
169-
curveID: BLS12_381_BBS_GURVY,
169+
CurveID: BLS12_381_BBS_GURVY,
170170
},
171171
}
172172

@@ -402,7 +402,7 @@ func (g *Gt) Bytes() []byte {
402402
/*********************************************************************/
403403

404404
type Curve struct {
405-
c driver.Curve
405+
C driver.Curve
406406
GenG1 *G1
407407
GenG2 *G2
408408
GenGt *Gt
@@ -413,19 +413,19 @@ type Curve struct {
413413
G2ByteSize int
414414
CompressedG2ByteSize int
415415
ScalarByteSize int
416-
curveID CurveID
416+
CurveID CurveID
417417
}
418418

419419
func (c *Curve) Rand() (io.Reader, error) {
420-
return c.c.Rand()
420+
return c.C.Rand()
421421
}
422422

423423
func (c *Curve) NewRandomZr(rng io.Reader) *Zr {
424-
return &Zr{zr: c.c.NewRandomZr(rng), curveID: c.curveID}
424+
return &Zr{zr: c.C.NewRandomZr(rng), curveID: c.CurveID}
425425
}
426426

427427
func (c *Curve) NewZrFromBytes(b []byte) *Zr {
428-
return &Zr{zr: c.c.NewZrFromBytes(b), curveID: c.curveID}
428+
return &Zr{zr: c.C.NewZrFromBytes(b), curveID: c.CurveID}
429429
}
430430

431431
func (c *Curve) NewG1FromBytes(b []byte) (p *G1, err error) {
@@ -436,7 +436,7 @@ func (c *Curve) NewG1FromBytes(b []byte) (p *G1, err error) {
436436
}
437437
}()
438438

439-
p = &G1{g1: c.c.NewG1FromBytes(b), curveID: c.curveID}
439+
p = &G1{g1: c.C.NewG1FromBytes(b), curveID: c.CurveID}
440440
return
441441
}
442442

@@ -448,7 +448,7 @@ func (c *Curve) NewG2FromBytes(b []byte) (p *G2, err error) {
448448
}
449449
}()
450450

451-
p = &G2{g2: c.c.NewG2FromBytes(b), curveID: c.curveID}
451+
p = &G2{g2: c.C.NewG2FromBytes(b), curveID: c.CurveID}
452452
return
453453
}
454454

@@ -460,7 +460,7 @@ func (c *Curve) NewG1FromCompressed(b []byte) (p *G1, err error) {
460460
}
461461
}()
462462

463-
p = &G1{g1: c.c.NewG1FromCompressed(b), curveID: c.curveID}
463+
p = &G1{g1: c.C.NewG1FromCompressed(b), curveID: c.CurveID}
464464
return
465465
}
466466

@@ -472,7 +472,7 @@ func (c *Curve) NewG2FromCompressed(b []byte) (p *G2, err error) {
472472
}
473473
}()
474474

475-
p = &G2{g2: c.c.NewG2FromCompressed(b), curveID: c.curveID}
475+
p = &G2{g2: c.C.NewG2FromCompressed(b), curveID: c.CurveID}
476476
return
477477
}
478478

@@ -484,70 +484,70 @@ func (c *Curve) NewGtFromBytes(b []byte) (p *Gt, err error) {
484484
}
485485
}()
486486

487-
p = &Gt{gt: c.c.NewGtFromBytes(b), curveID: c.curveID}
487+
p = &Gt{gt: c.C.NewGtFromBytes(b), curveID: c.CurveID}
488488
return
489489
}
490490

491491
func (c *Curve) NewZrFromInt(i int64) *Zr {
492-
return &Zr{zr: c.c.NewZrFromInt64(i), curveID: c.curveID}
492+
return &Zr{zr: c.C.NewZrFromInt64(i), curveID: c.CurveID}
493493
}
494494

495495
func (c *Curve) NewZrFromUint64(i uint64) *Zr {
496-
return &Zr{zr: c.c.NewZrFromUint64(i), curveID: c.curveID}
496+
return &Zr{zr: c.C.NewZrFromUint64(i), curveID: c.CurveID}
497497
}
498498

499499
func (c *Curve) NewG2() *G2 {
500-
return &G2{g2: c.c.NewG2(), curveID: c.curveID}
500+
return &G2{g2: c.C.NewG2(), curveID: c.CurveID}
501501
}
502502

503503
func (c *Curve) NewG1() *G1 {
504-
return &G1{g1: c.c.NewG1(), curveID: c.curveID}
504+
return &G1{g1: c.C.NewG1(), curveID: c.CurveID}
505505
}
506506

507507
func (c *Curve) Pairing(a *G2, b *G1) *Gt {
508-
return &Gt{gt: c.c.Pairing(a.g2, b.g1), curveID: c.curveID}
508+
return &Gt{gt: c.C.Pairing(a.g2, b.g1), curveID: c.CurveID}
509509
}
510510

511511
func (c *Curve) Pairing2(p *G2, q *G1, r *G2, s *G1) *Gt {
512-
return &Gt{gt: c.c.Pairing2(p.g2, r.g2, q.g1, s.g1), curveID: c.curveID}
512+
return &Gt{gt: c.C.Pairing2(p.g2, r.g2, q.g1, s.g1), curveID: c.CurveID}
513513
}
514514

515515
func (c *Curve) FExp(a *Gt) *Gt {
516-
return &Gt{gt: c.c.FExp(a.gt), curveID: c.curveID}
516+
return &Gt{gt: c.C.FExp(a.gt), curveID: c.CurveID}
517517
}
518518

519519
func (c *Curve) HashToZr(data []byte) *Zr {
520-
return &Zr{zr: c.c.HashToZr(data), curveID: c.curveID}
520+
return &Zr{zr: c.C.HashToZr(data), curveID: c.CurveID}
521521
}
522522

523523
func (c *Curve) HashToG1(data []byte) *G1 {
524-
return &G1{g1: c.c.HashToG1(data), curveID: c.curveID}
524+
return &G1{g1: c.C.HashToG1(data), curveID: c.CurveID}
525525
}
526526

527527
func (c *Curve) HashToG1WithDomain(data, domain []byte) *G1 {
528-
return &G1{g1: c.c.HashToG1WithDomain(data, domain), curveID: c.curveID}
528+
return &G1{g1: c.C.HashToG1WithDomain(data, domain), curveID: c.CurveID}
529529
}
530530

531531
func (c *Curve) HashToG2(data []byte) *G2 {
532-
return &G2{g2: c.c.HashToG2(data), curveID: c.curveID}
532+
return &G2{g2: c.C.HashToG2(data), curveID: c.CurveID}
533533
}
534534

535535
func (c *Curve) HashToG2WithDomain(data, domain []byte) *G2 {
536-
return &G2{g2: c.c.HashToG2WithDomain(data, domain), curveID: c.curveID}
536+
return &G2{g2: c.C.HashToG2WithDomain(data, domain), curveID: c.CurveID}
537537
}
538538

539539
func (c *Curve) ModSub(a, b, m *Zr) *Zr {
540-
return &Zr{zr: c.c.ModSub(a.zr, b.zr, m.zr), curveID: c.curveID}
540+
return &Zr{zr: c.C.ModSub(a.zr, b.zr, m.zr), curveID: c.CurveID}
541541
}
542542

543543
func (c *Curve) ModAdd(a, b, m *Zr) *Zr {
544-
return &Zr{zr: c.c.ModAdd(a.zr, b.zr, m.zr), curveID: c.curveID}
544+
return &Zr{zr: c.C.ModAdd(a.zr, b.zr, m.zr), curveID: c.CurveID}
545545
}
546546

547547
func (c *Curve) ModMul(a1, b1, m *Zr) *Zr {
548-
return &Zr{zr: c.c.ModMul(a1.zr, b1.zr, m.zr), curveID: c.curveID}
548+
return &Zr{zr: c.C.ModMul(a1.zr, b1.zr, m.zr), curveID: c.CurveID}
549549
}
550550

551551
func (c *Curve) ModNeg(a1, m *Zr) *Zr {
552-
return &Zr{zr: c.c.ModNeg(a1.zr, m.zr), curveID: c.curveID}
552+
return &Zr{zr: c.C.ModNeg(a1.zr, m.zr), curveID: c.CurveID}
553553
}

0 commit comments

Comments
 (0)