Criptografia

Certificats

Si se signa un document digital utilitzant una clau privada, el receptor ha de tenir la clau pública per verificar la signatura. El problema és que una clau no indica a qui pertany. Els certificats resolen aquest problema: una entitat ben coneguda (Certificate Authority: CA) verifica la propietat de la clau pública que se t'ha enviat.

Un certificat conté:

1. El nom de l'entitat per qui s'ha emès el certificat.
2. La clau pública d'aquesta entitat.
3. La signatura digital que verifica la informació en el certificat, feta amb la clau privada de l'emissor.

Un certificat podria contenir aquesta informació:

"L'autoritat de certificació 2276172 certifica que la clau pública de John Doe és 217126371812".

Problema: l'emissor del certificat té una clau pública en què hem de confiar. I poden estar encadenades. La darrera de la cadena està autosignada per ella mateixa. Llavors, hem d'acceptar certes CA com a confiables, i habitualment Java (igual que els navegadors) tenen una llista de CA confiables.

El certificat de servidor TLS/SSL és el més comú. El client utilitza l'algorisme de validació del camí de certificació:

1. El subject (CN) del certificat coincideix amb el domini al qual es connecta.
2. El certificat l'ha signat un CA confiable.

Com s'estableix la comunicació segura entre el navegador i un servidor HTTPS?

1. Quan el navegador es connecta al servidor es descarrega el seu certificat, que conté la seva clau pública.
2. El navegador posseeix les claus públiques de les CA confiables, i comprova si la signatura del certificat s'ha fet per una CA confiable.
3. El navegador comprova que el domini que apareix al certificat és el mateix amb el qual es comunica amb el servidor.
4. El navegador genera una clau simètrica, l'encripta amb la clau pública del servidor i li envia.
5. S'acaba el xifrat asimètric i comença el simètric amb la clau compartida.

Criptografia a Java (JCA)

motors criptogràfics de Java proporcionen mecanismes per signatures digitals, resums de missatges, etc. Aquests motors estan implementats per proveïdors de seguretat (java.security.Provider), que es poden visualitzar mitjançant java.security.Security.getProviders(). Cada motor (java.security.Provider.Service) té un tipus i un algorisme.

Claus

Podem generar claus de tipus simètric (KeyGenerator) o asimètric (KeyPairGenerator).

KeyGenerator keyGen = KeyGenerator.getInstance(algorithm);

keyGen.init(size);

SecretKey secretKey = keyGen.generateKey();

Algorismes simètrics típics són DES (56 bits) o AES (128, 192, 256 bits).

KeyPairGenerator kpg = KeyPairGenerator.getInstance(algorithm);

kpg.initialize(size);

KeyPair kp = kpg.generateKeyPair();

PublicKey publicKey = kp.getPublic();

PrivateKey privateKey = kp.getPrivate();

Cal indicar l'algorisme. El més habitual és RSA (1024, 2048 bits).

Tant SecretKey, com PublicKey i PrivateKey, són subclasses de java.security.Key. Totes elles tenen un mètode getEncoded(): la clau en format binari. Aquest format pot convertir-se, per exemple, a un format fàcil de gestionar amb cadenes. El més conegut és java.util.Base64, que permet intercanviar el format d'una clau Key key:

String stringKey = Base64.getEncoder().encode(key.getEncoded());

byte[] encoded = Base64.getDecoder().decode(stringKey);

Xifrat

Per a poder xifrar, necessitem un objecte javax.crypto.Cipher:

Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");

El format del paràmetre (algorithm) és algorithm/mode/padding. Mode i padding són opcionals: si no s'indiquen, s'utilitza el mode i padding per defecte. Què són?

• Padding: és una tècnica que consisteix a afegir dades al començament, mig o fi d'un missatge abans de ser xifrat. Això es fa perquè els algorismes estan dissenyats per tenir dades d'una mida concreta.
• Mode: defineix com es fa la correspondència entre els blocs d'entrada (en pla) i els de sortida (xifrats). El més senzill és el mode ECB: un bloc d'entrada va a un de sortida.

Després, hem d'inicialitzar l'objecte utilitzant el mode (Cipher.ENCRYPT_MODE o Cipher.DECRYPT_MODE) i la clau de xifrat:

cipher.init(Cipher.ENCRYPT_MODE, key); // xifrat

cipher.init(Cipher.DECRYPT_MODE, key); // desxifrat

Finalment, realitzem el xifrat o desxifrat:

byte[] bytesOriginal = textOriginal.getBytes("UTF-8"); // necessito bytes com a entrada

byte[] bytesXifrat = cipher.doFinal(bytesOriginal);

El desxifrat podria ser:

byte[] bytesOriginal = llegirBytes(); // un mètode qualsevol que obté dades

byte[] bytesDesxifrat = cipher.doFinal(bytesOriginal);

// alternativament, si el contingut a desxifrar és una part de l'array:

byte[] bytesDesxifrat = cipher.doFinal(bytesOriginal, inici, longitud);

Xifrat de streams

No té sentit xifrar grans quantitats de dades amb mètodes de bloc. Per a aquestes situacions, podem utilitzar el xifrat de streams. Aquest xifrat és sempre simètric.

