merakiumbrella

#!/usr/bin/env python3

#
# Update Umbrella Networks based on Meraki Networks
#
# Meraki support must whitelist the public IP from where this script is run,
# as well as the account used to perform the update.
#

#
# dyndns2 format::
#
#   curl -v -u user@domain.com 'https://updates.opendns.com/nic/update?hostname=Net%20name&origin_ip=xx.xx.xx.xx'
#
#  Spaces in hostname need to be replaced with %20
#  Use %40 in username to replace @
#

#
# Use base64 to encode the Umbrella password.
#
#    unset HISTFILE && echo -n secretPass | base64
#

# Format of YAML configuration file is as such:
#
# apikey: 'your-api-key-goes-here'
#
# username: 'umbrellalogin@yourdomain.com'
# password64: 'c2VjcmV0UGFzcw=='
#
# networks:
#  - meraki: 'Network1'
#    umbrella: 'Network 1'
#  - meraki: 'Another Net'
#    umbrella: 'Another Network'
#

import base64
import getopt
import os
import sys

import requests
import yaml

import meraki

DEFAULT_CONFIG_NAME = 'merakiumbrella.yaml'

class MerakiUmbrella:
    """Use Meraki network details to update Umbrella
    """
    def __init__(self, verbose=False):
        self.configuration = {}
        self.verbose = verbose
        self.debug = False
        self.apikey = ''
        self.orgid = ''
        self.dashboard = None
        self.configfile = DEFAULT_CONFIG_NAME

    def get_dashboard(self):
        """Create the dashboard API object
        """
        try:
            self.dashboard = meraki.DashboardAPI(api_key=self.apikey,
                                                 output_log=self.debug,
                                                 print_console=self.debug,
                                                 suppress_logging=True)
        except meraki.exceptions.APIKeyError as exception:
            print(f"Error: {exception}")
            sys.exit(5)

    def get_organization(self) -> dict:
        """Get the organization object.

        If there are more than one organizations accessible by the apikey,
        then the configuration must specify which one to use.

        Returns:
            dict: [description]
        """
        try:
            organizations = self.dashboard.organizations.getOrganizations()
        except meraki.exceptions.APIError as exception:
            print(f"Error: Unable to get organizations: {exception}")
            return None

        if not organizations:
            print("Error: No organizations found")
            return None

        # print("len(organizations) == {}".format(len(organizations)))
        if len(organizations) > 1:
            org_id = None
            if 'meraki' in self.configuration and 'org_id' in self.configuration['meraki']:
                org_id = self.configuration['meraki']['org_id']

            for organization in organizations:
                if self.verbose:
                    #print("org={}".format(organizations))
                    print("Organization: {} {}".format(organization['id'], organization['name']))
                if org_id == organization['id']:
                    return organization
                if self.orgid == organization['id']:
                    return organization
            if not org_id:
                print("Error: more than one organization available, but none specified")
            else:
                print(f"Error: org_id not found: {org_id}")
            sys.exit(9)
        return organizations[0]

    def get_networks(self):
        """Get the Meraki networks
        """
        organization = self.get_organization()
        try:
            networks = self.dashboard.organizations.getOrganizationNetworks(organization['id'])
        except meraki.exceptions.APIError as exception:
            print(f"Error: Unable to get networks: {exception}")
            return None
        return networks

    def doDynDns2(username, password, hostname, myip):
        """Perform a dynamic update

        Args:
            username ([type]): [description]
            password ([type]): [description]
            hostname ([type]): [description]
            myip ([type]): [description]
        """
        url = 'https://updates.opendns.com/nic/update?hostname={}&origin_ip={}'.format(hostname.replace(" ","%20"), myip)

        if self.verbose:
            print(f"url={url}")

        headers = {}
    #    headers['X-Cisco-Meraki-API-Key'] = key

        try:
            r = requests.get(url, headers=headers, auth=(username, password))
        except requests.exceptions.RequestException as e:
            print("Error: %s" % (e))
            return False
        except KeyboardInterrupt:
            print("Aborted")
            sys.exit(25)

        if self.verbose:
            print("r.status_code = %s" % (r.status_code))
            print("r.text = %s" % (r.text))

        if r.status_code == 400:
            if self.verbose:
                print("400 Bad request: %s : %s" % (url, r.text))
            return False
        if r.status_code == 401:
            print("Bad auth ({}): {}".format(username,url))
            sys.exit(50)
        if r.status_code == 404:
            print("404 Not found: %s" % (url))
            return False
        if r.status_code != 200:
            print("Error: %s - %s" % (r.status_code, r.text))
            return False

        if r.text.startswith("good"):
            print("{} updated to {}".format(hostname, myip))
            return True
        elif r.text == "nohost":
            print("{} Umbrella network does not exist.  Or account/source IP not authorized.".format(hostname))

        return False

    def get_config(self):
        """Get config from configuration file
        """
        if not os.path.isfile(self.configfile):
            print("Config file missing: {}".format(self.configfile))
            sys.exit(3)

        with open(self.configfile) as fp:
            self.configuration = yaml.load(fp, Loader=yaml.SafeLoader)

        if self.verbose:
            print("configuration={}".format(self.configuration))

        if 'apikey' in self.configuration:
            self.apikey = self.configuration['apikey']

        if len(self.apikey) < 1:
            print("Missing apikey")
            sys.exit(1)

        if not 'networks' in self.configuration:
            print("Missing 'networks' in configuration")
            sys.exit(20)

        if not 'umbrella' in self.configuration:
            print("Missing 'umbrella' in configuration")
            sys.exit(21)

        if not 'username' in self.configuration['umbrella']:
            print("Missing 'username' in umbrella configuration")
            sys.exit(21)

        if ((not 'password' in self.configuration['umbrella']) and
            (not 'password64' in self.configuration['umbrella'])):
            print("Missing 'password' or 'password64' in configuration")
            sys.exit(22)

    def get_umbrella_password(self) -> str:
        """Get the Umbrella password from configuration
        """
        if 'password' in self.configuration['umbrella']:
            return self.configuration['umbrella']['password']

        if 'password64' in self.configuration['umbrella']:
            return base64.b64decode(self.configuration['umbrella']['password64'])
        return None

    def main(self):
        """
        Parse the command line and configuration.
        """
        if 'MERAKI_APIKEY' in os.environ:
            self.apikey = os.environ['MERAKI_APIKEY']
        if 'MERAKI_ORGID' in os.environ:
            self.orgid = os.environ['MERAKI_ORGID']

        options = getopt.getopt(sys.argv[1:], 'a:c:o:v', [ 'apikey=', 'config=', 'orgid='
                                                                'verbose',
                                                                ])[0]
        for opt, arg in options:
            if opt in ('-v', '--verbose'):
                self.verbose = True
            elif opt in ('-a', '--apikey'):
                self.apikey = arg
            elif opt in ('-c', '--config'):
                self.configfile = arg
            elif opt in ('-o', '--orgid'):
                self.orgid = arg

        if len(self.configfile) < 1:
            print("Missing config filename")
            sys.exit(2)

        self.get_config()

        self.get_dashboard()

        org = self.get_organization()
        # print(f'org={org}')
        uplinks = self.dashboard.appliance.getOrganizationApplianceUplinkStatuses(org['id'])
        # print(f'uplinks={uplinks}')

        uplinks_by_network_id = {}
        for uplink in uplinks:
            uplinks_by_network_id[uplink['networkId']] = uplink

        networks = self.get_networks()
        #for network in networks:
        #    print(f"{network}")

        networksByName = {}
        networks_by_id = {}
        for network in networks:
            networksByName[network['name']] = network
            networks_by_id[network['id']] = network

        password = self.get_umbrella_password()

        for network in self.configuration['networks']:
            if self.verbose:
                print(f"network={network}")
                print("meraki={}".format(network['meraki']))
            if not network['meraki'] in networksByName:
                print("{} is not a known Meraki network".format(network['meraki']))
                sys.exit(30)

            app_uplink = uplinks_by_network_id[networksByName[network['meraki']]['id']]
            print(f'app_uplink={app_uplink}')

            for uplink in app_uplink['uplinks']:
                print(f'uplink={uplink}')
                if uplink['status'] == 'active':
                    if self.verbose:
                        print("publicIp={}".format(uplink['publicIp']))
                    #self.doDynDns2(self.configuration['username'], password, network['umbrella'], uplink['publicIp'])


        sys.exit(0)

if __name__ == "__main__":
    MerakiUmbrella().main()