Rename the `bytes` computed property in the extension on Data

to `byteArray` to avoid clashing with new `bytes: RawSpan` property
added in SE-0456 for Swift 6.2

Sources/CryptoSwift/ASN1/ASN1Encoder.swift

@@ -28,15 +28,15 @@ extension ASN1 {
     public static func encode(_ node: ASN1.Node) -> [UInt8] {
       switch node {
         case .integer(let integer):
-          return IDENTIFIERS.INTERGER.bytes + self.asn1LengthPrefixed(integer.bytes)
+          return IDENTIFIERS.INTERGER.bytes + self.asn1LengthPrefixed(integer.byteArray)
         case .bitString(let bits):
-          return IDENTIFIERS.BITSTRING.bytes + self.asn1LengthPrefixed([0x00] + bits.bytes)
+          return IDENTIFIERS.BITSTRING.bytes + self.asn1LengthPrefixed([0x00] + bits.byteArray)
         case .octetString(let octet):
-          return IDENTIFIERS.OCTETSTRING.bytes + self.asn1LengthPrefixed(octet.bytes)
+          return IDENTIFIERS.OCTETSTRING.bytes + self.asn1LengthPrefixed(octet.byteArray)
         case .null:
           return IDENTIFIERS.NULL.bytes
         case .objectIdentifier(let oid):
-          return IDENTIFIERS.OBJECTID.bytes + self.asn1LengthPrefixed(oid.bytes)
+          return IDENTIFIERS.OBJECTID.bytes + self.asn1LengthPrefixed(oid.byteArray)
         case .sequence(let nodes):
           return IDENTIFIERS.SEQUENCE.bytes + self.asn1LengthPrefixed( nodes.reduce(into: Array<UInt8>(), { partialResult, node in
             partialResult += encode(node)

Sources/CryptoSwift/Foundation/Array+Foundation.swift

@@ -27,6 +27,6 @@ public extension Array where Element == UInt8 {
       return
     }
 
-    append(contentsOf: decodedData.bytes)
+    append(contentsOf: decodedData.byteArray)
   }
 }

Sources/CryptoSwift/Foundation/Data+Extension.swift

@@ -25,55 +25,55 @@ extension Data {
   }
 
   public func md5() -> Data {
-    Data( Digest.md5(bytes))
+    Data( Digest.md5(byteArray))
   }
 
   public func sha1() -> Data {
-    Data( Digest.sha1(bytes))
+    Data( Digest.sha1(byteArray))
   }
 
   public func sha224() -> Data {
-    Data( Digest.sha224(bytes))
+    Data( Digest.sha224(byteArray))
   }
 
   public func sha256() -> Data {
-    Data( Digest.sha256(bytes))
+    Data( Digest.sha256(byteArray))
   }
 
   public func sha384() -> Data {
-    Data( Digest.sha384(bytes))
+    Data( Digest.sha384(byteArray))
   }
 
   public func sha512() -> Data {
-    Data( Digest.sha512(bytes))
+    Data( Digest.sha512(byteArray))
   }
 
   public func sha3(_ variant: SHA3.Variant) -> Data {
-    Data( Digest.sha3(bytes, variant: variant))
+    Data( Digest.sha3(byteArray, variant: variant))
   }
 
   public func crc32(seed: UInt32? = nil, reflect: Bool = true) -> Data {
-    Data( Checksum.crc32(bytes, seed: seed, reflect: reflect).bytes())
+    Data( Checksum.crc32(byteArray, seed: seed, reflect: reflect).bytes())
   }
 
   public func crc32c(seed: UInt32? = nil, reflect: Bool = true) -> Data {
-    Data( Checksum.crc32c(bytes, seed: seed, reflect: reflect).bytes())
+    Data( Checksum.crc32c(byteArray, seed: seed, reflect: reflect).bytes())
   }
 
   public func crc16(seed: UInt16? = nil) -> Data {
-    Data( Checksum.crc16(bytes, seed: seed).bytes())
+    Data( Checksum.crc16(byteArray, seed: seed).bytes())
   }
 
   public func encrypt(cipher: Cipher) throws -> Data {
-    Data( try cipher.encrypt(bytes.slice))
+    Data( try cipher.encrypt(byteArray.slice))
   }
 
   public func decrypt(cipher: Cipher) throws -> Data {
-    Data( try cipher.decrypt(bytes.slice))
+    Data( try cipher.decrypt(byteArray.slice))
   }
 
   public func authenticate(with authenticator: Authenticator) throws -> Data {
-    Data( try authenticator.authenticate(bytes))
+    Data( try authenticator.authenticate(byteArray))
   }
 }
 
@@ -82,11 +82,11 @@ extension Data {
     self.init(Array<UInt8>(hex: hex))
   }
 
-  public var bytes: Array<UInt8> {
+  public var byteArray: Array<UInt8> {
     Array(self)
   }
 
   public func toHexString() -> String {
-    self.bytes.toHexString()
+    self.byteArray.toHexString()
   }
 }

Sources/CryptoSwift/Foundation/String+FoundationExtension.swift

@@ -36,6 +36,6 @@ extension String {
       throw CipherError.decrypt
     }
 
-    return try decodedData.decrypt(cipher: cipher).bytes
+    return try decodedData.decrypt(cipher: cipher).byteArray
   }
 }

Sources/CryptoSwift/RSA/RSA+Cipher.swift

@@ -36,7 +36,7 @@ extension RSA: Cipher {
   @inlinable
   internal func encryptPreparedBytes(_ bytes: Array<UInt8>) throws -> Array<UInt8> {
     // Calculate encrypted data
-    return BigUInteger(Data(bytes)).power(self.e, modulus: self.n).serialize().bytes
+    return BigUInteger(Data(bytes)).power(self.e, modulus: self.n).serialize().byteArray
   }
 
   @inlinable
@@ -59,7 +59,7 @@ extension RSA: Cipher {
     guard let d = d else { throw RSA.Error.noPrivateKey }
 
     // Calculate decrypted data
-    return BigUInteger(Data(bytes)).power(d, modulus: self.n).serialize().bytes
+    return BigUInteger(Data(bytes)).power(d, modulus: self.n).serialize().byteArray
   }
 }
 

Sources/CryptoSwift/RSA/RSA+Signature.swift

@@ -35,7 +35,7 @@ extension RSA: Signature {
     let hashedAndEncoded = try RSA.hashedAndEncoded(bytes, variant: variant, keySizeInBytes: self.keySizeBytes)
 
     /// Calculate the Signature
-    let signedData = BigUInteger(Data(hashedAndEncoded)).power(d, modulus: self.n).serialize().bytes
+    let signedData = BigUInteger(Data(hashedAndEncoded)).power(d, modulus: self.n).serialize().byteArray
 
     return variant.formatSignedBytes(signedData, blockSize: self.keySizeBytes)
   }
@@ -61,7 +61,7 @@ extension RSA: Signature {
     if expectedData.count == self.keySizeBytes && expectedData.prefix(1) == [0x00] { expectedData = Array(expectedData.dropFirst()) }
 
     /// Step 2: 'Decrypt' the signature
-    let signatureResult = BigUInteger(Data(signature)).power(self.e, modulus: self.n).serialize().bytes
+    let signatureResult = BigUInteger(Data(signature)).power(self.e, modulus: self.n).serialize().byteArray
 
     /// Step 3: Compare the 'decrypted' signature with the prepared / encoded expected message....
     guard signatureResult == expectedData else { return false }

Sources/CryptoSwift/RSA/RSA.swift

@@ -259,8 +259,8 @@ extension RSA {
   /// // rsaKey.verify(...)
   /// ```
   public convenience init(rawRepresentation raw: Data) throws {
-    do { try self.init(privateDER: raw.bytes) } catch {
-      try self.init(publicDER: raw.bytes)
+    do { try self.init(privateDER: raw.byteArray) } catch {
+      try self.init(publicDER: raw.byteArray)
     }
   }
 }
@@ -286,8 +286,8 @@ extension RSA {
     let exp = self.e.serialize()
     let pubKeyAsnNode: ASN1.Node =
       .sequence(nodes: [
-        .integer(data: DER.i2ospData(x: mod.bytes, size: self.keySizeBytes)),
-        .integer(data: DER.i2ospData(x: exp.bytes, size: exp.bytes.count))
+        .integer(data: DER.i2ospData(x: mod.byteArray, size: self.keySizeBytes)),
+        .integer(data: DER.i2ospData(x: exp.byteArray, size: exp.byteArray.count))
       ])
     return ASN1.Encoder.encode(pubKeyAsnNode)
   }
@@ -326,14 +326,14 @@ extension RSA {
     let privateKeyAsnNode: ASN1.Node =
       .sequence(nodes: [
         .integer(data: Data(hex: "0x00")),
-        .integer(data: DER.i2ospData(x: mod.bytes, size: self.keySizeBytes)),
-        .integer(data: DER.i2ospData(x: self.e.serialize().bytes, size: 3)),
-        .integer(data: DER.i2ospData(x: d.serialize().bytes, size: self.keySizeBytes)),
-        .integer(data: DER.i2ospData(x: primes.p.serialize().bytes, size: paramWidth)),
-        .integer(data: DER.i2ospData(x: primes.q.serialize().bytes, size: paramWidth)),
-        .integer(data: DER.i2ospData(x: (d % (primes.p - 1)).serialize().bytes, size: paramWidth)),
-        .integer(data: DER.i2ospData(x: (d % (primes.q - 1)).serialize().bytes, size: paramWidth)),
-        .integer(data: DER.i2ospData(x: coefficient.serialize().bytes, size: paramWidth))
+        .integer(data: DER.i2ospData(x: mod.byteArray, size: self.keySizeBytes)),
+        .integer(data: DER.i2ospData(x: self.e.serialize().byteArray, size: 3)),
+        .integer(data: DER.i2ospData(x: d.serialize().byteArray, size: self.keySizeBytes)),
+        .integer(data: DER.i2ospData(x: primes.p.serialize().byteArray, size: paramWidth)),
+        .integer(data: DER.i2ospData(x: primes.q.serialize().byteArray, size: paramWidth)),
+        .integer(data: DER.i2ospData(x: (d % (primes.p - 1)).serialize().byteArray, size: paramWidth)),
+        .integer(data: DER.i2ospData(x: (d % (primes.q - 1)).serialize().byteArray, size: paramWidth)),
+        .integer(data: DER.i2ospData(x: coefficient.serialize().byteArray, size: paramWidth))
       ])
 
     // Encode and return the data

Sources/CryptoSwift/String+Extension.swift

@@ -20,7 +20,7 @@ extension String {
 
   @inlinable
   public var bytes: Array<UInt8> {
-    data(using: String.Encoding.utf8, allowLossyConversion: true)?.bytes ?? Array(utf8)
+    data(using: String.Encoding.utf8, allowLossyConversion: true)?.byteArray ?? Array(utf8)
   }
 
   @inlinable

Sources/CryptoSwift/UInt128.swift

@@ -58,7 +58,7 @@ struct UInt128: Equatable, ExpressibleByIntegerLiteral {
     var result = Data()
     result.append(ar)
     result.append(br)
-    return result.bytes
+    return result.byteArray
   }
 
   static func ^ (n1: UInt128, n2: UInt128) -> UInt128 {

Tests/CryptoSwiftTests/Access.swift

@@ -142,7 +142,7 @@ class Access: XCTestCase {
     _ = data.crc32()
     _ = data.crc32c()
 
-    _ = data.bytes
+    _ = data.byteArray
     _ = data.toHexString()
 
     do {

Tests/CryptoSwiftTests/DigestTests.swift

@@ -242,31 +242,31 @@ final class DigestTests: XCTestCase {
       let input = Data(bytes: buf, count: testSize)
 
       // SHA1
-      let sha1Once = SHA1().calculate(for: input.bytes)
+      let sha1Once = SHA1().calculate(for: input.byteArray)
 
       var sha1Partial = SHA1()
       for batch in input.batched(by: 17) {
-        _ = try sha1Partial.update(withBytes: batch.bytes)
+        _ = try sha1Partial.update(withBytes: batch.byteArray)
       }
       let sha1Result = try sha1Partial.finish()
       XCTAssertEqual(sha1Once, sha1Result)
 
       // SHA2
-      let sha2Once = SHA2(variant: .sha224).calculate(for: input.bytes)
+      let sha2Once = SHA2(variant: .sha224).calculate(for: input.byteArray)
 
       var sha2Partial = SHA2(variant: .sha224)
       for batch in input.batched(by: 17) {
-        _ = try sha2Partial.update(withBytes: batch.bytes)
+        _ = try sha2Partial.update(withBytes: batch.byteArray)
       }
       let sha2Result = try sha2Partial.finish()
       XCTAssertEqual(sha2Once, sha2Result)
 
       // SHA3
-      let sha3Once = SHA3(variant: .sha224).calculate(for: input.bytes)
+      let sha3Once = SHA3(variant: .sha224).calculate(for: input.byteArray)
 
       var sha3Partial = SHA3(variant: .sha224)
       for batch in input.batched(by: 17) {
-        _ = try sha3Partial.update(withBytes: batch.bytes)
+        _ = try sha3Partial.update(withBytes: batch.byteArray)
       }
       let sha3Result = try sha3Partial.finish()
       XCTAssertEqual(sha3Once, sha3Result)

Tests/CryptoSwiftTests/RSATests.swift

@@ -211,10 +211,10 @@ final class RSATests: XCTestCase {
     let rsa = try RSA(rawRepresentation: privateDERData)
 
     let expectedMessage = "RSA Keys"
-    let messageToDecrypt = Data(base64Encoded: fixture.messages[expectedMessage]!.encryptedMessage["algid:encrypt:RSA:PKCS1"]!)!.bytes
+    let messageToDecrypt = Data(base64Encoded: fixture.messages[expectedMessage]!.encryptedMessage["algid:encrypt:RSA:PKCS1"]!)!.byteArray
 
     // Decrypt the data
-    let decrypted = BigUInteger(Data(messageToDecrypt)).power(rsa.d!, modulus: rsa.n).serialize().bytes
+    let decrypted = BigUInteger(Data(messageToDecrypt)).power(rsa.d!, modulus: rsa.n).serialize().byteArray
 
     let unpadded = Padding.eme_pkcs1v15.remove(from: [0x00] + decrypted, blockSize: rsa.keySize)
 
@@ -231,7 +231,7 @@ final class RSATests: XCTestCase {
       let rsa = try RSA(keySize: 1024)
 
       for _ in 0..<5 {
-        let message = BigUInteger.randomInteger(withMaximumWidth: 256).serialize().bytes
+        let message = BigUInteger.randomInteger(withMaximumWidth: 256).serialize().byteArray
 
         let decrypted = try rsa.decrypt(rsa.encrypt(message, variant: .pksc1v15), variant: .pksc1v15)
         XCTAssertEqual(decrypted, message, "encrypt+decrypt failed")
@@ -251,7 +251,7 @@ final class RSATests: XCTestCase {
       let rsa = try RSA(keySize: 1024)
 
       for _ in 0..<5 {
-        let message = BigUInteger.randomInteger(withMaximumWidth: 256).serialize().bytes
+        let message = BigUInteger.randomInteger(withMaximumWidth: 256).serialize().byteArray
 
         let signature = try rsa.sign(message, variant: .message_pkcs1v15_SHA256)
         XCTAssertTrue(try rsa.verify(signature: signature, for: message, variant: .message_pkcs1v15_SHA256), "Failed to Verify Signature for `\(message)`")
@@ -308,7 +308,7 @@ final class RSATests: XCTestCase {
     let padded = EMSAPKCS1v15Padding().add(to: t, blockSize: rsa.keySizeBytes)
 
     // Sign the data
-    let signedData = BigUInteger(Data(padded)).power(rsa.d!, modulus: rsa.n).serialize().bytes
+    let signedData = BigUInteger(Data(padded)).power(rsa.d!, modulus: rsa.n).serialize().byteArray
 
     // Ensure the signed data matches that of our test fixture
     XCTAssertEqual(signedData.toBase64(), fixture.messages[message]!.signedMessage["algid:sign:RSA:message-PKCS1v15:SHA256"], "Failed to correctly sign the data")
@@ -331,7 +331,7 @@ final class RSATests: XCTestCase {
     // Import RSA Key
     let rsa = try RSA(rawRepresentation: privateDERData)
 
-    let message = Data("This is a long message that if not hashed, will be tool large to safely sign / encrypt, therefore it should throw an error instead of resulting in a signature".utf8).bytes
+    let message = Data("This is a long message that if not hashed, will be tool large to safely sign / encrypt, therefore it should throw an error instead of resulting in a signature".utf8).byteArray
 
     // The unhashed message is too long to sign, we expect an error to be thrown...
     XCTAssertThrowsError(try rsa.sign(message, variant: .digest_pkcs1v15_SHA1))
@@ -423,10 +423,10 @@ final class RSATests: XCTestCase {
               } else {
                 // The Raw encryption method is deterministic so we can test that encrypting the message matches the data in the test fixture...
                 let encrypted = try rsa.encrypt(message.key.bytes, variant: variant)
-                XCTAssertEqual(encrypted.toHexString(), Data(base64Encoded: message.value.encryptedMessage["algid:encrypt:RSA:raw"]!)!.bytes.toHexString(), "Encryption<\(test.key)>::Failed to encrypt the message `\(message.key)`")
+                XCTAssertEqual(encrypted.toHexString(), Data(base64Encoded: message.value.encryptedMessage["algid:encrypt:RSA:raw"]!)!.byteArray.toHexString(), "Encryption<\(test.key)>::Failed to encrypt the message `\(message.key)`")
 
                 // Decryption requires access to the Private Key, therefore attempting to decrypt with only a public key should throw an error
-                XCTAssertThrowsError(try rsa.decrypt(Data(base64Encoded: message.value.encryptedMessage["algid:encrypt:RSA:raw"]!)!.bytes), "Encryption<\(test.key)>::Did not throw error while decrypting `\(message.key)`")
+                XCTAssertThrowsError(try rsa.decrypt(Data(base64Encoded: message.value.encryptedMessage["algid:encrypt:RSA:raw"]!)!.byteArray), "Encryption<\(test.key)>::Did not throw error while decrypting `\(message.key)`")
               }
             } else {
               // Sometimes the message is too long to be safely encrypted by our key. When this happens we should encounter an error and our test value should be empty.
@@ -455,19 +455,19 @@ final class RSATests: XCTestCase {
 
             // Sometimes the message is too long to be safely signed by our key. When this happens we should encounter an error and our test value should be empty.
             if test.value == "" {
-              XCTAssertThrowsError(try rsa.verify(signature: Data(base64Encoded: test.value)!.bytes, for: message.key.bytes, variant: variant), "Signature<\(test.key)>::Did not throw error")
+              XCTAssertThrowsError(try rsa.verify(signature: Data(base64Encoded: test.value)!.byteArray, for: message.key.bytes, variant: variant), "Signature<\(test.key)>::Did not throw error")
             } else {
               // Ensure the signature is valid for the test fixtures rawMessage
-              XCTAssertTrue(try rsa.verify(signature: Data(base64Encoded: test.value)!.bytes, for: message.key.bytes, variant: variant), "Signature<\(test.key)>::Verification Failed")
+              XCTAssertTrue(try rsa.verify(signature: Data(base64Encoded: test.value)!.byteArray, for: message.key.bytes, variant: variant), "Signature<\(test.key)>::Verification Failed")
               // Ensure a modified message results in a false / invalid signature verification
-              XCTAssertFalse(try rsa.verify(signature: Data(base64Encoded: test.value)!.bytes, for: message.key.bytes + [0x00], variant: variant), "Signature<\(test.key)>::Verified a signature for an incorrect message `\(message.key)`")
+              XCTAssertFalse(try rsa.verify(signature: Data(base64Encoded: test.value)!.byteArray, for: message.key.bytes + [0x00], variant: variant), "Signature<\(test.key)>::Verified a signature for an incorrect message `\(message.key)`")
               if !message.key.bytes.isEmpty {
-                XCTAssertFalse(try rsa.verify(signature: Data(base64Encoded: test.value)!.bytes, for: message.key.bytes.dropLast(), variant: variant), "Signature<\(test.key)>::Verified a signature for an incorrect message `\(message.key)`")
+                XCTAssertFalse(try rsa.verify(signature: Data(base64Encoded: test.value)!.byteArray, for: message.key.bytes.dropLast(), variant: variant), "Signature<\(test.key)>::Verified a signature for an incorrect message `\(message.key)`")
               }
               // Ensure a modified signature results in a false / invalid signature verification (we replace the last element with a 1 in case the signature is all 0's)
-              XCTAssertFalse(try rsa.verify(signature: Data(base64Encoded: test.value)!.bytes.shuffled().dropLast() + [0x01], for: message.key.bytes, variant: variant), "Signature<\(test.key)>::Verified a False signature for message `\(message.key)`")
+              XCTAssertFalse(try rsa.verify(signature: Data(base64Encoded: test.value)!.byteArray.shuffled().dropLast() + [0x01], for: message.key.bytes, variant: variant), "Signature<\(test.key)>::Verified a False signature for message `\(message.key)`")
               // Ensure an invalid signature results in an error being thrown
-              XCTAssertThrowsError(try rsa.verify(signature: Data(base64Encoded: test.value)!.bytes.dropLast(), for: message.key.bytes, variant: variant), "Signature<\(test.key)>::Verified a False signature for message `\(message.key)`")
+              XCTAssertThrowsError(try rsa.verify(signature: Data(base64Encoded: test.value)!.byteArray.dropLast(), for: message.key.bytes, variant: variant), "Signature<\(test.key)>::Verified a False signature for message `\(message.key)`")
             }
           }
         }
@@ -516,10 +516,10 @@ final class RSATests: XCTestCase {
               } else {
                 // The Raw encryption method is deterministic so we can test that encrypting the message matches the data in the test fixture...
                 let encrypted = try rsa.encrypt(message.key.bytes, variant: variant)
-                XCTAssertEqual(encrypted.toHexString(), Data(base64Encoded: message.value.encryptedMessage["algid:encrypt:RSA:raw"]!)!.bytes.toHexString(), "Encryption<\(test.key)>::Failed to encrypt the message `\(message.key)`")
+                XCTAssertEqual(encrypted.toHexString(), Data(base64Encoded: message.value.encryptedMessage["algid:encrypt:RSA:raw"]!)!.byteArray.toHexString(), "Encryption<\(test.key)>::Failed to encrypt the message `\(message.key)`")
 
                 // Decrypt the fixtures encrypted message and ensure it matches the plaintext message
-                let decrypted = try rsa.decrypt(Data(base64Encoded: test.value)!.bytes, variant: variant)
+                let decrypted = try rsa.decrypt(Data(base64Encoded: test.value)!.byteArray, variant: variant)
                 XCTAssertEqual(String(data: Data(decrypted), encoding: .utf8), message.key, "Encryption<\(test.key)>::Failed to decrypt the message `\(message.key)`")
               }
             } else {
@@ -535,7 +535,7 @@ final class RSATests: XCTestCase {
                 XCTAssertEqual(test.key.bytes, decrypted, "Encryption<\(test.key)>::Failed to decrypt the message `\(message.key)`")
 
                 // Ensure the encrypted fixture can be decrypted and results in the expected raw message
-                let decryptedFixture = try rsa.decrypt(Data(base64Encoded: test.value)!.bytes, variant: variant)
+                let decryptedFixture = try rsa.decrypt(Data(base64Encoded: test.value)!.byteArray, variant: variant)
                 XCTAssertEqual(decryptedFixture, message.key.bytes, "Encryption<\(test.key)>::Failed to decrypt the message `\(message.key)`")
               }
             }
@@ -553,19 +553,19 @@ final class RSATests: XCTestCase {
               XCTAssertThrowsError(try rsa.sign(message.key.bytes, variant: variant), "Signature<\(test.key)>::Did not throw error")
             } else {
               let signature = try rsa.sign(message.key.bytes, variant: variant)
-              XCTAssertEqual(signature, Data(base64Encoded: test.value)?.bytes, "Signature<\(test.key)>::Signature does not match fixture")
+              XCTAssertEqual(signature, Data(base64Encoded: test.value)?.byteArray, "Signature<\(test.key)>::Signature does not match fixture")
 
               // Ensure the signature is valid for the test fixtures rawMessage
-              XCTAssertTrue(try rsa.verify(signature: Data(base64Encoded: test.value)!.bytes, for: message.key.bytes, variant: variant), "Signature<\(test.key)>::Verification Failed")
+              XCTAssertTrue(try rsa.verify(signature: Data(base64Encoded: test.value)!.byteArray, for: message.key.bytes, variant: variant), "Signature<\(test.key)>::Verification Failed")
               // Ensure a modified message results in a false / invalid signature verification
-              XCTAssertFalse(try rsa.verify(signature: Data(base64Encoded: test.value)!.bytes, for: message.key.bytes + [0x00], variant: variant), "Signature<\(test.key)>::Verified a signature for an incorrect message `\(message.key)`")
+              XCTAssertFalse(try rsa.verify(signature: Data(base64Encoded: test.value)!.byteArray, for: message.key.bytes + [0x00], variant: variant), "Signature<\(test.key)>::Verified a signature for an incorrect message `\(message.key)`")
               if !message.key.bytes.isEmpty {
-                XCTAssertFalse(try rsa.verify(signature: Data(base64Encoded: test.value)!.bytes, for: message.key.bytes.dropLast(), variant: variant), "Signature<\(test.key)>::Verified a signature for an incorrect message `\(message.key)`")
+                XCTAssertFalse(try rsa.verify(signature: Data(base64Encoded: test.value)!.byteArray, for: message.key.bytes.dropLast(), variant: variant), "Signature<\(test.key)>::Verified a signature for an incorrect message `\(message.key)`")
               }
               // Ensure a modified signature results in a false / invalid signature verification (we replace the last element with a 1 in case the signature is all 0's)
-              XCTAssertFalse(try rsa.verify(signature: Data(base64Encoded: test.value)!.bytes.shuffled().dropLast() + [0x01], for: message.key.bytes, variant: variant), "Signature<\(test.key)>::Verified a False signature for message `\(message.key)`")
+              XCTAssertFalse(try rsa.verify(signature: Data(base64Encoded: test.value)!.byteArray.shuffled().dropLast() + [0x01], for: message.key.bytes, variant: variant), "Signature<\(test.key)>::Verified a False signature for message `\(message.key)`")
               // Ensure an invalid signature results in an error being thrown
-              XCTAssertThrowsError(try rsa.verify(signature: Data(base64Encoded: test.value)!.bytes.dropLast(), for: message.key.bytes, variant: variant), "Signature<\(test.key)>::Verified a False signature for message `\(message.key)`")
+              XCTAssertThrowsError(try rsa.verify(signature: Data(base64Encoded: test.value)!.byteArray.dropLast(), for: message.key.bytes, variant: variant), "Signature<\(test.key)>::Verified a False signature for message `\(message.key)`")
             }
           }
         }

Tests/CryptoSwiftTests/SignatureVerificationTests.swift

@@ -37,7 +37,7 @@ final class SignatureVerificationTests: XCTestCase {
           continue
         }
         
-        let rsa = try RSA(publicDER: publicDerData.bytes)
+        let rsa = try RSA(publicDER: publicDerData.byteArray)
         
         guard
           let signedMessageData = Data(base64Encoded: testVector.signedMessage)
@@ -46,7 +46,7 @@ final class SignatureVerificationTests: XCTestCase {
           continue
         }
         
-        let result = try rsa.verify(signature: signedMessageData.bytes,
+        let result = try rsa.verify(signature: signedMessageData.byteArray,
                                     for: testVector.originalMessage.bytes,
                                     variant: testVector.variant)
         XCTAssertTrue(result, "Verification failed for test vector with id `\(testVector.id)`")