(Go) Stream a file to compression to encryption to an output file.

Runs a chain of streams to read a source file, compress, encrypt, and write an output file.

Chilkat Go Downloads Go Package for Windows, Linux, Alpine Linux, MAC OS X, Solaris, FreeBSD, OpenBSD, Raspberry Pi and other single board computers

    // 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)

    // The sink for the encryptor is the output file.
    streamE.SetSinkFile("qa_output/compressed_encrypted.dat")

    // 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

    // Let the streams run until finished.
    // 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)
    }

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

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

    taskE.DisposeTask()
    taskC.DisposeTask()

    // Load the file that was produced and decrypt/decompress to verify.
    binData := chilkat.NewBinData()
    success = binData.LoadFile("qa_output/compressed_encrypted.dat")
    success = crypt.DecryptBd(binData)
    success = compress.DecompressBd(binData)

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

    fmt.Println("Finished.")

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