🔒 Cisco Security & Device APIs

#!/usr/bin/env python3
"""
IOS XE NETCONF Example
Configuration management using ncclient
"""

from ncclient import manager
import xmltodict

# Connect to IOS XE device
def connect_netconf(host, port, username, password):
    """Establish NETCONF session"""
    device = {
        'host': host,
        'port': port,
        'username': username,
        'password': password,
        'hostkey_verify': False,
        'device_params': {'name': 'iosxe'}
    }
    
    conn = manager.connect(**device)
    print(f"✅ NETCONF session established with {host}")
    return conn

# Get running configuration
def get_config(conn):
    """Retrieve running configuration"""
    config = conn.get_config(source='running')
    print("✅ Retrieved running configuration")
    return config

# Get specific interface configuration
def get_interface(conn, interface_name):
    """Get interface configuration using filter"""
    
    # NETCONF filter (XML)
    interface_filter = f"""
    
        
            
                {interface_name}
            
        
    
    """
    
    result = conn.get(interface_filter)
    print(f"✅ Retrieved configuration for {interface_name}")
    return result

# Configure interface
def configure_interface(conn, interface_name, description):
    """Configure interface description"""
    
    # NETCONF edit-config payload
    config_data = f"""
    
        
            
                {interface_name}
                {description}
            
        
    
    """
    
    response = conn.edit_config(target='running', config=config_data)
    print(f"✅ Interface {interface_name} configured")
    return response

# Main execution
if __name__ == "__main__":
    # Connection details
    HOST = "ios-xe-device.example.com"
    PORT = 830
    USERNAME = "admin"
    PASSWORD = "cisco"
    
    # Connect
    conn = connect_netconf(HOST, PORT, USERNAME, PASSWORD)
    
    # Get interface info
    get_interface(conn, "GigabitEthernet1")
    
    # Configure interface
    configure_interface(conn, "GigabitEthernet1", "Configured via NETCONF")
    
    # Close connection
    conn.close_session()
    print("✅ NETCONF session closed")

#!/usr/bin/env python3
"""
IOS XE RESTCONF Example
RESTful interface to YANG models
"""

import requests
import json
from requests.auth import HTTPBasicAuth

# Disable SSL warnings for lab
import urllib3
urllib3.disable_warnings()

class IOSXERestconf:
    """IOS XE RESTCONF API Client"""
    
    def __init__(self, host, username, password):
        self.base_url = f"https://{host}/restconf/data"
        self.auth = HTTPBasicAuth(username, password)
        self.headers = {
            'Accept': 'application/yang-data+json',
            'Content-Type': 'application/yang-data+json'
        }
    
    def get_interfaces(self):
        """Get all interfaces"""
        url = f"{self.base_url}/ietf-interfaces:interfaces"
        
        response = requests.get(
            url,
            auth=self.auth,
            headers=self.headers,
            verify=False
        )
        
        if response.status_code == 200:
            interfaces = response.json()['ietf-interfaces:interfaces']['interface']
            print(f"✅ Found {len(interfaces)} interfaces")
            for intf in interfaces[:5]:
                print(f"  {intf['name']}: {intf.get('description', 'No description')}")
            return interfaces
        else:
            print(f"❌ Error: {response.status_code}")
            return []
    
    def get_interface(self, name):
        """Get specific interface"""
        url = f"{self.base_url}/ietf-interfaces:interfaces/interface={name}"
        
        response = requests.get(
            url,
            auth=self.auth,
            headers=self.headers,
            verify=False
        )
        
        if response.status_code == 200:
            intf = response.json()['ietf-interfaces:interface']
            print(f"\nInterface: {intf['name']}")
            print(f"  Type: {intf['type']}")
            print(f"  Enabled: {intf.get('enabled', False)}")
            print(f"  Description: {intf.get('description', 'N/A')}")
            return intf
        return None
    
    def configure_interface(self, name, description, enabled=True):
        """Configure interface via RESTCONF"""
        url = f"{self.base_url}/ietf-interfaces:interfaces/interface={name}"
        
        data = {
            "ietf-interfaces:interface": {
                "name": name,
                "description": description,
                "enabled": enabled
            }
        }
        
        response = requests.patch(
            url,
            auth=self.auth,
            headers=self.headers,
            json=data,
            verify=False
        )
        
        if response.status_code in [200, 204]:
            print(f"✅ Interface {name} configured")
            return True
        else:
            print(f"❌ Error: {response.status_code} - {response.text}")
            return False

