Merge pull request #18 from OSGP/feature/FDP-2357-refactor-all-bytebu…

…ffers-to-bytearrays

FDP-2357: replace all ByteBuffers with ByteArrays

kafka-message-signing/src/main/kotlin/com/gxf/utilities/kafka/message/signing/MessageSigner.kt

@@ -15,7 +15,6 @@ import org.springframework.core.io.Resource
 import org.springframework.stereotype.Component
 import java.io.IOException
 import java.io.UncheckedIOException
-import java.nio.ByteBuffer
 import java.nio.charset.StandardCharsets
 import java.security.*
 import java.security.spec.X509EncodedKeySpec
@@ -61,7 +60,7 @@ class MessageSigner(properties: MessageSigningProperties) {
     fun <T> signUsingField(message: SignableMessageWrapper<T>): T {
         if (this.signingEnabled) {
             val signatureBytes = this.signature(message)
-            message.setSignature(ByteBuffer.wrap(signatureBytes))
+            message.setSignature(signatureBytes)
         }
         return message.message
     }
@@ -176,21 +175,17 @@ class MessageSigner(properties: MessageSigningProperties) {
         val messageSignature = message.getSignature() ?: throw IllegalStateException(
             "This message does not contain a signature"
         )
-        messageSignature.mark()
-        val signatureBytes = ByteArray(messageSignature.remaining())
-        messageSignature[signatureBytes]
 
         try {
             message.setSignature(null)
-            if(this.verifySignatureBytes(signatureBytes, this.toByteArray(message))) {
+            if(this.verifySignatureBytes(messageSignature, this.toByteArray(message))) {
                 return message.message
             } else {
                 throw VerificationException("Verification of message signing failed")
             }
         } catch (e: SignatureException) {
             throw UncheckedSecurityException("Unable to verify message signature", e)
         } finally {
-            messageSignature.reset()
             message.setSignature(messageSignature)
         }
     }
@@ -257,10 +252,7 @@ class MessageSigner(properties: MessageSigningProperties) {
 
     private fun toByteArray(message: SignableMessageWrapper<*>): ByteArray {
         try {
-            val byteBuffer = message.toByteBuffer()
-            val bytes = ByteArray(byteBuffer.remaining())
-            byteBuffer[bytes]
-            return bytes
+            return message.toByteArray()
         } catch (e: IOException) {
             throw UncheckedIOException("Unable to determine bytes for message", e)
         }

kafka-message-signing/src/main/kotlin/com/gxf/utilities/kafka/message/wrapper/SignableMessageWrapper.kt

@@ -5,7 +5,6 @@
 package com.gxf.utilities.kafka.message.wrapper
 
 import java.io.IOException
-import java.nio.ByteBuffer
 
 /**
  * Wrapper for signable messages. Because these messages are generated from Avro schemas, they can't be changed.
@@ -14,18 +13,18 @@ import java.nio.ByteBuffer
 abstract class SignableMessageWrapper<T>(val message: T) {
 
     /**
-     * @return ByteBuffer of the whole message
+     * @return ByteArray of the whole message
      */
     @Throws(IOException::class)
-    abstract fun toByteBuffer(): ByteBuffer
+    abstract fun toByteArray(): ByteArray
 
     /**
-     * @return ByteBuffer of the signature in the message
+     * @return ByteArray of the signature in the message
      */
-    abstract fun getSignature(): ByteBuffer?
+    abstract fun getSignature(): ByteArray?
 
     /**
-     * @param signature The signature in ByteBuffer form to be set on the message
+     * @param signature The signature in ByteArray form to be set on the message
      */
-    abstract fun setSignature(signature: ByteBuffer?)
+    abstract fun setSignature(signature: ByteArray?)
 }

kafka-message-signing/src/test/kotlin/com/gxf/utilities/kafka/message/signing/MessageSignerTest.kt

@@ -14,10 +14,9 @@ import org.assertj.core.api.Assertions.assertThat
 import org.assertj.core.api.Assertions.catchThrowable
 import org.junit.jupiter.api.Test
 import org.springframework.core.io.ClassPathResource
-import java.nio.ByteBuffer
 import java.nio.charset.StandardCharsets
 import java.security.SecureRandom
-import java.util.*
+import java.util.Random
 import java.util.function.Consumer
 
 class MessageSignerTest {
@@ -56,14 +55,14 @@ class MessageSignerTest {
     fun signsMessageReplacingSignature() {
         val randomSignature = this.randomSignature()
         val messageWrapper = this.messageWrapper()
-        messageWrapper.setSignature(ByteBuffer.wrap(randomSignature))
+        messageWrapper.setSignature(randomSignature)
 
-        val actualSignatureBefore = this.bytes(messageWrapper.getSignature())
+        val actualSignatureBefore = messageWrapper.getSignature()
         assertThat(actualSignatureBefore).isNotNull().isEqualTo(randomSignature)
 
         messageSigner.signUsingField(messageWrapper)
 
-        val actualSignatureAfter = this.bytes(messageWrapper.getSignature())
+        val actualSignatureAfter = messageWrapper.getSignature()
         assertThat(actualSignatureAfter).isNotNull().isNotEqualTo(randomSignature)
     }
 
@@ -165,17 +164,11 @@ class MessageSignerTest {
     fun verifiesMessagesPreservingTheSignatureAndItsProperties() {
         val message = this.properlySignedMessage()
         val originalSignature = message.getSignature()
-        val originalPosition = originalSignature!!.position()
-        val originalLimit = originalSignature.limit()
-        val originalRemaining = originalSignature.remaining()
 
         messageSigner.verifyUsingField(message)
 
         val verifiedSignature = message.getSignature()
         assertThat(verifiedSignature).isEqualTo(originalSignature)
-        assertThat(verifiedSignature!!.position()).isEqualTo(originalPosition)
-        assertThat(verifiedSignature.limit()).isEqualTo(originalLimit)
-        assertThat(verifiedSignature.remaining()).isEqualTo(originalRemaining)
     }
 
     @Test
@@ -193,7 +186,7 @@ class MessageSignerTest {
 
     private fun messageWrapper(signature: ByteArray): TestableWrapper {
         val testableWrapper = TestableWrapper()
-        testableWrapper.setSignature(ByteBuffer.wrap(signature))
+        testableWrapper.setSignature(signature)
         return testableWrapper
     }
 
@@ -228,15 +221,6 @@ class MessageSignerTest {
         return signature
     }
 
-    private fun bytes(byteBuffer: ByteBuffer?): ByteArray? {
-        if (byteBuffer == null) {
-            return null
-        }
-        val bytes = ByteArray(byteBuffer.remaining())
-        byteBuffer[bytes]
-        return bytes
-    }
-
     private fun producerRecord(): ProducerRecord<String, Message> {
         return ProducerRecord("topic", this.message())
     }
@@ -266,17 +250,17 @@ class MessageSignerTest {
     }
 
     private class TestableWrapper : SignableMessageWrapper<String>("Some test message") {
-        private var signature: ByteBuffer? = null
+        private var signature: ByteArray? = null
 
-        override fun toByteBuffer(): ByteBuffer {
-            return ByteBuffer.wrap(message.toByteArray(StandardCharsets.UTF_8))
+        override fun toByteArray(): ByteArray {
+            return message.toByteArray(StandardCharsets.UTF_8)
         }
 
-        override fun getSignature(): ByteBuffer? {
+        override fun getSignature(): ByteArray? {
             return this.signature
         }
 
-        override fun setSignature(signature: ByteBuffer?) {
+        override fun setSignature(signature: ByteArray?) {
             this.signature = signature
         }
     }