Firma digital de PDF con certificado por software y C++

En este tutorial, se verá la implementación de firma digital desde una aplicación escrita en C++, haciendo uso de un par de claves y el certificado disponible en un contenedor PKCS#12.

En el caso de los archivos PDF, se maneja el contenido por secciones, ya que si comparamos el documento original con el firmado, serán diferentes por el contenido de la firma. Sin embargo el contenido propiamente del documento no cambia.

Por lo anterior, el cálculo del HASH se realiza sobre el contenido del PDF como se explica en el siguiente enlace: PDF

El mayor reto al momento de firmar un documento PDF es la manipulación del mismo, por lo que es necesario apoyarse en alguna librería. En nuestro caso se utilizará la librería publicada en: PoDoFo.

Para Debian 10 la librería viene incluída en los repositorios, por lo que solo hará falta ejecutar la siguiente instrucción:

  1. sudo apt install build-essential libpodofo-dev codeblocks

En caso de utilizar una versión previa a Debian 10, se deberá compilar la versión de libpodofo 0.9.6. Adicionalmente a las dependencias se instaló codeblocks que se utilizará para escribir el programa de manera más amigable, por lo que el primer paso será ingresar a codeblocks y crear un proyecto "Console Application".

Console Application

Seguir los siguientes pasos hasta finalizar el asistente.

Console Application Console Application Console Application

Teniendo el proyecto creado, lo primero será agregar el archivo "podofosign.cpp" que podrá ser reutilizado en otros proyectos para firmar.

Console Application Console Application Console Application

Dentro del archivo agregar las siguientes cabeceras:

  1. #include <podofo/podofo.h>
  3. #include <openssl/err.h>
  4. #include <openssl/pkcs12.h>
  6. using namespace PoDoFo;

Una vez importadas las cabeceras es necesario crear la siguiente función para calcular el espacio que ocupará la firma dentro del PDF.

  1. static bool load_cert_and_key(X509** out_cert, EVP_PKEY** out_pkey, pdf_int32& min_signature_size)
  2. {
  3.     min_signature_size = 0;
  5.     int l;
  6.     if ((l = i2d_X509( *out_cert, NULL )) != -1) {
  7.         min_signature_size += l + 418;
  8.     } else {
  9.         min_signature_size += 3072;
  10.     }
  12.     if ((l = EVP_PKEY_size( *out_pkey )) != -1) {
  13.         min_signature_size += l + 1448;
  14.     } else {
  15.         min_signature_size += 1042;
  16.     }
  18.     return true;
  19. }

El certificado y llave privada de la función anterior se los obtendrá del archivo pfx mediante la siguiente función.

  1. void abrir(std::string filePfx, std::string password, X509** cert, EVP_PKEY** pkey)
  2. {
  3.     FILE *fp = fopen(filePfx.c_str(), "rb");
  4.     if (fp == NULL) {
  5.         throw "No se pudo abrir el archivo.";
  6.     }
  7.     PKCS12 *p12_cert = NULL;
  8.     STACK_OF(X509) *additional_certs = NULL;
  10.     OpenSSL_add_all_algorithms();
  11.     if (d2i_PKCS12_fp(fp, &p12_cert) < 0) {
  12.         fclose(fp);
  13.         throw "Error al leer el archivo.";
  14.     }
  15.     fclose(fp);
  17.     if (PKCS12_parse(p12_cert, password.c_str(), pkey, cert, &additional_certs) == 0) {
  18.         int err = ERR_get_error();
  19.         switch (err) {
  20.             case 218570875:
  21.             case 218542222:
  22.             case 218529960:
  23.                 throw "Formato de archvio incorrecto.";
  24.             case 587686001:
  25.                 throw "Contraseña incorrecta.";
  26.             default:
  27.                 throw "Error desconocido.";
  28.         }
  29.     }
  30. }

