Use Data.bytes property in place of NSData.arrayOfBytes()

README.md

@@ -161,8 +161,8 @@ CryptoSwift use array of bytes aka `Array<UInt8>` as base type for all operation
 For you convenience CryptoSwift provide two function to easily convert array of bytes to NSData and other way around:
 
 ```swift
-let data: NSData = NSData(bytes: [0x01, 0x02, 0x03])
-let bytes:Array<UInt8> = data.arrayOfBytes()
+let data = Data(bytes: [0x01, 0x02, 0x03])
+let bytes = data.bytes
 ```
 
 Make bytes out of `String`:

Sources/CryptoSwift/Foundation/AES+Foundation.swift

@@ -10,7 +10,7 @@ import Foundation
 
 extension AES {
     convenience public init(key:String, iv:String, blockMode:BlockMode = .CBC, padding: Padding = PKCS7()) throws {
-        guard let kkey = key.bridge().data(using: String.Encoding.utf8.rawValue, allowLossyConversion: false)?.arrayOfBytes(), let iiv = iv.bridge().data(using: String.Encoding.utf8.rawValue, allowLossyConversion: false)?.arrayOfBytes() else {
+        guard let kkey = key.bridge().data(using: String.Encoding.utf8.rawValue, allowLossyConversion: false)?.bytes, let iiv = iv.bridge().data(using: String.Encoding.utf8.rawValue, allowLossyConversion: false)?.bytes else {
             throw Error.invalidKeyOrInitializationVector
         }
         

Sources/CryptoSwift/Foundation/CSArrayType+Foundation.swift

@@ -24,6 +24,6 @@ public extension CSArrayType where Iterator.Element == UInt8 {
             return
         }
 
-        self.append(contentsOf: decodedData.arrayOfBytes())
+        self.append(contentsOf: decodedData.bytes)
     }
 }

Sources/CryptoSwift/Foundation/ChaCha20+Foundation.swift

@@ -10,7 +10,7 @@ import Foundation
 
 extension ChaCha20 {
     convenience public init?(key:String, iv:String) {
-        guard let kkey = key.bridge().data(using: String.Encoding.utf8.rawValue, allowLossyConversion: false)?.arrayOfBytes(), let iiv = iv.bridge().data(using: String.Encoding.utf8.rawValue, allowLossyConversion: false)?.arrayOfBytes() else {
+        guard let kkey = key.bridge().data(using: String.Encoding.utf8.rawValue, allowLossyConversion: false)?.bytes, let iiv = iv.bridge().data(using: String.Encoding.utf8.rawValue, allowLossyConversion: false)?.bytes else {
             return nil
         }
         self.init(key: kkey, iv: iiv)

Sources/CryptoSwift/Foundation/Data+Extension.swift

@@ -22,7 +22,7 @@ extension Data {
     /// Two octet checksum as defined in RFC-4880. Sum of all octets, mod 65536
     public func checksum() -> UInt16 {
         var s:UInt32 = 0
-        var bytesArray = self.arrayOfBytes()
+        var bytesArray = self.bytes
         for i in 0..<bytesArray.count {
             s = s + UInt32(bytesArray[i])
         }
@@ -31,72 +31,69 @@ extension Data {
     }
     
     public func md5() -> Data {
-        let result = Hash.md5(self.arrayOfBytes()).calculate()
+        let result = Hash.md5(self.bytes).calculate()
         return Data(bytes: result)
     }
 
     public func sha1() -> Data? {
-        let result = Hash.sha1(self.arrayOfBytes()).calculate()
+        let result = Hash.sha1(self.bytes).calculate()
         return Data(bytes: result)
     }
 
     public func sha224() -> Data? {
-        let result = Hash.sha224(self.arrayOfBytes()).calculate()
+        let result = Hash.sha224(self.bytes).calculate()
         return Data(bytes: result)
     }
 
     public func sha256() -> Data? {
-        let result = Hash.sha256(self.arrayOfBytes()).calculate()
+        let result = Hash.sha256(self.bytes).calculate()
         return Data(bytes: result)
     }
 
     public func sha384() -> Data? {
-        let result = Hash.sha384(self.arrayOfBytes()).calculate()
+        let result = Hash.sha384(self.bytes).calculate()
         return Data(bytes: result)
     }
 
     public func sha512() -> Data? {
-        let result = Hash.sha512(self.arrayOfBytes()).calculate()
+        let result = Hash.sha512(self.bytes).calculate()
         return Data(bytes: result)
     }
 
     public func crc32(seed: UInt32? = nil, reflect : Bool = true) -> Data? {
-        let result = Hash.crc32(self.arrayOfBytes(), seed: seed, reflect: reflect).calculate()
+        let result = Hash.crc32(self.bytes, seed: seed, reflect: reflect).calculate()
         return Data(bytes: result)
     }
 
     public func crc16(seed: UInt16? = nil) -> Data? {
-        let result = Hash.crc16(self.arrayOfBytes(), seed: seed).calculate()
+        let result = Hash.crc16(self.bytes, seed: seed).calculate()
         return Data(bytes: result)
     }
 
     public func encrypt(cipher: Cipher) throws -> Data {
-        let encrypted = try cipher.encrypt(self.arrayOfBytes())
+        let encrypted = try cipher.encrypt(self.bytes)
         return Data(bytes: encrypted)
     }
 
     public func decrypt(cipher: Cipher) throws -> Data {
-        let decrypted = try cipher.decrypt(self.arrayOfBytes())
+        let decrypted = try cipher.decrypt(self.bytes)
         return Data(bytes: decrypted)
     }
     
     public func authenticate(with authenticator: Authenticator) throws -> Data {
-        let result = try authenticator.authenticate(self.arrayOfBytes())
+        let result = try authenticator.authenticate(self.bytes)
         return Data(bytes: result)
     }
 }
 
 extension Data {
-    
-    public func toHexString() -> String {
-        return self.arrayOfBytes().toHexString()
+
+    public var bytes: Array<UInt8> {
+        return Array(self)
     }
     
-    public func arrayOfBytes() -> Array<UInt8> {
-        let count = self.count / sizeof(UInt8)
-        var bytesArray = Array<UInt8>(repeating: 0, count: count)
-        (self as NSData).getBytes(&bytesArray, length:count * sizeof(UInt8))
-        return bytesArray
+    public func toHexString() -> String {
+        return self.bytes.toHexString()
     }
 }
 

Sources/CryptoSwift/Foundation/Rabbit+Foundation.swift

@@ -10,7 +10,7 @@ import Foundation
 
 extension Rabbit {
     convenience public init?(key: String) {
-        guard let kkey = key.bridge().data(using: String.Encoding.utf8.rawValue, allowLossyConversion: false)?.arrayOfBytes() else {
+        guard let kkey = key.bridge().data(using: String.Encoding.utf8.rawValue, allowLossyConversion: false)?.bytes else {
             return nil
         }
         self.init(key: kkey)
@@ -18,8 +18,8 @@ extension Rabbit {
     }
     
     convenience public init?(key: String, iv: String) {
-        guard let kkey = key.bridge().data(using: String.Encoding.utf8.rawValue, allowLossyConversion: false)?.arrayOfBytes(),
-            let iiv = iv.bridge().data(using: String.Encoding.utf8.rawValue, allowLossyConversion: false)?.arrayOfBytes()
+        guard let kkey = key.bridge().data(using: String.Encoding.utf8.rawValue, allowLossyConversion: false)?.bytes,
+            let iiv = iv.bridge().data(using: String.Encoding.utf8.rawValue, allowLossyConversion: false)?.bytes
             else {
                 return nil
         }

Sources/CryptoSwift/Foundation/String+FoundationExtension.swift

@@ -30,7 +30,7 @@ extension String {
             throw CipherError.decrypt
         }
 
-        return try decodedData.decrypt(cipher: cipher).arrayOfBytes()
+        return try decodedData.decrypt(cipher: cipher).bytes
     }
 
 }