1221

pending completion

Build # 1221

Build Type

Pull #315

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/dedis/kyber/commit/<a class=hub.com/dedis/kyber/commit/<a class="double-link" href="https://git"><a class=hub.com/dedis/kyber/commit/<a class="double-link" href="https://git"><a class=hub.com/dedis/kyber/commit/5e12ac110e4ded2f4b749c284365b3f9010def17">5e12ac110<a href="https://github.com/dedis/kyber/commit/5e12ac110e4ded2f4b749c284365b3f9010def17">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/dedis/kyber/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/dedis/kyber/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/dedis/kyber/commit/5e12ac110e4ded2f4b749c284365b3f9010def17&quot;&gt;5e12ac110&lt;/a&gt;&lt;a href=&quot;https://github.com/dedis/kyber/commit/5e12ac110e4ded2f4b749c284365b3f9010def17&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/dedis/kyber/commit/5e12ac110e4ded2f4b749c284365b3f9&lt;/a&gt;010def17">&quot;&gt;Merge &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/dedis/kyber/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/dedis/kyber/commit/<a class="double-link" href="https://github.com/dedis/kyber/commit/910ca6b78864e76058f54807f617e930be55f79d">910ca6b78</a><a href="https://github.com/dedis/kyber/commit/5e12ac110e4ded2f4b749c284365b3f9010def17">&amp;quot;&amp;gt;910ca6b78&amp;lt;/a&amp;gt;&amp;quot;&amp;gt;910ca6b78&amp;lt;/a&amp;gt;&amp;lt;a href=&amp;quot;https://github.com/dedis/kyber/commit/5e12ac110e4ded2f4b749c284365b3f9010de&lt;/a&gt;f17&quot;&gt; into &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/dedis/kyber/commit/<a class="double-link" href="https://github.com/dedis/kyber/commit/68d0f6b34">68d0f6b34">68d0f6b34</a>

Pull Request Pull Request #315:

Run Details

59 of 59 new or added lines in 3 files covered. (100.0%)

7939 of 9787 relevant lines covered (81.12%)

232728.35 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

69.96

/pairing/bn256/point.go

package bn256

import (
        "crypto/cipher"
        "crypto/subtle"
        "errors"
        "io"

        "github.com/dedis/kyber"
        "github.com/dedis/kyber/group/mod"
)

type pointG1 struct {
        g *curvePoint
}

func newPointG1() *pointG1 {
        p := &pointG1{g: &curvePoint{}}
        return p
}

func (p *pointG1) Equal(q kyber.Point) bool {
        x, _ := p.MarshalBinary()
        y, _ := q.MarshalBinary()
        return subtle.ConstantTimeCompare(x, y) == 1
}

func (p *pointG1) Null() kyber.Point {
        p.g.SetInfinity()
        return p
}

func (p *pointG1) Base() kyber.Point {
        p.g.Set(curveGen)
        return p
}

func (p *pointG1) Pick(rand cipher.Stream) kyber.Point {
        s := mod.NewInt64(0, Order).Pick(rand)
        p.Base()
        p.g.Mul(p.g, &s.(*mod.Int).V)
        return p
}

func (p *pointG1) Set(q kyber.Point) kyber.Point {
        x := q.(*pointG1).g
        p.g.Set(x)
        return p
}

func (p *pointG1) Clone() kyber.Point {
        q := newPointG1()
        buf, err := p.MarshalBinary()
        if err != nil {
                panic(err)
        }
        if err := q.UnmarshalBinary(buf); err != nil {
                panic(err)
        }
        return q
}

func (p *pointG1) EmbedLen() int {
        panic("bn256.G1: unsupported operation")
}

func (p *pointG1) Embed(data []byte, rand cipher.Stream) kyber.Point {
        // XXX: An approach to implement this is:
        // - Encode data as the x-coordinate of a point on y²=x³+3 where len(data)
        //   is stored in the least significant byte of x and the rest is being
        //   filled with random values, i.e., x = rand || data || len(data).
        // - Use the Tonelli-Shanks algorithm to compute the y-coordinate.
        // - Convert the new point to Jacobian coordinates and set it as p.
        panic("bn256.G1: unsupported operation")
}

func (p *pointG1) Data() ([]byte, error) {
        panic("bn256.G1: unsupported operation")
}

func (p *pointG1) Add(a, b kyber.Point) kyber.Point {
        x := a.(*pointG1).g
        y := b.(*pointG1).g
        p.g.Add(x, y) // p = a + b
        return p
}

func (p *pointG1) Sub(a, b kyber.Point) kyber.Point {
        q := newPointG1()
        return p.Add(a, q.Neg(b))
}

func (p *pointG1) Neg(q kyber.Point) kyber.Point {
        x := q.(*pointG1).g
        p.g.Neg(x)
        return p
}

func (p *pointG1) Mul(s kyber.Scalar, q kyber.Point) kyber.Point {
        if q == nil {
                q = newPointG1().Base()
        }
        t := s.(*mod.Int).V
        r := q.(*pointG1).g
        p.g.Mul(r, &t)
        return p
}

func (p *pointG1) MarshalBinary() ([]byte, error) {
        n := p.ElementSize()
        // Take a copy so that p is not written to, so calls to MarshalBinary
        // are threadsafe.
        pgtemp := *p.g
        pgtemp.MakeAffine()
        ret := make([]byte, p.MarshalSize())
        if pgtemp.IsInfinity() {
                return ret, nil
        }
        tmp := &gfP{}
        montDecode(tmp, &pgtemp.x)
        tmp.Marshal(ret)
        montDecode(tmp, &pgtemp.y)
        tmp.Marshal(ret[n:])
        return ret, nil
}

