//----------------------------------------------------------------
// Copyright (C) 2000-2003 Shangxin Corporation
// All rights reserved.
// 文件名: Licence.cs
// 创建者: 葛卫新
// 创建日期: 2003-12-04
// 概述: 本文件作用是实现对Escalade Licence 验证,存取操作的封装
// 修改纪录:潘小锋
// 备注：该项目使用Hashtable存在隐患，Hashtable的顺序不受人为控制，所以通过去key及value来组成字符串的方式会导致校验时候失败
// ----------------------------------------------------------------

using System;
using System.IO;
using System.Data;
using System.Security.Cryptography;
using System.Text;
using System.Collections;
using System.Xml;
using System.Management;
using System.Runtime.InteropServices;
using System.Windows.Forms;

namespace MyCMMI.CreateLicense
{
	/// <summary>
	/// Licence 的摘要说明。
	/// </summary>
	//[ClassInterfaceAttribute(ClassInterfaceType.AutoDual)] 
	public class Licence
    {

		// xfpan [5/31/2004]
		// 获取硬盘物理序列号
		[DllImport("DiskSerialNo.dll")]
		private static extern string GetDiskSerialNo();

		// 获取网卡序列号
		[DllImport("DiskSerialNo.dll")]
		private static extern string GetMacAddr();
		// xfpan [5/31/2004]

		private string m_LicencePath="";
		private string m_SignedString = "";
		private string PUBLICKEY = "<RSAKeyValue><Modulus>wD+BfPFh06qyNMMjyIZfbSeNSVGppoH4VCR6iVTnsrWm+Czjg24EycKvQfZd9SVYHJMASHuKr0VlBCPye2REs2b9UCT3b+yLqhFrde0v7k6m6FTZe4kH4USmhsQaJstcU94LCRDM3PNfWS3r9qZ11ZtJDmrGH1zFtOJsYBWdZAM=</Modulus><Exponent>AQAB</Exponent></RSAKeyValue>";
		UnicodeEncoding ByteConverter = new UnicodeEncoding();
		private bool _IsLoad = false;
		private bool _IsValidated = false;
		private string _LastErrorInfo = "";

		private DataSet m_ds = null;
		private const string TABLENAME = "Value";
 
//		/// <summary>
//		/// 构造函数
//		/// </summary>
//		/// <param name="f_LicencePath">licence文件路径</param>
//		public Licence(string f_LicencePath)
//		{
//			m_LicencePath = f_LicencePath;
//			InitDataSet();
//			Initialize(f_LicencePath);
//		}

		/// <summary>
		/// 构造函数
		/// </summary>
		/// <param name="f_LicencePath">licence文件路径</param>
		public Licence()
		{
			InitDataSet();
		}

		private void InitDataSet()
		{
			m_ds = new DataSet();
			DataTable m_dt = m_ds.Tables.Add(TABLENAME);
			m_dt.Columns.Add("DiskID",typeof(System.String));
			m_dt.Columns.Add("CompanyName",typeof(System.String));
			m_dt.Columns.Add("UserCount",typeof(System.String));
			m_dt.Columns.Add("ProductName",typeof(System.String));
			m_dt.Columns.Add("Version",typeof(System.String));
			m_dt.Columns.Add("FromDate",typeof(System.String));
			m_dt.Columns.Add("ToDate",typeof(System.String));			
		}

		/// <summary>
		/// 初始化
		/// </summary>
		public void Initialize(string f_LicencePath)
		{
			m_LicencePath = f_LicencePath;
			if(LoadLicenceFile())
			{
				_IsLoad = true;
			}
			else
			{
				_IsLoad = false;
			}
		}

