9934826789

Committed 15 Jul 2024 06:36AM UTC coverage: 79.905% (-4.6%) from 84.457%

Build # 9934826789

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #532 from dedis/dependabot/npm_and_yarn/docs/benchmark-app/braces-3.0.3

Bump braces from 3.0.2 to 3.0.3 in /docs/benchmark-app

Run Details

13862 of 17348 relevant lines covered (79.91%)

287091.4 hits per line

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

84.38

/util/encoding/encoding.go

// Package encoding package provides helper functions to encode/decode a Point/Scalar in
// hexadecimal.
package encoding

import (
        "encoding/hex"
        "errors"
        "io"
        "strings"

        "go.dedis.ch/kyber/v4"
)

// ReadHexPoint reads a point from r in hex representation.
func ReadHexPoint(group kyber.Group, r io.Reader) (kyber.Point, error) {
        point := group.Point()
        buf, err := getHex(r, point.MarshalSize())
        if err != nil {
                return nil, err
        }
        err = point.UnmarshalBinary(buf)
        return point, err
}

// WriteHexPoint writes a point in hex representation to w.
func WriteHexPoint(w io.Writer, point kyber.Point) error {
        buf, err := point.MarshalBinary()
        if err != nil {
                return err
        }
        out := hex.EncodeToString(buf)
        _, err = w.Write([]byte(out))
        return err
}

// ReadHexScalar takes a hex-encoded scalar and returns that scalar,
// optionally an error
func ReadHexScalar(group kyber.Group, r io.Reader) (kyber.Scalar, error) {
        s := group.Scalar()
        buf, err := getHex(r, s.MarshalSize())
        if err != nil {
                return nil, err
        }

        err = s.UnmarshalBinary(buf)
        if err != nil {
                return nil, err
        }

        return s, nil
}

// WriteHexScalar converts a scalar key to a hex-string
func WriteHexScalar(_ kyber.Group, w io.Writer, scalar kyber.Scalar) error {
        buf, err := scalar.MarshalBinary()
        if err != nil {
                return err
        }
        out := hex.EncodeToString(buf)
        _, err = w.Write([]byte(out))
        return err
}

// PointToStringHex converts a point to a hexadecimal representation
func PointToStringHex(_ kyber.Group, point kyber.Point) (string, error) {
        pbuf, err := point.MarshalBinary()
        return hex.EncodeToString(pbuf), err
}

// StringHexToPoint reads a hexadecimal representation of a point from a string.
func StringHexToPoint(group kyber.Group, s string) (kyber.Point, error) {
        return ReadHexPoint(group, strings.NewReader(s))
}

// ScalarToStringHex encodes a scalar to hexadecimal.
func ScalarToStringHex(_ kyber.Group, scalar kyber.Scalar) (string, error) {
        sbuf, err := scalar.MarshalBinary()
        return hex.EncodeToString(sbuf), err
}

// StringHexToScalar reads a scalar in hexadecimal from string
func StringHexToScalar(group kyber.Group, str string) (kyber.Scalar, error) {
        return ReadHexScalar(group, strings.NewReader(str))
}

func getHex(r io.Reader, l int) ([]byte, error) {
        bufHex := make([]byte, l*2)
        bufByte := make([]byte, l)
        n, err := r.Read(bufHex)
        if err != nil {
                return nil, err
        }
        if n < len(bufHex) {
                return nil, errors.New("didn't get enough bytes from stream")
        }
        _, err = hex.Decode(bufByte, bufHex)
        if err != nil {
                return nil, err
        }
        return bufByte, nil
}

1	// Package encoding package provides helper functions to encode/decode a Point/Scalar in
2	// hexadecimal.
3	package encoding
4
5	import (
6	"encoding/hex"
7	"errors"
8	"io"
9	"strings"
10
11	"go.dedis.ch/kyber/v4"
12	)
13
14	// ReadHexPoint reads a point from r in hex representation.
15	func ReadHexPoint(group kyber.Group, r io.Reader) (kyber.Point, error) {	12✔
16	point := group.Point()	12✔
17	buf, err := getHex(r, point.MarshalSize())	12✔
18	if err != nil {	18✔
19	return nil, err	6✔
20	}	6✔
21	err = point.UnmarshalBinary(buf)	6✔
22	return point, err	6✔
23	}
24
25	// WriteHexPoint writes a point in hex representation to w.
26	func WriteHexPoint(w io.Writer, point kyber.Point) error {	4✔
27	buf, err := point.MarshalBinary()	4✔
28	if err != nil {	4✔
29	return err	×
30	}	×
31	out := hex.EncodeToString(buf)	4✔
32	_, err = w.Write([]byte(out))	4✔
33	return err	4✔
34	}
35
36	// ReadHexScalar takes a hex-encoded scalar and returns that scalar,
37	// optionally an error
38	func ReadHexScalar(group kyber.Group, r io.Reader) (kyber.Scalar, error) {	6✔
39	s := group.Scalar()	6✔
40	buf, err := getHex(r, s.MarshalSize())	6✔
41	if err != nil {	6✔
42	return nil, err	×
43	}	×
44
45	err = s.UnmarshalBinary(buf)	6✔
46	if err != nil {	6✔
47	return nil, err	×
48	}	×
49
50	return s, nil	6✔
51	}
52
53	// WriteHexScalar converts a scalar key to a hex-string
54	func WriteHexScalar(_ kyber.Group, w io.Writer, scalar kyber.Scalar) error {	4✔
55	buf, err := scalar.MarshalBinary()	4✔
56	if err != nil {	4✔
57	return err	×
58	}	×
59	out := hex.EncodeToString(buf)	4✔
60	_, err = w.Write([]byte(out))	4✔
61	return err	4✔
62	}
63
64	// PointToStringHex converts a point to a hexadecimal representation
65	func PointToStringHex(_ kyber.Group, point kyber.Point) (string, error) {	2✔
66	pbuf, err := point.MarshalBinary()	2✔
67	return hex.EncodeToString(pbuf), err	2✔
68	}	2✔
69
70	// StringHexToPoint reads a hexadecimal representation of a point from a string.
71	func StringHexToPoint(group kyber.Group, s string) (kyber.Point, error) {	2✔
72	return ReadHexPoint(group, strings.NewReader(s))	2✔
73	}	2✔
74
75	// ScalarToStringHex encodes a scalar to hexadecimal.
76	func ScalarToStringHex(_ kyber.Group, scalar kyber.Scalar) (string, error) {	2✔
77	sbuf, err := scalar.MarshalBinary()	2✔
78	return hex.EncodeToString(sbuf), err	2✔
79	}	2✔
80
81	// StringHexToScalar reads a scalar in hexadecimal from string
82	func StringHexToScalar(group kyber.Group, str string) (kyber.Scalar, error) {	2✔
83	return ReadHexScalar(group, strings.NewReader(str))	2✔
84	}	2✔
85
86	func getHex(r io.Reader, l int) ([]byte, error) {	18✔
87	bufHex := make([]byte, l*2)	18✔
88	bufByte := make([]byte, l)	18✔
89	n, err := r.Read(bufHex)	18✔
90	if err != nil {	20✔
91	return nil, err	2✔
92	}	2✔
93	if n < len(bufHex) {	20✔
94	return nil, errors.New("didn't get enough bytes from stream")	4✔
95	}	4✔
96	_, err = hex.Decode(bufByte, bufHex)	12✔
97	if err != nil {	12✔
98	return nil, err	×
99	}	×
100	return bufByte, nil	12✔
101	}

dedis / kyber / 9934826789

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