iOS区块链钱包之BIP39（二）

HD wallet具有管理多个密钥和地址的机制，我们可以使用一个随机字符串seed通过BIP32或BIP44协议创建一个HD wallet，但是一串字符串的记忆成本太高，而且摘抄下来也会很麻烦。所以BIP39协议应运而生，他是可以使用12-24单字（可以是英文、中文、日文等等语言）来帮助用户更好的保存seed。一般我们使用长度为12个的英文单词来生成BIP39的内容，这串单词被称为mnemonic code，中文名叫助记词。

BIP-39 生成助记词流程

助记词钱包是通过BIP-39中定义的标准化过程自动生成的，钱包从熵源开始，增加校验和，然后将熵映射到字典列表中。

1.创建一个128-256位的随机序列（熵）

2.提出SHA256哈希的前几位（熵长/32）,就可以创建一个随机序列的校验和。

3.将校验和添加到随机序列的末尾。

4.将序列划分为包含11位的不同部分。

5.将每个包含11位部分的值与一个预先定义的2048个单词的字典做对应。

6.生成的有顺序的单词组就是助记词。

新建项目

导入CryptoSwift库

1. 新建BIP39.swift文件

import Foundation
import CryptoSwift

public enum BIP39Language {
    case english
    case chinese_simplified
    case chinese_traditional
    case japanese
    case korean
    case french
    case italian
    case spanish
    var words: [String] {
        switch self {
        case .english:
            return englishWords
        case .chinese_simplified:
            return simplifiedchineseWords
        case .chinese_traditional:
            return traditionalchineseWords
        case .japanese:
            return japaneseWords
        case .korean:
            return koreanWords
        case.french:
            return frenchWords
        case .italian:
            return italianWords
        case .spanish:
            return spanishWords
        }
    }
    var separator: String {
        switch self {
        case .japanese:
            return "\u{3000}"
        default:
            return " "
        }
    }
}
public class BIP39 {
    
    /// 返回一组助记词
    static public func generateMnemonics(bitsOfEntropy: Int, language: BIP39Language = BIP39Language.english) throws -> String? {
        // 1.创建一个128-256位的随机序列（熵）
        guard bitsOfEntropy >= 128 && bitsOfEntropy <= 256 && bitsOfEntropy % 32 == 0 else {return nil}
        guard let entropy = Data.randomBytes(length: bitsOfEntropy/8) else {throw AbstractError.noEntropyError}
        
        return BIP39.generateMnemonicsFromEntropy(entropy: entropy, language: language)
        
    }
    
    /// 通过熵生成助记词
    static public func generateMnemonicsFromEntropy(entropy: Data, language: BIP39Language = BIP39Language.english) -> String?  {
        guard entropy.count >= 16, entropy.count & 4 == 0 else {return nil}
        // 2.提出SHA256哈希的前几位（熵长/32）,就可以创建一个随机序列的校验和。
        let checksum = entropy.sha256()
        // 3.将校验和添加到随机序列的末尾。
        let checksumBits = entropy.count*8/32
        var fullEntropy = Data()
        fullEntropy.append(entropy)
        fullEntropy.append(checksum[0 ..< (checksumBits+7)/8 ])
        var wordList = [String]()
        // 4.将序列划分为包含11位的不同部分
        for i in 0 ..< fullEntropy.count*8/11 {
            guard let bits = fullEntropy.bitsInRange(i*11, 11) else {return nil}
            let index = Int(bits)
            guard language.words.count > index else {return nil}
            // 5.将每个包含11位部分的值与一个预先定义的2048个单词的字典做对应。
            let word = language.words[index]
            wordList.append(word)
        }
        let separator = language.separator
        // 6.生成的有顺序的单词组就是助记词。
        return wordList.joined(separator: separator)
    }
    
    /// 通过助记词返回一个熵
    static public func mnemonicsToEntropy(_ mnemonics: String, language: BIP39Language = BIP39Language.english) -> Data? {
        let wordList = mnemonics.components(separatedBy: " ")
        guard wordList.count >= 12 && wordList.count % 4 == 0 else {return nil}
        var bitString = ""
        for word in wordList {
            let idx = language.words.index(of: word)
            if (idx == nil) {
                return nil
            }
            let idxAsInt = language.words.startIndex.distance(to: idx!)
            let stringForm = String(UInt16(idxAsInt), radix: 2).leftPadding(toLength: 11, withPad: "0")
            bitString.append(stringForm)
        }
        let stringCount = bitString.count
        if stringCount % 33 != 0 {
            return nil
        }
        let entropyBits = bitString[0 ..< (bitString.count - bitString.count/33)]
        let checksumBits = bitString[(bitString.count - bitString.count/33) ..< bitString.count]
        guard let entropy = entropyBits.interpretAsBinaryData() else {
            return nil
        }
        let checksum = String(entropy.sha256().bitsInRange(0, checksumBits.count)!, radix: 2).leftPadding(toLength: checksumBits.count, withPad: "0")
        if checksum != checksumBits {
            return nil
        }
        return entropy
    }
    
    /// 通过助记词返回一个seed（种子）
    static public func seedFromMmemonics(_ mnemonics: String, password: String = "", language: BIP39Language = BIP39Language.english) -> Data? {
        let valid = BIP39.mnemonicsToEntropy(mnemonics, language: language) != nil
        if (!valid) {
            print("Potentially invalid mnemonics")
        }
        guard let mnemData = mnemonics.decomposedStringWithCompatibilityMapping.data(using: .utf8) else {return nil}
        let salt = "mnemonic" + password
        guard let saltData = salt.decomposedStringWithCompatibilityMapping.data(using: .utf8) else {return nil}
        guard let seedArray = try? PKCS5.PBKDF2(password: mnemData.bytes, salt: saltData.bytes, iterations: 2048, keyLength: 64, variant: HMAC.Variant.sha512).calculate() else {return nil}
        let seed = Data(bytes:seedArray)
        return seed
    }
}

2. 统一错误处理类AbstractError.swift

import Foundation

public enum AbstractError: Error {
    case noEntropyError
    case keyDerivationError
    case aesError
    case invalidAccountError
    case invalidPasswordError
    case encryptionError(String)
}

项目结构

image.png

demo使用：

// 生成助记词
let mnemonic = try! BIP39.generateMnemonics(bitsOfEntropy: 128)!

// 种子
let seed = BIP39.seedFromMmemonics(mnemonic)

print("助记词：\(mnemonic)")

print("种子seed：\(seed?.toHexString() ?? "")")

示例结果

助记词：soldier stay tackle return tackle lens praise leader traffic sword anxiety intact
种子seed：bc428e06a1bc08b3bf52ce6b1fd1a295518888b1de10eea3231043bed07e4ccd108e5a192bfd073d3db81dba8311ed2b109fbda3d6daa63d27000e395a46f887

验证地址：
https://iancoleman.io/bip39/
demo下载地址：
暂未上传