Esempio n. 1
0
        private bool CheckIfActivated()
        {
            try
            {
                if (!KeyHelper.MatchCurrentHardwareId(HWID_))
                {
                    log.Error("HWID changed");
                    return(false);
                }
                KeyValidator keyVal = new KeyValidator(Tmpl_);

                keyVal.SetKey(LicenseKey_);

                keyVal.SetValidationData("Email", Email_); // the key will not be valid if you set a different user name than the one you have set at key generation
                LicensingClient licensingClient = new LicensingClient(Tmpl_, LicenseKey_, keyVal.QueryValidationData(null), HWID_, ActivationKey_);
                if (licensingClient.IsLicenseValid())
                {
                    byte[] featureSet = keyVal.QueryKeyData("FeatureSet");
                    featureSet.ToString();
                    return(true);
                }
                else
                {
                    return(false);
                }
            }
            catch (Exception E)
            {
                log.Error("Program is not activated", E);
                return(false);
            }
        }
Esempio n. 2
0
        public static void Main(string[] args)
        {
            var p = new OptionSet()
            {
                { "name=", "the name of the person requesting the license", v => _name = v },            // Mandatory
                { "email=", "the email address of the person requesting the license", v => _email = v }, // Mandatory
                { "company=", "the company name of the person requesting the license", v => _company = v },
                // Mandatory
                { "expiry=", "the license expiry date in yyyy-mm-dd format", v => _expires = v }, // Mandatory
                { "?|help", "display this help and exit", v => _showHelp = true },                // Optional
            };

            // Process the command-line arguments
            List <string> options;

            try
            {
                options = p.Parse(args);
            }
            catch (OptionException e)
            {
                System.Console.Write("keygen: ");
                System.Console.WriteLine(e.Message);
                System.Console.WriteLine("Try `keygen --help' for more information.");
                return;
            }

            // Command line option "--help"
            if (_showHelp)
            {
                ShowHelp(p);
                return;
            }

            // Check that the mandatory input arguments were specified.
            if (_name == null ||
                _email == null ||
                _company == null ||
                _expires == null)
            {
                Console.WriteLine("You did not specify all the arguments. Try `keygen --help' for more information.");
                return;
            }

            /* ---------- PROCESS EXPIRY DATE ---------- */

            // Parse the input date.
            try
            {
                _expiryDate = DateTime.ParseExact(_expires, "yyyy-MM-dd", CultureInfo.InvariantCulture);
            }
            catch
            {
                Console.WriteLine("Invalid expiry date format. Date must be in yyyy-mm-dd format.");
                return;
            }

            // If the expiry date is in the past, then throw an error.
            DateTime currentDate = DateTime.Now;

            if (_expiryDate.CompareTo(currentDate) == -1)
            { // -1 is earlier
                Console.WriteLine("Expiry date cannot be in the past.");
                return;
            }

            /* ---------- PRIVATE KEY ---------- */
            string privateKeyFile = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + @"\private.key";

            if (File.Exists(privateKeyFile) == false)
            {
                Console.WriteLine("Could not find \"private.key\". This file is needed to generate a license key.");
                return;
            }
            string privateKey = File.ReadAllText(privateKeyFile);

            /* ---------- CREATE LICENSE TEMPLATE ---------- */
            // This is mostly a cut-and-paste from \SoftActivate Licensing SDK Standard\samples\CS\KeyGenCS
            // Note that the template will have to be duplicated in the C++ code that checks the key.

            // This is a demo key. Replace this key with your purchased key.
            SDKRegistration.SetLicenseKey("SLDMX-3GK7N-NRZKM-5SECA-TV25K");

            // The license key template specifies what the license key will look like, what data will it contain and
            // how secure the license key will be.
            KeyTemplate tmpl = new KeyTemplate();

            tmpl.NumberOfGroups     = 6;
            tmpl.CharactersPerGroup = 5;
            tmpl.Encoding           = LicenseKeyEncoding.Base32X;
            tmpl.GroupSeparator     = "-";
            tmpl.DataSize           = 30;      // the license keys will hold 30 bits of data
            tmpl.SignatureSize      = 120;     // 120 bits = ((characters per group * number of groups) * bits per character) -
            //data size ; 120 = ((6 * 5) * 5) - 30
            tmpl.ValidationDataSize = 100 * 8; // If the field size (as specified in the template) is smaller than the
            // data size, the data is truncated to fit the field.

            // Set the private key used to generate the license keys. This is previously obtained by a call to
            // LicenseKeyTemplate.GenerateSigningKeyPair().
            tmpl.SetPrivateKey(privateKey);        // TODO: replace demo key "w9Oz5xMOwkYv" in file with real key.
            tmpl.SetPublicKey("doxzyMNu7n46whM="); // needed to check that the license generated successfully.

            // Define the data portion of the license key. Keep in mind that the field names are not included in the
            // license keys. Only the field values are included.
            // Add a 14-bit field specifying the product expiration date, between 1/1/2010 and 12/31/2041
            tmpl.AddDataField("ExpirationDate",            // field name
                              LicenseKeyFieldType.Integer, // field is regarded as an integer
                              14,                          // field is 14 bits long (4 bits for month, 5 bits for day, 5 bits for year)
                              0                            // field starts at position 0 in license key data bits
                              );

            tmpl.AddValidationField("Name", LicenseKeyFieldType.String, 40 * 8, 0);
            tmpl.AddValidationField("Company", LicenseKeyFieldType.String, 20 * 8, 40);
            tmpl.AddValidationField("Email", LicenseKeyFieldType.String, 40 * 8, 80);

            // create a key generator based on the template above
            KeyGenerator keyGen = new KeyGenerator(tmpl);

            /* ---------- ADD LICENSE PROPERTIES AND GENERATE KEY ---------- */

            // add an expiration date for this license key
            int packedDate = PackDate(_expiryDate);

            keyGen.SetKeyData("ExpirationDate", packedDate);

            keyGen.SetValidationData("Name", _name);
            keyGen.SetValidationData("Company", _company);
            keyGen.SetValidationData("Email", _email);

            // now generate the license key
            string licenseKey = keyGen.GenerateKey();

            /* ---------- CHECK THE GENERATED KEY ---------- */

            // validate the generated key. This sequence of code is also used in the actual product to validate the
            // entered license key
            KeyValidator keyVal = new KeyValidator(tmpl);

            keyVal.SetKey(licenseKey);

            keyVal.SetValidationData("Name", _name); // the key will not be valid if you set a different user name than the one you have set at key generation
            keyVal.SetValidationData("Company", _company);
            keyVal.SetValidationData("Email", _email);

            if (keyVal.IsKeyValid())
            {
                Console.WriteLine("\nThe generated license key is: " + licenseKey);

                // now read the expiration date from the license key
                int expirationDate = keyVal.QueryIntKeyData("ExpirationDate");

                Console.WriteLine("The expiration date is " + UnpackDate(expirationDate).ToString("MMMM dd, yyyy"));

                _licenseXml = new XElement("license",
                                           new XElement("name", _name),
                                           new XElement("company", _company),
                                           new XElement("email", _email),
                                           new XElement("key", licenseKey),
                                           new XElement("expires", _expires)
                                           );
                Console.WriteLine(_licenseXml.ToString());
            }
            else
            {
                Console.WriteLine("Error creating/validating license key !\n");
            }

            return;
        }