		/// <summary>
		/// 加载许可证文件
		/// </summary>
		/// <returns>成功为true,失败为false</returns>
		private bool LoadLicenceFile()
		{
			string f_TmpString = "";
			string f_XmlString = "";
			if(m_ds == null || m_ds.Tables[TABLENAME] == null)
			{
				return false;
			}

			if(!File.Exists(m_LicencePath))
			{
				return false;//文件不存在
			}
			else
			{
				//先以流方式读出
				try
				{
					FileStream fs = File.OpenRead(m_LicencePath);
					StreamReader f_srfs = new StreamReader(fs,System.Text.Encoding.Unicode);
					f_srfs.BaseStream.Seek(0, SeekOrigin.Begin);
					while (f_srfs.Peek() > -1) 
					{
						f_XmlString += f_TmpString;//拼装Xml流
						f_TmpString = f_srfs.ReadLine();
					}
					m_SignedString = f_TmpString;//获取最后一行密文
					f_srfs.Close();
				}
				catch
				{
					return false;
				}
				XmlDocument doc = new XmlDocument();
				//加载Xml流
				try
				{
					doc.LoadXml(f_XmlString);
				}
				catch
				{
					return false;
				}
				XmlNode node =doc.FirstChild;
				int i,nodecount;
				string f_Key = "";
				string f_Value = "";
				
				m_ds.Tables[TABLENAME].Rows.Clear();
				DataRow m_dr = m_ds.Tables[TABLENAME].NewRow();
				nodecount = node.ChildNodes.Count;
				node = node.FirstChild;
				//获取许可证明文值,加载到哈希表中
				for(i=0;i<nodecount;i++)
				{
					f_Key = node.Attributes["key"].Value;
					f_Value = node.Attributes["value"].Value;
					m_dr[f_Key] = f_Value;
					node = node.NextSibling;
				}
				m_ds.Tables[TABLENAME].Rows.Add(m_dr);

				return true;
			}
		}

		/// <summary>
		/// 验证硬件序列号
		/// </summary>
		/// <returns>验证成功为true,不成功为false</returns>
		public bool ValidateSerialNo()
		{
			String DiskID = GetValidateInfo("DiskID");
			WriteLog("The DiskID is " + DiskID + " that read from licensefile");

			String DiskSn = GetDiskID();
			WriteLog("The DiskID is " + DiskSn + " that read from hardware");

			if(DiskID == "" || DiskSn == "" || DiskSn == null || DiskID != DiskSn)
			{
				WriteLog("The DiskID of licensefile (" + DiskID + ") is not equal of the DiskID of hareware (" + DiskSn + ")");
				_LastErrorInfo = "The DiskID of licensefile (" + DiskID + ") is not equal of the DiskID of hareware (" + DiskSn + ")";
				// 系统未注册
				return false;//Const.ERROR_ESCALADE_NOTREGISTER;
			}
			return true;
		}

		// xfpan [5/17/2004]
		/// <summary>
		/// 获取机器唯一标志
		/// </summary>
		/// <returns>机器唯一标志</returns>
		public string GetDiskID()
		{
			string DiskID = "";

			DiskID = GetMAC().Trim();
			if (DiskID != "")
			{
				DiskID = "MA-" + DiskID;
				return DiskID;
			}
			WriteLog("MAC ID is null");

			try
			{
				DiskID = GetDiskSerialNo().Trim();
				if(DiskID != "")
				{
					DiskID = "HD" + DiskID;
					return DiskID;
				}
				WriteLog("HD ID is null");
			}
			catch(Exception de)
			{
				_LastErrorInfo = "Getting DiskSerialNo,catch a exception.It's information that " + de.Message.ToString();
				WriteLog("Getting DiskSerialNo,catch a exception.It's information that " + de.Message.ToString());
			}			

			DiskID = GetCPUId();
			if (DiskID != "")
			{
				DiskID = "CP" + DiskID;
				return DiskID;
			}
			WriteLog("CPU ID is null");

			return "";
		}	

		private string GetCPUId()
		{
			String HDid = "";
			ManagementClass cimobject = new ManagementClass("Win32_Processor");
			try
			{
				ManagementObjectCollection moc = cimobject.GetInstances();
				foreach(ManagementObject mo in moc)
				{
					HDid = mo["UniqueId"].ToString();
					if(HDid != "")
						break;
				}
			}
			catch(Exception he)
			{
				WriteLog("When getting CPU ID,catch a exception.It's message that " + he.Message.ToString());
				_LastErrorInfo = "When getting CPU ID,catch a exception.It's message that " + he.Message.ToString();
				HDid = "";
			}
			return HDid.Trim();
		}