Para verificar que no existan otros campos de firma.

  1. static PdfObject* find_existing_signature_field(PdfAcroForm* pAcroForm, const PdfString& name)
  2. {
  3.     if( !pAcroForm )
  4.         PODOFO_RAISE_ERROR( ePdfError_InvalidHandle );
  6.     PdfObject* pFields = pAcroForm->GetObject()->GetDictionary().GetKey( PdfName( "Fields" ) );
  7.     if( pFields )
  8.     {
  9.         if( pFields->GetDataType() == ePdfDataType_Reference )
  10.             pFields = pAcroForm->GetDocument()->GetObjects()->GetObject( pFields->GetReference() );
  12.         if( pFields && pFields->GetDataType() == ePdfDataType_Array )
  13.         {
  14.             PdfArray &rArray = pFields->GetArray();
  15.             PdfArray::iterator it, end = rArray.end();
  16.             for( it = rArray.begin(); it != end; it++ )
  17.             {
  18.                 // require references in the Fields array
  19.                 if( it->GetDataType() == ePdfDataType_Reference )
  20.                 {
  21.                     PdfObject *item = pAcroForm->GetDocument()->GetObjects()->GetObject( it->GetReference() );
  23.                     if( item && item->GetDictionary().HasKey( PdfName( "T" ) ) &&
  24.                         item->GetDictionary().GetKey( PdfName( "T" ) )->GetString() == name )
  25.                     {
  26.                         // found a field with the same name
  27.                         const PdfObject *pFT = item->GetDictionary().GetKey( PdfName( "FT" ) );
  28.                         if( !pFT && item->GetDictionary().HasKey( PdfName( "Parent" ) ) )
  29.                         {
  30.                             const PdfObject *pTemp = item->GetIndirectKey( PdfName( "Parent" ) );
  31.                             if( !pTemp )
  32.                             {
  33.                                 PODOFO_RAISE_ERROR( ePdfError_InvalidDataType );
  34.                             }
  36.                             pFT = pTemp->GetDictionary().GetKey( PdfName( "FT" ) );
  37.                         }
  39.                         if( !pFT )
  40.                         {
  41.                             PODOFO_RAISE_ERROR( ePdfError_NoObject );
  42.                         }
  44.                         const PdfName fieldType = pFT->GetName();
  45.                         if( fieldType != PdfName( "Sig" ) )
  46.                         {
  47.                             std::string err = "Existing field '";
  48.                             err += name.GetString();
  49.                             err += "' isn't of a signature type, but '";
  50.                             err += fieldType.GetName().c_str();
  51.                             err += "' instead";
  53.                             PODOFO_RAISE_ERROR_INFO( ePdfError_InvalidName, err.c_str() );
  54.                         }
  56.                         return item;
  57.                     }
  58.                 }
  59.             }
  60.         }
  61.     }
  63.     return NULL;
  64. }

