Puis-je analyser rapidement mon réseau local pour des ports ouverts spécifiques?

Je voudrais savoir si il existe un moyen pour numériser à travers mon réseau local IP de gamme pour ouvrir les ports d'un numéro spécifique.

Essentiellement, je suis à la recherche d' nodejs de trouver des clients d'un type spécifique sans connaître leurs adresses IP. Dans ce cas, les lecteurs RFID qui sont à l'écoute sur le port 14150.

J'aimerais que ce scan rapide, donc je ne veux pas d'un long délai d'attente entre chaque adresse IP. Ils devraient tous se faire assez rapidement, peut-être dans quelques secondes max pour toute une IP locale gamme de jusqu'à 255 clients, à l'exclusion de ma propre IP.

J'ai écrit un code qui fait ce que je veux, mais c'est terriblement lent... je voudrais voir comment je peux faire cela plus rapidement par flamboyante à travers les liens et de s'en sortir si une connexion ne peut pas être faite à une adresse IP au sein de 20ms. Je veux capturer les connexions réelles dans un tableau que je peux utiliser pour un autre usage.

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();

source d'informationauteur clayperez

  1. 18

    Je l'ai fait pour vous https://github.com/eviltik/evilscan. (vient de sortir v0.0.3 aujourd'hui)

    Installer:

    npm install -g evilscan

    Utilisation (liste de port + la plage de ports) :

    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%)

    Conseils :

    Très rapide de balayage, vous pouvez jouer avec la "simultanéité" paramètre, plus de 1000, mais vous devez mettre à jour ulimit paramètre de votre linux première :

    ulimit -u unlimited

    Espérons que cette aide.

  2. 6

    Aucune des réponses précédentes vraiment travaillé la façon dont j'avais besoin. J'ai trouvé beaucoup de poids plus léger alternative. Avec cette solution, je reçois ma solution rapidement. Ma prochaine mise à jour sera pour spécifier une plage d'hôtes du sous-réseau actuel. J'imagine que je vais vouloir le limiter à la première 254 clients de sorte qu'il n'est pas exagéré. Voici le code:

    //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);
        }
    });
}
  3. 5

    Vous pouvez utiliser la commande arp pour obtenir une liste des périphériques qui sont vivants en premier. Pensez à l'extérieur de la boîte 😉 Vous n'avez pas de scanner tous les périphériques à l'aveuglette. 

    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);
} 
});

    Vous pouvez également utiliser arp-scan utilitaire, il est plus fiable. Mais arp-scan besoins d'accès à la racine de travail, il est donc préférable d'utiliser le protocole arp. Il est disponible sur à peu près tous les linux.

  4. 1

    Au lieu de simplement poster le lien (le lien peut aller morte à un moment), je vais poster le tutoriel ici de code à partir du site:

    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++;
}