Czy mogę szybko skanować sieć lokalną pod kątem określonych otwartych portów?

Question

Chciałbym wiedzieć, czy istnieje sposób na skanowanie w zakresie IP mojej sieci lokalnej dla otwartych portów o określonym numerze.

Zasadniczo szukam nodejs, aby znaleźć klientów określonego typu bez znajomości ich adresów IP. W tym przypadku czytniki RFID, które nasłuchują na porcie 14150.

Chciałbym, aby to skanowanie było szybkie, więc nie chcę długiego czasu między poszczególnymi adresami IP. Powinny się zdarzyć dość szybko, być może w ciągu kilku sekund max dla całego lokalnego zakresu adresów IP do 255 klientów, z wyłączeniem własnego adresu IP.

Napisałem kod, który robi to, co chcę, ale jest boleśnie powolny ... Chciałbym zobaczyć, jak mogę to przyspieszyć, przepuszczając połączenia i wychodząc, jeśli nie można nawiązać połączenia z danym adresem IP w ciągu 20 ms . Chcę uchwycić rzeczywiste połączenia w tablicy, które będę mógł wykorzystać w innym celu.

var net = require('net'); // Required to create socket connections 

var ip = 254; //IP address to start with on a C class network 

function checkConnect() { 
    ip--; 
    var thisIP = '192.168.1.' + ip; //concatenate to a real IP address 

    var S = new net.Socket(); 
    S.connect(80, thisIP); 

    if(ip > 0) { checkConnect(); } 

    S.on('connect', function() { console.log('port 80 found on ' + thisIP); }); 
    S.on('error', function() { console.log('no such port on ' + thisIP); }); 
    S.end(); 
} 

checkConnect(); 

Answer 1

Żadna z poprzednich odpowiedzi nie zadziałała tak, jak potrzebowałem. Znalazłem znacznie lżejszą alternatywę. Dzięki temu rozwiązaniu szybko otrzymuję rozwiązanie. Moja następna aktualizacja będzie polegała na określeniu zakresu hostów na podstawie bieżącej podsieci. Wyobrażam sobie, że będę chciał ograniczyć to do pierwszych 254 klientów, więc to nie jest przesada. Oto kod:

//LLRP DEVICE SCANNER 
var net = require('net'), Socket = net.Socket; 

var checkPort = function(port, host, callback) { 
    var socket = new Socket(), status = null; 

    // Socket connection established, port is open 
    socket.on('connect', function() {status = 'open';socket.end();}); 
    socket.setTimeout(1500);// If no response, assume port is not listening 
    socket.on('timeout', function() {status = 'closed';socket.destroy();}); 
    socket.on('error', function(exception) {status = 'closed';}); 
    socket.on('close', function(exception) {callback(null, status,host,port);}); 

    socket.connect(port, host); 
} 

var LAN = '192.168.1'; //Local area network to scan (this is rough) 
var LLRP = 5084; //globally recognized LLRP port for RFID readers 

//scan over a range of IP addresses and execute a function each time the LLRP port is shown to be open. 
for(var i=1; i <=255; i++){ 
    checkPort(LLRP, LAN+'.'+i, function(error, status, host, port){ 
     if(status == "open"){ 
      console.log("Reader found: ", host, port, status); 
     } 
    }); 
} 

Answer 2

Zamiast wysyłania odnośnik (link może pójść martwy w jednym momencie), wyślę kod tutaj samouczek ze strony:

var net = require('net'); 

// the machine to scan 
var host = 'localhost'; 
// starting from port number 
var start = 1; 
// to port number 
var end = 10000; 
// sockets should timeout asap to ensure no resources are wasted 
// but too low a timeout value increases the likelyhood of missing open sockets, so be careful 
var timeout = 2000; 

// the port scanning loop 
while (start <= end) { 

    // it is always good to give meaningful names to your variables 
    // since the context is changing, we use `port` to refer to current port to scan 
    var port = start; 

    // we create an anonynous function, pass the current port, and operate on it 
    // the reason we encapsulate the socket creation process is because we want to preseve the value of `port` for the callbacks 
    (function(port) { 
     // console.log('CHECK: ' + port); 
     var s = new net.Socket(); 

     s.setTimeout(timeout, function() { s.destroy(); }); 
     s.connect(port, host, function() { 
      console.log('OPEN: ' + port); 
      // we don't destroy the socket cos we want to listen to data event 
      // the socket will self-destruct in 2 secs cos of the timeout we set, so no worries 
     }); 

     // if any data is written to the client on connection, show it 
     s.on('data', function(data) { 
      console.log(port +': '+ data); 
      s.destroy(); 
     }); 

     s.on('error', function(e) { 
      // silently catch all errors - assume the port is closed 
      s.destroy(); 
     }); 
    })(port); 

    start++; 
} 

Answer 3

Zrobiłem to dla ciebie https://github.com/eviltik/evilscan. (Właśnie wydała v0.0.3 dzisiaj)

Install:

npm install -g evilscan 

Wykorzystanie (lista portów + zakres portów):

root@debian:~# evilscan --target=192.168.0.0/24 --port=21-446,5900 --concurrency=100 --progress 
192.168.0.3:5900|open 
192.168.0.26:53|open 
192.168.0.26:111|open 
192.168.0.26:81|open 
192.168.0.26:23|open 
Scanned 192.168.0.253:446 (100%) 

Porady:

Dla bardzo szybkie skanowanie, możesz grać z parametrem "współbieżność" eterze, ponad 1000, ale musisz najpierw zaktualizować parametr ulimit twojego linuksa:

ulimit -u unlimited 

Mam nadzieję, że ta pomoc.

Answer 4

Możesz użyć polecenia arp, aby uzyskać listę urządzeń, które są żywe jako pierwsze. Pomyśl poza zestawem;) Nie musisz skanować wszystkich urządzeń na ślepo.

var child = require("child_process"); 
var async = require("async"); 
var net = require("net"); 
var os = require("os"); 

function scan(port, cb){ 
    var hosts = {}; 
    var result = []; 
    async.series([ 
     function scan(next, c){ 
      if(c == 1){ 
       next(); return; 
      } 
      // scan twice because arp sometimes does not list all hosts on first time 
      child.exec("arp -n | awk '{print $1}' | tail -n+2", function(err, res){ 
       if(err) cb(err); 
       else { 
        var list = res.split("\n").filter(function(x){return x !== "";}); 
        list.map(function(x){ 
         hosts[x] = x; 
        }); 
       } 
       scan(next, 1); 
      }); 
     }, 
     function(next){ 
      // if you want to scan local addresses as well 
      var ifs = os.networkInterfaces(); 
      Object.keys(ifs).map(function(x){ 
       hosts[((ifs[x][0])||{}).address] = true; 
      }); 
      // do the scan 
      async.each(Object.keys(hosts), function(x, next){ 
       var s = new net.Socket(); 
       s.setTimeout(1500, function(){s.destroy(); next();}); 
       s.on("error", function(){ 
        s.destroy(); 
        next(); 
       }); 
       s.connect(port, x, function(){ 
        result.push(x); 
        s.destroy(); 
        next(); 
       }); 
      }, function(){ 
       next(); 
      }); 
     } 
    ], function(){ 
     cb(null, result); 
    }); 
} 

scan(80, function(err, hosts){ 
    if(err){ 
     console.error(err); 
    } else { 
     console.log("Found hosts: "+hosts); 
    } 
}); 

Możesz również użyć narzędzia arp-scan, które jest bardziej niezawodne. Ale arp-scan wymaga dostępu root do pracy, więc lepiej po prostu użyć arp. Jest dostępny na prawie każdym polu Linux.