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

     1  package asymmetric
     2  
     3  import (
     4  	"crypto/rand"
     5  	"fmt"
     6  	"time"
     7  
     8  	"github.com/jasoet/gopki/encryption"
     9  	"github.com/jasoet/gopki/keypair/algo"
    10  )
    11  
    12  // EncryptWithECDSA encrypts data using ECDH key agreement + AES-GCM.
    13  //
    14  // This function uses elliptic curve Diffie-Hellman (ECDH) key agreement to establish
    15  // a shared secret, then uses that secret to derive an AES key for data encryption.
    16  // An ephemeral key pair is generated for each encryption operation to ensure forward secrecy.
    17  //
    18  // Process:
    19  //  1. Convert ECDSA keys to ECDH format
    20  //  2. Generate ephemeral sender key pair
    21  //  3. Perform ECDH key agreement to get shared secret
    22  //  4. Derive AES-256 key from shared secret
    23  //  5. Encrypt data with AES-GCM using derived key
    24  //  6. Include ephemeral public key in result for recipient
    25  //
    26  // Parameters:
    27  //   - data: The plaintext data to encrypt (no size limitations)
    28  //   - keyPair: The ECDSA key pair (public key used for key agreement)
    29  //   - opts: Encryption options (algorithm will be set to AlgorithmECDH)
    30  //
    31  // Returns:
    32  //   - *encryption.EncryptedData: Encrypted data with ECDH algorithm metadata
    33  //   - error: Any error that occurred during key agreement or encryption
    34  //
    35  // Security properties:
    36  //   - Perfect forward secrecy through ephemeral keys
    37  //   - Authenticated encryption via AES-GCM
    38  //   - Protection against key reuse attacks
    39  //
    40  // Example:
    41  //
    42  //	ecdsaKeys, _ := algo.GenerateECDSAKeyPair(algo.P256)
    43  //	data := []byte("large amount of data")  // No size limitations
    44  //
    45  //	encrypted, err := asymmetric.EncryptWithECDSA(data, ecdsaKeys, opts)
    46  //	if err != nil {
    47  //		log.Fatal("ECDSA encryption failed:", err)
    48  //	}
    49  func EncryptWithECDSA(data []byte, keyPair *algo.ECDSAKeyPair, opts encryption.EncryptOptions) (*encryption.EncryptedData, error) {
    50  	if err := encryption.ValidateEncryptOptions(opts); err != nil {
    51  		return nil, err
    52  	}
    53  
    54  	// Convert ECDSA key to ECDH for key agreement
    55  	ecdhPrivateKey, err := keyPair.PrivateKey.ECDH()
    56  	if err != nil {
    57  		return nil, fmt.Errorf("failed to convert ECDSA private key to ECDH: %w", err)
    58  	}
    59  
    60  	ecdhPublicKey, err := keyPair.PublicKey.ECDH()
    61  	if err != nil {
    62  		return nil, fmt.Errorf("failed to convert ECDSA public key to ECDH: %w", err)
    63  	}
    64  
    65  	// Generate ephemeral key pair for sender
    66  	ephemeralPrivateKey, err := ecdhPrivateKey.Curve().GenerateKey(rand.Reader)
    67  	if err != nil {
    68  		return nil, fmt.Errorf("failed to generate ephemeral key: %w", err)
    69  	}
    70  
    71  	// Perform ECDH key agreement
    72  	sharedSecret, err := ephemeralPrivateKey.ECDH(ecdhPublicKey)
    73  	if err != nil {
    74  		return nil, fmt.Errorf("ECDH key agreement failed: %w", err)
    75  	}
    76  
    77  	// Derive AES key from shared secret
    78  	aesKey := deriveAESKey(sharedSecret)
    79  
    80  	// Encrypt data using AES-GCM
    81  	encryptedData, iv, tag, err := encryptAESGCM(data, aesKey)
    82  	if err != nil {
    83  		return nil, fmt.Errorf("AES-GCM encryption failed: %w", err)
    84  	}
    85  
    86  	// Include ephemeral public key for recipient
    87  	ephemeralPublicKeyBytes := ephemeralPrivateKey.PublicKey().Bytes()
    88  
    89  	return &encryption.EncryptedData{
    90  		Algorithm:    encryption.AlgorithmECDH,
    91  		Format:       opts.Format,
    92  		Data:         encryptedData,
    93  		EncryptedKey: ephemeralPublicKeyBytes, // Store ephemeral public key
    94  		IV:           iv,
    95  		Tag:          tag,
    96  		Timestamp:    time.Now(),
    97  		Metadata:     opts.Metadata,
    98  	}, nil
    99  }
   100  
   101  // DecryptWithECDSA decrypts ECDH + AES-GCM encrypted data.
   102  //
   103  // This function reverses the ECDSA encryption process by:
   104  //  1. Converting the recipient's ECDSA private key to ECDH format
   105  //  2. Extracting the sender's ephemeral public key from encrypted data
   106  //  3. Performing ECDH key agreement to recover the shared secret
   107  //  4. Deriving the same AES key used for encryption
   108  //  5. Decrypting the data using AES-GCM
   109  //
   110  // Parameters:
   111  //   - encrypted: The encrypted data to decrypt (must contain ephemeral key)
   112  //   - keyPair: The ECDSA key pair (private key used for key agreement)
   113  //   - opts: Decryption options
   114  //
   115  // Returns:
   116  //   - []byte: The decrypted plaintext data
   117  //   - error: Any error that occurred during key agreement or decryption
   118  //
   119  // Example:
   120  //
   121  //	plaintext, err := asymmetric.DecryptWithECDSA(encrypted, ecdsaKeys, opts)
   122  func DecryptWithECDSA(encrypted *encryption.EncryptedData, keyPair *algo.ECDSAKeyPair, opts encryption.DecryptOptions) ([]byte, error) {
   123  	if err := encryption.ValidateDecryptOptions(opts); err != nil {
   124  		return nil, err
   125  	}
   126  
   127  	if encrypted.Algorithm != encryption.AlgorithmECDH {
   128  		return nil, fmt.Errorf("expected ECDH algorithm, got %s", encrypted.Algorithm)
   129  	}
   130  
   131  	// Convert ECDSA private key to ECDH
   132  	ecdhPrivateKey, err := keyPair.PrivateKey.ECDH()
   133  	if err != nil {
   134  		return nil, fmt.Errorf("failed to convert ECDSA private key to ECDH: %w", err)
   135  	}
   136  
   137  	// Parse ephemeral public key from ECDH bytes
   138  	curve := ecdhPrivateKey.Curve()
   139  	ephemeralECDHKey, err := curve.NewPublicKey(encrypted.EncryptedKey)
   140  	if err != nil {
   141  		return nil, fmt.Errorf("failed to parse ephemeral public key: %w", err)
   142  	}
   143  
   144  	// Perform ECDH key agreement
   145  	sharedSecret, err := ecdhPrivateKey.ECDH(ephemeralECDHKey)
   146  	if err != nil {
   147  		return nil, fmt.Errorf("ECDH key agreement failed: %w", err)
   148  	}
   149  
   150  	// Derive AES key from shared secret
   151  	aesKey := deriveAESKey(sharedSecret)
   152  
   153  	// Decrypt data using AES-GCM
   154  	decrypted, err := decryptAESGCM(encrypted.Data, aesKey, encrypted.IV, encrypted.Tag)
   155  	if err != nil {
   156  		return nil, fmt.Errorf("AES-GCM decryption failed: %w", err)
   157  	}
   158  
   159  	return decrypted, nil
   160  }