Debian Codegraph @

dehydrated-hook-ddns-tsig.py

raw ◀ ▶
Source reconstructed at patch state 0 of 5 — not the installed (fully patched) source.
5 Debian patches touch this file
1 #!/usr/bin/env python
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 try:
515 key_name = cfg["key_name"]
516 key_secret = cfg["key_secret"]
517 except KeyError:
518 (key_name, key_algorithm, key_secret) = get_isc_key()
519
520 keyringd = {key_name: key_secret}
521 keyring = dns.tsigkeyring.from_text(keyringd)
522 cfg["keyring"] = keyring
523
524 try:
525 algo = cfg["key_algorithm"]
526 except KeyError:
527 algo = key_algorithm if key_algorithm else ""
528 algo = get_key_algo(algo)
529 cfg["keyalgorithm"] = algo
530
531 if "ttl" in cfg:
532 cfg["ttl"] = int(float(cfg["ttl"]))
533 else:
534 cfg["ttl"] = defaults["ttl"]
535
536 if "wait" in cfg:
537 cfg["wait"] = float(cfg["wait"])
538 else:
539 cfg["wait"] = defaults["sleep"]
540
541 if "name_server_ip" not in cfg:
542 cfg["name_server_ip"] = defaults["name_server_ip"]
543
544 cfg["dns_rewrite"] = rewriter(
545 cfg.get("dns_rewrite")
546 or defaults.get("dns_rewrite"))
547
548 return cfg
549
550
551 def read_config(args):
552 """
553 read configuration file (as specified in args),
554 merge it with the things specified in args
555 and return a list of config-dictionaries.
556
557 e.g. [{'domain': 'example.com', 'tokenfile': '-', 'token': 'secret',
558 'verbosity': 1, 'key_name': 'bla', 'key_value': '...'},]
559 """
560 try:
561 import configparser
562 except ImportError:
563 import ConfigParser as configparser
564
565 cfgfiles = defaults["configfiles"]
566 if args.config:
567 cfgfiles = args.config
568
569 config = configparser.ConfigParser()
570 config.read(cfgfiles)
571
572 # now merge args and conf
573 # we need to remove all the private args (used for building the argparser)
574 # args has the sub-command arguments as lists,
575 # because they can be given multiple times (hook-chain)
576 # we zip these dictionaries-of-lists into a list-of-dictionaries,
577 # and then iterate over the list, filling in more info from the config
578
579 # remove some unwanted keys
580 argdict = dict((k, v)
581 for k, v in vars(args).items()
582 if not k.startswith("_"))
583 for k in ['config', ]:
584 try:
585 del argdict[k]
586 except KeyError:
587 pass
588
589 # zip the dict-of-lists int o list-of-dicts
590 result = [_
591 for _ in map(dict, zip(*[[(k, v[0]) for v in value]
592 for k, value in argdict.items()
593 if type(value) is list]))]
594
595 # fill in the values from the configfile
596 for res in result:
597 domain = res['domain']
598 if domain in config.sections():
599 cfg = config[domain]
600 else:
601 cfg = config.defaults()
602
603 for c in cfg:
604 res[c] = cfg[c]
605
606 # special handling of 'verbosity':
607 # base_verbosity (configfile) + offset (cmdline)
608 verbosity = 0
609 if args.verbose:
610 verbosity += args.verbose
611 if "verbosity" in cfg:
612 verbosity += float(cfg["verbosity"])
613 res['verbosity'] = verbosity
614
615 return result
616
617
618 def parse_args():
619 import argparse
620
621 parser = argparse.ArgumentParser()
622 parser.add_argument(
623 "-c", "--config",
624 help="Read options from configuration files [%s]"
625 % (", ".join(defaults["configfiles"])),
626 action='append',
627 metavar="FILE")
628 parser.add_argument(
629 "-v", "--verbose",
630 help="Raise verbosity",
631 action='count', default=0)
632 parser.add_argument(
633 "-q", "--quiet",
634 help="Lower verbosity",
635 action='count', default=0)
636
637 subparsers = parser.add_subparsers(help='sub-command help', dest='_hook')
638
639 parser_deploychallenge = subparsers.add_parser(
640 'deploy_challenge',
641 prefix_chars='+',
642 help='make ACME challenge available via DNS')
643 parser_deploychallenge.set_defaults(
644 _func=deploy_challenge,
645 _parser=parser_deploychallenge)
646 parser_deploychallenge.add_argument(
647 'domain',
648 nargs=1, action='append',
649 help="domain name to request certificate for")
650 parser_deploychallenge.add_argument(
651 'tokenfile',
652 nargs=1, action='append',
653 help="IGNORED")
654 parser_deploychallenge.add_argument(
655 'token',
656 nargs=1, action='append',
657 help="ACME-provided token")
658 parser_deploychallenge.add_argument(
659 '_extra',
660 nargs='*',
661 metavar='...',
662 action='append',
663 help="domain1 tokenfile1 token1 ...",
664 )
665
666 parser_cleanchallenge = subparsers.add_parser(
667 'clean_challenge',
668 prefix_chars='+',
669 help='remove ACME challenge from DNS')
670 parser_cleanchallenge.set_defaults(
671 _func=clean_challenge,
672 _parser=parser_cleanchallenge)
673 parser_cleanchallenge.add_argument(
674 'domain',
675 nargs=1, action='append',
676 help="domain name for which to remove cetificate challenge")
677 parser_cleanchallenge.add_argument(
678 'tokenfile',
679 nargs=1, action='append',
680 help="IGNORED")
681 parser_cleanchallenge.add_argument(
682 'token',
683 nargs=1, action='append',
684 help="ACME-provided token")
685 parser_cleanchallenge.add_argument(
686 '_extra',
687 nargs='*',
688 metavar='...',
689 action='append',
690 help="domain1 tokenfile1 token1 ...",
691 )
692
693 parser_deploycert = subparsers.add_parser(
694 'deploy_cert',
695 prefix_chars='+',
696 help='deploy certificate obtained from ACME [NO-OP]')
697 parser_deploycert.set_defaults(
698 _func=deploy_cert,
699 _parser=parser_deploycert)
700 parser_deploycert.add_argument(
701 'domain',
702 nargs=1, action='append',
703 help="domain name to deploy certificate for")
704 parser_deploycert.add_argument(
705 'keyfile',
706 nargs=1, action='append',
707 help="private certificate")
708 parser_deploycert.add_argument(
709 'certfile',
710 nargs=1, action='append',
711 help="public certificate")
712 parser_deploycert.add_argument(
713 'fullchainfile',
714 nargs=1, action='append',
715 help="full certificate chain")
716 parser_deploycert.add_argument(
717 'chainfile',
718 nargs=1, action='append',
719 help="certificate chain")
720 parser_deploycert.add_argument(
721 'timestamp',
722 nargs=1, action='append',
723 help="time stamp")
724 parser_deploycert.add_argument(
725 '_extra',
726 nargs='*',
727 metavar='...',
728 action='append',
729 help="domain1 keyfile1 certfile1 fullchainfile1 chainfile1 ts1 ...",
730 )
731
732 parser_unchangedcert = subparsers.add_parser(
733 'unchanged_cert',
734 prefix_chars='+',
735 help='unchanged certificate obtained from ACME [NO-OP]')
736 parser_unchangedcert.set_defaults(
737 _func=unchanged_cert,
738 _parser=parser_unchangedcert)
739 parser_unchangedcert.add_argument(
740 'domain',
741 nargs=1, action='append',
742 help="domain name, for which the certificate hasn't changed")
743 parser_unchangedcert.add_argument(
744 'keyfile',
745 nargs=1, action='append',
746 help="private certificate")
747 parser_unchangedcert.add_argument(
748 'certfile',
749 nargs=1, action='append',
750 help="public certificate")
751 parser_unchangedcert.add_argument(
752 'fullchainfile',
753 nargs=1, action='append',
754 help="full certificate chain")
755 parser_unchangedcert.add_argument(
756 'chainfile',
757 nargs=1, action='append',
758 help="certificate chain")
759 parser_unchangedcert.add_argument(
760 '_extra',
761 nargs='*',
762 metavar='...',
763 action='append',
764 help="domain1 keyfile1 certfile1 fullchainfile1 chainfile1 ...",
765 )
766
767 parser_invalid_challenge = subparsers.add_parser(
768 'invalid_challenge',
769 prefix_chars='+',
770 help='challenge response has failed [NO-OP]')
771 parser_invalid_challenge.set_defaults(
772 _func=invalid_challenge,
773 _parser=parser_invalid_challenge)
774 parser_invalid_challenge.add_argument(
775 'domain',
776 nargs=1, action='append',
777 help="The primary domain name, i.e. the certificate common name (CN)")
778 parser_invalid_challenge.add_argument(
779 'response',
780 nargs=1, action='append',
781 help="The response that the verification server returned.")
782 parser_invalid_challenge.add_argument(
783 '_extra',
784 nargs='*',
785 metavar='...',
786 action='append',
787 help="domain1 response1 ...",
788 )
789
790 parser_request_failure = subparsers.add_parser(
791 'request_failure',
792 prefix_chars='+',
793 help='challenge response has failed [NO-OP]')
794 parser_request_failure.set_defaults(
795 _func=request_failure,
796 _parser=parser_request_failure)
797 parser_request_failure.add_argument(
798 'statuscode',
799 nargs=1, action='append',
800 help="The HTML status code that originated the error.")
801 parser_request_failure.add_argument(
802 'reason',
803 nargs=1, action='append',
804 help="The specified reason for the error.")
805 parser_request_failure.add_argument(
806 'reqtype',
807 nargs=1, action='append',
808 help="The kind of request that was made (GET, POST...)")
809 parser_request_failure.add_argument(
810 '_extra',
811 nargs='*',
812 metavar='...',
813 action='append',
814 help="statuscode1 reason1 reqtype1 ...",
815 )
816
817 parser_startup_hook = subparsers.add_parser(
818 'startup_hook',
819 prefix_chars='+',
820 help='dehydrated is starting up (do some initial tasks) [NO-OP]')
821 parser_startup_hook.set_defaults(
822 _func=startup_hook,
823 _parser=parser_startup_hook)
824
825 parser_exit_hook = subparsers.add_parser(
826 'exit_hook',
827 prefix_chars='+',
828 help='dehydrated is shutting down (do some final tasks) [NO-OP]')
829 parser_exit_hook.set_defaults(
830 _func=exit_hook,
831 _parser=parser_exit_hook)
832
833 # prepare to ignore unrecognised hooks
834 fallback_parser = argparse.ArgumentParser()
835 fallback_parser.add_argument('_hook_arg', nargs='*')
836 subparsers._name_parser_map = collections.defaultdict(
837 lambda: fallback_parser,
838 subparsers._name_parser_map)
839 subparsers.choices = None
840
841 args = parser.parse_args()
842 try:
843 while(args._extra[0]):
844 extra = args._extra[0]
845 args._extra = []
846 args = args._parser.parse_args(extra, args)
847 except AttributeError:
848 # no '_extra' attribute in this sub-parser
849 pass
850
851 verbosity = args.verbose - args.quiet
852 args.verbose = None
853 args.quiet = None
854 if verbosity:
855 args.verbose = verbosity
856
857 set_verbosity(verbosity)
858
859 cfg = read_config(args)
860
861 # ignore unrecognised hooks
862 if not hasattr(args, '_func'):
863 logger.debug("ignoring unknown hook: %s", args._hook)
864 return (lambda cfg: None, cfg)
865
866 return (args._func, cfg)
867
868
869 if __name__ == '__main__':
870 (fun, cfgs) = parse_args()
871 for cfg in cfgs:
872 set_verbosity(cfg['verbosity'])
873 fun(cfg)
874 sys.exit(0)