func (p *pointG1) MarshalTo(w io.Writer) (int, error) {
        buf, err := p.MarshalBinary()
        if err != nil {
                return 0, err
        }
        return w.Write(buf)
}

func (p *pointG1) UnmarshalBinary(buf []byte) error {
        n := p.ElementSize()
        if len(buf) < p.MarshalSize() {
                return errors.New("bn256.G1: not enough data")
        }
        if p.g == nil {
                p.g = &curvePoint{}
        } else {
                p.g.x, p.g.y = gfP{0}, gfP{0}
        }

        p.g.x.Unmarshal(buf)
        p.g.y.Unmarshal(buf[n:])
        montEncode(&p.g.x, &p.g.x)
        montEncode(&p.g.y, &p.g.y)

        zero := gfP{0}
        if p.g.x == zero && p.g.y == zero {
                // This is the point at infinity
                p.g.y = *newGFp(1)
                p.g.z = gfP{0}
                p.g.t = gfP{0}
        } else {
                p.g.z = *newGFp(1)
                p.g.t = *newGFp(1)
        }

        if !p.g.IsOnCurve() {
                return errors.New("bn256.G1: malformed point")
        }

        return nil
}

func (p *pointG1) UnmarshalFrom(r io.Reader) (int, error) {
        buf := make([]byte, p.MarshalSize())
        n, err := io.ReadFull(r, buf)
        if err != nil {
                return n, err
        }
        return n, p.UnmarshalBinary(buf)
}

func (p *pointG1) MarshalSize() int {
        return 2 * p.ElementSize()
}

func (p *pointG1) ElementSize() int {
        return 256 / 8
}

func (p *pointG1) String() string {
        return "bn256.G1:" + p.g.String()
}

type pointG2 struct {
        g *twistPoint
}

func newPointG2() *pointG2 {
        p := &pointG2{g: &twistPoint{}}
        return p
}

func (p *pointG2) Equal(q kyber.Point) bool {
        x, _ := p.MarshalBinary()
        y, _ := q.MarshalBinary()
        return subtle.ConstantTimeCompare(x, y) == 1
}

func (p *pointG2) Null() kyber.Point {
        p.g.SetInfinity()
        return p
}

func (p *pointG2) Base() kyber.Point {
        p.g.Set(twistGen)
        return p
}

func (p *pointG2) Pick(rand cipher.Stream) kyber.Point {
        s := mod.NewInt64(0, Order).Pick(rand)
        p.Base()
        p.g.Mul(p.g, &s.(*mod.Int).V)
        return p
}

func (p *pointG2) Set(q kyber.Point) kyber.Point {
        x := q.(*pointG2).g
        p.g.Set(x)
        return p
}

func (p *pointG2) Clone() kyber.Point {
        q := newPointG2()
        buf, err := p.MarshalBinary()
        if err != nil {
                panic(err)
        }
        if err := q.UnmarshalBinary(buf); err != nil {
                panic(err)
        }
        return q
}

func (p *pointG2) EmbedLen() int {
        panic("bn256.G2: unsupported operation")
}

func (p *pointG2) Embed(data []byte, rand cipher.Stream) kyber.Point {
        panic("bn256.G2: unsupported operation")
}

func (p *pointG2) Data() ([]byte, error) {
        panic("bn256.G2: unsupported operation")
}

func (p *pointG2) Add(a, b kyber.Point) kyber.Point {
        x := a.(*pointG2).g
        y := b.(*pointG2).g
        p.g.Add(x, y) // p = a + b
        return p
}

func (p *pointG2) Sub(a, b kyber.Point) kyber.Point {
        q := newPointG2()
        return p.Add(a, q.Neg(b))
}

func (p *pointG2) Neg(q kyber.Point) kyber.Point {
        x := q.(*pointG2).g
        p.g.Neg(x)
        return p
}

func (p *pointG2) Mul(s kyber.Scalar, q kyber.Point) kyber.Point {
        if q == nil {
                q = newPointG2().Base()
        }
        t := s.(*mod.Int).V
        r := q.(*pointG2).g
        p.g.Mul(r, &t)
        return p
}

func (p *pointG2) MarshalBinary() ([]byte, error) {
        n := p.ElementSize()
        if p.g == nil {
                p.g = &twistPoint{}
        }

        p.g.MakeAffine()
        if p.g.IsInfinity() {
                return make([]byte, 1), nil
        }

        ret := make([]byte, p.MarshalSize())
        ret[0] = 0x01
        temp := &gfP{}

        montDecode(temp, &p.g.x.x)
        temp.Marshal(ret[1+0*n:])
        montDecode(temp, &p.g.x.y)
        temp.Marshal(ret[1+1*n:])
        montDecode(temp, &p.g.y.x)
        temp.Marshal(ret[1+2*n:])
        montDecode(temp, &p.g.y.y)
        temp.Marshal(ret[1+3*n:])

        return ret, nil
}

func (p *pointG2) MarshalTo(w io.Writer) (int, error) {
        buf, err := p.MarshalBinary()
        if err != nil {
                return 0, err
        }
        return w.Write(buf)
}

