Implement License Key Fallback to manually parse License Key with additional Exception details

Author: mythz

src/ServiceStack.Text/LicenseUtils.cs

@@ -9,12 +9,14 @@
 using System.Text.RegularExpressions;
 using System.Threading;
 using ServiceStack.Text;
+using ServiceStack.Text.Common;
 
 namespace ServiceStack
 {
     public class LicenseException : Exception
     {
         public LicenseException(string message) : base(message) { }
+        public LicenseException(string message, Exception innerException) : base(message, innerException) {}
     }
 
     public enum LicenseType
@@ -182,17 +184,7 @@ public static void RegisterLicense(string licenseKeyText)
                     throw new LicenseException("This subscription has been revoked. " + ContactDetails);
 
                 var key = PclExport.Instance.VerifyLicenseKeyText(licenseKeyText);
-
-                var releaseDate = Env.GetReleaseDate();
-                if (releaseDate > key.Expiry)
-                    throw new LicenseException("This license has expired on {0} and is not valid for use with this release."
-                        .Fmt(key.Expiry.ToString("d")) + ContactDetails).Trace();
-
-                if (key.Type == LicenseType.Trial && DateTime.UtcNow > key.Expiry)
-                    throw new LicenseException("This trial license has expired on {0}."
-                        .Fmt(key.Expiry.ToString("d")) + ContactDetails).Trace();
-
-                __activatedLicense = key;
+                ValidateLicenseKey(key);
             }
             catch (Exception ex)
             {
@@ -201,9 +193,22 @@ public static void RegisterLicense(string licenseKeyText)
 
                 var msg = "This license is invalid." + ContactDetails;
                 if (!string.IsNullOrEmpty(subId))
-                    msg += " The id for this license is '{0}'".Fmt(subId);
+                    msg += $" The id for this license is '{subId}'";
 
-                throw new LicenseException(msg).Trace();
+                lock (typeof(LicenseUtils))
+                {
+                    try
+                    {
+                        var key = PclExport.Instance.VerifyLicenseKeyTextFallback(licenseKeyText);
+                        ValidateLicenseKey(key);
+                    }
+                    catch (Exception exFallback)
+                    {
+                        throw new LicenseException(msg, exFallback).Trace();
+                    }
+                }
+
+                throw new LicenseException(msg, ex).Trace();
             }
             finally
             {
@@ -213,6 +218,19 @@ public static void RegisterLicense(string licenseKeyText)
             }
         }
 
+        private static void ValidateLicenseKey(LicenseKey key)
+        {
+            var releaseDate = Env.GetReleaseDate();
+            if (releaseDate > key.Expiry)
+                throw new LicenseException($"This license has expired on {key.Expiry:d} and is not valid for use with this release."
+                                           + ContactDetails).Trace();
+
+            if (key.Type == LicenseType.Trial && DateTime.UtcNow > key.Expiry)
+                throw new LicenseException($"This trial license has expired on {key.Expiry:d}." + ContactDetails).Trace();
+
+            __activatedLicense = key;
+        }
+
         public static void RemoveLicense()
         {
             __activatedLicense = null;
@@ -365,7 +383,7 @@ public static LicenseKey ToLicenseKey(this string licenseKeyText)
                 var key = jsv.FromJsv<LicenseKey>();
 
                 if (key.Ref != refId)
-                    throw new LicenseException("The license '{0}' is not assigned to CustomerId '{1}'.".Fmt(base64)).Trace();
+                    throw new LicenseException("The license '{0}' is not assigned to CustomerId '{1}'.".Fmt(base64, refId)).Trace();
 
                 return key;
             }
@@ -376,9 +394,33 @@ public static LicenseKey ToLicenseKey(this string licenseKeyText)
             }
         }
 
+        public static LicenseKey ToLicenseKeyFallback(this string licenseKeyText)
+        {
+            licenseKeyText = Regex.Replace(licenseKeyText, @"\s+", "");
+            var parts = licenseKeyText.SplitOnFirst('-');
+            var refId = parts[0];
+            var base64 = parts[1];
+            var jsv = Convert.FromBase64String(base64).FromUtf8Bytes();
+
+            var map = jsv.FromJsv<Dictionary<string, string>>();
+            var key = new LicenseKey
+            {
+                Ref = map.Get("Ref"),
+                Name = map.Get("Name"),
+                Type = (LicenseType)Enum.Parse(typeof(LicenseType), map.Get("Type")),
+                Hash = map.Get("Hash"),
+                Expiry = DateTimeSerializer.ParseManual(map.Get("Expiry"), DateTimeKind.Utc).GetValueOrDefault(),
+            };
+
+            if (key.Ref != refId)
+                throw new LicenseException($"The license '{base64}' is not assigned to CustomerId '{refId}'.").Trace();
+
+            return key;
+        }
+
         public static string GetHashKeyToSign(this LicenseKey key)
         {
-            return "{0}:{1}:{2}:{3}".Fmt(key.Ref, key.Name, key.Expiry.ToString("yyyy-MM-dd"), key.Type);
+            return $"{key.Ref}:{key.Name}:{key.Expiry:yyyy-MM-dd}:{key.Type}";
         }
 
         public static Exception GetInnerMostException(this Exception ex)

