(Go) Streaming Encryption

Encrypt and decrypt using a stream.

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

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

    crypt := chilkat.NewCrypt2()

    // Setup encryption using the chacha20 algorithm...
    crypt.SetCryptAlgorithm("chacha20")
    crypt.SetKeyLength(256)
    crypt.SetEncodingMode("hex")
    ivHex := "000000000000000000000002"
    crypt.SetEncodedIV(ivHex,"hex")
    crypt.SetInitialCount(42)
    keyHex := "1c9240a5eb55d38af333888604f6b5f0473917c1402b80099dca5cbc207075c0"
    crypt.SetEncodedKey(keyHex,"hex")

    var plainText *string = new(string)
    *plainText = "The quick brown fox jumped over the lazy dog.\r\n"

    stream := chilkat.NewStream()

    // We'll save the encrypted output in eStrings to demonstrate streaming decryption next.
    eStrings := chilkat.NewStringArray()

    // Start a background task that will encrypt a stream.
    c := make(chan *chilkat.Task)
    go crypt.EncryptStreamAsync(stream,c)
    task := <-c
    var success bool

    // Write plainText to the stream, and read chacha20 encrypted text..
    var cipherText *string = new(string)
    var i int
    for i = 1; i <= 10; i++ {
        // Note: An encryption algorithm's block size will cause buffering,
        // and therefore not every loop iteration will produce output.
        success = stream.WriteString(*plainText)
        if stream.DataAvailable() == true {
            cipherText = stream.ReadBytesENC("hex")
            fmt.Println(*cipherText)
            success = eStrings.Append(*cipherText)
        }

    }

    // Tell the background task that the stream has ended.
    success = stream.WriteClose()

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

    // Get any remaining data available from the stream.
    if stream.DataAvailable() == true {
        cipherText = stream.ReadBytesENC("hex")
        fmt.Println(*cipherText)
        success = eStrings.Append(*cipherText)
    }

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

    task.DisposeTask()

    fmt.Println("-- encrypt finished --")

    // Now decrypt to return the original.

    // Reset the stream object so it can be used again.
    stream.Reset()

    // Start a background task that will decrypt a stream.
    c := make(chan *chilkat.Task)
    go crypt.DecryptStreamAsync(stream,c)
    task := <-c

    n := eStrings.Count()
    for i = 0; i <= n - 1; i++ {
        success = stream.WriteBytesENC(*eStrings.GetString(i),"hex")
        if stream.DataAvailable() == true {
            plainText = stream.ReadString()
            fmt.Println(*plainText)
        }

    }

    // Tell the background task that the stream has ended.
    success = stream.WriteClose()

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

    // Get any remaining data available from the stream.
    if stream.DataAvailable() == true {
        plainText = stream.ReadString()
        fmt.Println(*plainText)
    }

    if task.TaskSuccess() != true {
        fmt.Println("async decryption failed:")
        fmt.Println(task.ResultErrorText())
        success = false
    }

    task.DisposeTask()

    fmt.Println("-- decrypt finished --")

    crypt.DisposeCrypt2()
    stream.DisposeStream()
    eStrings.DisposeStringArray()
    task.DisposeTask()
    task.DisposeTask()