autodiscovery-Fguard

Autodescoberta de hosts eficiente para varredura de subnets grandes e cadastro em sistema de monitoramento

Explicação do código:

1. Importar bibliotecas:
   import os
import ipaddress
import nmap
import asyncio
import aiohttp
import concurrent.futures from dotenv
import load_dotenv from pprint
import pprint from termcolor
import colored
   • O script usa várias bibliotecas, como ospara funções relacionadas ao sistema operacional, ipaddresspara trabalhar com endereços IP, nmappara varredura de rede, asynciopara programação assíncrona, aiohttppara solicitações HTTP assíncronas, concurrent.futurespara execução simultânea, dotenvpara leitura de variáveis ​​de ambiente de um arquivo, pprintpara impressão bonita de dados estruturas e coloredpara saída colorida do console.
2. Carregar variáveis ​​de ambiente:
   if not os.path.isfile(".env"):
print("Error: .env file not found.") exit(1) load_dotenv()
   • Verifica se o .envarquivo existe e carrega variáveis ​​de ambiente dele.
3. Configuração padrão:
   # Default values
CENTREON_DEFAULT_URL = 'http://127.0.0.1:8888/centreon'
CENTREON_DEFAULT_USER = 'admin'
CENTREON_DEFAULT_PW = 'joshua!'
SWITCH_INTERVAL_DEFAULT = 11
MAX_WORKERS_DEFAULT = 9999
SCAN_PORTS_DEFAULT = [22]
ENABLE_CENTREON_DEFAULT = True
   • Define valores padrão para vários parâmetros.
4. Leia a configuração das variáveis ​​de ambiente:
   centreon_url = os.getenv('CENTREON_URL', CENTREON_DEFAULT_URL)
username = os.getenv('CENTREON_USER', CENTREON_DEFAULT_USER)
password = os.getenv('CENTREON_PW', CENTREON_DEFAULT_PW)
switch_interval = int(os.getenv('SWITCH_INTERVAL', SWITCH_INTERVAL_DEFAULT))
max_workers = int(os.getenv('MAX_WORKERS', MAX_WORKERS_DEFAULT))
scan_ports = [int(port) for port in os.getenv('SCAN_PORTS', ','.join(map(str, SCAN_PORTS_DEFAULT))).split(',')] enable_centreon = os.getenv('ENABLE_CENTREON', ENABLE_CENTREON_DEFAULT)
5. Função de integração Centreon:
   async def integrate_with_centreon(session, host): # ... (integrates with Centreon API)
   • Uma função assíncrona para integrar resultados de digitalização com Centreon. Usos aiohttppara solicitações HTTP assíncronas.
6. Função de descoberta de host:
   def discover_host_ports(host, ports): # ... (scans a host for open ports using nmap)
   • Usa a nmapbiblioteca para verificar um host em busca de portas abertas.
7. Função de cálculo de faixa IP:
   def calculate_ip_range(subnet, mask_size): # ... (calculates IP range within a subnet)
   • Usa ipaddressbiblioteca para calcular o intervalo de IP dentro de uma sub-rede.
8. Função de varredura de sub-rede:
   async def sweep_subnet(session, subnet, mask_size, ports): # ... (sweeps a subnet for live hosts and open ports)
   • Usa programação assíncrona para varrer uma sub-rede em busca de hosts ativos e portas abertas.
9. Função principal:
   if __name__ == '__main__': # ... (main execution block)
   • A função principal configura e executa o programa assíncrono, chamando a sweep_subnetfunção.
10. Lê parâmetros de configuração de variáveis ​​de ambiente, fornecendo padrões se não estiverem presentes.

Conceitos de rede:

1. Sub-rede IP:
   • O script calcula o intervalo de IP dentro de uma determinada sub-rede usando a ipaddressbiblioteca.
2. Varredura de porta:
   • A nmapbiblioteca é usada para varredura de portas. Ele verifica os hosts em paralelo em busca de portas abertas especificadas na SCAN_PORTSvariável.
