(Go) Sign PDF using Cloud Signature Consortium API

See more Signing in the Cloud Examples

Demonstrates how to sign a PDF using a CSC provider. (CSC is the acronym for Cloud Signature Consortium.) This example shows the how to sign a PDF using a particular instance of a CSC service providee JCC Payment Systems Ltd, a company based in Cyprus that provides payment processing services. To use a different CSC provider would only require the values of the JSON parameters, such as base URL, client ID, client secret, etc. to be modified.

The Cloud Signature Consortium (CSC) is an international group of organizations and technology providers dedicated to creating and promoting a standardized open API for cloud-based digital signatures. The goal of the consortium is to make remote, legally-binding digital signatures accessible through cloud-based services, ensuring compatibility and interoperability across different platforms, devices, and services.

The CSC develops and maintains an open standard for APIs that allow cloud-based digital signature solutions to be easily integrated into applications and platforms.

These APIs enable users to sign documents using cloud-based certificate authorities (CAs) and trust service providers (TSPs), ensuring legal compliance with digital signature regulations (such as eIDAS in the EU).

Note: This example requires Chilkat v10.0.0 or greater.

Chilkat Go Downloads Go Package for Windows, MacOS, Linux, Alpine Linux, Solaris

    // This example requires the Chilkat API to have been previously unlocked.
    // See Global Unlock Sample for sample code.

    pdf := chilkat.NewPdf()

    // Load a PDF to be signed.
    success := pdf.LoadFile("qa_data/pdf/hello.pdf")
    if success == false {
        fmt.Println(pdf.LastErrorText())
        pdf.DisposePdf()
        return
    }

    // Options for signing are specified in JSON.
    json := chilkat.NewJsonObject()

    // Indicate that we want an LTV-enabled signature
    json.UpdateBool("ltvOcsp",true)

    // Define the appearance of the signature.
    json.UpdateInt("page",1)
    json.UpdateString("appearance.y","top")
    json.UpdateString("appearance.x","left")
    json.UpdateString("appearance.fontScale","10.0")
    json.UpdateString("appearance.text[0]","Digitally signed by: cert_cn")
    json.UpdateString("appearance.text[1]","current_dt")
    json.UpdateString("appearance.text[2]","This is an LTV-enabled signature.")

    // --------------------------------------------------------------------
    // Provide the information about the CSC service to be used for signing.
    jsonCsc := chilkat.NewJsonObject()

    // Set the "service" equal to "CSC" to tell Chilkat to use the Cloud Signature Consortium API standard for signing.
    jsonCsc.UpdateString("service","CSC")

    // Provide the service's base URL, the user ID, client ID, and client secret.
    // Note: This example requires the CSC service to support the 
    // OAuth2 client credentials (oauth2code authType) method of authentication.

    // This is the base URL for the JCC CSC service.  It should be changed to your CSC provider's base URL.
    jsonCsc.UpdateString("baseUrl","https://ras-test.jcc.com.cy/adss/service/ras/csc/v1/")

    jsonCsc.UpdateString("userId","YOUR_USER_ID")
    jsonCsc.UpdateString("clientId","YOUR_CLIENT_ID")
    jsonCsc.UpdateString("clientSecret","YOUR_CLIENT_SECRET")

    // If your user ID has multiple possible credential IDs, you can select one by 
    // specifying the ID or a substring that must be contained within the ID.
    // Otherwise, Chilkat will use the 1st credential ID returned via the "credentials/list" endpoint.
    // ------------------------------------------------------------------------------------------------------------
    // IMPORTANT: Remove this line if you don't have multiple credential IDs, or if you wish to simply use the 1st.
    // ------------------------------------------------------------------------------------------------------------
    jsonCsc.UpdateString("useCredential","MY_CREDENTIAL_ID")

    // The SetCloudSigner method will send HTTPS REST requests to the base URL
    // to get information about the CSC service.
    // Specifically, it will do the following internally:
    // 1) Calls the "info" endpoint to get information about the remote service and the list of the API methods it supports.
    // 2) Calls the "oauth2/token" endpoint to get the OAuth2 authorization token via client credentials (using the clientId and clientSecret).
    // 3) Calls the "credentials/list" endpoint to get the list of credentials associated with the userId.
    // 4) Calls the "credentials/info" endpoint to retrieve the credential and return the main identity information 
    //    and the public key certificate or the certificate chain associated to it.
    //    The Chilkat certificate object is loaded with the retrieved certificate.
    cert := chilkat.NewCert()
    success = cert.SetCloudSigner(jsonCsc)

    // Tell the pdf object to use the certificate for signing.
    success = pdf.SetSigningCert(cert)
    if success == false {
        fmt.Println(pdf.LastErrorText())
        pdf.DisposePdf()
        json.DisposeJsonObject()
        jsonCsc.DisposeJsonObject()
        cert.DisposeCert()
        return
    }

    // This is where a 2FA means of authentication might occur, depending on the CSC provider.
    // For example, in the case of JCC Payment Systems, an authorization request is sent to 
    // the Ascertia GoSign app on your mobile device where you must authorize the request to sign.
    success = pdf.SignPdf(json,"qa_output/hello_signed.pdf")
    if success == false {
        fmt.Println(pdf.LastErrorText())
        pdf.DisposePdf()
        json.DisposeJsonObject()
        jsonCsc.DisposeJsonObject()
        cert.DisposeCert()
        return
    }

    fmt.Println("The PDF has been successfully signed using a CSC cloud signing service.")

    pdf.DisposePdf()
    json.DisposeJsonObject()
    jsonCsc.DisposeJsonObject()
    cert.DisposeCert()