示例#1
0
        public List <string> GetAllHashedLicenseKeysByLicenseSet(int licenseSetId)
        {
            List <string> hashedKeys = new List <string>();
            List <string> keys       = GetAllLicenseKeysByLicenseSet(licenseSetId);

            foreach (string k in keys)
            {
                hashedKeys.Add(_hashingProvider.ComputeHash(k, Properties.Resources.KeyHashingAlgo));
            }

            return(hashedKeys);
        }
        public ServiceProduct CreateTestProduct(string licenseKey)
        {
            DeleteTestServiceProduct();

            ServiceProduct prod = new ServiceProduct();

            prod.LicenseId   = int.MaxValue;
            prod.LicenseName = "Test Product License";
            prod.LicenseSets = new List <ServiceLicenseSet>();

            ServiceLicenseSet ls = new ServiceLicenseSet();

            ls.LicenseSetId   = int.MaxValue;
            ls.LicenseId      = int.MaxValue;
            ls.Keys           = new List <ServiceLicenseKey>();
            ls.LicenseSetName = "Test Product License Set";
            ls.LicenseType    = LicenseKeyTypeFlag.MultiUser;
            ls.MaxUsers       = 2;

            ServiceLicenseKey key = new ServiceLicenseKey();

            key.CreatedOn       = DateTime.Now;
            key.Key             = _hashingProvider.ComputeHash(licenseKey, "SHA256");
            key.LicenseSetId    = int.MaxValue;
            key.ActivationCount = 0;
            ls.Keys.Add(key);

            prod.LicenseSets.Add(ls);

            _serviceProductsRepository.SaveServiceProduct(prod);

            return(_serviceProductsRepository.GetProduct(int.MaxValue));
        }
        /// <summary>
        /// Returns the hardware fingerprint for the current system. Requires WMI enabled.
        /// </summary>
        /// <param name="type">Type of hardware to use in the Fingerprint</param>
        /// <returns>Hardware Fingerprint as a String</returns>
        public string GetHardwareFingerprint(FingerprintTypes type)
        {
            string fingerprint = null;

            try
            {
                switch (type)
                {
                case FingerprintTypes.Default:
                    fingerprint = _wmiDataProvider.GetPrimaryHardDriveSerial();
                    break;

                case FingerprintTypes.HardDriveSerial:
                    fingerprint = _wmiDataProvider.GetPrimaryHardDriveSerial();
                    break;

                default:
                    throw new ArgumentOutOfRangeException("type");
                }
            }
            catch { }

            if (String.IsNullOrEmpty(fingerprint))
            {
                try
                {
                    fingerprint = _wmiDataProvider.GetProcessorData();
                }
                catch { }
            }

            return(_hashingProvider.ComputeHash(fingerprint, "MD5"));
        }
示例#4
0
        public void LogActiviation(string licenseKey, ActivationResults activationResult, string ipAddress)
        {
            ActivationLog log = new ActivationLog();

            log.LicenseKey       = _hashingProvider.ComputeHash(licenseKey, "SHA256");
            log.ActivationResult = activationResult;
            log.IpAddress        = ipAddress;
            log.Timestamp        = DateTime.Now;

            _activationLogRepository.SaveActivationLog(log);
        }
示例#5
0
        public bool ValidatePassword(byte[] pwd, byte[] pwdCheck, byte[] salt)
        {
            var formattedPwdCheck = _saltStrategy.Format(pwdCheck, salt);
            var hashedPwd         = _hashProvider.ComputeHash(formattedPwdCheck);

            if (pwd.Length != hashedPwd.Length)
            {
                return(false);
            }

            for (var i = 0; i < pwd.Length; i++)
            {
                if (pwd[i] != hashedPwd[i])
                {
                    return(false);
                }
            }

            return(true);
        }
        public bool VaildatePassword(string pwd, byte[] pwdCheck, byte[] salt)
        {
            var formattedPwdCheck = _saltStrategy.Format(pwdCheck, salt);
            var hashedPwd         = _hashingProvider.ComputeHash(formattedPwdCheck);
            var userPwdData       = Encoding.UTF8.GetString(hashedPwd);

            if (pwd.Length != userPwdData.Length)
            {
                return(false);
            }

            for (var i = 0; i < pwd.Length; i++)
            {
                if (pwd[i] != userPwdData[i])
                {
                    return(false);
                }
            }

            return(true);
        }
        //                     傳入資料庫的密碼 ,  使用者輸入的   ,   加料
        public bool ValidatePassword(byte[] pwd, byte[] pwdCheck, byte[] salt)
        {
            //將使用者輸入的加料
            var formattedPwd = _saltStrategy.Format(pwdCheck, salt);
            //先加過料再作Hash
            var hashedPwd = _hashingProvider.ComputeHash(formattedPwd);

            //如果兩個長度不一樣(資料庫的和user輸入的)
            if (pwd.Length != hashedPwd.Length)
            {
                return(false);
            }
            //比對每個字元是否正確
            for (var i = 0; i < pwd.Length; i++)
            {
                if (pwd[i] != hashedPwd[i])
                {
                    return(false);
                }
            }
            return(true);
        }
示例#8
0
        /// <summary>
        /// Authorizes a license key to check to see if it can be activated. If not, logs the failure reason and
        /// returns false.
        /// </summary>
        /// <param name="licenseKey"></param>
        /// <param name="licenseBase"></param>
        /// <param name="hardwareFingerprint"></param>
        /// <returns></returns>
        public bool AuthorizeLicenseForActivation(string licenseKey, ServiceLicense licenseBase, string hardwareFingerprint)
        {
            KeyData keyData = _licenseKeyService.GetLicenseKeyData(licenseKey, licenseBase, true);

            // Step 1: Validate the physical key
            bool keyValid = _licenseKeyService.ValidateLicenseKey(licenseKey, licenseBase, true);

            if (!keyValid)
            {
                _activationLogService.LogActiviation(licenseKey, ActivationResults.ValidationFailure, null);

                return(false);
            }

            SecureString hashedLicenseKey = SecureStringHelper.StringToSecureString(_hashingProvider.ComputeHash(licenseKey, Resources.KeyHashAlgo));

            hashedLicenseKey.MakeReadOnly();

            // Step 2: Validate the key against the service
            if (!DoesKeyExistForLicenseSet(SecureStringHelper.SecureStringToString(hashedLicenseKey), keyData.LicenseSetId))
            {
                _activationLogService.LogActiviation(licenseKey, ActivationResults.UnknownKeyFailure, null);

                return(false);
            }

            // Step 3: Is this key used already
            if (!IsKeyAvialable(SecureStringHelper.SecureStringToString(hashedLicenseKey), keyData.LicenseSetId, hardwareFingerprint))
            {
                _activationLogService.LogActiviation(licenseKey, ActivationResults.TooManyFailure, null);

                return(false);
            }

            return(true);
        }
示例#9
0
        private string GetBucketName()
        {
            string hashData = DateTime.Now.Month + Environment.MachineName + DateTime.Now.Year + DateTime.Now.Day;

            return(_hashingProvider.ComputeHash(hashData, "MD5"));
        }