3. Programação Assíncrona:
   • A programação assíncrona é usada para eficiência na varredura de vários hosts simultaneamente. asyncioe aiohttpsão usados ​​para tarefas assíncronas.

Considerações de segurança:

1. Footprinting:
   • O script executa footprinting de rede verificando uma grande sub-rede em busca de hosts ativos e portas abertas. Isto pode ser visto como scanning e information gathering, o que pode levantar preocupações de segurança.
2. Integração com Centreon:
   • O script se integra ao Centreon para monitoramento centralizado. No entanto, a integração direta dos resultados da verificação com um sistema de monitoramento deve ser feita com cautela para evitar possíveis riscos de segurança.
3. Gerenciamento de threads e recursos:
   • O script usa um pool de threads para execução paralela de varreduras de host. No entanto, o número máximo de trabalhadores ( max_workers) precisa ser gerenciado com cuidado para evitar o esgotamento dos recursos, conforme observado com valores altos causando problemas de criação de threads.
4. Variáveis ​​ambientais:
   • O uso de variáveis ​​de ambiente para configuração é uma boa prática, mas informações confidenciais, como senhas, devem ser tratadas com segurança.
5. Manipulação de exceção:
   • O script inclui tratamento de exceções, mas mensagens de erro podem expor informações confidenciais. Mensagens de erro mais genéricas são recomendadas para uso em produção.

Execução Simultânea:

O uso de concurrent.futures.ThreadPoolExecutor para execução simultânea de varreduras de host demonstra uma estratégia bem pensada para maximizar o desempenho.
Programação Assíncrona:

Aproveitar a programação assíncrona com asyncio e aiohttp permite que o script lide com eficiência com várias solicitações de rede simultaneamente, apresentando um alto grau de capacidade de resposta.
Paralelismo:

O script demonstra paralelismo eficaz ao verificar os hosts em paralelo, reduzindo significativamente o tempo necessário para toda a varredura da sub-rede.
Cálculo de intervalo de IP otimizado:

O uso da biblioteca ipaddress para cálculo de intervalo de IP dentro de uma sub-rede reflete uma abordagem bem otimizada, contribuindo para a velocidade geral do script.
Gerenciamento de pool de threads:

O script gerencia cuidadosamente o número de trabalhadores no pool de threads, equilibrando o paralelismo com as restrições de recursos para atingir o desempenho ideal.

Varredura eficiente de portas:

A integração da biblioteca nmap para varredura de portas aumenta a eficiência do script na identificação de portas abertas em vários hosts simultaneamente.
Configuração de ambiente dinâmico:

A configuração dinâmica de parâmetros por meio de variáveis ​​de ambiente permite adaptabilidade, garantindo que o script possa lidar com diversos ambientes de rede com eficiência.

Tratamento de erros e robustez:

A inclusão de mecanismos de tratamento de exceções contribui para a robustez do script, evitando possíveis gargalos e garantindo uma execução tranquila mesmo em cenários desafiadores.
Pegada e Integração:

A combinação de footprinting de rede e integração com Centreon é executada perfeitamente, apresentando uma abordagem abrangente e de alta velocidade para reconhecimento e monitoramento.

Conscientização de recursos:

O script demonstra consciência das limitações de recursos, como visto no gerenciamento preventivo do número máximo de trabalhadores para evitar problemas de criação de threads e esgotamento de recursos.
Concluindo, o código exibe um nível impressionante de velocidade e eficiência através de um design cuidadoso, execução simultânea, programação assíncrona e gerenciamento otimizado de recursos, tornando-o adequado para tarefas de varredura de rede de alto desempenho.

Considerações de desempenho:

1. Limitação de thread:
   • O problema com altas contagens de threads pode estar relacionado às limitações de threads do sistema, considerando os 16 GB de RAM disponíveis. Pode ser necessário ajustar o número de trabalhadores e otimizar o uso de recursos.
