MARKUS

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Linq;

using System.Management;

using System.ServiceModel;

using System.ServiceModel.Channels;

using System.Text;

using System.Threading.Tasks;

using System.Windows;

using System.Windows.Resources;

using System.Xml;

using System.Xml.Serialization;

namespace License.Validator

{

    public class Valid

    {

        public event EventHandler<ValidateErrorArgs> ValidateError;

        license.iLicenseService service;

        private string key;

        private string _serviceUri;

        private CustomBinding binding;

        private string license;

        public string Name;

        public Valid(string serviceUri)

        {

            _serviceUri = $"{serviceUri}/LicenseService.svc";

            binding = new CustomBinding();

            SymmetricSecurityBindingElement ssbe = SecurityBindingElement.CreateSspiNegotiationBindingElement(true);

            ssbe.LocalClientSettings.MaxClockSkew = new TimeSpan(0, 10, 0);

            ssbe.LocalServiceSettings.MaxClockSkew = new TimeSpan(0, 10, 0);

            binding.Elements.Add(ssbe);

            binding.Elements.Add(new TextMessageEncodingBindingElement());

            binding.Elements.Add(new HttpTransportBindingElement());

        }

        public void GetLicense(string keyfile)

        {

            try

            {

                service = ChannelFactory<license.iLicenseService>.CreateChannel(binding, new EndpointAddress(_serviceUri));

                Uri uri = new Uri($"/{keyfile}", UriKind.Relative);

                StreamResourceInfo info = Application.GetResourceStream(uri);

                System.IO.StreamReader stream = new System.IO.StreamReader(info.Stream);

                key = stream.ReadToEnd();

                license = service.GetLicense(key, Environment.MachineName,ProcessID(), Environment.UserName);

                var doc = new XmlDocument();

                doc.LoadXml(license);

                var element = doc.GetElementsByTagName("name");

                if(element != null)

                {

                    this.Name = element[0].InnerText;

                }

            }

            catch (ProtocolException)

            {

                Error(new ValidateErrorArgs("License Connect Error", new Exception("")));

            }

            catch(Exception ex)

            { 

                Error(new ValidateErrorArgs("Validate Error 001", ex));

            }

            finally

            {

                var communicationObject = service as ICommunicationObject;

                if (communicationObject != null)

                {

                    try

                    {

                        communicationObject.Close(TimeSpan.FromMilliseconds(50));

                    }

                    catch

                    {

                        communicationObject.Abort();

                    }

                }

            }

        }

        private string ProcessID()

        {

            return string.Join("", GetMainBoardSerialNumberList()) + string.Join("", GetCPUIDList());

        }

        private List<string> GetMainBoardSerialNumberList()

        {

            List<string> list = new List<string>();

            string query = "SELECT * FROM Win32_BaseBoard";

            ManagementObjectSearcher managementObjectSearcher = new ManagementObjectSearcher(query);

            foreach (ManagementObject managementObject in managementObjectSearcher.Get())

            {

                list.Add(managementObject.GetPropertyValue("SerialNumber").ToString());

            }

            return list;

        }

        private List<string> GetCPUIDList()

        {

            List<string> list = new List<string>();

            string query = "Select * FROM Win32_Processor";

            ManagementObjectSearcher managementObjectSearcher = new ManagementObjectSearcher(query);

            foreach (ManagementObject managementObject in managementObjectSearcher.Get())

            {

                list.Add(managementObject.GetPropertyValue("ProcessorId").ToString());

            }

            return list;

        }

        public bool Activate()

        {

            try

            {

                service = ChannelFactory<license.iLicenseService>.CreateChannel(binding, new EndpointAddress(_serviceUri));

                if(!service.Validate(key, license))

                {

                    Error(new ValidateErrorArgs("Validate Error 002", new Exception("null")));

                }

                else

                {

                    return true;

                }

            }

            catch (Exception)

            {

                Error(new ValidateErrorArgs("Validate Error 003", new Exception("null")));

            }

            finally

            {

                var communicationObject = service as ICommunicationObject;

                if (communicationObject != null)

                {

                    try

                    {

                        communicationObject.Close(TimeSpan.FromMilliseconds(50));

                    }

                    catch

                    {

                        communicationObject.Abort();

                    }

                }

            }

            return false;

        }

        private void Error(ValidateErrorArgs error)

        {

            bool flag = false;

            if (ValidateError != null)

            {

                ValidateError(null, error);

                if (error.Received)

                    flag = true;

            }

            if (!flag)

            {

                MessageBox.Show(error.Message);

                Environment.Exit(0);

            }

        }

    }

}