.net 软件注册功能的简单实现

最新推荐文章于 2020-05-10 15:05:00 发布

weixin_30919571

最新推荐文章于 2020-05-10 15:05:00 发布

阅读量229

点赞数

原文链接：http://www.cnblogs.com/gxlxzys/archive/2007/07/12/815752.html

版权

相信很多初学编程的人都会对这个软件注册功能很感兴趣，我也不例外，刚学asp.net时，竞找不到这方面的实例，结果自己参考微软的一些文档自己做了一个，其实我做的这个注册功能很简单，读取计算机的CPU序列号，用MD5加密（经过处理）生成一个机器码，然后再把这个机器码处理一下就生成了注册码，在asp.net的配置文件web.config中加了一个键，用于存储注册码，程序运行时读取机器码，然后再生成注册码，对照一下配置文件内的注册码，如果一致就说明程序已注册，否则未注册。同时也做了一个注册机，用于生成注册码。注册机运行结果：

下面是代码：
1、首先是读取机器序列号的类Hardware,网上找来的

  1 using System;
  2 using System.Runtime.InteropServices;
  3 using System.Management;
  4 namespace Hardware
  5 {
  6      /// <summary>
  7      /// Hardware_Mac 的摘要说明。
  8      /// </summary>
  9      public class HardwareInfo
10     {
11          // 取机器名
12          public string GetHostName()
13         {
14              return System.Net.Dns.GetHostName();
15         }
16
17          // 取CPU编号
18          public String GetCpuID()
19         {
20              try
21             {
22                 ManagementClass mc = new ManagementClass( " Win32_Processor " );
23                 ManagementObjectCollection moc = mc.GetInstances();
24
25                 String strCpuID = null ;
26                  foreach (ManagementObject mo in moc)
27                 {
28                     strCpuID = mo.Properties[ " ProcessorId " ].Value.ToString();
29                      break ;
30                 }
31                  return strCpuID;
32             }
33              catch
34             {
35                  return "" ;
36             }
37
38         } // end method
39
40          // 取第一块硬盘编号
41          public String GetHardDiskID()
42         {
43              try
44             {
45                 ManagementObjectSearcher searcher =
                     new ManagementObjectSearcher( " SELECT * FROM Win32_PhysicalMedia " );
46                 String strHardDiskID = null ;
47                  foreach (ManagementObject mo in searcher.Get())
48                 {
49                     strHardDiskID = mo[ " SerialNumber " ].ToString().Trim();
50                      break ;
51                 }
52                  return strHardDiskID;
53             }
54              catch
55             {
56                  return "" ;
57             }
58         } // end
59
60          public enum NCBCONST
61         {
62             NCBNAMSZ = 16 , /* absolute length of a net name */
63             MAX_LANA = 254 , /* lana's in range 0 to MAX_LANA inclusive */
64             NCBENUM = 0x37 , /* NCB ENUMERATE LANA NUMBERS */
65             NRC_GOODRET = 0x00 , /* good return */
66             NCBRESET = 0x32 , /* NCB RESET */
67             NCBASTAT = 0x33 , /* NCB ADAPTER STATUS */
68             NUM_NAMEBUF = 30 , /* Number of NAME's BUFFER */
69         }
70
71         [StructLayout(LayoutKind.Sequential)]
72          public struct ADAPTER_STATUS
73         {
74             [MarshalAs(UnmanagedType.ByValArray, SizeConst = 6 )]
75              public byte [] adapter_address;
76              public byte rev_major;
77              public byte reserved0;
78              public byte adapter_type;
79              public byte rev_minor;
80              public ushort duration;
81              public ushort frmr_recv;
82              public ushort frmr_xmit;
83              public ushort iframe_recv_err;
84              public ushort xmit_aborts;
85              public uint xmit_success;
86              public uint recv_success;
87              public ushort iframe_xmit_err;
88              public ushort recv_buff_unavail;
89              public ushort t1_timeouts;
90              public ushort ti_timeouts;
91              public uint reserved1;
92              public ushort free_ncbs;
93              public ushort max_cfg_ncbs;
94              public ushort max_ncbs;
95              public ushort xmit_buf_unavail;
96              public ushort max_dgram_size;
97              public ushort pending_sess;
98              public ushort max_cfg_sess;
99              public ushort max_sess;
100              public ushort max_sess_pkt_size;
101              public ushort name_count;
102         }
103
104         [StructLayout(LayoutKind.Sequential)]
105          public struct NAME_BUFFER
106         {
107             [MarshalAs(UnmanagedType.ByValArray, SizeConst = ( int )NCBCONST.NCBNAMSZ)]
108              public byte [] name;
109              public byte name_num;
110              public byte name_flags;
111         }
112
113         [StructLayout(LayoutKind.Sequential)]
114          public struct NCB
115         {
116              public byte ncb_command;
117              public byte ncb_retcode;
118              public byte ncb_lsn;
119              public byte ncb_num;
120              public IntPtr ncb_buffer;
121              public ushort ncb_length;
122             [MarshalAs(UnmanagedType.ByValArray, SizeConst = ( int )NCBCONST.NCBNAMSZ)]
123              public byte [] ncb_callname;
124             [MarshalAs(UnmanagedType.ByValArray, SizeConst = ( int )NCBCONST.NCBNAMSZ)]
125              public byte [] ncb_name;
126              public byte ncb_rto;
127              public byte ncb_sto;
128              public IntPtr ncb_post;
129              public byte ncb_lana_num;
130              public byte ncb_cmd_cplt;
131             [MarshalAs(UnmanagedType.ByValArray, SizeConst = 10 )]
132              public byte [] ncb_reserve;
133              public IntPtr ncb_event;
134         }
135
136         [StructLayout(LayoutKind.Sequential)]
137          public struct LANA_ENUM
138         {
139              public byte length;
140             [MarshalAs(UnmanagedType.ByValArray, SizeConst = ( int )NCBCONST.MAX_LANA)]
141              public byte [] lana;
142         }
143
144         [StructLayout(LayoutKind.Auto)]
145          public struct ASTAT
146         {
147              public ADAPTER_STATUS adapt;
148             [MarshalAs(UnmanagedType.ByValArray, SizeConst = ( int )NCBCONST.NUM_NAMEBUF)]
149              public NAME_BUFFER[] NameBuff;
150         }
151          public class Win32API
152         {
153             [DllImport( " NETAPI32.DLL " )]
154              public static extern char Netbios( ref NCB ncb);
155         }
156
157          public string GetMacAddress()
158         {
159              string addr = "" ;
160              try
161             {
162                  int cb;
163                 ASTAT adapter;
164                 NCB Ncb = new NCB();
165                  char uRetCode;
166                 LANA_ENUM lenum;
167
168                 Ncb.ncb_command = ( byte )NCBCONST.NCBENUM;
169                 cb = Marshal.SizeOf( typeof (LANA_ENUM));
170                 Ncb.ncb_buffer = Marshal.AllocHGlobal(cb);
171                 Ncb.ncb_length = ( ushort )cb;
172                 uRetCode = Win32API.Netbios( ref Ncb);
173                 lenum = (LANA_ENUM)Marshal.PtrToStructure(Ncb.ncb_buffer, typeof (LANA_ENUM));
174                 Marshal.FreeHGlobal(Ncb.ncb_buffer);
175                  if (uRetCode != ( short )NCBCONST.NRC_GOODRET)
176                      return "" ;
177
178                  for ( int i = 0 ; i < lenum.length; i ++ )
179                 {
180                     Ncb.ncb_command = ( byte )NCBCONST.NCBRESET;
181                     Ncb.ncb_lana_num = lenum.lana[i];
182                     uRetCode = Win32API.Netbios( ref Ncb);
183                      if (uRetCode != ( short )NCBCONST.NRC_GOODRET)
184                          return "" ;
185
186                     Ncb.ncb_command = ( byte )NCBCONST.NCBASTAT;
187                     Ncb.ncb_lana_num = lenum.lana[i];
188                     Ncb.ncb_callname[ 0 ] = ( byte ) ' * ' ;
189                     cb = Marshal.SizeOf( typeof (ADAPTER_STATUS))
                         + Marshal.SizeOf( typeof (NAME_BUFFER)) * ( int )NCBCONST.NUM_NAMEBUF;
190                     Ncb.ncb_buffer = Marshal.AllocHGlobal(cb);
191                     Ncb.ncb_length = ( ushort )cb;
192                     uRetCode = Win32API.Netbios( ref Ncb);
193                     adapter.adapt = (ADAPTER_STATUS)Marshal.PtrToStructure(Ncb.ncb_buffer,
                             typeof (ADAPTER_STATUS));
194                     Marshal.FreeHGlobal(Ncb.ncb_buffer);
195
196                      if (uRetCode == ( short )NCBCONST.NRC_GOODRET)
197                     {
198                          if (i > 0 )
199                             addr += " : " ;
200                         addr = string .Format( " {0,2:X}{1,2:X}{2,2:X}{3,2:X}{4,2:X}{5,2:X} " ,
201                         adapter.adapt.adapter_address[ 0 ],
202                         adapter.adapt.adapter_address[ 1 ],
203                         adapter.adapt.adapter_address[ 2 ],
204                         adapter.adapt.adapter_address[ 3 ],
205                         adapter.adapt.adapter_address[ 4 ],
206                         adapter.adapt.adapter_address[ 5 ]);
207                     }
208                 }
209             }
210              catch
211             { }
212              return addr.Replace( ' ' , ' 0 ' );
213         }
214
215     }
216 }
217

  1 using System;
  2 using System.Runtime.InteropServices;
  3 using System.Management;
  4 namespace Hardware
  5 {
  6     /// <summary>
  7     /// Hardware_Mac 的摘要说明。
  8     /// </summary>
  9     public class HardwareInfo
10     {
11         //取机器名
12         public string GetHostName()
13         {
14             return System.Net.Dns.GetHostName();
15         }
16
17         //取CPU编号
18         public String GetCpuID()
19         {
20             try
21             {
22                 ManagementClass mc = new ManagementClass("Win32_Processor");
23                 ManagementObjectCollection moc = mc.GetInstances();
24
25                 String strCpuID = null;
26                 foreach (ManagementObject mo in moc)
27                 {
28                     strCpuID = mo.Properties["ProcessorId"].Value.ToString();
29                     break;
30                 }
31                 return strCpuID;
32             }
33             catch
34             {
35                 return "";
36             }
37
38         }//end method
39
40         //取第一块硬盘编号
41         public String GetHardDiskID()
42         {
43             try
44             {
45                 ManagementObjectSearcher searcher = new ManagementObjectSearcher("SELECT * FROM Win32_PhysicalMedia");
46                 String strHardDiskID = null;
47                 foreach (ManagementObject mo in searcher.Get())
48                 {
49                     strHardDiskID = mo["SerialNumber"].ToString().Trim();
50                     break;
51                 }
52                 return strHardDiskID;
53             }
54             catch
55             {
56                 return "";
57             }
58         }//end
59
60         public enum NCBCONST
61         {
62             NCBNAMSZ = 16, /* absolute length of a net name */
63             MAX_LANA = 254, /* lana's in range 0 to MAX_LANA inclusive */
64             NCBENUM = 0x37, /* NCB ENUMERATE LANA NUMBERS */
65             NRC_GOODRET = 0x00, /* good return */
66             NCBRESET = 0x32, /* NCB RESET */
67             NCBASTAT = 0x33, /* NCB ADAPTER STATUS */
68             NUM_NAMEBUF = 30, /* Number of NAME's BUFFER */
69         }
70
71         [StructLayout(LayoutKind.Sequential)]
72         public struct ADAPTER_STATUS
73         {
74             [MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)]
75             public byte[] adapter_address;
76             public byte rev_major;
77             public byte reserved0;
78             public byte adapter_type;
79             public byte rev_minor;
80             public ushort duration;
81             public ushort frmr_recv;
82             public ushort frmr_xmit;
83             public ushort iframe_recv_err;
84             public ushort xmit_aborts;
85             public uint xmit_success;
86             public uint recv_success;
87             public ushort iframe_xmit_err;
88             public ushort recv_buff_unavail;
89             public ushort t1_timeouts;
90             public ushort ti_timeouts;
91             public uint reserved1;
92             public ushort free_ncbs;
93             public ushort max_cfg_ncbs;
94             public ushort max_ncbs;
95             public ushort xmit_buf_unavail;
96             public ushort max_dgram_size;
97             public ushort pending_sess;
98             public ushort max_cfg_sess;
99             public ushort max_sess;
100             public ushort max_sess_pkt_size;
101             public ushort name_count;
102         }
103
104         [StructLayout(LayoutKind.Sequential)]
105         public struct NAME_BUFFER
106         {
107             [MarshalAs(UnmanagedType.ByValArray, SizeConst = (int)NCBCONST.NCBNAMSZ)]
108             public byte[] name;
109             public byte name_num;
110             public byte name_flags;
111         }
112
113         [StructLayout(LayoutKind.Sequential)]
114         public struct NCB
115         {
116             public byte ncb_command;
117             public byte ncb_retcode;
118             public byte ncb_lsn;
119             public byte ncb_num;
120             public IntPtr ncb_buffer;
121             public ushort ncb_length;
122             [MarshalAs(UnmanagedType.ByValArray, SizeConst = (int)NCBCONST.NCBNAMSZ)]
123             public byte[] ncb_callname;
124             [MarshalAs(UnmanagedType.ByValArray, SizeConst = (int)NCBCONST.NCBNAMSZ)]
125             public byte[] ncb_name;
126             public byte ncb_rto;
127             public byte ncb_sto;
128             public IntPtr ncb_post;
129             public byte ncb_lana_num;
130             public byte ncb_cmd_cplt;
131             [MarshalAs(UnmanagedType.ByValArray, SizeConst = 10)]
132             public byte[] ncb_reserve;
133             public IntPtr ncb_event;
134         }
135
136         [StructLayout(LayoutKind.Sequential)]
137         public struct LANA_ENUM
138         {
139             public byte length;
140             [MarshalAs(UnmanagedType.ByValArray, SizeConst = (int)NCBCONST.MAX_LANA)]
141             public byte[] lana;
142         }
143
144         [StructLayout(LayoutKind.Auto)]
145         public struct ASTAT
146         {
147             public ADAPTER_STATUS adapt;
148             [MarshalAs(UnmanagedType.ByValArray, SizeConst = (int)NCBCONST.NUM_NAMEBUF)]
149             public NAME_BUFFER[] NameBuff;
150         }
151         public class Win32API
152         {
153             [DllImport("NETAPI32.DLL")]
154             public static extern char Netbios(ref NCB ncb);
155         }
156
157         public string GetMacAddress()
158         {
159             string addr = "";
160             try
161             {
162                 int cb;
163                 ASTAT adapter;
164                 NCB Ncb = new NCB();
165                 char uRetCode;
166                 LANA_ENUM lenum;
167
168                 Ncb.ncb_command = (byte)NCBCONST.NCBENUM;
169                 cb = Marshal.SizeOf(typeof(LANA_ENUM));
170                 Ncb.ncb_buffer = Marshal.AllocHGlobal(cb);
171                 Ncb.ncb_length = (ushort)cb;
172                 uRetCode = Win32API.Netbios(ref Ncb);
173                 lenum = (LANA_ENUM)Marshal.PtrToStructure(Ncb.ncb_buffer, typeof(LANA_ENUM));
174                 Marshal.FreeHGlobal(Ncb.ncb_buffer);
175                 if (uRetCode != (short)NCBCONST.NRC_GOODRET)
176                     return "";
177
178                 for (int i = 0; i < lenum.length; i++)
179                 {
180                     Ncb.ncb_command = (byte)NCBCONST.NCBRESET;
181                     Ncb.ncb_lana_num = lenum.lana[i];
182                     uRetCode = Win32API.Netbios(ref Ncb);
183                     if (uRetCode != (short)NCBCONST.NRC_GOODRET)
184                         return "";
185
186                     Ncb.ncb_command = (byte)NCBCONST.NCBASTAT;
187                     Ncb.ncb_lana_num = lenum.lana[i];
188                     Ncb.ncb_callname[0] = (byte)'*';
189                     cb = Marshal.SizeOf(typeof(ADAPTER_STATUS)) + Marshal.SizeOf(typeof(NAME_BUFFER)) * (int)NCBCONST.NUM_NAMEBUF;
190                     Ncb.ncb_buffer = Marshal.AllocHGlobal(cb);
191                     Ncb.ncb_length = (ushort)cb;
192                     uRetCode = Win32API.Netbios(ref Ncb);
193                     adapter.adapt = (ADAPTER_STATUS)Marshal.PtrToStructure(Ncb.ncb_buffer, typeof(ADAPTER_STATUS));
194                     Marshal.FreeHGlobal(Ncb.ncb_buffer);
195
196                     if (uRetCode == (short)NCBCONST.NRC_GOODRET)
197                     {
198                         if (i > 0)
199                             addr += ":";
200                         addr = string.Format("{0,2:X}{1,2:X}{2,2:X}{3,2:X}{4,2:X}{5,2:X}",
201                         adapter.adapt.adapter_address[0],
202                         adapter.adapt.adapter_address[1],
203                         adapter.adapt.adapter_address[2],
204                         adapter.adapt.adapter_address[3],
205                         adapter.adapt.adapter_address[4],
206                         adapter.adapt.adapter_address[5]);
207                     }
208                 }
209             }
210             catch
211             { }
212             return addr.Replace(' ', '0');
213         }
214
215     }
216 }
217

2、然后是主界面程序的

1 private void btn_ReadHard_Click( object sender, EventArgs e)
2         {
3              // 读机器码
4              string hardcode = "" ;
5             Hardware.HardwareInfo hd = new Hardware.HardwareInfo();
6             hardcode   = hd.GetCpuID();
7             MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
8              byte [] hdcode1 = System.Text.Encoding.UTF8.GetBytes(hardcode + " new " );
9              byte [] hdcode2 = md5.ComputeHash(hdcode1);
10             md5.Clear();
11             tb_Hardcode.Text = Convert.ToBase64String(hdcode2).Replace( " = " , "" );
12
13         }

1
2          private string GetRegCode( string MacCode)
3         {
4              string stra = MacCode.Substring( 16 );
5              string [] arstr = new string [ 4 ]{MacCode.Substring( 1 , 5 ),
6                 MacCode.Substring( 6 , 5 ),MacCode.Substring( 11 , 5 ),MacCode.Substring( 16 , 5 )};
7              string str5 = "" ;
8             MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
9              byte [] hdcode;
10              byte [] regcode;
11              for ( int i = 0 ; i < arstr.Length;i ++ )
12             {
13                 hdcode = System.Text.Encoding.UTF8.GetBytes(arstr[i] + " string " );
14                 regcode = md5.ComputeHash(hdcode);
15                 str5 += Convert.ToBase64String(regcode).Replace( " = " , "" );
16             }
17             md5.Clear();
18              return str5;
19         }

1  private void btn_ReadHard_Click(object sender, EventArgs e)
2         {
3             //读机器码
4             string hardcode = "";
5             Hardware.HardwareInfo hd = new Hardware.HardwareInfo();
6             hardcode  = hd.GetCpuID();
7             MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
8             byte[] hdcode1 = System.Text.Encoding.UTF8.GetBytes(hardcode +"new");
9             byte[] hdcode2 = md5.ComputeHash(hdcode1);
10             md5.Clear();
11             tb_Hardcode.Text = Convert.ToBase64String(hdcode2).Replace("=","");
12
13         }

请大家参考6楼的回复,一定要进行工作进程模拟,否则任何一台电脑提取到的注册码是都是一样的,因为在取本机CpuID或硬盘序列号的时候,返回值为空.

或者在配置文件中加入身份验证要求,如

<allow users="CHINA-3ABA37ACE\administrator"/>
<deny users="*"/>
关于更多的asp.net身份模拟资料,请参考微软的这篇文档.

http://www.microsoft.com/china/community/program/originalarticles/techdoc/impersonation.mspx

转载于:https://www.cnblogs.com/gxlxzys/archive/2007/07/12/815752.html

weixin_30919571

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
.net 软件注册功能的简单实现

相信很多初学编程的人都会对这个软件注册功能很感兴趣，我也不例外，刚学asp.net时，竞找不到这方面的实例，结果自己参考微软的一些文档自己做了一个，其实我做的这个注册功能很简单，读取计算机的CPU序列号，用MD5加密（经过处理）生成一个机器码，然后再把这个机器码处理一下就生成了注册码，在asp.net的配置文件web.config中加了一个键，用于存储注册码，程序运行时读取机器码，然后再生...
复制链接

扫一扫