Cela fait longtemps que j’aimerais me lancer dans la programmation réseau car c’est un domaine où je me sens vierge de connaissance.

Pour remédier à cette lacune, je vais tenter de détecter toutes les IP visibles sur mon réseau privé.

On y trouve, comme dans beaucoup de maison, des ordinateurs, des téléphones/tablettes, des appareils multimedia, …

Mon but, dans un premier temps, est de simplement les lister! Je verrai ensuite si il y a moyen (bien sûre que oui) de les présenter un peu mieux à l’écran…

Donc, pour réaliser cela, il faut déjà savoir ce qu’il y a lieu de faire! Une petite recherche s’impose.

Si l’on en croit Wikipedia, il existe différents protocols associés au transfert de données. Les plus importants étant IPv4, IPv6, mais aussi Internet Stream Protocol, TP/IX, PIP ou encore TUBA.

Pour ce que j’ai l’intention de réaliser, je vais, de toute évidence utiliser les 2 premiers protocols nommés ci dessus IPv4 et IPv6.

L’IPv4 est un protocol permettant de codé une adresse sur 32bits et donc un peu plus de 4 milliards de combinaison. C’est pas mal mais insuffisant pour le monde dans lequel nous vivons, quoique bien assez pour un réseau privé.

L’IPv6 par contre permet de coder une adresse sur 128bits, ce qui offre bien plus de possibilités (environ 3.4 x 10³⁸ combinaisons 340 milliards de milliards de milliards de milliards de combinaisons). Est ce vraiment nécessaire pour un réseau privé??? Oui et non mais ceci est une autre discution.

Bref! Dans un premier temps, je vais juste me limiter au protocol IPv4 car, à priori, ce serait le protocol le plus utilisé au sein d’un réseau privé.

Toujours sur cette même page Wikipedia on peut voir un schéma assez grossier mais néanmoins intéressant de ce que l’on peut trouver dans l’entête d’un protocol IPv4. Pour une question de visibilité, les informations ont été regroupées par tranche de 32bits (1 DWORD)

4 bits version (ici 0100 = 4)
4 bits IHL (je ne sais pas encore ce que c’est)
8 bits ToS (encore un truc à apprendre)
16 bits Total Length (La longueur totale, je suppose du paquet puisque l’entête a une taille fixe)
16 bits Identification (Serait ce un numéro unique??? Étrange! Je croyais justement que c’était l’IP qui faisait cela…)
2 bits Flags (Je ne sais pas encore à quoi cela correspond)
14 bits Fragment Offset (La position du paquet dans une liste de paquets qui pourraient arriver dans le désordre) (( mmmm Est ce que cela aurait un rapport avec Identification ci dessus???))
8 bits Time To Live (Un timeout, je suppose)
8 bits Protocol (L’identificateur du protocol employé par dessus IP tel que UDP ou TCP)
16 bits Header Checksum (Le seul moyen de vérifier que cette entête ci n’est pas corrompue)
32 bits Source Address (L’adresse IP de l’émetteur du paquet en cours)
32 bits Destination Address (l’adresse IP du destinataire du paquet en cours)
24 bits Options (Voilà un truc bien explicite…)
8 bits Padding (Y aurait il un espace entre les différentes données ou bien un formatage préétabli??? À voir en profondeur…).

MMMMM! C’est intéressent tout cela mais est ce que j’ai besoin vraiment de connaître tout cela pour réaliser mon petit projet basique? C’est le moment d’aller voir ce qu’il convient de faire pour tenter de repérer ce qui se trouve sur le réseau privé! Si j’en crois le protocol, en écoutant se qu’il se passe sur le réseau, on peut connaître qui envoie et qui reçoit un paquet. C’est bien, c’est déjà 2 IP connues mais si une machine n’émet pas, il est impossible de savoir si elle existe. (C’est comme un prof qui fait sa prise de présence pour la première fois. Il ne sais pas à qui il s’adresse ni même si il a reçu des noms inexistant.) Techniquement, l’adresse de destination est peut être une erreur de l’envoyeur. Mais également, l’adresse de la source pourrait être fausse, c’est pas interdit d’écrire n’importe quoi! Mieux que cela, une même machine pourrait avoir plus d’une adresse IP…

