Firma remota

En este tutorial, se verá un ejemplo práctico de como firmar un archivo alojado en un servidor.

Para poder realizar el ejemplo necesita las siguientes herrameintas:

  • Jacobitus Total.- Esta es una herramienta desarrollada por ADSIB y que se encuentra disponible en Jacobitus Total
  • AdoptOpenJDK.- El JDK de java en su versión 11 o superior, disponible en AdoptOpenJDK
  • Tomcat.- El contenedor web Tomcat, disponible en Tomcat 9
  • NetBeans.- IDE de desarrollo para java NetBeans

Uno de los problemas al momento de firmar un documento digitalmente es tener que transferir ese documento por internet, ya que si es grande puede demorar mucho tiempo.

A contiunación se detalla un ejemplo de código que firma el documento PDF sin necesidad de transfereir el codumento.

Para poder lograr esto se requiere crear un proyecto Maven->Web Application.

A continuación podemos poner el nombre webapp y crear el proyecto.

Como se vió en el tutorial de Widgets para firmar un documento PDF necesitamos importar la librería de iText y para gestionar los servicios vamos a importar glashfish, por lo que agregamos las siguientes dependencias al archivo pom.

  1.         <dependency>
  2.             <groupId>com.itextpdf</groupId>
  3.             <artifactId>sign</artifactId>
  4.             <version>7.1.15</version>
  5.         </dependency>
  6.         <dependency>
  7.             <groupId>org.glassfish</groupId>
  8.             <artifactId>javax.json</artifactId>
  9.             <version>1.1.4</version>
  10.         </dependency>

De igual manera, es necesario crear una clase de tipo IExternalSignature para firmar el documento, la cual la pondremos en el paquete firmador.

  1. public class ServerSignature implements IExternalSignature {
  2.     protected Session session;
  3.     protected byte[] answer;
  5.     public ServerSignature(Session session) {
  6.         this.session = session;
  7.     }
  9.     @Override
  10.     public String getHashAlgorithm() {
  11.         return DigestAlgorithms.getDigest(DigestAlgorithms.getAllowedDigest("SHA256"));
  12.     }
  14.     @Override
  15.     public String getEncryptionAlgorithm() {
  16.         return "RSA";
  17.     }
  19.     public void setAnswer(byte[] answer) {
  20.         this.answer = answer;
  21.     }
  23.     @Override
  24.     public synchronized byte[] sign(byte[] sh) throws GeneralSecurityException {
  25.         try {
  26.             JsonObjectBuilder json = Json.createObjectBuilder();
  27.             json.add("method", "sign");
  28.             json.add("hash", Base64.getEncoder().encodeToString(sh));
  29.             try (Writer writer = session.getBasicRemote().getSendWriter()) {
  30.                 writer.write(json.build().toString());
  31.             }
  32.             wait();
  33.             return answer;
  34.         } catch (IOException | InterruptedException ex) {
  35.             throw new GeneralSecurityException(ex.getMessage());
  36.         }
  37.     }
  38. }

A diferencia del anterior ejemplo lo que hacemos es solicitar la firma a través de un websocket y asignamos la respuesta del web socket mediante el método setAnswer.

