fix: lint

Author: ginokent

crypto/rand/rand_test.go

@@ -95,7 +95,7 @@ func BenchmarkGenerateRandomString(b *testing.B) {
 		r := randz.NewReader(randz.WithNewReaderOptionRandomReader(mrand.New(mrand.NewSource(0))))
 		buf := make([]byte, 128)
 
-		for i := 0; i < b.N; i++ {
+		for range b.N {
 			_, _ = r.Read(buf)
 		}
 	})
@@ -104,7 +104,7 @@ func BenchmarkGenerateRandomString(b *testing.B) {
 		r := randz.NewReader(randz.WithNewReaderOptionRandomReader(crypto_rand.Reader))
 		buf := make([]byte, 128)
 
-		for i := 0; i < b.N; i++ {
+		for range b.N {
 			_, _ = r.Read(buf)
 		}
 	})

database/sql/rows.go

@@ -169,7 +169,7 @@ func getStructTags(structType reflect.Type, structTag string) []string {
 	}
 
 	tags := make([]string, structType.NumField())
-	for i := 0; structType.NumField() > i; i++ {
+	for i := range structType.NumField() {
 		rawTag := structType.Field(i).Tag.Get(structTag)
 		tags[i] = strings.Split(rawTag, ",")[0]
 	}

jose/jwa/sign_test.go

@@ -500,7 +500,6 @@ var signTestCases = map[string]struct {
 func TestJWSAlgorithm_Sign(t *testing.T) {
 	t.Parallel()
 	for name, testCase := range signTestCases {
-		t, name, testCase := t, name, testCase
 		t.Run(name, func(t *testing.T) {
 			t.Parallel()
 			actual, err := jwa.JWS(testCase.alg).Sign(testCase.key, testCase.signingInput)

jose/jwa/verify_test.go

@@ -435,7 +435,6 @@ var verifyTestCases = map[string]struct {
 func TestJWSAlgorithm_Verify(t *testing.T) {
 	t.Parallel()
 	for name, testCase := range verifyTestCases {
-		t, name, testCase := t, name, testCase
 		t.Run(name, func(t *testing.T) {
 			t.Parallel()
 			testCase.errHandler(t, jwa.JWS(testCase.alg).Verify(testCase.key, testCase.signingInput, testCase.signatureEncoded))

jose/jwk/jwk.go

@@ -11,6 +11,7 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"math"
 	"math/big"
 	"net/http"
 	"time"
@@ -23,6 +24,7 @@ var (
 	ErrCurveNotSupported      = errors.New("jwk: specified curve parameter is not supported")
 	ErrKeyIsNotForAlgorithm   = errors.New("jwk: key is not for algorithm")
 	ErrResponseIsNotCacheable = errors.New("jwk: response is not cacheable")
+	ErrInvalidKey             = errors.New("jwk: invalid key")
 )
 
 // ref. JSON Web Key (JWK) https://www.rfc-editor.org/rfc/rfc7517
@@ -394,19 +396,25 @@ func (jwk *JSONWebKey) EncodeRSAPublicKey(key *rsa.PublicKey, opts ...JSONWebKey
 }
 
 func (jwk *JSONWebKey) DecodeRSAPublicKey() (*rsa.PublicKey, error) {
-	n, err := base64.RawURLEncoding.DecodeString(jwk.N)
+	nByte, err := base64.RawURLEncoding.DecodeString(jwk.N)
 	if err != nil {
 		return nil, fmt.Errorf("base64.RawURLEncoding.DecodeString: JSONWebKey.N=%s: %w", jwk.N, err)
 	}
+	n := big.NewInt(0).SetBytes(nByte)
 
-	e, err := base64.RawURLEncoding.DecodeString(jwk.E)
+	eByte, err := base64.RawURLEncoding.DecodeString(jwk.E)
 	if err != nil {
 		return nil, fmt.Errorf("base64.RawURLEncoding.DecodeString: JSONWebKey.E=%s: %w", jwk.E, err)
 	}
+	eBigInt := big.NewInt(0).SetBytes(eByte)
+	if eBigInt.Uint64() > math.MaxInt {
+		return nil, fmt.Errorf("e=%d: %w", eBigInt.Uint64(), ErrInvalidKey)
+	}
+	e := int(eBigInt.Uint64())
 
 	return &rsa.PublicKey{
-		N: big.NewInt(0).SetBytes(n),
-		E: int(big.NewInt(0).SetBytes(e).Uint64()),
+		N: n,
+		E: e,
 	}, nil
 }
 

math/rand/rand.go

@@ -5,39 +5,39 @@ import (
 	"time"
 )
 
-func Range(min, max int) int {
+func Range(minValue, maxValue int) int {
 	//nolint:gosec
-	return rand.Intn(max-min+1) + min
+	return rand.Intn(maxValue-minValue+1) + minValue
 }
 
-func RangeRand(r *rand.Rand, min, max int) int {
-	return r.Intn(max-min+1) + min
+func RangeRand(r *rand.Rand, minValue, maxValue int) int {
+	return r.Intn(maxValue-minValue+1) + minValue
 }
 
-func Range31(min, max int32) int32 {
+func Range31(minValue, maxValue int32) int32 {
 	//nolint:gosec
-	return rand.Int31n(max-min+1) + min
+	return rand.Int31n(maxValue-minValue+1) + minValue
 }
 
-func Range31Rand(r *rand.Rand, min, max int32) int32 {
-	return r.Int31n(max-min+1) + min
+func Range31Rand(r *rand.Rand, minValue, maxValue int32) int32 {
+	return r.Int31n(maxValue-minValue+1) + minValue
 }
 
-func Range63(min, max int64) int64 {
+func Range63(minValue, maxValue int64) int64 {
 	//nolint:gosec
-	return rand.Int63n(max-min+1) + min
+	return rand.Int63n(maxValue-minValue+1) + minValue
 }
 
-func Range63Rand(r *rand.Rand, min, max int64) int64 {
-	return r.Int63n(max-min+1) + min
+func Range63Rand(r *rand.Rand, minValue, maxValue int64) int64 {
+	return r.Int63n(maxValue-minValue+1) + minValue
 }
 
-func RangeDuration(min, max time.Duration) time.Duration {
+func RangeDuration(minValue, maxValue time.Duration) time.Duration {
 	//nolint:gosec
-	return time.Duration(rand.Int63n(int64(max)-int64(min)+1) + int64(min))
+	return time.Duration(rand.Int63n(int64(maxValue)-int64(minValue)+1) + int64(minValue))
 }
 
-func RangeDurationRand(r *rand.Rand, min, max time.Duration) time.Duration {
+func RangeDurationRand(r *rand.Rand, minValue, maxValue time.Duration) time.Duration {
 	//nolint:gosec
-	return time.Duration(r.Int63n(int64(max)-int64(min)+1) + int64(min))
+	return time.Duration(r.Int63n(int64(maxValue)-int64(minValue)+1) + int64(minValue))
 }

strings/mask_test.go

@@ -26,7 +26,6 @@ func TestMaskPrefix(t *testing.T) {
 		{"mask 4", args{"abcd", "*", 4}, "****"},
 	}
 	for _, tt := range tests {
-		tt := tt
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 			if got := stringz.MaskPrefix(tt.args.s, tt.args.mask, tt.args.unmaskSuffix); got != tt.want {
@@ -56,7 +55,6 @@ func TestMaskSuffix(t *testing.T) {
 		{"mask 4", args{"abcd", "*", 4}, "abcd"},
 	}
 	for _, tt := range tests {
-		tt := tt
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 			if got := stringz.MaskSuffix(tt.args.s, tt.args.mask, tt.args.unmaskPrefix); got != tt.want {

sync/once_test.go

@@ -49,7 +49,6 @@ func TestOnce_Do(t *testing.T) {
 		actual := 0
 		const expect = 10
 		for i := 1; i <= 10; i++ {
-			i := i
 			if err := once.Do(func() error {
 				actual = i
 				return io.EOF // any error