letsencrypt.sh

   1 #!/usr/bin/env bash
   2
   3 set -e
   4 set -u
   5 set -o pipefail
   6
   7 # default config values
   8 CA="https://acme-v01.api.letsencrypt.org"
   9 LICENSE="https://letsencrypt.org/documents/LE-SA-v1.0.1-July-27-2015.pdf"
  10
  11 . ./config.sh
  12
  13 umask 077 # paranoid umask, we're creating private keys
  14
  15 anti_newline() {
  16   tr -d '\n\r'
  17 }
  18
  19 urlbase64() {
  20   # urlbase64: base64 encoded string with '+' replaced with '-' and '/' replaced with '_'
  21   openssl base64 -e | anti_newline | sed -r 's/=*$//g' | tr '+/' '-_'
  22 }
  23
  24 hex2bin() {
  25   # Store hex string from stdin
  26   tmphex="$(cat)"
  27
  28   # Remove spaces
  29   hex=''
  30   for ((i=0; i<${#tmphex}; i+=1)); do
  31     test "${tmphex:$i:1}" == " " || hex="${hex}${tmphex:$i:1}"
  32   done
  33
  34   # Add leading zero
  35   test $((${#hex} & 1)) == 0 || hex="0${hex}"
  36
  37   # Convert to escaped string
  38   escapedhex=''
  39   for ((i=0; i<${#hex}; i+=2)); do
  40     escapedhex=$escapedhex\\x${hex:$i:2}
  41   done
  42
  43   # Convert to binary data
  44   printf "${escapedhex}"
  45 }
  46
  47 _request() {
  48   temperr="$(mktemp)"
  49   if [ "${1}" = "head" ]; then
  50     curl -sSf -I "${2}" 2>"${temperr}"
  51   elif [ "${1}" = "get" ]; then
  52     curl -sSf "${2}" 2>"${temperr}"
  53   elif [ "${1}" = "post" ]; then
  54     curl -sSf "${2}" -d "${3}" 2>"${temperr}"
  55   fi
  56   if [ -s "${temperr}" ]; then
  57       echo "  + ERROR: An error occurred while sending ${1}-request to ${2} ($(<"${temperr}"))" >&2
  58       rm -f "${temperr}"
  59       exit 1
  60   fi
  61   rm -f "${temperr}"
  62 }
  63
  64 signed_request() {
  65   # Encode payload as urlbase64
  66   payload64="$(printf '%s' "${2}" | urlbase64)"
  67
  68   # Retrieve nonce from acme-server
  69   nonce="$(_request head "${CA}/directory" | grep Replay-Nonce: | awk -F ': ' '{print $2}' | anti_newline)"
  70
  71   # Build header with just our public key and algorithm information
  72   header='{"alg": "RS256", "jwk": {"e": "'"${pubExponent64}"'", "kty": "RSA", "n": "'"${pubMod64}"'"}}'
  73
  74   # Build another header which also contains the previously received nonce and encode it as urlbase64
  75   protected='{"alg": "RS256", "jwk": {"e": "'"${pubExponent64}"'", "kty": "RSA", "n": "'"${pubMod64}"'"}, "nonce": "'"${nonce}"'"}'
  76   protected64="$(printf '%s' "${protected}" | urlbase64)"
  77
  78   # Sign header with nonce and our payload with our private key and encode signature as urlbase64
  79   signed64="$(printf '%s' "${protected64}.${payload64}" | openssl dgst -sha256 -sign private_key.pem | urlbase64)"
  80
  81   # Send header + extended header + payload + signature to the acme-server
  82   data='{"header": '"${header}"', "protected": "'"${protected64}"'", "payload": "'"${payload64}"'", "signature": "'"${signed64}"'"}'
  83
  84   _request post "${1}" "${data}"
  85 }
  86
  87 sign_domain() {
  88   domain="${1}"
  89   altnames="${*}"
  90   echo "Signing domain ${1} (${*})..."
  91
  92   # If there is no existing certificate directory we need a new private key
  93   if [ ! -e "certs/${domain}" ]; then
  94     mkdir "certs/${domain}"
  95     echo "  + Generating private key..."
  96     openssl genrsa -out "certs/${domain}/privkey.pem" 4096 2> /dev/null > /dev/null
  97   fi
  98
  99   # Generate signing request config and the actual signing request
 100   SAN=""
 101   for altname in $altnames; do
 102     SAN+="DNS:${altname}, "
 103   done
 104   SAN="$(printf '%s' "${SAN}" | sed 's/,\s*$//g')"
 105   echo "  + Generating signing request..."
 106   openssl req -new -sha256 -key "certs/${domain}/privkey.pem" -out "certs/${domain}/cert.csr" -subj "/CN=${domain}/" -reqexts SAN -config <(cat /etc/ssl/openssl.cnf <(printf "[SAN]\nsubjectAltName=%s" "${SAN}")) > /dev/null
 107
 108   # Request and respond to challenges
 109   for altname in $altnames; do
 110     # Ask the acme-server for new challenge token and extract them from the resulting json block
 111     echo "  + Requesting challenge for ${altname}..."
 112     response="$(signed_request "${CA}/acme/new-authz" '{"resource": "new-authz", "identifier": {"type": "dns", "value": "'"${altname}"'"}}')"
 113
 114     challenge_token="$(printf '%s\n' "${response}" | grep -Eo '"challenges":[^\[]*\[[^]]*]' | sed 's/{/\n{/g' | grep 'http-01' | grep -Eo '"token":\s*"[^"]*"' | cut -d'"' -f4 | sed 's/[^A-Za-z0-9_\-]/_/g')"
 115     challenge_uri="$(printf '%s\n' "${response}" | grep -Eo '"challenges":[^\[]*\[[^]]*]' | sed 's/{/\n{/g' | grep 'http-01' | grep -Eo '"uri":\s*"[^"]*"' | cut -d'"' -f4)"
 116
 117     if [ -z "${challenge_token}" ] || [ -z "${challenge_uri}" ]; then
 118       echo "  + Error: Can't retrieve challenges (${response})"
 119       exit 1
 120     fi
 121
 122     # Challenge response consists of the challenge token and the thumbprint of our public certificate
 123     keyauth="${challenge_token}.${thumbprint}"
 124
 125     # Store challenge response in well-known location and make world-readable (so that a webserver can access it)
 126     printf '%s' "${keyauth}" > "${WELLKNOWN}/${challenge_token}"
 127     chmod a+r "${WELLKNOWN}/${challenge_token}"
 128
 129     # Ask the acme-server to verify our challenge and wait until it becomes valid
 130     echo "  + Responding to challenge for ${altname}..."
 131     result="$(signed_request "${challenge_uri}" '{"resource": "challenge", "keyAuthorization": "'"${keyauth}"'"}')"
 132
 133     status="$(printf '%s\n' "${result}" | grep -Eo '"status":\s*"[^"]*"' | cut -d'"' -f4)"
 134     if [ ! "${status}" = "pending" ] && [ ! "${status}" = "valid" ]; then
 135       echo "  + Challenge is invalid! (${result})"
 136       exit 1
 137     fi
 138
 139     while [ "${status}" = "pending" ]; do
 140       status="$(_request get "${challenge_uri}" | grep -Eo '"status":\s*"[^"]*"' | cut -d'"' -f4)"
 141       sleep 1
 142     done
 143
 144     echo "  + Challenge is valid!"
 145   done
 146
 147   # Finally request certificate from the acme-server and store it in cert.pem
 148   echo "  + Requesting certificate..."
 149   csr64="$(openssl req -in "certs/${domain}/cert.csr" -outform DER | urlbase64)"
 150   crt64="$(signed_request "${CA}/acme/new-cert" '{"resource": "new-cert", "csr": "'"${csr64}"'"}' | openssl base64 -e)"
 151   printf -- '-----BEGIN CERTIFICATE-----\n%s\n-----END CERTIFICATE-----\n' "${crt64}" > "certs/${domain}/cert.pem"
 152   echo "  + Done!"
 153 }
 154
 155 # Check if private key exists, if it doesn't exist yet generate a new one (4096bit rsa key)
 156 register="0"
 157 if [ ! -e "private_key.pem" ]; then
 158   echo "+ Generating account key..."
 159   openssl genrsa -out "private_key.pem" 4096 2> /dev/null > /dev/null
 160   register="1"
 161 fi
 162
 163 # Get public components from private key and calculate thumbprint
 164 pubExponent64="$(printf "%06x" "$(openssl rsa -in private_key.pem -noout -text | grep publicExponent | head -1 | cut -d' ' -f2)" | hex2bin | urlbase64)"
 165 pubMod64="$(printf '%s' "$(openssl rsa -in private_key.pem -noout -modulus | cut -d'=' -f2)" | hex2bin | urlbase64)"
 166
 167 thumbprint="$(printf '%s' "$(printf '%s' '{"e":"'"${pubExponent64}"'","kty":"RSA","n":"'"${pubMod64}"'"}' | shasum -a 256 | awk '{print $1}')" | hex2bin | urlbase64)"
 168
 169 # If we generated a new private key in the step above we have to register it with the acme-server
 170 if [ "${register}" = "1" ]; then
 171   echo "+ Registering account key with letsencrypt..."
 172   signed_request "${CA}/acme/new-reg" '{"resource": "new-reg", "agreement": "'"$LICENSE"'"}' > /dev/null
 173 fi
 174
 175 # Generate certificates for all domains found in domain.txt (TODO: check if certificate already exists and is about to expire)
 176 <domains.txt sed 's/^\s*//g;s/\s*$//g' | grep -v '^#' | grep -v '^$' | while read line; do
 177   sign_domain $line
 178 done