Merge pull request #80 from novasamatech/feature/trust-wallet-derivation

Hierarchical wallet derivations for Ed25519

Author: ERussel

Package.swift

@@ -173,8 +173,9 @@ enum Resources {
             ]
         case .hdkd:
             paths = [
-                "../Resources/BIP32HDKD.json",
-                "../Resources/BIP32HDKDEtalon.json",
+                "../Resources/BIP32Secp256HDKD.json",
+                "../Resources/BIP32Secp256HDKDEtalon.json",
+                "../Resources/BIP32Ed25519HDKDEtalon.json",
                 "../Resources/ecdsaHDKD.json",
                 "../Resources/ed25519HDKD.json",
                 "../Resources/sr25519HDKD.json"

SubstrateSdk.podspec

@@ -8,7 +8,7 @@
 
 Pod::Spec.new do |s|
   s.name             = 'SubstrateSdk'
-  s.version          = '4.3.0'
+  s.version          = '4.4.0'
   s.summary          = 'Utility library that implements clients specific logic to interact with substrate based networks'
 
   s.homepage         = 'https://github.com/nova-wallet/substrate-sdk-ios'

SubstrateSdk/Classes/Crypto/KeypairFactory/BIP32Ed25519KeyFactory.swift

@@ -0,0 +1,63 @@
+import NovaCrypto
+import BigInt
+
+public final class BIP32Ed25519KeyFactory: BIP32KeypairFactory {
+    private static let initialSeed = "ed25519 seed"
+    let internalFactory = EDKeyFactory()
+    
+    public override init() {
+        super.init()
+    }
+    
+    override func deriveFromSeed(_ seed: Data) throws -> BIP32ExtendedKeypair {
+        let hmacResult = try generateHMAC512(
+            from: seed,
+            secretKeyData: Data(Self.initialSeed.utf8)
+        )
+
+        let privateKeySeed = hmacResult[...31]
+        let chainCode = hmacResult[32...]
+
+        // we are returning seed as private key as both further derivation and signature requires it
+        let publicKey = try internalFactory.derive(fromSeed: privateKeySeed).publicKey()
+        let secretKey = try EDPrivateKey(rawData: privateKeySeed)
+        
+        let keypair = IRCryptoKeypair(publicKey: publicKey, privateKey: secretKey)
+
+        return BIP32ExtendedKeypair(keypair: keypair, chaincode: chainCode)
+    }
+
+    override func createKeypairFrom(
+        _ parentKeypair: BIP32ExtendedKeypair,
+        chaincode: Chaincode
+    ) throws -> BIP32ExtendedKeypair {
+        let sourceData: Data = try {
+            switch chaincode.type {
+            case .hard:
+                let padding = Data(repeating: 0, count: 1)
+                let privateKeyData = parentKeypair.privateKey().rawData()
+
+                return padding + privateKeyData + chaincode.data
+
+            case .soft:
+                throw BIP32KeypairFactoryError.unsupportedSoftDerivation
+            }
+        }()
+
+        let hmacResult = try generateHMAC512(
+            from: sourceData,
+            secretKeyData: parentKeypair.chaincode
+        )
+
+        let childPrivateKeySeed = hmacResult[...31]
+        let childChaincode = hmacResult[32...]
+        
+        // we are returning seed as private key as both further derivation and signature requires it
+        let publicKey = try internalFactory.derive(fromSeed: childPrivateKeySeed).publicKey()
+        let secretKey = try EDPrivateKey(rawData: childPrivateKeySeed)
+
+        let keypair = IRCryptoKeypair(publicKey: publicKey, privateKey: secretKey)
+        
+        return BIP32ExtendedKeypair(keypair: keypair, chaincode: childChaincode)
+    }
+}

SubstrateSdk/Classes/Crypto/KeypairFactory/BIP32KeypairFactory.swift

@@ -1,17 +1,52 @@
-import Foundation
+import CommonCrypto
 import NovaCrypto
 
-public struct BIP32KeypairFactory {
-    let internalFactory = BIP32KeyFactory()
+public class BIP32KeypairFactory {
+    func deriveFromSeed(_ seed: Data) throws -> BIP32ExtendedKeypair {
+        fatalError("Must be overriden by subsclass")
+    }
+    
+    func createKeypairFrom(_ parentKeypair: BIP32ExtendedKeypair, chaincode: Chaincode) throws -> BIP32ExtendedKeypair {
+        fatalError("Must be overriden by subsclass")
+    }
+    
+    func generateHMAC512(
+        from originalData: Data,
+        secretKeyData: Data
+    ) throws -> Data {
+        let digestLength = Int(CC_SHA512_DIGEST_LENGTH)
+        let algorithm = CCHmacAlgorithm(kCCHmacAlgSHA512)
+
+        var buffer = [UInt8](repeating: 0, count: digestLength)
+
+        originalData.withUnsafeBytes {
+            let rawOriginalDataPtr = $0.baseAddress!
+
+            secretKeyData.withUnsafeBytes {
+                let rawSecretKeyPtr = $0.baseAddress!
 
-    public init() {}
+                CCHmac(
+                    algorithm,
+                    rawSecretKeyPtr,
+                    secretKeyData.count,
+                    rawOriginalDataPtr,
+                    originalData.count,
+                    &buffer
+                )
+            }
+        }
+
+        return Data(bytes: buffer, count: digestLength)
+    }
+}
 
-    private func deriveChildKeypairFromMaster(
+private extension BIP32KeypairFactory {
+    func deriveChildKeypairFromMaster(
         _ masterKeypair: BIP32ExtendedKeypair,
         chainIndexList: [Chaincode]
     ) throws -> IRCryptoKeypairProtocol {
         let childExtendedKeypair = try chainIndexList.reduce(masterKeypair) { parentKeypair, chainIndex in
-            try internalFactory.createKeypairFrom(parentKeypair, chaincode: chainIndex)
+            try createKeypairFrom(parentKeypair, chaincode: chainIndex)
         }
 
         return childExtendedKeypair.keypair
@@ -23,7 +58,7 @@ extension BIP32KeypairFactory: KeypairFactoryProtocol {
         _ seed: Data,
         chaincodeList: [Chaincode]
     ) throws -> IRCryptoKeypairProtocol {
-        let masterKeypair = try internalFactory.deriveFromSeed(seed)
+        let masterKeypair = try deriveFromSeed(seed)
 
         return try deriveChildKeypairFromMaster(
             masterKeypair,

SubstrateSdk/Classes/Crypto/KeypairFactory/BIP32KeypairFactoryError.swift

@@ -0,0 +1,7 @@
+import NovaCrypto
+
+public enum BIP32KeypairFactoryError: Error {
+    case invalidMasterKey
+    case invalidChildKey
+    case unsupportedSoftDerivation
+}

SubstrateSdk/Classes/Crypto/BIP32KeyFactory.swift renamed to SubstrateSdk/Classes/Crypto/KeypairFactory/BIP32Secp256KeypairFactory.swift

@@ -1,66 +1,37 @@
-import CommonCrypto
 import NovaCrypto
 import BigInt
 
-public enum BIP32KeyFactoryError: Error {
-    case invalidChildKey
-}
-
-protocol BIP32KeyFactoryProtocol {
-    func deriveFromSeed(_ seed: Data) throws -> BIP32ExtendedKeypair
-    func createKeypairFrom(_ parentKeypair: BIP32ExtendedKeypair, chaincode: Chaincode) throws -> BIP32ExtendedKeypair
-}
-
-public struct BIP32KeyFactory {
+public final class BIP32Secp256KeypairFactory: BIP32KeypairFactory {
     private static let initialSeed = "Bitcoin seed"
     let internalFactory = SECKeyFactory()
-
-    private func generateHMAC512(
-        from originalData: Data,
-        secretKeyData: Data
-    ) throws -> Data {
-        let digestLength = Int(CC_SHA512_DIGEST_LENGTH)
-        let algorithm = CCHmacAlgorithm(kCCHmacAlgSHA512)
-
-        var buffer = [UInt8](repeating: 0, count: digestLength)
-
-        originalData.withUnsafeBytes {
-            let rawOriginalDataPtr = $0.baseAddress!
-
-            secretKeyData.withUnsafeBytes {
-                let rawSecretKeyPtr = $0.baseAddress!
-
-                CCHmac(
-                    algorithm,
-                    rawSecretKeyPtr,
-                    secretKeyData.count,
-                    rawOriginalDataPtr,
-                    originalData.count,
-                    &buffer
-                )
-            }
-        }
-
-        return Data(bytes: buffer, count: digestLength)
+    
+    public override init() {
+        super.init()
     }
-}
-
-extension BIP32KeyFactory: BIP32KeyFactoryProtocol {
-    func deriveFromSeed(_ seed: Data) throws -> BIP32ExtendedKeypair {
+    
+    override func deriveFromSeed(_ seed: Data) throws -> BIP32ExtendedKeypair {
         let hmacResult = try generateHMAC512(
             from: seed,
             secretKeyData: Data(Self.initialSeed.utf8)
         )
 
-        let privateKey = try SECPrivateKey(rawData: hmacResult[...31])
+        let privateKeyData = hmacResult[...31]
+        
+        let privateKeyInt = BigUInt(privateKeyData)
+
+        guard privateKeyInt < .secp256k1CurveOrder, privateKeyInt > 0 else {
+            throw BIP32KeypairFactoryError.invalidMasterKey
+        }
+        
+        let privateKey = try SECPrivateKey(rawData: privateKeyData)
         let chainCode = hmacResult[32...]
 
         let keypair = try internalFactory.derive(fromPrivateKey: privateKey)
 
         return BIP32ExtendedKeypair(keypair: keypair, chaincode: chainCode)
     }
 
-    func createKeypairFrom(
+    override func createKeypairFrom(
         _ parentKeypair: BIP32ExtendedKeypair,
         chaincode: Chaincode
     ) throws -> BIP32ExtendedKeypair {
@@ -69,7 +40,7 @@ extension BIP32KeyFactory: BIP32KeyFactoryProtocol {
             case .hard:
                 let padding = Data(repeating: 0, count: 1)
                 let privateKeyData = parentKeypair.privateKey().rawData()
-
+                
                 return padding + privateKeyData + chaincode.data
 
             case .soft:
@@ -88,14 +59,14 @@ extension BIP32KeyFactory: BIP32KeyFactoryProtocol {
         var privateKeyInt = BigUInt(privateKeySourceData.rawData())
 
         guard privateKeyInt < .secp256k1CurveOrder else {
-            throw BIP32KeyFactoryError.invalidChildKey
+            throw BIP32KeypairFactoryError.invalidChildKey
         }
 
         privateKeyInt += BigUInt(parentKeypair.privateKey().rawData())
         privateKeyInt %= .secp256k1CurveOrder
 
         guard privateKeyInt > 0 else {
-            throw BIP32KeyFactoryError.invalidChildKey
+            throw BIP32KeypairFactoryError.invalidChildKey
         }
 
         var privateKeyData = privateKeyInt.serialize()
@@ -113,6 +84,9 @@ extension BIP32KeyFactory: BIP32KeyFactoryProtocol {
         let privateKey = try SECPrivateKey(rawData: privateKeyData)
         let keypair = try internalFactory.derive(fromPrivateKey: privateKey)
 
-        return BIP32ExtendedKeypair(keypair: keypair, chaincode: childChaincode)
+        return BIP32ExtendedKeypair(
+            keypair: keypair,
+            chaincode: childChaincode
+        )
     }
 }

Tests/Crypto/BIP32/BIP32Ed25519KeypairDerivationTests.swift

@@ -0,0 +1,105 @@
+import XCTest
+@testable import SubstrateSdk
+import NovaCrypto
+#if canImport(TestHelpers)
+import TestHelpers
+#endif
+
+final class BIP32Ed25519KeypairDerivationTests: XCTestCase {
+    struct TestVectorItem: Decodable {
+        let seed: String
+        let derivationPath: String?
+        let privateKey: String
+        let publicKey: String
+        
+        func getPublicKeyWithoutPrefix() throws -> Data {
+            // drop "00" prefix which is present in slip10 vectors
+            // It is present in the test vectors ensure unified format with other vectors
+            // But we do not need it
+            try Data(hexString: publicKey).dropFirst(1)
+        }
+    }
+    
+    func testSoftDerivationNotSupported() throws {
+        let factory = BIP32Ed25519KeyFactory()
+        
+        let junction = try BIP32JunctionFactory().parse(path: "/0")
+        
+        let seed = try Data(hexString: "000102030405060708090a0b0c0d0e0f")
+        
+        XCTAssertThrowsError(
+            try factory.createKeypairFromSeed(seed, chaincodeList: junction.chaincodes),
+            "Error is expected"
+        ) { error in
+            guard let bip32Error = error as? BIP32KeypairFactoryError else {
+                XCTFail("Keypair derivation error is expected")
+                return
+            }
+            
+            XCTAssert(bip32Error == .unsupportedSoftDerivation)
+        }
+    }
+    
+    // SLIP-0010 Official Test Vectors: https://github.com/satoshilabs/slips/blob/master/slip-0010.md
+    func testDerivationFromSeed() throws {
+        try performTest(filename: "BIP32Ed25519HDKDEtalon", keypairFactory: BIP32Ed25519KeyFactory())
+    }
+    
+    private func performTest(filename: String, keypairFactory: KeypairFactoryProtocol) throws {
+        let bundle: Bundle
+#if SWIFT_PACKAGE
+        bundle = Bundle.module
+#else
+        bundle = Bundle(for: KeypairDeriviationTests.self)
+#endif
+        guard let url = bundle
+            .url(forResource: filename, withExtension: "json") else {
+            XCTFail("Can't find resource")
+            return
+        }
+
+        do {
+            let testData = try Data(contentsOf: url)
+            let decoder = JSONDecoder()
+            decoder.keyDecodingStrategy = .convertFromSnakeCase
+            let items = try decoder.decode([TestVectorItem].self, from: testData)
+
+            let junctionFactory = BIP32JunctionFactory()
+
+            for item in items {
+                let result: JunctionResult
+
+                if let derivationPath = item.derivationPath, !derivationPath.isEmpty {
+                    result = try junctionFactory.parse(path: derivationPath)
+                } else {
+                    result = JunctionResult(chaincodes: [], password: nil)
+                }
+                
+                let seed = try Data(hexString: item.seed)
+
+                let keypair = try keypairFactory.createKeypairFromSeed(seed, chaincodeList: result.chaincodes)
+
+                let expectedPrivateKey = try Data(hexString: item.privateKey)
+                let expectedPublicKey = try item.getPublicKeyWithoutPrefix()
+                
+                let actualPrivateKey = keypair.privateKey().rawData()
+                let actualPublicKey = keypair.publicKey().rawData()
+                
+                XCTAssertEqual(
+                    expectedPrivateKey,
+                    actualPrivateKey,
+                    "Expected private key \(expectedPrivateKey.toHex()) but received \(actualPrivateKey.toHex())"
+                )
+                
+                XCTAssertEqual(
+                    expectedPublicKey,
+                    actualPublicKey,
+                    "Expected public key \(expectedPublicKey.toHex()) but received \(actualPublicKey.toHex())"
+                )
+            }
+        } catch {
+            XCTFail("Unexpected error \(error)")
+        }
+    }
+
+}