paymentrequest.py (18103B)
1 #!/usr/bin/env python 2 # 3 # Electrum - lightweight Bitcoin client 4 # Copyright (C) 2014 Thomas Voegtlin 5 # 6 # Permission is hereby granted, free of charge, to any person 7 # obtaining a copy of this software and associated documentation files 8 # (the "Software"), to deal in the Software without restriction, 9 # including without limitation the rights to use, copy, modify, merge, 10 # publish, distribute, sublicense, and/or sell copies of the Software, 11 # and to permit persons to whom the Software is furnished to do so, 12 # subject to the following conditions: 13 # 14 # The above copyright notice and this permission notice shall be 15 # included in all copies or substantial portions of the Software. 16 # 17 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 18 # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 19 # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 20 # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 21 # BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 22 # ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 23 # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 24 # SOFTWARE. 25 import hashlib 26 import sys 27 import time 28 from typing import Optional, List, TYPE_CHECKING 29 import asyncio 30 import urllib.parse 31 32 import certifi 33 import aiohttp 34 35 36 try: 37 from . import paymentrequest_pb2 as pb2 38 except ImportError: 39 # sudo apt-get install protobuf-compiler 40 sys.exit("Error: could not find paymentrequest_pb2.py. Create it with 'protoc --proto_path=electrum/ --python_out=electrum/ electrum/paymentrequest.proto'") 41 42 from . import bitcoin, constants, ecc, util, transaction, x509, rsakey 43 from .util import bh2u, bfh, make_aiohttp_session 44 from .invoices import OnchainInvoice 45 from .crypto import sha256 46 from .bitcoin import address_to_script 47 from .transaction import PartialTxOutput 48 from .network import Network 49 from .logging import get_logger, Logger 50 51 if TYPE_CHECKING: 52 from .simple_config import SimpleConfig 53 54 55 _logger = get_logger(__name__) 56 57 58 REQUEST_HEADERS = {'Accept': 'application/bitcoin-paymentrequest', 'User-Agent': 'Electrum'} 59 ACK_HEADERS = {'Content-Type':'application/bitcoin-payment','Accept':'application/bitcoin-paymentack','User-Agent':'Electrum'} 60 61 ca_path = certifi.where() 62 ca_list = None 63 ca_keyID = None 64 65 def load_ca_list(): 66 global ca_list, ca_keyID 67 if ca_list is None: 68 ca_list, ca_keyID = x509.load_certificates(ca_path) 69 70 71 72 73 async def get_payment_request(url: str) -> 'PaymentRequest': 74 u = urllib.parse.urlparse(url) 75 error = None 76 if u.scheme in ('http', 'https'): 77 resp_content = None 78 try: 79 proxy = Network.get_instance().proxy 80 async with make_aiohttp_session(proxy, headers=REQUEST_HEADERS) as session: 81 async with session.get(url) as response: 82 resp_content = await response.read() 83 response.raise_for_status() 84 # Guard against `bitcoin:`-URIs with invalid payment request URLs 85 if "Content-Type" not in response.headers \ 86 or response.headers["Content-Type"] != "application/bitcoin-paymentrequest": 87 data = None 88 error = "payment URL not pointing to a payment request handling server" 89 else: 90 data = resp_content 91 data_len = len(data) if data is not None else None 92 _logger.info(f'fetched payment request {url} {data_len}') 93 except (aiohttp.ClientError, asyncio.TimeoutError) as e: 94 error = f"Error while contacting payment URL: {url}.\nerror type: {type(e)}" 95 if isinstance(e, aiohttp.ClientResponseError): 96 error += f"\nGot HTTP status code {e.status}." 97 if resp_content: 98 try: 99 error_text_received = resp_content.decode("utf8") 100 except UnicodeDecodeError: 101 error_text_received = "(failed to decode error)" 102 else: 103 error_text_received = error_text_received[:400] 104 error_oneline = ' -- '.join(error.split('\n')) 105 _logger.info(f"{error_oneline} -- [DO NOT TRUST THIS MESSAGE] " 106 f"{repr(e)} text: {error_text_received}") 107 data = None 108 elif u.scheme == 'file': 109 try: 110 with open(u.path, 'r', encoding='utf-8') as f: 111 data = f.read() 112 except IOError: 113 data = None 114 error = "payment URL not pointing to a valid file" 115 else: 116 data = None 117 error = f"Unknown scheme for payment request. URL: {url}" 118 pr = PaymentRequest(data, error=error) 119 return pr 120 121 122 class PaymentRequest: 123 124 def __init__(self, data, *, error=None): 125 self.raw = data 126 self.error = error # FIXME overloaded and also used when 'verify' succeeds 127 self.parse(data) 128 self.requestor = None # known after verify 129 self.tx = None 130 131 def __str__(self): 132 return str(self.raw) 133 134 def parse(self, r): 135 self.outputs = [] # type: List[PartialTxOutput] 136 if self.error: 137 return 138 self.id = bh2u(sha256(r)[0:16]) 139 try: 140 self.data = pb2.PaymentRequest() 141 self.data.ParseFromString(r) 142 except: 143 self.error = "cannot parse payment request" 144 return 145 self.details = pb2.PaymentDetails() 146 self.details.ParseFromString(self.data.serialized_payment_details) 147 pr_network = self.details.network 148 client_network = 'test' if constants.net.TESTNET else 'main' 149 if pr_network != client_network: 150 self.error = (f'Payment request network "{pr_network}" does not' 151 f' match client network "{client_network}".') 152 return 153 for o in self.details.outputs: 154 addr = transaction.get_address_from_output_script(o.script) 155 if not addr: 156 # TODO maybe rm restriction but then get_requestor and get_id need changes 157 self.error = "only addresses are allowed as outputs" 158 return 159 self.outputs.append(PartialTxOutput.from_address_and_value(addr, o.amount)) 160 self.memo = self.details.memo 161 self.payment_url = self.details.payment_url 162 163 def verify(self, contacts): 164 if self.error: 165 return False 166 if not self.raw: 167 self.error = "Empty request" 168 return False 169 pr = pb2.PaymentRequest() 170 try: 171 pr.ParseFromString(self.raw) 172 except: 173 self.error = "Error: Cannot parse payment request" 174 return False 175 if not pr.signature: 176 # the address will be displayed as requestor 177 self.requestor = None 178 return True 179 if pr.pki_type in ["x509+sha256", "x509+sha1"]: 180 return self.verify_x509(pr) 181 elif pr.pki_type in ["dnssec+btc", "dnssec+ecdsa"]: 182 return self.verify_dnssec(pr, contacts) 183 else: 184 self.error = "ERROR: Unsupported PKI Type for Message Signature" 185 return False 186 187 def verify_x509(self, paymntreq): 188 load_ca_list() 189 if not ca_list: 190 self.error = "Trusted certificate authorities list not found" 191 return False 192 cert = pb2.X509Certificates() 193 cert.ParseFromString(paymntreq.pki_data) 194 # verify the chain of certificates 195 try: 196 x, ca = verify_cert_chain(cert.certificate) 197 except BaseException as e: 198 _logger.exception('') 199 self.error = str(e) 200 return False 201 # get requestor name 202 self.requestor = x.get_common_name() 203 if self.requestor.startswith('*.'): 204 self.requestor = self.requestor[2:] 205 # verify the BIP70 signature 206 pubkey0 = rsakey.RSAKey(x.modulus, x.exponent) 207 sig = paymntreq.signature 208 paymntreq.signature = b'' 209 s = paymntreq.SerializeToString() 210 sigBytes = bytearray(sig) 211 msgBytes = bytearray(s) 212 if paymntreq.pki_type == "x509+sha256": 213 hashBytes = bytearray(hashlib.sha256(msgBytes).digest()) 214 verify = pubkey0.verify(sigBytes, x509.PREFIX_RSA_SHA256 + hashBytes) 215 elif paymntreq.pki_type == "x509+sha1": 216 verify = pubkey0.hashAndVerify(sigBytes, msgBytes) 217 else: 218 self.error = f"ERROR: unknown pki_type {paymntreq.pki_type} in Payment Request" 219 return False 220 if not verify: 221 self.error = "ERROR: Invalid Signature for Payment Request Data" 222 return False 223 ### SIG Verified 224 self.error = 'Signed by Trusted CA: ' + ca.get_common_name() 225 return True 226 227 def verify_dnssec(self, pr, contacts): 228 sig = pr.signature 229 alias = pr.pki_data 230 info = contacts.resolve(alias) 231 if info.get('validated') is not True: 232 self.error = "Alias verification failed (DNSSEC)" 233 return False 234 if pr.pki_type == "dnssec+btc": 235 self.requestor = alias 236 address = info.get('address') 237 pr.signature = b'' 238 message = pr.SerializeToString() 239 if ecc.verify_message_with_address(address, sig, message): 240 self.error = 'Verified with DNSSEC' 241 return True 242 else: 243 self.error = "verify failed" 244 return False 245 else: 246 self.error = "unknown algo" 247 return False 248 249 def has_expired(self) -> Optional[bool]: 250 if not hasattr(self, 'details'): 251 return None 252 return self.details.expires and self.details.expires < int(time.time()) 253 254 def get_time(self): 255 return self.details.time 256 257 def get_expiration_date(self): 258 return self.details.expires 259 260 def get_amount(self): 261 return sum(map(lambda x:x.value, self.outputs)) 262 263 def get_address(self): 264 o = self.outputs[0] 265 addr = o.address 266 assert addr 267 return addr 268 269 def get_requestor(self): 270 return self.requestor if self.requestor else self.get_address() 271 272 def get_verify_status(self): 273 return self.error if self.requestor else "No Signature" 274 275 def get_memo(self): 276 return self.memo 277 278 def get_id(self): 279 return self.id if self.requestor else self.get_address() 280 281 def get_outputs(self): 282 return self.outputs[:] 283 284 async def send_payment_and_receive_paymentack(self, raw_tx, refund_addr): 285 pay_det = self.details 286 if not self.details.payment_url: 287 return False, "no url" 288 paymnt = pb2.Payment() 289 paymnt.merchant_data = pay_det.merchant_data 290 paymnt.transactions.append(bfh(raw_tx)) 291 ref_out = paymnt.refund_to.add() 292 ref_out.script = util.bfh(address_to_script(refund_addr)) 293 paymnt.memo = "Paid using Electrum" 294 pm = paymnt.SerializeToString() 295 payurl = urllib.parse.urlparse(pay_det.payment_url) 296 resp_content = None 297 try: 298 proxy = Network.get_instance().proxy 299 async with make_aiohttp_session(proxy, headers=ACK_HEADERS) as session: 300 async with session.post(payurl.geturl(), data=pm) as response: 301 resp_content = await response.read() 302 response.raise_for_status() 303 try: 304 paymntack = pb2.PaymentACK() 305 paymntack.ParseFromString(resp_content) 306 except Exception: 307 return False, "PaymentACK could not be processed. Payment was sent; please manually verify that payment was received." 308 print(f"PaymentACK message received: {paymntack.memo}") 309 return True, paymntack.memo 310 except aiohttp.ClientError as e: 311 error = f"Payment Message/PaymentACK Failed:\nerror type: {type(e)}" 312 if isinstance(e, aiohttp.ClientResponseError): 313 error += f"\nGot HTTP status code {e.status}." 314 if resp_content: 315 try: 316 error_text_received = resp_content.decode("utf8") 317 except UnicodeDecodeError: 318 error_text_received = "(failed to decode error)" 319 else: 320 error_text_received = error_text_received[:400] 321 error_oneline = ' -- '.join(error.split('\n')) 322 _logger.info(f"{error_oneline} -- [DO NOT TRUST THIS MESSAGE] " 323 f"{repr(e)} text: {error_text_received}") 324 return False, error 325 326 327 def make_unsigned_request(req: 'OnchainInvoice'): 328 addr = req.get_address() 329 time = req.time 330 exp = req.exp 331 if time and type(time) != int: 332 time = 0 333 if exp and type(exp) != int: 334 exp = 0 335 amount = req.amount_sat 336 if amount is None: 337 amount = 0 338 memo = req.message 339 script = bfh(address_to_script(addr)) 340 outputs = [(script, amount)] 341 pd = pb2.PaymentDetails() 342 if constants.net.TESTNET: 343 pd.network = 'test' 344 for script, amount in outputs: 345 pd.outputs.add(amount=amount, script=script) 346 pd.time = time 347 pd.expires = time + exp if exp else 0 348 pd.memo = memo 349 pr = pb2.PaymentRequest() 350 pr.serialized_payment_details = pd.SerializeToString() 351 pr.signature = util.to_bytes('') 352 return pr 353 354 355 def sign_request_with_alias(pr, alias, alias_privkey): 356 pr.pki_type = 'dnssec+btc' 357 pr.pki_data = str(alias) 358 message = pr.SerializeToString() 359 ec_key = ecc.ECPrivkey(alias_privkey) 360 compressed = bitcoin.is_compressed_privkey(alias_privkey) 361 pr.signature = ec_key.sign_message(message, compressed) 362 363 364 def verify_cert_chain(chain): 365 """ Verify a chain of certificates. The last certificate is the CA""" 366 load_ca_list() 367 # parse the chain 368 cert_num = len(chain) 369 x509_chain = [] 370 for i in range(cert_num): 371 x = x509.X509(bytearray(chain[i])) 372 x509_chain.append(x) 373 if i == 0: 374 x.check_date() 375 else: 376 if not x.check_ca(): 377 raise Exception("ERROR: Supplied CA Certificate Error") 378 if not cert_num > 1: 379 raise Exception("ERROR: CA Certificate Chain Not Provided by Payment Processor") 380 # if the root CA is not supplied, add it to the chain 381 ca = x509_chain[cert_num-1] 382 if ca.getFingerprint() not in ca_list: 383 keyID = ca.get_issuer_keyID() 384 f = ca_keyID.get(keyID) 385 if f: 386 root = ca_list[f] 387 x509_chain.append(root) 388 else: 389 raise Exception("Supplied CA Not Found in Trusted CA Store.") 390 # verify the chain of signatures 391 cert_num = len(x509_chain) 392 for i in range(1, cert_num): 393 x = x509_chain[i] 394 prev_x = x509_chain[i-1] 395 algo, sig, data = prev_x.get_signature() 396 sig = bytearray(sig) 397 pubkey = rsakey.RSAKey(x.modulus, x.exponent) 398 if algo == x509.ALGO_RSA_SHA1: 399 verify = pubkey.hashAndVerify(sig, data) 400 elif algo == x509.ALGO_RSA_SHA256: 401 hashBytes = bytearray(hashlib.sha256(data).digest()) 402 verify = pubkey.verify(sig, x509.PREFIX_RSA_SHA256 + hashBytes) 403 elif algo == x509.ALGO_RSA_SHA384: 404 hashBytes = bytearray(hashlib.sha384(data).digest()) 405 verify = pubkey.verify(sig, x509.PREFIX_RSA_SHA384 + hashBytes) 406 elif algo == x509.ALGO_RSA_SHA512: 407 hashBytes = bytearray(hashlib.sha512(data).digest()) 408 verify = pubkey.verify(sig, x509.PREFIX_RSA_SHA512 + hashBytes) 409 else: 410 raise Exception("Algorithm not supported: {}".format(algo)) 411 if not verify: 412 raise Exception("Certificate not Signed by Provided CA Certificate Chain") 413 414 return x509_chain[0], ca 415 416 417 def check_ssl_config(config): 418 from . import pem 419 key_path = config.get('ssl_keyfile') 420 cert_path = config.get('ssl_certfile') 421 with open(key_path, 'r', encoding='utf-8') as f: 422 params = pem.parse_private_key(f.read()) 423 with open(cert_path, 'r', encoding='utf-8') as f: 424 s = f.read() 425 bList = pem.dePemList(s, "CERTIFICATE") 426 # verify chain 427 x, ca = verify_cert_chain(bList) 428 # verify that privkey and pubkey match 429 privkey = rsakey.RSAKey(*params) 430 pubkey = rsakey.RSAKey(x.modulus, x.exponent) 431 assert x.modulus == params[0] 432 assert x.exponent == params[1] 433 # return requestor 434 requestor = x.get_common_name() 435 if requestor.startswith('*.'): 436 requestor = requestor[2:] 437 return requestor 438 439 def sign_request_with_x509(pr, key_path, cert_path): 440 from . import pem 441 with open(key_path, 'r', encoding='utf-8') as f: 442 params = pem.parse_private_key(f.read()) 443 privkey = rsakey.RSAKey(*params) 444 with open(cert_path, 'r', encoding='utf-8') as f: 445 s = f.read() 446 bList = pem.dePemList(s, "CERTIFICATE") 447 certificates = pb2.X509Certificates() 448 certificates.certificate.extend(map(bytes, bList)) 449 pr.pki_type = 'x509+sha256' 450 pr.pki_data = certificates.SerializeToString() 451 msgBytes = bytearray(pr.SerializeToString()) 452 hashBytes = bytearray(hashlib.sha256(msgBytes).digest()) 453 sig = privkey.sign(x509.PREFIX_RSA_SHA256 + hashBytes) 454 pr.signature = bytes(sig) 455 456 457 def serialize_request(req): # FIXME this is broken 458 pr = make_unsigned_request(req) 459 signature = req.get('sig') 460 requestor = req.get('name') 461 if requestor and signature: 462 pr.signature = bfh(signature) 463 pr.pki_type = 'dnssec+btc' 464 pr.pki_data = str(requestor) 465 return pr 466 467 468 def make_request(config: 'SimpleConfig', req: 'OnchainInvoice'): 469 pr = make_unsigned_request(req) 470 key_path = config.get('ssl_keyfile') 471 cert_path = config.get('ssl_certfile') 472 if key_path and cert_path: 473 sign_request_with_x509(pr, key_path, cert_path) 474 return pr