fix: util and fixes for sha 256 checksums (#46)

.swiftlint.yml

@@ -4,6 +4,7 @@
 disabled_rules:
     - unused_closure_parameter
     - closure_parameter_position
+    - superfluous_disable_command
 excluded:
     - Test
 
@@ -34,4 +35,7 @@ return_arrow_whitespace: error
 statement_position:
   severity: error
 todo: warning
-trailing_semicolon: error
+trailing_semicolon: error
+file_length:
+  warning: 500
+  error: 1200

Source/AwsCommonRuntimeKit/Utilities.swift

@@ -41,18 +41,11 @@ extension String {
         let byteCursor = aws_byte_cursor_from_buf(output)
         return byteCursor.toData().base64EncodedString()
     }
+}
 
-    public func base64EncodedSha256(allocator: Allocator = defaultAllocator, truncate: Int = 0) -> String {
-        let input: UnsafePointer<aws_byte_cursor> = fromPointer(ptr: self.awsByteCursor)
-        let emptyBuffer: UInt8 = 0
-        let bufferPtr: UnsafeMutablePointer<UInt8> = fromPointer(ptr: emptyBuffer)
-        let buffer = aws_byte_buf(len: 0, buffer: bufferPtr, capacity: Int(AWS_SHA256_LEN), allocator: allocator.rawValue)
-        let output: UnsafeMutablePointer<aws_byte_buf> = fromPointer(ptr: buffer)
-
-        aws_sha256_compute(allocator.rawValue, input, output, truncate)
-
-        let byteCursor = aws_byte_cursor_from_buf(output)
-        return byteCursor.toData().base64EncodedString()
+extension aws_byte_buf {
+    func toByteBuffer() -> ByteBuffer {
+        return ByteBuffer(ptr: self.buffer, len: self.len, capacity: self.capacity)
     }
 }
 

Source/AwsCommonRuntimeKit/crt/ByteBuffer.swift

@@ -8,6 +8,8 @@ import class Foundation.FileHandle
 import class Foundation.OutputStream
 import struct Foundation.URL
 import AwsCIo
+import AwsCCommon
+import AwsCCal
 #if os(Linux)
      import Glibc
  #else
@@ -19,11 +21,24 @@ public class ByteBuffer: Codable {
 
     public init(size: Int) {
         array.reserveCapacity(size)
+        self.capacity = size
+    }
+
+    public init(bytes: [UInt8]) {
+        self.array = bytes
+        self.capacity = bytes.count
+    }
+
+    public init(ptr: UnsafeMutablePointer<UInt8>, len: Int, capacity: Int) {
+        let buffer = UnsafeBufferPointer(start: ptr, count: len)
+        self.array = Array(buffer)
+        self.capacity = capacity
     }
 
     public func allocate(_ size: Int) {
         array = [UInt8]()
         array.reserveCapacity(size)
+        self.capacity += size
         currentIndex = 0
     }
 
@@ -49,6 +64,11 @@ public class ByteBuffer: Codable {
         return self
     }
 
+    public func put(_ value: [UInt8]) -> ByteBuffer {
+        array.append(contentsOf: value)
+        return self
+    }
+
     public func put(_ value: ByteBuffer, offset: UInt = 0, maxBytes: UInt? = nil) {
         var end: UInt = UInt(value.length)
         if let maxBytes = maxBytes {
@@ -209,6 +229,7 @@ public class ByteBuffer: Codable {
 
     private var array = [UInt8]()
     private var currentIndex: Int = 0
+    var capacity: Int = 0
 
     private var currentEndianness: Endianness = .big
     private var hostEndianness: Endianness {
@@ -225,6 +246,29 @@ public class ByteBuffer: Codable {
         let container = try decoder.singleValueContainer()
         array = try container.decode([UInt8].self)
     }
+
+    public func readIntoBuffer(buffer: inout ByteBuffer) -> Int {
+        guard array.count > 0 else {
+            return 0
+        }
+
+        guard currentIndex < array.count else {
+            return 0
+        }
+        let bufferCapacity = buffer.capacity - buffer.array.count
+        var arrayEnd = array.count > bufferCapacity ? bufferCapacity + currentIndex: array.count
+        if arrayEnd > array.count {
+            arrayEnd = array.count
+        }
+        let dataArray = Array(array[currentIndex..<(arrayEnd)])
+        if dataArray.count > 0 {
+            _ = buffer.put(dataArray)
+            self.currentIndex = arrayEnd
+            return dataArray.count
+        } else {
+            return 0
+        }
+    }
 }
 
 extension ByteBuffer: AwsStream {
@@ -336,3 +380,30 @@ extension ByteBuffer {
         return InputStream(data: self.toData())
     }
 }
+
+public extension ByteBuffer {
+    func sha256(allocator: Allocator = defaultAllocator, truncate: Int = 0) -> ByteBuffer {
+        var byteCursor = aws_byte_cursor_from_array(self.array, self.array.count)
+
+        var bytes = [UInt8](repeating: 0, count: Int(AWS_SHA256_LEN))
+        let result: ByteBuffer = bytes.withUnsafeMutableBufferPointer { pointer in
+            var buffer = aws_byte_buf(len: 0, buffer: pointer.baseAddress, capacity: Int(AWS_SHA256_LEN), allocator: allocator.rawValue)
+            aws_sha256_compute(allocator.rawValue, &byteCursor, &buffer, truncate)
+            return buffer.toByteBuffer()
+        }
+        return result
+    }
+
+    func base64EncodedSha256(allocator: Allocator = defaultAllocator, truncate: Int = 0) -> String {
+        return sha256(allocator: allocator, truncate: truncate).toData().base64EncodedString()
+    }
+
+    func encodeToHexString() -> String {
+        var hexString = ""
+        for byte in array {
+            hexString += String(format: "%02x", UInt8(byte))
+        }
+
+        return hexString
+    }
+}

Test/AwsCommonRuntimeKitTests/crt/UtilityTests.swift

@@ -24,21 +24,20 @@ class UtilityTests: XCTestCase {
     }
 
     func testSha256() throws {
-        let hello = "Hello"
-        let sha256 = hello.base64EncodedSha256()
+        let hello = "Hello".data(using: .utf8)!
+        let sha256 = ByteBuffer(data: hello).base64EncodedSha256()
         XCTAssertEqual(sha256, "GF+NsyJx/iX1Yab8k4suJkMG7DBO2lGAB9F2SCY4GWk=")
     }
 
     func testSha256_EmptyString() throws {
-        let empty = ""
-        let sha256 = empty.base64EncodedSha256()
+        let empty = "".data(using: .utf8)!
+        let sha256 = ByteBuffer(data: empty).base64EncodedSha256()
         XCTAssertEqual(sha256, "47DEQpj8HBSa+/TImW+5JCeuQeRkm5NMpJWZG3hSuFU=")
     }
 
     func testSha256_payload() throws {
-        let payload = "{\"foo\":\"base64 encoded sha256 checksum\"}"
-
-        let sha256 = payload.base64EncodedSha256()
+        let payload = "{\"foo\":\"base64 encoded sha256 checksum\"}".data(using: .utf8)!
+        let sha256 = ByteBuffer(data: payload).base64EncodedSha256()
 
         XCTAssertEqual(sha256, "lBSnDP4sj/yN8eIVOJlv+vC56hw+7JtN0132GiMQXRg=")
     }