Enable linter in the CI

.github/workflows/golangci-lint.yml

@@ -0,0 +1,54 @@
+name: Lint
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    types: [opened, synchronize, reopened]
+
+permissions:
+  contents: read
+  # Optional: allow read access to pull request. Use with `only-new-issues` option.
+  # pull-requests: read
+
+jobs:
+  golangci:
+    name: lint
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-go@v3
+        with:
+          go-version: '1.20'
+          cache: false
+      - name: golangci-lint
+        uses: golangci/golangci-lint-action@v4
+        with:
+          # Require: The version of golangci-lint to use.
+          # When `install-mode` is `binary` (default) the value can be v1.2 or v1.2.3 or `latest` to use the latest version.
+          # When `install-mode` is `goinstall` the value can be v1.2.3, `latest`, or the hash of a commit.
+          version: v1.56.2
+
+          # Optional: working directory, useful for monorepos
+          # working-directory: somedir
+
+          # Optional: golangci-lint command line arguments.
+          #
+          # Note: By default, the `.golangci.yml` file should be at the root of the repository.
+          # The location of the configuration file can be changed by using `--config=`
+          # args: --timeout=30m --config=/my/path/.golangci.yml --issues-exit-code=0
+
+          # Optional: show only new issues if it's a pull request. The default value is `false`.
+          # only-new-issues: true
+
+          # Optional: if set to true, then all caching functionality will be completely disabled,
+          #           takes precedence over all other caching options.
+          # skip-cache: true
+
+          # Optional: if set to true, then the action won't cache or restore ~/go/pkg.
+          # skip-pkg-cache: true
+
+          # Optional: if set to true, then the action won't cache or restore ~/.cache/go-build.
+          # skip-build-cache: true
+
+          # Optional: The mode to install golangci-lint. It can be 'binary' or 'goinstall'.
+          # install-mode: "goinstall"

.gitignore

@@ -16,4 +16,5 @@ exit_tunnel
 .DS_Store
 *.cov
 profile.tmp
-Coding/
+Coding/
+.idea/

.golangci.yml

@@ -246,4 +246,3 @@ issues:
     - linters:
         - govet
       text: "shadow: declaration of \"err\" shadows declaration"
-    - path: ".*_decl.go"

Makefile

@@ -7,10 +7,7 @@ generate: tidy
 
 # Coding style static check.
 lint: tidy
-	@echo "Please setup a linter!"
-	#golangci-lint run
-	#staticcheck go list ./...
-
+	golangci-lint run
 
 vet: tidy
 	go vet ./...

encrypt/ecies/ecies.go

