c#实现的破解程序--针对软件使用时间限制

自己捣腾了一天，弄了一个修改软件过期的小程序，主要是自己有几款有时间限制的软件，每次改时间很麻烦。有了这个程序就可以一劳永逸了。

前提：只适用于修改操作系统时间后，程序就能够正常使用的那种软件。如Lingoes，reflector，这两款我测试是可以的。

在Win7下必需用管理员的方式启动。

思路很简单：

1，修改操作系统时间到软件过期前。

2，启动软件。

3，改回操作系统时间。

程序类似于网上的一款好像叫RunAsDate的软件，没用过，只大概记得它的界面，决定自己实现类似的功能。

该程序的亮点是

1，可以生成破解程序的快捷方式到桌面上，生成的快捷方式图标和原来的程序一样（有轻度的失真），生成这个快捷方式后，就不用这个破解程序了，这个才是我要的一劳永逸的东西。

2，对原来的程序exe文件做了备份，避免因破解不成功，软件自身因过期启动自我销毁的情况。如：Refletor就是其中一例。

先看一张程序界面图：

基本操作：

破解启动：界面功能很简单，一看就会用。有效时间一般不知道有效时间，不要指定。选中待破解的程序路径，点“破解启动”按钮，就可以启动程序，但是这种方式只能单次启动，也就是每次都要启动这个破解程序。

快捷方式生成：在“破解启动”成功的前提下，生成的快捷方式才可用。这种方式可以一劳永逸的生成桌面图标，下次也不用启动这个破解程序了。

下面这两个是生成的快捷方式图标：

快捷方式名称栏，可以输入名称来生成快捷方式。

如下图：

点快捷方式生成后：

不错，以后我就可以在桌面上直接启动这些过期的软件了。

下面贴出主要的代码程序：

Win32API

 using System;
 using System.Collections.Generic;
 using System.Text;
 using System.Runtime.InteropServices;

 namespace ApplicationActive
 {
     [StructLayout(LayoutKind.Sequential)]
     public struct SYSTEMTIME
     {
         public ushort wYear;
         public ushort wMonth;
         public ushort wDayOfWeek;
         public ushort wDay;
         public ushort wHour;
         public ushort wMinute;
         public ushort wSecond;
         public ushort wMilliseconds;

         public void FromDateTime(DateTime dateTime)
         {
             wYear = (ushort)dateTime.Year;
             wMonth = (ushort)dateTime.Month;
             wDayOfWeek = (ushort)dateTime.DayOfWeek;
             wDay = (ushort)dateTime.Day;
             wHour = (ushort)dateTime.Hour;
             wMinute = (ushort)dateTime.Minute;
             wSecond = (ushort)dateTime.Second;
             wMilliseconds = (ushort)dateTime.Millisecond;
         }

         public DateTime ToDateTime()
         {
             return new DateTime(wYear, wMonth, wDay, wHour, wMinute, wSecond);
         }
     }

     [Flags]
     enum SHGFI : int
     {
         /// <summary>get icon</summary>
         Icon = 0x000000100,
         /// <summary>get display name</summary>
         DisplayName = 0x000000200,
         /// <summary>get type name</summary>
         TypeName = 0x000000400,
         /// <summary>get attributes</summary>
         Attributes = 0x000000800,
         /// <summary>get icon location</summary>
         IconLocation = 0x000001000,
         /// <summary>return exe type</summary>
         ExeType = 0x000002000,
         /// <summary>get system icon index</summary>
         SysIconIndex = 0x000004000,
         /// <summary>put a link overlay on icon</summary>
         LinkOverlay = 0x000008000,
         /// <summary>show icon in selected state</summary>
         Selected = 0x000010000,
         /// <summary>get only specified attributes</summary>
         Attr_Specified = 0x000020000,
         /// <summary>get large icon</summary>
         LargeIcon = 0x000000000,
         /// <summary>get small icon</summary>
         SmallIcon = 0x000000001,
         /// <summary>get open icon</summary>
         OpenIcon = 0x000000002,
         /// <summary>get shell size icon</summary>
         ShellIconSize = 0x000000004,
         /// <summary>pszPath is a pidl</summary>
         PIDL = 0x000000008,
         /// <summary>use passed dwFileAttribute</summary>
         UseFileAttributes = 0x000000010,
         /// <summary>apply the appropriate overlays</summary>
         AddOverlays = 0x000000020,
         /// <summary>Get the index of the overlay in the upper 8 bits of the iIcon</summary>
         OverlayIndex = 0x000000040,
     }

     [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
     public struct SHFILEINFO
     {
         public SHFILEINFO(bool b)
         {
             hIcon = IntPtr.Zero;
             iIcon = 0;
             dwAttributes = 0;
             szDisplayName = "";
             szTypeName = "";
         }
         public IntPtr hIcon;
         public int iIcon;
         public uint dwAttributes;
         [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)]
         public string szDisplayName;
         [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 80)]
         public string szTypeName;
     };

     class Win32API
     {
         [DllImport("user32.dll", EntryPoint = "FindWindow")]
         public static extern IntPtr FindWindows(string lpClassName, string lpWindowName);
         [DllImport("kernel32.dll")]
         public static extern bool SetLocalTime(ref SYSTEMTIME Time);
         [DllImport("shell32.dll", CharSet = CharSet.Auto)]
         public static extern int SHGetFileInfo(
           string pszPath,
           int dwFileAttributes,
           out    SHFILEINFO psfi,
           uint cbfileInfo,
           SHGFI uFlags);

     }
 }

