Added Base64Sink and CipherSink.

Author: erickok

lib/src/main/java/nl/nl2312/okio/base64/Base64Sink.kt

@@ -0,0 +1,28 @@
+package nl.nl2312.okio.base64
+
+import okio.Buffer
+import okio.ForwardingSink
+import okio.Sink
+
+/**
+ * Encodes writes to a [Sink] on the fly using Base64.
+ *
+ * <p>Chunked writing is unsupported; the written Base64 output is always finalised. However, partial writing (not
+ * draining the full source) is supported.
+ */
+class Base64Sink(delegate: Sink) : ForwardingSink(delegate) {
+
+    override fun write(source: Buffer, byteCount: Long) {
+        // Read the requested number of bytes (or all available) from source
+        val bytesToRead = byteCount.coerceAtMost(source.size())
+        val decoded = source.readByteString(bytesToRead)
+
+        // Base64-encode
+        val encoded = decoded.base64()
+
+        val encodedSink = Buffer()
+        encodedSink.writeUtf8(encoded)
+        super.write(encodedSink, encodedSink.size())
+    }
+
+}

lib/src/main/java/nl/nl2312/okio/base64/Base64Source.kt

@@ -7,6 +7,10 @@ import okio.Source
 
 /**
  * Accepts any Base64-encoded data [Source] and decodes it on the fly.
+ *
+ * <p>Chunked and partial reading is supported. Requests for a specific number of bytes are honored (until the source
+ * is drained). Due to the nature of Base64 encoding, this means that for every 3 requested bytes, 4 bytes are read from
+ * the source.
  */
 class Base64Source(source: Source) : ForwardingSource(source) {
 

lib/src/main/java/nl/nl2312/okio/cipher/CipherSink.kt

@@ -0,0 +1,31 @@
+package nl.nl2312.okio.cipher
+
+import okio.Buffer
+import okio.ForwardingSink
+import okio.Sink
+import javax.crypto.Cipher
+
+/**
+ * Encrypts writes to a [Sink] on the fly given a pre-set [Cipher].
+ *
+ * <p>Chunked writing is unsupported; the written ciphered output is always finalised. However, partial writing (not
+ * draining the full source) is supported.
+ */
+class CipherSink(
+        delegate: Sink,
+        private val cipher: Cipher) : ForwardingSink(delegate) {
+
+    override fun write(source: Buffer, byteCount: Long) {
+        // Read the requested number of bytes (or all available) from source
+        val bytesToRead = byteCount.coerceAtMost(source.size())
+        val decrypted = source.readByteArray(bytesToRead)
+
+        // Encrypt
+        val encrypted = cipher.doFinal(decrypted)
+
+        val encryptedSink = Buffer()
+        encryptedSink.write(encrypted)
+        super.write(encryptedSink, encryptedSink.size())
+    }
+
+}

lib/src/main/java/nl/nl2312/okio/cipher/CipherSource.kt

@@ -7,6 +7,9 @@ import javax.crypto.Cipher
 
 /**
  * Accepts an encrypted [Source] and deciphers it on the fly.
+ *
+ * <p>Chunked and partial reading is supported. However, the deciphered output text is not complete until the [Source]
+ * is drained. Do not attempt to (re-)use the supplied [cipher] until the full source stream is completed.
  */
 class CipherSource(
         source: Source,

lib/src/test/java/nl/nl2312/okio/base64/Base64SinkTest.kt

@@ -0,0 +1,33 @@
+package nl.nl2312.okio.base64
+
+import com.google.common.truth.Truth.assertThat
+import okio.Buffer
+import org.junit.Test
+
+class Base64SinkTest {
+
+    private val utf8String = "okio oh my¿¡"
+    private val utf8Sink = Buffer().writeUtf8(utf8String)
+
+    @Test
+    fun write_fromFixedString() {
+        val output = Buffer()
+        val sink = Base64Sink(output)
+
+        sink.write(utf8Sink, Long.MAX_VALUE)
+
+        assertThat(output.readUtf8()).isEqualTo("b2tpbyBvaCBtecK/wqE=")
+    }
+
+    @Test
+    fun write_partialWrite() {
+        val output = Buffer()
+        val sink = Base64Sink(output)
+
+        // Request only to write the first 5 (decoded) characters
+        sink.write(utf8Sink, 5)
+
+        assertThat(output.readUtf8()).isEqualTo("b2tpbyA=")
+    }
+
+}

lib/src/test/java/nl/nl2312/okio/cipher/CipherSinkTest.kt

@@ -0,0 +1,89 @@
+package nl.nl2312.okio.cipher
+
+import com.google.common.truth.Truth.assertThat
+import okio.Buffer
+import org.junit.Test
+import java.security.SecureRandom
+import javax.crypto.BadPaddingException
+import javax.crypto.Cipher
+import javax.crypto.spec.IvParameterSpec
+import javax.crypto.spec.SecretKeySpec
+
+
+class CipherSinkTest {
+
+    private val encodeCipher: Cipher
+    private val decodeCipher: Cipher
+
+    init {
+        // Generate random secret key for the scope of these tests
+        val secureRandom = SecureRandom()
+        val key = ByteArray(16)
+        secureRandom.nextBytes(key)
+        val secretKeySpec = SecretKeySpec(key, "AES")
+        val ivBytes = ByteArray(16)
+        secureRandom.nextBytes(ivBytes)
+        val iv = IvParameterSpec(ivBytes)
+
+        // Encode some data to test with
+        encodeCipher = Cipher.getInstance("AES/CBC/PKCS5Padding")
+        encodeCipher.init(Cipher.ENCRYPT_MODE, secretKeySpec, iv)
+
+        // Prepare decoding decodeCipher for our tests
+        decodeCipher = Cipher.getInstance("AES/CBC/PKCS5Padding")
+        decodeCipher.init(Cipher.DECRYPT_MODE, secretKeySpec, iv)
+    }
+
+    @Test
+    fun write_fromFixedString() {
+        val output = Buffer()
+        val cipheredSink = CipherSink(output, encodeCipher)
+
+        val utf8Sink = Buffer().writeUtf8("okio oh my¿¡")
+        cipheredSink.write(utf8Sink, Long.MAX_VALUE)
+
+        val cipheredBytes = output.readByteArray()
+        assertThat(String(cipheredBytes)).isNotEqualTo("okio oh my¿¡")
+        val decipheredOutput = decodeCipher.doFinal(cipheredBytes)
+        assertThat(String(decipheredOutput)).isEqualTo("okio oh my¿¡")
+    }
+
+    @Test
+    fun write_partialWrite() {
+        val output = Buffer()
+        val cipheredSink = CipherSink(output, encodeCipher)
+
+        val utf8Sink = Buffer().writeUtf8("okio oh my¿¡")
+
+        // Encrypt first 5 bytes
+        cipheredSink.write(utf8Sink, 5)
+        val firstOutput = decodeCipher.doFinal(output.readByteArray())
+        assertThat(String(firstOutput)).isEqualTo("okio ")
+
+        // Encrypt another 5 bytes
+        cipheredSink.write(utf8Sink, 5)
+        val secondOutput = decodeCipher.doFinal(output.readByteArray())
+        assertThat(String(secondOutput)).isEqualTo("oh my")
+
+        // Asking to encrypt another 5 bytes will drain the sink
+        cipheredSink.write(utf8Sink, 5)
+        val finalOutput = decodeCipher.doFinal(output.readByteArray())
+        assertThat(String(finalOutput)).isEqualTo("¿¡")
+    }
+
+    @Test(expected = BadPaddingException::class)
+    fun write_chunkedWrite() {
+        val output = Buffer()
+        val cipheredSink = CipherSink(output, encodeCipher)
+
+        val utf8Sink = Buffer().writeUtf8("okio oh my¿¡")
+
+        // Encrypt first 5 bytes and then another 5 bytes
+        cipheredSink.write(utf8Sink, 5)
+        cipheredSink.write(utf8Sink, 5)
+
+        // Throws BadPaddingException as the output is not a single cipher text but two individual ones
+        decodeCipher.doFinal(output.readByteArray())
+    }
+
+}