Debian Codegraph @

dehydrated-hook-ddns-tsig.py

raw ◀ ▶
Source reconstructed at patch state 4 of 5 — not the installed (fully patched) source.
5 Debian patches touch this file
1 #!/usr/bin/env python3
2 # -*- coding: utf-8 -*-
3 #
4 # dehydrated-hook-ddns-tsig - dns-01 Challenge Hook Script for dehydrated
5 #
6 # This script uses the dnspython API to create and delete TXT records
7 # in order to prove ownership of a domain.
8 #
9 # Copyright (C) 2016 Elizabeth Ferdman https://eferdman.github.io
10 # Copyright (C) 2016 IOhannes m zmölnig <[email protected]>
11 #
12 # This program is free software: you can redistribute it and/or modify
13 # it under the terms of the GNU General Public License as published by
14 # the Free Software Foundation, either version 3 of the License, or
15 # (at your option) any later version.
16 #
17 # This program is distributed in the hope that it will be useful,
18 # but WITHOUT ANY WARRANTY; without even the implied warranty of
19 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 # GNU General Public License for more details.
21 #
22 # You should have received a copy of the GNU General Public License
23 # along with this program. If not, see <http://www.gnu.org/licenses/>.
24 #
25 ############################################################################
26
27 # callbacks:
28 # *deploy_challenge <DOMAIN> <TOKEN_FILENAME> <TOKEN_VALUE>.
29 # *clean_challenge <DOMAIN> <FILENAME> <TOKEN_VALUE>.
30 # deploy_cert <DOMAIN> <KEYFILE> <CERTFILE> <FULLCHAIN> <CHAINFILE> <TSTAMP>.
31 # unchanged_cert DOMAIN> <KEYFILE> <CERTFILE> <FULLCHAINFILE> <CHAINFILE>.
32 # invalid_challenge <DOMAIN> <RESPONSE>.
33 # request_failure <STATUSCODE> <REASON> <REQTYPE>.
34 # startup_hook.
35 # exit_hook.
36
37 import re
38 import os
39 import sys
40 import time
41 import logging
42 import collections
43 import dns.resolver
44 import dns.tsig
45 import dns.tsigkeyring
46 import dns.update
47 import dns.query
48 from dns.exception import DNSException
49
50
51 # the default configuration
52 defaults = {
53 "configfiles": [
54 "/etc/dehydrated/dehydrated-hook-ddns-tsig.conf",
55 "/usr/local/etc/dehydrated/dehydrated-hook-ddns-tsig.conf",
56 "dehydrated-hook-ddns-tsig.conf", ],
57 "name_server_ip": '10.0.0.1',
58 "ttl": 300,
59 "sleep": 5,
60 "loglevel": logging.WARN,
61 "dns_rewrite": None,
62 }
63 # valid key algorithms (but bind9 only supports hmac-md5)
64 key_algorithms = {
65 "": dns.tsig.HMAC_MD5,
66 "hmac-md5": dns.tsig.HMAC_MD5,
67 "hmac-sha1": dns.tsig.HMAC_SHA1,
68 "hmac-sha224": dns.tsig.HMAC_SHA224,
69 "hmac-sha256": dns.tsig.HMAC_SHA256,
70 "hmac-sha384": dns.tsig.HMAC_SHA384,
71 "hmac-sha512": dns.tsig.HMAC_SHA512,
72 }
73
74 # Configure some basic logging
75 logger = logging.getLogger(__name__)
76 logger.addHandler(logging.StreamHandler())
77
78
79 def set_verbosity(verbosity):
80 level = int(defaults["loglevel"] - (10 * verbosity))
81 if level <= 0:
82 level = 1
83 logger.setLevel(level)
84
85
86 set_verbosity(0)
87
88
89 def post_hook(name, cfg, args):
90 key = "post_%s" % (name,)
91 if key in cfg:
92 import subprocess
93 callargs = [cfg[key], name]
94 for a in args:
95 callargs += [cfg[a]]
96 logger.info(' + Calling post %s hook: %s' % (name, ' '.join(callargs)))
97 subprocess.call(callargs)
98 return
99
100
101 def get_key_algo(name='hmac-md5'):
102 try:
103 return key_algorithms[name]
104 except KeyError:
105 logger.debug("", exc_info=True)
106 logger.fatal("""Invalid key-algorithm '%s'
107 Only the following algorithms are allowed: %s"""
108 % (name, " ".join(key_algorithms.keys())))
109 sys.exit(1)
110
111
112 def get_isc_key():
113 try:
114 import iscpy
115 except ImportError:
116 logger.debug("", exc_info=True)
117 logger.fatal("""The 'iscpy' module is required to read keys from isc-config file.
118 Alternatively set key_name/key_secret in the configuration file""")
119 sys.exit(1)
120 key_file = os.environ.get('DDNS_HOOK_KEY_FILE')
121
122 # Open the key file for reading
123 try:
124 f = open(key_file, 'rU')
125 except IOError:
126 logger.debug("", exc_info=True)
127 logger.fatal("""Unable to read isc-config file!
128 Did you set the DDNS_HOOK_KEY_FILE env?
129 Alternatively set key_name/key_secret in the configuration file""")
130 sys.exit(1)
131
132 # Parse the key file
133 parsed_key_file = iscpy.ParseISCString(f.read())
134
135 # Grab the keyname, cut out the substring "key "
136 # and remove the extra quotes
137 key_name = parsed_key_file.keys()[0][4:].strip('\"')
138
139 # Grab the secret key
140 secret = parsed_key_file.values()[0]['secret'].strip('\"')
141 algorithm = parsed_key_file.values()[0]['algorithm'].strip('\"')
142 f.close()
143
144 return (key_name, algorithm, secret)
145
146
147 def query_NS_record(domain_name):
148 """get the nameservers for <name>
149
150 Return a list of nameserver IPs (might be empty)
151 """
152 name_list = domain_name.split('.')
153 for i in range(0, len(name_list)):
154 nameservers = []
155 try:
156 fqdn = '.'.join(name_list[i:])
157 for rdata in dns.resolver.query(fqdn, rdtype=dns.rdatatype.NS):
158 ns = rdata.target.to_unicode()
159 nsL = []
160 try:
161 nsL.extend([_.to_text() for _ in dns.resolver.query(ns, rdtype=dns.rdatatype.A)])
162 except (dns.resolver.NoAnswer, dns.resolver.NXDOMAIN) as e:
163 pass
164 try:
165 nsL.extend([_.to_text() for _ in dns.resolver.query(ns, rdtype=dns.rdatatype.AAAA)])
166 except (dns.resolver.NoAnswer, dns.resolver.NXDOMAIN) as e:
167 pass
168 if nsL:
169 nameservers.append(nsL)
170 except (dns.resolver.NoAnswer, dns.resolver.NXDOMAIN) as e:
171 continue
172 if nameservers:
173 return nameservers
174 return list()
175
176
177 def verify_record(domain_name,
178 nameservers,
179 rtype='A',
180 rdata=None,
181 timeout=0,
182 invert=False):
183 """verifies that a certain record is present on all nameservers
184
185 Checks whether an <rtype> record for <domain_name> is present on
186 all IPs listed in <nameservers>.
187 If <rdata> is not None, this also verifies that at least one <rtype> field
188 in each nameserver is <rdata>.
189
190 If <invert> is True, the verification is inverted
191 (the record must NOT be present).
192
193 Return True if the record could be verified, false otherwise.
194
195 """
196 resolver = dns.resolver.Resolver(configure=False)
197 now = None
198 if timeout and timeout > 0:
199 now = time.time()
200 resolver.timeout = timeout
201
202 for ns in nameservers:
203 if now and ((time.time() - now) > timeout):
204 return False
205 logger.info(" + Verifying %s %s %s=%s @%s"
206 % (domain_name,
207 "lacks" if invert else "has",
208 rtype,
209 rdata if rdata is not None else "*",
210 ns))
211 resolver.nameservers = ns
212 answer = []
213 try:
214 answer = [_.to_text().strip('"'+"'")
215 for _ in resolver.query(domain_name, rtype)]
216 except (dns.resolver.NXDOMAIN, dns.resolver.NoAnswer) as e:
217 # probably not there yet...
218 logger.debug(
219 "Unable to verify %s record for %s @ %s" %
220 (rtype, domain_name, ns))
221 if not invert:
222 return False
223
224 if rdata is None:
225 if not (invert ^ bool(answer)):
226 return False
227 else:
228 if not (invert ^ (rdata in answer)):
229 return False
230 return True
231
232
233 # Create a TXT record through the dnspython API
234 # Example code at
235 # https://github.com/rthalley/dnspython/blob/master/examples/ddns.py
236 def create_txt_record(
237 domain_name, token,
238 name_server_ip,
239 keyring, keyalgorithm=dns.tsig.HMAC_MD5,
240 ttl=300,
241 sleep=5,
242 timeout=10,
243 rewrite=None,
244 ):
245 domain_name = "_acme-challenge." + domain_name
246 domain_names = []
247 if rewrite:
248 d2 = rewrite(domain_name)
249 if d2 != domain_name:
250 domain_names += [d2]
251 domain_names += [domain_name]
252
253 def _do_create_txt(dn):
254 domain_list = dn.split('.')
255 logger.info(' + Creating TXT record "%s" for the domain %s'
256 % (token, dn))
257
258 for i in range(0, len(domain_list)):
259 head = '.'.join(domain_list[:i])
260 tail = '.'.join(domain_list[i:])
261 update = dns.update.Update(
262 tail,
263 keyring=keyring,
264 keyalgorithm=keyalgorithm)
265 update.add(head, ttl, 'TXT', token)
266 logger.debug(str(update))
267 try:
268 response = dns.query.udp(
269 update,
270 name_server_ip,
271 timeout=timeout)
272 rcode = response.rcode()
273 logger.debug(" + Creating TXT record %s -> %s returned %s" % (
274 head, tail,
275 dns.rcode.to_text(rcode)))
276 if rcode == dns.rcode.NOERROR:
277 return dn
278 except DNSException as err:
279 logger.debug("", exc_info=True)
280 logger.error(
281 "Error creating TXT record %s %s: %s" %
282 (head, tail, err))
283
284 name = None
285 for dn in domain_names:
286 name = _do_create_txt(dn)
287 if name:
288 break
289
290 # Wait for DNS record to propagate
291 if name:
292 if (sleep < 0):
293 return
294
295 microsleep = min(1, sleep/3.)
296 nameservers = query_NS_record(name)
297 if not nameservers:
298 nameservers = [[name_server_ip]]
299 now = time.time()
300 while (time.time() - now < sleep):
301 try:
302 if verify_record(name,
303 nameservers,
304 rtype='TXT',
305 rdata=token,
306 timeout=sleep,
307 invert=False):
308 logger.info(" + TXT record successfully added!")
309 return
310 except Exception:
311 logger.debug("", exc_info=True)
312 logger.fatal(
313 "Unable to check if TXT record was successfully inserted")
314 sys.exit(1)
315 time.sleep(microsleep)
316
317 logger.fatal(" + TXT record not added.")
318 sys.exit(1)
319
320
321 # Delete the TXT record using the dnspython API
322 def delete_txt_record(
323 domain_name, token,
324 name_server_ip,
325 keyring, keyalgorithm=dns.tsig.HMAC_MD5,
326 ttl=300,
327 sleep=5,
328 timeout=10,
329 rewrite=None,
330 ):
331 domain_name = "_acme-challenge." + domain_name
332 domain_names = []
333 if rewrite:
334 d2 = rewrite(domain_name)
335 if d2 != domain_name:
336 domain_names += [d2]
337 domain_names += [domain_name]
338
339 # Retrieve the specific TXT record
340 txt_record = dns.rdata.from_text(
341 dns.rdataclass.IN,
342 dns.rdatatype.TXT,
343 token)
344
345 def _do_delete_txt(dn):
346 domain_list = dn.split('.')
347 logger.info(
348 ' + Deleting TXT record "%s" for the domain %s' % (token, dn)
349 )
350
351 for i in range(0, len(domain_list)):
352 head = '.'.join(domain_list[:i])
353 tail = '.'.join(domain_list[i:])
354 # Attempt to delete the TXT record
355 update = dns.update.Update(
356 tail,
357 keyring=keyring,
358 keyalgorithm=keyalgorithm)
359 update.delete(head, txt_record)
360 logger.debug(str(update))
361 try:
362 response = dns.query.udp(
363 update,
364 name_server_ip,
365 timeout=timeout)
366 rcode = response.rcode()
367 logger.debug(" + Removing TXT record %s -> %s returned %s" % (
368 head, tail,
369 dns.rcode.to_text(rcode)))
370 if rcode == dns.rcode.NOERROR:
371 return dn
372 except DNSException as err:
373 logger.debug("", exc_info=True)
374 logger.error(
375 "Error deleting TXT record %s %s: %s" %
376 (head, tail, err))
377
378 name = None
379 for dn in domain_names:
380 name = _do_delete_txt(dn)
381 if name:
382 break
383
384 if (name):
385 # Wait for DNS record to propagate
386 if (sleep < 0):
387 return
388
389 microsleep = min(1, sleep/3.)
390 nameservers = query_NS_record(name)
391 if not nameservers:
392 nameservers = [[name_server_ip]]
393 now = time.time()
394 while (time.time() - now < sleep):
395 try:
396 if verify_record(name,
397 nameservers,
398 rtype='TXT',
399 rdata=token,
400 timeout=sleep,
401 invert=True):
402 logger.info(" + TXT record successfully deleted!")
403 return
404 except Exception:
405 logger.debug("", exc_info=True)
406 logger.fatal(
407 "Unable to check if TXT record was successfully removed")
408 sys.exit(1)
409 time.sleep(microsleep)
410
411 logger.fatal(" + TXT record not deleted.")
412 sys.exit(1)
413
414
415 # callback to show the challenge via DNS
416 def deploy_challenge(cfg):
417 ensure_config_dns(cfg)
418 create_txt_record(
419 cfg["domain"], cfg["token"],
420 cfg["name_server_ip"],
421 cfg["keyring"], cfg["keyalgorithm"],
422 ttl=cfg["ttl"],
423 sleep=cfg["wait"],
424 rewrite=cfg["dns_rewrite"],
425 )
426 return post_hook('deploy_challenge', cfg, ['domain', 'tokenfile', 'token'])
427
428
429 # callback to clean the challenge from DNS
430 def clean_challenge(cfg):
431 ensure_config_dns(cfg)
432 delete_txt_record(
433 cfg["domain"], cfg["token"],
434 cfg["name_server_ip"],
435 cfg["keyring"], cfg["keyalgorithm"],
436 ttl=cfg["ttl"],
437 sleep=cfg["wait"],
438 rewrite=cfg["dns_rewrite"],
439 )
440 return post_hook('clean_challenge', cfg, ['domain', 'tokenfile', 'token'])
441
442
443 # callback to deploy the obtained certificate
444 def deploy_cert(cfg):
445 """deploy obtained certificates [no-op]"""
446 return post_hook(
447 'deploy_cert', cfg,
448 ['domain',
449 'keyfile', 'certfile',
450 'fullchainfile', 'chainfile', 'timestamp'])
451
452
453 # callback when the certificate has not changed
454 # (currently unimplemented)
455 def unchanged_cert(cfg):
456 """called when certificated is still valid [no-op]"""
457 return post_hook(
458 'unchanged_cert', cfg,
459 ['domain', 'keyfile', 'certfile', 'fullchainfile', 'chainfile'])
460
461
462 # challenge response has failed
463 def invalid_challenge(cfg):
464 """challenge response failed [no-op]"""
465 return post_hook(
466 'invalid_challenge', cfg,
467 ['domain', 'response'])
468
469
470 # something went wrong when talking to the ACME-server
471 def request_failure(cfg):
472 """called when HTTP requests failed (e.g. ACME server is busy [no-op])"""
473 return post_hook(
474 'request_failure', cfg,
475 ['statuscode', 'reason', 'reqtype'])
476
477
478 def startup_hook(cfg):
479 """Called at beginning of cron-command, for some initial tasks
480 (e.g. start a webserver)"""
481 return post_hook('request_failure', cfg, [])
482
483
484 def exit_hook(cfg):
485 """Called at end of cron command, to do some cleanup"""
486 return post_hook('request_failure', cfg, [])
487
488
489 def rewriter(sed):
490 if not sed:
491 return None
492 try:
493 cmd, pattern, repl, options = re.split(r'(?<![^\\]\\)/', sed)
494 if cmd != 's':
495 logger.warn(
496 "invalid string-transformation '%s', must be 's/PTRN/REPL/'",
497 sed)
498 return None
499 regex = re.compile(pattern)
500 return lambda s: regex.sub(
501 re.sub(r'\\/', '/', repl),
502 s,
503 count='g' not in options)
504 except Exception as e:
505 logger.debug("", exc_info=True)
506 logger.warn("invalid string-transformation '%s'" % (sed))
507 return
508
509
510 def ensure_config_dns(cfg):
511 """make sure that the configuration can be used to update the DNS
512 (e.g. read rndc-key if missing; fix some values if present)
513 """
514 # (str)key_name
515 # (str)key_secret
516 # (str)key_algorithm
517 # (str)name_server_ip
518 # (int)ttl
519 # (float)wait
520
521 key_name = None
522 key_secret = None
523 key_algorithm = None
524
525 try:
526 key_name = cfg["key_name"]
527 key_secret = cfg["key_secret"]
528 except KeyError:
529 (key_name, key_algorithm, key_secret) = get_isc_key()
530
531 keyringd = {key_name: key_secret}
532 keyring = dns.tsigkeyring.from_text(keyringd)
533 cfg["keyring"] = keyring
534
535 try:
536 algo = cfg["key_algorithm"]
537 except KeyError:
538 algo = key_algorithm if key_algorithm else ""
539 algo = get_key_algo(algo)
540 cfg["keyalgorithm"] = algo
541
542 if "ttl" in cfg:
543 cfg["ttl"] = int(float(cfg["ttl"]))
544 else:
545 cfg["ttl"] = defaults["ttl"]
546
547 if "wait" in cfg:
548 cfg["wait"] = float(cfg["wait"])
549 else:
550 cfg["wait"] = defaults["sleep"]
551
552 if "name_server_ip" not in cfg:
553 cfg["name_server_ip"] = defaults["name_server_ip"]
554
555 cfg["dns_rewrite"] = rewriter(
556 cfg.get("dns_rewrite")
557 or defaults.get("dns_rewrite"))
558
559 return cfg
560
561
562 def read_config(args):
563 """
564 read configuration file (as specified in args),
565 merge it with the things specified in args
566 and return a list of config-dictionaries.
567
568 e.g. [{'domain': 'example.com', 'tokenfile': '-', 'token': 'secret',
569 'verbosity': 1, 'key_name': 'bla', 'key_value': '...'},]
570 """
571 try:
572 import configparser
573 except ImportError:
574 import ConfigParser as configparser
575
576 cfgfiles = defaults["configfiles"]
577 if args.config:
578 cfgfiles = args.config
579
580 config = configparser.ConfigParser()
581 config.read(cfgfiles)
582
583 # now merge args and conf
584 # we need to remove all the private args (used for building the argparser)
585 # args has the sub-command arguments as lists,
586 # because they can be given multiple times (hook-chain)
587 # we zip these dictionaries-of-lists into a list-of-dictionaries,
588 # and then iterate over the list, filling in more info from the config
589
590 # remove some unwanted keys
591 argdict = dict((k, v)
592 for k, v in vars(args).items()
593 if not k.startswith("_"))
594 for k in ['config', ]:
595 try:
596 del argdict[k]
597 except KeyError:
598 pass
599
600 # zip the dict-of-lists int o list-of-dicts
601 result = [_
602 for _ in map(dict, zip(*[[(k, v[0]) for v in value]
603 for k, value in argdict.items()
604 if type(value) is list]))]
605
606 # fill in the values from the configfile
607 for res in result:
608 domain = res['domain']
609 if domain in config.sections():
610 cfg = config[domain]
611 else:
612 cfg = config.defaults()
613
614 for c in cfg:
615 res[c] = cfg[c]
616
617 # special handling of 'verbosity':
618 # base_verbosity (configfile) + offset (cmdline)
619 verbosity = 0
620 if args.verbose:
621 verbosity += args.verbose
622 if "verbosity" in cfg:
623 verbosity += float(cfg["verbosity"])
624 res['verbosity'] = verbosity
625
626 return result
627
628
629 def parse_args():
630 import argparse
631
632 parser = argparse.ArgumentParser()
633 parser.add_argument(
634 "-c", "--config",
635 help="Read options from configuration files [%s]"
636 % (", ".join(defaults["configfiles"])),
637 action='append',
638 metavar="FILE")
639 parser.add_argument(
640 "-v", "--verbose",
641 help="Raise verbosity",
642 action='count', default=0)
643 parser.add_argument(
644 "-q", "--quiet",
645 help="Lower verbosity",
646 action='count', default=0)
647
648 subparsers = parser.add_subparsers(help='sub-command help', dest='_hook')
649
650 parser_deploychallenge = subparsers.add_parser(
651 'deploy_challenge',
652 prefix_chars='+',
653 help='make ACME challenge available via DNS')
654 parser_deploychallenge.set_defaults(
655 _func=deploy_challenge,
656 _parser=parser_deploychallenge)
657 parser_deploychallenge.add_argument(
658 'domain',
659 nargs=1, action='append',
660 help="domain name to request certificate for")
661 parser_deploychallenge.add_argument(
662 'tokenfile',
663 nargs=1, action='append',
664 help="IGNORED")
665 parser_deploychallenge.add_argument(
666 'token',
667 nargs=1, action='append',
668 help="ACME-provided token")
669 parser_deploychallenge.add_argument(
670 '_extra',
671 nargs='*',
672 metavar='...',
673 action='append',
674 help="domain1 tokenfile1 token1 ...",
675 )
676
677 parser_cleanchallenge = subparsers.add_parser(
678 'clean_challenge',
679 prefix_chars='+',
680 help='remove ACME challenge from DNS')
681 parser_cleanchallenge.set_defaults(
682 _func=clean_challenge,
683 _parser=parser_cleanchallenge)
684 parser_cleanchallenge.add_argument(
685 'domain',
686 nargs=1, action='append',
687 help="domain name for which to remove cetificate challenge")
688 parser_cleanchallenge.add_argument(
689 'tokenfile',
690 nargs=1, action='append',
691 help="IGNORED")
692 parser_cleanchallenge.add_argument(
693 'token',
694 nargs=1, action='append',
695 help="ACME-provided token")
696 parser_cleanchallenge.add_argument(
697 '_extra',
698 nargs='*',
699 metavar='...',
700 action='append',
701 help="domain1 tokenfile1 token1 ...",
702 )
703
704 parser_deploycert = subparsers.add_parser(
705 'deploy_cert',
706 prefix_chars='+',
707 help='deploy certificate obtained from ACME [NO-OP]')
708 parser_deploycert.set_defaults(
709 _func=deploy_cert,
710 _parser=parser_deploycert)
711 parser_deploycert.add_argument(
712 'domain',
713 nargs=1, action='append',
714 help="domain name to deploy certificate for")
715 parser_deploycert.add_argument(
716 'keyfile',
717 nargs=1, action='append',
718 help="private certificate")
719 parser_deploycert.add_argument(
720 'certfile',
721 nargs=1, action='append',
722 help="public certificate")
723 parser_deploycert.add_argument(
724 'fullchainfile',
725 nargs=1, action='append',
726 help="full certificate chain")
727 parser_deploycert.add_argument(
728 'chainfile',
729 nargs=1, action='append',
730 help="certificate chain")
731 parser_deploycert.add_argument(
732 'timestamp',
733 nargs=1, action='append',
734 help="time stamp")
735 parser_deploycert.add_argument(
736 '_extra',
737 nargs='*',
738 metavar='...',
739 action='append',
740 help="domain1 keyfile1 certfile1 fullchainfile1 chainfile1 ts1 ...",
741 )
742
743 parser_unchangedcert = subparsers.add_parser(
744 'unchanged_cert',
745 prefix_chars='+',
746 help='unchanged certificate obtained from ACME [NO-OP]')
747 parser_unchangedcert.set_defaults(
748 _func=unchanged_cert,
749 _parser=parser_unchangedcert)
750 parser_unchangedcert.add_argument(
751 'domain',
752 nargs=1, action='append',
753 help="domain name, for which the certificate hasn't changed")
754 parser_unchangedcert.add_argument(
755 'keyfile',
756 nargs=1, action='append',
757 help="private certificate")
758 parser_unchangedcert.add_argument(
759 'certfile',
760 nargs=1, action='append',
761 help="public certificate")
762 parser_unchangedcert.add_argument(
763 'fullchainfile',
764 nargs=1, action='append',
765 help="full certificate chain")
766 parser_unchangedcert.add_argument(
767 'chainfile',
768 nargs=1, action='append',
769 help="certificate chain")
770 parser_unchangedcert.add_argument(
771 '_extra',
772 nargs='*',
773 metavar='...',
774 action='append',
775 help="domain1 keyfile1 certfile1 fullchainfile1 chainfile1 ...",
776 )
777
778 parser_invalid_challenge = subparsers.add_parser(
779 'invalid_challenge',
780 prefix_chars='+',
781 help='challenge response has failed [NO-OP]')
782 parser_invalid_challenge.set_defaults(
783 _func=invalid_challenge,
784 _parser=parser_invalid_challenge)
785 parser_invalid_challenge.add_argument(
786 'domain',
787 nargs=1, action='append',
788 help="The primary domain name, i.e. the certificate common name (CN)")
789 parser_invalid_challenge.add_argument(
790 'response',
791 nargs=1, action='append',
792 help="The response that the verification server returned.")
793 parser_invalid_challenge.add_argument(
794 '_extra',
795 nargs='*',
796 metavar='...',
797 action='append',
798 help="domain1 response1 ...",
799 )
800
801 parser_request_failure = subparsers.add_parser(
802 'request_failure',
803 prefix_chars='+',
804 help='challenge response has failed [NO-OP]')
805 parser_request_failure.set_defaults(
806 _func=request_failure,
807 _parser=parser_request_failure)
808 parser_request_failure.add_argument(
809 'statuscode',
810 nargs=1, action='append',
811 help="The HTML status code that originated the error.")
812 parser_request_failure.add_argument(
813 'reason',
814 nargs=1, action='append',
815 help="The specified reason for the error.")
816 parser_request_failure.add_argument(
817 'reqtype',
818 nargs=1, action='append',
819 help="The kind of request that was made (GET, POST...)")
820 parser_request_failure.add_argument(
821 '_extra',
822 nargs='*',
823 metavar='...',
824 action='append',
825 help="statuscode1 reason1 reqtype1 ...",
826 )
827
828 parser_startup_hook = subparsers.add_parser(
829 'startup_hook',
830 prefix_chars='+',
831 help='dehydrated is starting up (do some initial tasks) [NO-OP]')
832 parser_startup_hook.set_defaults(
833 _func=startup_hook,
834 _parser=parser_startup_hook)
835
836 parser_exit_hook = subparsers.add_parser(
837 'exit_hook',
838 prefix_chars='+',
839 help='dehydrated is shutting down (do some final tasks) [NO-OP]')
840 parser_exit_hook.set_defaults(
841 _func=exit_hook,
842 _parser=parser_exit_hook)
843
844 # prepare to ignore unrecognised hooks
845 fallback_parser = argparse.ArgumentParser()
846 fallback_parser.add_argument('_hook_arg', nargs='*')
847 subparsers._name_parser_map = collections.defaultdict(
848 lambda: fallback_parser,
849 subparsers._name_parser_map)
850 subparsers.choices = None
851
852 args = parser.parse_args()
853 try:
854 while(args._extra[0]):
855 extra = args._extra[0]
856 args._extra = []
857 args = args._parser.parse_args(extra, args)
858 except AttributeError:
859 # no '_extra' attribute in this sub-parser
860 pass
861
862 verbosity = args.verbose - args.quiet
863 args.verbose = None
864 args.quiet = None
865 if verbosity:
866 args.verbose = verbosity
867
868 set_verbosity(verbosity)
869
870 cfg = read_config(args)
871
872 # ignore unrecognised hooks
873 if not hasattr(args, '_func'):
874 logger.debug("ignoring unknown hook: %s", args._hook)
875 return (lambda cfg: None, cfg)
876
877 return (args._func, cfg)
878
879
880 if __name__ == '__main__':
881 (fun, cfgs) = parse_args()
882 for cfg in cfgs:
883 set_verbosity(cfg['verbosity'])
884 fun(cfg)
885 sys.exit(0)