@@ -36,13 +36,13 @@ func Encrypt(group kyber.Group, public kyber.Point, message []byte, hash func()
 	// ephemeral key for every ECIES encryption and thus have a fresh
 	// HKDF-derived key for AES-GCM, the nonce for AES-GCM can be an arbitrary
 	// (even static) value. We derive it here simply via HKDF as well.)
-	len := 32 + 12
-	buf, err := deriveKey(hash, dh, len)
+	l := 32 + 12
+	buf, err := deriveKey(hash, dh, l)
 	if err != nil {
 		return nil, err
 	}
 	key := buf[:32]
-	nonce := buf[32:len]
+	nonce := buf[32:l]
 
 	// Encrypt message using AES-GCM
 	aes, err := aes.NewCipher(key)
@@ -91,13 +91,13 @@ func Decrypt(group kyber.Group, private kyber.Scalar, ctx []byte, hash func() ha
 
 	// Compute shared DH key and derive the symmetric key and nonce via HKDF
 	dh := group.Point().Mul(private, R)
-	len := 32 + 12
-	buf, err := deriveKey(hash, dh, len)
+	length := 32 + 12
+	buf, err := deriveKey(hash, dh, length)
 	if err != nil {
 		return nil, err
 	}
 	key := buf[:32]
-	nonce := buf[32:len]
+	nonce := buf[32:length]
 
 	// Decrypt message using AES-GCM
 	aes, err := aes.NewCipher(key)
@@ -111,18 +111,18 @@ func Decrypt(group kyber.Group, private kyber.Scalar, ctx []byte, hash func() ha
 	return aesgcm.Open(nil, nonce, ctx[l:], nil)
 }
 
-func deriveKey(hash func() hash.Hash, dh kyber.Point, len int) ([]byte, error) {
+func deriveKey(hash func() hash.Hash, dh kyber.Point, l int) ([]byte, error) {
 	dhb, err := dh.MarshalBinary()
 	if err != nil {
 		return nil, err
 	}
 	hkdf := hkdf.New(hash, dhb, nil, nil)
-	key := make([]byte, len, len)
+	key := make([]byte, l)
 	n, err := hkdf.Read(key)
 	if err != nil {
 		return nil, err
 	}
-	if n < len {
+	if n < l {
 		return nil, errors.New("ecies: hkdf-derived key too short")
 	}
 	return key, nil

group/curve25519/curve.go

@@ -81,6 +81,41 @@ func (c *curve) NewKey(stream cipher.Stream) kyber.Scalar {
 	return secret
 }
 
+func (c *curve) initBasePoint(self kyber.Group, p *Param, fullGroup bool, base point) {
+	var bx, by *big.Int
+	if fullGroup {
+		bx, by = &p.FBX, &p.FBY
+		base.initXY(&p.FBX, &p.FBY, self)
+	} else {
+		bx, by = &p.PBX, &p.PBY
+	}
+
+	if by.Sign() == 0 {
+		// No standard base point was defined, so pick one.
+		// Find the lowest-numbered y-coordinate that works.
+		var x, y mod.Int
+		for y.Init64(2, &c.P); ; y.Add(&y, &c.one) {
+			if !c.solveForX(&x, &y) {
+				continue // try another y
+			}
+			if c.coordSign(&x) != 0 {
+				x.Neg(&x) // try positive x first
+			}
+			base.initXY(&x.V, &y.V, self)
+			if c.validPoint(base) {
+				break // got one
+			}
+			x.Neg(&x) // try -bx
+			if c.validPoint(base) {
+				break // got one
+			}
+		}
+
+		bx, by = &x.V, &y.V
+	}
+	base.initXY(bx, by, self)
+}
+
 // Initialize a twisted Edwards curve with given parameters.
 // Caller passes pointers to null and base point prototypes to be initialized.
 func (c *curve) init(self kyber.Group, p *Param, fullGroup bool,
@@ -101,10 +136,10 @@ func (c *curve) init(self kyber.Group, p *Param, fullGroup bool,
 	// Note that we do NOT initialize c.order with Init(),
 	// as that would normalize to the modulus, resulting in zero.
 	// Just to be sure it's never used, we leave c.order.M set to nil.
-	// We want it to be in a ModInt so we can pass it to P.Mul(),
+	// We want it to be in a ModInt, so we can pass it to P.Mul(),
 	// but the scalar's modulus isn't needed for point multiplication.
 	if fullGroup {
-		// Scalar modulus is prime-order times the ccofactor
+		// Scalar modulus is prime-order times the cofactor
 		c.order.V.SetInt64(int64(p.R)).Mul(&c.order.V, &p.Q)
 	} else {
 		c.order.V.Set(&p.Q) // Prime-order subgroup
@@ -118,39 +153,7 @@ func (c *curve) init(self kyber.Group, p *Param, fullGroup bool,
 	null.initXY(zero, one, self)
 
 	// Base point B
-	var bx, by *big.Int
-	if !fullGroup {
-		bx, by = &p.PBX, &p.PBY
-	} else {
-		bx, by = &p.FBX, &p.FBY
-		base.initXY(&p.FBX, &p.FBY, self)
-	}
-	if by.Sign() == 0 {
-		// No standard base point was defined, so pick one.
-		// Find the lowest-numbered y-coordinate that works.
-		//println("Picking base point:")
-		var x, y mod.Int
-		for y.Init64(2, &c.P); ; y.Add(&y, &c.one) {
-			if !c.solveForX(&x, &y) {
-				continue // try another y
-			}
-			if c.coordSign(&x) != 0 {
-				x.Neg(&x) // try positive x first
-			}
-			base.initXY(&x.V, &y.V, self)
-			if c.validPoint(base) {
-				break // got one
-			}
-			x.Neg(&x) // try -bx
-			if c.validPoint(base) {
-				break // got one
-			}
-		}
-		//println("BX: "+x.V.String())
-		//println("BY: "+y.V.String())
-		bx, by = &x.V, &y.V
-	}
-	base.initXY(bx, by, self)
+	c.initBasePoint(self, p, fullGroup, base)
 
 	// Sanity checks
 	if !c.validPoint(null) {
@@ -209,7 +212,6 @@ func (c *curve) encodePoint(x, y *mod.Int) []byte {
 func (c *curve) decodePoint(bb []byte, x, y *mod.Int) error {
 
 	// Convert from little-endian
-	//fmt.Printf("decoding:\n%s\n", hex.Dump(bb))
 	b := make([]byte, len(bb))
 	reverse(b, bb)
 
@@ -267,22 +269,19 @@ func (c *curve) onCurve(x, y *mod.Int) bool {
 
 // Sanity-check a point to ensure that it is on the curve
 // and within the appropriate subgroup.
-func (c *curve) validPoint(P point) bool {
+func (c *curve) validPoint(p point) bool {
 
 	// Check on-curve
-	x, y := P.getXY()
+	x, y := p.getXY()
 	if !c.onCurve(x, y) {
 		return false
 	}
 
 	// Check in-subgroup by multiplying by subgroup order
 	Q := c.self.Point()
-	Q.Mul(&c.order, P)
-	if !Q.Equal(c.null) {
-		return false
-	}
+	Q.Mul(&c.order, p)
 
-	return true
+	return Q.Equal(c.null)
 }
 
 // Return number of bytes that can be embedded into points on this curve.
@@ -295,7 +294,7 @@ func (c *curve) embedLen() int {
 
 // Pick a [pseudo-]random curve point with optional embedded data,
 // filling in the point's x,y coordinates
-func (c *curve) embed(P point, data []byte, rand cipher.Stream) {
+func (c *curve) embed(p point, data []byte, rand cipher.Stream) {
 
 	// How much data to embed?
 	dl := c.embedLen()
@@ -334,7 +333,7 @@ func (c *curve) embed(P point, data []byte, rand cipher.Stream) {
 		}
 
 		// Initialize the point
-		P.initXY(&x.V, &y.V, c.self)
+		p.initXY(&x.V, &y.V, c.self)
 		if c.full {
 			// If we're using the full group,
 			// we just need any point on the curve, so we're done.
@@ -347,8 +346,8 @@ func (c *curve) embed(P point, data []byte, rand cipher.Stream) {
 		// we can convert our point into one in the subgroup
 		// simply by multiplying it by the cofactor.
 		if data == nil {
-			P.Mul(&c.cofact, P) // multiply by cofactor
-			if P.Equal(c.null) {
+			p.Mul(&c.cofact, p) // multiply by cofactor
+			if p.Equal(c.null) {
 				continue // unlucky; try again
 			}
 			return
@@ -360,7 +359,7 @@ func (c *curve) embed(P point, data []byte, rand cipher.Stream) {
 		if Q == nil {
 			Q = c.self.Point()
 		}
-		Q.Mul(&c.order, P)
+		Q.Mul(&c.order, p)
 		if Q.Equal(c.null) {
 			return
 		}
@@ -383,12 +382,11 @@ func (c *curve) data(x, y *mod.Int) ([]byte, error) {
 // reverse copies src into dst in byte-reversed order and returns dst,
 // such that src[0] goes into dst[len-1] and vice versa.
 // dst and src may be the same slice but otherwise must not overlap.
-func reverse(dst, src []byte) []byte {
+func reverse(dst, src []byte) {
 	l := len(dst)
 	for i, j := 0, l-1; i < (l+1)/2; {
 		dst[i], dst[j] = src[j], src[i]
 		i++
 		j--
 	}
-	return dst
 }