Esempio n. 3
0
        public void ActivationTask(String email, String key)
        {
            string       activationStatusStr = "";
            KeyValidator keyVal = null;

            try
            {
                // validate the generated key. This sequence of code is also used in the actual product to validate the entered license key
                keyVal = new KeyValidator(Tmpl_);
                keyVal.SetKey(key);
            }
            catch (Exception ex)
            {
                OnActivation(false, "Key is incorrect");
                log.Error("Key validation failed " + ex.Message);
                return;
            }

            try
            {
                keyVal.SetValidationData("Email", email); // the key will not be valid if you set a different user name than the one you have set at key generation


                LicensingClient licensingClient = new LicensingClient("https://activation.identamaster.com:444",
                                                                      Tmpl_,
                                                                      key,
                                                                      keyVal.QueryValidationData(null), CurrentHWID_,
                                                                      PRODUCT_ID);

                licensingClient.AcquireLicense();

                LicenseKey_    = key;
                Email_         = email;
                ActivationKey_ = licensingClient.ActivationKey;
                HWID_          = CurrentHWID_;
                // save keys
                SaveKeys();

                if (!licensingClient.IsLicenseValid())
                {
                    switch (licensingClient.LicenseStatus)
                    {
                    case LICENSE_STATUS.InvalidActivationKey:
                        activationStatusStr = "invalid activation key";
                        break;

                    case LICENSE_STATUS.InvalidHardwareId:
                        activationStatusStr = "invalid hardware id";
                        break;

                    case LICENSE_STATUS.Expired:
                    {
                        // the license expiration date returned by LicenseExpirationDate property is only valid if IsLicenseValid() returns true,
                        // or if IsLicenseValid() returns false and LicenseStatus returns LicenseStatus.Expired
                        DateTime expDate = licensingClient.LicenseExpirationDate;
                        activationStatusStr = "license expired (expiration date: " + expDate.Month + "/" + expDate.Day + "/" + expDate.Year + ")";
                    }
                    break;

                    default:
                        activationStatusStr = "unknown";
                        break;
                    }
                    OnActivation(false, activationStatusStr);
                }
                else
                {
                    State = STATE.ACTIVATED;
                    OnActivation(true, "");
                    return;
                }
            }
            catch (System.Net.WebException ex)
            {
                switch (ex.Status)
                {
                case System.Net.WebExceptionStatus.ConnectFailure:
                    OnActivation(false, "Couldn't access activation server");
                    log.Error("Could not connect to server " + ex.Message);
                    break;

                case System.Net.WebExceptionStatus.ProtocolError:
                    OnActivation(false, "Server didn't validate this key");
                    log.Error("Key validation failed " + ex.Message);
                    break;

                default:
                    OnActivation(false, "Network error");
                    log.Error("Unknown network error " + ex.Message);
                    break;
                }
                return;
            }
            catch (Exception ex)
            {
                OnActivation(false, "Failed");
                log.Error("Key validation failed " + ex.Message);
                return;
            }
        }