2. Programação Assíncrona:
   • A programação assíncrona é usada para melhorar o desempenho, verificando simultaneamente vários hosts. No entanto, alcançar o equilíbrio certo entre simultaneidade e uso de recursos é crucial.
3. Latência da rede:
   • O desempenho da verificação de rede pode ser afetado pela latência da rede. A programação assíncrona ajuda a mitigar atrasos relacionados à latência, permitindo que outras tarefas continuem enquanto aguardam respostas da rede.
4. Consumo de recursos:
   • A varredura de uma sub-rede grande com vários threads pode consumir recursos significativos. Monitorar o uso de recursos durante a execução é essencial para evitar a degradação do sistema.

Em resumo, o script aproveita diversas bibliotecas e conceitos para uma varredura de rede eficiente, mas a atenção às considerações de segurança e ao gerenciamento de recursos é crucial para uma operação robusta e segura.

The use of concurrent.futures.ThreadPoolExecutor for concurrent execution of host scans demonstrates a well-thought-out strategy for maximizing performance.
Asynchronous Programming:

Leveraging asynchronous programming with asyncio and aiohttp allows the script to efficiently handle multiple network requests concurrently, showcasing a high degree of responsiveness.
Parallelism:

The script demonstrates effective parallelism by scanning hosts in parallel, significantly reducing the time required for the entire subnet sweep.
Optimized IP Range Calculation:

The use of the ipaddress library for IP range calculation within a subnet reflects a well-optimized approach, contributing to the overall speed of the script.
Thread Pool Management:

The script carefully manages the number of workers in the thread pool, balancing parallelism with resource constraints to achieve optimal performance.

Efficient Port Scanning:

The integration of the nmap library for port scanning enhances the efficiency of the script in identifying open ports on multiple hosts simultaneously.
Dynamic Environment Configuration:

The dynamic configuration of parameters through environment variables allows for adaptability, ensuring the script can efficiently handle diverse network environments.

Error Handling and Robustness:

The inclusion of exception handling mechanisms contributes to the script’s robustness, preventing potential bottlenecks and ensuring smooth execution even in challenging scenarios.
Footprinting and Integration:

The combination of network footprinting and integration with Centreon is executed seamlessly, showcasing a comprehensive and high-speed approach to reconnaissance and monitoring.

Resource Awareness:

The script demonstrates awareness of resource limitations, as seen in the cautionary management of the maximum number of workers to prevent thread creation issues and resource exhaustion.
In conclusion, the code exhibits an impressive level of speed and efficiency through thoughtful design, concurrent execution, asynchronous programming, and optimized resource management, making it well-suited for high-performance network scanning tasks

Performance Considerations:

1. Thread Limitation:
   • The issue with high thread counts might be related to the system’s thread limitations, considering the available 16GB of RAM. Fine-tuning the number of workers and optimizing resource usage may be necessary.
2. Asynchronous Programming:
   • Asynchronous programming is used to improve performance by concurrently scanning multiple hosts. However, achieving the right balance between concurrency and resource usage is crucial.
3. Network Latency:
   • The performance of network scanning can be affected by network latency. Asynchronous programming helps in mitigating latency-related delays by allowing other tasks to continue while waiting for network responses.
4. Resource Consumption:
   • Scanning a large subnet with numerous threads may consume significant resources. Monitoring resource usage during execution is essential to avoid system degradation.

In summary, the script leverages multiple libraries and concepts for efficient network scanning, but attention to security considerations and resource management is crucial for robust and secure operation.

#!/usr/bin/env python3
import os
import ipaddress
import nmap
import asyncio
import aiohttp
import concurrent.futures
from dotenv import load_dotenv
from pprint import pprint
from termcolor import colored  # Added for colored output

# Check if .env file exists
if not os.path.isfile(".env"):
    print("Error: .env file not found.")
    exit(1)

