Logo Hardware.com.br
whitehat
whitehat Novo Membro Registrado
97 Mensagens 18 Curtidas

Scan em rede problema!

#1 Por whitehat 18/01/2025 - 16:25
boa tarde companheiros!
estou com um problema com um script
meu objetivo é escanear minha rede atrás de ips desconhecidos...
mas nunca acha nada, tenho 1 tv, 2 celulares e 1 desktop nessa rede, mas não acha o ip deles.
meu router: 192.168.0.1



#!/usr/bin/python3

#-*-coding: utf-8-*-

import socket

router = str(input("Router: &quot)

ports = [22,80,443,631,53]

start = 2

end = 31

ip_len = 0

with open("MapperLog.txt","a&quot as lists:

    for run in range(start, end):

        for port in ports:

            target = router[:-1]

            target = target + str(run)

            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:

                sock.settimeout(0.1)

                status = sock.connect_ex((target, port))

                print("IP Router-> {}, porta-> {}".format(target, port))

                print("Passando scan...&quot

                if status == 0:

                    with open("MapperLog.txt","a&quot as lists:

                        lists.write("IP ativo na rede[{}] pela porta[{}]\n".format(target, port))

                        ip_len += 1

ip_len = ip_len/3

print("IP`s online: ", ip_len)

lists.close()

sock.close()
python rede scan roteador
hudson-266
hudson-266 Zerinho Registrado
2 Mensagens 0 Curtidas
#2 Por hudson-266
19/01/2025 - 16:10
whitehat disse:

‎
E aí, meu querido!

Tenta usar o protocolo ARP para descoberta em LAN: 

from scapy.all import ARP, Ether, srp

import ipaddress



def ping_arp(network):

    try:

        # Verifica se a rede é válida

        ip_network = ipaddress.ip_network(network, strict=False)

    except ValueError:

        print(f"Rede inválida: {network}&quot

        return



    print(f"Escaneando a rede: {network}...&quot

    

    # Criação do pacote ARP

    # 'ff:ff:ff:ff:ff:ff' é o endereço MAC de broadcast

    arp_request = ARP(pdst=str(ip_network))

    broadcast = Ether(dst="ff:ff:ff:ff:ff:ff&quot

    packet = broadcast / arp_request



    # Envia o pacote e recebe as respostas

    answered, unanswered = srp(packet, timeout=2, verbose=False)



    # Lista para armazenar os IPs e MACs ativos

    devices = []



    # Processa as respostas

    for sent, received in answered:

        devices.append({'ip': received.psrc, 'mac': received.hwsrc})



    # Exibe os dispositivos encontrados

    if devices:

        print(f"Dispositivos ativos na rede {network}:&quot

        for device in devices:

            print(f"IP: {device['ip']}, MAC: {device['mac']}&quot

    else:

        print(f"Nenhum dispositivo ativo encontrado na rede {network}.&quot



# Rede alvo (ex.: 192.168.1.0/24)

rede=str(input("Rede (ex.: 192.168.1.0/24): &quot)

ping_arp(rede)


Ou com protocolo ICMP e TCP (conectar nas portas desejadas):

from scapy.all import sr1, IP, ICMP, TCP

import socket

import ipaddress



# Lista de portas para verificar

PORTAS = [22, 80, 443, 8080, 631, 53]



# Função para enviar um ping ICMP

def enviar_ping(ip):

    try:

        resposta = sr1(IP(dst=ip)/ICMP(), timeout=1, verbose=False)

        if resposta:

            return True

    except Exception as e:

        pass

    return False



# Função para verificar portas TCP

def verificar_portas_tcp(ip, portas):

    portas_responsivas = []

    for porta in portas:

        try:

            # Conexão TCP

            pacote = IP(dst=ip)/TCP(dport=porta, flags="S&quot

            resposta = sr1(pacote, timeout=1, verbose=False)

            if resposta and (resposta[TCP].flags == "SA" or resposta[TCP].flags == "RA&quot:

                portas_responsivas.append(porta)

        except Exception:

            pass

    return portas_responsivas



# Função principal

def escanear_rede(rede):

    try:

        # Valida a rede fornecida

        ip_rede = ipaddress.ip_network(rede, strict=False)

    except ValueError:

        print(f"Rede inválida: {rede}&quot

        return



    print(f"Escaneando a rede: {rede}...\n&quot

    hosts_ativos = []



    for ip in ip_rede.hosts():

        ip_str = str(ip)

        print(f"Verificando {ip_str}...&quot



        # Verifica se o host responde ao ping

        if enviar_ping(ip_str):

            print(f"{ip_str} respondeu ao ping!&quot

            hosts_ativos.append(ip_str)

            continue



        # Tenta conexão nas portas especificadas

        portas = verificar_portas_tcp(ip_str, PORTAS)

        if portas:

            print(f"{ip_str} respondeu em portas TCP: {portas}&quot

            hosts_ativos.append(ip_str)



    print("\nDispositivos ativos encontrados:&quot

    for host in hosts_ativos:

        print(host)



# Rede alvo no formato CIDR

rede_alvo = str(input("Rede (ex.: 192.168.1.0/24): &quot)

escanear_rede(rede_alvo)


Os scripts requerem privilégios administrativos. E o scan em um rede inteira pode demorar. Qualquer coisa ajusta pra apenas um host.

Vlw!

Boa sorte!

PS.: Qual SO tá usando?
© 1999-2025 Hardware.com.br. Todos os direitos reservados.
Imagem do Modal