A Java, tenim les classes CipherInputStream i CipherOutputStream.

Per exemple, si volem obrir un arxiu i xifrar-lo o desxifrar-lo, podem fer-ho així:

FileInputStream in = new FileInputStream(inputFilename);

FileOutputStream fileOut = new FileOutputStream(outputFilename);

CipherOutputStream out = new CipherOutputStream(fileOut, cipher);

Llavors, caldria copiar el stream in a out.

L'objecte cipher ha d'inicialitzar-se amb el mode que calgui, ENCRYPT_MODE o DECRYPT_MODE.

CipherInputStream es pot utilitzar de forma anàloga. En aquest cas, el stream de sortida podria ser un FileOutputStream:

FileInputStream fileIn = new FileInputStream(inputFilename);

CipherInputStream in = new CipherInputStream(fileIn, cipher);

FileOutputStream fileOut = new FileOutputStream(outputFilename);

Resums, signatures i certificats

Resums de missatges

Els resums s'implementen utilitzant la classe java.security.MessageDigest, que permet generar un resum de dades. El resum es pot fer segur utilitzant javax.crypto.Mac. També es pot realitzar l'operació amb Streams gràcies a java.security.DigestInputStream i java.security.DigestOutputStream.

Alguns algorismes típics de resums: MD2, MD5, SHA-1, SHA-256, SHA-384, SHA-512.

MessageDigest messageDigest = MessageDigest.getInstance(algorithm);

byte[] resum = messageDigest.digest(text.getBytes());

Resums segurs

Un Message Authentication Code (javax.crypto.Mac) és un resum xifrat amb una clau privada. Només es pot verificar si tens aquesta clau. Podem generar-lo així:

Mac mac = Mac.getInstance(algorithm);

mac.init(key); // la clau privada

byte[] macBytes = mac.doFinal(text.getBytes());

Un algorisme podria ser HmacSHA256 (HMAC: Hash-based MAC).

Signatures digitals

Una signatura digital equival a fer un resum i xifrar-lo amb una clau privada. El receptor podria desxifrar-lo amb la pública, i comparar-lo amb un resum que faci de les dades (en pla) rebudes.

Els algorismes són variats, per exemple, SHA256withRSA indica que el resum es fa amb SHA256 i l'encriptació amb RSA. Per tant, les claus utilitzades han de ser RSA. Per a signar una entrada (array de bytes):

Signature sign = Signature.getInstance(algorithm);

sign.initSign(privateKey);        

sign.update(input);

byte[] signatura = sign.sign();

Per verificar-la:

Signature sign = Signature.getInstance(algorithm);

sign.initVerify(publicKey);

sign.update(input);

boolean correcte = sign.verify(signatura);

Certificats

Els certificats (java.security.cert.Certificate) més habituals són de tipus X.509, i indiquen una vinculació d'una identitat a una clau pública, garantida per una altra entitat autoritzada. Inclouen:

• data d'inici i fi
• versió (3 actualment)
• número de sèrie (únic per proveïdor)
• el DN (distinguished name) de la CA emissora
• el DN del subjecte del certificat

Els DN (Distinguished Names) conté una sèrie de camps (CN, OU, O, L, S, C) que identifiquen tant l'emissor com el subjecte.

Habitualment, els trobem dins dels magatzems. Per gestionar-los podem utilitzar l'eina keytool del JRE o bé programàticament amb la classe java.security.KeyStore i els mètodes getKey() i getCertificate().

Són necessaris als portals web amb seguretat habilitada HTTPS.

Comunicació SSL amb sòcols

Per tal que un socket es pugui comunicar amb el protocol segur SSL, cal crear objectes una mica diferents.

Al servidor:

ServerSocket serverSocket = new ServerSocket(PORT);

Es converteix en:

SSLServerSocketFactory factory = (SSLServerSocketFactory) SSLServerSocketFactory.getDefault();        

SSLServerSocket serverSocket = (SSLServerSocket) factory.createServerSocket(PORT);

Opcionalment, si volem autenticar al client (ho veurem més endavant):

serverSocket.setNeedClientAuth(true);

Al client:

Socket clientSocket = new Socket(HOST, PORT);

Es converteix en:

SSLSocketFactory factory = (SSLSocketFactory) SSLSocketFactory.getDefault();

SSLSocket clientSocket = (SSLSocket) factory.createSocket(HOST, PORT);    

A més, cal configurar les claus privada i pública correctament. I això depèn de si volem o no autoritzar la clau pública dels clients al servidor.

Tenim dos tipus de magatzems necessaris:

• Els keystores serveixen per identificar-nos
• Els truststores serveixen per autoritzar altres parts

La configuració es realitza mitjançant propietats de sistema a Java, amb aquesta instrucció:

• System.setProperty("nomDeLaPropietat", "valor");

Sense autorització del client

Cal generar dos magatzems:

• serverKeystore.jks: clau pública/privada del servidor
• clientTruststore.jks: clau pública del servidor

keytool -genkey -alias srvAlias -keyalg RSA -keystore serverKeystore.jks -keysize 2048