		private string GetMAC()
		{
			string strMac = "";
			try
			{
				strMac = GetMacAddr();
			}
			catch(Exception me)
			{
				WriteLog("When getting Mac Address,catch a exception.It's message that " + me.Message.ToString());
				_LastErrorInfo = "When getting Mac Address,catch a exception.It's message that " + me.Message.ToString();
				strMac = "";
			}
			return strMac.Trim();
		}

		/// <summary>
		/// 验证许可时间
		/// </summary>
		/// <returns>验证成功为true,不成功为false</returns>
		public bool ValidateDate()
		{
			string CurrentDate = System.DateTime.Now.ToShortDateString();
			string FromDate = GetValidateInfo("FromDate");
			string ToDate = GetValidateInfo("ToDate");
			if(Convert.ToDateTime(CurrentDate) < Convert.ToDateTime(FromDate))
			{
				_LastErrorInfo = "许可证允许使用日期尚未开始";
				return false;//Const.ERROR_TELEPHONIST_TIMENOTARRIVE;
			}
			if(Convert.ToDateTime(CurrentDate) > Convert.ToDateTime(ToDate))
			{
				_LastErrorInfo = "许可证已过期";
				return false;//Const.ERROR_TELEPHONIST_OVERDUE;
			}
			return true;
		}

		/// <summary>
		/// 验证许可证文件
		/// </summary>
		/// <returns>验证成功为true,不成功为false</returns>
		public bool ValidateAuthority()
		{
			string f_UnSignedInfo = "";
			if(m_SignedString == "" || m_ds == null || m_ds.Tables[TABLENAME] == null || m_ds.Tables[TABLENAME].Rows.Count != 1)
			{
				return false;
			}
			
			for(int i = 0;i < m_ds.Tables[TABLENAME].Columns.Count;i++)
			{
				f_UnSignedInfo += m_ds.Tables[TABLENAME].Columns[i].ColumnName;
				f_UnSignedInfo += m_ds.Tables[TABLENAME].Rows[0][i].ToString();
			}
			byte[] UnSignedInfoByte = ByteConverter.GetBytes(f_UnSignedInfo);
			byte[] SignedInfoByte = ByteConverter.GetBytes(m_SignedString);
			try
			{
				// xfpan [5/20/2004]
				CspParameters CSPParam = new CspParameters();
				CSPParam.Flags = CspProviderFlags.UseMachineKeyStore;
				RSACryptoServiceProvider RSA = new RSACryptoServiceProvider(CSPParam);
				// xfpan [5/20/2004]
				RSA.FromXmlString(PUBLICKEY);
				HashAlgorithm sha = new SHA1CryptoServiceProvider();
				IsValidated = RSA.VerifyData(UnSignedInfoByte,sha,SignedInfoByte);
			}
			catch
			{
				return false;
			}
			return IsValidated;
		}

		/// <summary>
		/// 获取许可证信息
		/// </summary>
		/// <param name="f_ValidateKey">许可证信息主键</param>
		/// <returns>许可证信息对应值</returns>
		private string GetValidateInfo(string f_ValidateKey)
		{
			string f_ValidateInfo = "";

			if(m_ds == null || m_ds.Tables[TABLENAME] == null || m_ds.Tables[TABLENAME].Rows.Count != 1 || m_ds.Tables[TABLENAME].Columns[f_ValidateKey] == null)
			{
				f_ValidateInfo = "";
			}
			else
			{
				try
				{
					f_ValidateInfo = m_ds.Tables[TABLENAME].Rows[0][f_ValidateKey].ToString();
				}
				catch
				{
					f_ValidateInfo = "";
				}
			}
			return f_ValidateInfo;
		}

		//wuxiangrong 2005.10.19
		//获取许可证中的硬盘序列号
		public string GetDiskIDFromLicence()
		{
			try
			{
				return m_ds.Tables[TABLENAME].Rows[0]["DiskID"].ToString();
			}
			catch
			{
				return "";
			}
		}

		//获取许可证中的公司名称
		public string GetCompanyNameFromLicence()
		{
			try
			{
				return m_ds.Tables[TABLENAME].Rows[0]["CompanyName"].ToString();
			}
			catch
			{
				return "";
			}
		}