Ceci étant développé, n’y aurait il pas quelque chose qui permettrait à 2 machines de se dire bonjour, de se saluer, de se donner la main, …

Ça, je connais déjà la réponse, il suffit de jouer au ping pong… Tout ordinateur est capable d’envoyer et de recevoir un ping et/ou d’y répondre par un pong. C’est un peu comme si un ordi dit bonjour je m’appelle IP x est ce que IP y est bel et bien là? Et ensuite l’ordinateur y répond Bonjour je suis bien là!

C’est franchement plus pratique que de manipuler les paquets IP directement, quoique une combinaison des 2 devrait nous apporter énormément d’informations utiles!

La commande Ping sur un ordinateur est une implémentation du protocol ICMP par dessus le protocol IP qui permet de demander à une machine distante de savoir si elle est bien présente. Cela permet également de connaître le temps de réponse du serveur mais également le nombre de routeur que l’on peut trouver entre les 2 machines grâce au fameux TTL (Time To Live vu plus haut)

Donc, si j’ai bien compris, pour connaître les machines disponible sur un réseau privé, il suffit d’envoyer un Ping à toutes les adresses possible de ce réseau et de contrôler si on a une réponse ou non!

Tout cela, c’est bien mais cela ne reste que de la théorie! En pratique, qu’en est il? Existe t’il des librairies permettant de faire tout ce petit travail ou bien il faut réinventer la roue? Je pense qu’il y a un programme qui fait déjà le travail et qui s’appellerait nmap me semble t’il! Je vais aller voir cela de suite…

En effet NMAP est bel et bien ce que je pensais, et c’est même mieux que cela puisqu’il est possible également avec ce programme de connaître les ports ouverts et ainsi connaître quels sont les protocols à utiliser, pour autant que les numéros de port soient respecté par rapport à leur fonction dictée, mais aussi par le message que ces ports renvoie lors d’une interrogation…

Afin de ne pas réécrire ce genre de logiciel, ne serait il pas intéressent d’écrire un programme qui donne les options à nmap et qui récupère sa sortie???

Comme écrit ci dessus dans le titre, je suis triste de ne pas avoir écrit plus tôt sur le site.

Je n’ai pas d’excuse valable, j’aurais pu écrire ce que j’étais en train de faire…

Néanmoins, j’étais occupé à chercher comment faire passer une commande de l’API de Binance pour mon Shell, et c’est seulement après plusieurs jours que je me suis rendu compte que je cherchais à exécuter cette fameuse commande sur une mauvaise URL de base.

Bien sûre, je me suis senti gêné vis à vis de moi même! Comment voulez vous que j’écrive quoi que ce soit sur le site dans ces conditions là!

Mais alors, pourquoi le fais je maintenant??? C’est très simple! Après mûre réflexion, il est inutile d’être gêné de mal faire une chose. C’est justement en faisant mal certaine chose que nous apprenons à avancer. Et donc, écrire ceci en ce moment ne me cause absolument pas de tord. Par contre, cela peut fort bien aider la personne en train de le lire, entre autre, vous qui lisez.

Ne vous arrêtez pas en chemin, continuez d’avancer et il ne vous arrivera que du bon!

Après avoir cherché longtemps ce qui pouvait se faire de mieux en matière de logging en java, j’en suis revenu aux sources.

En effet, le namespace java.util contient une classe logger suffisement complète pour pouvoir y faire tout ce que l’on désire.

Cette classe, à elle seule ne sert pas à grand chose, mais combinée à un Handler ainsi qu’un Formater, qui sont toutes deux des classes de java.util, va permettre de créé des logs, aussi bien directement sur la console que dans un fichier ou un socket sur la toile.

Ce qui m’intéresse ici, c’est un log au format xml. Il existe une classe XmlFormater toute faite pour le réaliser mais elle ne donne pas de référence à un fichier xsl pour la conversion automatique par un browser internet. J’ai donc créé un nouveau Formater avec cette fameuse ligne en plus et créé également ce fichier xsl.

Pour information, il ne reste plus que internet explorer qui accepte de réaliser la conversion localement. Pour les autres browser, il faut passer par un serveur web pour une question de sécurité parait il…

