public void GetIdentifierTest()
        {
            const string Expected = "485B39315153-BFEBFBFF000106E5-A6502408";

            string actualEncryptedHex = PrivateKey.GetPrivateKey();

            var license = new License
            {
                Type       = License.LicenseType.Trial,
                TrialStart = new DateTime(2010, 11, 01),
                TrialEnd   = new DateTime(2010, 11, 09)
            };

            string licenseString = license.GenerateLicense(actualEncryptedHex);

            WriteLicenseKey(licenseString);

            string fullPath = Path.Combine(@"C:\Program Files\Alphamosaik\SharepointTranslator2010", "license.dat");

            if (File.Exists(fullPath))
            {
                string license1 = File.ReadAllText(fullPath);

                var license2 = new License(actualEncryptedHex, license1);

                if (license2.IsValide)
                {
                    string words1 = LoremIpsumGenerator.GetWords(512);
                }
            }

            string words = LoremIpsumGenerator.GetWords(512);

            Assert.Inconclusive("Verify the correctness of this test method.");
        }
Esempio n. 2
0
        void ComputeIccContext()
        {
            var issuerModulusLength = new BigInteger(issuerPrivateKey.Modulus, 16).BitLength / 8;
            var iccPublicKey        = certificateData.IccPrivateKey.GetPublicKey();
            var iccModulusLength    = new BigInteger(iccPublicKey.Modulus, 16).BitLength / 8;

            var iccPublicKeyCertificate = new IccPublicKeyCertificate
            {
                HashAlgorithmIndicator      = certificateData.HashAlgorithmIndicator.FromHexa().First(),
                ApplicationPan              = certificateData.ApplicationPan.FromHexa(),
                CertificateExpirationDate   = certificateData.ExpirationDate.FromHexa(),
                CertificateSerialNumber     = certificateData.SerialNumber.FromHexa(),
                PublicKeyAlgorithmIndicator = certificateData.PublicKeyAlgorithmIndicator.FromHexa().First(),
                IccPublicKey = iccPublicKey
            };

            IccContext = new EmvIccContext()
            {
                ApplicationPan = certificateData.ApplicationPan,
                IccPrivateKey  = certificateData.IccPrivateKey
            };

            // 9F46 ICC Public Key Certificate (Nca)
            IccContext.IccPublicKeyCertificate = iccPublicKeyCertificate.GenerateCertificate(issuerPrivateKey.GetPrivateKey()).ToHexa();

            // 9F48 ICC Public Key Remainder (Ni-Nca+42)
            if (iccModulusLength > issuerModulusLength - 42)
            {
                IccContext.IccPublicKeyRemainder = iccPublicKey.Modulus.FromHexa().Skip(issuerModulusLength - 42).ToArray().ToHexa();
            }

            // 9F47 ICC Public Key Exponent (1 or 3)
            IccContext.IccPrivateKey.PublicExponent = iccPublicKey.Exponent.FromHexa().ToHexa();
        }
Esempio n. 3
0
        void ComputeIssuerContext()
        {
            var caModulusLength     = new BigInteger(caPrivateKey.Modulus, 16).BitLength / 8;
            var issuerPublicKey     = certificateData.IssuerPrivateKey.GetPublicKey();
            var issuerModulusLength = new BigInteger(issuerPublicKey.Modulus, 16).BitLength / 8;

            var issuerPublicKeyCertificate = new IssuerPublicKeyCertificate
            {
                HashAlgorithmIndicator      = certificateData.HashAlgorithmIndicator.FromHexa().First(),
                IssuerIdentifier            = certificateData.IssuerIdentifier.FromHexa(),
                CertificateExpirationDate   = certificateData.ExpirationDate.FromHexa(),
                CertificateSerialNumber     = certificateData.SerialNumber.FromHexa(),
                PublicKeyAlgorithmIndicator = certificateData.PublicKeyAlgorithmIndicator.FromHexa().First(),
                IssuerPublicKey             = issuerPublicKey
            };

            IssuerContext = new EmvIssuerContext()
            {
                CaPublicKeyIndex = certificateData.CaPublicKeyIndex,
                IssuerPrivateKey = certificateData.IssuerPrivateKey
            };

            // 90   Issuer Public Key Certificate (Nca)
            IssuerContext.IssuerPublicKeyCertificate = issuerPublicKeyCertificate.GenerateCertificate(caPrivateKey.GetPrivateKey()).ToHexa();

            // 92   Issuer Public Key Remainder (Ni-Nca+36)
            if (issuerModulusLength > caModulusLength - 36)
            {
                IssuerContext.IssuerPublicKeyRemainder = issuerPublicKey.Modulus.FromHexa().Skip(caModulusLength - 36).ToArray().ToHexa();
            }

            // 9F32 Issuer Public Key Exponent (1 or 3)
            IssuerContext.IssuerPrivateKey.PublicExponent = issuerPublicKey.Exponent.FromHexa().ToHexa();
        }
        private static void GenerateLicenseKeyFile(string path)
        {
            string actualEncryptedHex = PrivateKey.GetPrivateKey();

            WriteLicenseKey(path, actualEncryptedHex);
        }