src/ServiceStack.Text/PclExport.Net40.cs

@@ -1133,9 +1133,66 @@ public static bool VerifyLicenseKeyText(this string licenseKeyText, out LicenseK
             return VerifySignedHash(originalData, signedData, publicKeyParams);
         }
 
+        public static bool VerifyLicenseKeyTextFallback(this string licenseKeyText, out LicenseKey key)
+        {
+            RSAParameters publicKeyParams;
+            try
+            {
+                var publicRsaProvider = new RSACryptoServiceProvider();
+                publicRsaProvider.FromXmlString(LicenseUtils.LicensePublicKey);
+                publicKeyParams = publicRsaProvider.ExportParameters(false);
+            }
+            catch (Exception ex)
+            {
+                throw new Exception("Could not import LicensePublicKey", ex);
+            }
+
+            try
+            {
+                key = licenseKeyText.ToLicenseKeyFallback();
+            }
+            catch (Exception ex)
+            {
+                throw new Exception("Could not deserialize LicenseKeyText Manually", ex);
+            }
+
+            byte[] originalData;
+            byte[] signedData;
+
+            try
+            {
+                originalData = key.GetHashKeyToSign().ToUtf8Bytes();
+            }
+            catch (Exception ex)
+            {
+                throw new Exception("Could not convert HashKey to UTF-8", ex);
+            }
+
+            try
+            {
+                signedData = Convert.FromBase64String(key.Hash);
+            }
+            catch (Exception ex)
+            {
+                throw new Exception("Could not convert key.Hash from Base64", ex);
+            }
+
+            try
+            {
+                return VerifySignedHash(originalData, signedData, publicKeyParams);
+            }
+            catch (Exception ex)
+            {
+                throw new Exception($"Could not Verify License Key ({originalData.Length}, {signedData.Length})", ex);
+            }
+        }
+
         public static bool VerifySha1Data(this RSACryptoServiceProvider RSAalg, byte[] unsignedData, byte[] encryptedData)
         {
-            return RSAalg.VerifyData(unsignedData, new SHA1CryptoServiceProvider(), encryptedData);
+            using (var sha = new SHA1CryptoServiceProvider())
+            {
+                return RSAalg.VerifyData(unsignedData, sha, encryptedData);
+            }
             //SL5 || WP
             //return RSAalg.VerifyData(unsignedData, encryptedData, new EMSAPKCS1v1_5_SHA1()); 
         }

src/ServiceStack.Text/PclExport.cs

@@ -452,6 +452,11 @@ public virtual LicenseKey VerifyLicenseKeyText(string licenseKeyText)
             return licenseKeyText.ToLicenseKey();
         }
 
+        public virtual LicenseKey VerifyLicenseKeyTextFallback(string licenseKeyText)
+        {
+            return licenseKeyText.ToLicenseKeyFallback();
+        }
+
         public virtual void BeginThreadAffinity()
         {
         }

tests/ServiceStack.Text.Tests/LicensingTests.cs

@@ -199,6 +199,28 @@ private void AssertKey(string licenseKeyText, LicenseKey expectedKey)
             Assert.That(licenseKey.Expiry, Is.EqualTo(expectedKey.Expiry));
         }
 
+        [Test]
+        public void Can_deserialize_all_license_key_fallback()
+        {
+            AssertKeyFallback(TestBusiness2000Text, TestBusiness2000);
+            AssertKeyFallback(TestIndie2000Text, TestIndie2000);
+            AssertKeyFallback(TestBusiness2013Text, TestBusiness2013);
+            AssertKeyFallback(TestIndie2013Text, TestIndie2013);
+            AssertKeyFallback(TestTrial2001Text, TestTrial2001);
+            AssertKeyFallback(TestTrial2016Text, TestTrial2016);
+        }
+
+        private void AssertKeyFallback(string licenseKeyText, LicenseKey expectedKey)
+        {
+            var licenseKey = licenseKeyText.ToLicenseKeyFallback();
+
+            Assert.That(licenseKey.Ref, Is.EqualTo(expectedKey.Ref));
+            Assert.That(licenseKey.Name, Is.EqualTo(expectedKey.Name));
+            Assert.That(licenseKey.Type, Is.EqualTo(expectedKey.Type));
+            //Assert.That(licenseKey.Hash, Is.EqualTo(expectedKey.Hash));
+            Assert.That(licenseKey.Expiry, Is.EqualTo(expectedKey.Expiry));
+        }
+
 #if !NETCORE
         [Explicit,Test]
         public void Test_dynamically_loaded_assemblies()