Y para crear la firma se utilizará la siguiente función.

  1. static void sign_with_signer( PdfSignOutputDevice &signer, X509 *cert, EVP_PKEY *pkey )
  2. {
  3.     if( !cert )
  4.         PODOFO_RAISE_ERROR_INFO( ePdfError_InvalidHandle, "cert == NULL" );
  5.     if( !pkey )
  6.         PODOFO_RAISE_ERROR_INFO( ePdfError_InvalidHandle, "pkey == NULL" );
  8.     unsigned int uBufferLen = 65535, len;
  9.     char *pBuffer;
  11.     while( pBuffer = reinterpret_cast<char *>( podofo_malloc( sizeof( char ) * uBufferLen) ), !pBuffer )
  12.     {
  13.         uBufferLen = uBufferLen / 2;
  14.         if( !uBufferLen )
  15.             break;
  16.     }
  18.     if( !pBuffer )
  19.         PODOFO_RAISE_ERROR (ePdfError_OutOfMemory);
  21.     int rc;
  22.     BIO *mem = BIO_new( BIO_s_mem() );
  23.     if( !mem )
  24.     {
  25.         podofo_free( pBuffer );
  26.         throw "Failed to create input BIO";
  27.     }
  29.     unsigned int flags = PKCS7_DETACHED | PKCS7_BINARY;
  30.     PKCS7 *pkcs7 = PKCS7_sign( cert, pkey, NULL, mem, flags );
  31.     if( !pkcs7 )
  32.     {
  33.         BIO_free( mem );
  34.         podofo_free( pBuffer );
  35.         throw "PKCS7_sign failed";
  36.     }
  38.     while( len = signer.ReadForSignature( pBuffer, uBufferLen ), len > 0 )
  39.     {
  40.         rc = BIO_write( mem, pBuffer, len );
  41.         if( static_cast<unsigned int>( rc ) != len )
  42.         {
  43.             PKCS7_free( pkcs7 );
  44.             BIO_free( mem );
  45.             podofo_free( pBuffer );
  46.             throw "BIO_write failed";
  47.         }
  48.     }
  50.     podofo_free( pBuffer );
  52.     if( PKCS7_final( pkcs7, mem, flags ) <= 0 )
  53.     {
  54.         PKCS7_free( pkcs7 );
  55.         BIO_free( mem );
  56.         throw "PKCS7_final failed";
  57.     }
  59.     bool success = false;
  60.     BIO *out = BIO_new( BIO_s_mem() );
  61.     if( !out )
  62.     {
  63.         PKCS7_free( pkcs7 );
  64.         BIO_free( mem );
  65.         throw "Failed to create output BIO";
  66.     }
  68.     char *outBuff = NULL;
  69.     long outLen;
  71.     i2d_PKCS7_bio( out, pkcs7 );
  73.     outLen = BIO_get_mem_data( out, &outBuff );
  75.     if( outLen > 0 && outBuff )
  76.     {
  77.         if( static_cast<size_t>( outLen ) > signer.GetSignatureSize() )
  78.         {
  79.             PKCS7_free( pkcs7 );
  80.             BIO_free( out );
  81.             BIO_free( mem );
  83.             std::ostringstream oss;
  84.             oss << "Requires at least " << outLen << " bytes for the signature, but reserved is only " << signer.GetSignatureSize() << " bytes";
  85.             PODOFO_RAISE_ERROR_INFO( ePdfError_ValueOutOfRange, oss.str().c_str() );
  86.         }
  88.         PdfData signature( outBuff, outLen );
  89.         signer.SetSignature( signature );
  90.         success = true;
  91.     }
  93.     PKCS7_free( pkcs7 );
  94.     BIO_free( out );
  95.     BIO_free( mem );
  97.     if( !success )
  98.         throw "Failed to get data from the output BIO";
  99. }

