Création d'identifiant unique pour une marchine par un programme

Bonjour,

Pour un projet personnel je commence à pointer une problématique assez importante à propos d'une fonctionnalité d'un programme que je dois réaliser.

En vue d'une communication réseau entre plusieurs acteurs (différents programmes aux buts divers), les machines doivent être identifiables. Un client lorsqu'il parle à un serveur doit indiquer qui il est en premier lieu. Ainsi mon programme doit générer un identifiant aléatoire au premier lancement (une sorte d'installation du programme). Cette génération passée, tout lancement du programme doit utiliser cet identifiant !

Les problématiques sont les suivantes :

• Le programme doit générer un identifiant (l'utilisation de l'ip+port de la machine n'est pas envisagée)
• L'identifiant une fois généré ne doit plus être modifiable, d'aucune façon que ce soit, par l'utilisateur du programme (c'est probablement impossible, mais il faut que cet identifiant soit suffisamment protégé).

Le programme générant un id sera codé en c++ (ce qui importe peu en fait), mais je me pose des questions sur la façon de rendre la plus compliquée possible la modification ultérieure d'un tel identifiant.

J'ai d'abord pensé à un fichier - le client pourrai écrire cet identifiant dans un fichier. Mais ce fichier doit être caché, dans un dossier particulier. Alors le programme pourra regarder à cet endroit si un identifiant existe, alors il pourra l'utiliser. Seulement un fichier est très facilement modifiable, il suffit de trouver le chemin où est stocké l'id pour le modifier.

Idéalement cet id doit pouvoir être récupérable par le programme, qu'il soit visible par l'utilisateur n'est pas un problème en soi, cependant la modification est un problème majeur pour mon programme.

Je me dis qu'il existe forcémment des applications utilisant un tel système, comment tout cela fonctionne, comment faire en sorte de stocker des informations de façon à ce qu'elles soient difficilement modifiables ?

J'espère être clair dans ce que je dis, le problème n'est pas forcemment simple à expliquer

Merci d'avance pour vos réponses, j'ai hâte de vous lire !

edit : y a t'il une carte à jouer si on regarde la date de derniere modification de l'id stocké en fichier ? Un exécutable peut-il se modifier lui-même afin de stocker l'id/cette date de modification directement en lui-même ?

edit2 : si le programme crypte l'identifiant de façon à ce que seul lui sache retrouver cet id s'il le souhaite ? quid de la clé utilisée pour crypter l'id alors ? L'id pourrait être crypté avec clé qui peut être retrouvée par le programme (par le calcul) ?

Lu'!

Tu ne pourras jamais garantir que personne ne modifiera cet identifiant stocké sur la machine. Sinon, j'ai envie de dire hash de l'adresse MAC ou du numéro de série de la carte mère.

Effectivement je sais bien qu'il est impossible de garantir que l'identifiant n'est pas modifié, cependant le hash de l'adresse MAC/n° de carte mère semble une bonne idée, l'utilisation d'un élément matériel semble intéressant du coup. Mon identifiant doit être généré sur 160 bits. Complètement aléatoirement il est statistiquement très improbable (quasi impossible) d'obtenir deux id identiques sur des nombres d'identifiants "raisonables" (un réseau de plusieurs millions de machines). Il doit pouvoir être possible de générer un id à partir de l'adresse MAC de la machine donc, en la donnant comme seed à un algo comme sha-1 par exemple.

Merci pour la réponse

Bonsoir,

Es-tu vraiment obligé de stocker l'identifiant sur le poste client ? A chaque installation d'un nouveau client réussie, l'identifiant pourrait être envoyé au serveur qui le mémorise - je parle d'un serveur central, type serveur de licence qu'on retrouve pour certains logiciels.

Ensuite à chaque lancement de l'application, le client génère son identifiant dynamiquement (il sera invariable s'il se base sur adresse mac ou autre composant) et l'envoie à ce même serveur pour que celui-ci le vérifie.

Et voilà une excellente occasion d'utiliser une fonction de hachage moderne

En version courte, tu ne peux pas.

Si quelqu'un veut se faire passer pour un nouvel utilisateur, il peut.

Si tu veux empêcher l'usurpation d'identité, là, on commence à pouvoir faire des choses. Ca va reposer sur de l'obfuscation, donc ce n'est pas sur à 100%, mais on peut rendre difficile l'usurpation d'identité. L'idée de base est de créer un identifiant et de le signer. La signature doit être dépendante du matériel, qui peut servir de sel ou d'altération d'une clef de chiffrement.

Il y a donc deux choses qui vont poser problème: garder la clef de chiffrement/signature secrète, et trouver un identifiant de la machine qui soit pénible à dupliquer. Le premier point se traite par les méthodes d'obfuscation de données dans un programme, le second est plus complexe: il faut trouver une information unique, présente partout, mais pénible à falsifier (au niveau logiciel, on peut tout falsifier, adresse MAC et id de carte mère inclus). L'identifiant de la carte mère, c'est bien, si il existe une méthode standard de le récupérer, et que la personne dont on veut usurper l'identité n'est pas complice (si elle est prête à donner son id de carte mère, ça va être facile de donner de fausses infos au programme).

J'ai déjà fait un système où j'allais lire l'identifiant du processeur en y accédant par adresse physique, c'est assez difficile à contourner, mais sur des systèmes moins maitrisés, comme un PC, c'est difficilement applicable.

Ah sa première connexion, l'application peut demander au serveur une clé (Que le serveur mémorisera ainsi que le client) relié à l'adresse mac de la machine.

La clé sera modifiable, mais le serveur remarquera que la clé ne correspond pas à l'adresse mac.

Après je ne connais pas les moyens de modifier l'adresse mac ou autre (Ni d’ailleurs si elle est récupérable ?) mais la on s'avance loin déjà.

Merci pour toutes vos réponses ça fait plaisir ! La communauté du zds se densifie c'est bien

Pour revenir au problème, je parle ici d'un réseau, d'une organisation client/serveur, en revanche l'identifiant doit être généré sur le client de façon complètement indépendant du serveur, il ne s'agit pas ici d'identifier une connexion entre client et serveur, mais uniquement de stocker un id de la machine (exactement comme l'adresse mac en fait).

Se baser sur l'adresse mac me semble un bon choix, je peut en tirer un digest de 160 bits facilement. Je n'ai plus qu'un problème du coup : m'assurer de générer un hash 160 bits avec une mac address en particulier, ou toutes à défaut, vu qu'une machine à plusieurs interfaces