lanscape 1.3.1a8__py3-none-any.whl → 1.3.2a6__py3-none-any.whl

lanscape/tests/test_api.py

@@ -1,194 +0,0 @@
-import unittest
-import json
-from ..ui.app import app
-from ..libraries.net_tools import get_network_subnet
-from ._helpers import right_size_subnet
-import time
-
-
-
-class ApiTestCase(unittest.TestCase):
-    app = app.test_client()
-
-    def test_port_lifecycle(self):
-        # Delete the new port list if it exists
-        self.app.delete('/api/port/list/test_port_list_lifecycle')
-
-        # Get the list of port lists
-        response = self.app.get('/api/port/list')
-        self.assertEqual(response.status_code, 200)
-        port_list_start = json.loads(response.data)
-
-        # Create a new port list
-        new_port_list = {'80': 'http', '443': 'https'}
-        response = self.app.post('/api/port/list/test_port_list_lifecycle', json=new_port_list)
-        self.assertEqual(response.status_code, 200)
-
-
-        # Get the list of port lists again
-        response = self.app.get('/api/port/list')
-        self.assertEqual(response.status_code, 200)
-        port_list_new = json.loads(response.data)
-        # Verify that the new port list is in the list of port lists
-        self.assertEqual(len(port_list_new), len(port_list_start) + 1)
-
-        # Get the new port list
-        response = self.app.get('/api/port/list/test_port_list_lifecycle')
-        self.assertEqual(response.status_code, 200)
-        port_list = json.loads(response.data)
-        self.assertEqual(port_list, new_port_list)
-
-        # Update the new port list
-        updated_port_list = {'22': 'ssh', '8080': 'http-alt'}
-        response = self.app.put('/api/port/list/test_port_list_lifecycle', json=updated_port_list)
-        self.assertEqual(response.status_code, 200)
-
-        # Get the new port list again
-        response = self.app.get('/api/port/list/test_port_list_lifecycle')
-        self.assertEqual(response.status_code, 200)
-        port_list = json.loads(response.data)
-
-        # Verify that the new port list has been updated
-        self.assertEqual(port_list, updated_port_list)
-
-        # Delete the new port list
-        response = self.app.delete('/api/port/list/test_port_list_lifecycle')
-        self.assertEqual(response.status_code, 200)
-
-    def test_scan(self):
-        # Delete the new port list if it exists
-        self.app.delete('/api/port/list/test_port_list_scan')
-
-        # Create a new port list
-        new_port_list = {'80': 'http', '443': 'https'}
-        response = self.app.post('/api/port/list/test_port_list_scan', json=new_port_list)
-        self.assertEqual(response.status_code, 200)
-
-        # Create a new scan, wait for completion
-        new_scan = {'subnet': right_size_subnet(get_network_subnet()), 'port_list': 'test_port_list_scan'}
-        response = self.app.post('/api/scan/async', json=new_scan)
-        self.assertEqual(response.status_code, 200)
-        scan_info = json.loads(response.data)
-        self.assertEqual(scan_info['status'], 'complete')
-        scanid = scan_info['scan_id']
-        self.assertIsNotNone(scanid)
-
-        # Validate the scan worked without error
-        response = self.app.get(f"/api/scan/{scanid}")
-        self.assertEqual(response.status_code, 200)
-        scan_data = json.loads(response.data)
-        self.assertEqual(scan_data['errors'], [])
-        self.assertEqual(scan_data['stage'],'complete')
-
-        # Render UI
-        uris = [
-            '/info',
-            f'/?scan_id={scanid}',
-            f'/scan/{scanid}/overview',
-            f'/scan/{scanid}/table',
-            f'/export/{scanid}'
-        ]
-        for uri in uris:
-            response = self.app.get(uri)
-            self.assertEqual(response.status_code,200)
-
-
-        # Delete the new port list
-        response = self.app.delete('/api/port/list/test_port_list_scan')
-        self.assertEqual(response.status_code, 200)
-
-    
-    def test_subnet_ports(self):
-        """
-        Test to ensure multi-subnet dectection is working
-        """
-
-        response = self.app.get('/api/tools/subnet/list')
-        self.assertEqual(response.status_code, 200)
-
-        subnets = json.loads(response.data)
-        self.assertIsNot(len(subnets), 0)
-        self.assertIsInstance(subnets[0],dict)
-        subnet:dict = subnets[0]
-        self.assertIsNotNone(subnet.get('address_cnt'))
-
-    def test_subnet_validation(self):
-        """
-        test subnet validation and parsing is working as expected
-        """
-        subnet_tests = {
-            # subnet : count (-1 == invalid)
-            '10.0.0.0/24': 254,
-            '10.0.0.2/24': 254,
-            '10.0.0.1-100': 100,
-            '192.168.1.1/25': 126,
-            '10.0.0.1/24, 192.168.1.1-100': 354,
-            '10.0.0.1/20': 4094,
-            '10.0.0.1/19': 8190,
-            '': -1, # blank
-            '10.0.1/24': -1, # invalid
-            '10.0.0.1/2': -1, # too big
-            '10.0.0.1/19, 192.168.1.1/20': 12284,
-            '10.0.0.1/17, 192.168.0.1/16': 98300,
-            '10.0.0.1/20, 192.168.0.1/20, 10.100.0.1/20': 12282,
-            '10.0.0.1/17, 192.168.0.1/16, 10.100.0.1/20': -1
-        }
-
-        for subnet, count in subnet_tests.items():
-            uri = f'/api/tools/subnet/test?subnet={subnet}'
-            response = self.app.get(uri)
-            self.assertEqual(response.status_code, 200)
-
-            data:dict = json.loads(response.data)
-            self.assertEqual(data.get('count'),count)
-            self.assertIsNotNone(data.get('msg'))
-            if count == -1:
-                self.assertFalse(data.get('valid'))
-    
-    def test_scan_api(self):
-        """
-        Test the scan API endpoints
-        """
-        # Create a new scan
-        new_scan = {
-            'subnet': right_size_subnet(get_network_subnet()),
-            'port_list': 'small',
-            'parallelism': 1
-        }
-        response = self.app.post('/api/scan', json=new_scan)
-        self.assertEqual(response.status_code, 200)
-        scan_info = json.loads(response.data)
-        self.assertEqual(scan_info['status'], 'running')
-        scan_id = scan_info['scan_id']
-        self.assertIsNotNone(scan_id)
-
-        percent_complete = 0
-        while percent_complete < 100:
-            # Get scan summary
-            response = self.app.get(f'/api/scan/{scan_id}/summary')
-            self.assertEqual(response.status_code, 200)
-            summary = json.loads(response.data)
-            self.assertTrue(summary['running'] or summary['stage'] == 'complete')
-            percent_complete = summary['percent_complete']
-            self.assertGreaterEqual(percent_complete, 0)
-            self.assertLessEqual(percent_complete, 100)
-            # Wait for a bit before checking again
-            time.sleep(2)
-        
-        self.assertEqual(summary['running'], False)
-        self.assertEqual(summary['stage'], 'complete')
-        self.assertGreater(summary['runtime'], 0)
-
-        devices_alive = summary['devices']['alive']
-        devices_scanned = summary['devices']['scanned']
-        devices_total = summary['devices']['total']
-
-        self.assertEqual(devices_scanned, devices_total)
-        self.assertGreater(devices_alive, 0)
-
-
-
-
-        
-if __name__ == '__main__':
-    unittest.main()