Finalmente la función que hace toda la magia.

  1. const char* sign(const char *inputfile, const char *filePfx, const char *password)
  2. {
  3.     EVP_PKEY *pkey;
  4.     X509 *cert;
  5.     abrir(filePfx, password, &cert, &pkey);
  6.     const char *outputfile = "/tmp/signed.pdf";
  7.     const char *reason = "I agree";
  8.     const char *sigsizestr = NULL;
  9.     const char *annot_position = NULL;
  10.     const char *field_name = NULL;
  11.     int annot_page = 0;
  12.     double annot_left = 0.0, annot_top = 0.0, annot_width = 0.0, annot_height = 0.0;
  13.     bool annot_print = false;
  14.     bool field_use_existing = false;
  16.     PdfError::EnableDebug( false );
  18.     int sigsize = -1;
  20.     if( sigsizestr )
  21.     {
  22.         sigsize = atoi( sigsizestr );
  24.         if( sigsize <= 0 )
  25.         {
  26.             throw (std::string("Invalid value for signature size specified (") + sigsizestr + "), use a positive integer, please").c_str();
  27.         }
  28.     }
  30.     if( outputfile && strcmp( outputfile, inputfile ) == 0)
  31.     {
  32.         // even I told you not to do it, you still specify the same output file
  33.         // as the input file. Just ignore that.
  34.         outputfile = NULL;
  35.     }
  37. #ifdef PODOFO_HAVE_OPENSSL_1_1
  38.     OPENSSL_init_crypto(0, NULL);
  39. #else
  40.     OpenSSL_add_all_algorithms();
  41.     ERR_load_crypto_strings();
  42.     ERR_load_PEM_strings();
  43.     ERR_load_ASN1_strings();
  44.     ERR_load_EVP_strings();
  45. #endif
  47.     pdf_int32 min_signature_size = 0;
  49.     if( !load_cert_and_key( &cert, &pkey, min_signature_size ) )
  50.     {
  51.         throw "Error al cargar el certificado y clave.";
  52.     }
  54.     if( sigsize > 0 )
  55.         min_signature_size = sigsize;
  57.     PdfSignatureField *pSignField = NULL;
  58.     PdfAnnotation *pTemporaryAnnot = NULL; // for existing signature fields
  60.     try
  61.     {
  62.         PdfMemDocument document;
  64.         document.Load( inputfile, true );
  66.         if( !document.GetPageCount() )
  67.             PODOFO_RAISE_ERROR_INFO( ePdfError_PageNotFound, "The document has no page. Only documents with at least one page can be signed" );
  69.         PdfAcroForm* pAcroForm = document.GetAcroForm();
  70.         if( !pAcroForm )
  71.             PODOFO_RAISE_ERROR_INFO( ePdfError_InvalidHandle, "acroForm == NULL" );
  73.         if( !pAcroForm->GetObject()->GetDictionary().HasKey( PdfName( "SigFlags" ) ) ||
  74.             !pAcroForm->GetObject()->GetDictionary().GetKey( PdfName( "SigFlags" ) )->IsNumber() ||
  75.             pAcroForm->GetObject()->GetDictionary().GetKeyAsLong( PdfName( "SigFlags" ) ) != 3 )
  76.         {
  77.             if( pAcroForm->GetObject()->GetDictionary().HasKey( PdfName( "SigFlags" ) ) )
  78.                 pAcroForm->GetObject()->GetDictionary().RemoveKey( PdfName( "SigFlags" ) );
  80.             pdf_int64 val = 3;
  81.             pAcroForm->GetObject()->GetDictionary().AddKey( PdfName( "SigFlags" ), PdfObject( val ) );
  82.         }
  84.         if( pAcroForm->GetNeedAppearances() )
  85.         {
  86.             pAcroForm->SetNeedAppearances( false );
  87.         }
  89.         PdfOutputDevice outputDevice( outputfile, true );
  90.         PdfSignOutputDevice signer( &outputDevice );
  92.         PdfString name;
  93.         PdfObject* pExistingSigField = NULL;
  95.         if( field_name )
  96.         {
  97.             name = PdfString( field_name );
  99.             pExistingSigField = find_existing_signature_field( pAcroForm, name );
  100.             if( pExistingSigField && !field_use_existing)
  101.             {
  102.                 std::string err = "Signature field named '";
  103.                 err += name.GetString();
  104.                 err += "' already exists";
  106.                 PODOFO_RAISE_ERROR_INFO( ePdfError_WrongDestinationType, err.c_str() );
  107.             }
  108.         }
  109.         else
  110.         {
  111.             char fldName[96]; // use bigger buffer to make sure sprintf does not overflow
  112.             sprintf( fldName, "PodofoSignatureField%" PDF_FORMAT_INT64, static_cast<pdf_int64>( document.GetObjects().GetObjectCount() ) );
  114.             name = PdfString( fldName );
  115.         }
  117.         if( pExistingSigField )
  118.         {
  119.             if( !pExistingSigField->GetDictionary().HasKey( "P" ) )
  120.             {
  121.                 std::string err = "Signature field named '";
  122.                 err += name.GetString();
  123.                 err += "' doesn't have a page reference";
  125.                 PODOFO_RAISE_ERROR_INFO( ePdfError_PageNotFound, err.c_str() );
  126.             }
  128.             PdfPage* pPage;
  130.             pPage = document.GetPagesTree()->GetPage( pExistingSigField->GetDictionary().GetKey( "P" )->GetReference() );
  131.             if( !pPage )
  132.                 PODOFO_RAISE_ERROR( ePdfError_PageNotFound );
  134.             pTemporaryAnnot = new PdfAnnotation( pExistingSigField, pPage );
  135.             if( !pTemporaryAnnot )
  136.                 PODOFO_RAISE_ERROR_INFO( ePdfError_OutOfMemory, "Cannot allocate annotation object for existing signature field" );
  138.             pSignField = new PdfSignatureField( pTemporaryAnnot );
  139.             if( !pSignField )
  140.                 PODOFO_RAISE_ERROR_INFO( ePdfError_OutOfMemory, "Cannot allocate existing signature field object" );
  142.             pSignField->EnsureSignatureObject();
  143.         }
  144.         else
  145.         {
  146.             PdfPage* pPage = document.GetPage( annot_page );
  147.             if( !pPage )
  148.                 PODOFO_RAISE_ERROR( ePdfError_PageNotFound );
  150.             PdfRect annot_rect;
  151.             if( annot_position )
  152.             {
  153.                 annot_rect = PdfRect( annot_left, pPage->GetPageSize().GetHeight() - annot_top - annot_height, annot_width, annot_height );
  154.             }
  156.             PdfAnnotation* pAnnot = pPage->CreateAnnotation( ePdfAnnotation_Widget, annot_rect );
  157.             if( !pAnnot )
  158.                 PODOFO_RAISE_ERROR_INFO( ePdfError_OutOfMemory, "Cannot allocate annotation object" );
  160.             if( annot_position && annot_print )
  161.                 pAnnot->SetFlags( ePdfAnnotationFlags_Print );
  162.             else if( !annot_position && ( !field_name || !field_use_existing ) )
  163.                 pAnnot->SetFlags( ePdfAnnotationFlags_Invisible | ePdfAnnotationFlags_Hidden );
  165.             pSignField = new PdfSignatureField( pAnnot, pAcroForm, &document );
  166.             if( !pSignField )
  167.                 PODOFO_RAISE_ERROR_INFO( ePdfError_OutOfMemory, "Cannot allocate signature field object" );
  168.         }
  170.         // use large-enough buffer to hold the signature with the certificate
  171.         signer.SetSignatureSize( min_signature_size );
  173.         pSignField->SetFieldName( name );
  174.         pSignField->SetSignatureReason( PdfString( reinterpret_cast<const pdf_utf8 *>( reason ) ) );
  175.         pSignField->SetSignatureDate( PdfDate() );
  176.         pSignField->SetSignature( *signer.GetSignatureBeacon() );
  178.         // The outputfile != NULL means that the write happens to a new file,
  179.         // which will be truncated first and then the content of the inputfile
  180.         // will be copied into the document, follwed by the changes.
  181.         document.WriteUpdate( &signer, outputfile != NULL );
  183.         if( !signer.HasSignaturePosition() )
  184.             PODOFO_RAISE_ERROR_INFO( ePdfError_SignatureError, "Cannot find signature position in the document data" );
  186.         // Adjust ByteRange for signature
  187.         signer.AdjustByteRange();
  189.         // Read data for signature and count it
  190.         // We seek at the beginning of the file
  191.         signer.Seek( 0 );
  193.         sign_with_signer( signer, cert, pkey );
  195.         signer.Flush();
  196.     }
  197.     catch( PdfError & e )
  198.     {
  199.         if (strcmp(e.what(), "ePdfError_NoPdfFile") == 0)
  200.         {
  201.             throw "Formato de archivo incorrecto.";
  202.         }
  203.         throw (std::string("Error: ") + e.what()).c_str();
  204.     }
  206. #ifndef PODOFO_HAVE_OPENSSL_1_1
  207.     ERR_free_strings();
  208. #endif
  210.     if( pSignField )
  211.         delete pSignField;
  213.     if( pTemporaryAnnot )
  214.         delete pTemporaryAnnot;
  216.     return outputfile;
  217. }

Nota.- Las funciones anteriores fueron modificadas de: PoDoFo

Para poder reutilizar la funcion sign será necesario crear un nuevo archivo de cabecera:

Console Application Console Application Console Application

Dentro de la cabecera simplemente habrá que hacer accesible el método sign.

  1. /*! Método para firmar documentos haciendo uso de PoDoFo. */
  2. const char* sign(const char *inputfile, const char *filePfx, const char *password);

Y en el método main del archivo main será decirle que archivo y certificado por software utilizar.

  1. cout << sign("/home/alberto/Documentos/prueba.pdf", "/home/alberto/Documentos/token.p12", "12345678") << endl;

Si se intenta compilar se producirá un error al no estar referenciadas las librerías. Para referenciar elegir la opción Build options del menú contextual.

Console Application Console Application

En el panel Other linker options, se especifica las librerías que serán enlazadas, que para este caso son openssl y podofo.

Si se compila y ejecuta se firmará el archivo prueba.pdf y se guardará el archivo firmado en /tmp/firmado.pdf.

Si desea descargar un ejemplo de archivo firmado puede hacerlo a través del siguiente link: Archivo firmado de ejemplo

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

© ADSIB 2019 Bolivia