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