lanscape/tests/test_env.py

@@ -1,30 +0,0 @@
-import unittest
-
-from ..libraries.version_manager import lookup_latest_version 
-from ..libraries.app_scope import ResourceManager, is_local_run
-from ..libraries.net_tools import is_arp_supported
-
-
-
-class EnvTestCase(unittest.TestCase):
-    def test_versioning(self):
-        version = lookup_latest_version()
-        self.assertIsNotNone(version)
-
-    def test_resource_manager(self):
-        ports = ResourceManager('ports')
-        self.assertGreater(len(ports.list()),0)
-        mac = ResourceManager('mac_addresses')
-        mac_list = mac.get('mac_db.json')
-        self.assertIsNotNone(mac_list)
-    
-    def test_local_version(self):
-        self.assertTrue(is_local_run())
-        
-    def test_arp_support(self):
-        arp_supported = is_arp_supported()
-        self.assertIn(arp_supported, [True, False],
-            f"ARP support should be either True or False, not {arp_supported}"
-        )
-        
-

lanscape/tests/test_library.py

@@ -1,53 +0,0 @@
-import unittest
-from ..libraries.net_tools import smart_select_primary_subnet
-from ._helpers import right_size_subnet
-from ..libraries.subnet_scan import ScanManager, ScanConfig
-
-sm = ScanManager()
-
-class LibraryTestCase(unittest.TestCase):
-    def test_scan(self):
-        subnet = smart_select_primary_subnet()
-        self.assertIsNotNone(subnet)
-        cfg = ScanConfig(
-            subnet = right_size_subnet(subnet),
-            t_multiplier=1.0,
-            port_list='small'
-        )
-        scan = sm.new_scan(cfg)
-        self.assertTrue(scan.running)
-        sm.wait_until_complete(scan.uid)
-
-        self.assertFalse(scan.running)
-
-        # ensure there are not any remaining running threads
-        self.assertDictEqual(scan.job_stats.running,{})
-
-
-        cnt_with_hostname = 0
-        ips = []
-        macs = []
-        for d in scan.results.devices:
-            if d.hostname: cnt_with_hostname += 1
-            # ensure there arent dupe mac addresses
-            self.assertNotIn(d.get_mac(), macs)
-            macs.append(d.get_mac())
-
-            # ensure there arent dupe ips
-            self.assertNotIn(d.ip, ips)
-            ips.append(d.ip)
-
-            # device must be alive to be in this list
-            self.assertTrue(d.alive)
-    
-        # find at least one device
-        self.assertGreater(len(scan.results.devices),0)
-
-        # ensure everything got scanned
-        self.assertEqual(scan.results.devices_scanned, scan.results.devices_total)
-
-
-
-
-        
-        

