HYTOS

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Security.Cryptography;

using System.IO;

using Microsoft.Win32;

using System.Net.NetworkInformation;

using Converter.SPPID.Form;

using System.Windows.Forms;

using Converter.SPPID.Properties;

using System.Net;

using JWT;

using JWT.Algorithms;

using JWT.Serializers;

using JWT.Exceptions;

using Newtonsoft.Json;

namespace DOFTECH.License

{

    public class LicenseDTO

    {

        /// <summary>

        /// 라이센스 고유 값

        /// </summary>

        public int uid { get; set; }

        /// <summary>

        /// MAC 주소

        /// </summary>

        public string mac { get; set; }

        /// <summary>

        /// 메일 주소

        /// </summary>

        public string email { get; set; }

        /// <summary>

        /// 어플리케이션

        /// </summary>

        public string app { get; set; }

        /// <summary>

        /// 라이센스 코드

        /// </summary>

        public string code { get; set; }

        /// <summary>

        /// api name.

        /// </summary>

        public string api { get; set; }

        /// <summary>

        /// 만료 시간.

        /// </summary>

        public string expiration_date { get; set; }

        /// <summary>

        /// 만료 시간.

        /// </summary>

        public string exp { get; set; }

        /// <summary>

        /// License 개수

        /// </summary>

        public int count { get; set; }

    }

    public class LicenseReturn

    {

        /// <summary>

        /// STATUS

        /// </summary>

        public bool success { get; set; }

        /// <summary>

        /// CODE

        /// </summary>

        public int code { get; set; }

        /// <summary>

        /// MSG

        /// </summary>

        public string msg { get; set; }

        /// <summary>

        /// DATA

        /// </summary>

        public string data { get; set; }

    }

    public static class License

    {

        //public static bool IsEnabled()

        //{

        //    bool result = false;

        //    string path = string.Empty;

        //    try

        //    {

        //        RegistryKey key = Registry.LocalMachine;

        //        RegistryKey software = key.OpenSubKey("SOFTWARE");

        //        RegistryKey DOFTECH = software.OpenSubKey("DOFTECH");

        //        RegistryKey SPPIDConverter = DOFTECH.OpenSubKey("SPPIDConverter", true);

        //        path = SPPIDConverter.GetValue("path") + "licenses.licx";

        //        if (File.Exists(path))

        //        {

        //            string data = File.ReadAllText(path);

        //            data = Crypt.decrypt(data, "dof1073#");

        //            if (data.StartsWith("Date:"))

        //            {

        //                data = data.Remove(0, "Date:".Length);

        //                if (string.IsNullOrEmpty(data))

        //                {

        //                    DateTime dataTime = new DateTime(2000, 1, 1);

        //                    DateTime currentTime = DateTime.Now;

        //                    if (DateTime.TryParse(Converter.SPPID.Properties.Resources.lic, out dataTime) && DateTime.Compare(dataTime.AddDays(150), currentTime) >= 0)

        //                        result = true;

        //                }

        //            }

        //            else if (data.StartsWith("Absolute:"))

        //            {

        //                data = data.Remove(0, "Absolute:".Length);

        //                string macAddress = NetworkInterface.GetAllNetworkInterfaces()[0].GetPhysicalAddress().ToString();

        //                if (string.IsNullOrEmpty(data))

        //                {

        //                    data = "Absolute:" + macAddress;

        //                    data = Crypt.encrypt(data, "dof1073#");

        //                    File.WriteAllText(path, data);

        //                    result = true;

        //                }

        //                else if (macAddress == data)

        //                    result = true;

        //            }

        //        }

        //    }

        //    catch (Exception ex)

        //    {

        //    }

        //    return result;

        //}

        public static bool IsEnabled()

        {

            bool result = false;

            try

            {

                string key = Settings.Default.LicenseKey;

                if (!string.IsNullOrEmpty(key))

                {

                    key = Crypt.decrypt(key, "dof1073#");

                }

                else

                {

                    key = "dummy"; // must fail

                }

                if (!CheckLicense(key))

                {

                    var dlg = new LicenseForm();

                    if (dlg.ShowDialog() == DialogResult.OK)

                    {

                        key = dlg.key;

                    }

                    if (CheckLicense(key))

                    {

                        Settings.Default.LicenseKey = Crypt.encrypt(key, "dof1073#");

                        Settings.Default.Save();

                        result = true;

                    }

                }

                else

                {

                    result = true;

                }

            }

            catch (Exception ex)

            {

            }

            return result;

        }

        public static bool CheckLicense(string key)

