이 경우 하이브리드 암호화 프리미티브를 DHKEM_X25519_HKDF_SHA256, HKDF_SHA256, AES_256_GCM 키 암호화 사용 사례에 적합합니다
공개 키 암호화는 공개 키와 1개라는 두 개의 키로 데이터를 보호하는 것입니다. 비공개입니다. 공개 키가 암호화에 사용되고 비공개 키가 사용됩니다. 암호화되어 있습니다 이 방법은 발신자가 보안 비밀을 저장할 수 없고 공개 키로 데이터를 암호화해야 하는 경우
다음 예에서는 하이브리드 암호화 기본 요소를 사용하기 시작할 수 있습니다.
C++
// A command-line utility for testing Tink Hybrid Encryption.
#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/config/global_registry.h"
#include "util/util.h"
#ifndef TINK_EXAMPLES_EXCLUDE_HPKE
#include "tink/hybrid/hpke_config.h"
#endif
#include "tink/hybrid/hybrid_config.h"
#include "tink/hybrid_decrypt.h"
#include "tink/hybrid_encrypt.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, "", "Input file name");
ABSL_FLAG(std::string, output_filename, "", "Output file name");
ABSL_FLAG(std::string, context_info, "",
"Context info for Hybrid Encryption/Decryption");
namespace {
using ::crypto::tink::HybridDecrypt;
using ::crypto::tink::HybridEncrypt;
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 {
Status HybridCli(absl::string_view mode, const std::string& keyset_filename,
const std::string& input_filename,
const std::string& output_filename,
absl::string_view context_info) {
Status result = crypto::tink::HybridConfig::Register();
if (!result.ok()) return result;
#ifndef TINK_EXAMPLES_EXCLUDE_HPKE
// HPKE isn't supported when using OpenSSL as a backend.
result = crypto::tink::RegisterHpke();
if (!result.ok()) return result;
#endif
// Read the keyset from file.
StatusOr<std::unique_ptr<KeysetHandle>> keyset_handle =
ReadJsonCleartextKeyset(keyset_filename);
if (!keyset_handle.ok()) return keyset_handle.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) {
// Get the hybrid encryption primitive.
StatusOr<std::unique_ptr<HybridEncrypt>> hybrid_encrypt_primitive =
(*keyset_handle)
->GetPrimitive<crypto::tink::HybridEncrypt>(
crypto::tink::ConfigGlobalRegistry());
if (!hybrid_encrypt_primitive.ok()) {
return hybrid_encrypt_primitive.status();
}
// Generate the ciphertext.
StatusOr<std::string> encrypt_result =
(*hybrid_encrypt_primitive)->Encrypt(*input_file_content, context_info);
if (!encrypt_result.ok()) return encrypt_result.status();
output = encrypt_result.value();
} else { // operation == kDecrypt.
// Get the hybrid decryption primitive.
StatusOr<std::unique_ptr<HybridDecrypt>> hybrid_decrypt_primitive =
(*keyset_handle)
->GetPrimitive<crypto::tink::HybridDecrypt>(
crypto::tink::ConfigGlobalRegistry());
if (!hybrid_decrypt_primitive.ok()) {
return hybrid_decrypt_primitive.status();
}
// Recover the plaintext.
StatusOr<std::string> decrypt_result =
(*hybrid_decrypt_primitive)->Decrypt(*input_file_content, context_info);
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 context_info = absl::GetFlag(FLAGS_context_info);
std::clog << "Using keyset from file " << keyset_filename << " to hybrid "
<< mode << " file " << input_filename << " with context info '"
<< context_info << "'." << '\n';
std::clog << "The resulting output will be written to " << output_filename
<< '\n';
CHECK_OK(tink_cc_examples::HybridCli(mode, keyset_filename, input_filename,
output_filename, context_info));
return 0;
}
Go
import (
"bytes"
"fmt"
"log"
"github.com/tink-crypto/tink-go/v2/hybrid"
"github.com/tink-crypto/tink-go/v2/insecurecleartextkeyset"
"github.com/tink-crypto/tink-go/v2/keyset"
)
func Example() {
// A private keyset created with
// "tinkey create-keyset --key-template=DHKEM_X25519_HKDF_SHA256_HKDF_SHA256_AES_256_GCM --out private_keyset.cfg".
// Note that this keyset has the secret key information in cleartext.
privateJSONKeyset := `{
"key": [{
"keyData": {
"keyMaterialType":
"ASYMMETRIC_PRIVATE",
"typeUrl":
"type.googleapis.com/google.crypto.tink.HpkePrivateKey",
"value":
"EioSBggBEAEYAhogVWQpmQoz74jcAp5WOD36KiBQ71MVCpn2iWfOzWLtKV4aINfn8qlMbyijNJcCzrafjsgJ493ZZGN256KTfKw0WN+p"
},
"keyId": 958452012,
"outputPrefixType": "TINK",
"status": "ENABLED"
}],
"primaryKeyId": 958452012
}`
// The corresponding public keyset created with
// "tinkey create-public-keyset --in private_keyset.cfg".
publicJSONKeyset := `{
"key": [{
"keyData": {
"keyMaterialType":
"ASYMMETRIC_PUBLIC",
"typeUrl":
"type.googleapis.com/google.crypto.tink.HpkePublicKey",
"value":
"EgYIARABGAIaIFVkKZkKM++I3AKeVjg9+iogUO9TFQqZ9olnzs1i7Sle"
},
"keyId": 958452012,
"outputPrefixType": "TINK",
"status": "ENABLED"
}],
"primaryKeyId": 958452012
}`
// Create a keyset handle from the keyset containing the public key. Because the
// public keyset does not contain any secrets, we can use [keyset.ReadWithNoSecrets].
publicKeysetHandle, err := keyset.ReadWithNoSecrets(
keyset.NewJSONReader(bytes.NewBufferString(publicJSONKeyset)))
if err != nil {
log.Fatal(err)
}
// Retrieve the HybridEncrypt primitive from publicKeysetHandle.
encPrimitive, err := hybrid.NewHybridEncrypt(publicKeysetHandle)
if err != nil {
log.Fatal(err)
}
plaintext := []byte("message")
encryptionContext := []byte("encryption context")
ciphertext, err := encPrimitive.Encrypt(plaintext, encryptionContext)
if err != nil {
log.Fatal(err)
}
// Create a keyset handle from the cleartext private keyset in the previous
// step. The keyset handle provides abstract access to the underlying keyset to
// limit the access of 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.
privateKeysetHandle, err := insecurecleartextkeyset.Read(
keyset.NewJSONReader(bytes.NewBufferString(privateJSONKeyset)))
if err != nil {
log.Fatal(err)
}
// Retrieve the HybridDecrypt primitive from privateKeysetHandle.
decPrimitive, err := hybrid.NewHybridDecrypt(privateKeysetHandle)
if err != nil {
log.Fatal(err)
}
decrypted, err := decPrimitive.Decrypt(ciphertext, encryptionContext)
if err != nil {
log.Fatal(err)
}
fmt.Println(string(decrypted))
// Output: message
}
자바
package hybrid;
import static java.nio.charset.StandardCharsets.UTF_8;
import com.google.crypto.tink.HybridDecrypt;
import com.google.crypto.tink.HybridEncrypt;
import com.google.crypto.tink.InsecureSecretKeyAccess;
import com.google.crypto.tink.KeysetHandle;
import com.google.crypto.tink.TinkJsonProtoKeysetFormat;
import com.google.crypto.tink.hybrid.HybridConfig;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
/**
* A command-line utility for hybrid encryption.
*
* <p>It loads cleartext keys from disk - this is not recommended!
*
* <p>It requires the following arguments:
*
* <ul>
* <li>mode: either 'encrypt' or 'decrypt'.
* <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] contex-info: Bind the encryption to this context info.
*/
public final class HybridExample {
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 HybridExample encrypt/decrypt key-file input-file output-file context-info");
System.exit(1);
}
String mode = args[0];
if (!mode.equals("encrypt") && !mode.equals("decrypt")) {
System.err.println("Incorrect mode. Please select encrypt or decrypt.");
System.exit(1);
}
Path keyFile = Paths.get(args[1]);
Path inputFile = Paths.get(args[2]);
byte[] input = Files.readAllBytes(inputFile);
Path outputFile = Paths.get(args[3]);
byte[] contextInfo = new byte[0];
if (args.length == 5) {
contextInfo = args[4].getBytes(UTF_8);
}
// Register all hybrid encryption key types with the Tink runtime.
HybridConfig.register();
// Read the keyset into a KeysetHandle.
KeysetHandle handle =
TinkJsonProtoKeysetFormat.parseKeyset(
new String(Files.readAllBytes(keyFile), UTF_8), InsecureSecretKeyAccess.get());
if (mode.equals("encrypt")) {
// Get the primitive.
HybridEncrypt encryptor = handle.getPrimitive(HybridEncrypt.class);
// Use the primitive to encrypt data.
byte[] ciphertext = encryptor.encrypt(input, contextInfo);
Files.write(outputFile, ciphertext);
} else {
HybridDecrypt decryptor = handle.getPrimitive(HybridDecrypt.class);
// Use the primitive to decrypt data.
byte[] plaintext = decryptor.decrypt(input, contextInfo);
Files.write(outputFile, plaintext);
}
}
private HybridExample() {}
}
Obj-C
Python
import tink
from tink import hybrid
from tink import secret_key_access
def example():
"""Encrypt and decrypt using hybrid encryption."""
# Register the hybrid encryption key managers. This is needed to create
# HybridEncrypt and HybridDecrypt primitives later.
hybrid.register()
# A private keyset created with
# tinkey create-keyset \
# --key-template=DHKEM_X25519_HKDF_SHA256_HKDF_SHA256_AES_256_GCM \
# --out private_keyset.cfg
# Note that this keyset has the secret key information in cleartext.
private_keyset = r"""{
"key": [{
"keyData": {
"keyMaterialType":
"ASYMMETRIC_PRIVATE",
"typeUrl":
"type.googleapis.com/google.crypto.tink.HpkePrivateKey",
"value":
"EioSBggBEAEYAhogVWQpmQoz74jcAp5WOD36KiBQ71MVCpn2iWfOzWLtKV4aINfn8qlMbyijNJcCzrafjsgJ493ZZGN256KTfKw0WN+p"
},
"keyId": 958452012,
"outputPrefixType": "TINK",
"status": "ENABLED"
}],
"primaryKeyId": 958452012
}"""
# The corresponding public keyset created with
# "tinkey create-public-keyset --in private_keyset.cfg"
public_keyset = r"""{
"key": [{
"keyData": {
"keyMaterialType":
"ASYMMETRIC_PUBLIC",
"typeUrl":
"type.googleapis.com/google.crypto.tink.HpkePublicKey",
"value":
"EgYIARABGAIaIFVkKZkKM++I3AKeVjg9+iogUO9TFQqZ9olnzs1i7Sle" },
"keyId": 958452012,
"outputPrefixType": "TINK",
"status": "ENABLED"
}],
"primaryKeyId": 958452012
}"""
# Create a keyset handle from the keyset containing the public key. Because
# this keyset does not contain any secrets, we can use
# `parse_without_secret`.
public_keyset_handle = tink.json_proto_keyset_format.parse_without_secret(
public_keyset
)
# Retrieve the HybridEncrypt primitive from the keyset handle.
enc_primitive = public_keyset_handle.primitive(hybrid.HybridEncrypt)
# Use enc_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 = enc_primitive.encrypt(b'message', b'context_info')
# Create a keyset handle from the private keyset. 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 tink.json_proto_keyset_format.parse, as it implies that your key
# material is passed in cleartext which is a security risk.
private_keyset_handle = tink.json_proto_keyset_format.parse(
private_keyset, secret_key_access.TOKEN
)
# Retrieve the HybridDecrypt primitive from the private keyset handle.
dec_primitive = private_keyset_handle.primitive(hybrid.HybridDecrypt)
# Use dec_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.
decrypted = dec_primitive.decrypt(ciphertext, b'context_info')
하이브리드 암호화
하이브리드 암호화 프리미티브는 대칭 암호화의 효율성을 결합하고 공개 키 (비대칭) 암호화의 편의성을 사용합니다. 누구나 암호화할 수 있음 공개 키를 사용하여 데이터를 암호화할 수 있지만 비공개 키가 있는 사용자만 데이터를 수집하는 데 사용됩니다
하이브리드 암호화의 경우 발신자가 새로운 대칭 키를 생성하여 일반 텍스트를 사용하여 암호문을 생성합니다. 그 대칭 키는 수신자의 공개 키로 캡슐화되어 있습니다. 하이브리드 복호화의 경우 대칭 키는 수신자에 의해 캡슐화 해제된 다음 원래의 일반 텍스트를 복구합니다. Tink 하이브리드 암호화 전송 참조 형식을 참조하세요. 키 캡슐화와 함께 암호문을 전송합니다.
하이브리드 암호화에는 다음과 같은 속성이 있습니다.
- Secrecy: 아무도 암호화된 보안에 관한 정보를 일반 텍스트 (길이 제외)를 사용합니다.
- 비대칭: 암호문은 공개 키로 암호화할 수 있습니다. 복호화를 위해서는 개인 키가 필요합니다.
- 무작위 지정: 암호화가 무작위로 이루어집니다. 동일한 일반 텍스트는 동일한 암호문을 생성하지 않습니다. 이를 통해 공격자는 지정된 일반 텍스트에 해당하는 암호문을 파악합니다.
하이브리드 암호화는 Tink에 한 쌍의 프리미티브로 표시됩니다.
- 암호화를 위한 HybridEncrypt
- 복호화용 HybridDecrypt
컨텍스트 정보 매개변수
하이브리드 암호화는 일반 텍스트 외에도
context_info는 일반적으로 컨텍스트에서 암시적인 공개 데이터이지만
결과 암호문에 바인딩되어야 합니다. 이것은 암호문이
이를 통해 컨텍스트 정보의 무결성을 확인할 수는 있지만
보장한다는 것을 의미합니다 실제 컨텍스트 정보는 비워 둘 수 있습니다.
또는 null이지만 결과 암호문의 올바른 복호화를 보장하기 위해
복호화를 위해 동일한 컨텍스트 정보 값이 제공되어야 합니다.
하이브리드 암호화의 구체적인 구현은 컨텍스트 정보를 사용할 수 있습니다. 예를 들면 다음과 같습니다.
- AEAD 대칭 암호화를 위한 관련 데이터 입력으로
context_info사용 (참고: RFC 5116). context_info를 'CtxInfo'로 사용 HKDF 입력 (구현에서 키 파생 함수로서의 HKDF, 참고: RFC 5869).
키 유형 선택
DHKEM_X25519_HKDF_SHA256_HKDF_SHA256_AES_256_GCM
키 유형을 지원합니다 이 키 유형은 하이브리드 공개 키를 구현합니다.
RFC에 지정된 암호화 (HPKE) 표준
9180 HPKE는
키 파생 함수 (KDF), 키 파생 함수 (KDF) 및
관련 데이터 (AEAD) 알고리즘을 사용한 인증된 암호화
DHKEM_X25519_HKDF_SHA256_HKDF_SHA256_AES_256_GCM에서는 구체적으로 다음을 채택합니다.
- KEM: HKDF-SHA-256을 사용하여 Curve25519에 대한 Diffie–Hellman이 공유 보안 비밀.
- KDF: HKDF-SHA-256으로 발신자 및 수신자 컨텍스트를 가져옵니다.
- AEAD: HPKE에 따라 생성된 12바이트 nonce가 있는 AES-256-GCM 있습니다.
지원되는 기타 HPKE 키 유형에는 다음이 포함되나 이에 국한되지 않습니다.
DHKEM_X25519_HKDF_SHA256_HKDF_SHA256_AES_128_GCMDHKEM_X25519_HKDF_SHA256_HKDF_SHA256_CHACHA20_POLY1305DHKEM_P256_HKDF_SHA256_HKDF_SHA256_AES_128_GCMDHKEM_P521_HKDF_SHA512_HKDF_SHA512_AES_256_GCM
자세한 내용은 RFC 9180을 참조하세요. KEM, KDF, AEAD의 알고리즘 선택에 관해 자세히 알아보실 수 있습니다
더 이상 권장되지 않지만 Tink는 ECIES의 일부 변형도 지원합니다. Victor Shoup의 ISO 18033-2 표준 버전을 사용합니다. 지원되는 일부 ECIES 키 유형은 다음과 같습니다.
ECIES_P256_HKDF_HMAC_SHA256_AES128_GCMECIES_P256_COMPRESSED_HKDF_HMAC_SHA256_AES128_GCMECIES_P256_HKDF_HMAC_SHA256_AES128_CTR_HMAC_SHA256ECIES_P256_COMPRESSED_HKDF_HMAC_SHA256_AES128_CTR_HMAC_SHA256
최소 속성
- 일반 텍스트 및 컨텍스트 정보는 범위 내에서 임의의 길이를 가질 수 있습니다. 0..232바이트)
- 선택된 적응형 암호화 텍스트 공격으로부터 보안
- 타원 곡선 기반 체계에 대한 128비트 보안