Para firmar el documento vamos a crear la clase FirmadorThread ya que se requiere el uso de hilos.

  1. public class FirmadorThread extends Thread {
  2.     protected ServerSignature signature;
  3.     protected Session session;
  4.     protected String file;
  5.     protected String pem;
  6.     protected Map tasks;
  8.     public FirmadorThread(Session session, String file, String pem, Map tasks) {
  9.         this.session = session;
  10.         signature = new ServerSignature(session);
  11.         this.file = file;
  12.         this.pem = pem;
  13.         tasks.put(file, signature);
  14.         this.tasks = tasks;
  15.     }
  17.     @Override
  18.     public void run() {
  19.         try {
  20.             PdfReader reader = new PdfReader(new FileInputStream("/tmp/" + file));
  21.             PdfSigner signer = new PdfSigner(reader, new FileOutputStream("/tmp/prueba.signed.pdf"), new StampingProperties());
  22.             Rectangle rect = new Rectangle(0, 0, 0, 0);
  23.             PdfSignatureAppearance appearance = signer.getSignatureAppearance();
  24.             appearance.setPageRect(rect);
  25.             signer.setFieldName("sig");
  26.             IExternalDigest digest = new BouncyCastleDigest();
  27.             CertificateFactory cf = CertificateFactory.getInstance("X.509");
  28.             X509Certificate cert = (X509Certificate)cf.generateCertificate(new ByteArrayInputStream(pem.getBytes()));
  29.             signer.signDetached(digest, signature, new Certificate[] { cert }, null, null, null, 0, PdfSigner.CryptoStandard.CADES);
  30.             tasks.remove(file);
  31.         } catch (IOException | GeneralSecurityException ex) {
  32.             try (Writer writer = session.getBasicRemote().getSendWriter()) {
  33.                 writer.write("{\"label\":\"" + ex.getMessage() + "\"}");
  34.             } catch (IOException ex1) {
  35.                 Logger.getLogger(FirmadorThread.class.getName()).log(Level.SEVERE, null, ex1);
  36.             }
  37.         }
  38.     }
  39. }

De manera similar se firma haciendo uso de iText, sin embargo en este caso es importante hacer una gestión concurrente del archivo para que no se vaya a acceder de forma simultánea, para lo cual se agrega el archivo a un mapa y se lo remueve una vez concluído el proceso de firma.

Con esto ya tendríamos el firmador, ahora corresponde implementar el servicio y el cliente que interactuará con el Jacobitus Total, para esto crearemos la clase Documento dentro del paquete resources.

  1. @ServerEndpoint(value="/firmar")
  2. public class Documento {
  3.     private final Map tasks = new TreeMap<>();
  5.     @OnMessage
  6.     public void mensaje(Session session, String mensaje) throws IOException, EncodeException {
  7.         JsonReader jsonReader = Json.createReader(new ByteArrayInputStream(mensaje.getBytes()));
  8.         JsonObject json = jsonReader.readObject();
  9.         switch(json.getString("method")) {
  10.             case "hash":
  11.                 if (json.containsKey("file")) {
  12.                     if (tasks.containsKey(json.getString("file"))) {
  13.                         try (Writer writer = session.getBasicRemote().getSendWriter()) {
  14.                             writer.write("{\"mensaje\":\"El archivo está siendo procesado.\"}");
  15.                         }
  16.                     } else {
  17.                         new FirmadorThread(session, json.getString("file"), json.getString("cert"), tasks).start();
  18.                     }
  19.                 } else {
  20.                     try (Writer writer = session.getBasicRemote().getSendWriter()) {
  21.                         writer.write("{\"mensaje\":\"No se especificó el archivo.\"}");
  22.                     }
  23.                 }
  24.                 break;
  25.             case "sign":
  26.                 try (Writer writer = session.getBasicRemote().getSendWriter()) {
  27.                     if (tasks.containsKey(json.getString("file"))) {
  28.                         if (tasks.containsKey(json.getString("file"))) {
  29.                             ServerSignature serverSignature = tasks.get(json.getString("file"));
  30.                             serverSignature.setAnswer(Base64.getDecoder().decode(json.getString("sign")));
  31.                             synchronized(serverSignature) {
  32.                                 serverSignature.notify();
  33.                             }
  34.                             writer.write("{\"mensaje\":\"Recibido.\"}");
  35.                         } else {
  36.                             writer.write("{\"mensaje\":\"El archivo no está en cola.\"}");
  37.                         }
  38.                     } else {
  39.                         writer.write("{\"mensaje\":\"No se especificó el archivo.\"}");
  40.                     }
  41.                 }
  42.                 break;
  43.         }
  44.     }
  45. }

En esencia lo que hacemos es crear un endpoint para atender las solicitudes del cliente, lo que nos permitirá obtener el hash del documento para firmarlo con el Jacobitus Total y devolver la firma para agregarla al documento.

