(Go) Streaming Compression --> Streaming Encryption

Demonstrate how to feed a compression stream into an encryption stream. This example does the following:

Data File --> Compress --> Encrypt --> Application Reads

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

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

    var success bool

    // Initialize the compression object.
    compress := chilkat.NewCompression()
    compress.SetAlgorithm("deflate")

    // Initialize the encryption object.
    crypt := chilkat.NewCrypt2()
    crypt.SetCryptAlgorithm("chacha20")
    crypt.SetKeyLength(256)
    crypt.SetEncodingMode("hex")
    ivHex := "000000000000000000000002"
    crypt.SetEncodedIV(ivHex,"hex")
    crypt.SetInitialCount(42)
    keyHex := "1c9240a5eb55d38af333888604f6b5f0473917c1402b80099dca5cbc207075c0"
    crypt.SetEncodedKey(keyHex,"hex")

    // Setup the streams.  
    // streamC is for compression
    streamC := chilkat.NewStream()
    // streamE is for encryption
    streamE := chilkat.NewStream()

    // The source for the compressor is a file.
    streamC.SetSourceFile("qa_data/hamlet.xml")
    // The source for the encryptor is the output of the compressor stream.
    success = streamE.SetSourceStream(streamC)

    // Our application will be reading the output of streamE.
    // Start the compression and encryption streams in background threads..
    c := make(chan *chilkat.Task)
    go compress.CompressStreamAsync(streamC,c)
    taskC := <-c
    c := make(chan *chilkat.Task)
    go crypt.EncryptStreamAsync(streamE,c)
    taskE := <-c

    // Read the compressed and encrypted bytes.
    outData := chilkat.NewBinData()
    for (streamE.EndOfStream() != true) {
        if streamE.DataAvailable() == true {
            success = streamE.ReadBd(outData)
        }

    }

    // Let's make sure the background task finished.
    // It should already be the case that the task is finished.
    for ((taskE.Finished() != true) || (taskC.Finished() != true)) {
        taskE.SleepMs(20)
    }

    // Get any remaining data that needs to be flushed.
    if streamE.DataAvailable() == true {
        success = streamE.ReadBd(outData)
    }

    // Double-check for success..
    if taskE.TaskSuccess() != true {
        fmt.Println("async encryption failed:")
        fmt.Println(taskE.ResultErrorText())
        success = false
    }

    // Double-check for success..
    if taskC.TaskSuccess() != true {
        fmt.Println("async compression failed:")
        fmt.Println(taskC.ResultErrorText())
        success = false
    }

    taskE.DisposeTask()
    taskC.DisposeTask()

    // Save the compressed/encrypted data to a file.
    outData.WriteFile("qa_output/compressedEncrypted.dat")

    fmt.Println("The async compress/encrypt was successful.")

    // Let's decrypt and decompress to further verify...
    success = crypt.DecryptBd(outData)
    success = compress.DecompressBd(outData)

    // outData should contain the original data..
    success = outData.WriteFile("qa_output/original_hamlet.xml")

    compress.DisposeCompression()
    crypt.DisposeCrypt2()
    streamC.DisposeStream()
    streamE.DisposeStream()
    taskC.DisposeTask()
    taskE.DisposeTask()
    outData.DisposeBinData()