创建图标，备份，启动用的共通类 

 using System;
 using System.Collections.Generic;
 using System.Windows.Forms;
 using System.Text;
 using System.Drawing;
 using System.Runtime.InteropServices;
 using IWshRuntimeLibrary;
 using System.IO;
 using System.Diagnostics;

 namespace ApplicationActive
 {
     class CommonFunction
     {
         public enum StartMode
         {
             WinForm,
             ShortCut
         }
         public static readonly string CRACK_FOLDER_NAME = "xsw_Crack";
         public static readonly string CONFIG_NAME = "xsw_Crack.xml";
         public static StartMode Mode = StartMode.WinForm;

         private static Icon GetIcon(string strPath, bool bSmall)
         {
             SHFILEINFO info = new SHFILEINFO(true);
             int cbFileInfo = Marshal.SizeOf(info);
             SHGFI flags;
             if (bSmall)
                 flags = SHGFI.Icon | SHGFI.SmallIcon | SHGFI.UseFileAttributes;
             else
                 flags = SHGFI.Icon | SHGFI.LargeIcon;

             Win32API.SHGetFileInfo(strPath, 256, out info, (uint)cbFileInfo, flags);
             return Icon.FromHandle(info.hIcon);
         }

         public static string GetCrackFolderPath(string strPath)
         {
             string dirName = Path.GetDirectoryName(strPath);
             dirName += "\\" + CRACK_FOLDER_NAME;
             if (!Directory.Exists(dirName))
             {
                 Directory.CreateDirectory(dirName);
             }
             return dirName;
         }

         public static void CreateShortCut(string strPath, string shortcutName)
         {
             string shortcutPath;
             string shortcutIconLocation;
             string crackFolder;

             crackFolder = GetCrackFolderPath(strPath);
             shortcutPath = Environment.GetFolderPath(Environment.SpecialFolder.Desktop) + "\\" + shortcutName + ".lnk";
             shortcutIconLocation = crackFolder + "\\" + shortcutName + ".ico";

             //create Icon
             Icon shortcutIcon = GetIcon(strPath, false);
             FileStream fs = new FileStream(shortcutIconLocation, FileMode.OpenOrCreate, FileAccess.Write);
             shortcutIcon.Save(fs);
             fs.Close();

             //copy crack program file
             string crackFileName = new FileInfo(System.Reflection.Assembly.GetExecutingAssembly().Location).Name;
             if (!System.IO.File.Exists(crackFolder + "\\" + crackFileName))
             {
                 System.IO.File.Copy(System.Reflection.Assembly.GetExecutingAssembly().Location, crackFolder + "\\" + crackFileName, true);
             }
             System.IO.File.Copy(Application.StartupPath + "\\" + CommonFunction.CONFIG_NAME, crackFolder + "\\" + CommonFunction.CONFIG_NAME,true);
             BackupTargetFile(strPath);

             WshShell shell = new WshShell();
             IWshShortcut shortcut = (IWshShortcut)shell.CreateShortcut(shortcutPath);
             shortcut.Arguments = "\"" + strPath + "\"";
             shortcut.TargetPath = crackFolder + "\\" + crackFileName;
             shortcut.WorkingDirectory = crackFolder;
             shortcut.WindowStyle = 1; //normal
             shortcut.IconLocation = shortcutIconLocation;
             shortcut.Save();
         }

         public static void BackupTargetFile(string strPath)
         {
             string strFileTo = GetCrackFolderPath(strPath) +"\\" + new FileInfo(strPath).Name;
             if (!System.IO.File.Exists(strFileTo))
             {
                 System.IO.File.Copy(strPath, strFileTo);
             }
         }

         public static void StartProgram(string path, DateTime? settingDate)
         {
             System.Diagnostics.Stopwatch stopWatch = new System.Diagnostics.Stopwatch();
             DateTime NowDate = DateTime.Now;
             stopWatch.Start();

             //back up EXE file
             BackupTargetFile(path);
             FileInfo fileInfo = new System.IO.FileInfo(path);
             DateTime validDateTime = fileInfo.CreationTime > fileInfo.LastWriteTime ? fileInfo.LastWriteTime : fileInfo.CreationTime;

             if (settingDate.HasValue)
             {
                 validDateTime = settingDate.Value;
             }

             //update date
             SYSTEMTIME st = new SYSTEMTIME();
             st.FromDateTime(validDateTime);
             Win32API.SetLocalTime(ref st);
             System.Threading.Thread.Sleep(1000);
             try
             {
                 //start program
                 ProcessStartInfo PstartInfoExe = new ProcessStartInfo();
                 PstartInfoExe.FileName = path;
                 PstartInfoExe.WindowStyle = ProcessWindowStyle.Minimized;
                 PstartInfoExe.UseShellExecute = false;
                 Process p = new Process();
                 p.StartInfo = PstartInfoExe;
                 p.Start();
                 p.WaitForInputIdle(10000);
                 System.Threading.Thread.Sleep(2000);

                 if (CommonFunction.Mode == StartMode.WinForm)
                 {
                     ConfigManager.GetInstance().FilePath = path;
                     if (settingDate.HasValue)
                     {
                         ConfigManager.GetInstance().ExpireDate = validDateTime;
                     }
                     ConfigManager.GetInstance().Save();
                 }
             }
             catch
             {
             }
             finally
             {
                 //update to old date
                 stopWatch.Stop();
                 NowDate.Add(stopWatch.Elapsed);
                 st.FromDateTime(NowDate);
                 Win32API.SetLocalTime(ref st);
             }
         }
     }
 }