# Usage
device = IOSXERestconf('cat9k.example.com', 'admin', 'cisco')
device.get_interfaces()
device.configure_interface('GigabitEthernet1/0/1', 'Uplink to Core', enabled=True)

#!/usr/bin/env python3
"""
NX-OS NX-API CLI Example
Execute CLI commands programmatically
"""

import requests
import json
from requests.auth import HTTPBasicAuth

class NXOSDevice:
    """NX-OS NX-API Client"""
    
    def __init__(self, host, username, password):
        self.url = f"https://{host}/ins"
        self.auth = HTTPBasicAuth(username, password)
        self.headers = {'Content-Type': 'application/json'}
    
    def execute_command(self, command):
        """Execute single CLI command"""
        payload = {
            "ins_api": {
                "version": "1.0",
                "type": "cli_show",
                "chunk": "0",
                "sid": "1",
                "input": command,
                "output_format": "json"
            }
        }
        
        response = requests.post(
            self.url,
            auth=self.auth,
            headers=self.headers,
            json=payload,
            verify=False
        )
        
        if response.status_code == 200:
            result = response.json()['ins_api']['outputs']['output']
            return result['body']
        else:
            print(f"❌ Error: {response.status_code}")
            return None
    
    def execute_config(self, commands):
        """Execute configuration commands"""
        payload = {
            "ins_api": {
                "version": "1.0",
                "type": "cli_conf",
                "chunk": "0",
                "sid": "1",
                "input": commands,
                "output_format": "json"
            }
        }
        
        response = requests.post(
            self.url,
            auth=self.auth,
            headers=self.headers,
            json=payload,
            verify=False
        )
        
        if response.status_code == 200:
            print("✅ Configuration applied")
            return True
        else:
            print(f"❌ Error: {response.status_code}")
            return False
    
    def show_version(self):
        """Get device version information"""
        result = self.execute_command("show version")
        if result:
            print(f"\nHostname: {result.get('host_name', 'N/A')}")
            print(f"Software: {result.get('nxos_ver_str', 'N/A')}")
            print(f"Uptime: {result.get('kern_uptm_days', 'N/A')} days")
        return result
    
    def show_interfaces(self):
        """Get interface status"""
        result = self.execute_command("show interface brief")
        if result:
            interfaces = result['TABLE_interface']['ROW_interface']
            print(f"\n✅ Interfaces ({len(interfaces)}):")
            for intf in interfaces[:5]:
                print(f"  {intf['interface']}: {intf['state']}")
        return result
    
    def configure_interface_description(self, interface, description):
        """Configure interface description"""
        commands = f"""
        interface {interface}
        description {description}
        """
        return self.execute_config(commands)

# Usage Example
device = NXOSDevice('nxos-switch.example.com', 'admin', 'admin')
device.show_version()
device.show_interfaces()
device.configure_interface_description('Ethernet1/1', 'Uplink via API')

# Enable IOx (application hosting)
configure terminal
iox
exit

# Enable Guest Shell
guestshell enable

# Access Guest Shell
guestshell

# Inside Guest Shell - run Python
python3
>>> import cli
>>> output = cli.execute('show version')
>>> print(output)

#!/usr/bin/env python3
"""
IOS XE Guest Shell Python Example
Using CLI module for device interaction
"""

# Import CLI module (available in Guest Shell)
import cli

# Execute show command
def show_command(command):
    """Execute show command and return output"""
    output = cli.execute(command)
    print(f"Executing: {command}")
    print(output)
    return output

# Configure device
def configure_device(config_commands):
    """Apply configuration commands"""
    output = cli.configure(config_commands)
    print("✅ Configuration applied")
    print(output)
    return output

# Example usage
if __name__ == "__main__":
    # Show commands
    show_command("show version")
    show_command("show ip interface brief")
    
    # Configuration
    config = """
    interface GigabitEthernet1
    description Configured from Python
    """
    configure_device(config)