Ahora para el cliente debemos crear la carpeta js dentro de Web Pages para programar las funciones del navegador y dentro comenzamos con el archivo token.js

  1. 'use strict';
  3. function listar(callback) {
  4.     const xhttp = new XMLHttpRequest();
  5.     xhttp.onload = function() {
  6.         var json = JSON.parse(this.responseText);
  7.         if (json.finalizado) {
  8.             var options = '';
  9.             const tokens = json.datos.tokens;
  10.             for (let i = 0; i < tokens.length; i++) {
  11.                 var selected = '';
  12.                 if (i === 0) {
  13.                     selected = ' selected';
  14.                 }
  15.                 options += `${tokens[i].slot}. ${tokens[i].name}`;
  16.             }
  17.             callback(options);
  18.         }
  19.     };
  20.     xhttp.open("GET", "https://localhost:9000/api/token/connected");
  21.     xhttp.send();
  22. }
  24. function certificados(slot, pin, callback) {
  25.     const xhttp = new XMLHttpRequest();
  26.     xhttp.onload = function() {
  27.         var json = JSON.parse(this.responseText);
  28.         if (json.finalizado) {
  29.             var certs = '';
  30.             const elements = json.datos.data_token.data;
  31.             for (let i = 0; i < elements.length; i++) {
  32.                 if (elements[i].tipo === 'X509_CERTIFICATE') {
  33.                     var selected = '';
  34.                     if (i === 0) {
  35.                         selected = ' selected';
  36.                     }
  37.                     certs += `${elements[i].titular.CN}`;
  38.                 }
  39.             }
  40.             callback(certs);
  41.         }
  42.     };
  43.     xhttp.open("POST", "https://localhost:9000/api/token/data");
  44.     xhttp.setRequestHeader("Content-Type", "application/json;charset=UTF-8");
  45.     xhttp.send(JSON.stringify({
  46.         slot: slot,
  47.         pin: pin
  48.     }));
  49. }
  51. function certificado(slot, pin, label, callback) {
  52.     const xhttp = new XMLHttpRequest();
  53.     xhttp.onload = function() {
  54.         var json = JSON.parse(this.responseText);
  55.         if (json.finalizado) {
  56.             const elements = json.datos.data_token.data;
  57.             for (let i = 0; i < elements.length; i++) {
  58.                 if (elements[i].tipo === 'X509_CERTIFICATE') {
  59.                     if (elements[i].alias === label) {
  60.                         callback(elements[i].pem);
  61.                         break;
  62.                     }
  63.                 }
  64.             }
  65.         }
  66.     };
  67.     xhttp.open("POST", "https://localhost:9000/api/token/data");
  68.     xhttp.setRequestHeader("Content-Type", "application/json;charset=UTF-8");
  69.     xhttp.send(JSON.stringify({
  70.         slot: slot,
  71.         pin: pin
  72.     }));
  73. }
  75. function firmarHash(slot, pin, label, hash, callback) {
  76.     const xhttp = new XMLHttpRequest();
  77.     xhttp.onload = function() {
  78.         var json = JSON.parse(this.responseText);
  79.         if (json.finalizado) {
  80.             callback(json.datos.firma);
  81.         }
  82.     };
  83.     xhttp.open("POST", "https://localhost:9000/api/token/firmar_hash");
  84.     xhttp.setRequestHeader("Content-Type", "application/json;charset=UTF-8");
  85.     xhttp.send(JSON.stringify({
  86.         slot: slot,
  87.         pin: pin,
  88.         alias: label,
  89.         hash: hash
  90.     }));
  91. }

Para comprender mejor el código se puede consultar el tutorial Jacobitus FiDo, ya que las funciones consumen los servicios de Jacobitus Total para acceder al token criptográfico.