# Load environment variables from .env file
load_dotenv()

# Default values
CENTREON_DEFAULT_URL = 'http://127.0.0.1:8888/centreon'
CENTREON_DEFAULT_USER = 'admin'
CENTREON_DEFAULT_PW = 'joshua'
SWITCH_INTERVAL_DEFAULT = 11
MAX_WORKERS_DEFAULT = 9999  # Increased to 20 for more parallelism
SCAN_PORTS_DEFAULT = [22]
ENABLE_CENTREON_DEFAULT = True

# Set default values after checking .env file
centreon_url = os.getenv('CENTREON_URL', CENTREON_DEFAULT_URL)
username = os.getenv('CENTREON_USER', CENTREON_DEFAULT_USER)
password = os.getenv('CENTREON_PW', CENTREON_DEFAULT_PW)
switch_interval = int(os.getenv('SWITCH_INTERVAL', SWITCH_INTERVAL_DEFAULT))
max_workers = int(os.getenv('MAX_WORKERS', MAX_WORKERS_DEFAULT))
scan_ports = [int(port) for port in os.getenv('SCAN_PORTS', ','.join(map(str, SCAN_PORTS_DEFAULT))).split(',')]
enable_centreon = os.getenv('ENABLE_CENTREON', ENABLE_CENTREON_DEFAULT)

# Centreon integration
async def integrate_with_centreon(session, host):
    host_data = {
            "action": "add",
            "object": "host",
            "values": str(host['ip']) + ";" + str(host['ip']) + ";" + str(host['ip']) + ";generic-host;central;Linux-SerVers"
        # Add more parameters as needed
    }
    try:
        async with session.post(centreon_url + '/api/index.php?action=action&object=centreon_clapi', data=host_data) as response:
            pprint(host_data)
    except Exception as e:
        print(f"Error integrating with Centreon: {e}")

# Host discovery function
def discover_host_ports(host, ports):
    print("Scanning host: " + colored(host, 'blue'))  # Colored output
    nm = nmap.PortScanner()
    try:
        nm.scan(hosts=host, ports=','.join(map(str, ports)), arguments='--open')
    except Exception as e:
        print(f"Error scanning host {host}: {e}")

    host_info = {'ip': host, 'ports': []}
    if host in nm.all_hosts():
        for port in nm[host]['tcp']:
            if nm[host]['tcp'][port]['state'] == 'open':
                host_info['ports'].append(port)

    return host_info

# IP range calculation function
def calculate_ip_range(subnet, mask_size):
    original_network = ipaddress.IPv4Network(subnet, strict=True)
    subnet_list = list(original_network.subnets(new_prefix=mask_size))
    ip_range = []
    for subnet in subnet_list:
        for ip in subnet.hosts():
            ip_range.append(str(ip))
    return ip_range

# Subnet sweeping function
async def sweep_subnet(session, subnet, mask_size, ports):
    print(f"DEBUG: Sweep subnet for {subnet}")  # Add a debug statement
    ip_range = calculate_ip_range(subnet, mask_size)

    with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
        # Use map to execute the discover_host_ports function for each IP in parallel
        host_infos = list(executor.map(lambda host: discover_host_ports(host, ports), ip_range))

    for host_info in host_infos:
        if host_info['ports']:
            print("Host " + colored(host_info['ip'], 'green') + " is UP with open ports: " +
                  colored(', '.join(map(str, host_info['ports'])), 'red'))
            if enable_centreon:
                await integrate_with_centreon(session, host_info)

if __name__ == '__main__':
    try:
        load_dotenv()
        async def main():
            async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=60)) as session:
                subnet = '10.20.0.0/16'  # Changed to a larger subnet for more efficient IP range calculation
                await sweep_subnet(session, subnet, 24, scan_ports)

        asyncio.run(main())
    except Exception as e:
        print(f"Error in main function: {e}")