func (p *pointG2) UnmarshalBinary(buf []byte) error {
        n := p.ElementSize()
        if p.g == nil {
                p.g = &twistPoint{}
        }

        if len(buf) > 0 && buf[0] == 0x00 {
                p.g.SetInfinity()
                //return buf[1:], nil
                return nil
        } else if len(buf) > 0 && buf[0] != 0x01 {
                return errors.New("bn256.G2: malformed point")
        } else if len(buf) < p.MarshalSize() {
                return errors.New("bn256.G2: not enough data")
        }

        p.g.x.x.Unmarshal(buf[1+0*n:])
        p.g.x.y.Unmarshal(buf[1+1*n:])
        p.g.y.x.Unmarshal(buf[1+2*n:])
        p.g.y.y.Unmarshal(buf[1+3*n:])
        montEncode(&p.g.x.x, &p.g.x.x)
        montEncode(&p.g.x.y, &p.g.x.y)
        montEncode(&p.g.y.x, &p.g.y.x)
        montEncode(&p.g.y.y, &p.g.y.y)

        if p.g.x.IsZero() && p.g.y.IsZero() {
                // This is the point at infinity.
                p.g.y.SetOne()
                p.g.z.SetZero()
                p.g.t.SetZero()
        } else {
                p.g.z.SetOne()
                p.g.t.SetOne()

                if !p.g.IsOnCurve() {
                        return errors.New("bn256.G2: malformed point")
                }
        }
        return nil
}

func (p *pointG2) UnmarshalFrom(r io.Reader) (int, error) {
        buf := make([]byte, p.MarshalSize())
        n, err := io.ReadFull(r, buf)
        if err != nil {
                return n, err
        }
        return n, p.UnmarshalBinary(buf)
}

func (p *pointG2) MarshalSize() int {
        return 4*p.ElementSize() + 1
}

func (p *pointG2) ElementSize() int {
        return 256 / 8
}

func (p *pointG2) String() string {
        return "bn256.G2:" + p.g.String()
}

type pointGT struct {
        g *gfP12
}

func newPointGT() *pointGT {
        p := &pointGT{g: &gfP12{}}
        return p
}

func (p *pointGT) Equal(q kyber.Point) bool {
        x, _ := p.MarshalBinary()
        y, _ := q.MarshalBinary()
        return subtle.ConstantTimeCompare(x, y) == 1
}

func (p *pointGT) Null() kyber.Point {
        p.g.Set(gfP12Inf)
        return p
}

func (p *pointGT) Base() kyber.Point {
        p.g.Set(gfP12Gen)
        return p
}

func (p *pointGT) Pick(rand cipher.Stream) kyber.Point {
        s := mod.NewInt64(0, Order).Pick(rand)
        p.Base()
        p.g.Exp(p.g, &s.(*mod.Int).V)
        return p
}

func (p *pointGT) Set(q kyber.Point) kyber.Point {
        x := q.(*pointGT).g
        p.g.Set(x)
        return p
}

func (p *pointGT) Clone() kyber.Point {
        q := newPointGT()
        buf, err := p.MarshalBinary()
        if err != nil {
                panic(err)
        }
        if err := q.UnmarshalBinary(buf); err != nil {
                panic(err)
        }
        return q
}

func (p *pointGT) EmbedLen() int {
        panic("bn256.GT: unsupported operation")
}

func (p *pointGT) Embed(data []byte, rand cipher.Stream) kyber.Point {
        panic("bn256.GT: unsupported operation")
}

func (p *pointGT) Data() ([]byte, error) {
        panic("bn256.GT: unsupported operation")
}

func (p *pointGT) Add(a, b kyber.Point) kyber.Point {
        x := a.(*pointGT).g
        y := b.(*pointGT).g
        p.g.Mul(x, y)
        return p
}

func (p *pointGT) Sub(a, b kyber.Point) kyber.Point {
        q := newPointGT()
        return p.Add(a, q.Neg(b))
}

func (p *pointGT) Neg(q kyber.Point) kyber.Point {
        x := q.(*pointGT).g
        p.g.Conjugate(x)
        return p
}

func (p *pointGT) Mul(s kyber.Scalar, q kyber.Point) kyber.Point {
        if q == nil {
                q = newPointGT().Base()
        }
        t := s.(*mod.Int).V
        r := q.(*pointGT).g
        p.g.Exp(r, &t)
        return p
}

func (p *pointGT) MarshalBinary() ([]byte, error) {
        n := p.ElementSize()
        ret := make([]byte, p.MarshalSize())
        temp := &gfP{}

        montDecode(temp, &p.g.x.x.x)
        temp.Marshal(ret[0*n:])
        montDecode(temp, &p.g.x.x.y)
        temp.Marshal(ret[1*n:])
        montDecode(temp, &p.g.x.y.x)
        temp.Marshal(ret[2*n:])
        montDecode(temp, &p.g.x.y.y)
        temp.Marshal(ret[3*n:])
        montDecode(temp, &p.g.x.z.x)
        temp.Marshal(ret[4*n:])
        montDecode(temp, &p.g.x.z.y)
        temp.Marshal(ret[5*n:])
        montDecode(temp, &p.g.y.x.x)
        temp.Marshal(ret[6*n:])
        montDecode(temp, &p.g.y.x.y)
        temp.Marshal(ret[7*n:])
        montDecode(temp, &p.g.y.y.x)
        temp.Marshal(ret[8*n:])
        montDecode(temp, &p.g.y.y.y)
        temp.Marshal(ret[9*n:])
        montDecode(temp, &p.g.y.z.x)
        temp.Marshal(ret[10*n:])
        montDecode(temp, &p.g.y.z.y)
        temp.Marshal(ret[11*n:])

        return ret, nil
}