        {

            try

            {

                const string secret = "795hi#(7qq5&p#f3ysa#n-449h8g_n95olca)b%t23s7!w%v0m";

                if (key != "dummy")

                {

                    IJsonSerializer serializer = new JsonNetSerializer();

                    var provider = new UtcDateTimeProvider();

                    IJwtValidator validator = new JwtValidator(serializer, provider);

                    IBase64UrlEncoder urlEncoder = new JwtBase64UrlEncoder();

                    IJwtAlgorithm algorithm = new HMACSHA256Algorithm(); // symmetric

                    IJwtDecoder decoder = new JwtDecoder(serializer, validator, urlEncoder, algorithm);

                    var json = decoder.Decode(key, secret, verify: true);

                    var licenseDto = JsonConvert.DeserializeObject<LicenseDTO>(json);

                    if (NetworkInterface.GetAllNetworkInterfaces()[0].GetPhysicalAddress().ToString() != licenseDto.mac)

                    {

                        return false;

                    }

                    string url = licenseDto.api;

                    string responseText = string.Empty;

                    HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);

                    request.Method = "GET";

                    request.Timeout = 5 * 1000;

                    request.ContentType = "application/json";

                    request.Headers.Add("x-auth-token:" + key);

                    bool validKey = true;

                    using (HttpWebResponse resp = (HttpWebResponse)request.GetResponse())

                    {

                        HttpStatusCode status = resp.StatusCode;

                        Console.WriteLine(status);

                        Stream respStream = resp.GetResponseStream();

                        using (StreamReader sr = new StreamReader(respStream))

                        {

                            responseText = sr.ReadToEnd();

                            var licenseReturn = JsonConvert.DeserializeObject<LicenseReturn>(responseText);

                            if (!licenseReturn.success)

                            {

                                MessageBox.Show(licenseReturn.msg, "SPPID Converter", MessageBoxButtons.OK, MessageBoxIcon.Warning);

                                validKey = false;

                            }

                        }

                    }

                    return validKey;

                }

            }

            catch (Exception ex)

            {

            }

            return false;

        }

        public static string SHA256Hash(string data)

        {

            SHA256 sha = new SHA256Managed();

            byte[] hash = sha.ComputeHash(Encoding.ASCII.GetBytes(data));

            StringBuilder stringBuilder = new StringBuilder();

            foreach (byte b in hash)

            {

                stringBuilder.AppendFormat("{0:x2}", b);

            }

            return stringBuilder.ToString();

        }

        private static void CreateDateLicenseFile()

        {

            string path = Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory) + @"\[Date]licenses.licx";

            string data = "Date:";

            using (StreamWriter sw = File.CreateText(path))

            {

                data = Crypt.encrypt(data, "dof1073#");

                sw.Write(data);

                sw.Close();

                sw.Dispose();

            }

        }

        private static void CreateAbsoluteLicenseFile()

        {

            string path = Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory) + @"\[Absolute]licenses.licx";

            string data = "Absolute:";

            using (StreamWriter sw = File.CreateText(path))

            {

                data = Crypt.encrypt(data, "dof1073#");

                sw.Write(data);

                sw.Close();

                sw.Dispose();

            }

        }

    }

    class Crypt

    {

        public static String encrypt(String text, String password)

        {

            RijndaelManaged RijndaelCipher = new RijndaelManaged();

            byte[] plainText = Encoding.UTF8.GetBytes(text);

            byte[] salt = Encoding.UTF8.GetBytes(password);

            PasswordDeriveBytes secretKey = new PasswordDeriveBytes(password, salt);

            ICryptoTransform Encryptor = RijndaelCipher.CreateEncryptor(secretKey.GetBytes(32), secretKey.GetBytes(16));

            MemoryStream memoryStream = new MemoryStream();

            CryptoStream cryptoStream = new CryptoStream(memoryStream, Encryptor, CryptoStreamMode.Write);

            cryptoStream.Write(plainText, 0, plainText.Length);     // 암호화 시작

            cryptoStream.FlushFinalBlock();

            byte[] cryptBytes = memoryStream.ToArray();

            // 스트림을 닫습니다.

            memoryStream.Close();

            cryptoStream.Close();

            String cryptResult = Convert.ToBase64String(cryptBytes);

            return cryptResult;     // 암호화 문자열 리턴.

        }

        public static String decrypt(String text, String password)

        {

            RijndaelManaged RijndaelCipher = new RijndaelManaged();

            byte[] encryptData = Convert.FromBase64String(text);

            byte[] salt = Encoding.UTF8.GetBytes(password);

            PasswordDeriveBytes SecretKey = new PasswordDeriveBytes(password, salt);

            ICryptoTransform Decryptor = RijndaelCipher.CreateDecryptor(SecretKey.GetBytes(32), SecretKey.GetBytes(16));

            MemoryStream memoryStream = new MemoryStream(encryptData);

            CryptoStream cryptoStream = new CryptoStream(memoryStream, Decryptor, CryptoStreamMode.Read);

            byte[] PlainText = new byte[encryptData.Length];

            // 복호화 시작

            int DecryptedCount = cryptoStream.Read(PlainText, 0, PlainText.Length);

            memoryStream.Close();

            cryptoStream.Close();

            // 복호화된 데이터를 문자열로 바꾼다.

            string DecryptedData = Encoding.UTF8.GetString(PlainText, 0, DecryptedCount);

            // 최종 결과 리턴

            return DecryptedData;

        }

    }

}