lanscape/ui/app.py

@@ -1,122 +0,0 @@
-from flask import Flask, render_template, request
-from time import sleep
-import multiprocessing
-import traceback
-import threading
-import logging
-import os
-
-from ..libraries.runtime_args import RuntimeArgs, parse_args
-from ..libraries.version_manager import is_update_available, get_installed_version, lookup_latest_version
-from ..libraries.app_scope import is_local_run
-from ..libraries.net_tools import is_arp_supported
-
-app = Flask(
-    __name__
-)
-log = logging.getLogger('flask')
-
-## Import and register BPs
-################################
-
-from .blueprints.api import api_bp
-from .blueprints.web import web_bp
-
-app.register_blueprint(api_bp)
-app.register_blueprint(web_bp)
-    
-## Define global jinja filters
-################################
-
-def is_substring_in_values(results: dict, substring: str) -> bool:
-    return any(substring.lower() in str(v).lower() for v in results.values()) if substring else True
-
-app.jinja_env.filters['is_substring_in_values'] = is_substring_in_values
-
-## Define global jinja vars
-################################
-
-def set_global_safe(key: str, value):
-    """ Safely set global vars without worrying about an exception """
-    app_globals = app.jinja_env.globals
-    try:
-        if callable(value): value = value()
-        
-        app_globals[key] = value
-        log.debug(f'jinja_globals[{key}] = {value}')
-    except:
-        default = app_globals.get(key)
-        log.debug(traceback.format_exc())
-        log.info(
-            f"Unable to set app global var '{key}'"+
-            f"defaulting to '{default}'"
-        )
-        app_globals[key] = default
-
-set_global_safe('app_version',get_installed_version)
-set_global_safe('update_available', is_update_available)
-set_global_safe('latest_version',lookup_latest_version)
-set_global_safe('runtime_args', vars(parse_args()))
-set_global_safe('is_local',is_local_run)
-set_global_safe('is_arp_supported', is_arp_supported)
-
-## External hook to kill flask server
-################################
-
-exiting = False
-@app.route("/shutdown", methods=['GET', 'POST'])
-def exit_app():
-    
-    req_type = request.args.get('type')
-    if req_type == 'browser-close':
-        args = parse_args()
-        if args.persistent:
-            log.info('Dectected browser close, not exiting flask.')
-            return "Ignored"
-        log.info('Web browser closed, terminating flask. (disable with --peristent)')
-    elif req_type == 'core':
-        log.info('Core requested exit, terminating flask.')
-    else:
-        log.info('Received external exit request. Terminating flask.')
-    global exiting
-    exiting = True
-    return "Done"
-
-@app.teardown_request
-def teardown(exception):
-    if exiting:
-        os._exit(0)
-
-## Generalized error handling
-################################
-@app.errorhandler(500)
-def internal_error(e):
-    """
-    handle internal errors nicely
-    """
-    tb = traceback.format_exc()
-    return render_template('error.html',
-                           error=None,
-                           traceback=tb), 500
-
-## Webserver creation functions
-################################
-
-def start_webserver_daemon(args: RuntimeArgs) -> threading.Thread:
-    proc = threading.Thread(target=start_webserver, args=(args,))
-    proc.daemon = True # Kill thread when main thread exits
-    proc.start()
-    log.info('Flask server initializing as dameon')
-    return proc
-
-def start_webserver(args: RuntimeArgs) -> int:
-    run_args = {
-        'host':'0.0.0.0',
-        'port':args.port,
-        'debug':args.reloader,
-        'use_reloader':args.reloader
-    }
-    app.run(**run_args)
-
-
-

