Add limited support for electrum segwit seeds

README.md

@@ -44,6 +44,7 @@ If you have specific questions about the project, our [Telegram Group](https://t
 * Optimized seed word entry interface
 * Support for Bitcoin Mainnet & Testnet
 * Support for custom user-defined derivation paths
+* Support for loading Electrum Segwit seed phrases with feature limitations: [Electrum support info](docs/electrum.md)
 * On-demand receive address verification
 * Address Explorer for single sig and multisig wallets
 * User-configurable QR code display density

docs/electrum.md

@@ -0,0 +1,15 @@
+# SeedSigner Electrum seed phrase support
+
+SeedSigner supports loading of [Electrum's Segwit seed phrases](https://electrum.readthedocs.io/en/latest/seedphrase.html#electrum-seed-version-system).  This is considered an Advanced feature that is disabled by default.  
+
+To load an Electrum Segwit seed phrase, first enable Electrum seed support in Settings -> Advanced -> Electrum seed support.  After this option is enabled, the user will now be able to enter an Electrum seed phrase by selecting "Enter Electrum seed" in the Load Seed screen.
+
+Some SeedSigner functionality is deliberately disabled when using an Electrum mnemonic:
+
+- BIP-85 child seeds
+	- Not applicable for Electrum seed types
+- SeedQR backups
+	- Since Electrum seeds are not supported by other SeedQR implementations, it would be dangerous to use SeedQR as a backup tool for Electrum seeds and is thus disabled
+- Custom derivations
+	- Hard coded derivation path and script types in SeedSigner to match Electrum wallet software. These are m/0h for single sig and m/1h for multisig
+	- User-chosen custom derivations are thus not supported for Electrum seeds

src/seedsigner/models/encode_qr.py

@@ -85,16 +85,15 @@ def is_complete(self):
 
 @dataclass
 class SeedQrEncoder(BaseStaticQrEncoder):
-    mnemonic: List[str] = None
-    wordlist_language_code: str = SettingsConstants.WORDLIST_LANGUAGE__ENGLISH
+    seed : Seed = None
 
     def __post_init__(self):
-        self.wordlist = Seed.get_wordlist(self.wordlist_language_code)
+        self.wordlist = Seed.get_wordlist(self.seed.wordlist_language_code)
         super().__post_init__()
 
         self.data = ""
         # Output as Numeric data format
-        for word in self.mnemonic:
+        for word in self.seed.mnemonic_list:
             index = self.wordlist.index(word)
             self.data += str("%04d" % index)
 
@@ -109,18 +108,18 @@ class CompactSeedQrEncoder(SeedQrEncoder):
     def next_part(self):
         # Output as binary data format
         binary_str = ""
-        for word in self.mnemonic:
+        for word in self.seed.mnemonic_list:
             index = self.wordlist.index(word)
 
             # Convert index to binary, strip out '0b' prefix; zero-pad to 11 bits
             binary_str += bin(index).split('b')[1].zfill(11)
 
         # We can exclude the checksum bits at the end
-        if len(self.mnemonic) == 24:
+        if len(self.seed.mnemonic_list) == 24:
             # 8 checksum bits in a 24-word seed
             binary_str = binary_str[:-8]
 
-        elif len(self.mnemonic) == 12:
+        elif len(self.seed.mnemonic_list) == 12:
             # 4 checksum bits in a 12-word seed
             binary_str = binary_str[:-4]
 
@@ -149,22 +148,14 @@ class BaseXpubQrEncoder(BaseQrEncoder):
     """
     Base Xpub QrEncoder for static and animated formats
     """
-    mnemonic: list = None
-    passphrase: str = None
+    seed: Seed = None
     derivation: str = None
     network: str = SettingsConstants.MAINNET
-    wordlist_language_code: str = SettingsConstants.WORDLIST_LANGUAGE__ENGLISH
+    sig_type : str = None
 
     def prep_xpub(self):
-        self.wordlist = Seed.get_wordlist(self.wordlist_language_code)
-
-        if self.wordlist == None:
-            raise Exception('Wordlist Required')
 
-        version = bip32.detect_version(self.derivation, default="xpub", network=NETWORKS[SettingsConstants.map_network_to_embit(self.network)])
-        self.seed = Seed(mnemonic=self.mnemonic,
-                         passphrase=self.passphrase,
-                         wordlist_language_code=self.wordlist_language_code)
+        version = self.seed.detect_version(self.derivation, self.network, self.sig_type)
         self.root = bip32.HDKey.from_seed(self.seed.seed_bytes, version=NETWORKS[SettingsConstants.map_network_to_embit(self.network)]["xprv"])
         self.fingerprint = self.root.child(0).fingerprint
         self.xprv = self.root.derive(self.derivation)

src/seedsigner/models/seed.py

@@ -1,4 +1,6 @@
 import unicodedata
+import hashlib
+import hmac
 
 from binascii import hexlify
 from embit import bip39, bip32, bip85
@@ -18,7 +20,7 @@ def __init__(self,
                  mnemonic: List[str] = None,
                  passphrase: str = "",
                  wordlist_language_code: str = SettingsConstants.WORDLIST_LANGUAGE__ENGLISH) -> None:
-        self.wordlist_language_code = wordlist_language_code
+        self._wordlist_language_code = wordlist_language_code
 
         if not mnemonic:
             raise Exception("Must initialize a Seed with a mnemonic List[str]")
@@ -56,7 +58,11 @@ def mnemonic_str(self) -> str:
     @property
     def mnemonic_list(self) -> List[str]:
         return self._mnemonic
-
+
+
+    @property 
+    def wordlist_language_code(self) -> str:
+        return self._wordlist_language_code
 
     @property
     def mnemonic_display_str(self) -> str:
@@ -100,6 +106,28 @@ def set_wordlist_language_code(self, language_code: str):
         # TODO: Support other BIP-39 wordlist languages!
         raise Exception("Not yet implemented!")
 
+    @property
+    def script_override(self) -> list:
+        return None
+
+    def derivation_override(self, wallet_type: str  = SettingsConstants.SINGLE_SIG) -> str:
+        return None
+
+    def detect_version(self, derivation_path: str, network: str = SettingsConstants.MAINNET, wallet_type: str = SettingsConstants.SINGLE_SIG) -> str:
+        embit_network = NETWORKS[SettingsConstants.map_network_to_embit(network)]
+        return bip32.detect_version(derivation_path, default="xpub", network=embit_network)
+
+    @property
+    def passphrase_label(self) -> str:
+        return SettingsConstants.LABEL__BIP39_PASSPHRASE
+
+    @property
+    def seedqr_supported(self) -> bool:
+        return True
+
+    @property
+    def bip85_supported(self) -> bool:
+        return True
 
     def get_fingerprint(self, network: str = SettingsConstants.MAINNET) -> str:
         root = bip32.HDKey.from_seed(self.seed_bytes, version=NETWORKS[SettingsConstants.map_network_to_embit(network)]["xprv"])
@@ -125,3 +153,65 @@ def __eq__(self, other):
         if isinstance(other, Seed):
             return self.seed_bytes == other.seed_bytes
         return False
+
+
+
+class ElectrumSeed(Seed):
+
+
+    def _generate_seed(self) -> bool:
+        if len(self._mnemonic) != 12:
+            return False
+        s = hmac.digest(b"Seed version", self.mnemonic_str.encode('utf8'), hashlib.sha512).hex()
+        prefix = s[0:3]
+        # only support Electrum Segwit version for now
+        if SettingsConstants.ELECTRUM_SEED_SEGWIT == prefix:
+            self.seed_bytes=hashlib.pbkdf2_hmac('sha512', self.mnemonic_str.encode('utf-8'), b'electrum' + self._passphrase.encode('utf-8'), iterations = SettingsConstants.ELECTRUM_PBKDF2_ROUNDS)
+            return True
+        else:
+            raise InvalidSeedException("Unsupported electrum seed input")
+            return False
+
+    def set_passphrase(self, passphrase: str, regenerate_seed: bool = True):
+        if passphrase:
+            self._passphrase = ElectrumSeed.normalize_electrum_passphrase(passphrase)
+        else:
+            # Passphrase must always have a string value, even if it's just the empty
+            # string.
+            self._passphrase = ""
+
+        if regenerate_seed:
+            # Regenerate the internal seed since passphrase changes the result
+            self._generate_seed()
+
+    @staticmethod
+    def normalize_electrum_passphrase(passphrase : str) -> str:
+        passphrase = unicodedata.normalize('NFKD', passphrase)
+        # lower
+        passphrase = passphrase.lower()
+        # normalize whitespaces
+        passphrase = u' '.join(passphrase.split())
+        return passphrase
+
+    @property
+    def script_override(self) -> list:
+            return [SettingsConstants.NATIVE_SEGWIT]
+
+    def derivation_override(self, wallet_type: str = SettingsConstants.SINGLE_SIG) -> str:
+        return "m/0h" if SettingsConstants.SINGLE_SIG == wallet_type else "m/1h"
+
+    def detect_version(self, derivation_path: str, network: str = SettingsConstants.MAINNET, wallet_type: str = SettingsConstants.SINGLE_SIG) -> str:
+        embit_network = NETWORKS[SettingsConstants.map_network_to_embit(network)]
+        return embit_network["zpub"] if SettingsConstants.SINGLE_SIG == wallet_type else embit_network["Zpub"]
+
+    @property
+    def passphrase_label(self) -> str:
+        return SettingsConstants.LABEL__CUSTOM_EXTENSION
+
+    @property
+    def seedqr_supported(self) -> bool:
+        return False
+
+    @property
+    def bip85_supported(self) -> bool:
+        return False

src/seedsigner/models/seed_storage.py

@@ -1,5 +1,5 @@
 from typing import List
-from seedsigner.models.seed import Seed, InvalidSeedException
+from seedsigner.models.seed import Seed, ElectrumSeed, InvalidSeedException
 from seedsigner.models.settings_definition import SettingsConstants
 
 
@@ -9,6 +9,7 @@ def __init__(self) -> None:
         self.seeds: List[Seed] = []
         self.pending_seed: Seed = None
         self._pending_mnemonic: List[str] = []
+        self._pending_is_electrum : bool = False
 
 
     def set_pending_seed(self, seed: Seed):
@@ -58,8 +59,9 @@ def pending_mnemonic_length(self) -> int:
         return len(self._pending_mnemonic)
 
 
-    def init_pending_mnemonic(self, num_words:int = 12):
+    def init_pending_mnemonic(self, num_words:int = 12, is_electrum:bool = False):
         self._pending_mnemonic = [None] * num_words
+        self._pending_is_electrum = is_electrum
 
 
     def update_pending_mnemonic(self, word: str, index: int):
@@ -81,16 +83,23 @@ def get_pending_mnemonic_word(self, index: int) -> str:
 
     def get_pending_mnemonic_fingerprint(self, network: str = SettingsConstants.MAINNET) -> str:
         try:
-            seed = Seed(self._pending_mnemonic)
+            if self._pending_is_electrum:
+                seed = ElectrumSeed(self._pending_mnemonic)
+            else:
+                seed = Seed(self._pending_mnemonic)
             return seed.get_fingerprint(network)
         except InvalidSeedException:
             return None
 
 
     def convert_pending_mnemonic_to_pending_seed(self):
-        self.pending_seed = Seed(self._pending_mnemonic)
+        if self._pending_is_electrum:
+            self.pending_seed = ElectrumSeed(self._pending_mnemonic)
+        else:
+            self.pending_seed = Seed(self._pending_mnemonic)
         self.discard_pending_mnemonic()
 
 
     def discard_pending_mnemonic(self):
         self._pending_mnemonic = []
+        self._pending_is_electrum = False

src/seedsigner/models/settings_definition.py

@@ -160,6 +160,7 @@ def map_network_to_embit(cls, network) -> str:
     SETTING__CAMERA_ROTATION = "camera_rotation"
     SETTING__COMPACT_SEEDQR = "compact_seedqr"
     SETTING__BIP85_CHILD_SEEDS = "bip85_child_seeds"
+    SETTING__ELECTRUM_SEEDS = "electrum_seeds"
     SETTING__MESSAGE_SIGNING = "message_signing"
     SETTING__PRIVACY_WARNINGS = "privacy_warnings"
     SETTING__DIRE_WARNINGS = "dire_warnings"
@@ -198,6 +199,15 @@ def map_network_to_embit(cls, network) -> str:
         TYPE__ENABLED_DISABLED_PROMPT_REQUIRED,
     ]
 
+    # Electrum seed constants
+    ELECTRUM_SEED_STANDARD = "01"
+    ELECTRUM_SEED_SEGWIT = "100"
+    ELECTRUM_SEED_2FA = "101"
+    ELECTRUM_PBKDF2_ROUNDS=2048
+
+    # Label strings
+    LABEL__BIP39_PASSPHRASE = "BIP-39 Passphrase"
+    LABEL__CUSTOM_EXTENSION = "Custom Extension"
 
 @dataclass
 class SettingsEntry:
@@ -458,6 +468,13 @@ class SettingsDefinition:
                       visibility=SettingsConstants.VISIBILITY__ADVANCED,
                       default_value=SettingsConstants.OPTION__DISABLED),
 