keytool -export -keystore serverKeystore.jks -alias srvAlias -file server.crt

keytool -importcert -file server.crt -keystore clientTruststore.jks -alias srvAlias

Configuració al servidor per a identificar-se:

javax.net.ssl.keyStore=serverKeystore.jks

javax.net.ssl.keyStorePassword=yourpassword

Configuració al client per a acceptar al servidor:

javax.net.ssl.trustStore=clientTrustore.jks

javax.net.ssl.trustStorePassword=yourpassword

Amb autorització del client

Als les configuracions anteriors, cal afegir:

• clientKeystore.jks: clau pública/privada del client
• serverTruststore.jks: clau pública del client

keytool -genkey -keyalg RSA -alias cltAlias -keystore clientKeystore.jks -keysize 2048

keytool -export -keystore clientKeystore.jks -alias cltAlias -file cliente.crt

keytool -importcert -file cliente.crt -keystore serverTruststore.jks -alias cltAlias

Configuració al servidor per a acceptar el client:

javax.net.ssl.trustStore=serverTruststore.jks

javax.net.ssl.trustStorePassword=yourpassword

Configuració al client per a identificar-se:

javax.net.ssl.keyStore=clientKeystore.jks

javax.net.ssl.keyStorePassword=yourpassword

Gestió de claus

Un magatzem de claus, o keystore, pot tenir un alias, i pot contenir:

• Claus: pot ser una clau (asimètrica o simètrica). Si es tracta d'una asimètrica, pot contenir una cadena de certificats.
• Certificats: una clau pública, habitualment l'arrel de CAs de confiança.

Les keystores poden tenir diferents formats (JKS, JCEKS, PKCS12, PKCS11, DKS). Els més utilitzats són:

• JKS (Java Key Store): format propietari de Java. Històricament, el més utilitzat. Extensió jks.
• PKCS#12: format standard. Format recomanat. Extensió p12 o pfx.

Java té una eina anomenada keytool per gestionar magatzems de claus. A continuació es mostren algunes comandes habituals.

Comenda per llistar els continguts d'una keystore:

$ keytool -list -v -keystore keystore.jks

Comanda per generar un keystore amb una parella de claus:

$ keytool -genkey -alias mydomain -keyalg RSA -keystore keystore.jks -keysize 2048

Comanda per exportar un certificat d'una keystore:

$ keytool -export -alias mydomain -file mydomain.crt -keystore keystore.jks

Comanda per importar un certificat a una keystore:

$ keytool -importcert -file mydomain.crt -keystore keystore.jks -alias mydomain

Formats de certificats

PEM - Privacy Enhanced Mail

PEM és el format més comú en què les autoritats certificadores emeten certificats. Aquests són més utilitzats pels usuaris d’Unix / Linux. Estan codificats en base-64.

La part pública del certificat estarà limitada per "—–BEGIN PUBLIC KEY—–" i "—–END PUBLIC KEY—–", mentre que la part privada del certificat és dins de "—–BEGIN RSA PRIVATE KEY––" i "—–END RSA PRIVATE KEY—–".

El format PEM pot contenir qualsevol certificat client / servidor, certificat intermedi, CA arrel i la clau privada.

• Són fitxers ASCII codificats per Base64.
• Tenen extensions com .pem, .crt, .key (.cert de vegades).
• Els servidors Apache i similars utilitzen certificats de format PEM.

DER - Distinguished Encoding Rule

DER és un certificat de format binari. Es poden codificar tota mena de certificats i claus privades.

Aquest format admet l’emmagatzematge d'un únic certificat i no inclou la clau privada per a la CA arrel/intermèdia.

• Són fitxers de format binari.
• Tenen extensions .cer i .der.

DER s’utilitza normalment en la plataforma Java.

PKCS#7

Aquest format només conté certificat o cadena de certificats, però no emmagatzema la clau privada.

CA s’utilitza habitualment per proporcionar cadenes de certificats als usuaris, i solen tenir extensió .p7b o .p7s.

PFX - Personal Information Exchange

PFX és un format per emmagatzemar un certificat de servidor o qualsevol certificat intermedi juntament amb la clau privada en un fitxer xifrat. PFX segueix l'estàndard de xifratge de clau pública (PKCS). El terme PFX s'utilitza indistintament amb PKCS#12.

Tenen extensió .pfx o .p12.

Referències

• Criptografia (M11)
• JCA Standard Algorithm Name Documentation for JDK 8 (veure Implementation Requirements)
• Java Cryptography Architecture Oracle Providers Documentation for JDK 8
• Java Criptography (Jenkov)
• Cryptographic hash function (Wikipedia)
• Public-key cryptography (Wikipedia)
• Java Security 2nd Edition (examples)
• Generating and Verifying Signatures (The Java Tutorials)
• A Deep Dive on End-to-End Encryption: How Do Public Key Encryption Systems Work?
• Java Keytool - Commands and Tutorials
• Java KeyStores - the gory details
• Trusted Timestamping (INCIBE)
• Trusted Timestamping (Wikipedia)
• CyberChef
• Capture The Flag 101