func (p *pointGT) MarshalTo(w io.Writer) (int, error) {
        buf, err := p.MarshalBinary()
        if err != nil {
                return 0, err
        }
        return w.Write(buf)
}

func (p *pointGT) UnmarshalBinary(buf []byte) error {
        n := p.ElementSize()
        if len(buf) < p.MarshalSize() {
                return errors.New("bn256.GT: not enough data")
        }

        if p.g == nil {
                p.g = &gfP12{}
        }

        p.g.x.x.x.Unmarshal(buf[0*n:])
        p.g.x.x.y.Unmarshal(buf[1*n:])
        p.g.x.y.x.Unmarshal(buf[2*n:])
        p.g.x.y.y.Unmarshal(buf[3*n:])
        p.g.x.z.x.Unmarshal(buf[4*n:])
        p.g.x.z.y.Unmarshal(buf[5*n:])
        p.g.y.x.x.Unmarshal(buf[6*n:])
        p.g.y.x.y.Unmarshal(buf[7*n:])
        p.g.y.y.x.Unmarshal(buf[8*n:])
        p.g.y.y.y.Unmarshal(buf[9*n:])
        p.g.y.z.x.Unmarshal(buf[10*n:])
        p.g.y.z.y.Unmarshal(buf[11*n:])
        montEncode(&p.g.x.x.x, &p.g.x.x.x)
        montEncode(&p.g.x.x.y, &p.g.x.x.y)
        montEncode(&p.g.x.y.x, &p.g.x.y.x)
        montEncode(&p.g.x.y.y, &p.g.x.y.y)
        montEncode(&p.g.x.z.x, &p.g.x.z.x)
        montEncode(&p.g.x.z.y, &p.g.x.z.y)
        montEncode(&p.g.y.x.x, &p.g.y.x.x)
        montEncode(&p.g.y.x.y, &p.g.y.x.y)
        montEncode(&p.g.y.y.x, &p.g.y.y.x)
        montEncode(&p.g.y.y.y, &p.g.y.y.y)
        montEncode(&p.g.y.z.x, &p.g.y.z.x)
        montEncode(&p.g.y.z.y, &p.g.y.z.y)

        // TODO: check if point is on curve

        return nil
}

func (p *pointGT) UnmarshalFrom(r io.Reader) (int, error) {
        buf := make([]byte, p.MarshalSize())
        n, err := io.ReadFull(r, buf)
        if err != nil {
                return n, err
        }
        return n, p.UnmarshalBinary(buf)
}

func (p *pointGT) MarshalSize() int {
        return 12 * p.ElementSize()
}

func (p *pointGT) ElementSize() int {
        return 256 / 8
}

func (p *pointGT) String() string {
        return "bn256.GT:" + p.g.String()
}

func (p *pointGT) Finalize() kyber.Point {
        buf := finalExponentiation(p.g)
        p.g.Set(buf)
        return p
}

func (p *pointGT) Miller(p1, p2 kyber.Point) kyber.Point {
        a := p1.(*pointG1).g
        b := p2.(*pointG2).g
        p.g.Set(miller(b, a))
        return p
}

func (p *pointGT) Pair(p1, p2 kyber.Point) kyber.Point {
        a := p1.(*pointG1).g
        b := p2.(*pointG2).g
        p.g.Set(optimalAte(b, a))
        return p
}