+        SettingsEntry(category=SettingsConstants.CATEGORY__FEATURES,
+                      attr_name=SettingsConstants.SETTING__ELECTRUM_SEEDS,
+                      abbreviated_name="Electrum",
+                      display_name="Electrum seed support (Native Segwit only)",
+                      visibility=SettingsConstants.VISIBILITY__ADVANCED,
+                      default_value=SettingsConstants.OPTION__DISABLED),
+
         SettingsEntry(category=SettingsConstants.CATEGORY__FEATURES,
                       attr_name=SettingsConstants.SETTING__MESSAGE_SIGNING,
                       display_name="Message signing",

src/seedsigner/views/psbt_views.py

@@ -17,6 +17,7 @@ class PSBTSelectSeedView(View):
     SCAN_SEED = ("Scan a seed", SeedSignerIconConstants.QRCODE)
     TYPE_12WORD = ("Enter 12-word seed", FontAwesomeIconConstants.KEYBOARD)
     TYPE_24WORD = ("Enter 24-word seed", FontAwesomeIconConstants.KEYBOARD)
+    TYPE_ELECTRUM = ("Enter Electrum seed", FontAwesomeIconConstants.KEYBOARD)
 
 
     def run(self):
@@ -44,6 +45,8 @@ def run(self):
         button_data.append(self.SCAN_SEED)
         button_data.append(self.TYPE_12WORD)
         button_data.append(self.TYPE_24WORD)
+        if self.settings.get_value(SettingsConstants.SETTING__ELECTRUM_SEEDS) == SettingsConstants.OPTION__ENABLED:
+            button_data.append(self.TYPE_ELECTRUM)
 
         selected_menu_num = self.run_screen(
             ButtonListScreen,
@@ -75,6 +78,18 @@ def run(self):
                 self.controller.storage.init_pending_mnemonic(num_words=24)
             return Destination(SeedMnemonicEntryView)
 
+        elif button_data[selected_menu_num] == self.TYPE_ELECTRUM:
+            self.run_screen(
+                    WarningScreen,
+                    title="Electrum warning",
+                    status_headline=None,
+                    text=f"Some features disabled for Electrum seeds",
+                    show_back_button=False,
+            )
+            from seedsigner.views.seed_views import SeedMnemonicEntryView
+            self.controller.storage.init_pending_mnemonic(num_words=12, is_electrum=True)
+            return Destination(SeedMnemonicEntryView)
+
 
 
 class PSBTOverviewView(View):