macir.rb

   1 #!/usr/bin/ruby
   2
   3 # frozen_string_literal: true
   4
   5 require 'yaml'
   6 require 'openssl'
   7 require 'acme-client'
   8 require 'dnsruby'
   9 require 'time'
  10 require 'English'
  11
  12
  13 def read_config(path = 'config.yaml')
  14   p "Reading config from #{path}"
  15   YAML.load_file(path)
  16 rescue Psych::SyntaxError => e
  17   warn "Parsing configfile failed: #{e}"
  18   raise
  19 rescue Errno::ENOENT => e
  20   warn "IO failed: #{e}"
  21   raise
  22 end
  23
  24 def ensure_cert_dir(path = './certs')
  25   unless File.exist?(path)
  26     puts 'Certificate directory does not exist. Creating with secure permissions.'
  27     Dir.mkdir(path, 0o0700)
  28   end
  29   File.world_writable?(path) && warn('WARNING! Certificate directory is world writable! This could be a serious security issue!')
  30   File.world_readable?(path) && warn('WARNING! Certificate directory is world readable! This could be a serious security issue!')
  31   File.file?(path) && raise('Certificate directory is not a directory but a file. Aborting.')
  32   File.writable?(path) || raise('Certificate directory is not writable. Aborting.')
  33 end
  34
  35 def read_account_key(path = 'pkey.pem')
  36   p "Reading account key from #{path}"
  37   if File.readable?(path)
  38     p "File #{path} is readable, trying to parse"
  39     privatekey_string = File.read(path)
  40     private_key = OpenSSL::PKey::EC.new(privatekey_string)
  41   elsif File.exist?(path)
  42     raise("The file #{path} exists but is not readable. Make it readable or specify different path")
  43   else
  44     p "File #{path} does not exist, trying to create"
  45     private_key = OpenSSL::PKey::EC.generate('prime256v1')
  46     File.write(path, private_key.private_to_pem)
  47   end
  48   return private_key
  49 end
  50
  51 def read_cert_key(cert_name)
  52   folder = "./certs/#{cert_name}/"
  53   path = "#{folder}/current.key"
  54   p "cert_name #{cert_name}: Reading cert key from #{path}"
  55   if File.readable?(path)
  56     p "cert_name #{cert_name}: File #{path} is readable, trying to parse"
  57     privatekey_string = File.read(path)
  58     private_key = OpenSSL::PKey::EC.new(privatekey_string)
  59   elsif File.exist?(path)
  60     raise("cert_name #{cert_name}: The file #{path} exists but is not readable. Make it readable or specify different path")
  61   else
  62     p "cert_name #{cert_name}: File #{path} does not exist, trying to create"
  63     private_key = OpenSSL::PKey::EC.generate('prime256v1')
  64     pkey_file = File.new("#{folder}#{Time.now.to_i}.key", 'w')
  65     pkey_file.write(private_key.private_to_pem)
  66     File.symlink(File.basename(pkey_file), "#{File.dirname(pkey_file)}/current.key")
  67   end
  68   return private_key
  69 end
  70
  71 def lookup_soa(domain)
  72   rec = Dnsruby::Recursor.new
  73   p "Domain #{domain}: Getting SOA records for #{domain}"
  74   rec.query_no_validation_or_recursion(domain, 'SOA')
  75 rescue StandardError => e
  76   warn "Domain #{domain}: SOA lookup during deploy failed: #{e}"
  77   raise
  78 end
  79
  80 def find_apex_domain(domain)
  81   domain_soa_resp = lookup_soa(domain)
  82   if domain_soa_resp.answer.empty?
  83     domain_soa_resp.authority[0].name
  84   else
  85     domain_soa_resp.answer[0].name
  86   end
  87 end
  88
  89 def deploy_dns01_challenge_token(domain, challenge, nameserver, config)
  90   p "Domain #{domain}: Creating DNS UPDATE packet"
  91
  92   apex_domain = find_apex_domain(domain)
  93
  94   update = Dnsruby::Update.new(apex_domain)
  95   # TODO: delete challenge token record after validation
  96   update.delete("#{challenge.record_name}.#{domain}", challenge.record_type)
  97   update.add("#{challenge.record_name}.#{domain}", challenge.record_type, 10, challenge.record_content)
  98
  99   p "Domain #{domain}: Creating object for contacting nameserver"
 100   res = Dnsruby::Resolver.new(nameserver)
 101   res.dnssec = false
 102
 103   p "Domain #{domain}: Looking up TSIG parameters"
 104   tsig_name = config.dig('domains', domain, 'tsig_key') || config.dig('defaults', 'domains', 'tsig_key')
 105   tsig_key = config.dig('tsig_keys', tsig_name, 'key')
 106   tsig_alg = config.dig('tsig_keys', tsig_name, 'algorithm')
 107
 108   p "Domain #{domain}: Creating TSIG object"
 109   tsig = Dnsruby::RR.create(
 110     {
 111       name: tsig_name,
 112       type: 'TSIG',
 113       key: tsig_key,
 114       algorithm: tsig_alg,
 115     }
 116   )
 117
 118   p "Domain #{domain}: Signing DNS UPDATE packet with TSIG object"
 119   tsig.apply(update)
 120
 121   p "Domain #{domain}: Sending UPDATE to nameserver"
 122   res.send_message(update)
 123 rescue StandardError => e
 124   warn "Domain #{domain}: DNS Update failed: #{e}"
 125   raise
 126 end
 127
 128 def wait_for_challenge_propagation(domain, challenge)
 129   rec = Dnsruby::Recursor.new
 130   p "Domain #{domain}: Getting SOA records for #{domain}"
 131   begin
 132     domain_soa_resp = rec.query_no_validation_or_recursion(domain, 'SOA')
 133   rescue StandardError => e
 134     warn "Domain #{domain}: SOA lookup during propagation wait failed: #{e}"
 135     raise
 136   end
 137   apex_domain = if domain_soa_resp.answer.empty?
 138                   domain_soa_resp.authority[0].name
 139                 else
 140                   domain_soa_resp.answer[0].name
 141                 end
 142
 143   p "Domain #{domain}: Creating recursor object for checking challenge propagation"
 144   rec = Dnsruby::Recursor.new
 145   p "Domain #{domain}: Getting NS records for #{apex_domain}"
 146   begin
 147     domain_auth_ns = rec.query_no_validation_or_recursion(apex_domain, 'NS')
 148   rescue StandardError => e
 149     warn "Domain #{domain}: NS lookup failed: #{e}"
 150     raise
 151   end
 152
 153   p "Domain #{domain}: Checking challenge status on all NS"
 154
 155   threads = []
 156
 157   domain_auth_ns.answer.each do |ns|
 158     threads << Thread.new(ns) do |my_ns|
 159       nameserver = my_ns.rdata.to_s
 160       p "Domain #{domain}: Creating resolver object for checking propagation on #{nameserver}"
 161       res = Dnsruby::Resolver.new(nameserver)
 162       res.dnssec = false
 163       res.do_caching = false
 164       loop do
 165         p "Domain #{domain}: Querying ACME challenge record"
 166         result = res.query_no_validation_or_recursion("_acme-challenge.#{domain}", 'TXT')
 167         propagated = result.answer.any? do |answer|
 168           answer.rdata[0] == challenge.record_content
 169         end
 170         break if propagated
 171
 172         p "Domain #{domain}: Not yet propagated, still old value, sleeping before checking again"
 173         sleep(0.5)
 174       rescue Dnsruby::NXDomain
 175         p "Domain #{domain}: Not yet propagated, NXdomain, sleeping before checking again"
 176         sleep(0.5)
 177         retry
 178       rescue StandardError => e
 179         warn "Domain #{domain}: ACME challenge lookup failed: #{e}"
 180         raise
 181       end
 182     end
 183   end
 184
 185   threads.each(&:join)
 186 end
 187
 188 def acme_request_with_retries(retries: 5, &block)
 189   p "Retries: #{retries}"
 190   block.call(self)
 191 rescue Acme::Client::Error::BadNonce
 192   raise unless retries.positive?
 193
 194   p 'Retrying because of invalid nonce.'
 195   acme_request_with_retries(retries: retries - 1, &block)
 196 end
 197
 198 def wait_for_challenge_validation(challenge, cert_name)
 199   p 'Requesting validation of challenge'
 200   acme_request_with_retries { challenge.request_validation }
 201
 202   while challenge.status == 'pending'
 203     p "Cert #{cert_name}: Sleeping because challenge validation is pending"
 204     sleep(0.1)
 205     p 'Checking again'
 206     acme_request_with_retries { challenge.reload }
 207   end
 208 end
 209
 210 def get_cert(order, cert_name, domains, domain_key)
 211   path = "./certs/#{cert_name}/"
 212   crt_file = "#{path}/cert.pem"
 213   p "Cert #{cert_name}: Creating CSR object"
 214   csr = Acme::Client::CertificateRequest.new(
 215     private_key: domain_key,
 216     names: domains,
 217     subject: { common_name: domains[0] }
 218   )
 219   p "Cert #{cert_name}: Finalize cert order"
 220   acme_request_with_retries { order.reload }
 221   acme_request_with_retries { order.finalize(csr: csr) }
 222   while order.status == 'processing'
 223     p "Cert #{cert_name}: Sleep while order is processing"
 224     sleep(0.1)
 225     p "Cert #{cert_name}: Rechecking order status"
 226     acme_request_with_retries { order.reload }
 227   end
 228   # p "order status: #{order.status}"
 229   # pp order
 230   cert = acme_request_with_retries { order.certificate }
 231
 232   p "Cert #{cert_name}: Writing cert"
 233   cert_file = File.new("#{path}#{Time.now.to_i}.crt", 'w')
 234   cert_file.write(cert)
 235   if File.symlink?("#{File.dirname(cert_file)}/current.crt")
 236     File.unlink("#{File.dirname(cert_file)}/current.crt")
 237     File.symlink(File.basename(cert_file), "#{File.dirname(cert_file)}/current.crt")
 238   elsif File.file?("#{File.dirname(cert_file)}/current.crt")
 239     raise 'Could not place symlink for "current.crt" because that is already a normal file.'
 240   end
 241   return cert
 242 end
 243
 244
 245 config = read_config
 246
 247 cert_dir = config.dig('global', 'cert_dir') || './certs/'
 248
 249 ensure_cert_dir(cert_dir)
 250
 251 acme_threads = []
 252 # iterate over configured certs
 253 # TODO: make this one thread per cert
 254 # TODO: check all domains for apex domain, deploy challenges for one apex_domain all at once
 255 config['certs'].each_pair do |cert_name, cert_opts|
 256   acme_threads << Thread.new(cert_name, cert_opts) do |cert_name, cert_opts|
 257     ensure_cert_dir(cert_dir + cert_name)
 258
 259     p "Cert #{cert_name}: Finding CA to use for cert"
 260     cert_ca = cert_opts['ca'] || config.dig('defaults', 'certs', 'ca')
 261     cert_ca_name = cert_ca['name']
 262     cert_ca_account = cert_ca['account']
 263
 264     p "Cert #{cert_name}: Finding directory URL for CA"
 265     acme_directory_url = config.dig('CAs', cert_ca_name, 'directory_url')
 266
 267     p "Cert #{cert_name}: Finding account to use for cert #{cert_name} from CA #{cert_ca_name}"
 268     account = config.dig('ca_accounts', cert_ca_account)
 269     email = account['email']
 270
 271     private_key = read_account_key(account['keyfile'])
 272
 273     p "Cert #{cert_name}: Creating client object for communication with CA"
 274     client = Acme::Client.new(private_key: private_key, directory: acme_directory_url)
 275
 276     acme_request_with_retries { client.new_account(contact: "mailto:#{email}", terms_of_service_agreed: true) }
 277
 278     p "Cert #{cert_name}: Creating order object for cert #{cert_name}"
 279     order = acme_request_with_retries { client.new_order(identifiers: cert_opts['domain_names']) }
 280
 281     p "Cert #{cert_name}: order status"
 282     p order.status
 283
 284     if order.status != 'ready'
 285       p "Cert #{cert_name}: Order is not ready, we need to authorize first"
 286
 287       # TODO: collect dns modifications per primary NS, update all at once
 288       p "Cert #{cert_name}: Iterating over required authorizations"
 289       auths = acme_request_with_retries { order.authorizations }
 290       auths.each do |auth|
 291         p "Cert #{cert_name}: Processing authorization for #{auth.domain}"
 292         p "Cert #{cert_name}: Finding challenge type for #{auth.domain}"
 293         # p "Cert #{cert_name}: auth is:"
 294         # pp auth
 295         if auth.status == 'valid'
 296           p "Cert #{cert_name}: Authorization for #{auth.domain} is still valid, skipping"
 297           next
 298         end
 299
 300         challenge = auth.dns01
 301         primary_ns = config.dig('domains', auth.domain, 'primary_ns') || config.dig('defaults', 'domains', 'primary_ns')
 302         deploy_dns01_challenge_token(auth.domain, challenge, primary_ns, config)
 303         wait_for_challenge_propagation(auth.domain, challenge)
 304         wait_for_challenge_validation(challenge, cert_name)
 305       end
 306     else
 307       p "Cert #{cert_name}: Order is ready, we don’t need to authorize"
 308     end
 309     domain_key = read_cert_key(cert_name)
 310
 311     get_cert(order, cert_name, cert_opts['domain_names'], domain_key)
 312   end
 313 end
 314
 315 acme_threads.each(&:join)