1	package bn256
2
3	import (
4	"crypto/cipher"
5	"crypto/subtle"
6	"errors"
7	"io"
8
9	"github.com/dedis/kyber"
10	"github.com/dedis/kyber/group/mod"
11	)
12
13	type pointG1 struct {
14	g *curvePoint
15	}
16
17	func newPointG1() *pointG1 {	25✔
18	p := &pointG1{g: &curvePoint{}}	25✔
19	return p	25✔
20	}	25✔
21
22	func (p *pointG1) Equal(q kyber.Point) bool {	4✔
23	x, _ := p.MarshalBinary()	4✔
24	y, _ := q.MarshalBinary()	4✔
25	return subtle.ConstantTimeCompare(x, y) == 1	4✔
26	}	4✔
27
28	func (p *pointG1) Null() kyber.Point {	1✔
29	p.g.SetInfinity()	1✔
30	return p	1✔
31	}	1✔
32
33	func (p *pointG1) Base() kyber.Point {	12✔
34	p.g.Set(curveGen)	12✔
35	return p	12✔
36	}	12✔
37
38	func (p *pointG1) Pick(rand cipher.Stream) kyber.Point {	2✔
39	s := mod.NewInt64(0, Order).Pick(rand)	2✔
40	p.Base()	2✔
41	p.g.Mul(p.g, &s.(*mod.Int).V)	2✔
42	return p	2✔
43	}	2✔
44
45	func (p *pointG1) Set(q kyber.Point) kyber.Point {	×
46	x := q.(*pointG1).g	×
47	p.g.Set(x)	×
48	return p	×
49	}	×
50
51	func (p *pointG1) Clone() kyber.Point {	1✔
52	q := newPointG1()	1✔
53	buf, err := p.MarshalBinary()	1✔
54	if err != nil {	1✔
55	panic(err)	×
56	}
57	if err := q.UnmarshalBinary(buf); err != nil {	1✔
58	panic(err)	×
59	}
60	return q	1✔
61	}
62
63	func (p *pointG1) EmbedLen() int {	×
64	panic("bn256.G1: unsupported operation")	×
65	}
66
67	func (p *pointG1) Embed(data []byte, rand cipher.Stream) kyber.Point {	×
68	// XXX: An approach to implement this is:	×
69	// - Encode data as the x-coordinate of a point on y²=x³+3 where len(data)	×
70	// is stored in the least significant byte of x and the rest is being	×
71	// filled with random values, i.e., x = rand \|\| data \|\| len(data).	×
72	// - Use the Tonelli-Shanks algorithm to compute the y-coordinate.	×
73	// - Convert the new point to Jacobian coordinates and set it as p.	×
74	panic("bn256.G1: unsupported operation")	×
75	}
76
77	func (p *pointG1) Data() ([]byte, error) {	×
78	panic("bn256.G1: unsupported operation")	×
79	}
80
81	func (p *pointG1) Add(a, b kyber.Point) kyber.Point {	4✔
82	x := a.(*pointG1).g	4✔
83	y := b.(*pointG1).g	4✔
84	p.g.Add(x, y) // p = a + b	4✔
85	return p	4✔
86	}	4✔
87
88	func (p *pointG1) Sub(a, b kyber.Point) kyber.Point {	1✔
89	q := newPointG1()	1✔
90	return p.Add(a, q.Neg(b))	1✔
91	}	1✔
92
93	func (p *pointG1) Neg(q kyber.Point) kyber.Point {	3✔
94	x := q.(*pointG1).g	3✔
95	p.g.Neg(x)	3✔
96	return p	3✔
97	}	3✔
98
99	func (p *pointG1) Mul(s kyber.Scalar, q kyber.Point) kyber.Point {	8✔
100	if q == nil {	16✔
101	q = newPointG1().Base()	8✔
102	}	8✔
103	t := s.(*mod.Int).V	8✔
104	r := q.(*pointG1).g	8✔
105	p.g.Mul(r, &t)	8✔
106	return p	8✔
107	}
108
109	func (p *pointG1) MarshalBinary() ([]byte, error) {	12✔
110	n := p.ElementSize()	12✔
111	// Take a copy so that p is not written to, so calls to MarshalBinary	12✔
112	// are threadsafe.	12✔
113	pgtemp := *p.g	12✔
114	pgtemp.MakeAffine()	12✔
115	ret := make([]byte, p.MarshalSize())	12✔
116	if pgtemp.IsInfinity() {	12✔
117	return ret, nil	×
118	}	×
119	tmp := &gfP{}	12✔
120	montDecode(tmp, &pgtemp.x)	12✔
121	tmp.Marshal(ret)	12✔
122	montDecode(tmp, &pgtemp.y)	12✔
123	tmp.Marshal(ret[n:])	12✔
124	return ret, nil	12✔
125	}
126
127	func (p *pointG1) MarshalTo(w io.Writer) (int, error) {	×
128	buf, err := p.MarshalBinary()	×
129	if err != nil {	×
130	return 0, err	×
131	}	×
132	return w.Write(buf)	×
133	}
134
135	func (p *pointG1) UnmarshalBinary(buf []byte) error {	2✔
136	n := p.ElementSize()	2✔
137	if len(buf) < p.MarshalSize() {	2✔
138	return errors.New("bn256.G1: not enough data")	×
139	}	×
140	if p.g == nil {	2✔
141	p.g = &curvePoint{}	×
142	} else {	2✔
143	p.g.x, p.g.y = gfP{0}, gfP{0}	2✔
144	}	2✔
145
146	p.g.x.Unmarshal(buf)	2✔
147	p.g.y.Unmarshal(buf[n:])	2✔
148	montEncode(&p.g.x, &p.g.x)	2✔
149	montEncode(&p.g.y, &p.g.y)	2✔
150		2✔
151	zero := gfP{0}	2✔
152	if p.g.x == zero && p.g.y == zero {	2✔
153	// This is the point at infinity	×
154	p.g.y = *newGFp(1)	×
155	p.g.z = gfP{0}	×
156	p.g.t = gfP{0}	×
157	} else {	2✔
158	p.g.z = *newGFp(1)	2✔
159	p.g.t = *newGFp(1)	2✔
160	}	2✔
161
162	if !p.g.IsOnCurve() {	2✔
163	return errors.New("bn256.G1: malformed point")	×
164	}	×
165
166	return nil	2✔
167	}
168
169	func (p *pointG1) UnmarshalFrom(r io.Reader) (int, error) {	×
170	buf := make([]byte, p.MarshalSize())	×
171	n, err := io.ReadFull(r, buf)	×
172	if err != nil {	×
173	return n, err	×
174	}	×
175	return n, p.UnmarshalBinary(buf)	×
176	}
177
178	func (p *pointG1) MarshalSize() int {	14✔
179	return 2 * p.ElementSize()	14✔
180	}	14✔
181
182	func (p *pointG1) ElementSize() int {	28✔
183	return 256 / 8	28✔
184	}	28✔
185
186	func (p *pointG1) String() string {	×
187	return "bn256.G1:" + p.g.String()	×
188	}	×
189
190	type pointG2 struct {
191	g *twistPoint
192	}
193
194	func newPointG2() *pointG2 {	25✔
195	p := &pointG2{g: &twistPoint{}}	25✔
196	return p	25✔
197	}	25✔
198
199	func (p *pointG2) Equal(q kyber.Point) bool {	4✔
200	x, _ := p.MarshalBinary()	4✔
201	y, _ := q.MarshalBinary()	4✔
202	return subtle.ConstantTimeCompare(x, y) == 1	4✔
203	}	4✔
204
205	func (p *pointG2) Null() kyber.Point {	1✔
206	p.g.SetInfinity()	1✔
207	return p	1✔
208	}	1✔
209
210	func (p *pointG2) Base() kyber.Point {	12✔
211	p.g.Set(twistGen)	12✔
212	return p	12✔
213	}	12✔
214
215	func (p *pointG2) Pick(rand cipher.Stream) kyber.Point {	2✔
216	s := mod.NewInt64(0, Order).Pick(rand)	2✔
217	p.Base()	2✔
218	p.g.Mul(p.g, &s.(*mod.Int).V)	2✔
219	return p	2✔
220	}	2✔
221
222	func (p *pointG2) Set(q kyber.Point) kyber.Point {	×
223	x := q.(*pointG2).g	×
224	p.g.Set(x)	×
225	return p	×
226	}	×
227
228	func (p *pointG2) Clone() kyber.Point {	1✔
229	q := newPointG2()	1✔
230	buf, err := p.MarshalBinary()	1✔
231	if err != nil {	1✔
232	panic(err)	×
233	}
234	if err := q.UnmarshalBinary(buf); err != nil {	1✔
235	panic(err)	×
236	}
237	return q	1✔
238	}
239
240	func (p *pointG2) EmbedLen() int {	×
241	panic("bn256.G2: unsupported operation")	×
242	}
243
244	func (p *pointG2) Embed(data []byte, rand cipher.Stream) kyber.Point {	×
245	panic("bn256.G2: unsupported operation")	×
246	}
247
248	func (p *pointG2) Data() ([]byte, error) {	×
249	panic("bn256.G2: unsupported operation")	×
250	}
251
252	func (p *pointG2) Add(a, b kyber.Point) kyber.Point {	4✔
253	x := a.(*pointG2).g	4✔
254	y := b.(*pointG2).g	4✔
255	p.g.Add(x, y) // p = a + b	4✔
256	return p	4✔
257	}	4✔
258
259	func (p *pointG2) Sub(a, b kyber.Point) kyber.Point {	1✔
260	q := newPointG2()	1✔
261	return p.Add(a, q.Neg(b))	1✔
262	}	1✔
263
264	func (p *pointG2) Neg(q kyber.Point) kyber.Point {	3✔
265	x := q.(*pointG2).g	3✔
266	p.g.Neg(x)	3✔
267	return p	3✔
268	}	3✔
269
270	func (p *pointG2) Mul(s kyber.Scalar, q kyber.Point) kyber.Point {	8✔
271	if q == nil {	16✔
272	q = newPointG2().Base()	8✔
273	}	8✔
274	t := s.(*mod.Int).V	8✔
275	r := q.(*pointG2).g	8✔
276	p.g.Mul(r, &t)	8✔
277	return p	8✔
278	}
279
280	func (p *pointG2) MarshalBinary() ([]byte, error) {	12✔
281	n := p.ElementSize()	12✔
282	if p.g == nil {	12✔
283	p.g = &twistPoint{}	×
284	}	×
285
286	p.g.MakeAffine()	12✔
287	if p.g.IsInfinity() {	12✔
288	return make([]byte, 1), nil	×
289	}	×
290
291	ret := make([]byte, p.MarshalSize())	12✔
292	ret[0] = 0x01	12✔
293	temp := &gfP{}	12✔
294		12✔
295	montDecode(temp, &p.g.x.x)	12✔
296	temp.Marshal(ret[1+0*n:])	12✔
297	montDecode(temp, &p.g.x.y)	12✔
298	temp.Marshal(ret[1+1*n:])	12✔
299	montDecode(temp, &p.g.y.x)	12✔
300	temp.Marshal(ret[1+2*n:])	12✔
301	montDecode(temp, &p.g.y.y)	12✔
302	temp.Marshal(ret[1+3*n:])	12✔
303		12✔
304	return ret, nil	12✔
305	}
306
307	func (p *pointG2) MarshalTo(w io.Writer) (int, error) {	×
308	buf, err := p.MarshalBinary()	×
309	if err != nil {	×
310	return 0, err	×
311	}	×
312	return w.Write(buf)	×
313	}
314
315	func (p *pointG2) UnmarshalBinary(buf []byte) error {	2✔
316	n := p.ElementSize()	2✔
317	if p.g == nil {	2✔
318	p.g = &twistPoint{}	×
319	}	×
320
321	if len(buf) > 0 && buf[0] == 0x00 {	2✔
322	p.g.SetInfinity()	×
323	//return buf[1:], nil	×
324	return nil	×
325	} else if len(buf) > 0 && buf[0] != 0x01 {	2✔
326	return errors.New("bn256.G2: malformed point")	×
327	} else if len(buf) < p.MarshalSize() {	2✔
328	return errors.New("bn256.G2: not enough data")	×
329	}	×
330
331	p.g.x.x.Unmarshal(buf[1+0*n:])	2✔
332	p.g.x.y.Unmarshal(buf[1+1*n:])	2✔
333	p.g.y.x.Unmarshal(buf[1+2*n:])	2✔
334	p.g.y.y.Unmarshal(buf[1+3*n:])	2✔
335	montEncode(&p.g.x.x, &p.g.x.x)	2✔
336	montEncode(&p.g.x.y, &p.g.x.y)	2✔
337	montEncode(&p.g.y.x, &p.g.y.x)	2✔
338	montEncode(&p.g.y.y, &p.g.y.y)	2✔
339		2✔
340	if p.g.x.IsZero() && p.g.y.IsZero() {	2✔
341	// This is the point at infinity.	×
342	p.g.y.SetOne()	×
343	p.g.z.SetZero()	×
344	p.g.t.SetZero()	×
345	} else {	2✔
346	p.g.z.SetOne()	2✔
347	p.g.t.SetOne()	2✔
348		2✔
349	if !p.g.IsOnCurve() {	2✔
350	return errors.New("bn256.G2: malformed point")	×
351	}	×
352	}
353	return nil	2✔
354	}
355
356	func (p *pointG2) UnmarshalFrom(r io.Reader) (int, error) {	×
357	buf := make([]byte, p.MarshalSize())	×
358	n, err := io.ReadFull(r, buf)	×
359	if err != nil {	×
360	return n, err	×
361	}	×
362	return n, p.UnmarshalBinary(buf)	×
363	}
364
365	func (p *pointG2) MarshalSize() int {	14✔
366	return 4*p.ElementSize() + 1	14✔
367	}	14✔
368
369	func (p *pointG2) ElementSize() int {	28✔
370	return 256 / 8	28✔
371	}	28✔
372
373	func (p *pointG2) String() string {	×
374	return "bn256.G2:" + p.g.String()	×
375	}	×
376
377	type pointGT struct {
378	g *gfP12
379	}
380
381	func newPointGT() *pointGT {	27✔
382	p := &pointGT{g: &gfP12{}}	27✔
383	return p	27✔
384	}	27✔
385
386	func (p *pointGT) Equal(q kyber.Point) bool {	4✔
387	x, _ := p.MarshalBinary()	4✔
388	y, _ := q.MarshalBinary()	4✔
389	return subtle.ConstantTimeCompare(x, y) == 1	4✔
390	}	4✔
391
392	func (p *pointGT) Null() kyber.Point {	1✔
393	p.g.Set(gfP12Inf)	1✔
394	return p	1✔
395	}	1✔
396
397	func (p *pointGT) Base() kyber.Point {	8✔
398	p.g.Set(gfP12Gen)	8✔
399	return p	8✔
400	}	8✔
401
402	func (p *pointGT) Pick(rand cipher.Stream) kyber.Point {	2✔
403	s := mod.NewInt64(0, Order).Pick(rand)	2✔
404	p.Base()	2✔
405	p.g.Exp(p.g, &s.(*mod.Int).V)	2✔
406	return p	2✔
407	}	2✔
408
409	func (p *pointGT) Set(q kyber.Point) kyber.Point {	×
410	x := q.(*pointGT).g	×
411	p.g.Set(x)	×
412	return p	×
413	}	×
414
415	func (p *pointGT) Clone() kyber.Point {	1✔
416	q := newPointGT()	1✔
417	buf, err := p.MarshalBinary()	1✔
418	if err != nil {	1✔
419	panic(err)	×
420	}
421	if err := q.UnmarshalBinary(buf); err != nil {	1✔
422	panic(err)	×
423	}
424	return q	1✔
425	}
426
427	func (p *pointGT) EmbedLen() int {	×
428	panic("bn256.GT: unsupported operation")	×
429	}
430
431	func (p *pointGT) Embed(data []byte, rand cipher.Stream) kyber.Point {	×
432	panic("bn256.GT: unsupported operation")	×
433	}
434
435	func (p *pointGT) Data() ([]byte, error) {	×
436	panic("bn256.GT: unsupported operation")	×
437	}
438
439	func (p *pointGT) Add(a, b kyber.Point) kyber.Point {	4✔
440	x := a.(*pointGT).g	4✔
441	y := b.(*pointGT).g	4✔
442	p.g.Mul(x, y)	4✔
443	return p	4✔
444	}	4✔
445
446	func (p *pointGT) Sub(a, b kyber.Point) kyber.Point {	1✔
447	q := newPointGT()	1✔
448	return p.Add(a, q.Neg(b))	1✔
449	}	1✔
450
451	func (p *pointGT) Neg(q kyber.Point) kyber.Point {	3✔
452	x := q.(*pointGT).g	3✔
453	p.g.Conjugate(x)	3✔
454	return p	3✔
455	}	3✔
456
457	func (p *pointGT) Mul(s kyber.Scalar, q kyber.Point) kyber.Point {	9✔
458	if q == nil {	13✔
459	q = newPointGT().Base()	4✔
460	}	4✔
461	t := s.(*mod.Int).V	9✔
462	r := q.(*pointGT).g	9✔
463	p.g.Exp(r, &t)	9✔
464	return p	9✔
465	}
466
467	func (p *pointGT) MarshalBinary() ([]byte, error) {	13✔
468	n := p.ElementSize()	13✔
469	ret := make([]byte, p.MarshalSize())	13✔
470	temp := &gfP{}	13✔
471		13✔
472	montDecode(temp, &p.g.x.x.x)	13✔
473	temp.Marshal(ret[0*n:])	13✔
474	montDecode(temp, &p.g.x.x.y)	13✔
475	temp.Marshal(ret[1*n:])	13✔
476	montDecode(temp, &p.g.x.y.x)	13✔
477	temp.Marshal(ret[2*n:])	13✔
478	montDecode(temp, &p.g.x.y.y)	13✔
479	temp.Marshal(ret[3*n:])	13✔
480	montDecode(temp, &p.g.x.z.x)	13✔
481	temp.Marshal(ret[4*n:])	13✔
482	montDecode(temp, &p.g.x.z.y)	13✔
483	temp.Marshal(ret[5*n:])	13✔
484	montDecode(temp, &p.g.y.x.x)	13✔
485	temp.Marshal(ret[6*n:])	13✔
486	montDecode(temp, &p.g.y.x.y)	13✔
487	temp.Marshal(ret[7*n:])	13✔
488	montDecode(temp, &p.g.y.y.x)	13✔
489	temp.Marshal(ret[8*n:])	13✔
490	montDecode(temp, &p.g.y.y.y)	13✔
491	temp.Marshal(ret[9*n:])	13✔
492	montDecode(temp, &p.g.y.z.x)	13✔
493	temp.Marshal(ret[10*n:])	13✔
494	montDecode(temp, &p.g.y.z.y)	13✔
495	temp.Marshal(ret[11*n:])	13✔
496		13✔
497	return ret, nil	13✔
498	}	13✔
499
500	func (p *pointGT) MarshalTo(w io.Writer) (int, error) {	×
501	buf, err := p.MarshalBinary()	×
502	if err != nil {	×
503	return 0, err	×
504	}	×
505	return w.Write(buf)	×
506	}
507
508	func (p *pointGT) UnmarshalBinary(buf []byte) error {	2✔
509	n := p.ElementSize()	2✔
510	if len(buf) < p.MarshalSize() {	2✔
511	return errors.New("bn256.GT: not enough data")	×
512	}	×
513
514	if p.g == nil {	2✔
515	p.g = &gfP12{}	×
516	}	×
517
518	p.g.x.x.x.Unmarshal(buf[0*n:])	2✔
519	p.g.x.x.y.Unmarshal(buf[1*n:])	2✔
520	p.g.x.y.x.Unmarshal(buf[2*n:])	2✔
521	p.g.x.y.y.Unmarshal(buf[3*n:])	2✔
522	p.g.x.z.x.Unmarshal(buf[4*n:])	2✔
523	p.g.x.z.y.Unmarshal(buf[5*n:])	2✔
524	p.g.y.x.x.Unmarshal(buf[6*n:])	2✔
525	p.g.y.x.y.Unmarshal(buf[7*n:])	2✔
526	p.g.y.y.x.Unmarshal(buf[8*n:])	2✔
527	p.g.y.y.y.Unmarshal(buf[9*n:])	2✔
528	p.g.y.z.x.Unmarshal(buf[10*n:])	2✔
529	p.g.y.z.y.Unmarshal(buf[11*n:])	2✔
530	montEncode(&p.g.x.x.x, &p.g.x.x.x)	2✔
531	montEncode(&p.g.x.x.y, &p.g.x.x.y)	2✔
532	montEncode(&p.g.x.y.x, &p.g.x.y.x)	2✔
533	montEncode(&p.g.x.y.y, &p.g.x.y.y)	2✔
534	montEncode(&p.g.x.z.x, &p.g.x.z.x)	2✔
535	montEncode(&p.g.x.z.y, &p.g.x.z.y)	2✔
536	montEncode(&p.g.y.x.x, &p.g.y.x.x)	2✔
537	montEncode(&p.g.y.x.y, &p.g.y.x.y)	2✔
538	montEncode(&p.g.y.y.x, &p.g.y.y.x)	2✔
539	montEncode(&p.g.y.y.y, &p.g.y.y.y)	2✔
540	montEncode(&p.g.y.z.x, &p.g.y.z.x)	2✔
541	montEncode(&p.g.y.z.y, &p.g.y.z.y)	2✔
542		2✔
543	// TODO: check if point is on curve	2✔
544		2✔
545	return nil	2✔
546	}
547
548	func (p *pointGT) UnmarshalFrom(r io.Reader) (int, error) {	×
549	buf := make([]byte, p.MarshalSize())	×
550	n, err := io.ReadFull(r, buf)	×
551	if err != nil {	×
552	return n, err	×
553	}	×
554	return n, p.UnmarshalBinary(buf)	×
555	}
556
557	func (p *pointGT) MarshalSize() int {	15✔
558	return 12 * p.ElementSize()	15✔
559	}	15✔
560
561	func (p *pointGT) ElementSize() int {	30✔
562	return 256 / 8	30✔
563	}	30✔
564
565	func (p *pointGT) String() string {	×
566	return "bn256.GT:" + p.g.String()	×
567	}	×
568
569	func (p *pointGT) Finalize() kyber.Point {	×
570	buf := finalExponentiation(p.g)	×
571	p.g.Set(buf)	×
572	return p	×
573	}	×
574
575	func (p *pointGT) Miller(p1, p2 kyber.Point) kyber.Point {	×
576	a := p1.(*pointG1).g	×
577	b := p2.(*pointG2).g	×
578	p.g.Set(miller(b, a))	×
579	return p	×
580	}	×
581
582	func (p *pointGT) Pair(p1, p2 kyber.Point) kyber.Point {	5✔
583	a := p1.(*pointG1).g	5✔
584	b := p2.(*pointG2).g	5✔
585	p.g.Set(optimalAte(b, a))	5✔
586	return p	5✔
587	}	5✔

dedis / kyber / 1221

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous