Question obtenir l'identifiant unique de la machine


Je souhaite obtenir le numéro de série unique de l’ordinateur pour le logiciel sans avoir à le copier.

J'ai essayé avec le numéro de série du processeur et le numéro de série du disque dur qui changent tous après le formatage et la réinstallation des fenêtres.

Une idée de la façon dont je peux obtenir un numéro de série immuable d'un ordinateur?


26
2018-01-05 07:55


origine


Réponses:


Vous pouvez utiliser Créateur de code WMI. Je suppose que vous pouvez avoir une combinaison de "clés" (clé processeurid, mac et logiciel).

using System.Management;
using System.Windows.Forms;

try
{
     ManagementObjectSearcher searcher = 
         new ManagementObjectSearcher("root\\CIMV2", "SELECT * FROM Win32_Processor"); 

     foreach (ManagementObject queryObj in searcher.Get())
     {
         Console.WriteLine("-----------------------------------");
         Console.WriteLine("Win32_Processor instance");
         Console.WriteLine("-----------------------------------");
         Console.WriteLine("Architecture: {0}", queryObj["Architecture"]);
         Console.WriteLine("Caption: {0}", queryObj["Caption"]);
         Console.WriteLine("Family: {0}", queryObj["Family"]);
         Console.WriteLine("ProcessorId: {0}", queryObj["ProcessorId"]);
     }
}
catch (ManagementException e)
{
    MessageBox.Show("An error occurred while querying for WMI data: " + e.Message);
}

Win32_Processor

Récupération d'identifiants matériels en C # avec WMI par Peter Bromberg


14
2018-01-20 07:21



Si vous avez besoin d'un identifiant unique, vous devez d'abord décider de votre définition de unique. Si vous souhaitez / avez l'intention de l'utiliser pour un mécanisme de protection contre la copie, utilisez quelque chose de simple. En effet, si quelqu'un veut vraiment utiliser votre logiciel, il trouvera un moyen de briser votre protection, avec suffisamment de temps et de compétences. Dans le cas d'un identifiant matériel unique, pensez aux machines virtuelles et vous verrez qu'il est possible d'usurper n'importe quoi pour que quelqu'un puisse manipuler votre logiciel.

Il n'y a pas grand chose que vous pouvez prendre sur un PC et le considérer comme unique sur toute sa durée de vie. (Les modifications matérielles nécessiteront très probablement une régénération de l'ID à un moment donné.) Si vous avez besoin de quelque chose comme ça, vous devriez rechercher une authentification. Clé USB que vous pouvez envoyer à vos clients.

Si vous avez juste besoin d'un identifiant unique qui n'est pas aussi difficile à obtenir, vous pouvez prendre l'adresse MAC (non fiable), le numéro de série du système d'exploitation ou le nom du domaine et de l'utilisateur, mais tous risquent d'être falsifiés. Cependant, si votre objectif principal est de bloquer les personnes non autorisées, vous ne vendez rien car personne ne voudra utiliser votre logiciel s'il est difficile à installer, enregistrer ou déplacer d'un PC à un autre, même si la dernière considération est partie intégrante de la licence par machine. (Cela se produira probablement assez souvent.)

Dans un premier temps, simplifiez-vous la tâche: utilisez un outil simple qui ne soit pas facile à utiliser dans votre groupe cible. (Par exemple, les noms de domaine et d’utilisateur ne peuvent pas être facilement usurpés par les clients d’entreprise, car leurs PC fonctionnent dans un environnement plus étendu mettant en œuvre des règles, etc.) Oubliez les autres jusqu’à

Peut-être que vous pouvez les verrouiller mais cela ne signifie pas qu'ils vont acheter votre logiciel; ils ne vont tout simplement plus l'utiliser. Ce que vous devez considérer, c'est combien de clients potentiels ne seront pas ou ne seront pas prêts à payer parce que vous avez rendu la tâche si compliquée d'utiliser votre programme.


14
2018-01-05 08:37



Je resterais bien loin des adresses MAC. Sur certains matériels, l'adresse MAC peut changer lorsque vous redémarrez. Au début de nos recherches, nous avons appris à ne pas compter sur cela.

Jetez un oeil à l'article Développement pour la protection logicielle et les licences qui propose des conseils sur la conception et la mise en œuvre d’applications pour réduire le piratage.

Déni de responsabilité obligatoire & plug: la société que j'ai cofondée produit le Solution de licence OffByZero Cobalt. Vous ne serez donc probablement pas surpris d'apprendre que je vous recommande d'externaliser vos licences et de vous concentrer sur vos compétences de base.


10
2018-01-20 04:56



Check-out Cet article. C'est très exhaustif et vous trouverez comment extraire diverses informations sur le matériel.

Citation du article:

Pour obtenir des informations sur le matériel, vous devez créer un objet de classe ManagementObjectSearcher.

using System.Management;
ManagementObjectSearcher searcher = new ManagementObjectSearcher("select * from " + Key);
foreach (ManagementObject share in searcher.Get()) {
    // Some Codes ...
}

La clé du code ci-dessus est une variable remplacée par les données appropriées. Par exemple, pour obtenir les informations du processeur, vous devez remplacer la clé par Win32_Processor.


4
2018-01-05 08:14



edit: Je viens de voir que tu voulais dire en c #. Voici un meilleur moyen avec du code non géré:

ManagementClass oMClass = new ManagementClass ("Win32_NetworkAdapterConfiguration");
ManagementObjectCollection colMObj = oMCLass.GetInstances();
foreach(ManagementObject objMO in colMObj)
    Console.WriteLine(objMO["MacAddress"].ToString());

3
2018-01-05 07:59



Je seconde la suggestion de Blindy d'utiliser l'adresse MAC de la (première?) Carte réseau. Oui, l'adresse MAC peut être falsifiée, mais cela a des effets secondaires (vous ne voulez pas deux PC avec la même adresse MAC sur le même réseau), et "votre pirate moyen" ne le fera pas simplement pour pouvoir utiliser votre logiciel. Étant donné qu'il n'y a pas de solution à 100% contre le piratage de logiciels, l'adresse MAC est un bon compromis, IMO.

Notez toutefois que l'adresse changera lorsque l'utilisateur ajoute, remplace ou supprime une carte réseau (ou remplace son ancien ordinateur), alors préparez-vous à aider vos clients et à leur donner une nouvelle clé lorsqu'ils changent de configuration matérielle.


2
2018-01-05 08:21



Oui, nous pourrions obtenir un code combinant une adresse physique, un identifiant de lecteur unique, un identifiant de disque dur (numéro de série), un identifiant de processeur et un identifiant de BIOS. Exemple (Exemple complet):

//Main physical hard drive ID
    private static string diskId()
    {
        return identifier("Win32_DiskDrive", "Model")
        + identifier("Win32_DiskDrive", "Manufacturer")
        + identifier("Win32_DiskDrive", "Signature")
        + identifier("Win32_DiskDrive", "TotalHeads");
    }
    //Motherboard ID
    private static string baseId()
    {
        return identifier("Win32_BaseBoard", "Model")
        + identifier("Win32_BaseBoard", "Manufacturer")
        + identifier("Win32_BaseBoard", "Name")
        + identifier("Win32_BaseBoard", "SerialNumber");
    }

2
2017-11-04 16:36



Vous ne devriez pas utiliser MAC, sa mauvaise façon. Parce que certains OS ne font que le changer tous les jours. Mon expirience: Tools.CpuID.ProcessorId () + volumeSerial;

string volumeSerial = "";
    try {
        ManagementObject dsk = new ManagementObject(@"win32_logicaldisk.deviceid=""C:""");
        dsk.Get();
        volumeSerial = dsk["VolumeSerialNumber"].ToString();
    } catch {
        try {
            ManagementObject dsk = new ManagementObject(@"win32_logicaldisk.deviceid=""D:""");
            dsk.Get();
            volumeSerial = dsk["VolumeSerialNumber"].ToString();
        } catch { File.WriteAllText("disk.mising","need C or D"); Environment.Exit(0); }
    }

public class CpuID
    {
        [DllImport("user32", EntryPoint = "CallWindowProcW", CharSet = CharSet.Unicode, SetLastError = true, ExactSpelling = true)]
        private static extern IntPtr CallWindowProcW([In] byte[] bytes, IntPtr hWnd, int msg, [In, Out] byte[] wParam, IntPtr lParam);

        [return: MarshalAs(UnmanagedType.Bool)]
        [DllImport("kernel32", CharSet = CharSet.Unicode, SetLastError = true)]
        public static extern bool VirtualProtect([In] byte[] bytes, IntPtr size, int newProtect, out int oldProtect);

        const int PAGE_EXECUTE_READWRITE = 0x40;



        public static string ProcessorId()
        {
            byte[] sn = new byte[8];

            if (!ExecuteCode(ref sn))
                return "ND";

            return string.Format("{0}{1}", BitConverter.ToUInt32(sn, 4).ToString("X8"), BitConverter.ToUInt32(sn, 0).ToString("X8"));
        }

        private static bool ExecuteCode(ref byte[] result)
    {
        int num;

        /* The opcodes below implement a C function with the signature:
         * __stdcall CpuIdWindowProc(hWnd, Msg, wParam, lParam);
         * with wParam interpreted as an 8 byte unsigned character buffer.
         * */

        byte[] code_x86 = new byte[] {
            0x55,                      /* push ebp */
            0x89, 0xe5,                /* mov  ebp, esp */
            0x57,                      /* push edi */
            0x8b, 0x7d, 0x10,          /* mov  edi, [ebp+0x10] */
            0x6a, 0x01,                /* push 0x1 */
            0x58,                      /* pop  eax */
            0x53,                      /* push ebx */
            0x0f, 0xa2,                /* cpuid    */
            0x89, 0x07,                /* mov  [edi], eax */
            0x89, 0x57, 0x04,          /* mov  [edi+0x4], edx */
            0x5b,                      /* pop  ebx */
            0x5f,                      /* pop  edi */
            0x89, 0xec,                /* mov  esp, ebp */
            0x5d,                      /* pop  ebp */
            0xc2, 0x10, 0x00,          /* ret  0x10 */
        };
        byte[] code_x64 = new byte[] {
            0x53,                                     /* push rbx */
            0x48, 0xc7, 0xc0, 0x01, 0x00, 0x00, 0x00, /* mov rax, 0x1 */
            0x0f, 0xa2,                               /* cpuid */
            0x41, 0x89, 0x00,                         /* mov [r8], eax */
            0x41, 0x89, 0x50, 0x04,                   /* mov [r8+0x4], edx */
            0x5b,                                     /* pop rbx */
            0xc3,                                     /* ret */
        };

        byte[] code;

        if (IsX64Process())
            code = code_x64;
        else 
            code = code_x86;

        IntPtr ptr = new IntPtr(code.Length);

        if (!VirtualProtect(code, ptr, PAGE_EXECUTE_READWRITE, out num))
            Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error());

        ptr = new IntPtr(result.Length);

        try {
            return (CallWindowProcW(code, IntPtr.Zero, 0, result, ptr) != IntPtr.Zero);
        } catch { System.Windows.Forms.MessageBox.Show("Память повреждена"); return false; }
    }

        private static bool IsX64Process()
        {
            return IntPtr.Size == 8;
        }

    }

2
2018-01-16 12:02



Vous pouvez essayer d'obtenir des informations du bios. Ce sera toujours valable après un format.


-5
2018-05-04 18:54