[Author Prev][Author Next][Thread Prev][Thread Next][Author Index][Thread Index]
[tor-commits] [flashproxy/master] move common functionality and command-line options into flashproxy-common
commit badb39f9c13497a7887bac4ac24210ec12be9e39
Author: Ximin Luo <infinity0@xxxxxxxxxxxxxx>
Date: Thu Feb 13 16:45:09 2014 +0000
move common functionality and command-line options into flashproxy-common
- move keys.DEFAULT_FACILITATOR_PUBKEY_PEM into new reg module to be with other default-facilitator data
---
flashproxy-client | 37 +++--------------
flashproxy-reg-appspot | 97 ++++++---------------------------------------
flashproxy-reg-email | 103 +++++++-----------------------------------------
flashproxy-reg-http | 69 ++++----------------------------
flashproxy-reg-url | 65 ++++--------------------------
flashproxy/keys.py | 47 ++++++++++++++--------
flashproxy/reg.py | 59 ++++++++++++++++++++++++++-
flashproxy/util.py | 38 ++++++++++++++++++
8 files changed, 177 insertions(+), 338 deletions(-)
diff --git a/flashproxy-client b/flashproxy-client
index 9e198a4..b69d1bf 100755
--- a/flashproxy-client
+++ b/flashproxy-client
@@ -8,6 +8,7 @@ import BaseHTTPServer
import array
import base64
import cStringIO
+import flashproxy
import os
import os.path
import select
@@ -19,7 +20,8 @@ import threading
import time
import traceback
-from flashproxy.util import parse_addr_spec, addr_family, format_addr
+from flashproxy.util import parse_addr_spec, addr_family, format_addr, safe_str, safe_format_addr
+from flashproxy.reg import DEFAULT_TRANSPORT
from hashlib import sha1
@@ -35,7 +37,6 @@ DEFAULT_LOCAL_PORT_EXTERNAL = 9001
DEFAULT_REMOTE_PORT = 9000
DEFAULT_REGISTER_METHODS = ["appspot", "email", "http"]
DEFAULT_PORT_FORWARDING_HELPER = "tor-fw-helper"
-DEFAULT_TRANSPORT = "websocket"
# We will re-register if we have fewer than this many waiting proxies. The
# facilitator may choose to ignore our requests.
@@ -71,22 +72,12 @@ class options(object):
facilitator_url = None
facilitator_pubkey_filename = None
-def safe_str(s):
- """Return "[scrubbed]" if options.safe_logging is true, and s otherwise."""
- if options.safe_logging:
- return "[scrubbed]"
- else:
- return s
-
log_lock = threading.Lock()
def log(msg):
with log_lock:
print >> options.log_file, (u"%s %s" % (time.strftime(LOG_DATE_FORMAT), msg)).encode("UTF-8")
options.log_file.flush()
-def safe_format_addr(addr):
- return safe_str(format_addr(addr))
-
def format_sockaddr(sockaddr):
host, port = socket.getnameinfo(sockaddr, socket.NI_NUMERICHOST | socket.NI_NUMERICSERV)
port = int(port)
@@ -1036,19 +1027,8 @@ The -4, -6, --unsafe-logging, --transport and --facilitator-pubkey options are
propagated to the child registration helpers. For backwards compatilibility,
the --facilitator option is also propagated to the http registration helper.
If you need to pass more options, use TODO #9976.""")
- # common opts
- parser.add_argument("-4", help="name lookups use only IPv4.",
- action="store_const", const=socket.AF_INET, dest="address_family")
- parser.add_argument("-6", help="name lookups use only IPv6.",
- action="store_const", const=socket.AF_INET6, dest="address_family")
- parser.add_argument("--unsafe-logging", help="don't scrub IP addresses and "
- "other sensitive information from logs.", action="store_true")
- parser.add_argument("--facilitator-pubkey", help="encrypt registrations to "
- "the given PEM-formatted public key file (default built-in).",
- metavar='FILENAME')
- parser.add_argument("--transport",
- help="register using the given transport, default %(default)s.",
- default=DEFAULT_TRANSPORT)
+ flashproxy.util.add_module_opts(parser)
+ flashproxy.reg.add_module_opts(parser)
parser.add_argument("-f", "--facilitator", metavar="URL",
help="register with the facilitator at this URL, default %(default)s. "
"This is passed to the http registration ONLY.")
@@ -1090,12 +1070,7 @@ If you need to pass more options, use TODO #9976.""")
ns = parser.parse_args(sys.argv[1:])
# set registration options
- options.address_family = ns.address_family or socket.AF_UNSPEC
- if options.address_family != socket.AF_UNSPEC:
- getaddrinfo = socket.getaddrinfo
- def getaddrinfo_replacement(host, port, family, *args, **kwargs):
- return getaddrinfo(host, port, options.address_family, *args, **kwargs)
- socket.getaddrinfo = getaddrinfo_replacement
+ options.address_family = ns.address_family
options.transport = ns.transport
options.safe_logging = not ns.unsafe_logging
options.facilitator_url = ns.facilitator
diff --git a/flashproxy-reg-appspot b/flashproxy-reg-appspot
index f0e4714..42aef97 100755
--- a/flashproxy-reg-appspot
+++ b/flashproxy-reg-appspot
@@ -2,16 +2,16 @@
"""Register with a facilitator through Google App Engine."""
import argparse
+import flashproxy
import httplib
-import os
import socket
-import subprocess
import sys
import urlparse
import urllib2
from flashproxy.keys import PIN_GOOGLE_CA_CERT, PIN_GOOGLE_PUBKEY_SHA1, check_certificate_pin, ensure_M2Crypto, temp_cert
-from flashproxy.util import parse_addr_spec, format_addr
+from flashproxy.reg import build_reg_b64enc
+from flashproxy.util import parse_addr_spec, safe_str, safe_format_addr
try:
from M2Crypto import SSL
@@ -19,54 +19,11 @@ except ImportError:
# Defer the error reporting so that --help works even without M2Crypto.
pass
-DEFAULT_REMOTE = ("", 9000)
-DEFAULT_TRANSPORT = "websocket"
-
# The domain to which requests appear to go.
FRONT_DOMAIN = "www.google.com"
# The value of the Host header within requests.
TARGET_DOMAIN = "fp-reg-a.appspot.com"
-FLASHPROXY_REG_URL = "flashproxy-reg-url"
-
-class options(object):
- address_family = socket.AF_UNSPEC
- use_certificate_pin = True
- facilitator_pubkey_filename = None
- transport = DEFAULT_TRANSPORT
- safe_logging = True
-
-def safe_str(s):
- """Return "[scrubbed]" if options.safe_logging is true, and s otherwise."""
- if options.safe_logging:
- return "[scrubbed]"
- else:
- return s
-
-def safe_format_addr(addr):
- return safe_str(format_addr(addr))
-
-def generate_url(addr):
- if getattr(sys, "frozen", False):
- script_dir = os.path.dirname(sys.executable)
- else:
- script_dir = sys.path[0]
- if not script_dir:
- # Maybe the script was read from stdin; in any case don't guess at the directory.
- raise ValueError("Can't find executable directory for registration helpers")
- command = [os.path.join(script_dir, FLASHPROXY_REG_URL)]
- command += ["-f", urlparse.urlunparse(("https", FRONT_DOMAIN, "/", "", "", ""))]
- if options.transport is not None:
- command += ["--transport", options.transport]
- if options.facilitator_pubkey_filename is not None:
- command += ["--facilitator-pubkey", options.facilitator_pubkey_filename]
- command.append(format_addr(addr))
- p = subprocess.Popen(command, stdout=subprocess.PIPE)
- stdout, stderr = p.communicate()
- if p.returncode != 0:
- raise ValueError("%s exited with status %d" % (FLASHPROXY_REG_URL, p.returncode))
- return stdout.strip()
-
# Like socket.create_connection in that it tries resolving different address
# families, but doesn't connect the socket.
def create_socket(address, timeout = None):
@@ -105,8 +62,7 @@ class PinHTTPSConnection(httplib.HTTPSConnection):
self.sock = SSL.Connection(ctx, sock)
self.sock.connect((self.host, self.port))
- if options.use_certificate_pin:
- check_certificate_pin(self.sock, PIN_GOOGLE_PUBKEY_SHA1)
+ check_certificate_pin(self.sock, PIN_GOOGLE_PUBKEY_SHA1)
class PinHTTPSHandler(urllib2.HTTPSHandler):
def https_open(self, req):
@@ -130,40 +86,12 @@ parser = argparse.ArgumentParser(
description="Register with a facilitator through a Google App Engine app. "
"If only the external port is given, the remote server guesses our "
"external address.")
-# common opts
-parser.add_argument("-4", help="name lookups use only IPv4.",
- action="store_const", const=socket.AF_INET, dest="address_family")
-parser.add_argument("-6", help="name lookups use only IPv6.",
- action="store_const", const=socket.AF_INET6, dest="address_family")
-parser.add_argument("--unsafe-logging", help="don't scrub IP addresses and "
- "other sensitive information from logs.", action="store_true")
-parser.add_argument("--disable-pin", help="disable all certificate pinning "
- "checks", action="store_true",)
-parser.add_argument("--facilitator-pubkey", help="encrypt registrations to "
- "the given PEM-formatted public key file (default built-in).",
- metavar='FILENAME')
-parser.add_argument("--transport",
- help="register using the given transport, default %(default)s.",
- default=DEFAULT_TRANSPORT)
-# common args
-parser.add_argument("remote_addr",
- help="remote to register, default %s - the external IP address is guessed."
- % format_addr(DEFAULT_REMOTE),
- metavar="REMOTE:PORT", default="", nargs="?",
- type=lambda x: parse_addr_spec(x, *DEFAULT_REMOTE))
-
-ns = parser.parse_args(sys.argv[1:])
-options.address_family = ns.address_family or socket.AF_UNSPEC
-if options.address_family != socket.AF_UNSPEC:
- getaddrinfo = socket.getaddrinfo
- def getaddrinfo_replacement(host, port, family, *args, **kwargs):
- return getaddrinfo(host, port, options.address_family, *args, **kwargs)
- socket.getaddrinfo = getaddrinfo_replacement
-options.safe_logging = not ns.unsafe_logging
-options.use_certificate_pin = not ns.disable_pin
-options.facilitator_pubkey_filename = ns.facilitator_pubkey
-options.transport = ns.transport
-remote_addr = ns.remote_addr
+flashproxy.util.add_module_opts(parser)
+flashproxy.keys.add_module_opts(parser)
+flashproxy.reg.add_registration_args(parser)
+
+options = parser.parse_args(sys.argv[1:])
+remote_addr = options.remote_addr
ensure_M2Crypto()
@@ -186,9 +114,10 @@ if not remote_addr[0]:
sys.exit(1)
try:
- url = generate_url(remote_addr)
+ reg = build_reg_b64enc(remote_addr, options.transport, urlsafe=True)
+ url = urlparse.urljoin(urlparse.urlunparse(("https", FRONT_DOMAIN, "/", "", "", "")), "reg/" + reg)
except Exception, e:
- print >> sys.stderr, "Error running %s: %s" % (FLASHPROXY_REG_URL, str(e))
+ print >> sys.stderr, "Error generating URL: %s" % str(e)
sys.exit(1)
try:
diff --git a/flashproxy-reg-email b/flashproxy-reg-email
index a151efd..ddfc9fa 100755
--- a/flashproxy-reg-email
+++ b/flashproxy-reg-email
@@ -2,66 +2,30 @@
"""Register with a facilitator using the email method."""
import argparse
+import flashproxy
import os
import re
import smtplib
-import socket
import sys
-import urllib
-from flashproxy.keys import PIN_GOOGLE_CA_CERT, PIN_GOOGLE_PUBKEY_SHA1, DEFAULT_FACILITATOR_PUBKEY_PEM, check_certificate_pin, ensure_M2Crypto, temp_cert
-from flashproxy.util import parse_addr_spec, format_addr
+from flashproxy.keys import PIN_GOOGLE_CA_CERT, PIN_GOOGLE_PUBKEY_SHA1, check_certificate_pin, ensure_M2Crypto, temp_cert
+from flashproxy.reg import build_reg_b64enc
+from flashproxy.util import parse_addr_spec, format_addr, safe_format_addr
try:
- from M2Crypto import BIO, RSA, SSL
+ from M2Crypto import SSL
except ImportError:
# Defer the error reporting so that --help works even without M2Crypto.
pass
-DEFAULT_REMOTE = ("", 9000)
DEFAULT_EMAIL_ADDRESS = "flashproxyreg.a@xxxxxxxxx"
# dig MX gmail.com
DEFAULT_SMTP = ("gmail-smtp-in.l.google.com", 25)
-DEFAULT_TRANSPORT = "websocket"
# Use this to prevent Python smtplib from guessing and leaking our hostname.
EHLO_FQDN = "[127.0.0.1]"
FROM_EMAIL_ADDRESS = "nobody@localhost"
-class options(object):
- remote_addr = None
-
- address_family = socket.AF_UNSPEC
- debug = False
- use_certificate_pin = True
- email_addr = None
- facilitator_pubkey_filename = None
- smtp_addr = None
- transport = DEFAULT_TRANSPORT
- safe_logging = True
-
-def safe_str(s):
- """Return "[scrubbed]" if options.safe_logging is true, and s otherwise."""
- if options.safe_logging:
- return "[scrubbed]"
- else:
- return s
-
-def safe_format_addr(addr):
- return safe_str(format_addr(addr))
-
-def build_reg(addr, transport):
- return urllib.urlencode((
- ("client", format_addr(addr)),
- ("client-transport", transport),
- ))
-
-def get_facilitator_pubkey():
- if options.facilitator_pubkey_filename is not None:
- return RSA.load_pub_key(options.facilitator_pubkey_filename)
- else:
- return RSA.load_pub_key_bio(BIO.MemoryBuffer(DEFAULT_FACILITATOR_PUBKEY_PEM))
-
parser = argparse.ArgumentParser(
usage="%(prog)s [OPTIONS] [REMOTE][:PORT]",
description="Register with a flash proxy facilitator through email. Makes "
@@ -71,27 +35,9 @@ parser = argparse.ArgumentParser(
epilog="Using an SMTP server or email address other than the defaults will "
"not work unless you have made special arrangements to connect them to a "
"facilitator.")
-# common opts
-parser.add_argument("-4", help="name lookups use only IPv4.",
- action="store_const", const=socket.AF_INET, dest="address_family")
-parser.add_argument("-6", help="name lookups use only IPv6.",
- action="store_const", const=socket.AF_INET6, dest="address_family")
-parser.add_argument("--unsafe-logging", help="don't scrub IP addresses and "
- "other sensitive information from logs.", action="store_true")
-parser.add_argument("--disable-pin", help="disable all certificate pinning "
- "checks", action="store_true",)
-parser.add_argument("--facilitator-pubkey", help="encrypt registrations to "
- "the given PEM-formatted public key file (default built-in).",
- metavar='FILENAME')
-parser.add_argument("--transport",
- help="register using the given transport, default %(default)s.",
- default=DEFAULT_TRANSPORT)
-# common args
-parser.add_argument("remote_addr",
- help="remote to register, default %s - the external IP address is guessed."
- % format_addr(DEFAULT_REMOTE),
- metavar="REMOTE:PORT", default="", nargs="?",
- type=lambda x: parse_addr_spec(x, *DEFAULT_REMOTE))
+flashproxy.util.add_module_opts(parser)
+flashproxy.keys.add_module_opts(parser)
+flashproxy.reg.add_registration_args(parser)
# specific opts
parser.add_argument("-e", "--email", metavar="ADDRESS",
help="send mail to ADDRESS, default %(default)s.",
@@ -103,26 +49,11 @@ parser.add_argument("-d", "--debug",
help="enable debugging output (Python smtplib messages).",
action="store_true")
-ns = parser.parse_args(sys.argv[1:])
-options.address_family = ns.address_family or socket.AF_UNSPEC
-if options.address_family != socket.AF_UNSPEC:
- getaddrinfo = socket.getaddrinfo
- def getaddrinfo_replacement(host, port, family, *args, **kwargs):
- return getaddrinfo(host, port, options.address_family, *args, **kwargs)
- socket.getaddrinfo = getaddrinfo_replacement
-options.safe_logging = not ns.unsafe_logging
-options.use_certificate_pin = not ns.disable_pin
-options.facilitator_pubkey_filename = ns.facilitator_pubkey
-options.transport = ns.transport
-options.remote_addr = ns.remote_addr
-# specific parsing
-options.email_addr = ns.email
-options.smtp_addr = ns.smtp
-options.debug = ns.debug
+options = parser.parse_args(sys.argv[1:])
ensure_M2Crypto()
-smtp = smtplib.SMTP(options.smtp_addr[0], options.smtp_addr[1], EHLO_FQDN)
+smtp = smtplib.SMTP(options.smtp[0], options.smtp[1], EHLO_FQDN)
if options.debug:
smtp.set_debuglevel(1)
@@ -149,8 +80,7 @@ try:
smtp.sock.connect_ssl()
smtp.file = smtp.sock.makefile()
- if options.use_certificate_pin:
- check_certificate_pin(smtp.sock, PIN_GOOGLE_PUBKEY_SHA1)
+ check_certificate_pin(smtp.sock, PIN_GOOGLE_PUBKEY_SHA1)
smtp.ehlo(EHLO_FQDN)
if not options.remote_addr[0]:
@@ -164,21 +94,18 @@ try:
spec = "[" + spec + "]"
options.remote_addr = parse_addr_spec(spec, *options.remote_addr)
- body_plain = build_reg(options.remote_addr, options.transport)
- rsa = get_facilitator_pubkey()
- body_crypt = rsa.public_encrypt(body_plain, RSA.pkcs1_oaep_padding)
- body = body_crypt.encode("base64")
+ body = build_reg_b64enc(options.remote_addr, options.transport)
# Add a random subject to keep Gmail from threading everything.
rand_string = os.urandom(5).encode("hex")
- smtp.sendmail(options.email_addr, options.email_addr, """\
+ smtp.sendmail(options.email, options.email, """\
To: %(to_addr)s\r
From: %(from_addr)s\r
Subject: client reg %(rand_string)s\r
\r
%(body)s
""" % {
- "to_addr": options.email_addr,
+ "to_addr": options.email,
"from_addr": FROM_EMAIL_ADDRESS,
"rand_string": rand_string,
"body": body,
@@ -188,4 +115,4 @@ except Exception, e:
print >> sys.stderr, "Failed to register: %s" % str(e)
sys.exit(1)
-print "Registered \"%s\" with %s." % (safe_format_addr(options.remote_addr), options.email_addr)
+print "Registered \"%s\" with %s." % (safe_format_addr(options.remote_addr), options.email)
diff --git a/flashproxy-reg-http b/flashproxy-reg-http
index a3ad246..debd2d1 100755
--- a/flashproxy-reg-http
+++ b/flashproxy-reg-http
@@ -2,82 +2,29 @@
"""Register with a facilitator using the HTTP method."""
import argparse
-import socket
+import flashproxy
import sys
-import urllib
import urllib2
-from flashproxy.util import parse_addr_spec, format_addr
-
-DEFAULT_REMOTE = ("", 9000)
-DEFAULT_FACILITATOR_URL = "https://fp-facilitator.org/";
-DEFAULT_TRANSPORT = "websocket"
-
-class options(object):
- remote_addr = None
-
- address_family = socket.AF_UNSPEC
- facilitator_url = None
- transport = DEFAULT_TRANSPORT
- safe_logging = True
-
-def safe_str(s):
- """Return "[scrubbed]" if options.safe_logging is true, and s otherwise."""
- if options.safe_logging:
- return "[scrubbed]"
- else:
- return s
-
-def safe_format_addr(addr):
- return safe_str(format_addr(addr))
-
-def build_reg(addr, transport):
- return urllib.urlencode((
- ("client", format_addr(addr)),
- ("client-transport", transport),
- ))
+from flashproxy.util import safe_format_addr
+from flashproxy.reg import DEFAULT_FACILITATOR_URL, build_reg
parser = argparse.ArgumentParser(
usage="%(prog)s [OPTIONS] [REMOTE][:PORT]",
description="Register with a flash proxy facilitator using an HTTP POST. "
"If only the external port is given, the remote server guesses our "
"external address.")
-# common opts
-parser.add_argument("-4", help="name lookups use only IPv4.",
- action="store_const", const=socket.AF_INET, dest="address_family")
-parser.add_argument("-6", help="name lookups use only IPv6.",
- action="store_const", const=socket.AF_INET6, dest="address_family")
-parser.add_argument("--unsafe-logging", help="don't scrub IP addresses and "
- "other sensitive information from logs.", action="store_true")
-parser.add_argument("--transport",
- help="register using the given transport, default %(default)s.",
- default=DEFAULT_TRANSPORT)
-# common args
-parser.add_argument("remote_addr",
- help="remote to register, default %s - the external IP address is guessed."
- % format_addr(DEFAULT_REMOTE),
- metavar="REMOTE:PORT", default="", nargs="?",
- type=lambda x: parse_addr_spec(x, *DEFAULT_REMOTE))
-# specific opts
+flashproxy.util.add_module_opts(parser)
+flashproxy.reg.add_registration_args(parser, ignore_pubkey=True)
parser.add_argument("-f", "--facilitator", metavar="URL",
help="register with the given facilitator, default %(default)s.",
default=DEFAULT_FACILITATOR_URL)
-ns = parser.parse_args(sys.argv[1:])
-options.address_family = ns.address_family or socket.AF_UNSPEC
-if options.address_family != socket.AF_UNSPEC:
- getaddrinfo = socket.getaddrinfo
- def getaddrinfo_replacement(host, port, family, *args, **kwargs):
- return getaddrinfo(host, port, options.address_family, *args, **kwargs)
- socket.getaddrinfo = getaddrinfo_replacement
-options.safe_logging = not ns.unsafe_logging
-options.transport = ns.transport
-options.remote_addr = ns.remote_addr
-options.facilitator_url = ns.facilitator
+options = parser.parse_args(sys.argv[1:])
body = build_reg(options.remote_addr, options.transport)
try:
- http = urllib2.urlopen(options.facilitator_url, body, 10)
+ http = urllib2.urlopen(options.facilitator, body, 10)
except urllib2.HTTPError, e:
print >> sys.stderr, "Status code was %d, not 200" % e.code
sys.exit(1)
@@ -89,4 +36,4 @@ except Exception, e:
sys.exit(1)
http.close()
-print "Registered \"%s\" with %s." % (safe_format_addr(options.remote_addr), options.facilitator_url)
+print "Registered \"%s\" with %s." % (safe_format_addr(options.remote_addr), options.facilitator)
diff --git a/flashproxy-reg-url b/flashproxy-reg-url
index e8789d5..e73b035 100755
--- a/flashproxy-reg-url
+++ b/flashproxy-reg-url
@@ -2,78 +2,29 @@
"""Register with a facilitator using an indirect URL."""
import argparse
-import base64
+import flashproxy
import sys
-import urllib
import urlparse
-from flashproxy.keys import DEFAULT_FACILITATOR_PUBKEY_PEM, ensure_M2Crypto
-from flashproxy.util import parse_addr_spec, format_addr
-
-try:
- from M2Crypto import BIO, RSA
-except ImportError:
- # Defer the error reporting so that --help works even without M2Crypto.
- pass
-
-DEFAULT_REMOTE = ("", 9000)
-DEFAULT_FACILITATOR_URL = "https://fp-facilitator.org/";
-DEFAULT_TRANSPORT = "websocket"
-
-class options(object):
- facilitator_url = None
- facilitator_pubkey_filename = None
- transport = DEFAULT_TRANSPORT
-
-def build_reg(addr, transport):
- return urllib.urlencode((
- ("client", format_addr(addr)),
- ("client-transport", transport),
- ))
-
-def get_facilitator_pubkey():
- if options.facilitator_pubkey_filename is not None:
- return RSA.load_pub_key(options.facilitator_pubkey_filename)
- else:
- return RSA.load_pub_key_bio(BIO.MemoryBuffer(DEFAULT_FACILITATOR_PUBKEY_PEM))
+from flashproxy.keys import ensure_M2Crypto
+from flashproxy.reg import DEFAULT_FACILITATOR_URL, build_reg_b64enc
parser = argparse.ArgumentParser(
usage="%(prog)s [OPTIONS] REMOTE[:PORT]",
description="Print a URL, which, when retrieved, will cause the input "
"client address to be registered with the flash proxy facilitator.")
-# common opts
-parser.add_argument("--facilitator-pubkey", help="encrypt registrations to "
- "the given PEM-formatted public key file (default built-in).",
- metavar='FILENAME')
-parser.add_argument("--transport",
- help="register using the given transport, default %(default)s.",
- default=DEFAULT_TRANSPORT)
-# common args
-parser.add_argument("remote_addr",
- help="remote to register, default %s - the external IP address is guessed."
- % format_addr(DEFAULT_REMOTE),
- metavar="REMOTE:PORT", default="", nargs="?",
- type=lambda x: parse_addr_spec(x, *DEFAULT_REMOTE))
-# specific opts
+flashproxy.reg.add_registration_args(parser)
parser.add_argument("-f", "--facilitator", metavar="URL",
help="register with the given facilitator, default %(default)s.",
default=DEFAULT_FACILITATOR_URL)
-ns = parser.parse_args(sys.argv[1:])
-options.facilitator_pubkey_filename = ns.facilitator_pubkey
-options.transport = ns.transport
-remote_addr = ns.remote_addr
-options.facilitator_url = ns.facilitator
+options = parser.parse_args(sys.argv[1:])
ensure_M2Crypto()
-if not ns.remote_addr[0]:
+if not options.remote_addr[0]:
print >> sys.stderr, "An IP address (not just a port) is required."
sys.exit(1)
-reg_plain = build_reg(remote_addr, options.transport)
-rsa = get_facilitator_pubkey()
-reg_crypt = rsa.public_encrypt(reg_plain, RSA.pkcs1_oaep_padding)
-reg = base64.urlsafe_b64encode(reg_crypt)
-
-print urlparse.urljoin(options.facilitator_url, "reg/" + reg)
+reg = build_reg_b64enc(options.remote_addr, options.transport, urlsafe=True)
+print urlparse.urljoin(options.facilitator, "reg/" + reg)
diff --git a/flashproxy/keys.py b/flashproxy/keys.py
index 1365f07..8c60dc0 100644
--- a/flashproxy/keys.py
+++ b/flashproxy/keys.py
@@ -1,15 +1,32 @@
+import base64
import errno
import os
+import sys
import tempfile
from hashlib import sha1
try:
import M2Crypto
+ from M2Crypto import BIO, RSA
except ImportError:
# Defer the error so that the main program gets a chance to print help text
M2Crypto = None
+class options(object):
+ disable_pin = True
+
+def add_module_opts(parser):
+ parser.add_argument("--disable-pin", help="disable all certificate pinning "
+ "checks", action="store_true",)
+
+ old_parse = parser.parse_args
+ def parse_args(namespace):
+ options.disable_pin = namespace.disable_pin
+ return namespace
+ parser.parse_args = lambda *a, **kw: parse_args(old_parse(*a, **kw))
+
+
# We trust no other CA certificate than this.
#
# To find the certificate to copy here,
@@ -49,23 +66,8 @@ PIN_GOOGLE_PUBKEY_SHA1 = (
"\x43\xda\xd6\x30\xee\x53\xf8\xa9\x80\xca\x6e\xfd\x85\xf4\x6a\xa3\x79\x90\xe0\xea",
)
-# Registrations are encrypted with this public key before being emailed. Only
-# the facilitator operators should have the corresponding private key. Given a
-# private key in reg-email, get the public key like this:
-# openssl rsa -pubout < reg-email > reg-email.pub
-DEFAULT_FACILITATOR_PUBKEY_PEM = """\
------BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA44Mt8c599/4N2fgu6ppN
-oatPW1GOgZxxObljFtEy0OWM1eHB35OOn+Kn9MxNHTRxVWwCEi0HYxWNVs2qrXxV
-84LmWBz6A65d2qBlgltgLXusiXLrpwxVmJeO+GfmbF8ur0U9JSYxA20cGW/kujNg
-XYDGQxO1Gvxq2lHK2LQmBpkfKEE1DMFASmIvlHDQgDj3XBb5lYeOsHZmg16UrGAq
-1UH238hgJITPGLXBtwLtJkYbrATJvrEcmvI7QSm57SgYGpaB5ZdCbJL5bag5Pgt6
-M5SDDYYY4xxEPzokjFJfCQv+kcyAnzERNMQ9kR41ePTXG62bpngK5iWGeJ5XdkxG
-gwIDAQAB
------END PUBLIC KEY-----
-"""
-
def check_certificate_pin(sock, cert_pubkey):
+ if options.disable_pin: return
found = []
for cert in sock.get_peer_cert_chain():
pubkey_der = cert.get_pubkey().as_der()
@@ -105,6 +107,19 @@ class temp_cert(object):
def __exit__(self, type, value, traceback):
os.unlink(self.path)
+def get_pubkey(defaultkeybytes, overridefn=None):
+ if overridefn is not None:
+ return RSA.load_pub_key(overridefn)
+ else:
+ return RSA.load_pub_key_bio(BIO.MemoryBuffer(defaultkeybytes))
+
+def pubkey_b64enc(plaintext, pubkey, urlsafe=False):
+ ciphertext = pubkey.public_encrypt(plaintext, RSA.pkcs1_oaep_padding)
+ if urlsafe:
+ return base64.urlsafe_b64encode(ciphertext)
+ else:
+ return ciphertext.encode("base64")
+
def ensure_M2Crypto():
if M2Crypto is None:
print >> sys.stderr, """\
diff --git a/flashproxy/reg.py b/flashproxy/reg.py
index 0551f06..bc292dc 100644
--- a/flashproxy/reg.py
+++ b/flashproxy/reg.py
@@ -1,6 +1,63 @@
+import urllib
from collections import namedtuple
-from flashproxy.util import parse_addr_spec
+from flashproxy.keys import get_pubkey, pubkey_b64enc
+from flashproxy.util import parse_addr_spec, format_addr
+
+DEFAULT_REMOTE = ("", 9000)
+DEFAULT_FACILITATOR_URL = "https://fp-facilitator.org/";
+DEFAULT_TRANSPORT = "websocket"
+# Default facilitator pubkey owned by the operator of DEFAULT_FACILITATOR_URL
+DEFAULT_FACILITATOR_PUBKEY_PEM = """\
+-----BEGIN PUBLIC KEY-----
+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA44Mt8c599/4N2fgu6ppN
+oatPW1GOgZxxObljFtEy0OWM1eHB35OOn+Kn9MxNHTRxVWwCEi0HYxWNVs2qrXxV
+84LmWBz6A65d2qBlgltgLXusiXLrpwxVmJeO+GfmbF8ur0U9JSYxA20cGW/kujNg
+XYDGQxO1Gvxq2lHK2LQmBpkfKEE1DMFASmIvlHDQgDj3XBb5lYeOsHZmg16UrGAq
+1UH238hgJITPGLXBtwLtJkYbrATJvrEcmvI7QSm57SgYGpaB5ZdCbJL5bag5Pgt6
+M5SDDYYY4xxEPzokjFJfCQv+kcyAnzERNMQ9kR41ePTXG62bpngK5iWGeJ5XdkxG
+gwIDAQAB
+-----END PUBLIC KEY-----
+"""
+_OPTION_IGNORED = "ignored; for compatibility with other methods"
+
+class options(object):
+ transport = DEFAULT_TRANSPORT
+ facilitator_pubkey = None
+
+def add_module_opts(parser, ignore_pubkey=False):
+ parser.add_argument("--transport", metavar="TRANSPORT",
+ help="register using the given transport, default %(default)s.",
+ default=DEFAULT_TRANSPORT)
+ parser.add_argument("--facilitator-pubkey", metavar="FILENAME",
+ help=(_OPTION_IGNORED if ignore_pubkey else "encrypt registrations to "
+ "the given PEM-formatted public key file (default built-in)."))
+
+ old_parse = parser.parse_args
+ def parse_args(namespace):
+ options.transport = namespace.transport
+ options.facilitator_pubkey = namespace.facilitator_pubkey
+ return namespace
+ parser.parse_args = lambda *a, **kw: parse_args(old_parse(*a, **kw))
+
+def add_registration_args(parser, **kwargs):
+ add_module_opts(parser, **kwargs)
+ parser.add_argument("remote_addr", metavar="ADDR:PORT",
+ help="external addr+port to register, default %s" %
+ format_addr(DEFAULT_REMOTE), default="", nargs="?",
+ type=lambda x: parse_addr_spec(x, *DEFAULT_REMOTE))
+
+
+def build_reg(addr, transport):
+ return urllib.urlencode((
+ ("client", format_addr(addr)),
+ ("client-transport", transport),
+ ))
+
+def build_reg_b64enc(addr, transport, urlsafe=False):
+ pubkey = get_pubkey(DEFAULT_FACILITATOR_PUBKEY_PEM, options.facilitator_pubkey)
+ return pubkey_b64enc(build_reg(addr, transport), pubkey, urlsafe=urlsafe)
+
class Transport(namedtuple("Transport", "inner outer")):
@classmethod
diff --git a/flashproxy/util.py b/flashproxy/util.py
index 13cb5a4..5df15be 100644
--- a/flashproxy/util.py
+++ b/flashproxy/util.py
@@ -1,6 +1,44 @@
import re
import socket
+_old_socket_getaddrinfo = socket.getaddrinfo
+
+class options(object):
+ safe_logging = True
+ address_family = socket.AF_UNSPEC
+
+def add_module_opts(parser):
+ parser.add_argument("-4",
+ help="name lookups use only IPv4.",
+ action="store_const", const=socket.AF_INET, dest="address_family")
+ parser.add_argument("-6",
+ help="name lookups use only IPv6.",
+ action="store_const", const=socket.AF_INET6, dest="address_family")
+ parser.add_argument("--unsafe-logging",
+ help="don't scrub IP addresses and other sensitive information from "
+ "logs.", action="store_true")
+
+ old_parse = parser.parse_args
+ def parse_args(namespace):
+ options.safe_logging = not namespace.unsafe_logging
+ options.address_family = namespace.address_family or socket.AF_UNSPEC
+ if options.address_family != socket.AF_UNSPEC:
+ def getaddrinfo_replacement(host, port, family, *args, **kwargs):
+ return _old_socket_getaddrinfo(host, port, options.address_family, *args, **kwargs)
+ socket.getaddrinfo = getaddrinfo_replacement
+ return namespace
+ parser.parse_args = lambda *a, **kw: parse_args(old_parse(*a, **kw))
+
+def safe_str(s):
+ """Return "[scrubbed]" if options.safe_logging is true, and s otherwise."""
+ if options.safe_logging:
+ return "[scrubbed]"
+ else:
+ return s
+
+def safe_format_addr(addr):
+ return safe_str(format_addr(addr))
+
def parse_addr_spec(spec, defhost = None, defport = None):
"""Parse a host:port specification and return a 2-tuple ("host", port) as
understood by the Python socket functions.
_______________________________________________
tor-commits mailing list
tor-commits@xxxxxxxxxxxxxxxxxxxx
https://lists.torproject.org/cgi-bin/mailman/listinfo/tor-commits