import argparse, subprocess, json, os, urllib2, sys, base64, binascii, ssl, \
hashlib, tempfile, re, time
def sign_csr(csr):
"""Use the ACME protocol to get an ssl certificate signed by a
certificate authority.
:param string csr: Path to the certificate signing request.
:returns: Signed Certificate (PEM format)
:rtype: string
"""
CA = "https://letsencrypt-demo.org/"
#CA = "http://localhost:8888/"
def _b64(b):
"Shortcut function to go from bytes to jwt base64 string"
return base64.urlsafe_b64encode(b).replace("=", "")
def _a64(a):
"Shortcut function to go from jwt base64 string to bytes"
return base64.urlsafe_b64decode(str(a + ("=" * (len(a) % 4))))
#Step 1: Get the domain name to be certified
sys.stderr.write("Reading csr file...\n")
proc = subprocess.Popen(["openssl", "req", "-in", csr, "-noout", "-text"],
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
out, err = proc.communicate()
domain, pub_hex, pub_exp = re.search("\
Subject:.+? CN=([^\s,;/]+).+?\
Modulus\:\s+00:([a-f0-9\:\s]+?)\
Exponent\: ([0-9]+)\
", out, re.MULTILINE|re.DOTALL).groups()
pub_mod = binascii.unhexlify(re.sub("(\s|:)", "", pub_hex))
pub_mod64 = _b64(pub_mod)
pub_exp = int(pub_exp)
pub_exp = "{0:x}".format(pub_exp)
pub_exp = "0{}".format(pub_exp) if len(pub_exp) % 2 else pub_exp
pub_exp = binascii.unhexlify(pub_exp)
pub_exp64 = _b64(pub_exp)
sys.stderr.write("Found domain '{}'\n".format(domain))
#Step 2: Get challenges from the CA
sys.stderr.write("Requesting challenges...")
data = json.dumps({
"type": "challengeRequest",
"identifier": domain,
})
resp = urllib2.urlopen(CA, data)
result = resp.read()
resp_json = json.loads(result)
sessionID = resp_json['sessionID']
nonce64 = resp_json['nonce']
nonce = _a64(nonce64)
challenges = resp_json['challenges']
sys.stderr.write("Challenges received!\n")
#Step 3: Get the dvsni challenge
sys.stderr.write("Parsing dvsni challenge...\n")
challenge = [c for c in challenges if c['type'] == "dvsni"][0]
dvsni_nonce = binascii.unhexlify(challenge['nonce'])
dvsni_r = _a64(challenge['r'])
#Step 4: Calculate the sni code
client_code = os.urandom(32)
sni_code = hashlib.sha256(dvsni_r + client_code).hexdigest()
sni = sni_code + ".acme.invalid"
#Step 5: Generate the OpenSSL configuration for the SNI challenge
sys.stderr.write("Generating test configuation...\n")
proc = subprocess.Popen(["openssl", "version", "-d"],
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
out, err = proc.communicate()
openssl_dir = re.search("OPENSSLDIR: \"([^\"]+)\"", out).group(1)
openssl_cnf = open(os.path.join(openssl_dir, "openssl.cnf")).read()
test_conf = tempfile.NamedTemporaryFile(dir=".", prefix="test_", suffix=".cnf")
test_conf.write(openssl_cnf)
test_conf.write("\n\n[ alt_names ]\nsubjectAltName = DNS:" + sni + "\n")
test_conf.flush()
#Step 5: Generate a self-signed ssl cert with the sni altname
sys.stderr.write("Generating test key for dvsni challenge...\n")
test_crt = tempfile.NamedTemporaryFile(dir=".", prefix="test_", suffix=".crt")
test_crt_name = os.path.basename(test_crt.name)
test_pem = tempfile.NamedTemporaryFile(dir=".", prefix="test_", suffix=".pem")
test_pem_name = os.path.basename(test_pem.name)
proc = subprocess.Popen(
["openssl", "req", "-new", "-newkey", "rsa:4096",
"-days", "365", "-nodes", "-x509", "-sha256",
"-subj", "/C=AA/ST=A/L=A/O=A/CN={}".format(domain),
"-config", test_conf.name, "-extensions", "alt_names",
"-keyout", test_pem.name, "-out", test_crt.name],
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
proc.wait()
sys.stderr.write("Test key generated!\n")
#Step 6: Get ready to sign the challenge response
msgsig_nonce = os.urandom(16)
msgsig_nonce64 = _b64(msgsig_nonce)
msg = msgsig_nonce + domain + nonce
msg_file = tempfile.NamedTemporaryFile(dir=".", prefix="test_", suffix=".msg")
msg_file_name = os.path.basename(msg_file.name)
msg_file.write(msg)
msg_file.flush()
msgsig_file = tempfile.NamedTemporaryFile(dir=".", prefix="test_", suffix=".msgsig")
msgsig_file_name = os.path.basename(msgsig_file.name)
#Step 7: Get ready to sign the certificate request response
dersig_nonce = os.urandom(16)
dersig_nonce64 = _b64(dersig_nonce)
proc = subprocess.Popen(["openssl", "req", "-in", csr, "-outform", "DER"],
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
der_raw, err = proc.communicate()
der = dersig_nonce + der_raw
der_file = tempfile.NamedTemporaryFile(dir=".", prefix="test_", suffix=".der")
der_file_name = os.path.basename(der_file.name)
der_file.write(der)
der_file.flush()
dersig_file = tempfile.NamedTemporaryFile(dir=".", prefix="test_", suffix=".dersig")
dersig_file_name = os.path.basename(dersig_file.name)
#Step 8: Get the user to sign the request and start the https server
sys.stderr.write("""
====================================================
================USER ACTION REQUIRED================
====================================================
Since we don't ask for your private key or sudo access, you will need
to do some manual commands in order to get a signed certificate. Here's
what you need to do:
1. Sign some files requested by the certificate authority.
2. Copy a test key and certificate to your server.
3. Run an https server with the test key and certificate.
We've listed the commands you need to do this below. You should be able
to copy and paste them into a new terminal window.
(NOTE: Replace 'priv.key' below with your private key, if different)
(NOTE: Replace 'ubuntu' below with your sudo user, if different)
COMMANDS:
--------------------------
#Step 1: Sign the needed files
openssl dgst -sha256 -sign priv.key -out {} {}
openssl dgst -sha256 -sign priv.key -out {} {}
#Step 2: Copy the test key and certificate to your server
scp {} ubuntu@{}:{}
scp {} ubuntu@{}:{}
#Step 3: Run an https server with the test key and certificate
ssh -t ubuntu@{} "sudo python -c \\"import BaseHTTPServer, ssl; \\
httpd = BaseHTTPServer.HTTPServer(('0.0.0.0', 443), BaseHTTPServer.BaseHTTPRequestHandler); \\
httpd.socket = ssl.wrap_socket(httpd.socket, keyfile='{}', certfile='{}'); \\
httpd.serve_forever()\\""
--------------------------
====================================================
====================================================
====================================================
""".format(
msgsig_file_name, msg_file_name,
dersig_file_name, der_file_name,
test_pem_name, domain, test_pem_name,
test_crt_name, domain, test_crt_name,
domain, test_pem_name, test_crt_name))
stdout = sys.stdout
sys.stdout = sys.stderr
raw_input("Press Enter when you've run the above commands in a new terminal window...")
sys.stdout = stdout
#Step 9: Let the CA know you are ready for the challenge
msgsig_file.seek(0)
msgsig_in = msgsig_file.read()
f = open("test.sig", "wb")
f.write(msgsig_in)
f.close()
msgsig64 = _b64(msgsig_in)
sys.stderr.write("Sending challenge response...\n")
data = json.dumps({
"type": "authorizationRequest",
"sessionID": sessionID,
"nonce": nonce64,
"signature": {
"nonce": msgsig_nonce64,
"alg": "RS256",
"jwk": {
"kty": "RSA",
"e": pub_exp64,
"n": pub_mod64
},
"sig": msgsig64
},
"responses": [
{
"type": "dvsni",
"s": _b64(client_code)
}
]
})
resp = urllib2.urlopen(CA, data)
result = json.loads(resp.read())
#Step 10: Wait for the response giving authorization
is_done = False
while not is_done:
if result['type'] == "defer":
sys.stderr.write("Deferred...\n")
time.sleep(result.get("interval", 3))
data = json.dumps({
"type": "statusRequest",
"token": result['token']
})
resp = urllib2.urlopen(CA, data)
result = json.loads(resp.read())
else:
sys.stderr.write("Sending certificate request...\n")
is_done = True
#Step 11: Request the signed certificate
proc = subprocess.Popen(["openssl", "req", "-in", csr, "-outform", "DER"],
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
csr_der, err = proc.communicate()
csr_der64 = _b64(csr_der)
dersig_file.seek(0)
dersig = dersig_file.read()
dersig64 = _b64(dersig)
data = json.dumps({
"type": "certificateRequest",
"csr": csr_der64,
"signature": {
"alg": "RS256",
"nonce": dersig_nonce64,
"sig": dersig64,
"jwk": {
"kty": "RSA",
"e": pub_exp64,
"n": pub_mod64
}
}
})
resp = urllib2.urlopen(CA, data)
result = json.loads(resp.read())
sys.stderr.write("Exporting signed certificate...\n")
#Step 12: Parse and output the signed certificate!
crt_start = "-----BEGIN CERTIFICATE-----\n"
crt_end = "\n-----END CERTIFICATE-----\n"
crt64 = result['certificate']
crt_pem = base64.b64encode(_a64(crt64))
crt_pem = "\n".join(crt_pem[i:i+64] for i in xrange(0, len(crt_pem), 64))
crt_pem = crt_start + crt_pem + crt_end
for chain64 in result.get("chains", []):
chain_pem = base64.b64encode(_a64(chain64))
chain_pem = "\n".join(chain_pem[i:i+64] for i in xrange(0, len(chain_pem), 64))
chain_pem = crt_start + chain_pem + crt_end
crt_pem += chain_pem
sys.stderr.write("Done! Your certificate is signed by the certificate authority!\n")
return crt_pem
if __name__ == "__main__":
parser = argparse.ArgumentParser(
formatter_class=argparse.RawDescriptionHelpFormatter,
description="""\
Get a SSL certificate signed by a Let's Encrypt (ACME) certificate authority and
output that signed certificate. You do NOT need to run this script on your
server and this script does not ask for your private key. It will print out
commands that you need to run with your private key or on your server as root,
which gives you a chance to review the commands instead of trusting this script.
Prerequisites:
* openssl
* python
Example: Generate a key, create a csr, and have it signed.
--------------
$ openssl genrsa -out priv.key 4096
$ openssl req -new -sha256 -key priv.key -out cert.csr
$ python sign_csr.py cert.csr > signed.crt
--------------
""")
parser.add_argument("csr_path", help="path to certificate signing request")
args = parser.parse_args()
signed_crt = sign_csr(args.csr_path)
sys.stdout.write(signed_crt)