lanscape/ui/blueprints/__init__.py

@@ -1,7 +0,0 @@
-from ...libraries.subnet_scan import ScanManager
-import logging
-# defining here so blueprints can access the same
-# manager instance
-scan_manager = ScanManager()
-
-log = logging.getLogger('Blueprints')

lanscape/ui/blueprints/api/__init__.py

@@ -1,5 +0,0 @@
-from flask import Blueprint
-
-api_bp = Blueprint('api', __name__)
-
-from . import port, scan, tools

lanscape/ui/blueprints/api/port.py

@@ -1,27 +0,0 @@
-from flask import request, jsonify
-from . import api_bp
-from ....libraries.port_manager import PortManager
-
-# Port Manager API
-############################################
-@api_bp.route('/api/port/list', methods=['GET'])
-def get_port_lists():
-    return jsonify(PortManager().get_port_lists())
-
-@api_bp.route('/api/port/list/<port_list>', methods=['GET'])
-def get_port_list(port_list):
-    return jsonify(PortManager().get_port_list(port_list))
-
-@api_bp.route('/api/port/list/<port_list>', methods=['POST'])
-def create_port_list(port_list):
-    data = request.get_json()
-    return jsonify(PortManager().create_port_list(port_list, data))
-
-@api_bp.route('/api/port/list/<port_list>', methods=['PUT'])
-def update_port_list(port_list):
-    data = request.get_json()
-    return jsonify(PortManager().update_port_list(port_list, data))
-
-@api_bp.route('/api/port/list/<port_list>', methods=['DELETE'])
-def delete_port_list(port_list):
-    return jsonify(PortManager().delete_port_list(port_list))

lanscape/ui/blueprints/api/scan.py

@@ -1,69 +0,0 @@
-from . import api_bp
-from ....libraries.subnet_scan import ScanConfig
-from .. import scan_manager
-
-from flask import request, jsonify
-import json
-import traceback
-
-# Subnet Scanner API
-############################################
-@api_bp.route('/api/scan', methods=['POST'])
-@api_bp.route('/api/scan/threaded', methods=['POST'])
-def scan_subnet_threaded():
-    try:
-        config = get_scan_config()
-        scan = scan_manager.new_scan(config)
-
-        return jsonify({'status': 'running', 'scan_id': scan.uid})
-    except:
-        return jsonify({'status': 'error', 'traceback': traceback.format_exc()}), 500
-    
-
-@api_bp.route('/api/scan/async', methods=['POST'])
-def scan_subnet_async():
-    config = get_scan_config()
-    scan = scan_manager.new_scan(config)
-    scan_manager.wait_until_complete(scan.uid)
-
-    return jsonify({'status': 'complete', 'scan_id': scan.uid})
-
-@api_bp.route('/api/scan/<scan_id>', methods=['GET'])
-def get_scan(scan_id):
-    scan = scan_manager.get_scan(scan_id)
-    # cast to str and back to handle custom JSON serialization
-    return jsonify(json.loads(scan.results.export(str)))
-
-@api_bp.route('/api/scan/<scan_id>/summary',methods=['GET'])
-def get_scan_summary(scan_id):
-    scan = scan_manager.get_scan(scan_id)
-    if not scan:
-        return jsonify({'error':'scan not found'}), 404
-    return jsonify({
-        'running': scan.running,
-        'percent_complete': scan.calc_percent_complete(),
-        'stage': scan.results.stage,
-        'runtime': scan.results.get_runtime(),
-        'devices': {
-            'scanned': scan.results.devices_scanned,
-            'alive': len(scan.results.devices),
-            'total': scan.results.devices_total
-        }
-    })
-
-@api_bp.route('/api/scan/<scan_id>/terminate', methods=['GET'])
-def terminate_scan(scan_id):
-    scan = scan_manager.get_scan(scan_id)
-    scan.terminate()
-    return jsonify({'success': True})
-
-def get_scan_config():
-    """
-    pulls config from the request body
-    """
-    data = request.get_json()
-    return ScanConfig(
-        subnet = data['subnet'],
-        port_list= data['port_list'],
-        t_multiplier=data.get('parallelism',1.0)
-    )