A continuación creamos el archivo firmar.js que será el encargado de obtener el hash del servidor, solicitar la firma al Jacobitus Total y enviar la firma al servidor para que se almacene en el documento.

  1. (function(window, document, JSON) {
  2.     'use strict';
  3.     var tokens = document.getElementById('tokens');
  4.     var pass = document.getElementById('pass');
  5.     var certs = document.getElementById('certs');
  6.     listar(function(options) {
  7.         document.getElementById('tokens').innerHTML = options;
  8.     });
  9.     document.getElementById('actualizar').addEventListener('click', actualizar);
  10.     function actualizar() {
  11.         certificados(tokens.value, pass.value, function(options) {
  12.             document.getElementById('certs').innerHTML = options;
  13.         });
  14.     }
  15.     var url = 'ws://' + window.location.host + '/webapp/firmar',
  16.         ws = new WebSocket(url);
  17.     ws.onopen = onOpen;
  18.     ws.onclose = onClose;
  19.     ws.onmessage = onMessage;
  20.     document.getElementById('firmar').addEventListener('click', firmar);
  21.     function onOpen() {
  22.         console.log('Conectado...');
  23.     }
  24.     function onClose() {
  25.         console.log('Desconectado...');
  26.     }
  27.     function firmar() {
  28.         console.log('Firmando...');
  29.         certificado(tokens.value, pass.value, certs.value, function(cert) {
  30.             ws.send(JSON.stringify({method:'hash',file:'prueba.pdf',cert:cert}));
  31.         });
  32.     }
  33.     function onMessage(evt) {
  34.         var obj = JSON.parse(evt.data);
  35.         switch (obj.method) {
  36.             case 'sign':
  37.                 firmarHash(tokens.value, pass.value, certs.value, obj.hash, function(sign) {
  38.                     ws.send(JSON.stringify({method:'sign',file:'prueba.pdf',sign:sign}));
  39.                 });
  40.                 break;
  41.             default:
  42.                 alert(obj.mensaje);
  43.                 ws.close();
  44.                 break;
  45.         }
  46.     }
  47. })(window, document, JSON);

El código anterior se encarga de abrir una conexión websocket con el servidor y cuando el usuario presione el botón Firmar envía el certificado obtenido del token y el nombre del archivo solicitando se calcule el hash, una vez que recibe el hash lo envía al Jacobitus Total y una vez obtenida la respuesta envía la firma al servidor.

Finalmente nos queda la interfaz HTML para que el usuario pueda interactuar con el sistema.

  1. <!DOCTYPE html>
  2. <html>
  3.     <head>
  4.         <title>Firma remota</title>
  5.         <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  6.         <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.0.2/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-EVSTQN3/azprG1Anm3QDgpJLIm9Nao0Yz1ztcQTwFspd3yD65VohhpuuCOmLASjC" crossorigin="anonymous">
  7.     </head>
  8.     <body class="container">
  9.         <h1>Firma remota</h1>
  10.         <form>
  11.             <div class="mb-3">
  12.                 <label for="tokens" class="form-label">Token</label>
  13.                 <select id="tokens" class="form-select">
  14.                     <option>No encontrado</option>
  15.                 </select>
  16.             </div>
  17.             <div class="mb-3">
  18.                 <label for="pass" class="form-label">Pin</label>
  19.                 <div class="input-group mb-3">
  20.                     <input id="pass" type="password" class="form-control">
  21.                     <button id="actualizar" type="button" class="btn btn-primary">Actualizar</button>
  22.                 </div>
  23.             </div>
  24.             <div class="mb-3">
  25.                 <label for="certs" class="form-label">Certificados</label>
  26.                 <select id="certs" class="form-select">
  27.                     <option>No encontrado</option>
  28.                 </select>
  29.             </div>
  30.             <button id="firmar" type="button" class="btn btn-primary">Firmar</button>
  31.         </form>
  32.         <script src="js/token.js"></script>
  33.         <script src="js/firmar.js"></script>
  34.     </body>
  35. </html>

El documento prueba.pdf de la carpeta /tmp se firmará con el certificado seleccionado del token criptográfico.

El documento firmado será guardado con el nombre /tmp/prueba.signed.pdf

Si desea descargar el ejemplo puede hacerlo a través del siguiente link: Código de ejemplo

© ADSIB 2019 Bolivia