github.com/jasoet/gopki@v1.15.0/encryption/symmetric/symmetric_test.go (about)

     1  package symmetric
     2  
     3  import (
     4  	"bytes"
     5  	"crypto/rand"
     6  	"fmt"
     7  	"testing"
     8  	"time"
     9  
    10  	"github.com/jasoet/gopki/encryption"
    11  	"github.com/stretchr/testify/assert"
    12  )
    13  
    14  func TestEncryptAESGCM(t *testing.T) {
    15  	testData := []byte("test data for AES-GCM encryption")
    16  	opts := encryption.DefaultEncryptOptions()
    17  
    18  	t.Run("AES-128", func(t *testing.T) {
    19  		key, err := GenerateAESKey(16)
    20  		assert.NoError(t, err)
    21  
    22  		encrypted, err := EncryptAESGCM(testData, key, opts)
    23  		assert.NoError(t, err)
    24  		assert.NotNil(t, encrypted)
    25  		assert.Equal(t, encryption.AlgorithmAESGCM, encrypted.Algorithm)
    26  		assert.NotEmpty(t, encrypted.Data)
    27  		assert.NotEmpty(t, encrypted.IV)
    28  		assert.NotEmpty(t, encrypted.Tag)
    29  		assert.Equal(t, 12, len(encrypted.IV))  // GCM nonce size
    30  		assert.Equal(t, 16, len(encrypted.Tag)) // GCM tag size
    31  	})
    32  
    33  	t.Run("AES-192", func(t *testing.T) {
    34  		key, err := GenerateAESKey(24)
    35  		assert.NoError(t, err)
    36  
    37  		encrypted, err := EncryptAESGCM(testData, key, opts)
    38  		assert.NoError(t, err)
    39  		assert.NotNil(t, encrypted)
    40  		assert.Equal(t, encryption.AlgorithmAESGCM, encrypted.Algorithm)
    41  	})
    42  
    43  	t.Run("AES-256", func(t *testing.T) {
    44  		key, err := GenerateAESKey(32)
    45  		assert.NoError(t, err)
    46  
    47  		encrypted, err := EncryptAESGCM(testData, key, opts)
    48  		assert.NoError(t, err)
    49  		assert.NotNil(t, encrypted)
    50  		assert.Equal(t, encryption.AlgorithmAESGCM, encrypted.Algorithm)
    51  	})
    52  
    53  	t.Run("Invalid Key Size", func(t *testing.T) {
    54  		invalidKey := make([]byte, 15) // Invalid size
    55  
    56  		encrypted, err := EncryptAESGCM(testData, invalidKey, opts)
    57  		assert.Error(t, err)
    58  		assert.Nil(t, encrypted)
    59  		assert.Contains(t, err.Error(), "invalid AES key size")
    60  	})
    61  
    62  	t.Run("Empty Data", func(t *testing.T) {
    63  		key, err := GenerateAESKey(32)
    64  		assert.NoError(t, err)
    65  
    66  		encrypted, err := EncryptAESGCM([]byte{}, key, opts)
    67  		assert.NoError(t, err)
    68  		assert.NotNil(t, encrypted)
    69  		assert.Empty(t, encrypted.Data)
    70  	})
    71  
    72  	t.Run("Large Data", func(t *testing.T) {
    73  		largeData := make([]byte, 1024*1024) // 1MB
    74  		_, err := rand.Read(largeData)
    75  		assert.NoError(t, err)
    76  
    77  		key, err := GenerateAESKey(32)
    78  		assert.NoError(t, err)
    79  
    80  		encrypted, err := EncryptAESGCM(largeData, key, opts)
    81  		assert.NoError(t, err)
    82  		assert.NotNil(t, encrypted)
    83  		assert.Len(t, encrypted.Data, len(largeData))
    84  	})
    85  
    86  	t.Run("With Metadata", func(t *testing.T) {
    87  		key, err := GenerateAESKey(32)
    88  		assert.NoError(t, err)
    89  
    90  		opts := encryption.DefaultEncryptOptions()
    91  		opts.Metadata = map[string]interface{}{
    92  			"purpose":   "testing",
    93  			"algorithm": "AES-GCM",
    94  		}
    95  
    96  		encrypted, err := EncryptAESGCM(testData, key, opts)
    97  		assert.NoError(t, err)
    98  		assert.NotNil(t, encrypted.Metadata)
    99  		assert.Equal(t, "testing", encrypted.Metadata["purpose"])
   100  		assert.Equal(t, "AES-GCM", encrypted.Metadata["algorithm"])
   101  	})
   102  
   103  	t.Run("Unique Nonces", func(t *testing.T) {
   104  		key, err := GenerateAESKey(32)
   105  		assert.NoError(t, err)
   106  
   107  		encrypted1, err := EncryptAESGCM(testData, key, opts)
   108  		assert.NoError(t, err)
   109  
   110  		encrypted2, err := EncryptAESGCM(testData, key, opts)
   111  		assert.NoError(t, err)
   112  
   113  		// Same plaintext should produce different ciphertexts due to unique nonces
   114  		assert.NotEqual(t, encrypted1.IV, encrypted2.IV)
   115  		assert.NotEqual(t, encrypted1.Data, encrypted2.Data)
   116  		assert.NotEqual(t, encrypted1.Tag, encrypted2.Tag)
   117  	})
   118  
   119  	t.Run("Invalid Encrypt Options", func(t *testing.T) {
   120  		key, err := GenerateAESKey(32)
   121  		assert.NoError(t, err)
   122  
   123  		invalidOpts := encryption.EncryptOptions{
   124  			Algorithm: "INVALID_ALG", // Invalid algorithm
   125  			Format:    encryption.FormatCMS,
   126  		}
   127  
   128  		encrypted, err := EncryptAESGCM(testData, key, invalidOpts)
   129  		assert.Error(t, err)
   130  		assert.Nil(t, encrypted)
   131  		assert.Contains(t, err.Error(), "unsupported encryption algorithm")
   132  	})
   133  
   134  	t.Run("Zero Length Key", func(t *testing.T) {
   135  		zeroKey := []byte{} // Zero-length key
   136  
   137  		encrypted, err := EncryptAESGCM(testData, zeroKey, opts)
   138  		assert.Error(t, err)
   139  		assert.Nil(t, encrypted)
   140  		assert.Contains(t, err.Error(), "invalid AES key size")
   141  	})
   142  }
   143  
   144  func TestDecryptAESGCM(t *testing.T) {
   145  	testData := []byte("test data for AES-GCM decryption")
   146  	opts := encryption.DefaultEncryptOptions()
   147  	decryptOpts := encryption.DefaultDecryptOptions()
   148  
   149  	t.Run("AES-128 Round Trip", func(t *testing.T) {
   150  		key, err := GenerateAESKey(16)
   151  		assert.NoError(t, err)
   152  
   153  		encrypted, err := EncryptAESGCM(testData, key, opts)
   154  		assert.NoError(t, err)
   155  
   156  		decrypted, err := DecryptAESGCM(encrypted, key, decryptOpts)
   157  		assert.NoError(t, err)
   158  		assert.Equal(t, testData, decrypted)
   159  	})
   160  
   161  	t.Run("AES-192 Round Trip", func(t *testing.T) {
   162  		key, err := GenerateAESKey(24)
   163  		assert.NoError(t, err)
   164  
   165  		encrypted, err := EncryptAESGCM(testData, key, opts)
   166  		assert.NoError(t, err)
   167  
   168  		decrypted, err := DecryptAESGCM(encrypted, key, decryptOpts)
   169  		assert.NoError(t, err)
   170  		assert.Equal(t, testData, decrypted)
   171  	})
   172  
   173  	t.Run("AES-256 Round Trip", func(t *testing.T) {
   174  		key, err := GenerateAESKey(32)
   175  		assert.NoError(t, err)
   176  
   177  		encrypted, err := EncryptAESGCM(testData, key, opts)
   178  		assert.NoError(t, err)
   179  
   180  		decrypted, err := DecryptAESGCM(encrypted, key, decryptOpts)
   181  		assert.NoError(t, err)
   182  		assert.Equal(t, testData, decrypted)
   183  	})
   184  
   185  	t.Run("Wrong Algorithm", func(t *testing.T) {
   186  		key, err := GenerateAESKey(32)
   187  		assert.NoError(t, err)
   188  
   189  		encrypted := &encryption.EncryptedData{
   190  			Algorithm: encryption.AlgorithmRSAOAEP,
   191  			Data:      []byte("test"),
   192  			IV:        make([]byte, 12),
   193  			Tag:       make([]byte, 16),
   194  		}
   195  
   196  		decrypted, err := DecryptAESGCM(encrypted, key, decryptOpts)
   197  		assert.Error(t, err)
   198  		assert.Nil(t, decrypted)
   199  		assert.Contains(t, err.Error(), "expected AES-GCM algorithm")
   200  	})
   201  
   202  	t.Run("Wrong Key", func(t *testing.T) {
   203  		key1, err := GenerateAESKey(32)
   204  		assert.NoError(t, err)
   205  		key2, err := GenerateAESKey(32)
   206  		assert.NoError(t, err)
   207  
   208  		encrypted, err := EncryptAESGCM(testData, key1, opts)
   209  		assert.NoError(t, err)
   210  
   211  		decrypted, err := DecryptAESGCM(encrypted, key2, decryptOpts)
   212  		assert.Error(t, err)
   213  		assert.Nil(t, decrypted)
   214  		assert.Contains(t, err.Error(), "authentication error")
   215  	})
   216  
   217  	t.Run("Invalid Key Size", func(t *testing.T) {
   218  		key, err := GenerateAESKey(32)
   219  		assert.NoError(t, err)
   220  
   221  		encrypted, err := EncryptAESGCM(testData, key, opts)
   222  		assert.NoError(t, err)
   223  
   224  		invalidKey := make([]byte, 15)
   225  		decrypted, err := DecryptAESGCM(encrypted, invalidKey, decryptOpts)
   226  		assert.Error(t, err)
   227  		assert.Nil(t, decrypted)
   228  		assert.Contains(t, err.Error(), "invalid AES key size")
   229  	})
   230  
   231  	t.Run("Tampered Ciphertext", func(t *testing.T) {
   232  		key, err := GenerateAESKey(32)
   233  		assert.NoError(t, err)
   234  
   235  		encrypted, err := EncryptAESGCM(testData, key, opts)
   236  		assert.NoError(t, err)
   237  
   238  		// Tamper with ciphertext
   239  		encrypted.Data[0] ^= 0x01
   240  
   241  		decrypted, err := DecryptAESGCM(encrypted, key, decryptOpts)
   242  		assert.Error(t, err)
   243  		assert.Nil(t, decrypted)
   244  		assert.Contains(t, err.Error(), "authentication error")
   245  	})
   246  
   247  	t.Run("Tampered Tag", func(t *testing.T) {
   248  		key, err := GenerateAESKey(32)
   249  		assert.NoError(t, err)
   250  
   251  		encrypted, err := EncryptAESGCM(testData, key, opts)
   252  		assert.NoError(t, err)
   253  
   254  		// Tamper with authentication tag
   255  		encrypted.Tag[0] ^= 0x01
   256  
   257  		decrypted, err := DecryptAESGCM(encrypted, key, decryptOpts)
   258  		assert.Error(t, err)
   259  		assert.Nil(t, decrypted)
   260  		assert.Contains(t, err.Error(), "authentication error")
   261  	})
   262  
   263  	t.Run("Tampered IV", func(t *testing.T) {
   264  		key, err := GenerateAESKey(32)
   265  		assert.NoError(t, err)
   266  
   267  		encrypted, err := EncryptAESGCM(testData, key, opts)
   268  		assert.NoError(t, err)
   269  
   270  		// Tamper with IV/nonce
   271  		encrypted.IV[0] ^= 0x01
   272  
   273  		decrypted, err := DecryptAESGCM(encrypted, key, decryptOpts)
   274  		assert.Error(t, err)
   275  		assert.Nil(t, decrypted)
   276  		assert.Contains(t, err.Error(), "authentication error")
   277  	})
   278  
   279  	t.Run("Large Data Round Trip", func(t *testing.T) {
   280  		largeData := make([]byte, 5*1024*1024) // 5MB
   281  		_, err := rand.Read(largeData)
   282  		assert.NoError(t, err)
   283  
   284  		key, err := GenerateAESKey(32)
   285  		assert.NoError(t, err)
   286  
   287  		encrypted, err := EncryptAESGCM(largeData, key, opts)
   288  		assert.NoError(t, err)
   289  
   290  		decrypted, err := DecryptAESGCM(encrypted, key, decryptOpts)
   291  		assert.NoError(t, err)
   292  		assert.True(t, bytes.Equal(largeData, decrypted))
   293  	})
   294  
   295  	t.Run("Empty Data Round Trip", func(t *testing.T) {
   296  		key, err := GenerateAESKey(32)
   297  		assert.NoError(t, err)
   298  
   299  		encrypted, err := EncryptAESGCM([]byte{}, key, opts)
   300  		assert.NoError(t, err)
   301  
   302  		decrypted, err := DecryptAESGCM(encrypted, key, decryptOpts)
   303  		assert.NoError(t, err)
   304  		assert.Empty(t, decrypted)
   305  	})
   306  
   307  	t.Run("Invalid Decrypt Options", func(t *testing.T) {
   308  		key, err := GenerateAESKey(32)
   309  		assert.NoError(t, err)
   310  
   311  		encrypted, err := EncryptAESGCM(testData, key, opts)
   312  		assert.NoError(t, err)
   313  
   314  		invalidDecryptOpts := encryption.DecryptOptions{
   315  			MaxAge: -1 * time.Hour, // Invalid negative max age
   316  		}
   317  
   318  		decrypted, err := DecryptAESGCM(encrypted, key, invalidDecryptOpts)
   319  		assert.Error(t, err)
   320  		assert.Nil(t, decrypted)
   321  		assert.Contains(t, err.Error(), "invalid encryption parameters")
   322  	})
   323  }
   324  
   325  func TestGenerateAESKey(t *testing.T) {
   326  	t.Run("AES-128", func(t *testing.T) {
   327  		key, err := GenerateAESKey(16)
   328  		assert.NoError(t, err)
   329  		assert.Len(t, key, 16)
   330  	})
   331  
   332  	t.Run("AES-192", func(t *testing.T) {
   333  		key, err := GenerateAESKey(24)
   334  		assert.NoError(t, err)
   335  		assert.Len(t, key, 24)
   336  	})
   337  
   338  	t.Run("AES-256", func(t *testing.T) {
   339  		key, err := GenerateAESKey(32)
   340  		assert.NoError(t, err)
   341  		assert.Len(t, key, 32)
   342  	})
   343  
   344  	t.Run("Invalid Key Sizes", func(t *testing.T) {
   345  		invalidSizes := []int{8, 12, 15, 17, 20, 25, 31, 33, 64}
   346  		for _, size := range invalidSizes {
   347  			key, err := GenerateAESKey(size)
   348  			assert.Error(t, err)
   349  			assert.Nil(t, key)
   350  			assert.Contains(t, err.Error(), "invalid AES key size")
   351  		}
   352  	})
   353  
   354  	t.Run("Key Uniqueness", func(t *testing.T) {
   355  		key1, err := GenerateAESKey(32)
   356  		assert.NoError(t, err)
   357  
   358  		key2, err := GenerateAESKey(32)
   359  		assert.NoError(t, err)
   360  
   361  		// Keys should be different
   362  		assert.NotEqual(t, key1, key2)
   363  	})
   364  
   365  	t.Run("Key Randomness", func(t *testing.T) {
   366  		key, err := GenerateAESKey(32)
   367  		assert.NoError(t, err)
   368  
   369  		// Key should not be all zeros
   370  		allZeros := make([]byte, 32)
   371  		assert.NotEqual(t, allZeros, key)
   372  
   373  		// Key should not be all 0xFF
   374  		allFF := make([]byte, 32)
   375  		for i := range allFF {
   376  			allFF[i] = 0xFF
   377  		}
   378  		assert.NotEqual(t, allFF, key)
   379  	})
   380  }
   381  
   382  func TestDeriveKeyFromPassword(t *testing.T) {
   383  	password := "test-password-123"
   384  	salt := []byte("test-salt-16-bytes-long")
   385  	iterations := 100000
   386  
   387  	t.Run("AES-128", func(t *testing.T) {
   388  		key, err := DeriveKeyFromPassword(password, salt, 16, iterations)
   389  		assert.NoError(t, err)
   390  		assert.Len(t, key, 16)
   391  	})
   392  
   393  	t.Run("AES-192", func(t *testing.T) {
   394  		key, err := DeriveKeyFromPassword(password, salt, 24, iterations)
   395  		assert.NoError(t, err)
   396  		assert.Len(t, key, 24)
   397  	})
   398  
   399  	t.Run("AES-256", func(t *testing.T) {
   400  		key, err := DeriveKeyFromPassword(password, salt, 32, iterations)
   401  		assert.NoError(t, err)
   402  		assert.Len(t, key, 32)
   403  	})
   404  
   405  	t.Run("Deterministic", func(t *testing.T) {
   406  		key1, err := DeriveKeyFromPassword(password, salt, 32, iterations)
   407  		assert.NoError(t, err)
   408  
   409  		key2, err := DeriveKeyFromPassword(password, salt, 32, iterations)
   410  		assert.NoError(t, err)
   411  
   412  		// Same inputs should produce same key
   413  		assert.Equal(t, key1, key2)
   414  	})
   415  
   416  	t.Run("Different Passwords", func(t *testing.T) {
   417  		key1, err := DeriveKeyFromPassword("password1", salt, 32, iterations)
   418  		assert.NoError(t, err)
   419  
   420  		key2, err := DeriveKeyFromPassword("password2", salt, 32, iterations)
   421  		assert.NoError(t, err)
   422  
   423  		// Different passwords should produce different keys
   424  		assert.NotEqual(t, key1, key2)
   425  	})
   426  
   427  	t.Run("Different Salts", func(t *testing.T) {
   428  		salt1 := []byte("salt1-16-bytes-long")
   429  		salt2 := []byte("salt2-16-bytes-long")
   430  
   431  		key1, err := DeriveKeyFromPassword(password, salt1, 32, iterations)
   432  		assert.NoError(t, err)
   433  
   434  		key2, err := DeriveKeyFromPassword(password, salt2, 32, iterations)
   435  		assert.NoError(t, err)
   436  
   437  		// Different salts should produce different keys
   438  		assert.NotEqual(t, key1, key2)
   439  	})
   440  
   441  	t.Run("Different Iterations", func(t *testing.T) {
   442  		key1, err := DeriveKeyFromPassword(password, salt, 32, 10000)
   443  		assert.NoError(t, err)
   444  
   445  		key2, err := DeriveKeyFromPassword(password, salt, 32, 20000)
   446  		assert.NoError(t, err)
   447  
   448  		// Different iteration counts should produce different keys
   449  		assert.NotEqual(t, key1, key2)
   450  	})
   451  
   452  	t.Run("Invalid Key Size", func(t *testing.T) {
   453  		key, err := DeriveKeyFromPassword(password, salt, 15, iterations)
   454  		assert.Error(t, err)
   455  		assert.Nil(t, key)
   456  		assert.Contains(t, err.Error(), "invalid AES key size")
   457  	})
   458  
   459  	t.Run("Salt Too Short", func(t *testing.T) {
   460  		shortSalt := []byte("short")
   461  		key, err := DeriveKeyFromPassword(password, shortSalt, 32, iterations)
   462  		assert.Error(t, err)
   463  		assert.Nil(t, key)
   464  		assert.Contains(t, err.Error(), "salt too short")
   465  	})
   466  
   467  	t.Run("Iterations Too Low", func(t *testing.T) {
   468  		key, err := DeriveKeyFromPassword(password, salt, 32, 500)
   469  		assert.Error(t, err)
   470  		assert.Nil(t, key)
   471  		assert.Contains(t, err.Error(), "iteration count too low")
   472  	})
   473  
   474  	t.Run("Round Trip Encryption", func(t *testing.T) {
   475  		testData := []byte("test data for password-derived encryption")
   476  
   477  		key, err := DeriveKeyFromPassword(password, salt, 32, iterations)
   478  		assert.NoError(t, err)
   479  
   480  		encrypted, err := EncryptAESGCM(testData, key, encryption.DefaultEncryptOptions())
   481  		assert.NoError(t, err)
   482  
   483  		// Derive the same key again
   484  		derivedKey, err := DeriveKeyFromPassword(password, salt, 32, iterations)
   485  		assert.NoError(t, err)
   486  
   487  		decrypted, err := DecryptAESGCM(encrypted, derivedKey, encryption.DefaultDecryptOptions())
   488  		assert.NoError(t, err)
   489  		assert.Equal(t, testData, decrypted)
   490  	})
   491  }
   492  
   493  func TestDeriveKeyFromSharedSecret(t *testing.T) {
   494  	sharedSecret := make([]byte, 32)
   495  	_, err := rand.Read(sharedSecret)
   496  	assert.NoError(t, err)
   497  
   498  	info := []byte("test-context-info")
   499  
   500  	t.Run("AES-128", func(t *testing.T) {
   501  		key, err := DeriveKeyFromSharedSecret(sharedSecret, info, 16)
   502  		assert.NoError(t, err)
   503  		assert.Len(t, key, 16)
   504  	})
   505  
   506  	t.Run("AES-192", func(t *testing.T) {
   507  		key, err := DeriveKeyFromSharedSecret(sharedSecret, info, 24)
   508  		assert.NoError(t, err)
   509  		assert.Len(t, key, 24)
   510  	})
   511  
   512  	t.Run("AES-256", func(t *testing.T) {
   513  		key, err := DeriveKeyFromSharedSecret(sharedSecret, info, 32)
   514  		assert.NoError(t, err)
   515  		assert.Len(t, key, 32)
   516  	})
   517  
   518  	t.Run("Deterministic", func(t *testing.T) {
   519  		key1, err := DeriveKeyFromSharedSecret(sharedSecret, info, 32)
   520  		assert.NoError(t, err)
   521  
   522  		key2, err := DeriveKeyFromSharedSecret(sharedSecret, info, 32)
   523  		assert.NoError(t, err)
   524  
   525  		// Same inputs should produce same key
   526  		assert.Equal(t, key1, key2)
   527  	})
   528  
   529  	t.Run("Different Shared Secrets", func(t *testing.T) {
   530  		sharedSecret1 := make([]byte, 32)
   531  		sharedSecret2 := make([]byte, 32)
   532  		_, err := rand.Read(sharedSecret1)
   533  		assert.NoError(t, err)
   534  		_, err = rand.Read(sharedSecret2)
   535  		assert.NoError(t, err)
   536  
   537  		key1, err := DeriveKeyFromSharedSecret(sharedSecret1, info, 32)
   538  		assert.NoError(t, err)
   539  
   540  		key2, err := DeriveKeyFromSharedSecret(sharedSecret2, info, 32)
   541  		assert.NoError(t, err)
   542  
   543  		// Different shared secrets should produce different keys
   544  		assert.NotEqual(t, key1, key2)
   545  	})
   546  
   547  	t.Run("Different Info", func(t *testing.T) {
   548  		info1 := []byte("context1")
   549  		info2 := []byte("context2")
   550  
   551  		key1, err := DeriveKeyFromSharedSecret(sharedSecret, info1, 32)
   552  		assert.NoError(t, err)
   553  
   554  		key2, err := DeriveKeyFromSharedSecret(sharedSecret, info2, 32)
   555  		assert.NoError(t, err)
   556  
   557  		// Different info should produce different keys
   558  		assert.NotEqual(t, key1, key2)
   559  	})
   560  
   561  	t.Run("No Info", func(t *testing.T) {
   562  		key, err := DeriveKeyFromSharedSecret(sharedSecret, nil, 32)
   563  		assert.NoError(t, err)
   564  		assert.Len(t, key, 32)
   565  	})
   566  
   567  	t.Run("Invalid Key Size", func(t *testing.T) {
   568  		key, err := DeriveKeyFromSharedSecret(sharedSecret, info, 15)
   569  		assert.Error(t, err)
   570  		assert.Nil(t, key)
   571  		assert.Contains(t, err.Error(), "invalid AES key size")
   572  	})
   573  
   574  	t.Run("Empty Shared Secret", func(t *testing.T) {
   575  		key, err := DeriveKeyFromSharedSecret([]byte{}, info, 32)
   576  		assert.Error(t, err)
   577  		assert.Nil(t, key)
   578  		assert.Contains(t, err.Error(), "shared secret cannot be empty")
   579  	})
   580  
   581  	t.Run("Round Trip Encryption", func(t *testing.T) {
   582  		testData := []byte("test data for shared secret encryption")
   583  
   584  		key, err := DeriveKeyFromSharedSecret(sharedSecret, info, 32)
   585  		assert.NoError(t, err)
   586  
   587  		encrypted, err := EncryptAESGCM(testData, key, encryption.DefaultEncryptOptions())
   588  		assert.NoError(t, err)
   589  
   590  		// Derive the same key again
   591  		derivedKey, err := DeriveKeyFromSharedSecret(sharedSecret, info, 32)
   592  		assert.NoError(t, err)
   593  
   594  		decrypted, err := DecryptAESGCM(encrypted, derivedKey, encryption.DefaultDecryptOptions())
   595  		assert.NoError(t, err)
   596  		assert.Equal(t, testData, decrypted)
   597  	})
   598  }
   599  
   600  func TestGenerateSalt(t *testing.T) {
   601  	t.Run("Minimum Size", func(t *testing.T) {
   602  		salt, err := GenerateSalt(16)
   603  		assert.NoError(t, err)
   604  		assert.Len(t, salt, 16)
   605  	})
   606  
   607  	t.Run("Large Salt", func(t *testing.T) {
   608  		salt, err := GenerateSalt(64)
   609  		assert.NoError(t, err)
   610  		assert.Len(t, salt, 64)
   611  	})
   612  
   613  	t.Run("Salt Uniqueness", func(t *testing.T) {
   614  		salt1, err := GenerateSalt(16)
   615  		assert.NoError(t, err)
   616  
   617  		salt2, err := GenerateSalt(16)
   618  		assert.NoError(t, err)
   619  
   620  		// Salts should be different
   621  		assert.NotEqual(t, salt1, salt2)
   622  	})
   623  
   624  	t.Run("Salt Randomness", func(t *testing.T) {
   625  		salt, err := GenerateSalt(16)
   626  		assert.NoError(t, err)
   627  
   628  		// Salt should not be all zeros
   629  		allZeros := make([]byte, 16)
   630  		assert.NotEqual(t, allZeros, salt)
   631  	})
   632  
   633  	t.Run("Salt Too Small", func(t *testing.T) {
   634  		salt, err := GenerateSalt(8)
   635  		assert.Error(t, err)
   636  		assert.Nil(t, salt)
   637  		assert.Contains(t, err.Error(), "salt size too small")
   638  	})
   639  }
   640  
   641  func TestQuickEncryptSymmetric(t *testing.T) {
   642  	testData := []byte("test data for quick symmetric encryption")
   643  
   644  	t.Run("Valid Encryption", func(t *testing.T) {
   645  		key, err := GenerateAESKey(32)
   646  		assert.NoError(t, err)
   647  
   648  		encrypted, err := QuickEncryptSymmetric(testData, key)
   649  		assert.NoError(t, err)
   650  		assert.NotNil(t, encrypted)
   651  		assert.Equal(t, encryption.AlgorithmAESGCM, encrypted.Algorithm)
   652  		assert.NotEmpty(t, encrypted.Data)
   653  	})
   654  
   655  	t.Run("Invalid Key", func(t *testing.T) {
   656  		invalidKey := make([]byte, 15)
   657  
   658  		encrypted, err := QuickEncryptSymmetric(testData, invalidKey)
   659  		assert.Error(t, err)
   660  		assert.Nil(t, encrypted)
   661  	})
   662  }
   663  
   664  func TestQuickDecryptSymmetric(t *testing.T) {
   665  	testData := []byte("test data for quick symmetric decryption")
   666  
   667  	t.Run("Round Trip", func(t *testing.T) {
   668  		key, err := GenerateAESKey(32)
   669  		assert.NoError(t, err)
   670  
   671  		encrypted, err := QuickEncryptSymmetric(testData, key)
   672  		assert.NoError(t, err)
   673  
   674  		decrypted, err := QuickDecryptSymmetric(encrypted, key)
   675  		assert.NoError(t, err)
   676  		assert.Equal(t, testData, decrypted)
   677  	})
   678  
   679  	t.Run("Wrong Key", func(t *testing.T) {
   680  		key1, err := GenerateAESKey(32)
   681  		assert.NoError(t, err)
   682  		key2, err := GenerateAESKey(32)
   683  		assert.NoError(t, err)
   684  
   685  		encrypted, err := QuickEncryptSymmetric(testData, key1)
   686  		assert.NoError(t, err)
   687  
   688  		decrypted, err := QuickDecryptSymmetric(encrypted, key2)
   689  		assert.Error(t, err)
   690  		assert.Nil(t, decrypted)
   691  	})
   692  }
   693  
   694  func TestSymmetricPerformance(t *testing.T) {
   695  	if testing.Short() {
   696  		t.Skip("Skipping performance test in short mode")
   697  	}
   698  
   699  	key, err := GenerateAESKey(32)
   700  	assert.NoError(t, err)
   701  
   702  	// Test with different data sizes
   703  	dataSizes := []int{
   704  		1024,             // 1KB
   705  		1024 * 1024,      // 1MB
   706  		10 * 1024 * 1024, // 10MB
   707  	}
   708  
   709  	for _, size := range dataSizes {
   710  		t.Run(fmt.Sprintf("Size%dB", size), func(t *testing.T) {
   711  			data := make([]byte, size)
   712  			_, err := rand.Read(data)
   713  			assert.NoError(t, err)
   714  
   715  			// Measure encryption
   716  			encrypted, err := QuickEncryptSymmetric(data, key)
   717  			assert.NoError(t, err)
   718  
   719  			// Measure decryption
   720  			decrypted, err := QuickDecryptSymmetric(encrypted, key)
   721  			assert.NoError(t, err)
   722  
   723  			assert.True(t, bytes.Equal(data, decrypted))
   724  		})
   725  	}
   726  }