lanscape/ui/blueprints/api/tools.py

@@ -1,30 +0,0 @@
-from flask import request, jsonify
-from . import api_bp
-from ....libraries.net_tools import get_all_network_subnets
-from ....libraries.ip_parser import parse_ip_input
-from ....libraries.errors import SubnetTooLargeError
-import traceback
-
-
-@api_bp.route('/api/tools/subnet/test')
-def test_subnet():
-    subnet = request.args.get('subnet')
-    if not subnet: return jsonify({'valid': False, 'msg': 'Subnet cannot be blank', 'count': -1})
-    try:
-        ips = parse_ip_input(subnet)
-        length = len(ips)
-        return jsonify({'valid': True, 'msg': f"{length} IP{'s' if length > 1 else ''}", 'count': length})
-    except SubnetTooLargeError:
-        return jsonify({'valid': False, 'msg': 'subnet too large', 'error': traceback.format_exc(), 'count': -1})
-    except:
-        return jsonify({'valid': False, 'msg': 'invalid subnet', 'error': traceback.format_exc(), 'count': -1})
-    
-@api_bp.route('/api/tools/subnet/list')
-def list_subnet():
-    """
-    list all interface subets
-    """
-    try: 
-        return jsonify(get_all_network_subnets())
-    except:
-        return jsonify({'error': traceback.format_exc()})

lanscape/ui/blueprints/web/__init__.py

@@ -1,5 +0,0 @@
-from flask import Blueprint
-
-web_bp = Blueprint('web', __name__)
-
-from . import routes

lanscape/ui/blueprints/web/routes.py

@@ -1,74 +0,0 @@
-from flask import render_template, request, redirect
-from . import web_bp
-from ....libraries.subnet_scan import SubnetScanner
-from ....libraries.net_tools import (
-    get_all_network_subnets, 
-    smart_select_primary_subnet
-)
-from .. import scan_manager, log
-import os
-
-# Template Renderer
-############################################
-@web_bp.route('/', methods=['GET'])
-def index():
-    subnets = get_all_network_subnets()
-    subnet = smart_select_primary_subnet(subnets)
-    
-    port_list = 'medium'
-    parallelism = 1
-    if scan_id := request.args.get('scan_id'): 
-        if scan := scan_manager.get_scan(scan_id):
-            subnet = scan.cfg.subnet
-            port_list = scan.cfg.port_list
-            parallelism = scan.cfg.t_multiplier
-            
-        else:
-            log.debug(f'Redirecting, scan {scan_id} doesnt exist in memory')
-            return redirect('/')
-    return render_template(
-            'main.html',
-            subnet=subnet, 
-            port_list=port_list, 
-            parallelism=parallelism,
-            alternate_subnets=subnets
-        )
-    
-
-@web_bp.route('/scan/<scan_id>', methods=['GET'])
-@web_bp.route('/scan/<scan_id>/<section>', methods=['GET'])
-def render_scan(scan_id, section='all'):
-    if scanner := scan_manager.get_scan(scan_id):
-        data = scanner.results.export()
-        filter = request.args.get('filter')
-        return render_template('scan.html', data=data, section=section, filter=filter)
-    log.debug(f'Redirecting, scan {scan_id} doesnt exist in memory')
-    return redirect('/')
-
-@web_bp.route('/errors/<scan_id>')
-def view_errors(scan_id):
-    if scanner := scan_manager.get_scan(scan_id):
-        data = scanner.results.export()
-        return render_template('scan/scan-error.html',data=data)
-    log.debug(f'Redirecting, scan {scan_id} doesnt exist in memory')
-    return redirect('/')
-
-@web_bp.route('/export/<scan_id>')
-def export_scan(scan_id):
-    if scanner := scan_manager.get_scan(scan_id):
-        export_json = scanner.results.export(str)
-        return render_template(
-            'scan/export.html',
-            scan=scanner,
-            export_json=export_json
-        )
-    log.debug(f'Redirecting, scan {scan_id} doesnt exist in memory')
-    return redirect('/')
-
-@web_bp.route('/shutdown-ui')
-def shutdown_ui():
-    return render_template('shutdown.html')
-
-@web_bp.route('/info')
-def app_info():
-    return render_template('info.html')