Recomendamos la primitiva AEAD con el valor Tipo de clave AES128_GCM para la mayoría de los casos de uso de encriptación de datos.
La encriptación autenticada con datos asociados (AEAD) es la forma más sencilla más apropiada para la mayoría de los casos de uso. AEAD proporciona confidencialidad y autenticidad y garantiza que los mensajes siempre tengan textos cifrados diferentes. (salidas encriptadas), incluso si los textos sin formato (las entradas para la encriptación) la misma. Es simétrico y usa una sola clave para la encriptación y desencriptación.
En los siguientes ejemplos, puedes comenzar a usar la primitiva AEAD:
C++
// A command-line utility for testing Tink AEAD.
#include <iostream>
#include <memory>
#include <ostream>
#include <string>
#include "absl/flags/flag.h"
#include "absl/flags/parse.h"
#include "absl/log/check.h"
#include "absl/strings/string_view.h"
#include "tink/aead.h"
#include "tink/aead/aead_config.h"
#include "tink/config/global_registry.h"
#include "util/util.h"
#include "tink/keyset_handle.h"
#include "tink/util/status.h"
ABSL_FLAG(std::string, keyset_filename, "", "Keyset file in JSON format");
ABSL_FLAG(std::string, mode, "", "Mode of operation {encrypt|decrypt}");
ABSL_FLAG(std::string, input_filename, "", "Filename to operate on");
ABSL_FLAG(std::string, output_filename, "", "Output file name");
ABSL_FLAG(std::string, associated_data, "",
"Associated data for AEAD (default: empty");
namespace {
using ::crypto::tink::Aead;
using ::crypto::tink::AeadConfig;
using ::crypto::tink::KeysetHandle;
using ::crypto::tink::util::Status;
using ::crypto::tink::util::StatusOr;
constexpr absl::string_view kEncrypt = "encrypt";
constexpr absl::string_view kDecrypt = "decrypt";
void ValidateParams() {
// ...
}
} // namespace
namespace tink_cc_examples {
// AEAD example CLI implementation.
Status AeadCli(absl::string_view mode, const std::string& keyset_filename,
const std::string& input_filename,
const std::string& output_filename,
absl::string_view associated_data) {
Status result = AeadConfig::Register();
if (!result.ok()) return result;
// Read the keyset from file.
StatusOr<std::unique_ptr<KeysetHandle>> keyset_handle =
ReadJsonCleartextKeyset(keyset_filename);
if (!keyset_handle.ok()) return keyset_handle.status();
// Get the primitive.
StatusOr<std::unique_ptr<Aead>> aead =
(*keyset_handle)
->GetPrimitive<crypto::tink::Aead>(
crypto::tink::ConfigGlobalRegistry());
if (!aead.ok()) return aead.status();
// Read the input.
StatusOr<std::string> input_file_content = ReadFile(input_filename);
if (!input_file_content.ok()) return input_file_content.status();
// Compute the output.
std::string output;
if (mode == kEncrypt) {
StatusOr<std::string> encrypt_result =
(*aead)->Encrypt(*input_file_content, associated_data);
if (!encrypt_result.ok()) return encrypt_result.status();
output = encrypt_result.value();
} else { // operation == kDecrypt.
StatusOr<std::string> decrypt_result =
(*aead)->Decrypt(*input_file_content, associated_data);
if (!decrypt_result.ok()) return decrypt_result.status();
output = decrypt_result.value();
}
// Write the output to the output file.
return WriteToFile(output, output_filename);
}
} // namespace tink_cc_examples
int main(int argc, char** argv) {
absl::ParseCommandLine(argc, argv);
ValidateParams();
std::string mode = absl::GetFlag(FLAGS_mode);
std::string keyset_filename = absl::GetFlag(FLAGS_keyset_filename);
std::string input_filename = absl::GetFlag(FLAGS_input_filename);
std::string output_filename = absl::GetFlag(FLAGS_output_filename);
std::string associated_data = absl::GetFlag(FLAGS_associated_data);
std::clog << "Using keyset from file " << keyset_filename << " to AEAD-"
<< mode << " file " << input_filename << " with associated data '"
<< associated_data << "'." << '\n';
std::clog << "The resulting output will be written to " << output_filename
<< '\n';
CHECK_OK(tink_cc_examples::AeadCli(mode, keyset_filename, input_filename,
output_filename, associated_data));
return 0;
}
Go
import (
"bytes"
"fmt"
"log"
"github.com/tink-crypto/tink-go/v2/aead"
"github.com/tink-crypto/tink-go/v2/insecurecleartextkeyset"
"github.com/tink-crypto/tink-go/v2/keyset"
)
func Example() {
// A keyset created with "tinkey create-keyset --key-template=AES256_GCM". Note
// that this keyset has the secret key information in cleartext.
jsonKeyset := `{
"key": [{
"keyData": {
"keyMaterialType":
"SYMMETRIC",
"typeUrl":
"type.googleapis.com/google.crypto.tink.AesGcmKey",
"value":
"GiBWyUfGgYk3RTRhj/LIUzSudIWlyjCftCOypTr0jCNSLg=="
},
"keyId": 294406504,
"outputPrefixType": "TINK",
"status": "ENABLED"
}],
"primaryKeyId": 294406504
}`
// Create a keyset handle from the cleartext keyset in the previous
// step. The keyset handle provides abstract access to the underlying keyset to
// limit the exposure of accessing the raw key material. WARNING: In practice,
// it is unlikely you will want to use a insecurecleartextkeyset, as it implies
// that your key material is passed in cleartext, which is a security risk.
// Consider encrypting it with a remote key in Cloud KMS, AWS KMS or HashiCorp Vault.
// See https://github.com/google/tink/blob/master/docs/GOLANG-HOWTO.md#storing-and-loading-existing-keysets.
keysetHandle, err := insecurecleartextkeyset.Read(
keyset.NewJSONReader(bytes.NewBufferString(jsonKeyset)))
if err != nil {
log.Fatal(err)
}
// Retrieve the AEAD primitive we want to use from the keyset handle.
primitive, err := aead.New(keysetHandle)
if err != nil {
log.Fatal(err)
}
// Use the primitive to encrypt a message. In this case the primary key of the
// keyset will be used (which is also the only key in this example).
plaintext := []byte("message")
associatedData := []byte("associated data")
ciphertext, err := primitive.Encrypt(plaintext, associatedData)
if err != nil {
log.Fatal(err)
}
// Use the primitive to decrypt the message. Decrypt finds the correct key in
// the keyset and decrypts the ciphertext. If no key is found or decryption
// fails, it returns an error.
decrypted, err := primitive.Decrypt(ciphertext, associatedData)
if err != nil {
log.Fatal(err)
}
fmt.Println(string(decrypted))
// Output: message
}
Java
package aead;
import static java.nio.charset.StandardCharsets.UTF_8;
import com.google.crypto.tink.Aead;
import com.google.crypto.tink.InsecureSecretKeyAccess;
import com.google.crypto.tink.KeysetHandle;
import com.google.crypto.tink.TinkJsonProtoKeysetFormat;
import com.google.crypto.tink.aead.AeadConfig;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
/**
* A command-line utility for encrypting small files with AEAD.
*
* <p>It loads cleartext keys from disk - this is not recommended!
*
* <p>It requires the following arguments:
*
* <ul>
* <li>mode: Can be "encrypt" or "decrypt" to encrypt/decrypt the input to the output.
* <li>key-file: Read the key material from this file.
* <li>input-file: Read the input from this file.
* <li>output-file: Write the result to this file.
* <li>[optional] associated-data: Associated data used for the encryption or decryption.
*/
public final class AeadExample {
private static final String MODE_ENCRYPT = "encrypt";
private static final String MODE_DECRYPT = "decrypt";
public static void main(String[] args) throws Exception {
if (args.length != 4 && args.length != 5) {
System.err.printf("Expected 4 or 5 parameters, got %d\n", args.length);
System.err.println(
"Usage: java AeadExample encrypt/decrypt key-file input-file output-file"
+ " [associated-data]");
System.exit(1);
}
String mode = args[0];
Path keyFile = Paths.get(args[1]);
Path inputFile = Paths.get(args[2]);
Path outputFile = Paths.get(args[3]);
byte[] associatedData = new byte[0];
if (args.length == 5) {
associatedData = args[4].getBytes(UTF_8);
}
// Register all AEAD key types with the Tink runtime.
AeadConfig.register();
// Read the keyset into a KeysetHandle.
KeysetHandle handle =
TinkJsonProtoKeysetFormat.parseKeyset(
new String(Files.readAllBytes(keyFile), UTF_8), InsecureSecretKeyAccess.get());
// Get the primitive.
Aead aead = handle.getPrimitive(Aead.class);
// Use the primitive to encrypt/decrypt files.
if (MODE_ENCRYPT.equals(mode)) {
byte[] plaintext = Files.readAllBytes(inputFile);
byte[] ciphertext = aead.encrypt(plaintext, associatedData);
Files.write(outputFile, ciphertext);
} else if (MODE_DECRYPT.equals(mode)) {
byte[] ciphertext = Files.readAllBytes(inputFile);
byte[] plaintext = aead.decrypt(ciphertext, associatedData);
Files.write(outputFile, plaintext);
} else {
System.err.println("The first argument must be either encrypt or decrypt, got: " + mode);
System.exit(1);
}
}
private AeadExample() {}
}
Obj-C
Python
import tink
from tink import aead
from tink import secret_key_access
def example():
"""Encrypt and decrypt using AEAD."""
# Register the AEAD key managers. This is needed to create an Aead primitive
# later.
aead.register()
# A keyset created with "tinkey create-keyset --key-template=AES256_GCM". Note
# that this keyset has the secret key information in cleartext.
keyset = r"""{
"key": [{
"keyData": {
"keyMaterialType":
"SYMMETRIC",
"typeUrl":
"type.googleapis.com/google.crypto.tink.AesGcmKey",
"value":
"GiBWyUfGgYk3RTRhj/LIUzSudIWlyjCftCOypTr0jCNSLg=="
},
"keyId": 294406504,
"outputPrefixType": "TINK",
"status": "ENABLED"
}],
"primaryKeyId": 294406504
}"""
# Create a keyset handle from the cleartext keyset in the previous
# step. The keyset handle provides abstract access to the underlying keyset to
# limit access of the raw key material. WARNING: In practice, it is unlikely
# you will want to use a cleartext_keyset_handle, as it implies that your key
# material is passed in cleartext, which is a security risk.
keyset_handle = tink.json_proto_keyset_format.parse(
keyset, secret_key_access.TOKEN
)
# Retrieve the Aead primitive we want to use from the keyset handle.
primitive = keyset_handle.primitive(aead.Aead)
# Use the primitive to encrypt a message. In this case the primary key of the
# keyset will be used (which is also the only key in this example).
ciphertext = primitive.encrypt(b'msg', b'associated_data')
# Use the primitive to decrypt the message. Decrypt finds the correct key in
# the keyset and decrypts the ciphertext. If no key is found or decryption
# fails, it raises an error.
output = primitive.decrypt(ciphertext, b'associated_data')
AEAD
El tipo primitivo de encriptación autenticada con datos asociados (AEAD) es común para la encriptación de datos y es adecuada para la mayoría de las necesidades.
AEAD tiene las siguientes propiedades:
- Secrecy: no se conoce nada sobre el texto simple, excepto su longitud.
- Autenticidad: Es imposible cambiar el texto simple encriptado. subyacente sin ser detectada.
- Simétrica: Encriptar el texto simple y desencriptar el texto cifrado es con la misma clave.
- Aleatorización: La encriptación es aleatoria. Dos mensajes con el mismo el texto simple generan textos cifrados diferentes. Los atacantes no pueden saber el texto cifrado corresponde a un texto simple determinado. Si quieres evitarlo, usa AEAD determinista en su lugar.
Datos asociados
Los AEAD se pueden usar para vincular el cifrado a valores específicos
los datos en la nube. Supongamos que tienes una base de datos con los campos user-id.
y encrypted-medical-history. En este caso, user-id se puede usar como
los datos asociados al encriptar encrypted-medical-history. Esto evita que se produzca un
de transferir los antecedentes médicos de un usuario a otro.
Elige un tipo de clave
Si bien recomendamos AES128_GCM para la mayoría de los usos, hay varios tipos de claves para necesidades diferentes (para la seguridad de 256 bits, reemplaza AES128 por AES256 a continuación). Generalmente:
- AES128_CTR_HMAC_SHA256 con un vector de inicialización (IV) de 16 bytes es el valor modo conservador con buenos límites.
- AES128_EAX es un poco menos conservador y un poco más rápido que AES128_CTR_HMAC_SHA256.
- AES128_GCM suele ser el modo más rápido, con los límites más estrictos en la la cantidad y el tamaño de los mensajes. Cuando estos límites en el texto simple y se superan las longitudes de datos asociadas (debajo), AES128_GCM falla y se filtra la clave. el material de lectura.
- AES128_GCM_SIV es casi tan rápida como AES128_GCM, con límites muy buenos para un pero está un poco menos establecido. Para usar esto en Java, debes instalar Conscrypt.
- XChaCha20Poly1305 tiene un límite mucho mayor para la cantidad de mensajes y tamaño de mensaje que AES128_GCM, pero cuando falla (muy improbable) también filtra material de claves. No está acelerado por hardware, por lo que puede ser más lento que Modos AES en situaciones en las que la aceleración de hardware está disponible
Garantías de seguridad
Las implementaciones de AEAD ofrecen lo siguiente:
- Seguridad CCA2:
- Seguridad de al menos 80 bits.
- La capacidad de encriptar al menos 232 mensajes con un total de 250 bytes. No hay ataques con hasta 232 textos sin formato elegidos o texto cifrado elegidos tiene una probabilidad de éxito mayor que 2-32.