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', '12'))
  22         self.base_url = 'https://' + self.host + '/' # This never changes
  23
  24         # Sanity check the numerical version.
  25         if self.version not in [9, 10, 11, 12]:
  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         # Finally, create a URL opener to make HTTPS requests.
  42         #
  43         # First, create a cookie jar that we'll attach to our URL
  44         # opener thingy.
  45         cj = http.cookiejar.CookieJar()
  46         cookie_proc = urllib.request.HTTPCookieProcessor(cj)
  47
  48         # SSL mumbo jumbo to make it ignore the certificate's hostname
  49         # when verify_cert = False.
  50         if self.verify_cert:
  51             ssl_ctx = ssl.create_default_context()
  52         else:
  53             ssl_ctx = ssl._create_unverified_context()
  54
  55         https_handler = urllib.request.HTTPSHandler(context=ssl_ctx)
  56
  57         # Now Create a URL opener, and tell it to use our cookie jar
  58         # and SSL context. We keep this around for future requests.
  59         self.opener = urllib.request.build_opener(https_handler, cookie_proc)
  60
  61
  62     def login(self):
  63         """
  64         Perform the HTTPS request to log in to the Untangle web admin
  65         UI. The resulting session cookie is stored by our ``self.opener``.
  66         """
  67         login_path = 'auth/login?url=/setup/welcome.do&realm=Administrator'
  68         url = self.base_url + login_path
  69         post_vars = {'username': self.username, 'password': self.password }
  70         post_data = urllib.parse.urlencode(post_vars).encode('ascii')
  71         self.opener.open(url, post_data)
  72
  73
  74     def get_backup(self):
  75         """
  76         Version-agnostic get-me-a-backup method. Dispatches to the
  77         actual implementation based on ``self.version``.
  78         """
  79         if self.version == 9:
  80             return self.get_backup_v9()
  81         elif self.version in [10, 11, 12]:
  82             # The procedure for v11 or v12 is the same as for v10.
  83             return self.get_backup_v10()
  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_v10(self):
 105         """
 106         Retrieve a backup from Untangle version 10.
 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()