Voici donc les listings qui me permettent de créer un log en java. Je ne rentrerai pas dans des explications en détail mais si vous avez besoin d’informations, vous pouvez toujours laisser un commentaire sous l’article, je me ferai un plaisir de le lire et d’y répondre.

	private static Logger logger;

	public static void createLogger() {
		logger = Logger.getLogger("binanceshell.application");
		Handler loghandler;
		try {
			loghandler = new FileHandler("myTestingLogFile.xml");
			loghandler.setFormatter(new MyXmlFormatter());
			//System.out.println(loghandler.getFormatter().getTail(loghandler));
			logger.addHandler(loghandler);
		} catch (SecurityException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}		
	}

Pour écrire un log, il suffit de faire:

logger.log(Level.INFO,"Application Start!");

Ci dessous, je donne une copie de la classe MyXmlFormatter, qui crée une sortie au format xml le plus simplement possible:

package be.dagal.java.crypto.application.binanceshell;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.logging.Formatter;
import java.util.logging.Handler;
import java.util.logging.LogRecord;

public class MyXmlFormatter extends Formatter {
	private static final SimpleDateFormat SDF = new SimpleDateFormat("MM/dd/yyyy hh:mm:ss");
	@Override
	public String getHead(Handler h) {
		return "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\r\n"
				+ "<?xml-stylesheet href=\"logger.xsl\" type=\"text/xsl\"?>\r\n"
				+ "<!DOCTYPE log SYSTEM \"logger.dtd\">\r\n"
				+ "<log>\r\n";
	}
	@Override
	public String getTail(Handler h) {
		return "</log>\r\n";
	}
	@Override
	public String format(LogRecord record) {
		return "<record>\r\n"
				+ "  <date>" + SDF.format(new Date(record.getMillis())) + "</date>\r\n"
				+ "  <millis>" + record.getMillis() + "</millis>\r\n"
				+ "  <sequence>" + record.getSequenceNumber() + "</sequence>\r\n"
				+ "  <logger> " + record.getResourceBundleName()+"</logger>\r\n"
				+ "  <level>" + record.getLevel() + "</level>\r\n"
				+ "  <class>" + record.getSourceClassName() + "</class>\r\n"
				+ "  <method>" + record.getSourceMethodName() + "</method>\r\n"
				+ "  <thread>" + record.getThreadID() + "</thread>\r\n"
				+ "  <message>" + record.getMessage() + "</message>\r\n"
				+ "</record>\r\n";
	}

}

J’espère que cela suffira à donner des idées à certains.

Étant donné qu’il faut absolument que les fichiers xml et xsl soient sur un serveur, j’ai installé un serveur XAMPP qui fourni Apache, MySQL, PHP, Perl, Tomcat, et j’en passe bien d’autre. Ce bundle de serveur pour GNU/Linux, MS Windows, Mac OS est entièrement gratuit, et je crois même que tout est open source, sans vouloir m’avancer trop loin.

Maintenant que j’ai un serveur web opérationnel, et tout ce qui va avec, je vais pouvoir trouver un emplacement pour y mettre mes fichiers de log mais aussi un semblant de site internet qui va me permettre de faire tout mes tests.

Je vais donc commencer à réfléchir à ce que je vais mettre dans ce site, et par la même occasion, à ce que je dois écrire en java, php, html, xml, xhtml, xsl, dtd, css, …

Au cœur du système se trouvera BinanceShell, un interpréteur de commande spécialement développé pour l’API de Binance.

Dans un premier temps les entrées sorties se feront uniquement via la console, et par la même occasion via un tunnel local (pipe)

Par la suite, je compte bien créer d’autres interractions comme un nouveau Rest/Post commun avec d’autres broker que Binance. Cela serait bien utile pour un programme plus général.

La sortie se fera uniquement en XML dans un premier temps, et sur la console.

Les possibilités futur sont infinie: http, telegram, twitter, etc…

Je viens donc de démarrer un projet en java pour réaliser cet interpréteur purement console dans un premier temps.

Le fait de l’écrire en java permettra de changer d’ordinateur facilement sans devoir compiler le programme 150000x