A Beleza da Criptografia de Chave Pública com Encapsulamento de Chave: HPKE

A Beleza da Encriptação de Chave Pública com Encapsulamento de Chave: HPKE

Podemos, claro, encriptar dados com RSA OAEP, mas as chaves são bastante grandes e o processo é bastante intensivo. O uso da criptografia de curva elíptica (ECC) tem sido a nossa salvação. Mas, podemos realmente encriptar dados diretamente com ECC e, por isso, usamos um método de encapsulamento de chave (KEM), que também é usado em métodos PQC. Com isto, usamos um método de troca de chaves Diffie-Hellman (DH) — mas fazemo-lo de forma offline.

Digamos que Bob quer encriptar dados para Alice. Para isso, Bob terá uma chave privada b e uma chave pública b.G, e Alice terá uma chave privada a e uma chave pública a.G. O ponto base na curva elíptica é então G, e onde a.G é o ponto G adicionado a si mesmo a vezes. Bob inicialmente obtém a chave pública de Alice (a.G) de forma confiável. Ele então pegará sua chave privada (b) e realizará uma operação Diffie-Hellman para dar um ponto resultante de a.B.G. Em seguida, ele alimenta isso no método HKDF para expandir e extrair para uma chave AES, juntamente com alguns dados de contexto. Isso derivará uma chave secreta (SecretKey), que será usada para encriptar algum texto simples:

Bob também serializará sua chave pública e a enviará junto com a mensagem. Isso também terá um valor de hash que mostrará que a mensagem encriptada e a chave pública serializada não foram adulteradas.

Para descriptografar, Alice desserializa a chave pública de Bob para produzir b.G. Ela então pegará sua chave privada (a) e realizará uma operação Diffie-Hellman para obter a.b.G. Alimentamos isso em uma função HKDF com o contexto, que produzirá a mesma chave secreta que Bob (SecretKey). Alice poderá então descriptografar o texto cifrado e revelar a mensagem.

Com Hybrid Public Key Encryption (HPKE), usamos a chave pública de um destinatário para encriptar texto simples usando um mecanismo de encapsulamento de chave assimétrica (KEM). A chave é derivada usando uma função de derivação de chave (KDF), e onde os dados são encriptados com uma encriptação autenticada com função de dados adicionais (AEAD). Neste caso, usaremos: DHKEM_P256_HKDF_SHA256 (usando P256 como o KEM), DHKEM_P384_HKDF_SHA384 (usando P384 como o KEM), DHKEM_P521_HKDF_SHA512 (usando P521 como o KEM) ou DHKEM_X25519_HKDF_SHA256 (usando X25519 como o KEM). Em cada caso, HKDF é usado para gerar a chave.

O código está [here]:

package main
import (
       "fmt"
 "os"
 "strconv"
 "github.com/tink-crypto/tink-go/v2/hybrid/hpke"
 "github.com/tink-crypto/tink-go/v2/hybrid"
 "github.com/tink-crypto/tink-go/v2/keyset"
)
func main() {
 msg:="Testing"
 context:="My Context"

 method:=hpke.DHKEM_P256_HKDF_SHA256
 m:=1
 argCount := len(os.Args[1:])
 if (argCount>0) {msg = os.Args[1]}
 if (argCount>1) {context =os.Args[2]}
 if (argCount>2) {m,_ =strconv.Atoi(os.Args[3])}

 if (m==2) {method=hpke.DHKEM_P384_HKDF_SHA384
 } else if (m==3) {method=hpke.DHKEM_P521_HKDF_SHA512
 } else if (m==4) {method=hpke.DHKEM_X25519_HKDF_SHA256
 } 
 plaintext := []byte(msg)
 contextInfo := []byte(context)
 params,_ := hpke.NewParameters(hpke.ParametersOpts{
  KEMID:   method,
  KDFID:   hpke.HKDFSHA256,
  AEADID:  hpke.AES256GCM,
  Variant: hpke.VariantTink,
 })
 
 km := keyset.NewManager()
 keyID, _ := km.AddNewKeyFromParameters(params)
 if err := km.SetPrimary(keyID); err != nil {
 }
 privateKeyHandle, _ := km.Handle()

 publicKeyHandle, _ := privateKeyHandle.Public()

 encrypter, _ := hybrid.NewHybridEncrypt(publicKeyHandle)
 decrypter, _ := hybrid.NewHybridDecrypt(privateKeyHandle)

 ciphertext,_ := encrypter.Encrypt(plaintext, contextInfo)
 decrypted,_ := decrypter.Decrypt(ciphertext, contextInfo)

 fmt.Printf("Plaintext: %s\n\n",msg)
 fmt.Printf("Method: %s\n\n",method)
 fmt.Printf("Private key: %s\n\n",privateKeyHandle)
 fmt.Printf("Public key: %s\n\n",publicKeyHandle)
 fmt.Printf("Ciphertext: %x\n\n",ciphertext)
 fmt.Printf("Decrypted: %s\n",decrypted)

}

Uma execução de amostra para DHKEM-P256-HKDF-SHA256 está [here]:

Plaintext: Testing
Method: DHKEM-P256-HKDF-SHA256
Private key: primary_key_id:1203322961 key_info:{type_url:"type.googleapis.com/google.crypto.tink.HpkePrivateKey" status:ENABLED key_id:1203322961 output_prefix_type:TINK}
Public key: primary_key_id:1203322961 key_info:{type_url:"type.googleapis.com/google.crypto.tink.HpkePublicKey" status:ENABLED key_id:1203322961 output_prefix_type:TINK}
Ciphertext: 0147b94051043bdeb59abad6caebff20753dadfc0bf8a2d6131b6935f149afdc84b450dda4316d79bae3529eaafec63197a55ffd30c186ffea74bbcb811bfb2b93dacfeaab3b4cc8352534fd5f2e7252abac03553b16d607ea791df7c9
Decrypted: Testing