Third Party Signing Example

1
/*
2
 *   Copyright © 2020-2026 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.util.Log
13
import com.pspdfkit.catalog.R
14
import com.pspdfkit.catalog.SdkExample
15
import com.pspdfkit.catalog.SdkExample.Companion.TAG
16
import com.pspdfkit.configuration.activity.PdfActivityConfiguration
17
import com.pspdfkit.document.DocumentSource
18
import com.pspdfkit.document.PdfDocumentLoader
19
import com.pspdfkit.document.providers.AssetDataProvider
20
import com.pspdfkit.signatures.DigitalSignatureType
21
import com.pspdfkit.signatures.SignerOptions
22
import com.pspdfkit.signatures.SigningConfiguration
23
import com.pspdfkit.signatures.SigningManager
24
import com.pspdfkit.signatures.getPrivateKeyEntryFromP12Stream
25
import com.pspdfkit.signatures.getX509Certificates
26
import com.pspdfkit.ui.PdfActivityIntentBuilder
27
import kotlinx.coroutines.CoroutineScope
28
import kotlinx.coroutines.Dispatchers
29
import kotlinx.coroutines.launch
30
import java.io.File
31
import java.io.IOException
32
import java.security.GeneralSecurityException
33
import java.security.KeyStore
34

35
/**
36
 * An example showing the ability to sign a document using a third-party service.
37
 * */
38
class ThirdPartySigningExample(context: Context) : SdkExample(context, R.string.thirdPartySigningExampleTitle, R.string.thirdPartySigningExampleDescription) {
39

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

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

49
        /** [SignerOptions] contains all the required configuration for [SigningManager]*/
50
        val signerOptions = SignerOptions.Builder(signatureFormFields[0], Uri.fromFile(outputFile))
51
            .setType(digitalSignatureType).build()
52
        CoroutineScope(Dispatchers.Main).launch {
53
            SigningManager.getDataToSign(context, signerOptions).onSuccess { unsignedData ->
54
                // ---  Start  --- //
55
                // This code can be replaced by a third party signing service that signs the data in PKCS@7 format.
56
                val signingConfiguration = SigningConfiguration(
57
                    privateKey = keyEntryWithCertificates.privateKey,
58
                    certificates = keyEntryWithCertificates.getX509Certificates()
59
                )
60
                val signResponse = if (digitalSignatureType == DigitalSignatureType.BASIC) {
61
                    SigningManager.signWithBasicSignature(context, signingConfiguration, unsignedData.first, unsignedData.second)
62
                } else {
63
                    SigningManager.signWithCAdESSignature(context, signingConfiguration, unsignedData.first, unsignedData.second)
64
                }
65
                // ---  End  --- //
66

67
                signResponse.onSuccess { signedData ->
68
                    SigningManager.embedPKCS7Signature(context, signerOptions, signedData).onSuccessEmpty {
69
                        val intent = PdfActivityIntentBuilder.fromUri(context, Uri.fromFile(outputFile))
70
                            .configuration(configuration.build())
71
                            .build()
72
                        context.startActivity(intent)
73
                    }.onError { Log.e(TAG, "embedPKCS7Signature: ${it.localizedMessage}") }
74
                }.onError { Log.e(TAG, "signWithBasicSignature: ${it.localizedMessage}") }
75
            }.onError { Log.e(TAG, "getDataToSign: ${it.localizedMessage}") }
76
        }
77
    }
78

79
    /**
80
     * Loads the [KeyStore.PrivateKeyEntry] that will be used by our [SigningManager].
81
     */
82
    @Throws(IOException::class, GeneralSecurityException::class)
83
    private fun getPrivateKeyEntry(context: Context): KeyStore.PrivateKeyEntry {
84
        // Inside a p12 we have both the certificate (or certificate chain to the root CA) and private key used for signing.
85
        val keystoreFile = context.assets.open("digital-signatures/ExampleSigner.p12")
86
        return getPrivateKeyEntryFromP12Stream(keystoreFile, "test")
87
    }
88
}