Debian Codegraph @

dehydrated-hook-ddns-tsig.py

raw ◀ ▶
Source reconstructed at patch state 2 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, dns.rdatatype.NS):
158 ns = rdata.target.to_unicode()
159 nsL = []
160 nsL.extend([_.to_text() for _ in dns.resolver.query(ns)]) # default type: A
161 nsL.extend([_.to_text() for _ in dns.resolver.query(ns, rdtype=dns.rdatatype.AAAA)])
162 nameservers.append(nsL)
163 except (dns.resolver.NoAnswer, dns.resolver.NXDOMAIN) as e:
164 continue
165 if nameservers:
166 return nameservers
167 return list()
168
169
170 def verify_record(domain_name,
171 nameservers,
172 rtype='A',
173 rdata=None,
174 timeout=0,
175 invert=False):
176 """verifies that a certain record is present on all nameservers
177
178 Checks whether an <rtype> record for <domain_name> is present on
179 all IPs listed in <nameservers>.
180 If <rdata> is not None, this also verifies that at least one <rtype> field
181 in each nameserver is <rdata>.
182
183 If <invert> is True, the verification is inverted
184 (the record must NOT be present).
185
186 Return True if the record could be verified, false otherwise.
187
188 """
189 resolver = dns.resolver.Resolver(configure=False)
190 now = None
191 if timeout and timeout > 0:
192 now = time.time()
193 resolver.timeout = timeout
194
195 for ns in nameservers:
196 if now and ((time.time() - now) > timeout):
197 return False
198 logger.info(" + Verifying %s %s %s=%s @%s"
199 % (domain_name,
200 "lacks" if invert else "has",
201 rtype,
202 rdata if rdata is not None else "*",
203 ns))
204 resolver.nameservers = ns
205 answer = []
206 try:
207 answer = [_.to_text().strip('"'+"'")
208 for _ in resolver.query(domain_name, rtype)]
209 except (dns.resolver.NXDOMAIN, dns.resolver.NoAnswer) as e:
210 # probably not there yet...
211 logger.debug(
212 "Unable to verify %s record for %s @ %s" %
213 (rtype, domain_name, ns))
214 if not invert:
215 return False
216
217 if rdata is None:
218 if not (invert ^ bool(answer)):
219 return False
220 else:
221 if not (invert ^ (rdata in answer)):
222 return False
223 return True
224
225
226 # Create a TXT record through the dnspython API
227 # Example code at
228 # https://github.com/rthalley/dnspython/blob/master/examples/ddns.py
229 def create_txt_record(
230 domain_name, token,
231 name_server_ip,
232 keyring, keyalgorithm=dns.tsig.HMAC_MD5,
233 ttl=300,
234 sleep=5,
235 timeout=10,
236 rewrite=None,
237 ):
238 domain_name = "_acme-challenge." + domain_name
239 domain_names = []
240 if rewrite:
241 d2 = rewrite(domain_name)
242 if d2 != domain_name:
243 domain_names += [d2]
244 domain_names += [domain_name]
245
246 def _do_create_txt(dn):
247 domain_list = dn.split('.')
248 logger.info(' + Creating TXT record "%s" for the domain %s'
249 % (token, dn))
250
251 for i in range(0, len(domain_list)):
252 head = '.'.join(domain_list[:i])
253 tail = '.'.join(domain_list[i:])
254 update = dns.update.Update(
255 tail,
256 keyring=keyring,
257 keyalgorithm=keyalgorithm)
258 update.add(head, ttl, 'TXT', token)
259 logger.debug(str(update))
260 try:
261 response = dns.query.udp(
262 update,
263 name_server_ip,
264 timeout=timeout)
265 rcode = response.rcode()
266 logger.debug(" + Creating TXT record %s -> %s returned %s" % (
267 head, tail,
268 dns.rcode.to_text(rcode)))
269 if rcode is dns.rcode.NOERROR:
270 return dn
271 except DNSException as err:
272 logger.debug("", exc_info=True)
273 logger.error(
274 "Error creating TXT record %s %s: %s" %
275 (head, tail, err))
276
277 name = None
278 for dn in domain_names:
279 name = _do_create_txt(dn)
280 if name:
281 break
282
283 # Wait for DNS record to propagate
284 if name:
285 if (sleep < 0):
286 return
287
288 microsleep = min(1, sleep/3.)
289 nameservers = query_NS_record(name)
290 if not nameservers:
291 nameservers = [name_server_ip]
292 now = time.time()
293 while (time.time() - now < sleep):
294 try:
295 if verify_record(name,
296 nameservers,
297 rtype='TXT',
298 rdata=token,
299 timeout=sleep,
300 invert=False):
301 logger.info(" + TXT record successfully added!")
302 return
303 except Exception:
304 logger.debug("", exc_info=True)
305 logger.fatal(
306 "Unable to check if TXT record was successfully inserted")
307 sys.exit(1)
308 time.sleep(microsleep)
309
310 logger.fatal(" + TXT record not added.")
311 sys.exit(1)
312
313
314 # Delete the TXT record using the dnspython API
315 def delete_txt_record(
316 domain_name, token,
317 name_server_ip,
318 keyring, keyalgorithm=dns.tsig.HMAC_MD5,
319 ttl=300,
320 sleep=5,
321 timeout=10,
322 rewrite=None,
323 ):
324 domain_name = "_acme-challenge." + domain_name
325 domain_names = []
326 if rewrite:
327 d2 = rewrite(domain_name)
328 if d2 != domain_name:
329 domain_names += [d2]
330 domain_names += [domain_name]
331
332 # Retrieve the specific TXT record
333 txt_record = dns.rdata.from_text(
334 dns.rdataclass.IN,
335 dns.rdatatype.TXT,
336 token)
337
338 def _do_delete_txt(dn):
339 domain_list = dn.split('.')
340 logger.info(
341 ' + Deleting TXT record "%s" for the domain %s' % (token, dn)
342 )
343
344 for i in range(0, len(domain_list)):
345 head = '.'.join(domain_list[:i])
346 tail = '.'.join(domain_list[i:])
347 # Attempt to delete the TXT record
348 update = dns.update.Update(
349 tail,
350 keyring=keyring,
351 keyalgorithm=keyalgorithm)
352 update.delete(head, txt_record)
353 logger.debug(str(update))
354 try:
355 response = dns.query.udp(
356 update,
357 name_server_ip,
358 timeout=timeout)
359 rcode = response.rcode()
360 logger.debug(" + Removing TXT record %s -> %s returned %s" % (
361 head, tail,
362 dns.rcode.to_text(rcode)))
363 if rcode is dns.rcode.NOERROR:
364 return dn
365 except DNSException as err:
366 logger.debug("", exc_info=True)
367 logger.error(
368 "Error deleting TXT record %s %s: %s" %
369 (head, tail, err))
370
371 name = None
372 for dn in domain_names:
373 name = _do_delete_txt(dn)
374 if name:
375 break
376
377 if (name):
378 # Wait for DNS record to propagate
379 if (sleep < 0):
380 return
381
382 microsleep = min(1, sleep/3.)
383 nameservers = query_NS_record(name)
384 if not nameservers:
385 nameservers = [name_server_ip]
386 now = time.time()
387 while (time.time() - now < sleep):
388 try:
389 if verify_record(name,
390 nameservers,
391 rtype='TXT',
392 rdata=token,
393 timeout=sleep,
394 invert=True):
395 logger.info(" + TXT record successfully deleted!")
396 return
397 except Exception:
398 logger.debug("", exc_info=True)
399 logger.fatal(
400 "Unable to check if TXT record was successfully removed")
401 sys.exit(1)
402 time.sleep(microsleep)
403
404 logger.fatal(" + TXT record not deleted.")
405 sys.exit(1)
406
407
408 # callback to show the challenge via DNS
409 def deploy_challenge(cfg):
410 ensure_config_dns(cfg)
411 create_txt_record(
412 cfg["domain"], cfg["token"],
413 cfg["name_server_ip"],
414 cfg["keyring"], cfg["keyalgorithm"],
415 ttl=cfg["ttl"],
416 sleep=cfg["wait"],
417 rewrite=cfg["dns_rewrite"],
418 )
419 return post_hook('deploy_challenge', cfg, ['domain', 'tokenfile', 'token'])
420
421
422 # callback to clean the challenge from DNS
423 def clean_challenge(cfg):
424 ensure_config_dns(cfg)
425 delete_txt_record(
426 cfg["domain"], cfg["token"],
427 cfg["name_server_ip"],
428 cfg["keyring"], cfg["keyalgorithm"],
429 ttl=cfg["ttl"],
430 sleep=cfg["wait"],
431 rewrite=cfg["dns_rewrite"],
432 )
433 return post_hook('clean_challenge', cfg, ['domain', 'tokenfile', 'token'])
434
435
436 # callback to deploy the obtained certificate
437 def deploy_cert(cfg):
438 """deploy obtained certificates [no-op]"""
439 return post_hook(
440 'deploy_cert', cfg,
441 ['domain',
442 'keyfile', 'certfile',
443 'fullchainfile', 'chainfile', 'timestamp'])
444
445
446 # callback when the certificate has not changed
447 # (currently unimplemented)
448 def unchanged_cert(cfg):
449 """called when certificated is still valid [no-op]"""
450 return post_hook(
451 'unchanged_cert', cfg,
452 ['domain', 'keyfile', 'certfile', 'fullchainfile', 'chainfile'])
453
454
455 # challenge response has failed
456 def invalid_challenge(cfg):
457 """challenge response failed [no-op]"""
458 return post_hook(
459 'invalid_challenge', cfg,
460 ['domain', 'response'])
461
462
463 # something went wrong when talking to the ACME-server
464 def request_failure(cfg):
465 """called when HTTP requests failed (e.g. ACME server is busy [no-op])"""
466 return post_hook(
467 'request_failure', cfg,
468 ['statuscode', 'reason', 'reqtype'])
469
470
471 def startup_hook(cfg):
472 """Called at beginning of cron-command, for some initial tasks
473 (e.g. start a webserver)"""
474 return post_hook('request_failure', cfg, [])
475
476
477 def exit_hook(cfg):
478 """Called at end of cron command, to do some cleanup"""
479 return post_hook('request_failure', cfg, [])
480
481
482 def rewriter(sed):
483 if not sed:
484 return None
485 try:
486 cmd, pattern, repl, options = re.split(r'(?<![^\\]\\)/', sed)
487 if cmd != 's':
488 logger.warn(
489 "invalid string-transformation '%s', must be 's/PTRN/REPL/'",
490 sed)
491 return None
492 regex = re.compile(pattern)
493 return lambda s: regex.sub(
494 re.sub(r'\\/', '/', repl),
495 s,
496 count='g' not in options)
497 except Exception as e:
498 logger.debug("", exc_info=True)
499 logger.warn("invalid string-transformation '%s'" % (sed))
500 return
501
502
503 def ensure_config_dns(cfg):
504 """make sure that the configuration can be used to update the DNS
505 (e.g. read rndc-key if missing; fix some values if present)
506 """
507 # (str)key_name
508 # (str)key_secret
509 # (str)key_algorithm
510 # (str)name_server_ip
511 # (int)ttl
512 # (float)wait
513
514 key_name = None
515 key_secret = None
516 key_algorithm = None
517
518 try:
519 key_name = cfg["key_name"]
520 key_secret = cfg["key_secret"]
521 except KeyError:
522 (key_name, key_algorithm, key_secret) = get_isc_key()
523
524 keyringd = {key_name: key_secret}
525 keyring = dns.tsigkeyring.from_text(keyringd)
526 cfg["keyring"] = keyring
527
528 try:
529 algo = cfg["key_algorithm"]
530 except KeyError:
531 algo = key_algorithm if key_algorithm else ""
532 algo = get_key_algo(algo)
533 cfg["keyalgorithm"] = algo
534
535 if "ttl" in cfg:
536 cfg["ttl"] = int(float(cfg["ttl"]))
537 else:
538 cfg["ttl"] = defaults["ttl"]
539
540 if "wait" in cfg:
541 cfg["wait"] = float(cfg["wait"])
542 else:
543 cfg["wait"] = defaults["sleep"]
544
545 if "name_server_ip" not in cfg:
546 cfg["name_server_ip"] = defaults["name_server_ip"]
547
548 cfg["dns_rewrite"] = rewriter(
549 cfg.get("dns_rewrite")
550 or defaults.get("dns_rewrite"))
551
552 return cfg
553
554
555 def read_config(args):
556 """
557 read configuration file (as specified in args),
558 merge it with the things specified in args
559 and return a list of config-dictionaries.
560
561 e.g. [{'domain': 'example.com', 'tokenfile': '-', 'token': 'secret',
562 'verbosity': 1, 'key_name': 'bla', 'key_value': '...'},]
563 """
564 try:
565 import configparser
566 except ImportError:
567 import ConfigParser as configparser
568
569 cfgfiles = defaults["configfiles"]
570 if args.config:
571 cfgfiles = args.config
572
573 config = configparser.ConfigParser()
574 config.read(cfgfiles)
575
576 # now merge args and conf
577 # we need to remove all the private args (used for building the argparser)
578 # args has the sub-command arguments as lists,
579 # because they can be given multiple times (hook-chain)
580 # we zip these dictionaries-of-lists into a list-of-dictionaries,
581 # and then iterate over the list, filling in more info from the config
582
583 # remove some unwanted keys
584 argdict = dict((k, v)
585 for k, v in vars(args).items()
586 if not k.startswith("_"))
587 for k in ['config', ]:
588 try:
589 del argdict[k]
590 except KeyError:
591 pass
592
593 # zip the dict-of-lists int o list-of-dicts
594 result = [_
595 for _ in map(dict, zip(*[[(k, v[0]) for v in value]
596 for k, value in argdict.items()
597 if type(value) is list]))]
598
599 # fill in the values from the configfile
600 for res in result:
601 domain = res['domain']
602 if domain in config.sections():
603 cfg = config[domain]
604 else:
605 cfg = config.defaults()
606
607 for c in cfg:
608 res[c] = cfg[c]
609
610 # special handling of 'verbosity':
611 # base_verbosity (configfile) + offset (cmdline)
612 verbosity = 0
613 if args.verbose:
614 verbosity += args.verbose
615 if "verbosity" in cfg:
616 verbosity += float(cfg["verbosity"])
617 res['verbosity'] = verbosity
618
619 return result
620
621
622 def parse_args():
623 import argparse
624
625 parser = argparse.ArgumentParser()
626 parser.add_argument(
627 "-c", "--config",
628 help="Read options from configuration files [%s]"
629 % (", ".join(defaults["configfiles"])),
630 action='append',
631 metavar="FILE")
632 parser.add_argument(
633 "-v", "--verbose",
634 help="Raise verbosity",
635 action='count', default=0)
636 parser.add_argument(
637 "-q", "--quiet",
638 help="Lower verbosity",
639 action='count', default=0)
640
641 subparsers = parser.add_subparsers(help='sub-command help', dest='_hook')
642
643 parser_deploychallenge = subparsers.add_parser(
644 'deploy_challenge',
645 prefix_chars='+',
646 help='make ACME challenge available via DNS')
647 parser_deploychallenge.set_defaults(
648 _func=deploy_challenge,
649 _parser=parser_deploychallenge)
650 parser_deploychallenge.add_argument(
651 'domain',
652 nargs=1, action='append',
653 help="domain name to request certificate for")
654 parser_deploychallenge.add_argument(
655 'tokenfile',
656 nargs=1, action='append',
657 help="IGNORED")
658 parser_deploychallenge.add_argument(
659 'token',
660 nargs=1, action='append',
661 help="ACME-provided token")
662 parser_deploychallenge.add_argument(
663 '_extra',
664 nargs='*',
665 metavar='...',
666 action='append',
667 help="domain1 tokenfile1 token1 ...",
668 )
669
670 parser_cleanchallenge = subparsers.add_parser(
671 'clean_challenge',
672 prefix_chars='+',
673 help='remove ACME challenge from DNS')
674 parser_cleanchallenge.set_defaults(
675 _func=clean_challenge,
676 _parser=parser_cleanchallenge)
677 parser_cleanchallenge.add_argument(
678 'domain',
679 nargs=1, action='append',
680 help="domain name for which to remove cetificate challenge")
681 parser_cleanchallenge.add_argument(
682 'tokenfile',
683 nargs=1, action='append',
684 help="IGNORED")
685 parser_cleanchallenge.add_argument(
686 'token',
687 nargs=1, action='append',
688 help="ACME-provided token")
689 parser_cleanchallenge.add_argument(
690 '_extra',
691 nargs='*',
692 metavar='...',
693 action='append',
694 help="domain1 tokenfile1 token1 ...",
695 )
696
697 parser_deploycert = subparsers.add_parser(
698 'deploy_cert',
699 prefix_chars='+',
700 help='deploy certificate obtained from ACME [NO-OP]')
701 parser_deploycert.set_defaults(
702 _func=deploy_cert,
703 _parser=parser_deploycert)
704 parser_deploycert.add_argument(
705 'domain',
706 nargs=1, action='append',
707 help="domain name to deploy certificate for")
708 parser_deploycert.add_argument(
709 'keyfile',
710 nargs=1, action='append',
711 help="private certificate")
712 parser_deploycert.add_argument(
713 'certfile',
714 nargs=1, action='append',
715 help="public certificate")
716 parser_deploycert.add_argument(
717 'fullchainfile',
718 nargs=1, action='append',
719 help="full certificate chain")
720 parser_deploycert.add_argument(
721 'chainfile',
722 nargs=1, action='append',
723 help="certificate chain")
724 parser_deploycert.add_argument(
725 'timestamp',
726 nargs=1, action='append',
727 help="time stamp")
728 parser_deploycert.add_argument(
729 '_extra',
730 nargs='*',
731 metavar='...',
732 action='append',
733 help="domain1 keyfile1 certfile1 fullchainfile1 chainfile1 ts1 ...",
734 )
735
736 parser_unchangedcert = subparsers.add_parser(
737 'unchanged_cert',
738 prefix_chars='+',
739 help='unchanged certificate obtained from ACME [NO-OP]')
740 parser_unchangedcert.set_defaults(
741 _func=unchanged_cert,
742 _parser=parser_unchangedcert)
743 parser_unchangedcert.add_argument(
744 'domain',
745 nargs=1, action='append',
746 help="domain name, for which the certificate hasn't changed")
747 parser_unchangedcert.add_argument(
748 'keyfile',
749 nargs=1, action='append',
750 help="private certificate")
751 parser_unchangedcert.add_argument(
752 'certfile',
753 nargs=1, action='append',
754 help="public certificate")
755 parser_unchangedcert.add_argument(
756 'fullchainfile',
757 nargs=1, action='append',
758 help="full certificate chain")
759 parser_unchangedcert.add_argument(
760 'chainfile',
761 nargs=1, action='append',
762 help="certificate chain")
763 parser_unchangedcert.add_argument(
764 '_extra',
765 nargs='*',
766 metavar='...',
767 action='append',
768 help="domain1 keyfile1 certfile1 fullchainfile1 chainfile1 ...",
769 )
770
771 parser_invalid_challenge = subparsers.add_parser(
772 'invalid_challenge',
773 prefix_chars='+',
774 help='challenge response has failed [NO-OP]')
775 parser_invalid_challenge.set_defaults(
776 _func=invalid_challenge,
777 _parser=parser_invalid_challenge)
778 parser_invalid_challenge.add_argument(
779 'domain',
780 nargs=1, action='append',
781 help="The primary domain name, i.e. the certificate common name (CN)")
782 parser_invalid_challenge.add_argument(
783 'response',
784 nargs=1, action='append',
785 help="The response that the verification server returned.")
786 parser_invalid_challenge.add_argument(
787 '_extra',
788 nargs='*',
789 metavar='...',
790 action='append',
791 help="domain1 response1 ...",
792 )
793
794 parser_request_failure = subparsers.add_parser(
795 'request_failure',
796 prefix_chars='+',
797 help='challenge response has failed [NO-OP]')
798 parser_request_failure.set_defaults(
799 _func=request_failure,
800 _parser=parser_request_failure)
801 parser_request_failure.add_argument(
802 'statuscode',
803 nargs=1, action='append',
804 help="The HTML status code that originated the error.")
805 parser_request_failure.add_argument(
806 'reason',
807 nargs=1, action='append',
808 help="The specified reason for the error.")
809 parser_request_failure.add_argument(
810 'reqtype',
811 nargs=1, action='append',
812 help="The kind of request that was made (GET, POST...)")
813 parser_request_failure.add_argument(
814 '_extra',
815 nargs='*',
816 metavar='...',
817 action='append',
818 help="statuscode1 reason1 reqtype1 ...",
819 )
820
821 parser_startup_hook = subparsers.add_parser(
822 'startup_hook',
823 prefix_chars='+',
824 help='dehydrated is starting up (do some initial tasks) [NO-OP]')
825 parser_startup_hook.set_defaults(
826 _func=startup_hook,
827 _parser=parser_startup_hook)
828
829 parser_exit_hook = subparsers.add_parser(
830 'exit_hook',
831 prefix_chars='+',
832 help='dehydrated is shutting down (do some final tasks) [NO-OP]')
833 parser_exit_hook.set_defaults(
834 _func=exit_hook,
835 _parser=parser_exit_hook)
836
837 # prepare to ignore unrecognised hooks
838 fallback_parser = argparse.ArgumentParser()
839 fallback_parser.add_argument('_hook_arg', nargs='*')
840 subparsers._name_parser_map = collections.defaultdict(
841 lambda: fallback_parser,
842 subparsers._name_parser_map)
843 subparsers.choices = None
844
845 args = parser.parse_args()
846 try:
847 while(args._extra[0]):
848 extra = args._extra[0]
849 args._extra = []
850 args = args._parser.parse_args(extra, args)
851 except AttributeError:
852 # no '_extra' attribute in this sub-parser
853 pass
854
855 verbosity = args.verbose - args.quiet
856 args.verbose = None
857 args.quiet = None
858 if verbosity:
859 args.verbose = verbosity
860
861 set_verbosity(verbosity)
862
863 cfg = read_config(args)
864
865 # ignore unrecognised hooks
866 if not hasattr(args, '_func'):
867 logger.debug("ignoring unknown hook: %s", args._hook)
868 return (lambda cfg: None, cfg)
869
870 return (args._func, cfg)
871
872
873 if __name__ == '__main__':
874 (fun, cfgs) = parse_args()
875 for cfg in cfgs:
876 set_verbosity(cfg['verbosity'])
877 fun(cfg)
878 sys.exit(0)