src/untangle/untangle.py

   1 import configparser
   2 import http.cookiejar
   3 import ssl
   4 import urllib.parse
   5 import urllib.request
   6
   7 class Untangle:
   8     """
   9     This class wraps one instance of Untangle. It gets initialized with
  10     some configuration information, and then provides the methods to
  11     retreive a backup.
  12     """
  13     def __init__(self, s):
  14         """
  15         Initialize this Untangle object with a ConfigParser section.
  16         """
  17         self.name = s.name
  18         self.host = s['host']
  19         self.username = s.get('username', 'admin')
  20         self.password = s['password']
  21         self.version = int(s.get('version', '11'))
  22         self.base_url = 'https://' + self.host + '/' # This never changes
  23
  24         # Sanity check the numerical version.
  25         if self.version not in [9, 11]:
  26             msg =  'Invalid version "' + str(self.version) + '" '
  27             msg += 'in section "' + s.name + '"'
  28             raise configparser.ParsingError(msg)
  29
  30         # Sanity check the boolean verify_cert parameter.
  31         vc = s.get('verify_cert', 'False')
  32         if vc == 'True':
  33             self.verify_cert = True
  34         elif vc == 'False':
  35             self.verify_cert = False
  36         else:
  37             msg =  'Invalid value "' + vc + '" for verify_cert '
  38             msg += 'in section "' + s.name + '"'
  39             raise configparser.ParsingError(msg)
  40
  41         #
  42         # Finally, create a URL opener to make HTTPS requests.
  43         #
  44         # First, create a cookie jar that we'll attach to our URL
  45         # opener thingy.
  46         cj = http.cookiejar.CookieJar()
  47         cookie_proc = urllib.request.HTTPCookieProcessor(cj)
  48
  49         # SSL mumbo jumbo to make it ignore the certificate's hostname
  50         # when verify_cert = False.
  51         if self.verify_cert:
  52             ssl_ctx = ssl.create_default_context()
  53         else:
  54             ssl_ctx = ssl._create_unverified_context()
  55
  56         https_handler = urllib.request.HTTPSHandler(context=ssl_ctx)
  57
  58         # Now Create a URL opener, and tell it to use our cookie jar
  59         # and SSL context. We keep this around for future requests.
  60         self.opener = urllib.request.build_opener(https_handler, cookie_proc)
  61
  62
  63     def login(self):
  64         """
  65         Perform the HTTPS request to log in to the Untangle web admin
  66         UI. The resulting session cookie is stored by our ``self.opener``.
  67         """
  68         login_path = 'auth/login?url=/setup/welcome.do&realm=Administrator'
  69         url = self.base_url + login_path
  70         post_vars = {'username': self.username, 'password': self.password }
  71         post_data = urllib.parse.urlencode(post_vars).encode('ascii')
  72         self.opener.open(url, post_data)
  73
  74
  75     def get_backup(self):
  76         """
  77         Version-agnostic get-me-a-backup method. Dispatches to the
  78         actual implementation based on ``self.version``.
  79         """
  80         if self.version == 9:
  81             return self.get_backup_v9()
  82         elif self.version == 11:
  83             return self.get_backup_v11()
  84
  85
  86     def get_backup_v9(self):
  87         """
  88         Retrieve a backup from Untangle version 9. This requires two
  89         requests; the first just hits the page, and the second actually
  90         retrieves the backup file.
  91
  92         Returns the binary HTTPS response (i.e. the file).
  93         """
  94         url = self.base_url + '/webui/backup'
  95         post_vars = {'action': 'requestBackup'}
  96         post_data = urllib.parse.urlencode(post_vars).encode('ascii')
  97         self.opener.open(url, post_data)
  98
  99         url = self.base_url + 'webui/backup?action=initiateDownload'
 100         with self.opener.open(url) as response:
 101             return response.read()
 102
 103
 104     def get_backup_v11(self):
 105         """
 106         Retrieve a backup from Untangle version 11.
 107
 108         Returns the binary HTTPS response (i.e. the file).
 109         """
 110         url = self.base_url + '/webui/download?type=backup'
 111         post_vars = {'type': 'backup'}
 112         post_data = urllib.parse.urlencode(post_vars).encode('ascii')
 113         with self.opener.open(url, post_data) as response:
 114             return response.read()