chore: Fix linter issues

Author: lubux

.golangci.yml

@@ -20,6 +20,11 @@ issues:
     - ST1003  # CamelCase variables; see constants/cipher.go
     - missing output for example, go test can't validate it
     - variable 'hasExpiredEntity' is only used in the if-statement
+    - G101
+    - Magic number
+    - param max has same name as predeclared identifier
+    - G115
+    - the methods of "signatureCollector"
   exclude-rules:
     - path: crypto/key_clear.go
       text: "SA1019"
@@ -31,6 +36,8 @@ issues:
       text: "Using the variable on range scope"
     - path: crypto/sign_verify_test.go
       text: "Using the variable on range scope"
+    - path: crypto/interop_test.go
+      text: "G101: Potential hardcoded credentials"
 
 linters:
   enable-all: true

crypto/encrypt_decrypt_test.go

@@ -927,7 +927,7 @@ func TestEncryptDecryptKey(t *testing.T) {
 func TestEncryptCompressionApplied(t *testing.T) {
 	const numReplicas = 10
 	builder := strings.Builder{}
-	for i := 0; i < numReplicas; i++ {
+	for range numReplicas {
 		builder.WriteString(testMessage)
 	}
 	messageToEncrypt := builder.String()

crypto/keyring_test.go

@@ -5,6 +5,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"github.com/ProtonMail/go-crypto/openpgp/ecdh"
 	"github.com/ProtonMail/go-crypto/openpgp/eddsa"
@@ -121,11 +122,11 @@ func TestKeyIds(t *testing.T) {
 }
 
 func TestMultipleKeyRing(t *testing.T) {
-	assert.Exactly(t, 3, len(keyRingTestMultiple.entities))
+	assert.Len(t, keyRingTestMultiple.entities, 3)
 	assert.Exactly(t, 3, keyRingTestMultiple.CountEntities())
 	assert.Exactly(t, 3, keyRingTestMultiple.CountDecryptionEntities(testTime))
 
-	assert.Exactly(t, 3, len(keyRingTestMultiple.GetKeys()))
+	assert.Len(t, keyRingTestMultiple.GetKeys(), 3)
 
 	testKey, err := keyRingTestMultiple.GetKey(1)
 	if err != nil {
@@ -134,28 +135,28 @@ func TestMultipleKeyRing(t *testing.T) {
 	assert.Exactly(t, keyTestEC, testKey)
 
 	_, err = keyRingTestMultiple.GetKey(3)
-	assert.NotNil(t, err)
+	require.Error(t, err)
 
 	singleKeyRing, err := keyRingTestMultiple.FirstKey()
 	if err != nil {
 		t.Fatal("Expected no error while filtering the first key, got:", err)
 	}
-	assert.Exactly(t, 1, len(singleKeyRing.entities))
+	assert.Len(t, singleKeyRing.entities, 1)
 	assert.Exactly(t, 1, singleKeyRing.CountEntities())
 	assert.Exactly(t, 1, singleKeyRing.CountDecryptionEntities(testTime))
 }
 
 func TestSerializeParse(t *testing.T) {
 	serialized, err := keyRingTestMultiple.Serialize()
-	assert.Nil(t, err)
+	require.NoError(t, err)
 
 	parsed, err := NewKeyRingFromBinary(serialized)
-	assert.Nil(t, err)
+	require.NoError(t, err)
 
-	assert.Exactly(t, 3, len(parsed.GetKeys()))
+	assert.Len(t, parsed.GetKeys(), 3)
 	for i, parsedKey := range parsed.GetKeys() {
 		expectedKey, err := keyRingTestMultiple.GetKey(i)
-		assert.Nil(t, err)
+		require.NoError(t, err)
 		assert.Exactly(t, parsedKey.GetFingerprint(), expectedKey.GetFingerprint())
 	}
 }
@@ -167,7 +168,7 @@ func TestClearPrivateKey(t *testing.T) {
 	}
 
 	for _, key := range keyRingCopy.GetKeys() {
-		assert.Nil(t, clearPrivateKey(key.entity.PrivateKey.PrivateKey))
+		require.NoError(t, clearPrivateKey(key.entity.PrivateKey.PrivateKey))
 	}
 
 	keys := keyRingCopy.GetKeys()

crypto/message_test.go

@@ -11,6 +11,7 @@ import (
 
 	"github.com/ProtonMail/go-crypto/openpgp/packet"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestTextMessageEncryptionWithPassword(t *testing.T) {
@@ -32,7 +33,7 @@ func TestTextMessageEncryptionWithPassword(t *testing.T) {
 		}
 		sessionKey, ok := p.(*packet.SymmetricKeyEncrypted)
 		if ok {
-			assert.Equal(t, sessionKey.CipherFunc, packet.CipherAES256)
+			assert.Equal(t, packet.CipherAES256, sessionKey.CipherFunc)
 			foundSk = true
 			break
 		}
@@ -43,7 +44,7 @@ func TestTextMessageEncryptionWithPassword(t *testing.T) {
 	// Decrypt data with wrong password
 	decryptorWrong, _ := testPGP.Decryption().Password([]byte("Wrong password")).New()
 	_, err = decryptorWrong.Decrypt(encrypted.Bytes(), Bytes)
-	assert.NotNil(t, err)
+	require.Error(t, err)
 
 	// Decrypt data with the good password
 	decryptor, _ := testPGP.Decryption().Password(testSymmetricKey).New()
@@ -67,7 +68,7 @@ func TestBinaryMessageEncryptionWithPassword(t *testing.T) {
 	// Decrypt data with wrong password
 	decryptorWrong, _ := testPGP.Decryption().Password([]byte("Wrong password")).New()
 	_, err = decryptorWrong.Decrypt(encrypted.Bytes(), Bytes)
-	assert.NotNil(t, err)
+	require.Error(t, err)
 
 	// Decrypt data with the good password
 	decryptor, _ := testPGP.Decryption().Password(testSymmetricKey).New()
@@ -305,7 +306,7 @@ func TestSHA1SignedMessageDecryption(t *testing.T) {
 
 func TestMultipleKeyMessageEncryption(t *testing.T) {
 	var message = []byte("plain text")
-	assert.Exactly(t, 3, len(keyRingTestMultiple.entities))
+	assert.Len(t, keyRingTestMultiple.entities, 3)
 
 	encryptor, _ := testPGP.Encryption().Recipients(keyRingTestMultiple).SigningKeys(keyRingTestPrivate).New()
 	ciphertext, err := encryptor.Encrypt(message)
@@ -317,7 +318,7 @@ func TestMultipleKeyMessageEncryption(t *testing.T) {
 	// followed by a single symmetrically encrypted data packet (tag 18)
 	var p packet.Packet
 	packets := packet.NewReader(bytes.NewReader(ciphertext.Bytes()))
-	for i := 0; i < 3; i++ {
+	for range 3 {
 		if p, err = packets.Next(); err != nil {
 			t.Fatal(err.Error())
 		}
@@ -349,15 +350,15 @@ func TestMultipleKeyMessageEncryption(t *testing.T) {
 
 func TestMessageGetEncryptionKeyIDs(t *testing.T) {
 	var message = []byte("plain text")
-	assert.Exactly(t, 3, len(keyRingTestMultiple.entities))
+	assert.Len(t, keyRingTestMultiple.entities, 3)
 
 	encryptor, _ := testPGP.Encryption().Recipients(keyRingTestMultiple).SigningKeys(keyRingTestPrivate).New()
 	ciphertext, err := encryptor.Encrypt(message)
 	if err != nil {
 		t.Fatal("Expected no error when encrypting, got:", err)
 	}
 	ids, ok := ciphertext.EncryptionKeyIDs()
-	assert.Exactly(t, 3, len(ids))
+	assert.Len(t, ids, 3)
 	assert.True(t, ok)
 	encKey, ok := keyRingTestMultiple.entities[0].EncryptionKey(time.Now(), nil)
 	assert.True(t, ok)
@@ -371,7 +372,7 @@ func TestMessageGetHexGetEncryptionKeyIDs(t *testing.T) {
 	}
 
 	ids, ok := ciphertext.HexEncryptionKeyIDs()
-	assert.Exactly(t, 2, len(ids))
+	assert.Len(t, ids, 2)
 	assert.True(t, ok)
 
 	assert.Exactly(t, "76ad736fa7e0e83c", ids[0])
@@ -388,7 +389,7 @@ func TestMessageGetSignatureKeyIDs(t *testing.T) {
 	}
 
 	ids, ok := SignatureKeyIDs(signature)
-	assert.Exactly(t, 1, len(ids))
+	assert.Len(t, ids, 1)
 	assert.True(t, ok)
 	signingKey, ok := keyRingTestPrivate.entities[0].SigningKey(time.Now(), nil)
 	assert.True(t, ok)
@@ -402,7 +403,7 @@ func TestMessageGetHexSignatureKeyIDs(t *testing.T) {
 	}
 
 	ids, ok := ciphertext.HexSignatureKeyIDs()
-	assert.Exactly(t, 2, len(ids))
+	assert.Len(t, ids, 2)
 	assert.True(t, ok)
 
 	assert.Exactly(t, "3eb6259edf21df24", ids[0])

crypto/sessionkey_test.go

@@ -11,6 +11,7 @@ import (
 	"github.com/ProtonMail/gopenpgp/v3/constants"
 	"github.com/ProtonMail/gopenpgp/v3/profile"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 var testSessionKey *SessionKey
@@ -81,7 +82,7 @@ func TestSymmetricKeyPacket(t *testing.T) {
 	decHandle, _ := testPGP.Decryption().Password([]byte("Wrong password")).New()
 	wrongSymmetricKey, err := decHandle.DecryptSessionKey(keyPacket)
 	if err != nil {
-		assert.EqualError(t, err, "gopenpgp: unable to decrypt any packet")
+		require.EqualError(t, err, "gopenpgp: unable to decrypt any packet")
 	} else {
 		assert.NotEqual(t, testSessionKey, wrongSymmetricKey)
 	}
@@ -134,7 +135,7 @@ func TestDataPacketEncryption(t *testing.T) {
 	}
 	decryptor, _ := testPGP.Decryption().SessionKey(wrongKey).New()
 	_, err = decryptor.Decrypt(pgpMessage.BinaryDataPacket(), Bytes)
-	assert.NotNil(t, err)
+	require.Error(t, err)
 
 	// Decrypt data with the good session key
 	decryptor, _ = testPGP.Decryption().SessionKey(testSessionKey).New()
@@ -145,7 +146,7 @@ func TestDataPacketEncryption(t *testing.T) {
 	assert.Exactly(t, message, decrypted.Bytes())
 
 	// Encrypt session key
-	assert.Exactly(t, 3, len(keyRingTestMultiple.entities))
+	assert.Len(t, keyRingTestMultiple.entities, 3)
 	encryptor, _ = testPGP.Encryption().Recipients(keyRingTestMultiple).New()
 	keyPackets, err := encryptor.EncryptSessionKey(testSessionKey)
 	if err != nil {
@@ -167,7 +168,7 @@ func TestDataPacketEncryption(t *testing.T) {
 	}
 	ids, ok := pgpMessage.EncryptionKeyIDs()
 	assert.True(t, ok)
-	assert.Exactly(t, 3, len(ids))
+	assert.Len(t, ids, 3)
 
 	// Test if final decryption succeeds
 	decryptor, _ = testPGP.Decryption().DecryptionKeys(keyRingTestPrivate).New()
@@ -239,7 +240,7 @@ func TestDataPacketEncryptionAndSignature(t *testing.T) {
 	}
 	decryptor, _ := testPGP.Decryption().SessionKey(wrongKey).New()
 	_, err = decryptor.Decrypt(pgpMessage.BinaryDataPacket(), Bytes)
-	assert.NotNil(t, err)
+	require.Error(t, err)
 
 	// Decrypt data with the good session key
 	decryptor, _ = testPGP.Decryption().SessionKey(testSessionKey).New()
@@ -276,7 +277,7 @@ func TestDataPacketEncryptionAndSignature(t *testing.T) {
 	assert.Exactly(t, message, decrypted.Bytes())
 
 	// Encrypt session key
-	assert.Exactly(t, 3, len(keyRingTestMultiple.entities))
+	assert.Len(t, keyRingTestMultiple.entities, 3)
 	encryptor, _ = testPGP.Encryption().Recipients(keyRingTestMultiple).New()
 	keyPacket, err := encryptor.EncryptSessionKey(testSessionKey)
 	if err != nil {
@@ -298,7 +299,7 @@ func TestDataPacketEncryptionAndSignature(t *testing.T) {
 	}
 	ids, ok := pgpMessage.EncryptionKeyIDs()
 	assert.True(t, ok)
-	assert.Exactly(t, 3, len(ids))
+	assert.Len(t, ids, 3)
 
 	// Test if final decryption & verification succeeds
 	decryptor, _ = testPGP.Decryption().DecryptionKeys(keyRingTestPrivate).VerificationKeys(keyRingTestPublic).New()
@@ -345,7 +346,7 @@ func TestMDCFailDecryption(t *testing.T) {
 
 	decryptor, _ := testPGP.Decryption().SessionKey(sessionKey).New()
 	_, err = decryptor.Decrypt(pgpMessage.BinaryDataPacket(), Bytes)
-	assert.NotNil(t, err)
+	assert.Error(t, err)
 }
 
 func TestAsymmetricKeyPacketDecryptionFailure(t *testing.T) {

crypto/signature_test.go

@@ -176,9 +176,6 @@ func Test_KeyRing_GetVerifiedSignatureTimestampSuccess(t *testing.T) {
 		t.Fatal(err)
 	}
 	actualTime := verificationResult.SignatureCreationTime()
-	if err != nil {
-		t.Errorf("Got an error while parsing the signature creation time: %v", err)
-	}
 	if timeLocal != actualTime {
 		t.Errorf("Expected creation time to be %d, got %d", timeLocal, actualTime)
 	}
@@ -226,9 +223,6 @@ func Test_KeyRing_GetVerifiedSignatureWithTwoKeysTimestampSuccess(t *testing.T)
 	}
 	actualTime := verificationResult.SignatureCreationTime()
 	otherTime := verificationResult.Signatures[1].Signature.CreationTime.Unix()
-	if err != nil {
-		t.Errorf("Got an error while parsing the signature creation time: %v", err)
-	}
 
 	if time2 != otherTime {
 		t.Errorf("Expected creation time to be %d, got %d", otherTime, time2)

go.mod

@@ -2,7 +2,6 @@ module github.com/ProtonMail/gopenpgp/v3
 
 go 1.23.0
 
-
 require (
 	github.com/ProtonMail/go-crypto v1.4.1
 	github.com/ProtonMail/go-mime v0.0.0-20230322103455-7d82a3887f2f

internal/sanitize_string_test.go

@@ -23,7 +23,7 @@ func testStringSanitizeReader(t *testing.T, test string) {
 		n, err = reader.Read(smallBuff)
 		byteBuffer.Write(smallBuff[:n])
 	}
-	assert.Equal(t, byteBuffer.String(), expectedOutput(test))
+	assert.Equal(t, expectedOutput(test), byteBuffer.String())
 }
 
 func TestStringSanitizeReader(t *testing.T) {

mime/mime.go

@@ -62,7 +62,7 @@ func Decrypt(
 	bodyContent, bodyMimeType := body.GetBody()
 	bodyContentSanitized := internal.SanitizeString(bodyContent)
 	callbacks.OnBody(bodyContentSanitized, bodyMimeType)
-	for i := 0; i < len(attachments); i++ {
+	for i := range attachments {
 		callbacks.OnAttachment(attachmentHeaders[i], []byte(attachments[i]))
 	}
 	callbacks.OnEncryptedHeaders("")

mime/mime_test.go

@@ -22,18 +22,18 @@ func (t *Callbacks) OnBody(body string, mimetype string) {
 	assert.Exactly(t.Testing, readTestFile("mime_decryptedBody", false), body)
 }
 
-func (t Callbacks) OnAttachment(headers string, data []byte) {
+func (t *Callbacks) OnAttachment(headers string, data []byte) {
 	assert.Exactly(t.Testing, 1, data)
 }
 
-func (t Callbacks) OnEncryptedHeaders(headers string) {
+func (t *Callbacks) OnEncryptedHeaders(headers string) {
 	assert.Exactly(t.Testing, "", headers)
 }
 
-func (t Callbacks) OnVerified(verified int) {
+func (t *Callbacks) OnVerified(verified int) {
 }
 
-func (t Callbacks) OnError(err error) {
+func (t *Callbacks) OnError(err error) {
 	t.Testing.Fatal("Error in decrypting MIME message: ", err)
 }