Merge pull request #1076 from mluisbrown/michael/rename-data-bytes-to-bytearray

nathanfallet · web-flow · commit 2c06f88754e7 · 2025-07-09T23:00:20.000-07:00
diff --git a/Sources/CryptoSwift/ASN1/ASN1Encoder.swift b/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)
diff --git a/Sources/CryptoSwift/Foundation/Array+Foundation.swift b/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)
   }
 }
diff --git a/Sources/CryptoSwift/Foundation/Data+Extension.swift b/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()
   }
 }
diff --git a/Sources/CryptoSwift/Foundation/String+FoundationExtension.swift b/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
   }
 }
diff --git a/Sources/CryptoSwift/RSA/RSA+Cipher.swift b/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
   }
 }
 
diff --git a/Sources/CryptoSwift/RSA/RSA+Signature.swift b/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 }
diff --git a/Sources/CryptoSwift/RSA/RSA.swift b/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
diff --git a/Sources/CryptoSwift/String+Extension.swift b/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
diff --git a/Sources/CryptoSwift/UInt128.swift b/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 {
diff --git a/Tests/CryptoSwiftTests/Access.swift b/Tests/CryptoSwiftTests/Access.swift
@@ -142,7 +142,7 @@ class Access: XCTestCase {
     _ = data.crc32()
     _ = data.crc32c()
 
-    _ = data.bytes
+    _ = data.byteArray
     _ = data.toHexString()
 
     do {
diff --git a/Tests/CryptoSwiftTests/DigestTests.swift b/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)
diff --git a/Tests/CryptoSwiftTests/RSATests.swift b/Tests/CryptoSwiftTests/RSATests.swift
diff --git a/Tests/CryptoSwiftTests/SignatureVerificationTests.swift b/Tests/CryptoSwiftTests/SignatureVerificationTests.swift

Original file line number	Diff line number	Diff line change
`@@ -27,6 +27,6 @@ public extension Array where Element == UInt8 {`
`27`	`27`	`return`
`28`	`28`	`}`
`29`	`29`
`30`		`- append(contentsOf: decodedData.bytes)`
	`30`	`+ append(contentsOf: decodedData.byteArray)`
`31`	`31`	`}`
`32`	`32`	`}`
Original file line number	Diff line number	Diff line change
`@@ -25,55 +25,55 @@ extension Data {`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`public func md5() -> Data {`
`28`		`- Data( Digest.md5(bytes))`
	`28`	`+ Data( Digest.md5(byteArray))`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`public func sha1() -> Data {`
`32`		`- Data( Digest.sha1(bytes))`
	`32`	`+ Data( Digest.sha1(byteArray))`
`33`	`33`	`}`
`34`	`34`
`35`	`35`	`public func sha224() -> Data {`
`36`		`- Data( Digest.sha224(bytes))`
	`36`	`+ Data( Digest.sha224(byteArray))`
`37`	`37`	`}`
`38`	`38`
`39`	`39`	`public func sha256() -> Data {`
`40`		`- Data( Digest.sha256(bytes))`
	`40`	`+ Data( Digest.sha256(byteArray))`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`public func sha384() -> Data {`
`44`		`- Data( Digest.sha384(bytes))`
	`44`	`+ Data( Digest.sha384(byteArray))`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`public func sha512() -> Data {`
`48`		`- Data( Digest.sha512(bytes))`
	`48`	`+ Data( Digest.sha512(byteArray))`
`49`	`49`	`}`
`50`	`50`
`51`	`51`	`public func sha3(_ variant: SHA3.Variant) -> Data {`
`52`		`- Data( Digest.sha3(bytes, variant: variant))`
	`52`	`+ Data( Digest.sha3(byteArray, variant: variant))`
`53`	`53`	`}`
`54`	`54`
`55`	`55`	`public func crc32(seed: UInt32? = nil, reflect: Bool = true) -> Data {`
`56`		`- Data( Checksum.crc32(bytes, seed: seed, reflect: reflect).bytes())`
	`56`	`+ Data( Checksum.crc32(byteArray, seed: seed, reflect: reflect).bytes())`
`57`	`57`	`}`
`58`	`58`
`59`	`59`	`public func crc32c(seed: UInt32? = nil, reflect: Bool = true) -> Data {`
`60`		`- Data( Checksum.crc32c(bytes, seed: seed, reflect: reflect).bytes())`
	`60`	`+ Data( Checksum.crc32c(byteArray, seed: seed, reflect: reflect).bytes())`
`61`	`61`	`}`
`62`	`62`
`63`	`63`	`public func crc16(seed: UInt16? = nil) -> Data {`
`64`		`- Data( Checksum.crc16(bytes, seed: seed).bytes())`
	`64`	`+ Data( Checksum.crc16(byteArray, seed: seed).bytes())`
`65`	`65`	`}`
`66`	`66`
`67`	`67`	`public func encrypt(cipher: Cipher) throws -> Data {`
`68`		`- Data( try cipher.encrypt(bytes.slice))`
	`68`	`+ Data( try cipher.encrypt(byteArray.slice))`
`69`	`69`	`}`
`70`	`70`
`71`	`71`	`public func decrypt(cipher: Cipher) throws -> Data {`
`72`		`- Data( try cipher.decrypt(bytes.slice))`
	`72`	`+ Data( try cipher.decrypt(byteArray.slice))`
`73`	`73`	`}`
`74`	`74`
`75`	`75`	`public func authenticate(with authenticator: Authenticator) throws -> Data {`
`76`		`- Data( try authenticator.authenticate(bytes))`
	`76`	`+ Data( try authenticator.authenticate(byteArray))`
`77`	`77`	`}`
`78`	`78`	`}`
`79`	`79`
`@@ -82,11 +82,11 @@ extension Data {`
`82`	`82`	`self.init(Array<UInt8>(hex: hex))`
`83`	`83`	`}`
`84`	`84`
`85`		`- public var bytes: Array<UInt8> {`
	`85`	`+ public var byteArray: Array<UInt8> {`
`86`	`86`	`Array(self)`
`87`	`87`	`}`
`88`	`88`
`89`	`89`	`public func toHexString() -> String {`
`90`		`- self.bytes.toHexString()`
	`90`	`+ self.byteArray.toHexString()`
`91`	`91`	`}`
`92`	`92`	`}`
Original file line number	Diff line number	Diff line change
`@@ -36,6 +36,6 @@ extension String {`
`36`	`36`	`throw CipherError.decrypt`
`37`	`37`	`}`
`38`	`38`
`39`		`- return try decodedData.decrypt(cipher: cipher).bytes`
	`39`	`+ return try decodedData.decrypt(cipher: cipher).byteArray`
`40`	`40`	`}`
`41`	`41`	`}`
Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ extension RSA: Cipher {`
`36`	`36`	`@inlinable`
`37`	`37`	`internal func encryptPreparedBytes(_ bytes: Array<UInt8>) throws -> Array<UInt8> {`
`38`	`38`	`// Calculate encrypted data`
`39`		`- return BigUInteger(Data(bytes)).power(self.e, modulus: self.n).serialize().bytes`
	`39`	`+ return BigUInteger(Data(bytes)).power(self.e, modulus: self.n).serialize().byteArray`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`@inlinable`
`@@ -59,7 +59,7 @@ extension RSA: Cipher {`
`59`	`59`	`guard let d = d else { throw RSA.Error.noPrivateKey }`
`60`	`60`
`61`	`61`	`// Calculate decrypted data`
`62`		`- return BigUInteger(Data(bytes)).power(d, modulus: self.n).serialize().bytes`
	`62`	`+ return BigUInteger(Data(bytes)).power(d, modulus: self.n).serialize().byteArray`
`63`	`63`	`}`
`64`	`64`	`}`
`65`	`65`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ extension String {`
`20`	`20`
`21`	`21`	`@inlinable`
`22`	`22`	`public var bytes: Array<UInt8> {`
`23`		`- data(using: String.Encoding.utf8, allowLossyConversion: true)?.bytes ?? Array(utf8)`
	`23`	`+ data(using: String.Encoding.utf8, allowLossyConversion: true)?.byteArray ?? Array(utf8)`
`24`	`24`	`}`
`25`	`25`
`26`	`26`	`@inlinable`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ struct UInt128: Equatable, ExpressibleByIntegerLiteral {`
`58`	`58`	`var result = Data()`
`59`	`59`	`result.append(ar)`
`60`	`60`	`result.append(br)`
`61`		`- return result.bytes`
	`61`	`+ return result.byteArray`
`62`	`62`	`}`
`63`	`63`
`64`	`64`	`static func ^ (n1: UInt128, n2: UInt128) -> UInt128 {`