xml保存用

 using System;
 using System.Collections.Generic;
 using System.Text;
 using System.ComponentModel;
 using System.Data;
 using System.Drawing;
 using System.Windows.Forms;
 using System.Diagnostics;
 using System.IO;
 using System.Xml;

 namespace ApplicationActive
 {
     class ConfigManager
     {
         private static ConfigManager instance = null;

         public static ConfigManager GetInstance()
         {
             if (instance == null)
                 instance = new ConfigManager();
             return instance;
         }

         private DateTime? _expireDate = null;
         public DateTime? ExpireDate
         {
             get { return _expireDate; }
             set { _expireDate = value; }
         }

         private string _filePath  = string.Empty;
         public string FilePath
         {
             get { return _filePath; }
             set { _filePath = value; }
         }

         private ConfigManager()
         {
             GetXml();
         }

         public void Save()
         {
             string xmlPath = Application.StartupPath + "\\" + CommonFunction.CONFIG_NAME;
             if (this._filePath == string.Empty)
             {
                 return;
             }

             XmlWriter xmlWriter = XmlWriter.Create(xmlPath);
             xmlWriter.WriteStartElement("Root");
             xmlWriter.WriteElementString("ExePath", _filePath);
             if (_expireDate.HasValue)
             {
                 xmlWriter.WriteElementString("ExpireDate", this._expireDate.Value.ToString("yyyy/MM/dd HH:mm:ss"));
             }
             xmlWriter.WriteEndElement();
             xmlWriter.Close();
         }

         public void GetXml()
         {
             string xmlPath = Application.StartupPath + "\\" + CommonFunction.CONFIG_NAME; ;
             if (!System.IO.File.Exists(xmlPath))
             {
                 return;
             }
             XmlDocument xmlDoc = new XmlDocument();
             xmlDoc.Load(xmlPath);
             XmlNode xmlNode = xmlDoc.SelectSingleNode("Root");

             for (int i = 0; i < xmlNode.ChildNodes.Count; i++)
             {
                 if (xmlNode.ChildNodes[i].Name == "ExePath")
                 {
                     this._filePath = xmlNode.ChildNodes[i].InnerText;
                 }
                 if (xmlNode.ChildNodes[i].Name == "ExpireDate")
                 {
                     try
                     {
                         this._expireDate = Convert.ToDateTime(xmlNode.ChildNodes[i].InnerText);
                     }
                     catch
                     {
                     }
                 }
             }
         }
     }
 }

