github.com/jasoet/gopki@v1.15.0/encryption/asymmetric/helpers_test.go (about)

     1  package asymmetric
     2  
     3  import (
     4  	"bytes"
     5  	"crypto/rand"
     6  	"crypto/sha256"
     7  	"fmt"
     8  	"io"
     9  	"testing"
    10  
    11  	"golang.org/x/crypto/hkdf"
    12  )
    13  
    14  func TestDeriveAESKey(t *testing.T) {
    15  	testCases := []struct {
    16  		name         string
    17  		secretLength int
    18  	}{
    19  		{"32ByteSecret", 32},
    20  		{"64ByteSecret", 64},
    21  		{"128ByteSecret", 128},
    22  		{"MinSecret", 1},
    23  		{"EmptySecret", 0},
    24  	}
    25  
    26  	for _, tc := range testCases {
    27  		t.Run(tc.name, func(t *testing.T) {
    28  			secret := make([]byte, tc.secretLength)
    29  			if tc.secretLength > 0 {
    30  				_, err := rand.Read(secret)
    31  				if err != nil {
    32  					t.Fatalf("Failed to generate test secret: %v", err)
    33  				}
    34  			}
    35  
    36  			derivedKey := deriveAESKey(secret)
    37  
    38  			// Check that derived key is always 32 bytes (AES-256)
    39  			if len(derivedKey) != 32 {
    40  				t.Errorf("Expected derived key length 32, got %d", len(derivedKey))
    41  			}
    42  
    43  			// Check that the same input produces the same output (deterministic)
    44  			derivedKey2 := deriveAESKey(secret)
    45  			if !bytes.Equal(derivedKey, derivedKey2) {
    46  				t.Error("Key derivation is not deterministic")
    47  			}
    48  
    49  			// Check that different inputs produce different outputs
    50  			if tc.secretLength > 0 {
    51  				differentSecret := make([]byte, tc.secretLength)
    52  				differentSecret[0] = secret[0] ^ 0xFF // Make it different
    53  				copy(differentSecret[1:], secret[1:])
    54  
    55  				differentKey := deriveAESKey(differentSecret)
    56  				if bytes.Equal(derivedKey, differentKey) {
    57  					t.Error("Different secrets produced the same derived key")
    58  				}
    59  			}
    60  		})
    61  	}
    62  }
    63  
    64  func TestDeriveAESKeyConsistencyWithHKDF(t *testing.T) {
    65  	// Test that our key derivation matches direct HKDF usage
    66  	secret := make([]byte, 32)
    67  	_, err := rand.Read(secret)
    68  	if err != nil {
    69  		t.Fatalf("Failed to generate test secret: %v", err)
    70  	}
    71  
    72  	// Derive key using our function
    73  	ourKey := deriveAESKey(secret)
    74  
    75  	// Derive key using HKDF directly (should match our implementation)
    76  	hkdfReader := hkdf.New(sha256.New, secret, nil, []byte("GoPKI-AES-Key"))
    77  	expectedKey := make([]byte, 32)
    78  	_, err = io.ReadFull(hkdfReader, expectedKey)
    79  	if err != nil {
    80  		t.Fatalf("Failed to derive key with HKDF: %v", err)
    81  	}
    82  
    83  	if !bytes.Equal(ourKey, expectedKey) {
    84  		t.Error("Our key derivation doesn't match HKDF implementation")
    85  	}
    86  }
    87  
    88  func TestEncryptAESGCM(t *testing.T) {
    89  	// Only test AES-256 as the implementation only supports 32-byte keys
    90  	testKeys := [][]byte{
    91  		make([]byte, 32), // AES-256
    92  	}
    93  
    94  	// Fill keys with test data
    95  	for _, key := range testKeys {
    96  		_, err := rand.Read(key)
    97  		if err != nil {
    98  			t.Fatalf("Failed to generate test key: %v", err)
    99  		}
   100  	}
   101  
   102  	testData := [][]byte{
   103  		[]byte(""),
   104  		[]byte("short"),
   105  		[]byte("medium length test data"),
   106  		make([]byte, 1024),  // 1KB
   107  		make([]byte, 10240), // 10KB
   108  	}
   109  
   110  	// Fill large test data
   111  	for i := range testData[len(testData)-1] {
   112  		testData[len(testData)-1][i] = byte(i % 256)
   113  	}
   114  	for i := range testData[len(testData)-2] {
   115  		testData[len(testData)-2][i] = byte(i % 256)
   116  	}
   117  
   118  	for _, key := range testKeys {
   119  		for dataIdx, data := range testData {
   120  			t.Run(fmt.Sprintf("Key%dBytes_Data%d", len(key), dataIdx), func(t *testing.T) {
   121  				ciphertext, iv, tag, err := encryptAESGCM(data, key)
   122  				if err != nil {
   123  					t.Fatalf("Failed to encrypt: %v", err)
   124  				}
   125  
   126  				// Check IV length (should be 12 bytes for GCM)
   127  				if len(iv) != 12 {
   128  					t.Errorf("Expected IV length 12, got %d", len(iv))
   129  				}
   130  
   131  				// Check tag length (should be 16 bytes for GCM)
   132  				if len(tag) != 16 {
   133  					t.Errorf("Expected tag length 16, got %d", len(tag))
   134  				}
   135  
   136  				// Check ciphertext length matches plaintext length
   137  				if len(ciphertext) != len(data) {
   138  					t.Errorf("Ciphertext length %d doesn't match plaintext length %d", len(ciphertext), len(data))
   139  				}
   140  
   141  				// For non-empty data, ciphertext should be different from plaintext
   142  				if len(data) > 0 && bytes.Equal(ciphertext, data) {
   143  					t.Error("Ciphertext should be different from plaintext")
   144  				}
   145  			})
   146  		}
   147  	}
   148  }
   149  
   150  func TestEncryptAESGCMUniqueness(t *testing.T) {
   151  	key := make([]byte, 32)
   152  	_, err := rand.Read(key)
   153  	if err != nil {
   154  		t.Fatalf("Failed to generate test key: %v", err)
   155  	}
   156  
   157  	data := []byte("test data for uniqueness")
   158  
   159  	// Encrypt the same data multiple times
   160  	numTests := 10
   161  	results := make(map[string]bool)
   162  
   163  	for i := 0; i < numTests; i++ {
   164  		ciphertext, iv, tag, err := encryptAESGCM(data, key)
   165  		if err != nil {
   166  			t.Fatalf("Failed to encrypt iteration %d: %v", i, err)
   167  		}
   168  
   169  		// Create unique identifier for this encryption
   170  		identifier := string(iv) + string(tag) + string(ciphertext)
   171  
   172  		if results[identifier] {
   173  			t.Error("Encryption produced identical results - IVs should be unique")
   174  		}
   175  		results[identifier] = true
   176  
   177  		// Each IV should be unique
   178  		ivStr := string(iv)
   179  		if len(ivStr) != 12 {
   180  			t.Errorf("IV length should be 12, got %d", len(ivStr))
   181  		}
   182  	}
   183  
   184  	if len(results) != numTests {
   185  		t.Errorf("Expected %d unique encryptions, got %d", numTests, len(results))
   186  	}
   187  }
   188  
   189  func TestEncryptAESGCMInvalidKey(t *testing.T) {
   190  	// Test invalid keys - implementation only accepts 32-byte keys
   191  	invalidKeys := [][]byte{
   192  		make([]byte, 15), // Too short
   193  		make([]byte, 16), // AES-128 not supported
   194  		make([]byte, 24), // AES-192 not supported
   195  		make([]byte, 31), // Too short
   196  		make([]byte, 33), // Too long
   197  		nil,              // Nil key
   198  		{},               // Empty key
   199  	}
   200  
   201  	data := []byte("test data")
   202  
   203  	for i, key := range invalidKeys {
   204  		t.Run(fmt.Sprintf("InvalidKey%d", i), func(t *testing.T) {
   205  			_, _, _, err := encryptAESGCM(data, key)
   206  			if err == nil {
   207  				t.Errorf("Expected error for invalid key of length %d", len(key))
   208  			}
   209  		})
   210  	}
   211  }
   212  
   213  func TestDecryptAESGCM(t *testing.T) {
   214  	// Only test AES-256 as the implementation only supports 32-byte keys
   215  	testKeys := [][]byte{
   216  		make([]byte, 32), // AES-256
   217  	}
   218  
   219  	// Fill keys with test data
   220  	for _, key := range testKeys {
   221  		_, err := rand.Read(key)
   222  		if err != nil {
   223  			t.Fatalf("Failed to generate test key: %v", err)
   224  		}
   225  	}
   226  
   227  	testData := [][]byte{
   228  		[]byte(""),
   229  		[]byte("short"),
   230  		[]byte("medium length test data for decryption"),
   231  		make([]byte, 1024),
   232  	}
   233  
   234  	// Fill large test data
   235  	for i := range testData[len(testData)-1] {
   236  		testData[len(testData)-1][i] = byte(i % 256)
   237  	}
   238  
   239  	for _, key := range testKeys {
   240  		for dataIdx, originalData := range testData {
   241  			t.Run(fmt.Sprintf("Key%dBytes_Data%d", len(key), dataIdx), func(t *testing.T) {
   242  				// Encrypt first
   243  				ciphertext, iv, tag, err := encryptAESGCM(originalData, key)
   244  				if err != nil {
   245  					t.Fatalf("Failed to encrypt: %v", err)
   246  				}
   247  
   248  				// Decrypt
   249  				decrypted, err := decryptAESGCM(ciphertext, key, iv, tag)
   250  				if err != nil {
   251  					t.Fatalf("Failed to decrypt: %v", err)
   252  				}
   253  
   254  				// Verify decrypted data matches original
   255  				if !bytes.Equal(decrypted, originalData) {
   256  					t.Errorf("Decrypted data doesn't match original. Expected: %v, Got: %v", originalData, decrypted)
   257  				}
   258  			})
   259  		}
   260  	}
   261  }
   262  
   263  func TestDecryptAESGCMErrorCases(t *testing.T) {
   264  	key := make([]byte, 32)
   265  	_, err := rand.Read(key)
   266  	if err != nil {
   267  		t.Fatalf("Failed to generate test key: %v", err)
   268  	}
   269  
   270  	data := []byte("test data for error cases")
   271  	ciphertext, iv, tag, err := encryptAESGCM(data, key)
   272  	if err != nil {
   273  		t.Fatalf("Failed to encrypt test data: %v", err)
   274  	}
   275  
   276  	t.Run("InvalidKey", func(t *testing.T) {
   277  		invalidKey := make([]byte, 15) // Invalid length
   278  		_, err := decryptAESGCM(ciphertext, invalidKey, iv, tag)
   279  		if err == nil {
   280  			t.Error("Expected error for invalid key")
   281  		}
   282  	})
   283  
   284  	t.Run("WrongKey", func(t *testing.T) {
   285  		wrongKey := make([]byte, 32)
   286  		_, err := rand.Read(wrongKey)
   287  		if err != nil {
   288  			t.Fatalf("Failed to generate wrong key: %v", err)
   289  		}
   290  
   291  		_, err = decryptAESGCM(ciphertext, wrongKey, iv, tag)
   292  		if err == nil {
   293  			t.Error("Expected error for wrong key")
   294  		}
   295  	})
   296  
   297  	t.Run("CorruptedCiphertext", func(t *testing.T) {
   298  		corruptedCiphertext := make([]byte, len(ciphertext))
   299  		copy(corruptedCiphertext, ciphertext)
   300  		if len(corruptedCiphertext) > 0 {
   301  			corruptedCiphertext[0] ^= 0xFF
   302  		}
   303  
   304  		_, err := decryptAESGCM(corruptedCiphertext, key, iv, tag)
   305  		if err == nil {
   306  			t.Error("Expected error for corrupted ciphertext")
   307  		}
   308  	})
   309  
   310  	t.Run("CorruptedIV", func(t *testing.T) {
   311  		corruptedIV := make([]byte, len(iv))
   312  		copy(corruptedIV, iv)
   313  		corruptedIV[0] ^= 0xFF
   314  
   315  		_, err := decryptAESGCM(ciphertext, key, corruptedIV, tag)
   316  		if err == nil {
   317  			t.Error("Expected error for corrupted IV")
   318  		}
   319  	})
   320  
   321  	t.Run("CorruptedTag", func(t *testing.T) {
   322  		corruptedTag := make([]byte, len(tag))
   323  		copy(corruptedTag, tag)
   324  		corruptedTag[0] ^= 0xFF
   325  
   326  		_, err := decryptAESGCM(ciphertext, key, iv, corruptedTag)
   327  		if err == nil {
   328  			t.Error("Expected error for corrupted tag")
   329  		}
   330  	})
   331  
   332  	t.Run("InvalidIVLength", func(t *testing.T) {
   333  		defer func() {
   334  			if r := recover(); r != nil {
   335  				// Expected panic for invalid IV length
   336  				t.Logf("Caught expected panic for invalid IV length: %v", r)
   337  			}
   338  		}()
   339  
   340  		invalidIV := make([]byte, 11) // Wrong length
   341  		_, err := decryptAESGCM(ciphertext, key, invalidIV, tag)
   342  		if err == nil {
   343  			t.Error("Expected error for invalid IV length")
   344  		}
   345  	})
   346  
   347  	t.Run("InvalidTagLength", func(t *testing.T) {
   348  		invalidTag := make([]byte, 15) // Wrong length
   349  		_, err := decryptAESGCM(ciphertext, key, iv, invalidTag)
   350  		if err == nil {
   351  			t.Error("Expected error for invalid tag length")
   352  		}
   353  	})
   354  
   355  	t.Run("NilInputs", func(t *testing.T) {
   356  		// Test nil ciphertext
   357  		_, err := decryptAESGCM(nil, key, iv, tag)
   358  		if err == nil {
   359  			t.Error("Expected error for nil ciphertext")
   360  		}
   361  
   362  		// Test nil key
   363  		_, err = decryptAESGCM(ciphertext, nil, iv, tag)
   364  		if err == nil {
   365  			t.Error("Expected error for nil key")
   366  		}
   367  
   368  		// Test nil IV (this will panic)
   369  		func() {
   370  			defer func() {
   371  				if r := recover(); r != nil {
   372  					t.Logf("Caught expected panic for nil IV: %v", r)
   373  				}
   374  			}()
   375  			_, err = decryptAESGCM(ciphertext, key, nil, tag)
   376  			if err == nil {
   377  				t.Error("Expected error for nil IV")
   378  			}
   379  		}()
   380  
   381  		// Test nil tag
   382  		_, err = decryptAESGCM(ciphertext, key, iv, nil)
   383  		if err == nil {
   384  			t.Error("Expected error for nil tag")
   385  		}
   386  	})
   387  }
   388  
   389  func TestAESGCMRoundTrip(t *testing.T) {
   390  	// Test complete round-trip encryption/decryption
   391  	// Only test AES-256 as implementation only supports 32-byte keys
   392  	testCases := []struct {
   393  		keySize  int
   394  		dataSize int
   395  	}{
   396  		{32, 0},
   397  		{32, 1},
   398  		{32, 100},
   399  		{32, 1000},
   400  		{32, 10000},
   401  	}
   402  
   403  	for _, tc := range testCases {
   404  		t.Run(fmt.Sprintf("Key%d_Data%d", tc.keySize, tc.dataSize), func(t *testing.T) {
   405  			key := make([]byte, tc.keySize)
   406  			_, err := rand.Read(key)
   407  			if err != nil {
   408  				t.Fatalf("Failed to generate key: %v", err)
   409  			}
   410  
   411  			originalData := make([]byte, tc.dataSize)
   412  			for i := range originalData {
   413  				originalData[i] = byte(i % 256)
   414  			}
   415  
   416  			// Encrypt
   417  			ciphertext, iv, tag, err := encryptAESGCM(originalData, key)
   418  			if err != nil {
   419  				t.Fatalf("Failed to encrypt: %v", err)
   420  			}
   421  
   422  			// Decrypt
   423  			decrypted, err := decryptAESGCM(ciphertext, key, iv, tag)
   424  			if err != nil {
   425  				t.Fatalf("Failed to decrypt: %v", err)
   426  			}
   427  
   428  			// Verify
   429  			if !bytes.Equal(decrypted, originalData) {
   430  				t.Error("Round-trip failed: decrypted data doesn't match original")
   431  			}
   432  		})
   433  	}
   434  }
   435  
   436  func BenchmarkDeriveAESKey(b *testing.B) {
   437  	secret := make([]byte, 32)
   438  	_, err := rand.Read(secret)
   439  	if err != nil {
   440  		b.Fatalf("Failed to generate test secret: %v", err)
   441  	}
   442  
   443  	b.ResetTimer()
   444  	for i := 0; i < b.N; i++ {
   445  		_ = deriveAESKey(secret)
   446  	}
   447  }
   448  
   449  func BenchmarkEncryptAESGCM(b *testing.B) {
   450  	key := make([]byte, 32)
   451  	_, err := rand.Read(key)
   452  	if err != nil {
   453  		b.Fatalf("Failed to generate key: %v", err)
   454  	}
   455  
   456  	data := make([]byte, 1024)
   457  	_, err = rand.Read(data)
   458  	if err != nil {
   459  		b.Fatalf("Failed to generate data: %v", err)
   460  	}
   461  
   462  	b.ResetTimer()
   463  	for i := 0; i < b.N; i++ {
   464  		_, _, _, err := encryptAESGCM(data, key)
   465  		if err != nil {
   466  			b.Fatalf("Encryption failed: %v", err)
   467  		}
   468  	}
   469  }
   470  
   471  func BenchmarkDecryptAESGCM(b *testing.B) {
   472  	key := make([]byte, 32)
   473  	_, err := rand.Read(key)
   474  	if err != nil {
   475  		b.Fatalf("Failed to generate key: %v", err)
   476  	}
   477  
   478  	data := make([]byte, 1024)
   479  	_, err = rand.Read(data)
   480  	if err != nil {
   481  		b.Fatalf("Failed to generate data: %v", err)
   482  	}
   483  
   484  	ciphertext, iv, tag, err := encryptAESGCM(data, key)
   485  	if err != nil {
   486  		b.Fatalf("Failed to encrypt test data: %v", err)
   487  	}
   488  
   489  	b.ResetTimer()
   490  	for i := 0; i < b.N; i++ {
   491  		_, err := decryptAESGCM(ciphertext, key, iv, tag)
   492  		if err != nil {
   493  			b.Fatalf("Decryption failed: %v", err)
   494  		}
   495  	}
   496  }