		//获取许可证中的用户数量
		public string GetUserCountFromLicence()
		{
			try
			{
				return m_ds.Tables[TABLENAME].Rows[0]["UserCount"].ToString();
			}
			catch
			{
				return "";
			}
		}

		//获取许可证中的产品名称
		public string GetProductNameFromLicence()
		{
			try
			{
				return m_ds.Tables[TABLENAME].Rows[0]["ProductName"].ToString();
			}
			catch
			{
				return "";
			}
		}

		//获取许可证中的版本号
		public string GetVersionFromLicence()
		{
			try
			{
				return m_ds.Tables[TABLENAME].Rows[0]["Version"].ToString();
			}
			catch
			{
				return "";
			}
		}

		//获取许可证中的有效期的启起日期
		public string GetFromDateFromLicence()
		{
			try
			{
				return m_ds.Tables[TABLENAME].Rows[0]["FromDate"].ToString();
			}
			catch
			{
				return "";
			}
		}

		//获取许可证中的有效期的截止日期
		public string GetToDateFromLicence()
		{
			try
			{
				return m_ds.Tables[TABLENAME].Rows[0]["ToDate"].ToString();
			}
			catch
			{
				return "";
			}
		}
		//wuxiangrong 2005.10.19


		/// <summary>
		/// 加载是否成功标志
		/// </summary>
		public bool IsLoad
		{
			get
			{
				return _IsLoad;
			}
			set
			{
				_IsLoad = value;
			}
		}

		/// <summary>
		/// 验证是否成功标志
		/// </summary>
		public bool IsValidated
		{
			get
			{
				return _IsValidated;
			}
			set
			{
				_IsValidated = value;
			}
		}

		// 测试使用
		private void WriteLog(String ErrInfos)
		{
			FileStream fs;
			StreamWriter sw;
			try
			{
				fs = new FileStream("c:\\ErrorLog.txt", FileMode.OpenOrCreate | FileMode.Append);			
				sw = new StreamWriter(fs);
				sw.WriteLine(DateTime.Now.ToString() + " " + ErrInfos);
				sw.Close();
			}
			catch{}
		}

		/// <summary>
		/// 最后的错误信息
		/// </summary>
		public string LastErrorInfo
		{
			get
			{
				return _LastErrorInfo;
			}
			set
			{
				_LastErrorInfo = value;
			}
		}

		/// <summary>
		/// 验证，包括验证是否加载成功、许可证文件是否有效、时间是否在有效期内、序列号是否正确
		/// </summary>
		/// <param name="f_LicencePath">许可证路径</param>
		/// <param name="ProductName">产品名称</param>
		/// <returns>验证成功为true,不成功为false</returns>
		public bool Validate(string f_LicencePath,string ProductName)
		{
			Initialize(f_LicencePath);

			// 验证是否加载成功
			if(_IsLoad == false)
			{
				_LastErrorInfo = "加载许可文件失败";
				return false;
			}

			// 验证许可证文件是否有效
			if(!ValidateAuthority())
			{
				_LastErrorInfo = "验证许可证文件失败";
				return false;
			}
			
			// 验证时间是否在有效期内
			if(!ValidateDate())
			{
				// 错误信息在底层已经给出 [9/22/2005]
				return false;
			}
			
			// 验证序列号是否正确
			if(!ValidateSerialNo())
			{
				// 错误信息在底层已经给出 [9/22/2005]
				return false;
			}

			// 验证产品名称是否正确
			if(!ValidateProductName(ProductName))
			{
				// 错误信息在底层已经给出 [9/22/2005]
				return false;
			}
			
			// 验证成功
			return true;
		}

		/// <summary>
		/// 校验产品名称
		/// </summary>
		/// <param name="ProductName">产品名称</param>
		/// <returns>返回值,正确返回true,错误返回false</returns>
		public bool ValidateProductName(string ProductName)
		{
			string ProName = GetValidateInfo("ProductName").Trim();
			if(ProName != ProductName)
			{
				_LastErrorInfo = "错误信息:请使用正确的许可证,当前运行的产品为" + ProductName + ",而使用的是产品为" + ProName + "的许可证";
				return false;
			}
			return true;
		}
	}
}