Form 类

 using System;
 using System.Collections.Generic;
 using System.ComponentModel;
 using System.Data;
 using System.Drawing;
 using System.Text;
 using System.Windows.Forms;
 using System.Diagnostics;
 using System.IO;
 using System.Xml;
 using System.Runtime.InteropServices;
 using IWshRuntimeLibrary;

 namespace ApplicationActive
 {
     public partial class FrmSetting : Form
     {
         public FrmSetting()
         {

             InitializeComponent();
         }

         private void FrmSetting_Load(object sender, EventArgs e)
         {
             if (ConfigManager.GetInstance().FilePath != string.Empty)
             {
                 this.tbx_pgmPath.Text = ConfigManager.GetInstance().FilePath;
             }
             if (ConfigManager.GetInstance().ExpireDate.HasValue)
             {
                 this.chkExpire.Checked = true;
                 this.dtpExpireDate.Value = ConfigManager.GetInstance().ExpireDate.Value;
             }
         }

         private void btnFile_Click(object sender, EventArgs e)
         {
             OpenFileDialog fileDialog = new OpenFileDialog();
             fileDialog.Filter = "file (*.exe)|*.exe";
             if (fileDialog.ShowDialog() == DialogResult.OK)
             {
                 this.tbx_pgmPath.Text = fileDialog.FileName;
             }
         }

         private void btn_startPgm_Click(object sender, EventArgs e)
         {
             if (InputCheck() == false)
                 return;

             if (this.dtpExpireDate.Enabled)
             {

                 CommonFunction.StartProgram(this.tbx_pgmPath.Text, this.dtpExpireDate.Value);
             }
             else
             {
                 CommonFunction.StartProgram(this.tbx_pgmPath.Text, null);
             }
         }

         private void btn_CreateIcon_Click(object sender, EventArgs e)
         {
             if (InputCheck() == false)
                 return;

             string shortcutName = "";
             if (this.tbx_IconName.Text == string.Empty)
             {
                 shortcutName = new System.IO.FileInfo(this.tbx_pgmPath.Text).Name.Substring(0, new System.IO.FileInfo(this.tbx_pgmPath.Text).Name.Length - 4);
             }
             else
             {
                 shortcutName = this.tbx_IconName.Text;
             }
             try
             {
                 CommonFunction.CreateShortCut(this.tbx_pgmPath.Text, shortcutName);
                 MessageBox.Show("生成成功！",this.Text, MessageBoxButtons.OK, MessageBoxIcon.Information);
             }
             catch
             {
                 MessageBox.Show("生成失败！", this.Text, MessageBoxButtons.OK, MessageBoxIcon.Error);
             }

         }

         private void chkExpire_CheckedChanged(object sender, EventArgs e)
         {
             if (chkExpire.Checked)
             {
                 this.dtpExpireDate.Enabled = true;
             }
             else
             {
                 this.dtpExpireDate.Enabled = false;
             }
         }

         private void btn_Close_Click(object sender, EventArgs e)
         {
             this.Close();
         }

         private bool InputCheck()
         {
             string filePath = this.tbx_pgmPath.Text;
             if (filePath == "")
             {
                 MessageBox.Show("file is not seleted.", this.Text, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                 return false ;
             }
             if (!System.IO.File.Exists(filePath))
             {

                 string backupFile = System.IO.Path.GetDirectoryName(filePath) + "\\" + CommonFunction.CRACK_FOLDER_NAME + "\\" + filePath.Substring(filePath.LastIndexOf("\\") + 1);
                 if (System.IO.File.Exists(backupFile))
                 {
                     try
                     {
                         System.IO.File.Copy(backupFile, filePath);
                     }
                     catch
                     {
                         MessageBox.Show("file is not found!", this.Text, MessageBoxButtons.OK, MessageBoxIcon.Error);
                         return false ;
                     }
                 }
                 else
                 {
                     MessageBox.Show("file is not found!", this.Text, MessageBoxButtons.OK, MessageBoxIcon.Error);
                     return false ;
                 }
             }
             return true;
         }
     }
 }

program类

 using System;
 using System.Collections.Generic;
 using System.Windows.Forms;

 namespace ApplicationActive
 {
     static class Program
     {
         /// <summary>
         /// アプリケーションのメイン エントリ ポイントです。
         /// </summary>
         [STAThread]
         static void Main(string[] args)
         {
             Application.EnableVisualStyles();
             Application.SetCompatibleTextRenderingDefault(false);

             ConfigManager.GetInstance().GetXml();
             if (args.Length > 0)
             {
                 CommonFunction.Mode = CommonFunction.StartMode.ShortCut;
                 string filePath = args[0];
                 if (!System.IO.File.Exists(filePath))
                 {
                     string backupFile = System.IO.Path.GetDirectoryName(filePath) + "\\" + CommonFunction.CRACK_FOLDER_NAME + "\\" + filePath.Substring(filePath.LastIndexOf("\\") + 1);
                     if (System.IO.File.Exists(backupFile))
                     {
                         try
                         {
                             System.IO.File.Copy(backupFile, filePath);
                         }
                         catch
                         {
                             MessageBox.Show("file:<" + filePath + ">" + " not found!", "error", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                             return;
                         }
                     }
                     else
                     {
                         MessageBox.Show("file:<" + filePath + ">" + " not found!", "error", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                         return;
                     }
                 }
                 CommonFunction.StartProgram(filePath, ConfigManager.GetInstance().ExpireDate);
             }
             else
             {
                 CommonFunction.Mode = CommonFunction.StartMode.WinForm;
                 Application.Run(new FrmSetting());
             }
         }
     }
 }

 以上程序是用vs2005，在xp环境下编译的，在win7上转化成vs2008后发现不能正常运行，其原因是win7的UAC账户控制，必需要以管理员的方式启动才能运行，于是在vs2008中加入一个app.manifest文件，配置修改如下：

 <?xml version="1.0" encoding="utf-8"?>
 <asmv1:assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1" xmlns:asmv1="urn:schemas-microsoft-com:asm.v1" xmlns:asmv2="urn:schemas-microsoft-com:asm.v2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
   <assemblyIdentity version="1.0.0.0" name="MyApplication.app"/>
   <trustInfo xmlns="urn:schemas-microsoft-com:asm.v2">
     <security>
       <requestedPrivileges xmlns="urn:schemas-microsoft-com:asm.v3">
         <!-- UAC 清单选项
             如果希望更改 Windows 用户帐户控制级别，请用以下节点之一替换
             requestedExecutionLevel 节点。

         <requestedExecutionLevel  level="asInvoker" uiAccess="false" />
         <requestedExecutionLevel  level="requireAdministrator" uiAccess="false" />
         <requestedExecutionLevel  level="highestAvailable" uiAccess="false" />

             如果您希望利用文件和注册表虚拟化提供
             向后兼容性，请删除 requestedExecutionLevel 节点。
         -->
         <requestedExecutionLevel level="requireAdministrator" uiAccess="false" />
       </requestedPrivileges>
     </security>
   </trustInfo>
 </asmv1:assembly>

关键是这句：<requestedExecutionLevel level="requireAdministrator" uiAccess="false" />

重新编译后在Win7下就能正常运行了。

转载请注明出处：http://blog.csdn.net/xiashengwang/article/details/7096715