Add signature to PDF in Kotlin for Android

1
/*
2
 *   Copyright © 2020-2025 PSPDFKit GmbH. All rights reserved.
3
 *
4
 *   The PSPDFKit Sample applications are licensed with a modified BSD license.
5
 *   Please see License for details. This notice may not be removed from this file.
6
 */
7

8
package com.pspdfkit.catalog.examples.kotlin
9

10
import android.content.Context
11
import android.net.Uri
12
import android.widget.Toast
13
import com.pspdfkit.catalog.R
14
import com.pspdfkit.catalog.SdkExample
15
import com.pspdfkit.configuration.activity.PdfActivityConfiguration
16
import com.pspdfkit.document.DocumentSource
17
import com.pspdfkit.document.PdfDocumentLoader
18
import com.pspdfkit.document.providers.AssetDataProvider
19
import com.pspdfkit.signatures.DigitalSignatureMetadata
20
import com.pspdfkit.signatures.SignatureAppearance
21
import com.pspdfkit.signatures.SignatureAppearance.SignatureAppearanceMode
22
import com.pspdfkit.signatures.SignerOptions
23
import com.pspdfkit.signatures.SigningManager
24
import com.pspdfkit.signatures.getPrivateKeyEntryFromP12Stream
25
import com.pspdfkit.signatures.getX509Certificates
26
import com.pspdfkit.signatures.timestamp.TimestampData
27
import com.pspdfkit.ui.PdfActivityIntentBuilder
28
import com.pspdfkit.utils.PdfLog
29
import java.io.File
30
import java.io.IOException
31
import java.security.GeneralSecurityException
32
import java.security.KeyStore
33
import java.security.NoSuchAlgorithmException
34
import java.security.PrivateKey
35
import java.security.Signature
36

37
/**
38
 * An example showing how to leverage customSigning functionality in [SigningManager] to digitally sign document manually.
39
 * */
40
class ManualSigningExample(context: Context) : SdkExample(context, R.string.manualSigningExampleTitle, R.string.manualSigningExampleDescription) {
41

42
    override fun launchExample(context: Context, configuration: PdfActivityConfiguration.Builder) {
43
        val assetName = "Form_example.pdf"
44

45
        val unsignedDocument = PdfDocumentLoader.openDocument(context, DocumentSource(AssetDataProvider(assetName)))
46
        val keyEntryWithCertificates = getPrivateKeyEntry(context)
47
        val privateKey = keyEntryWithCertificates.privateKey
48
        val certificates = keyEntryWithCertificates.getX509Certificates()
49
        val signatureFormFields = unsignedDocument.documentSignatureInfo.signatureFormFields
50
        val outputFile = File(context.filesDir, "signedDocument.pdf")
51
        outputFile.delete() // make sure output is deleted from previous runs.
52

53
        /** Configure the appearance of the signature using [SignatureAppearance] **/
54
        val appearance = SignatureAppearance(
55
            signatureAppearanceMode = SignatureAppearanceMode.SIGNATURE_ONLY
56
        )
57
        val metadata = DigitalSignatureMetadata(
58
            signatureAppearance = appearance,
59
            timestampData = TimestampData("https://freetsa.org/tsr")
60
        )
61

62
        /** [SignerOptions] contains all the required configuration for [SigningManager]*/
63
        val signerOptions = SignerOptions.Builder(signatureFormFields[0], Uri.fromFile(outputFile))
64
            .setCertificates(certificates)
65
            .setSignatureMetadata(metadata)
66
            .setType(digitalSignatureType)
67
            .build()
68

69
        /** [SignerOptions] contains all the required configuration for [SigningManager]*/
70
        SigningManager.signDocument(
71
            context = context,
72
            signerOptions = signerOptions,
73
            customSigning = { data, hashAlgorithm ->
74
                /** Here we are manually signing ByteArray with provided hashAlgorithm and private key, this is a mandatory step if
75
                 * customer doesn't provide private key in [SignerOptions] */
76
                data.signData(privateKey, hashAlgorithm)
77
            },
78
            onFailure = { e ->
79
                Toast.makeText(context, "Error launching example. See logcat for details.", Toast.LENGTH_SHORT).show()
80
                PdfLog.e("ManualSigningExample", e, "Error while launching example.")
81
            }
82
        ) {
83
            val signedDocument = Uri.fromFile(outputFile)
84
            // Load and show the signed document.
85
            val intent = PdfActivityIntentBuilder.fromUri(context, signedDocument)
86
                .configuration(configuration.build())
87
                .build()
88
            context.startActivity(intent)
89
        }
90
    }
91

92
    private fun ByteArray.signData(privateKey: PrivateKey, hashAlgorithm: String?): ByteArray = try {
93
        /** We are using the [Signature] class from java.security package, to sign the byte arrays.*/
94

95
        /** The signature algorithm can be, among others, the NIST standard DSA, using DSA and SHA-256.
96
         *  The DSA algorithm using the SHA-256 message digest algorithm can be specified as SHA256withDSA.
97
         *  In the case of RSA the signing algorithm could be specified as, for example, SHA256withRSA.
98
         *  The algorithm name must be specified, as there is no default.
99
         *
100
         *  Here 'hashAlgorithm' is SHA256 and 'key.algorithm' is RSA
101
         *  providing algorithm as SHA256withRSA
102
         *  for more details visit https://docs.oracle.com/javase/8/docs/api/java/security/Signature.html
103
         **/
104
        val algorithm = "${hashAlgorithm}with${privateKey.algorithm}"
105

106
        Signature.getInstance(algorithm).run {
107
            initSign(privateKey) // Initialize this object for signing.
108
            update(this@signData) // Updates the data to be signed or verified, using the specified array of bytes
109
            sign() // Returns the signature bytes of all the data updated
110
        }
111
    } catch (e: NoSuchAlgorithmException) {
112
        throw RuntimeException(e)
113
    }
114

115
    /**
116
     * Loads the [KeyStore.PrivateKeyEntry] that will be used by our [SigningManager].
117
     */
118
    @Throws(IOException::class, GeneralSecurityException::class)
119
    private fun getPrivateKeyEntry(context: Context): KeyStore.PrivateKeyEntry {
120
        // Inside a p12 we have both the certificate (or certificate chain to the root CA) and private key used for signing.
121
        val keystoreFile = context.assets.open("digital-signatures/ExampleSigner.p12")
122
        return getPrivateKeyEntryFromP12Stream(keystoreFile, "test")
123
    }
124
}