Attention: Here be dragons
This is the latest
(unstable) version of this documentation, which may document features
not available in or compatible with released stable versions of Godot.
Checking the stable version of the documentation...
Crypto
Hereda: RefCounted < Object
Proporciona acceso a funcionalidades criptográficas avanzadas.
Descripción
La clase Crypto proporciona acceso a funcionalidades criptográficas avanzadas.
Actualmente, esto incluye cifrado/descifrado de clave asimétrica, firma/verificación y la generación de bytes aleatorios criptográficamente seguros, claves RSA, resúmenes HMAC y certificados X509Certificate autofirmados.
var crypto = Crypto.new()
# Generar una nueva clave RSA.
var key = crypto.generate_rsa(4096)
# Generar un nuevo certificado autofirmado con la clave dada.
var cert = crypto.generate_self_signed_certificate(key, "CN=mydomain.com,O=My Game Company,C=IT")
# Guardar la clave y el certificado en la carpeta del usuario.
key.save("user://generated.key")
cert.save("user://generated.crt")
# Cifrado
var data = "Algunos datos"
var encrypted = crypto.encrypt(key, data.to_utf8_buffer())
# Descifrado
var decrypted = crypto.decrypt(key, encrypted)
# Firma
var signature = crypto.sign(HashingContext.HASH_SHA256, data.sha256_buffer(), key)
# Verificación
var verified = crypto.verify(HashingContext.HASH_SHA256, data.sha256_buffer(), signature, key)
# Comprobaciones
assert(verified)
assert(data.to_utf8_buffer() == decrypted)
using Godot;
using System.Diagnostics;
Crypto crypto = new Crypto();
// Generar una nueva clave RSA.
CryptoKey key = crypto.GenerateRsa(4096);
// Generar un nuevo certificado autofirmado con la clave dada.
X509Certificate cert = crypto.GenerateSelfSignedCertificate(key, "CN=mydomain.com,O=My Game Company,C=IT");
// Guardar la clave y el certificado en la carpeta del usuario.
key.Save("user://generated.key");
cert.Save("user://generated.crt");
// Cifrado
string data = "Algunos datos";
byte[] encrypted = crypto.Encrypt(key, data.ToUtf8Buffer());
// Descifrado
byte[] decrypted = crypto.Decrypt(key, encrypted);
// Firma
byte[] signature = crypto.Sign(HashingContext.HashType.Sha256, Data.Sha256Buffer(), key);
// Verificación
bool verified = crypto.Verify(HashingContext.HashType.Sha256, Data.Sha256Buffer(), signature, key);
// Comprobaciones
Debug.Assert(verified);
Debug.Assert(data.ToUtf8Buffer() == decrypted);
Métodos
constant_time_compare(trusted: PackedByteArray, received: PackedByteArray) |
|
decrypt(key: CryptoKey, ciphertext: PackedByteArray) |
|
encrypt(key: CryptoKey, plaintext: PackedByteArray) |
|
generate_random_bytes(size: int) |
|
generate_rsa(size: int) |
|
generate_self_signed_certificate(key: CryptoKey, issuer_name: String = "CN=myserver,O=myorganisation,C=IT", not_before: String = "20140101000000", not_after: String = "20340101000000") |
|
hmac_digest(hash_type: HashType, key: PackedByteArray, msg: PackedByteArray) |
|
sign(hash_type: HashType, hash: PackedByteArray, key: CryptoKey) |
|
verify(hash_type: HashType, hash: PackedByteArray, signature: PackedByteArray, key: CryptoKey) |
Descripciones de Métodos
bool constant_time_compare(trusted: PackedByteArray, received: PackedByteArray) 🔗
Compara dos PackedByteArray para determinar la igualdad sin filtrar información de tiempo para evitar ataques de tiempo.
Véase esta publicación de blog para obtener más información.
PackedByteArray decrypt(key: CryptoKey, ciphertext: PackedByteArray) 🔗
Descifra el ciphertext dado con la key privada proporcionada.
Nota: El tamaño máximo del texto cifrado aceptado está limitado por el tamaño de la clave.
PackedByteArray encrypt(key: CryptoKey, plaintext: PackedByteArray) 🔗
Cifra el plaintext dado con la key pública proporcionada.
Nota: El tamaño máximo del texto plano aceptado está limitado por el tamaño de la clave.
PackedByteArray generate_random_bytes(size: int) 🔗
Genera un PackedByteArray de bytes aleatorios criptográficamente seguros con el size dado.
CryptoKey generate_rsa(size: int) 🔗
Genera una RSA CryptoKey que puede ser utilizada para crear certificados autofirmados y pasarla a StreamPeerTLS.accept_stream().
X509Certificate generate_self_signed_certificate(key: CryptoKey, issuer_name: String = "CN=myserver,O=myorganisation,C=IT", not_before: String = "20140101000000", not_after: String = "20340101000000") 🔗
Genera un X509Certificate autofirmado a partir de la CryptoKey y el issuer_name dados. La validez del certificado se definirá mediante not_before y not_after (primera fecha de validez y última fecha de validez). El issuer_name debe contener al menos "CN=" (nombre común, es decir, el nombre del dominio), "O=" (organización, es decir, el nombre de su empresa), "C=" (país, es decir, el código ISO-3166 de dos letras del país en el que la organización tiene su sede).
Un pequeño ejemplo para generar una clave RSA y un certificado autofirmado X509.
var criptografia = Crypto.new()
# Genera una clave de 4096 bits RSA.
var clave = criptografia.generate_rsa(4096)
# Genera un certificado autofirmado usando la clave.
var certificado = criptografia.generate_self_signed_certificate(clave, "CN=example.com,O=A Game Company,C=IT")
var criptografia = new Crypto();
// Generar clave RSA de 4096 bits.
CryptoKey clave = criptografia.GenerateRsa(4096);
// Generar certificado autofirmado usando la clave dada.
X509Certificate certificado = criptografia.GenerateSelfSignedCertificate(clave, "CN=mydomain.com,O=My Game Company,C=IT");
PackedByteArray hmac_digest(hash_type: HashType, key: PackedByteArray, msg: PackedByteArray) 🔗
Genera un resumen HMAC de msg usando key. El parámetro hash_type es el algoritmo de hash que se utiliza para los hashes internos y externos.
Actualmente, solo se admiten HashingContext.HASH_SHA256 y HashingContext.HASH_SHA1.
PackedByteArray sign(hash_type: HashType, hash: PackedByteArray, key: CryptoKey) 🔗
Firma un hash dado de tipo hash_type con la key privada proporcionada.
bool verify(hash_type: HashType, hash: PackedByteArray, signature: PackedByteArray, key: CryptoKey) 🔗
Verifica que una signature dada para hash de tipo hash_type coincida con la key pública proporcionada.