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 }