make pi dummy address resistent, refactoring

Author: kratm2

electrum/address_synchronizer.py

@@ -417,7 +417,8 @@ def remove_from_spent_outpoints():
                     scripthash = bitcoin.script_to_scripthash(txo.scriptpubkey)
                     prevout = TxOutpoint(bfh(tx_hash), idx)
                     self.db.remove_prevout_by_scripthash(scripthash, prevout=prevout, value=txo.value)
-                    self.db.remove_silent_payment_address(txo.address)
+                    if addr := txo.address:
+                        self.db.remove_silent_payment_address(addr)
         util.trigger_callback('adb_removed_tx', self, tx_hash, tx)
 
     def get_depending_transactions(self, tx_hash: str) -> Set[str]:

electrum/payment_identifier.py

@@ -278,20 +278,23 @@ def parse(self, text: str):
                     # no address, no bolt11 and no silent payment address, invalid
                     self.set_state(PaymentIdentifierState.INVALID)
                     return
-                elif self.bip21.get('address') == DummyAddress.SILENT_PAYMENT:
+                elif DummyAddress.is_dummy_address(self.bip21.get('address')):
                     self.set_state(PaymentIdentifierState.INVALID)
-                    return # user manually entered DummyAddress.SILENT_PAYMENT
+                    return # user manually entered DummyAddress
                 self.set_state(PaymentIdentifierState.AVAILABLE)
         elif self.parse_output(text)[0]:
-            scriptpubkey, is_address = self.parse_output(text)
-            if bitcoin.script_to_address(scriptpubkey) == DummyAddress.SILENT_PAYMENT:
-                sp_address = self.parse_address(text)
-                if sp_address == DummyAddress.SILENT_PAYMENT:
+            scriptpubkey, is_address, sp_addr = self.parse_output(text)
+            addr = bitcoin.script_to_address(scriptpubkey) if is_address else None
+            if addr == DummyAddress.SILENT_PAYMENT:
+                if sp_addr is None:
                     self.set_state(PaymentIdentifierState.INVALID) # user manually entered DummyAddress.SILENT_PAYMENT
                     return
-                self.sp_address = sp_address
+                self.sp_address = sp_addr
                 self._type = PaymentIdentifierType.SILENT_PAYMENT
             else:
+                if DummyAddress.is_dummy_address(addr):
+                    self.set_state(PaymentIdentifierState.INVALID) # user manually entered dummy lighting address
+                    return
                 self._type = PaymentIdentifierType.SPK
                 self.spk = scriptpubkey
                 self.spk_is_address = is_address
@@ -500,7 +503,7 @@ def get_onchain_outputs(self, amount, allow_silent_payment=True):
                 else:
                     address = sp_address  # use silent payment address
 
-            scriptpubkey, is_address = self.parse_output(address)
+            scriptpubkey, is_address, _ = self.parse_output(address)
             assert is_address  # unlikely, but make sure it is an address, not a script
             output = PartialTxOutput(scriptpubkey=scriptpubkey, value=amount)
             if output.address == DummyAddress.SILENT_PAYMENT:
@@ -543,30 +546,34 @@ def parse_address_and_amount(self, line: str) -> PartialTxOutput:
             x, y = line.split(',')
         except ValueError:
             raise Exception("expected two comma-separated values: (address, amount)") from None
-        scriptpubkey, is_address = self.parse_output(x)
+        scriptpubkey, is_address, sp_addr = self.parse_output(x)
         if not scriptpubkey:
             raise Exception('Invalid address')
         amount = self.parse_amount(y)
         output = PartialTxOutput(scriptpubkey=scriptpubkey, value=amount)
         if output.address == DummyAddress.SILENT_PAYMENT:
-            output.sp_addr = SilentPaymentAddress(self.parse_address(x)) # maybe parsing again isn't needed
+            output.sp_addr = SilentPaymentAddress(sp_addr) # raises if user entered manually silent-dummy-addr -> invalid
+        elif DummyAddress.is_dummy_address(output.address):
+            raise Exception('user manually entered dummy address')
         return output
 
-    def parse_output(self, x: str) -> Tuple[Optional[bytes], bool]:
+    def parse_output(self, x: str) -> Tuple[Optional[bytes], bool, Optional[str]]:
         try:
             address = self.parse_address(x)
+            sp_addr = None
             if is_silent_payment_address(address):
+                sp_addr = address
                 address = DummyAddress.SILENT_PAYMENT
-            return bitcoin.address_to_script(address), True
+            return bitcoin.address_to_script(address), True, sp_addr
         except Exception as e:
             pass
         try:
             m = re.match('^' + RE_SCRIPT_FN + '$', x)
             script = self.parse_script(str(m.group(1)))
-            return script, False
+            return script, False, None
         except Exception as e:
             pass
-        return None, False
+        return None, False, None
 
     def parse_script(self, x: str) -> bytes:
         script = bytearray()

tests/test_payment_identifier.py

@@ -4,12 +4,12 @@
 from electrum.bip21 import MissingFallbackAddress
 from electrum.invoices import Invoice
 from electrum.payment_identifier import (maybe_extract_lightning_payment_identifier, PaymentIdentifier,
-                                         PaymentIdentifierType, invoice_from_payment_identifier)
+                                         PaymentIdentifierType, invoice_from_payment_identifier, PaymentIdentifierState)
 from electrum.wallet import restore_wallet_from_text
 
 from . import ElectrumTestCase
 from electrum.transaction import PartialTxOutput
-from electrum.bitcoin import script_to_address, DummyAddress
+from electrum.bitcoin import DummyAddress
 
 
 class WalletMock:
@@ -403,3 +403,15 @@ def test_silent_payment_bip21(self):
             pi.get_onchain_outputs(0, allow_silent_payment=False)[0].address,
             '1RustyRX2oai4EYYDpQGWvEL62BBGqN9T'
         )
+
+    def test_dummy_address_abuse(self):
+        for dummy_addr in [DummyAddress.SILENT_PAYMENT, DummyAddress.SWAP, DummyAddress.CHANNEL]:
+            for pi_str in [
+                dummy_addr,  # spk/silent payment
+                f"1RustyRX2oai4EYYDpQGWvEL62BBGqN9T,2\n{dummy_addr}, 5",  # multiline
+                f"bitcoin:{dummy_addr}",  # bip21
+            ]:
+                pi = PaymentIdentifier(self.wallet, pi_str)
+                self.assertEqual(pi.state, PaymentIdentifierState.INVALID)
+
+