| 1. ¿Qué es la criptografía simétrica? |
La criptografía simétrica utiliza la misma clave para cifrar y descifrar datos. |
# Python: Ejemplo de cifrado simétrico usando AES
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad
from Crypto.Random import get_random_bytes
key = get_random_bytes(16)
cipher = AES.new(key, AES.MODE_CBC)
plaintext = b'Hello, World!'
ciphertext = cipher.encrypt(pad(plaintext, AES.block_size))
print(ciphertext)
|
| 2. ¿Qué es la criptografía asimétrica? |
La criptografía asimétrica utiliza un par de claves, una pública para cifrar y una privada para descifrar. |
# Python: Ejemplo de cifrado asimétrico usando RSA
from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP
key = RSA.generate(2048)
cipher = PKCS1_OAEP.new(key.publickey())
plaintext = b'Hello, World!'
ciphertext = cipher.encrypt(plaintext)
print(ciphertext)
|
| 3. ¿Qué es un certificado digital? |
Un certificado digital es un archivo que asocia una clave pública con una identidad, validado por una autoridad certificadora. |
|
| 4. ¿Cómo se genera un par de claves RSA en Java? |
Se utiliza la clase `KeyPairGenerator` para generar un par de claves RSA. |
// Java: Generación de un par de claves RSA
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
public class RSAKeyPair {
public static void main(String[] args) throws NoSuchAlgorithmException {
KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA");
keyGen.initialize(2048);
KeyPair keyPair = keyGen.generateKeyPair();
System.out.println("Public Key: " + keyPair.getPublic());
System.out.println("Private Key: " + keyPair.getPrivate());
}
}
|
| 5. ¿Qué es el algoritmo SHA-256? |
SHA-256 es un algoritmo de hash que genera un resumen de 256 bits a partir de datos de entrada. |
# Python: Ejemplo de hash SHA-256
import hashlib
data = b'Hello, World!'
hash_object = hashlib.sha256(data)
hex_dig = hash_object.hexdigest()
print(hex_dig)
|
| 6. ¿Cómo se firma digitalmente un mensaje en C#? |
Se utiliza la clase `RSACryptoServiceProvider` para crear una firma digital. |
// C#: Ejemplo de firma digital
using System;
using System.Security.Cryptography;
using System.Text;
class Program
{
static void Main()
{
using (var rsa = new RSACryptoServiceProvider())
{
var data = Encoding.UTF8.GetBytes("Hello, World!");
var signature = rsa.SignData(data, CryptoConfig.MapNameToOID("SHA256"));
Console.WriteLine(Convert.ToBase64String(signature));
}
}
}
|
| 7. ¿Qué es una autoridad certificadora (CA)? |
Una autoridad certificadora (CA) es una entidad que emite certificados digitales y verifica la identidad de las partes. |
|
| 8. ¿Cómo se verifica una firma digital en TypeScript? |
Se usa la biblioteca `crypto` para verificar firmas digitales en Node.js. |
// TypeScript: Ejemplo de verificación de firma digital
import * as crypto from 'crypto';
const publicKey = `-----BEGIN PUBLIC KEY-----
...
-----END PUBLIC KEY-----`;
const verifier = crypto.createVerify('SHA256');
verifier.update('Hello, World!');
const signature = Buffer.from('signature_here', 'base64');
const isValid = verifier.verify(publicKey, signature);
console.log(isValid);
|
| 9. ¿Cómo se cifra un archivo usando AES en Java? |
Se usa la clase `Cipher` para cifrar datos con AES. |
// Java: Ejemplo de cifrado AES
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;
public class AESEncryption {
public static void main(String[] args) throws Exception {
KeyGenerator keyGen = KeyGenerator.getInstance("AES");
keyGen.init(128);
SecretKey secretKey = keyGen.generateKey();
Cipher cipher = Cipher.getInstance("AES");
cipher.init(Cipher.ENCRYPT_MODE, secretKey);
byte[] encrypted = cipher.doFinal("Hello, World!".getBytes());
System.out.println(Base64.getEncoder().encodeToString(encrypted));
}
}
|
| 10. ¿Qué es el "Key Exchange" y por qué es importante? |
El "Key Exchange" es el proceso de intercambiar claves de cifrado de manera segura. Es importante para establecer sesiones seguras entre partes. |
|
| 11. ¿Cómo se realiza el "Key Exchange" utilizando Diffie-Hellman en Python? |
Se utiliza la biblioteca `cryptography` para implementar Diffie-Hellman. |
# Python: Ejemplo de intercambio de claves con Diffie-Hellman
from cryptography.hazmat.primitives.asymmetric import dh
from cryptography.hazmat.primitives import serialization
parameters = dh.generate_parameters(generator=2, key_size=2048)
private_key = parameters.generate_private_key()
public_key = private_key.public_key()
print(public_key.public_bytes(encoding=serialization.Encoding.PEM, format=serialization.PublicFormat.SubjectPublicKeyInfo))
|
| 12. ¿Cómo se genera un certificado autofirmado en Java? |
Se utiliza `KeyPairGenerator` y `X509V3CertificateGenerator` para generar un certificado autofirmado. |
// Java: Ejemplo de generación de un certificado autofirmado
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.Security;
import java.security.cert.X509Certificate;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.bouncycastle.x509.X509V3CertificateGenerator;
import java.math.BigInteger;
import java.util.Date;
public class SelfSignedCertificate {
public static void main(String[] args) throws Exception {
Security.addProvider(new BouncyCastleProvider());
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
keyPairGenerator.initialize(2048);
KeyPair keyPair = keyPairGenerator.generateKeyPair();
X509V3CertificateGenerator certGen = new X509V3CertificateGenerator();
certGen.setSerialNumber(BigInteger.ONE);
certGen.setSubjectDN(new org.bouncycastle.asn1.x509.X509Name("CN=Test"));
certGen.setIssuerDN(new org.bouncycastle.asn1.x509.X509Name("CN=Test"));
certGen.setPublicKey(keyPair.getPublic());
certGen.setNotBefore(new Date(System.currentTimeMillis()));
certGen.setNotAfter(new Date(System.currentTimeMillis() + 365 * 24 * 60 * 60 * 1000L));
X509Certificate certificate = certGen.generate(keyPair.getPrivate());
System.out.println(certificate);
}
}
|
| 13. ¿Cómo se encripta y se descifra un mensaje en TypeScript? |
Se utiliza la biblioteca `crypto` en Node.js para cifrar y descifrar mensajes. |
// TypeScript: Ejemplo de cifrado y descifrado con AES
import * as crypto from 'crypto';
const key = crypto.randomBytes(32);
const iv = crypto.randomBytes(16);
const cipher = crypto.createCipheriv('aes-256-cbc', key, iv);
const encrypted = Buffer.concat([cipher.update('Hello, World!', 'utf8'), cipher.final()]);
const decipher = crypto.createDecipheriv('aes-256-cbc', key, iv);
const decrypted = Buffer.concat([decipher.update(encrypted), decipher.final()]);
console.log(decrypted.toString());
|
| 14. ¿Qué es el "TLS" y cómo se usa en la comunicación segura? |
TLS (Transport Layer Security) es un protocolo que proporciona comunicación segura en redes. Se usa para cifrar datos entre el cliente y el servidor. |
|
| 15. ¿Cómo se verifica la validez de un certificado digital? |
Se verifica comprobando la firma del certificado con la autoridad certificadora, asegurando que no esté expirado y que esté revocado. |
|
| 16. ¿Cómo se genera una clave privada en Python? |
Se utiliza la biblioteca `cryptography` para generar claves privadas. |
# Python: Ejemplo de generación de una clave privada RSA
from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.hazmat.primitives import serialization
private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
pem = private_key.private_bytes(
encoding=serialization.Encoding.PEM,
format=serialization.PrivateFormat.TraditionalOpenSSL,
encryption_algorithm=serialization.NoEncryption()
)
print(pem.decode())
|
| 17. ¿Qué es el "HMAC" y cómo se usa en la autenticación de mensajes? |
HMAC (Hash-based Message Authentication Code) usa una clave secreta y una función hash para verificar la integridad y autenticidad de los datos. |
# Python: Ejemplo de HMAC con SHA-256
import hmac
import hashlib
key = b'secret'
message = b'Hello, World!'
hmac_obj = hmac.new(key, message, hashlib.sha256)
print(hmac_obj.hexdigest())
|
| 18. ¿Cómo se usa un certificado digital en una conexión HTTPS en Java? |
Se configura un `SSLContext` con el certificado digital para establecer conexiones HTTPS seguras. |
// Java: Configuración de HTTPS con certificado digital
import javax.net.ssl.SSLContext;
import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.TrustManagerFactory;
import java.security.KeyStore;
import java.security.cert.CertificateFactory;
import java.io.FileInputStream;
public class HttpsExample {
public static void main(String[] args) throws Exception {
KeyStore keyStore = KeyStore.getInstance("PKCS12");
FileInputStream fis = new FileInputStream("keystore.p12");
keyStore.load(fis, "password".toCharArray());
KeyManagerFactory kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
kmf.init(keyStore, "password".toCharArray());
SSLContext sslContext = SSLContext.getInstance("TLS");
sslContext.init(kmf.getKeyManagers(), null, null);
System.out.println("SSLContext setup completed");
}
}
|
| 19. ¿Qué es el "CRL" y cuál es su propósito? |
El CRL (Certificate Revocation List) es una lista que contiene certificados digitales que han sido revocados antes de su fecha de expiración. |
|
| 20. ¿Cómo se extrae el contenido de un certificado digital en Python? |
Se utiliza la biblioteca `cryptography` para leer y extraer datos de un certificado. |
# Python: Ejemplo de extracción de información de un certificado digital
from cryptography import x509
from cryptography.hazmat.backends import default_backend
with open("certificate.pem", "rb") as f:
cert_data = f.read()
cert = x509.load_pem_x509_certificate(cert_data, default_backend())
print(cert.subject)
print(cert.issuer)
|
| 21. ¿Cómo se realiza la generación de un certificado SSL/TLS autofirmado en C#? |
Se utiliza la clase `X509Certificate2` para generar un certificado SSL/TLS autofirmado. |
// C#: Generación de un certificado SSL/TLS autofirmado
using System;
using System.Security.Cryptography.X509Certificates;
class Program
{
static void Main()
{
var certificate = new X509Certificate2("path_to_cert.pfx", "password");
Console.WriteLine(certificate);
}
}
|
| 22. ¿Qué es la "encriptación asimétrica" y cómo se diferencia de la simétrica? |
La encriptación asimétrica usa un par de claves (pública y privada), mientras que la simétrica usa una sola clave para cifrar y descifrar. |
|
| 23. ¿Cómo se implementa el cifrado de datos con RSA en TypeScript? |
Se utiliza la biblioteca `node-forge` para cifrar y descifrar datos con RSA. |
// TypeScript: Ejemplo de cifrado con RSA usando node-forge
import * as forge from 'node-forge';
const { publicKey, privateKey } = forge.pki.rsa.generateKeyPair(2048);
const encrypted = publicKey.encrypt('Hello, World!');
const decrypted = privateKey.decrypt(encrypted);
console.log(decrypted);
|
| 24. ¿Qué es el "PKCS#12" y cómo se usa en Java? |
PKCS#12 es un estándar para almacenar claves privadas y certificados. Se usa para importar y exportar certificados en Java. |
// Java: Cargar un archivo PKCS#12
import java.io.FileInputStream;
import java.security.KeyStore;
public class PKCS12Example {
public static void main(String[] args) throws Exception {
KeyStore keyStore = KeyStore.getInstance("PKCS12");
FileInputStream fis = new FileInputStream("keystore.p12");
keyStore.load(fis, "password".toCharArray());
System.out.println("KeyStore loaded");
}
}
|
| 25. ¿Cómo se cifra un mensaje en Java usando el algoritmo AES? |
Se usa la clase `Cipher` para cifrar datos con el algoritmo AES. |
// Java: Ejemplo de cifrado AES
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;
public class AESEncryption {
public static void main(String[] args) throws Exception {
KeyGenerator keyGen = KeyGenerator.getInstance("AES");
keyGen.init(128);
SecretKey secretKey = keyGen.generateKey();
Cipher cipher = Cipher.getInstance("AES");
cipher.init(Cipher.ENCRYPT_MODE, secretKey);
byte[] encrypted = cipher.doFinal("Hello, World!".getBytes());
System.out.println(Base64.getEncoder().encodeToString(encrypted));
}
}
|
| 26. ¿Cómo se realiza la verificación de una firma digital en Java? |
Se usa la clase `Signature` para verificar una firma digital. |
// Java: Ejemplo de verificación de firma digital
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Signature;
import java.util.Base64;
public class SignatureVerification {
public static void main(String[] args) throws Exception {
KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA");
keyGen.initialize(2048);
KeyPair keyPair = keyGen.generateKeyPair();
PrivateKey privateKey = keyPair.getPrivate();
PublicKey publicKey = keyPair.getPublic();
Signature signer = Signature.getInstance("SHA256withRSA");
signer.initSign(privateKey);
byte[] data = "Hello, World!".getBytes();
signer.update(data);
byte[] signature = signer.sign();
Signature verifier = Signature.getInstance("SHA256withRSA");
verifier.initVerify(publicKey);
verifier.update(data);
boolean isValid = verifier.verify(signature);
System.out.println("Signature valid: " + isValid);
}
}
|