Esempio n. 1
0
        public static void ExportAutoKey()
        {
            RSAParameters privateParams;
            RSAParameters publicParams;
            int keySize;

            using (RSA rsa = new RSACryptoServiceProvider())
            {
                keySize = rsa.KeySize;

                // We've not done anything with this instance yet, but it should automatically
                // create the key, because we'll now asked about it.
                privateParams = rsa.ExportParameters(true);
                publicParams = rsa.ExportParameters(false);

                // It shouldn't be changing things when it generated the key.
                Assert.Equal(keySize, rsa.KeySize);
            }

            Assert.Null(publicParams.D);
            Assert.NotNull(privateParams.D);

            ValidateParameters(ref publicParams);
            ValidateParameters(ref privateParams);

            Assert.Equal(privateParams.Modulus, publicParams.Modulus);
            Assert.Equal(privateParams.Exponent, publicParams.Exponent);
        }
Esempio n. 2
0
        private static void GenerateKey(Func<RSA, int> getSize)
        {
            int keySize;

            using (var rsa = new RSACryptoServiceProvider())
            {
                keySize = getSize(rsa);
            }

            using (var rsa = new RSACryptoServiceProvider(keySize))
            {
                Assert.Equal(keySize, rsa.KeySize);

                // Some providers may generate the key in the constructor, but
                // all of them should have generated it before answering ExportParameters.
                RSAParameters keyParameters = rsa.ExportParameters(false);
                ImportExport.ValidateParameters(ref keyParameters);

                // KeySize should still be what we set it to originally.
                Assert.Equal(keySize, rsa.KeySize);

                // KeySize describes the size of the modulus in bits
                // So, 8 * the number of bytes in the modulus should be the same value.
                Assert.Equal(keySize, keyParameters.Modulus.Length * 8);
            }
        }
Esempio n. 3
0
        public static void PaddedExport()
        {
            // OpenSSL's numeric type for the storage of RSA key parts disregards zero-valued
            // prefix bytes.
            //
            // The .NET 4.5 RSACryptoServiceProvider type verifies that all of the D breakdown
            // values (P, DP, Q, DQ, InverseQ) are exactly half the size of D (which is itself
            // the same size as Modulus).
            //
            // These two things, in combination, suggest that we ensure that all .NET
            // implementations of RSA export their keys to the fixed array size suggested by their
            // KeySize property.
            RSAParameters diminishedDPParamaters = TestData.DiminishedDPParamaters;
            RSAParameters exported;

            using (RSA rsa = new RSACryptoServiceProvider())
            {
                rsa.ImportParameters(diminishedDPParamaters);
                exported = rsa.ExportParameters(true);
            }

            // DP is the most likely to fail, the rest just otherwise ensure that Export
            // isn't losing data.
            AssertKeyEquals(ref diminishedDPParamaters, ref exported);
        }
Esempio n. 4
0
        public static void LargeKeyImportExport()
        {
            RSAParameters imported = TestData.RSA16384Params;

            using (RSA rsa = new RSACryptoServiceProvider())
            {
                try
                {
                    rsa.ImportParameters(imported);
                }
                catch (CryptographicException)
                {
                    // The key is pretty big, perhaps it was refused.
                    return;
                }

                RSAParameters exported = rsa.ExportParameters(false);

                Assert.Equal(exported.Modulus, imported.Modulus);
                Assert.Equal(exported.Exponent, imported.Exponent);
                Assert.Null(exported.D);

                exported = rsa.ExportParameters(true);

                AssertKeyEquals(ref imported, ref exported);
            }
        }
Esempio n. 5
0
 public static RSAParameters ToPublicRSAParameters(this string publicKeyXml)
 {
     using (var rsa = new RSACryptoServiceProvider())
     {
         rsa.FromXmlString(publicKeyXml);
         return rsa.ExportParameters(includePrivateParameters: false);
     }
 }
Esempio n. 6
0
    //Asymetric
    void Main()
    {
        try
        {
            UnicodeEncoding ByteConverter = new UnicodeEncoding();

            byte[] dataToEncrypt = ByteConverter.GetBytes("Data to Encrypt");
            byte[] encryptedData;
            byte[] decryptedData;

            using (RSACryptoServiceProvider RSA = new RSACryptoServiceProvider())
            {
                encryptedData = RSAEncrypt(dataToEncrypt, RSA.ExportParameters(false));
                decryptedData = RSADecrypt(encryptedData, RSA.ExportParameters(true));

                Console.WriteLine("Decrypted plaintext: {0}", ByteConverter.GetString(decryptedData));
            }
        }
        catch (ArgumentNullException)
        {
            Console.WriteLine("Encryption failed.");
        }
    }
Esempio n. 7
0
        public static void RsaDecryptAfterExport()
        {
            byte[] output;

            using (var rsa = new RSACryptoServiceProvider())
            {
                byte[] crypt = rsa.Encrypt(TestData.HelloBytes, true);

                // Export the key, this should not clear/destroy the key.
                RSAParameters ignored = rsa.ExportParameters(true);
                output = rsa.Decrypt(crypt, true);
            }

            Assert.Equal(TestData.HelloBytes, output);
        }
  public static void Main(string[] args) {
    string path = args[0];
    byte[] blob = null;
    using(FileStream fs = File.Open(path, FileMode.Open)) {
      blob = new byte[fs.Length];
      fs.Read(blob, 0, blob.Length);
    }

    RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
    rsa.ImportCspBlob(blob);
    RSAParameters PrivateKey = rsa.ExportParameters(true);
    byte[] key = RSAKeyToASN1(PrivateKey);

    using(FileStream fs = File.Open(path + ".out", FileMode.Create)) {
      fs.Write(key, 0, key.Length);
    }

    Console.WriteLine("Your file is ready for you at " + path + ".out.");
  }
    public void Pkcs1DecodingTest()
    {
        #pragma warning disable 0436
        // Initialize the "Known Good" RSAParameters.
        byte[] capi1Blob = Convert.FromBase64String(AsymmetricKeyAlgorithmProviderTests.Helper.PrivateKeyFormatsAndBlobs[Tuple.Create(PCLCrypto.AsymmetricAlgorithm.RsaOaepSha1, CryptographicPrivateKeyBlobType.Capi1PrivateKey)]);
        var rsa = new RSACryptoServiceProvider();
        rsa.ImportCspBlob(capi1Blob);
        RSAParameters rsaCapi = rsa.ExportParameters(true);

        // Now load up the tested one.
        byte[] pkcs1KeyBlob = Convert.FromBase64String(AsymmetricKeyAlgorithmProviderTests.Helper.PrivateKeyFormatsAndBlobs[Tuple.Create(PCLCrypto.AsymmetricAlgorithm.RsaOaepSha1, CryptographicPrivateKeyBlobType.Pkcs1RsaPrivateKey)]);
        RSAParameters homeReadPkcs1 = KeyFormatter.ToPlatformParameters(KeyFormatter.Pkcs1.Read(pkcs1KeyBlob));
        #pragma warning restore 0436
        Assert.Equal(WinRTCrypto.CryptographicBuffer.EncodeToHexString(rsaCapi.Modulus), WinRTCrypto.CryptographicBuffer.EncodeToHexString(homeReadPkcs1.Modulus));
        Assert.Equal(WinRTCrypto.CryptographicBuffer.EncodeToHexString(rsaCapi.Exponent), WinRTCrypto.CryptographicBuffer.EncodeToHexString(homeReadPkcs1.Exponent));
        Assert.Equal(WinRTCrypto.CryptographicBuffer.EncodeToHexString(rsaCapi.D), WinRTCrypto.CryptographicBuffer.EncodeToHexString(homeReadPkcs1.D));
        Assert.Equal(WinRTCrypto.CryptographicBuffer.EncodeToHexString(rsaCapi.P), WinRTCrypto.CryptographicBuffer.EncodeToHexString(homeReadPkcs1.P));
        Assert.Equal(WinRTCrypto.CryptographicBuffer.EncodeToHexString(rsaCapi.Q), WinRTCrypto.CryptographicBuffer.EncodeToHexString(homeReadPkcs1.Q));
        Assert.Equal(WinRTCrypto.CryptographicBuffer.EncodeToHexString(rsaCapi.DP), WinRTCrypto.CryptographicBuffer.EncodeToHexString(homeReadPkcs1.DP));
        Assert.Equal(WinRTCrypto.CryptographicBuffer.EncodeToHexString(rsaCapi.DQ), WinRTCrypto.CryptographicBuffer.EncodeToHexString(homeReadPkcs1.DQ));
        Assert.Equal(WinRTCrypto.CryptographicBuffer.EncodeToHexString(rsaCapi.InverseQ), WinRTCrypto.CryptographicBuffer.EncodeToHexString(homeReadPkcs1.InverseQ));
    }
Esempio n. 10
0
        public void RSA_public_blob_to_jwk()
        {
            var bytes = Convert.FromBase64String(File.ReadAllText(@"C:\Temp\public.blob"));
            var csp   = new RSACryptoServiceProvider();

            csp.ImportCspBlob(bytes);

            var parameters = csp.ExportParameters(false);
            var keyset     = new JsonWebKeySet
            {
                Keys = new JsonWebKey[]
                {
                    new JsonWebKey
                    {
                        Algorithm     = "RS256",
                        KeyType       = "RSA",
                        IntendedUse   = "sig",
                        Exponent      = Convert.ToBase64String(parameters.Exponent),
                        Modulus       = Convert.ToBase64String(parameters.Modulus),
                        KeyIdentifier = "1"
                    }
                }
            };

            Console.WriteLine(JsonConvert.SerializeObject(keyset));

            var jwk = keyset.Keys.Where(k => k.KeyType == "RSA" && k.IntendedUse == "sig").First();

            csp.ImportParameters(new RSAParameters
            {
                Exponent = Convert.FromBase64String(jwk.Exponent),
                Modulus  = Convert.FromBase64String(jwk.Modulus)
            });
            bytes = csp.ExportCspBlob(false);
            File.WriteAllText(@"C:\Temp\public.from_jwk.blob", Convert.ToBase64String(bytes));
        }
Esempio n. 11
0
        void loadP12(byte[] p12data, string password)
        {
            X509Certificate2Collection col = new X509Certificate2Collection();

            col.Import(p12data, password, X509KeyStorageFlags.Exportable);
            foreach (X509Certificate2 cert in col)
            {
                if (cert.HasPrivateKey)
                {
                    _certificate = cert;
                    RSACryptoServiceProvider tmpKey    = (RSACryptoServiceProvider)cert.PrivateKey;
                    RSAParameters            keyParams = tmpKey.ExportParameters(true);
                    CspParameters            p         = new CspParameters();
                    p.ProviderName = "Microsoft Enhanced RSA and AES Cryptographic Provider";
                    _key           = new RSACryptoServiceProvider(p);
                    _key.ImportParameters(keyParams);
                }
            }

            if (_key == null || _certificate == null)
            {
                throw new ArgumentException("key and/or certificate still missing after p12 processing");
            }
        }
Esempio n. 12
0
        public void AllowGoodToken()
        {
            var fakeIssuer   = "example.okta.com";
            var fakeAudience = "aud://default";

            using (RSACryptoServiceProvider rsaCryptoServiceProvider = new RSACryptoServiceProvider(2048))
            {
                RSAParameters rsaKeyInfo     = rsaCryptoServiceProvider.ExportParameters(true);
                var           rsaSecurityKey = new RsaSecurityKey(rsaKeyInfo);

                var signingCredentials = new SigningCredentials(rsaSecurityKey, SecurityAlgorithms.RsaSha256);

                var jwtContents = new JwtSecurityToken(
                    issuer: fakeIssuer,
                    audience: fakeAudience,
                    expires: DateTime.UtcNow.Add(TimeSpan.FromMinutes(1)),
                    signingCredentials: signingCredentials);

                var jwt = new JwtSecurityTokenHandler().WriteToken(jwtContents);

                var fakeOktaWebOptions = new OktaWebOptions
                {
                    OktaDomain = fakeIssuer,
                };

                var handler = new StrictTokenHandler();

                var validationParameters = new DefaultTokenValidationParameters(fakeOktaWebOptions, fakeIssuer)
                {
                    IssuerSigningKey = signingCredentials.Key,
                    ValidAudience    = fakeAudience,
                };

                handler.ValidateToken(jwt, validationParameters, out _);
            }
        }
Esempio n. 13
0
        /// <summary>
        ///  XML格式私钥转PEM
        /// </summary>
        /// <param name="xml">XML格式私钥</param>
        /// <param name="saveFile">保存文件的物理路径</param>
        public static string Xml2PemPrivate(string xml, string saveFile)
        {
            var rsa = new RSACryptoServiceProvider();

            rsa.FromXmlString(xml);
            var p   = rsa.ExportParameters(true);
            var key = new RsaPrivateCrtKeyParameters(
                new BigInteger(1, p.Modulus), new BigInteger(1, p.Exponent), new BigInteger(1, p.D),
                new BigInteger(1, p.P), new BigInteger(1, p.Q), new BigInteger(1, p.DP), new BigInteger(1, p.DQ),
                new BigInteger(1, p.InverseQ));

            using (var sw = new StreamWriter(saveFile))
            {
                var pemWriter = new Org.BouncyCastle.OpenSsl.PemWriter(sw);
                pemWriter.WriteObject(key);
            }

            PrivateKeyInfo privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(key);

            byte[] serializedPrivateBytes = privateKeyInfo.ToAsn1Object().GetEncoded();
            string privateKey             = Convert.ToBase64String(serializedPrivateBytes);

            return(Format(privateKey, 2));
        }
Esempio n. 14
0
        // Load private and or public key information from the key store.
        // This overloaded version of the method loads the information from the user
        // section if "useMachineStore" is false, otherwise it loads the information
        // from the machine section. The method will return false if the entry does
        // not exist.
        public bool LoadFromContainer(string containerName, bool useMachineStore)
        {
            // Create new cryptographic service provider parameters object
            CspParameters cspParameters = new CspParameters();

            // Set the container name, which in this case is the MAC address
            cspParameters.KeyContainerName = containerName;
            // This flag indicates that the entry must exist. Without setting this
            // the application will return a random key. This flag is also what causes
            // an error to be thrown in the following try-catch.
            cspParameters.Flags = CspProviderFlags.UseExistingKey;
            // Set the machine store flag if necessary
            if (useMachineStore)
            {
                cspParameters.Flags |= CspProviderFlags.UseMachineKeyStore;
            }
            // If this throws an error then the entry does not exist
            try
            {
                // Create temporary RSA encryption in order to load the information from the
                // key store and import into classes' RSA encryption object.
                using (RSACryptoServiceProvider tempRsa = new RSACryptoServiceProvider(cspParameters))
                {
                    // Import key information from the key store to the current class RSA
                    // encryption object.
                    _rsa.ImportParameters(tempRsa.ExportParameters(!tempRsa.PublicOnly));
                }
            }
            catch
            {
                // The entry does not exist
                return(false);
            }
            // The entry was retrieved
            return(true);
        }
            public RSAParameters GenerateOtherPublicKey()
            {
                var folder = ruta;

                if (!Directory.Exists(folder))
                {
                    Directory.CreateDirectory(folder);
                }

                RSAParameters key = new RSAParameters();

                using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(2048))
                {
                    //rsa.ImportParameters(GetPrivateKey());
                    var publicKey = rsa.ExportParameters(false);
                    using (var str = new FileStream(Path.Combine(folder, $"publicKey.xml"), FileMode.Create))
                    {
                        var xml = new System.Xml.Serialization.XmlSerializer(typeof(RSAParameters));
                        xml.Serialize(str, publicKey);
                    }
                }

                return(key);
            }
Esempio n. 16
0
        /// <summary>
        /// Returns the RSA Key pair for a RSA CryptoServiceProvider
        /// Borrowed this small sample from .NET Crypto Extensions
        /// </summary>
        /// <param name="rsa">RSA CSP</param>
        /// <returns>RSA key pair</returns>
        private static AsymmetricCipherKeyPair GetRsaKeyPair(
            RSACryptoServiceProvider rsa)
        {
            RSAParameters rp      = rsa.ExportParameters(true);
            BigInteger    modulus = new BigInteger(1, rp.Modulus);
            BigInteger    pubExp  = new BigInteger(1, rp.Exponent);

            RsaKeyParameters pubKey = new RsaKeyParameters(
                false,
                modulus,
                pubExp);

            RsaPrivateCrtKeyParameters privKey = new RsaPrivateCrtKeyParameters(
                modulus,
                pubExp,
                new BigInteger(1, rp.D),
                new BigInteger(1, rp.P),
                new BigInteger(1, rp.Q),
                new BigInteger(1, rp.DP),
                new BigInteger(1, rp.DQ),
                new BigInteger(1, rp.InverseQ));

            return(new AsymmetricCipherKeyPair(pubKey, privKey));
        }
        public RSAParameters ParseRSAKeyInfo(RSAKeySetIdentity rsaKeySet)
        {
            RSAParameters rsaParams;

            int startIndex = rsaKeySet.RSA_PrivateKey.IndexOf(BEGIN_RSA_PRIVATE_KEY, StringComparison.Ordinal);
            int endIndex   = rsaKeySet.RSA_PrivateKey.IndexOf(END_RSA_PRIVATE_KEY, StringComparison.Ordinal);

            if (startIndex < 0 || endIndex < 0)
            {
                throw new ArgumentException("Invalid key data");
            }

            string keyData = rsaKeySet.RSA_PrivateKey.Substring(startIndex + BEGIN_RSA_PRIVATE_KEY.Length, endIndex - startIndex - BEGIN_RSA_PRIVATE_KEY.Length).Replace("\r\n", "");

            byte[] keyBlobBytes = Convert.FromBase64String(keyData);
            using (var rsa = new RSACryptoServiceProvider())
            {
                rsa.ImportCspBlob(keyBlobBytes);
                rsaParams = rsa.ExportParameters(true);
            }


            return(rsaParams);
        }
Esempio n. 18
0
        public ISignatureAlgorithm ToSignatureAlgorithm(SignatureAlgorithmDataRecord dataRecord, SharedSecretEncryptionKey encryptionKey, int?recordVersion)
        {
            if (dataRecord == null)
            {
                throw new ArgumentNullException(nameof(dataRecord));
            }

            switch (dataRecord.Type)
            {
            case string str when str.Equals("rsa", StringComparison.OrdinalIgnoreCase):
                using (var rsaForVerification = new RSACryptoServiceProvider())
                {
                    rsaForVerification.FromXml(dataRecord.Param);
                    var paramsForVerification = rsaForVerification.ExportParameters(includePrivateParameters: false);

                    return(SignatureAlgorithm.CreateForVerification(paramsForVerification, new HashAlgorithmName(dataRecord.Hash)));
                }

            case string str when str.Equals("ecdsa", StringComparison.OrdinalIgnoreCase):
                using (var ecdsaForVerification = ECDsa.Create())
                {
                    ecdsaForVerification.FromXml(dataRecord.Param);
                    var paramsForVerification = ecdsaForVerification.ExportParameters(includePrivateParameters: false);

                    return(SignatureAlgorithm.CreateForVerification(paramsForVerification, new HashAlgorithmName(dataRecord.Hash)));
                }

            case string str when str.Equals("hmac", StringComparison.OrdinalIgnoreCase):
                var unencryptedKey = GetUnencryptedParameter(dataRecord, encryptionKey);

                return(SignatureAlgorithm.CreateForVerification(unencryptedKey, new HashAlgorithmName(dataRecord.Hash)));

            default:
                throw new NotSupportedException($"The specified signature algorithm type ({dataRecord.Type ?? "[null]"}) cannot be deserialized.");
            }
        }
            public async Task CanRoundTripRSA()
            {
                using (var rsa = new RSACryptoServiceProvider()) {
                    var publicKeyParams = rsa.ExportParameters(false);
                    var rsaAlg          = RSASignatureAlgorithm.CreateForVerification(HashAlgorithmName.SHA384, publicKeyParams);
                    var client          = new Client(
                        "c1",
                        "app one",
                        rsaAlg,
                        TimeSpan.FromMinutes(1),
                        TimeSpan.FromMinutes(1),
                        RequestTargetEscaping.RFC2396,
                        new Claim("company", "Dalion"),
                        new Claim("scope", "HttpMessageSigning"));
                    await _sut.Register(client);

                    var actual = await _sut.Get(client.Id);

                    actual.Should().BeEquivalentTo(client, options => options.ComparingByMembers <Client>());
                    actual.SignatureAlgorithm.Should().BeAssignableTo <RSASignatureAlgorithm>();
                    actual.SignatureAlgorithm.As <RSASignatureAlgorithm>().GetPublicKey().ToXml().Should().Be(rsa.ExportParameters(false).ToXml());
                    actual.SignatureAlgorithm.As <RSASignatureAlgorithm>().HashAlgorithm.Should().Be(HashAlgorithmName.SHA384);
                }
            }
Esempio n. 20
0
        /*
         * 构造RSA公钥私钥集合(c#、java互通)
         */
        public static Hashtable RSAInitKey()
        {
            Hashtable ht = new Hashtable();
            RSACryptoServiceProvider RSA        = new RSACryptoServiceProvider();
            RSAParameters            RSAKeyInfo = RSA.ExportParameters(true);

            try
            {
                ht.Add("publickey", Convert.ToBase64String(RSA.ExportCspBlob(false)));
                ht.Add("privatekey", Convert.ToBase64String(RSA.ExportCspBlob(true)));
                ht.Add("d", Convert.ToBase64String(RSAKeyInfo.D));
                ht.Add("dp", Convert.ToBase64String(RSAKeyInfo.DP));
                ht.Add("dq", Convert.ToBase64String(RSAKeyInfo.DQ));
                ht.Add("p", Convert.ToBase64String(RSAKeyInfo.P));
                ht.Add("q", Convert.ToBase64String(RSAKeyInfo.Q));
                ht.Add("inverseq", Convert.ToBase64String(RSAKeyInfo.InverseQ));
                ht.Add("modulus", Convert.ToBase64String(RSAKeyInfo.Modulus));
            }
            catch
            {
                Console.WriteLine("rsa - Hashtable-An element with key already exists");
            }
            return(ht);
        }
Esempio n. 21
0
        public CryptoManager()
        {
            m_RSA_Exch_Def = new RSAPKCS1KeyExchangeDeformatter();
            m_RSA_Exch_For = new RSAPKCS1KeyExchangeFormatter();
            m_RSA          = new RSACryptoServiceProvider();
            m_RSA.KeySize  = m_KeySize;
            //m_RSA.PersistKeyInCsp    = true;

            m_SHA = new SHA256Managed();

            m_RIJ           = new RijndaelManaged();
            m_RIJ.Padding   = PaddingMode.PKCS7;
            m_RIJ.Mode      = CipherMode.CBC;
            m_RIJ.IV        = new byte[16];
            m_RIJ.BlockSize = 128;
            m_RIJ.KeySize   = 256;
            m_RIJ.GenerateKey();

            //m_PublicKey              = m_RSA.ExportCspBlob(false);
            //m_PrivateKey             = m_RSA.ExportCspBlob(true);
            m_PublicKey  = Encoding.UTF8.GetBytes(m_RSA.ToXmlString(false));
            m_PrivateKey = Encoding.UTF8.GetBytes(m_RSA.ToXmlString(true));
            m_KeyPair    = m_RSA.ExportParameters(true);
        }
Esempio n. 22
0
        public bool ProvjeriPotpisPoruke()
        {
            //Dohvaćanje privatnog ključa
            RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();

            var javniKljuc = rsa.ExportParameters(true);
            var sr         = new System.IO.StringReader(System.IO.File.ReadAllText(@"javni_kljuc.txt"));
            var xs         = new System.Xml.Serialization.XmlSerializer(typeof(RSAParameters));

            javniKljuc = (RSAParameters)xs.Deserialize(sr);

            rsa = new RSACryptoServiceProvider();
            rsa.ImportParameters(javniKljuc);

            //Citanje kriptiranog teksta i potpisane poruke
            string kriptiraniTekst = System.IO.File.ReadAllText(@"asimetricno_kriptiranje.txt");

            byte[] kriptiraniTekstBajtniOblik = Convert.FromBase64String(kriptiraniTekst);

            byte[] digitalniPotpis = System.IO.File.ReadAllBytes(@"digitalniPotpis.txt");

            //Provjera potpisa
            return(rsa.VerifyData(kriptiraniTekstBajtniOblik, "SHA512", digitalniPotpis));
        }
Esempio n. 23
0
        public async Task JwtTokenGenerator_ShouldBeOk_WhenIsSuTagIsPresentAndIsTrue()
        {
            // Arrange
            var options = Options.Create(new JwtOptions()
            {
                TokenLifeTime = 1
            });

            var publicAndPrivate = new RSACryptoServiceProvider(2048);
            var key = new RsaSecurityKey(publicAndPrivate.ExportParameters(true));
            var signingCredentials = new SigningCredentials(key, SecurityAlgorithms.RsaSha256);
            var handler            = new JwtSecurityTokenHandler();
            var sut = new JwtTokenGenerator(options, signingCredentials, handler);

            // Act
            var jwtToken = sut.CreateJwtToken();

            // Assert
            var jsonToken      = handler.ReadToken(jwtToken);
            var tokens         = handler.ReadToken(jwtToken) as JwtSecurityToken;
            var isSuClaimValue = tokens.Claims.First(claim => claim.Type == "isSU").Value;

            Assert.True(isSuClaimValue == "true");
        }
Esempio n. 24
0
        private void Test(string Name, int Size)
        {
            CspParameters CspParams = new CspParameters()
            {
                Flags            = CspProviderFlags.UseMachineKeyStore | CspProviderFlags.NoPrompt,
                KeyContainerName = Name
            };

            Stopwatch Watch = new Stopwatch();

            Watch.Start();

            RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(Size, CspParams);

            Watch.Stop();
            double Ms = (1000.0d * Watch.ElapsedTicks) / Stopwatch.Frequency;

            RSAParameters Parameters = rsa.ExportParameters(true);

            Console.Out.WriteLine("Size: " + Size.ToString());
            Console.Out.WriteLine("Time: " + Ms.ToString("F2") + " ms");
            Console.Out.WriteLine("P Len: " + Parameters.P.Length.ToString());
            Console.Out.WriteLine("Q Len: " + Parameters.Q.Length.ToString());
        }
Esempio n. 25
0
        public OrderDomains(Options options)
        {
            this.options = options;
            var serviceCollection = new ServiceCollection();

            serviceCollection.AddHttpClient();
            ServiceProvider    services          = serviceCollection.BuildServiceProvider();
            IHttpClientFactory httpClientFactory = services.GetRequiredService <System.Net.Http.IHttpClientFactory>();

            cloudflareClient = new CloudflareClientFactory(options.Username, options.ApiKey, new CloudflareRestClientFactory(httpClientFactory), CloudflareAPIEndpoint.V4Endpoint)
                               .Create();

            // RSA service provider
            var rsaCryptoServiceProvider = new RSACryptoServiceProvider(2048);

            if (string.IsNullOrEmpty(options.Key))
            {
                Program.LogLine("Generating new key for ACME.");
                var exportKey = rsaCryptoServiceProvider.ExportCspBlob(true);
                var strKey    = Convert.ToBase64String(exportKey);

                File.WriteAllText("acmekey.key", strKey);
            }
            else
            {
                var key = Convert.FromBase64String(File.ReadAllText(options.Key));
                rsaCryptoServiceProvider.ImportCspBlob(key);
            }

            var rsaKey = RSA.Create(rsaCryptoServiceProvider.ExportParameters(true));

            acmeClient = new ACMEClient(
                new Uri(options.Environment == AcmeEnvironment.ProductionV2 ? ACMEEnvironment.ProductionV2 : ACMEEnvironment.StagingV2),
                rsaKey,
                new HttpClient());
        }
Esempio n. 26
0
        public void Checking_Message_That_Was_Signed_By_Hospital_For_Should_Return_Success()
        {
            // given
            var           cryptoProvider    = GetCryptoProvider();
            RSAParameters rsaPrivateKeyInfo = cryptoProvider.ExportParameters(true);
            string        publicKeyPem      = ExportPublicKey(cryptoProvider);
            Patient       patient           = new Patient("joe", "smith", "*****@*****.**");

            // simulate having an ID from the DB
            Hospital hospital = new Hospital("Acme Hospital", publicKeyPem);

            patient.Id = 124;
            Document doc1          = new Document(patient.Id, hospital);
            var      message       = doc1.ToJson();
            string   signedMessage = SignData(message, rsaPrivateKeyInfo);

            // when
            var signatureService = GetSignatureService();
            RSACryptoServiceProvider importedKey = signatureService.ImportPublicKey(publicKeyPem);
            var result = signatureService.VerifySignature(message, signedMessage, importedKey.ExportParameters(false));

            // then
            result.Should().BeTrue();
        }
Esempio n. 27
0
        /// <summary>
        /// 得到RSA的解谜的密匙对
        /// </summary>
        /// <returns></returns>
        public static RSAKey GetRASKey()
        {
            RSACryptoServiceProvider.UseMachineKeyStore = true;
            //声明一个指定大小的RSA容器
            RSACryptoServiceProvider rsaProvider = new RSACryptoServiceProvider(DWKEYSIZE);

            //取得RSA容易里的各种参数,根据参数生成公钥和私钥。参数列表
            //public byte[] D; 	d,私钥指数
            //public byte[] DP; d mod (p - 1) mod函数是一个求余函数 因为7 除以 3 商2余1,余数1即MOD运算后的结果。
            //public byte[] DQ; d mod (q - 1)
            //public byte[] Exponent; e,公钥指数
            //public byte[] InverseQ; (InverseQ)(q) = 1 mod p
            //public byte[] Modulus; P*Q
            //public byte[] P;  第一个质数
            //public byte[] Q;  第二个质数

            RSAParameters p = rsaProvider.ExportParameters(true);

            return new RSAKey()
            {
                PublicKey = ComponentKey(p.Exponent, p.Modulus),
                PrivateKey = ComponentKey(p.D, p.Modulus)
            };
        }
Esempio n. 28
0
        public static String ToXmlString(RSACryptoServiceProvider rsa, bool includePrivateParameters)
        {
            // we extend appropriately for private components
            RSAParameters rsaParams = rsa.ExportParameters(includePrivateParameters);
            StringBuilder sb        = new StringBuilder();

            sb.Append("<RSAKeyValue>");
            // Add the modulus
            sb.Append("<Modulus>" + Convert.ToBase64String(rsaParams.Modulus) + "</Modulus>");
            // Add the exponent
            sb.Append("<Exponent>" + Convert.ToBase64String(rsaParams.Exponent) + "</Exponent>");
            if (includePrivateParameters)
            {
                // Add the private components
                sb.Append("<P>" + Convert.ToBase64String(rsaParams.P) + "</P>");
                sb.Append("<Q>" + Convert.ToBase64String(rsaParams.Q) + "</Q>");
                sb.Append("<DP>" + Convert.ToBase64String(rsaParams.DP) + "</DP>");
                sb.Append("<DQ>" + Convert.ToBase64String(rsaParams.DQ) + "</DQ>");
                sb.Append("<InverseQ>" + Convert.ToBase64String(rsaParams.InverseQ) + "</InverseQ>");
                sb.Append("<D>" + Convert.ToBase64String(rsaParams.D) + "</D>");
            }
            sb.Append("</RSAKeyValue>");
            return(sb.ToString());
        }
Esempio n. 29
0
        public static void ExportPrivateKey(RSACryptoServiceProvider rsa, string kId, string outputPath, byte[] password, byte[] salt)
        {
            var          rsaParams = rsa.ExportParameters(true);
            var          ms        = new MemoryStream();
            BinaryWriter w         = new BinaryWriter(ms);

            w.WriteLengthPrefixedBuffer(rsaParams.D);
            w.WriteLengthPrefixedBuffer(rsaParams.DP);
            w.WriteLengthPrefixedBuffer(rsaParams.DQ);
            w.WriteLengthPrefixedBuffer(rsaParams.Exponent);
            w.WriteLengthPrefixedBuffer(rsaParams.InverseQ);
            w.WriteLengthPrefixedBuffer(rsaParams.Modulus);
            w.WriteLengthPrefixedBuffer(rsaParams.P);
            w.WriteLengthPrefixedBuffer(rsaParams.Q);
            w.Flush();

            var aes = Aes.Create();

            aes.Key = password;
            aes.GenerateIV();
            aes.Mode    = CipherMode.CBC;
            aes.Padding = PaddingMode.PKCS7;

            var transform = aes.CreateEncryptor();
            var encrypted = new MemoryStream();

            encrypted.Write(aes.IV, 0, (int)aes.IV.Length);
            using (CryptoStream stream = new CryptoStream(encrypted, transform, CryptoStreamMode.Write))
            {
                stream.Write(ms.ToArray(), 0, (int)ms.Length);
                stream.FlushFinalBlock();
            }

            File.WriteAllText(Path.Combine(outputPath, kId + ".key.private"),
                              Convert.ToBase64String(salt) + "." + Convert.ToBase64String(encrypted.ToArray()));
        }
Esempio n. 30
0
        private void button_Code_Click(object sender, EventArgs e)
        {
            RSACryptoServiceProvider RSA1 = new RSACryptoServiceProvider();


            string message = textBox_ToCode.Text;

            char[] dataASCII = message.ToCharArray(0, message.Length);
            int    i         = 0;

            byte[] data = new byte[message.Length];

            foreach (var item in dataASCII)
            {
                data[i] = Convert.ToByte((int)item);
                i++;
            }

            byte[] EncryptedASCII = RSA1.Encrypt(data, true);             // szyfrowanie kodu ASCII
            i = 0;
            char[] encrypted = new char[EncryptedASCII.Length];
            foreach (var item in EncryptedASCII)
            {
                encrypted[i] = (char)item;
                //encrypted[i] = (char)(item+3);  // dodatkowe działanie + szyfr cezara
                i++;
            }
            string enMessage = string.Join("", encrypted);

            textBox_Coded.Text = enMessage;

            MyParameters = RSA1.ExportParameters(true);

            textBox_e.Text = "e = " + BitConverter.ToString(MyParameters.Exponent, 0);
            textBox_p.Text = "n = " + BitConverter.ToString(MyParameters.Modulus, 0);
        }
Esempio n. 31
0
        // Uncomment the following 2 lines and run API to generate your encryption codes.
        // Copy and past output to your Web.config file

        //[WebMethod] public void generate_1024_Key() {streamJson(getEncryptedString(1024));}
        //[WebMethod] public void generate_2048_Key() {streamJson(getEncryptedString(2048));}

        private string getEncryptedString(int EncryptionPadding)
        {
            var    csp = new RSACryptoServiceProvider(EncryptionPadding);
            var    key = csp.ExportParameters(true);
            string KeyString;

            {
                var sw = new System.IO.StringWriter();
                var xs = new System.Xml.Serialization.XmlSerializer(typeof(RSAParameters));
                xs.Serialize(sw, key);
                KeyString = sw.ToString();
            }
            return(string.Format("&lt;RSAKeyValue&gt;&lt;Exponent&gt;{0}&lt;/Exponent&gt;&lt;Modulus&gt;{1}&lt;/Modulus&gt;&lt;P&gt;{2}&lt;/P&gt;&lt;Q&gt;{3}&lt;/Q&gt;&lt;DP&gt;{4}&lt;/DP&gt;&lt;DQ&gt;{5}&lt;/DQ&gt;&lt;InverseQ&gt;{6}&lt;/InverseQ&gt;&lt;D&gt;{7}&lt;/D&gt;&lt;/RSAKeyValue&gt;",
                                 Convert.ToBase64String(key.Exponent),
                                 Convert.ToBase64String(key.Modulus),
                                 Convert.ToBase64String(key.P),
                                 Convert.ToBase64String(key.Q),
                                 Convert.ToBase64String(key.DP),
                                 Convert.ToBase64String(key.DQ),
                                 Convert.ToBase64String(key.InverseQ),
                                 Convert.ToBase64String(key.D)
                                 )
                   );
        }
        internal static bool GetKey(bool isServer, out RSAParameters CSPRSAPARAM)
        {
            CSPRSAPARAM = default(RSAParameters);
            RSACryptoServiceProvider rsaCrypt = null;
            bool result;

            try
            {
                string _rsaKey = ConfigurationSettings.AppSettings["RSAKey"].ToString();
                if (_rsaKey != string.Empty)
                {
                    rsaCrypt = new RSACryptoServiceProvider();
                    rsaCrypt.FromXmlString(_rsaKey.Replace("(", "<").Replace(")", ">"));
                    CSPRSAPARAM = rsaCrypt.ExportParameters(isServer);
                    result      = true;
                }
                else
                {
                    result = false;
                }
            }
            catch (Exception ex)
            {
                string _msg = ex.ToString();
                result = false;
            }
            finally
            {
                if (rsaCrypt != null)
                {
                    rsaCrypt.Clear();
                }
                rsaCrypt = null;
            }
            return(result);
        }
Esempio n. 33
0
        public static void Run()
        {
            var importedKey = PEM.Read(@"resources\example.org.key", "RSA PRIVATE KEY");

            Console.WriteLine("Imported key length: {0}", importedKey.Length);

            using var rsa = new RSACryptoServiceProvider();
            rsa.ImportRSAPrivateKey(importedKey, out _);

            var parameters       = rsa.ExportParameters(true);
            var parametersLength = parameters.D.Length +
                                   parameters.DP.Length +
                                   parameters.DQ.Length +
                                   parameters.Exponent.Length +
                                   parameters.InverseQ.Length +
                                   parameters.Modulus.Length +
                                   parameters.P.Length +
                                   parameters.Q.Length;

            Console.WriteLine();
            Console.WriteLine("Parameters length: {0}", parametersLength);
            Console.WriteLine("Modulus: {0} ({1})", parameters.Modulus.Length, importedKey.IndexOf(parameters.Modulus));
            Console.WriteLine("Exponent: {0} ({1})", parameters.Exponent.Length, importedKey.IndexOf(parameters.Exponent));
            Console.WriteLine("D: {0} ({1})", parameters.D.Length, importedKey.IndexOf(parameters.D));
            Console.WriteLine("P: {0} ({1})", parameters.P.Length, importedKey.IndexOf(parameters.P));
            Console.WriteLine("Q: {0} ({1})", parameters.Q.Length, importedKey.IndexOf(parameters.Q));
            Console.WriteLine("DP: {0} ({1})", parameters.DP.Length, importedKey.IndexOf(parameters.DP));
            Console.WriteLine("DQ: {0} ({1})", parameters.DQ.Length, importedKey.IndexOf(parameters.DQ));
            Console.WriteLine("InverseQ: {0} ({1})", parameters.InverseQ.Length, importedKey.IndexOf(parameters.InverseQ));

            var exportedKey = rsa.ExportRSAPrivateKey();

            Console.WriteLine();
            Console.WriteLine("Exported key length: {0}", exportedKey.Length);
            Console.WriteLine("Matches exported key: {0}", importedKey.IndexOf(exportedKey) == 0);
        }
Esempio n. 34
0
        public string Encrypt(string strData)
        {
            var byteData = Encoding.UTF8.GetBytes(strData);

            using (var rsa = new RSACryptoServiceProvider(1024))
            {
                try
                {
                    var rsaParameters = rsa.ExportParameters(false);

                    rsa.FromXmlString(publicKey);

                    var encryptedData = rsa.Encrypt(byteData, false);

                    var base64Encrypted = Convert.ToBase64String(encryptedData);

                    return(base64Encrypted);
                }
                finally
                {
                    rsa.PersistKeyInCsp = false;
                }
            }
        }
Esempio n. 35
0
        public RSACryptoServiceProvider CreateKey()
        {
            RSACryptoServiceProvider rsa = null;

            if (!File.Exists(_keyFile))
            {
                Trace.Info("Creating new RSA key using 2048-bit key length");

                rsa = new RSACryptoServiceProvider(2048);

                // Now write the parameters to disk
                SaveParameters(rsa.ExportParameters(true));
                Trace.Info("Successfully saved RSA key parameters to file {0}", _keyFile);
            }
            else
            {
                Trace.Info("Found existing RSA key parameters file {0}", _keyFile);

                rsa = new RSACryptoServiceProvider();
                rsa.ImportParameters(LoadParameters());
            }

            return(rsa);
        }
Esempio n. 36
0
        /// <summary>
        /// 创建加密钥,解密钥
        /// </summary>
        public void CreateRSAKey()
        {
            RSACryptoServiceProvider rsa  = new RSACryptoServiceProvider();
            RSAParameters            keys = rsa.ExportParameters(true);

            //公钥
            String pkxml = "<root>\n<Modulus>" + ToHexString(keys.Modulus) + "</Modulus>";

            pkxml += "\n<Exponent>" + ToHexString(keys.Exponent) + "</Exponent>\n</root>";

            //私钥
            String psxml = "<root>\n<Modulus>" + ToHexString(keys.Modulus) + "</Modulus>";

            psxml += "\n<Exponent>" + ToHexString(keys.Exponent) + "</Exponent>";
            psxml += "\n<D>" + ToHexString(keys.D) + "</D>";
            psxml += "\n<DP>" + ToHexString(keys.DP) + "</DP>";
            psxml += "\n<P>" + ToHexString(keys.P) + "</P>";
            psxml += "\n<Q>" + ToHexString(keys.Q) + "</Q>";
            psxml += "\n<DQ>" + ToHexString(keys.DQ) + "</DQ>";
            psxml += "\n<InverseQ>" + ToHexString(keys.InverseQ) + "</InverseQ>\n</root>";

            SaveToFile("publickey.xml", pkxml);
            SaveToFile("privatekey.xml", psxml);
        }
Esempio n. 37
0
        public UserInformation Login(string username, string password, out UserDatabase data)
        {
            UserDatabase dataComp = new UserDatabase(this.userDatabasePath);

            var user = dataComp.GetUser(username);

            if (user != null && user.IsPasswordValid(password))
            {
                var userCert = new X509Certificate2(user.PublicCertificate);

                if (userCert == null)
                {
                    throw new Exception("Certificate error.");
                }

                if (CertificateValidator.VerifyCertificate(userCert) == false)
                {
                    throw new Exception("Certificate is invalid.");
                }

                byte[] keyRaw            = File.ReadAllBytes(this.privateKeyPath);
                var    privateParameters = new KeyFileParser(keyRaw).GetParameters();
                RSACryptoServiceProvider publicKeyProvider = (RSACryptoServiceProvider)userCert.PublicKey.Key;
                if (!RsaMachine.AreKeysMatched(publicKeyProvider.ExportParameters(false), privateParameters))
                {
                    throw new Exception("The given private key does not match this user's certificate.");
                }

                data = dataComp;
                return(new UserInformation(user, privateParameters));
            }
            else
            {
                throw new Exception("Invalid username or password.");
            }
        }
Esempio n. 38
0
        private string GenerateToken(Person p)
        {
            IIdentity identity = new ClaimsIdentity("local");
            var       user     = new ClaimsIdentity(identity);

            user.AddClaim(new Claim("role", "admin"));
            user.AddClaim(new Claim("role", "user"));

            var rsa = new RSACryptoServiceProvider(2048);
            var key = new RsaSecurityKey(rsa.ExportParameters(true));
            var signingCredentials          = new SigningCredentials(key, SecurityAlgorithms.RsaSha256Signature);
            JwtSecurityTokenHandler handler = new JwtSecurityTokenHandler();
            var tokenDescriptor             = new SecurityTokenDescriptor()
            {
                Issuer             = "http://localhost:5000",
                Audience           = "api",
                SigningCredentials = signingCredentials,
                Subject            = user
            };
            var securityToken = handler.CreateJwtSecurityToken(tokenDescriptor);
            var token         = handler.WriteToken(securityToken);

            return(token);
        }
Esempio n. 39
0
        public RsaData(int keySize = 2048)
        {
            RSACryptoServiceProvider.UseMachineKeyStore = false;

            var rsaProvider = new RSACryptoServiceProvider(keySize);

            rsaProvider.PersistKeyInCsp = false;

            // Execution time depends on the keySize
            RsaParams = rsaProvider.ExportParameters(true);

            // Let's use little-endian
            RsaParams.D        = RsaParams.D.Reverse().ToArray();
            RsaParams.DP       = RsaParams.DP.Reverse().ToArray();
            RsaParams.DQ       = RsaParams.DQ.Reverse().ToArray();
            RsaParams.Exponent = RsaParams.Exponent.Reverse().ToArray();
            RsaParams.InverseQ = RsaParams.InverseQ.Reverse().ToArray();
            RsaParams.Modulus  = RsaParams.Modulus.Reverse().ToArray();
            RsaParams.P        = RsaParams.P.Reverse().ToArray();
            RsaParams.Q        = RsaParams.Q.Reverse().ToArray();

            // We just need it for rsa data generation
            rsaProvider = null;
        }
Esempio n. 40
0
 public static RSAParameters ToPublicRsaParameters(this RSAParameters privateKey)
 {
     using (var rsa = new RSACryptoServiceProvider())
     {
         rsa.ImportParameters(privateKey);
         return rsa.ExportParameters(includePrivateParameters: false);
     }
 }
Esempio n. 41
0
    /// <summary>
    /// 得到RSA的解谜的密匙对
    /// </summary>
    /// <returns></returns>
    public static RSAKey GetRASKey()
    {
        RSACryptoServiceProvider.UseMachineKeyStore = true;
        //声明一个指定大小的RSA容器
        RSACryptoServiceProvider rsaProvider = new RSACryptoServiceProvider(DWKEYSIZE);
        //取得RSA容易里的各种参数
        RSAParameters p = rsaProvider.ExportParameters(true);

        return new RSAKey()
        {
            PrivateKey = ToBase64Key(rsaProvider.ToXmlString(true)),
            PublicKey = ToBase64Key(rsaProvider.ToXmlString(false)),
            PublicKeyExponent = BytesToHexString(p.Exponent),
            PublicKeyModulus = BytesToHexString(p.Modulus)
        };
    }
        public static void NonExportable_Ephemeral()
        {
            CspParameters cspParameters = new CspParameters
            {
                Flags = CspProviderFlags.UseNonExportableKey,
            };

            using (var rsa = new RSACryptoServiceProvider(cspParameters))
            {
                // Ephemeral keys don't successfully request the exportable bit.
                Assert.ThrowsAny<CryptographicException>(() => rsa.CspKeyContainerInfo.Exportable);

                Assert.Throws<CryptographicException>(() => rsa.ExportCspBlob(true));
                Assert.Throws<CryptographicException>(() => rsa.ExportParameters(true));
            }
        }
Esempio n. 43
0
 /// <summary>
 /// Generates a new set of keys
 /// </summary>
 /// <returns></returns>
 public static RSAParameters CreateKeys()
 {
     CspParameters xCSP = new CspParameters();
     RSACryptoServiceProvider xRSA = new RSACryptoServiceProvider(xCSP);
     return xRSA.ExportParameters(true);
 }
Esempio n. 44
0
        public static void ImportReset()
        {
            using (RSA rsa = new RSACryptoServiceProvider())
            {
                RSAParameters exported = rsa.ExportParameters(true);
                RSAParameters imported;

                // Ensure that we cause the KeySize value to change.
                if (rsa.KeySize == 1024)
                {
                    imported = TestData.RSA2048Params;
                }
                else
                {
                    imported = TestData.RSA1024Params;
                }

                Assert.NotEqual(imported.Modulus.Length * 8, rsa.KeySize);
                Assert.NotEqual(imported.Modulus, exported.Modulus);

                rsa.ImportParameters(imported);

                Assert.Equal(imported.Modulus.Length * 8, rsa.KeySize);

                exported = rsa.ExportParameters(true);
                AssertKeyEquals(ref imported, ref exported);
            }
        }
Esempio n. 45
0
File: test.cs Progetto: mono/gert
	public static void ThreadLoad ()
	{
		RSA rsa = new RSACryptoServiceProvider (384);
		rsa.ExportParameters (false);
	}
Esempio n. 46
0
    private static void RSATest()
    {
        var publicPrivateRsa = new RSACryptoServiceProvider
            (
                new CspParameters()
                {
                    KeyContainerName = "PublicPrivateKeys",
                    Flags = CspProviderFlags.UseMachineKeyStore
                    //Flags = CspProviderFlags.UseDefaultKeyContainer
                }
            )
        {
            PersistKeyInCsp = true,
        };

        var publicRsa = new RSACryptoServiceProvider(
                new CspParameters()
                {
                    KeyContainerName = "PublicKey",
                    Flags = CspProviderFlags.UseMachineKeyStore
                    //Flags = CspProviderFlags.UseDefaultKeyContainer
                }
            )
        {
            PersistKeyInCsp = true
        };

        //Export the key.
        publicRsa.ImportParameters(publicPrivateRsa.ExportParameters(false));
        Console.WriteLine(publicRsa.ToXmlString(false));
        Console.WriteLine(publicPrivateRsa.ToXmlString(false));
        //Dispose those two CSPs.
        using (publicRsa)
        {
            publicRsa.Clear();
        }
        using (publicPrivateRsa)
        {
            publicRsa.Clear();
        }

        //Retrieve keys
        publicPrivateRsa = new RSACryptoServiceProvider(
                new CspParameters()
                {
                    KeyContainerName = "PublicPrivateKeys",
                    Flags = CspProviderFlags.UseMachineKeyStore
                    //Flags = CspProviderFlags.UseDefaultKeyContainer
                }
            );

        publicRsa = new RSACryptoServiceProvider(
                new CspParameters()
                {
                    KeyContainerName = "PublicKey",
                    Flags = CspProviderFlags.UseMachineKeyStore
                    //Flags = CspProviderFlags.UseDefaultKeyContainer
                }
            );
        Console.WriteLine(publicRsa.ToXmlString(false));
        Console.WriteLine(publicPrivateRsa.ToXmlString(false));
        using (publicRsa)
        {
            publicRsa.Clear();
        }
        using (publicPrivateRsa)
        {
            publicRsa.Clear();
        }
    }
Esempio n. 47
0
    private void RequestSecureConnection()
    {
        if (!_connected) return;

        _rsa = new RSACryptoServiceProvider(1024);
        RSAParameters keyInfo = _rsa.ExportParameters(false);
        byte[] data = PackageFactory.Pack(PackageType.RequestSecureConnection, new SecurityRequestData(keyInfo.Exponent, keyInfo.Modulus));
        BeginSend(data);
    }
Esempio n. 48
0
    /*	static void Main()
    {
        try
        {
            //Create a UnicodeEncoder to convert between byte array and string.
            UnicodeEncoding ByteConverter = new UnicodeEncoding();

            //Create byte arrays to hold original, encrypted, and decrypted data.
            byte[] dataToEncrypt = ByteConverter.GetBytes("Data to Encrypt");
            byte[] encryptedData;
            byte[] decryptedData;

            //Create a new instance of RSACryptoServiceProvider to generate
            //public and private key data.
            RSACryptoServiceProvider RSA = new RSACryptoServiceProvider();

            //Pass the data to ENCRYPT, the public key information
            //(using RSACryptoServiceProvider.ExportParameters(false),
            //and a boolean flag specifying no OAEP padding.
            encryptedData = RSAEncrypt(dataToEncrypt,RSA.ExportParameters(false), false);

            //Pass the data to DECRYPT, the private key information
            //(using RSACryptoServiceProvider.ExportParameters(true),
            //and a boolean flag specifying no OAEP padding.
            decryptedData = RSADecrypt(encryptedData,RSA.ExportParameters(true), false);

            //Display the decrypted plaintext to the console.
            Console.WriteLine("Decrypted plaintext: {0}", ByteConverter.GetString(decryptedData));
        }
        catch(ArgumentNullException)
        {
            //Catch this exception in case the encryption did
            //not succeed.
            Console.WriteLine("Encryption failed.");

        }
    }
    */
    public void RSAcreatekeys(int size)
    {
        //Generate a public/private key pair.
        RSACryptoServiceProvider RSA = new RSACryptoServiceProvider(size);
        rsaks = size;

        //Save the public key information to an RSAParameters structure.
        rsaki = RSA.ExportParameters(true);
    }
Esempio n. 49
0
        public static void UnusualExponentImportExport()
        {
            // Most choices for the Exponent value in an RSA key use a Fermat prime.
            // Since a Fermat prime is 2^(2^m) + 1, it always only has two bits set, and
            // frequently has the form { 0x01, [some number of 0x00s], 0x01 }, which has the same
            // representation in both big- and little-endian.
            //
            // The only real requirement for an Exponent value is that it be coprime to (p-1)(q-1).
            // So here we'll use the (non-Fermat) prime value 433 (0x01B1) to ensure big-endian export.
            RSAParameters unusualExponentParameters = TestData.UnusualExponentParameters;
            RSAParameters exported;

            using (RSA rsa = new RSACryptoServiceProvider())
            {
                rsa.ImportParameters(unusualExponentParameters);
                exported = rsa.ExportParameters(true);
            }

            // Exponent is the most likely to fail, the rest just otherwise ensure that Export
            // isn't losing data.
            AssertKeyEquals(ref unusualExponentParameters, ref exported);
        }
        public static void NonExportable_Persisted()
        {
            CspParameters cspParameters = new CspParameters
            {
                KeyContainerName = Guid.NewGuid().ToString(),
                Flags = CspProviderFlags.UseNonExportableKey,
            };

            using (new RsaKeyLifetime(cspParameters))
            {
                using (var rsa = new RSACryptoServiceProvider(cspParameters))
                {
                    Assert.False(rsa.CspKeyContainerInfo.Exportable, "rsa.CspKeyContainerInfo.Exportable");

                    Assert.Throws<CryptographicException>(() => rsa.ExportCspBlob(true));
                    Assert.Throws<CryptographicException>(() => rsa.ExportParameters(true));
                }
            }
        }
Esempio n. 51
0
 public static RSAParameters CreatePrivateKeyParams(RsaKeyLengths rsaKeyLength = RsaKeyLengths.Bit2048)
 {
     using (var rsa = new RSACryptoServiceProvider((int)rsaKeyLength))
     {
         return rsa.ExportParameters(includePrivateParameters: true);
     }
 }
Esempio n. 52
0
        public static void MultiExport()
        {
            RSAParameters imported = TestData.RSA1024Params;

            using (RSA rsa = new RSACryptoServiceProvider())
            {
                rsa.ImportParameters(imported);

                RSAParameters exportedPrivate = rsa.ExportParameters(true);
                RSAParameters exportedPrivate2 = rsa.ExportParameters(true);
                RSAParameters exportedPublic = rsa.ExportParameters(false);
                RSAParameters exportedPublic2 = rsa.ExportParameters(false);
                RSAParameters exportedPrivate3 = rsa.ExportParameters(true);
                RSAParameters exportedPublic3 = rsa.ExportParameters(false);

                AssertKeyEquals(ref imported, ref exportedPrivate);

                Assert.Equal(imported.Modulus, exportedPublic.Modulus);
                Assert.Equal(imported.Exponent, exportedPublic.Exponent);
                Assert.Null(exportedPublic.D);
                ValidateParameters(ref exportedPublic);

                AssertKeyEquals(ref exportedPrivate, ref exportedPrivate2);
                AssertKeyEquals(ref exportedPrivate, ref exportedPrivate3);

                AssertKeyEquals(ref exportedPublic, ref exportedPublic2);
                AssertKeyEquals(ref exportedPublic, ref exportedPublic3);
            }
        }
Esempio n. 53
0
		/// <summary>
		/// Enroll the authenticator with the server
		/// </summary>
		public bool Enroll(EnrollState state)
		{
			// clear error
			state.Error = null;

			try
			{
				var data = new NameValueCollection();
				var cookies = state.Cookies = state.Cookies ?? new CookieContainer();
				string response;

				if (string.IsNullOrEmpty(state.OAuthToken) == true)
				{
					// get session
					response = Request(COMMUNITY_BASE + "/login/home?goto=0", "GET", null, cookies);

					// get the user's RSA key
					data.Add("username", state.Username);
					response = Request(COMMUNITY_BASE + "/login/getrsakey", "POST", data, cookies);
					var rsaresponse = JObject.Parse(response);
					if (rsaresponse.SelectToken("success").Value<bool>() != true)
					{
						throw new InvalidEnrollResponseException("Cannot get steam information for user: "******"steamid").Value<string>();

					// encrypt password with RSA key
					RNGCryptoServiceProvider random = new RNGCryptoServiceProvider();
					byte[] encryptedPassword;
					using (var rsa = new RSACryptoServiceProvider())
					{
						var passwordBytes = Encoding.ASCII.GetBytes(state.Password);
						var p = rsa.ExportParameters(false);
						p.Exponent = Authenticator.StringToByteArray(rsaresponse.SelectToken("publickey_exp").Value<string>());
						p.Modulus = Authenticator.StringToByteArray(rsaresponse.SelectToken("publickey_mod").Value<string>());
						rsa.ImportParameters(p);
						encryptedPassword = rsa.Encrypt(passwordBytes, false);
					}

					// login request
					data = new NameValueCollection();
					data.Add("password", Convert.ToBase64String(encryptedPassword));
					data.Add("username", state.Username);
					data.Add("twofactorcode", "");
					data.Add("emailauth", (state.EmailAuthText != null ? state.EmailAuthText : string.Empty));
					data.Add("loginfriendlyname", "#login_emailauth_friendlyname_mobile");
					data.Add("captchagid", (state.CaptchaId != null ? state.CaptchaId : "-1"));
					data.Add("captcha_text", (state.CaptchaText != null ? state.CaptchaText : "enter above characters"));
					data.Add("emailsteamid", (state.EmailAuthText != null ? state.SteamId : string.Empty));
					data.Add("rsatimestamp", rsaresponse.SelectToken("timestamp").Value<string>());
					data.Add("remember_login", "false");
					data.Add("oauth_client_id", "DE45CD61");
					data.Add("oauth_scope", "read_profile write_profile read_client write_client");
					data.Add("donotache", new DateTime().ToUniversalTime().Subtract(new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).TotalMilliseconds.ToString());
					response = Request(COMMUNITY_BASE + "/mobilelogin/dologin/", "POST", data, cookies);
					Dictionary<string, object> loginresponse = JsonConvert.DeserializeObject<Dictionary<string, object>>(response);

					// require captcha
					if (loginresponse.ContainsKey("captcha_needed") == true && (bool)loginresponse["captcha_needed"] == true)
					{
						state.RequiresCaptcha = true;
						state.CaptchaId = (string)loginresponse["captcha_gid"];
						state.CaptchaUrl = COMMUNITY_BASE + "/public/captcha.php?gid=" + state.CaptchaId;
					}
					else
					{
						state.RequiresCaptcha = false;
						state.CaptchaId = null;
						state.CaptchaUrl = null;
						state.CaptchaText = null;
					}

					// require email auth
					if (loginresponse.ContainsKey("emailauth_needed") == true && (bool)loginresponse["emailauth_needed"] == true)
					{
						if (loginresponse.ContainsKey("emaildomain") == true)
						{
							var emaildomain = (string)loginresponse["emaildomain"];
							if (string.IsNullOrEmpty(emaildomain) == false)
							{
								state.EmailDomain = emaildomain;
							}
						}
						state.RequiresEmailAuth = true;
					}
					else
					{
						state.EmailDomain = null;
						state.RequiresEmailAuth = false;
					}

					// require email auth
					if (loginresponse.ContainsKey("requires_twofactor") == true && (bool)loginresponse["requires_twofactor"] == true)
					{
						state.Requires2FA = true;
					}
					else
					{
						state.Requires2FA = false;
					}

					// if we didn't login, return the result
					if (loginresponse.ContainsKey("login_complete") == false || (bool)loginresponse["login_complete"] == false || loginresponse.ContainsKey("oauth") == false)
					{
						if (loginresponse.ContainsKey("oauth") == false)
						{
							state.Error = "No OAuth token in response";
						}
						if (loginresponse.ContainsKey("message") == true)
						{
							state.Error = (string)loginresponse["message"];
						}
						return false;
					}

					// get the OAuth token - is stringified json
					string oauth = (string)loginresponse["oauth"];
					var oauthjson = JObject.Parse(oauth);
					state.OAuthToken = oauthjson.SelectToken("oauth_token").Value<string>();
				}

				// login to webapi
				data.Clear();
				data.Add("access_token", state.OAuthToken);
				response = Request(WEBAPI_BASE + "/ISteamWebUserPresenceOAuth/Logon/v0001", "POST", data);

				if (state.RequiresActivation == false)
				{
					// add a new authenticator
					data.Clear();
					string deviceId = BuildRandomId();
					data.Add("access_token", state.OAuthToken);
					data.Add("steamid", state.SteamId);
					data.Add("authenticator_type", "1");
					data.Add("device_identifier", deviceId);
					response = Request(WEBAPI_BASE + "/ITwoFactorService/AddAuthenticator/v0001", "POST", data);
					var tfaresponse = JObject.Parse(response);
					if (response.IndexOf("revocation_code") == -1)
					{
						// invalid response
						state.OAuthToken = null; // force new login
						state.RequiresLogin = true;
						state.Cookies = null;
						state.Error = "Invalid response from Steam: " + response;
						return false;
					}
					
					// save data into this authenticator
					var secret = tfaresponse.SelectToken("response.shared_secret").Value<string>();
					this.SecretKey = Convert.FromBase64String(secret);
					this.Serial = tfaresponse.SelectToken("response.serial_number").Value<string>();
					this.DeviceId = deviceId;
					this.RevocationCode = state.RevocationCode = tfaresponse.SelectToken("response.revocation_code").Value<string>();

					// calculate server drift
					long servertime = tfaresponse.SelectToken("response.server_time").Value<long>() * 1000;
					ServerTimeDiff = servertime - CurrentTime;
					LastServerTime = DateTime.Now.Ticks;

					// send authorisation email
					data.Clear();
					data.Add("access_token", state.OAuthToken);
					data.Add("steamid", state.SteamId);
					data.Add("email_type", "1");
					data.Add("include_activation", "1");
					response = Request(WEBAPI_BASE + "/ITwoFactorService/SendEmail/v0001", "POST", data);

					state.RequiresActivation = true;

					return false;
				}

				// finalize adding the authenticator
				data.Clear();
				data.Add("access_token", state.OAuthToken);
				data.Add("steamid", state.SteamId);
				data.Add("activation_code", state.ActivationCode);

				// try and authorise
				ServerTimeDiff -= 40000; // start at previous interval
				var retries = 0;
				while (state.RequiresActivation == true && retries < ENROLL_ACTIVATE_RETRIES)
				{
					data.Add("authenticator_code", this.CalculateCode(false));
					data.Add("authenticator_time", this.ServerTime.ToString());
					response = Request(WEBAPI_BASE + "/ITwoFactorService/FinalizeAddAuthenticator/v0001", "POST", data);
					var finalizeresponse = JObject.Parse(response);
					if (response.IndexOf("status") != -1 && finalizeresponse.SelectToken("response.status").Value<int>() == INVALID_ACTIVATION_CODE)
					{
						state.Error = "Invalid activation code";
						return false;
					}

					// reset our time
					if (response.IndexOf("server_time") != -1)
					{
						long servertime = finalizeresponse.SelectToken("response.server_time").Value<long>() * 1000;
						ServerTimeDiff = servertime - CurrentTime;
						LastServerTime = DateTime.Now.Ticks;
					}

					// check success
					if (finalizeresponse.SelectToken("response.success").Value<bool>() == true)
					{
						if (response.IndexOf("want_more") != -1 && finalizeresponse.SelectToken("response.want_more").Value<bool>() == true)
						{
							ServerTimeDiff += 30000L;
							retries++;
							continue;
						}
						state.RequiresActivation = false;
						break;
					}

					ServerTimeDiff += 30000L;
					retries++;
				}
				if (state.RequiresActivation == true)
				{
					state.Error = "There was a problem activating. There might be an issue with the Steam servers. Please try again later.";
					return false;
				}

				// mark and successful and return key
				state.Success = true;
				state.SecretKey = Authenticator.ByteArrayToString(this.SecretKey);

				// send confirmation email
				data.Clear();
				data.Add("access_token", state.OAuthToken);
				data.Add("steamid", state.SteamId);
				data.Add("email_type", "2");
				response = Request(WEBAPI_BASE + "/ITwoFactorService/SendEmail/v0001", "POST", data);

				return true;
			}
			catch (InvalidRequestException ex)
			{
				throw new InvalidEnrollResponseException("Error enrolling new authenticator", ex);
			}
		}
Esempio n. 54
0
        public static void PublicOnlyPrivateExport()
        {
            RSAParameters imported = new RSAParameters
            {
                Modulus = TestData.RSA1024Params.Modulus,
                Exponent = TestData.RSA1024Params.Exponent,
            };

            using (RSA rsa = new RSACryptoServiceProvider())
            {
                rsa.ImportParameters(imported);
                Assert.Throws<CryptographicException>(() => rsa.ExportParameters(true));
            }
        }
Esempio n. 55
0
        public static void RSAParametersToBlob_PublicPrivate()
        {
            byte[] blob;

            using (var rsa = new RSACryptoServiceProvider())
            {
                rsa.ImportParameters(TestData.RSA1024Params);
                blob = rsa.ExportCspBlob(true);
            }

            RSAParameters exported;

            using (var rsa = new RSACryptoServiceProvider())
            {
                rsa.ImportCspBlob(blob);

                Assert.False(rsa.PublicOnly);

                exported = rsa.ExportParameters(true);
            }

            RSAParameters expected = TestData.RSA1024Params;

            ImportExport.AssertKeyEquals(ref expected, ref exported);
        }
        public static bool VerifyLicenseKeyText(this string licenseKeyText, out LicenseKey key)
        {
            var publicRsaProvider = new RSACryptoServiceProvider();
            publicRsaProvider.FromXmlString(LicensePublicKey);
            var publicKeyParams = publicRsaProvider.ExportParameters(false);

            key = licenseKeyText.ToLicenseKey();
            var originalData = key.GetHashKeyToSign().ToUtf8Bytes();
            var signedData = Convert.FromBase64String(key.Hash);

            return VerifySignedHash(originalData, signedData, publicKeyParams);
        }
Esempio n. 57
0
        public static void RSAParametersToBlob_PublicOnly()
        {
            byte[] blob;

            using (var rsa = new RSACryptoServiceProvider())
            {
                rsa.ImportParameters(TestData.RSA1024Params);
                blob = rsa.ExportCspBlob(false);
            }

            RSAParameters exported;

            using (var rsa = new RSACryptoServiceProvider())
            {
                rsa.ImportCspBlob(blob);

                Assert.True(rsa.PublicOnly);

                exported = rsa.ExportParameters(false);
            }

            RSAParameters expected = new RSAParameters
            {
                Modulus = TestData.RSA1024Params.Modulus,
                Exponent = TestData.RSA1024Params.Exponent,
            };

            ImportExport.AssertKeyEquals(ref expected, ref exported);
        }
Esempio n. 58
0
		/// <summary>
		/// Enroll the authenticator with the server
		/// </summary>
		public bool Enroll(EnrollState state)
		{
			// clear error
			state.Error = null;

			try
			{
				var data = new NameValueCollection();
				var cookies = state.Cookies = state.Cookies ?? new CookieContainer();
				string response;

				if (string.IsNullOrEmpty(state.OAuthToken) == true)
				{
					// get session
					if (cookies.Count == 0)
					{
						cookies.Add(new Cookie("mobileClientVersion", "3067969+%282.1.3%29", "/", ".steamcommunity.com"));
						cookies.Add(new Cookie("mobileClient", "android", "/", ".steamcommunity.com"));
						cookies.Add(new Cookie("steamid", "", "/", ".steamcommunity.com"));
						cookies.Add(new Cookie("steamLogin", "", "/", ".steamcommunity.com"));
						cookies.Add(new Cookie("Steam_Language", "english", "/", ".steamcommunity.com"));
						cookies.Add(new Cookie("dob", "", "/", ".steamcommunity.com"));

						NameValueCollection headers = new NameValueCollection();
						headers.Add("X-Requested-With", "com.valvesoftware.android.steam.community");

						response = Request("https://steamcommunity.com/login?oauth_client_id=DE45CD61&oauth_scope=read_profile%20write_profile%20read_client%20write_client", "GET", null, cookies, headers);
					}

					// get the user's RSA key
					data.Add("username", state.Username);
					response = Request(COMMUNITY_BASE + "/login/getrsakey", "POST", data, cookies);
					var rsaresponse = JObject.Parse(response);
					if (rsaresponse.SelectToken("success").Value<bool>() != true)
					{
						throw new InvalidEnrollResponseException("Cannot get steam information for user: "******"steamid").Value<string>();

					// encrypt password with RSA key
					RNGCryptoServiceProvider random = new RNGCryptoServiceProvider();
					byte[] encryptedPassword;
					using (var rsa = new RSACryptoServiceProvider())
					{
						var passwordBytes = Encoding.ASCII.GetBytes(state.Password);
						var p = rsa.ExportParameters(false);
						p.Exponent = Authenticator.StringToByteArray(rsaresponse.SelectToken("publickey_exp").Value<string>());
						p.Modulus = Authenticator.StringToByteArray(rsaresponse.SelectToken("publickey_mod").Value<string>());
						rsa.ImportParameters(p);
						encryptedPassword = rsa.Encrypt(passwordBytes, false);
					}

					// login request
					data = new NameValueCollection();
					data.Add("password", Convert.ToBase64String(encryptedPassword));
					data.Add("username", state.Username);
					data.Add("twofactorcode", "");
					data.Add("emailauth", (state.EmailAuthText != null ? state.EmailAuthText : string.Empty));
					data.Add("loginfriendlyname", "#login_emailauth_friendlyname_mobile");
					data.Add("captchagid", (state.CaptchaId != null ? state.CaptchaId : "-1"));
					data.Add("captcha_text", (state.CaptchaText != null ? state.CaptchaText : "enter above characters"));
					data.Add("emailsteamid", (state.EmailAuthText != null ? state.SteamId ?? string.Empty : string.Empty));
					data.Add("rsatimestamp", rsaresponse.SelectToken("timestamp").Value<string>());
					data.Add("remember_login", "false");
					data.Add("oauth_client_id", "DE45CD61");
					data.Add("oauth_scope", "read_profile write_profile read_client write_client");
					data.Add("donotache", new DateTime().ToUniversalTime().Subtract(new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).TotalMilliseconds.ToString());
					response = Request(COMMUNITY_BASE + "/login/dologin/", "POST", data, cookies);
					Dictionary<string, object> loginresponse = JsonConvert.DeserializeObject<Dictionary<string, object>>(response);

					if (loginresponse.ContainsKey("emailsteamid") == true)
					{
						state.SteamId = loginresponse["emailsteamid"] as string;
					}

					// require captcha
					if (loginresponse.ContainsKey("captcha_needed") == true && (bool)loginresponse["captcha_needed"] == true)
					{
						state.RequiresCaptcha = true;
						state.CaptchaId = (string)loginresponse["captcha_gid"];
						state.CaptchaUrl = COMMUNITY_BASE + "/public/captcha.php?gid=" + state.CaptchaId;
					}
					else
					{
						state.RequiresCaptcha = false;
						state.CaptchaId = null;
						state.CaptchaUrl = null;
						state.CaptchaText = null;
					}

					// require email auth
					if (loginresponse.ContainsKey("emailauth_needed") == true && (bool)loginresponse["emailauth_needed"] == true)
					{
						if (loginresponse.ContainsKey("emaildomain") == true)
						{
							var emaildomain = (string)loginresponse["emaildomain"];
							if (string.IsNullOrEmpty(emaildomain) == false)
							{
								state.EmailDomain = emaildomain;
							}
						}
						state.RequiresEmailAuth = true;
					}
					else
					{
						state.EmailDomain = null;
						state.RequiresEmailAuth = false;
					}

					// require email auth
					if (loginresponse.ContainsKey("requires_twofactor") == true && (bool)loginresponse["requires_twofactor"] == true)
					{
						state.Requires2FA = true;
					}
					else
					{
						state.Requires2FA = false;
					}

					// if we didn't login, return the result
					if (loginresponse.ContainsKey("login_complete") == false || (bool)loginresponse["login_complete"] == false || loginresponse.ContainsKey("oauth") == false)
					{
						if (loginresponse.ContainsKey("oauth") == false)
						{
							state.Error = "No OAuth token in response";
						}
						if (loginresponse.ContainsKey("message") == true)
						{
							state.Error = (string)loginresponse["message"];
						}
						return false;
					}

					// get the OAuth token - is stringified json
					string oauth = (string)loginresponse["oauth"];
					var oauthjson = JObject.Parse(oauth);
					state.OAuthToken = oauthjson.SelectToken("oauth_token").Value<string>();
					if (oauthjson.SelectToken("steamid") != null)
					{
						state.SteamId = oauthjson.SelectToken("steamid").Value<string>();
					}
				}

				// login to webapi
				data.Clear();
				data.Add("access_token", state.OAuthToken);
				response = Request(WEBAPI_BASE + "/ISteamWebUserPresenceOAuth/Logon/v0001", "POST", data);

				var sessionid = cookies.GetCookies(new Uri(COMMUNITY_BASE + "/"))["sessionid"].Value;

				if (state.RequiresActivation == false)
				{
					data.Clear();
					data.Add("op", "has_phone");
					data.Add("arg", "null");
					data.Add("sessionid", sessionid);

					response = Request(COMMUNITY_BASE + "/steamguard/phoneajax", "POST", data, cookies);
					var jsonresponse = JObject.Parse(response);
					bool hasPhone = jsonresponse.SelectToken("has_phone").Value<Boolean>();
					if (hasPhone == false)
					{
						state.OAuthToken = null; // force new login
						state.RequiresLogin = true;
						state.Cookies = null;
						state.Error = "Your Steam account must have a SMS-capable phone number attached. Go into Account Details of the Steam client or Steam website and click Add a Phone Number.";
						return false;
					}

					//response = Request(COMMUNITY_BASE + "/steamguard/phone_checksms?bForTwoFactor=1&bRevoke2fOnCancel=", "GET", null, cookies);

					// add a new authenticator
					data.Clear();
					string deviceId = BuildRandomId();
					data.Add("access_token", state.OAuthToken);
					data.Add("steamid", state.SteamId);
					data.Add("authenticator_type", "1");
					data.Add("device_identifier", deviceId);
					data.Add("sms_phone_id", "1");
					response = Request(WEBAPI_BASE + "/ITwoFactorService/AddAuthenticator/v0001", "POST", data);
					var tfaresponse = JObject.Parse(response);
					if (response.IndexOf("status") == -1 && tfaresponse.SelectToken("response.status").Value<int>() == 84)
					{
						// invalid response
						state.OAuthToken = null; // force new login
						state.RequiresLogin = true;
						state.Cookies = null;
						state.Error = "Unable to send SMS. Check your phone is registered on your Steam account.";
						return false;
					}
					if (response.IndexOf("shared_secret") == -1)
					{
						// invalid response
						state.OAuthToken = null; // force new login
						state.RequiresLogin = true;
						state.Cookies = null;
						state.Error = "Invalid response from Steam: " + response;
						return false;
					}

					// save data into this authenticator
					var secret = tfaresponse.SelectToken("response.shared_secret").Value<string>();
					this.SecretKey = Convert.FromBase64String(secret);
					this.Serial = tfaresponse.SelectToken("response.serial_number").Value<string>();
					this.DeviceId = deviceId;
					state.RevocationCode = tfaresponse.SelectToken("response.revocation_code").Value<string>();

					// add the steamid into the data
					var steamdata = JObject.Parse(tfaresponse.SelectToken("response").ToString());
					if (steamdata.SelectToken("steamid") == null)
					{
						steamdata.Add("steamid", state.SteamId);
					}
					if (steamdata.SelectToken("steamguard_scheme") == null)
					{
						steamdata.Add("steamguard_scheme", "2");
					}
					this.SteamData = steamdata.ToString(Newtonsoft.Json.Formatting.None);

					// calculate server drift
					long servertime = tfaresponse.SelectToken("response.server_time").Value<long>() * 1000;
					ServerTimeDiff = servertime - CurrentTime;
					LastServerTime = DateTime.Now.Ticks;

					state.RequiresActivation = true;

					return false;
				}

				// finalize adding the authenticator
				data.Clear();
				data.Add("access_token", state.OAuthToken);
				data.Add("steamid", state.SteamId);
				data.Add("activation_code", state.ActivationCode);

				// try and authorise
				var retries = 0;
				while (state.RequiresActivation == true && retries < ENROLL_ACTIVATE_RETRIES)
				{
					data.Add("authenticator_code", this.CalculateCode(false));
					data.Add("authenticator_time", this.ServerTime.ToString());
					response = Request(WEBAPI_BASE + "/ITwoFactorService/FinalizeAddAuthenticator/v0001", "POST", data);
					var finalizeresponse = JObject.Parse(response);
					if (response.IndexOf("status") != -1 && finalizeresponse.SelectToken("response.status").Value<int>() == INVALID_ACTIVATION_CODE)
					{
						state.Error = "Invalid activation code";
						return false;
					}

					// reset our time
					if (response.IndexOf("server_time") != -1)
					{
						long servertime = finalizeresponse.SelectToken("response.server_time").Value<long>() * 1000;
						ServerTimeDiff = servertime - CurrentTime;
						LastServerTime = DateTime.Now.Ticks;
					}

					// check success
					if (finalizeresponse.SelectToken("response.success").Value<bool>() == true)
					{
						if (response.IndexOf("want_more") != -1 && finalizeresponse.SelectToken("response.want_more").Value<bool>() == true)
						{
							ServerTimeDiff += 30000L;
							retries++;
							continue;
						}
						state.RequiresActivation = false;
						break;
					}

					ServerTimeDiff += 30000L;
					retries++;
				}
				if (state.RequiresActivation == true)
				{
					state.Error = "There was a problem activating. There might be an issue with the Steam servers. Please try again later.";
					return false;
				}

				// mark and successful and return key
				state.Success = true;
				state.SecretKey = Authenticator.ByteArrayToString(this.SecretKey);

				// send confirmation email
				data.Clear();
				data.Add("access_token", state.OAuthToken);
				data.Add("steamid", state.SteamId);
				data.Add("email_type", "2");
				response = Request(WEBAPI_BASE + "/ITwoFactorService/SendEmail/v0001", "POST", data);

				return true;
			}
			catch (UnauthorisedRequestException ex)
			{
				throw new InvalidEnrollResponseException("You are not allowed to add an authenticator. Have you enabled 'community-generated content' in Family View?", ex);
			}
			catch (InvalidRequestException ex)
			{
				throw new InvalidEnrollResponseException("Error enrolling new authenticator", ex);
			}
		}
Esempio n. 59
0
		/// <summary>
		/// Load the trade confirmations
		/// </summary>
		/// <param name="state">current Steam session</param>
		/// <returns></returns>
		public string LoadTrades(SteamSession state)
		{
			// clear error
			state.Error = null;

			try
			{
				var data = new NameValueCollection();
				var cookies = state.Cookies = state.Cookies ?? new CookieContainer();
				string response;

				if (string.IsNullOrEmpty(state.OAuthToken) == true)
				{
					// get session
					if (cookies.Count == 0)
					{
						cookies.Add(new Cookie("mobileClientVersion", "3067969+%282.1.3%29", "/", ".steamcommunity.com"));
						cookies.Add(new Cookie("mobileClient", "android", "/", ".steamcommunity.com"));
						cookies.Add(new Cookie("steamid", "", "/", ".steamcommunity.com"));
						cookies.Add(new Cookie("steamLogin", "", "/", ".steamcommunity.com"));
						cookies.Add(new Cookie("Steam_Language", "english", "/", ".steamcommunity.com"));
						cookies.Add(new Cookie("dob", "", "/", ".steamcommunity.com"));

						NameValueCollection headers = new NameValueCollection();
						headers.Add("X-Requested-With", "com.valvesoftware.android.steam.community");

						response = Request("https://steamcommunity.com/login?oauth_client_id=DE45CD61&oauth_scope=read_profile%20write_profile%20read_client%20write_client", "GET", null, cookies, headers);
					}

					// get the user's RSA key
					data.Add("username", state.Username);
					response = Request(COMMUNITY_BASE + "/login/getrsakey", "POST", data, cookies);
					var rsaresponse = JObject.Parse(response);
					if (rsaresponse.SelectToken("success").Value<bool>() != true)
					{
						throw new InvalidTradesResponseException("Cannot get steam information for user: "******"publickey_exp").Value<string>());
						p.Modulus = Authenticator.StringToByteArray(rsaresponse.SelectToken("publickey_mod").Value<string>());
						rsa.ImportParameters(p);
						byte[] encryptedPassword = rsa.Encrypt(passwordBytes, false);
						encryptedPassword64 = Convert.ToBase64String(encryptedPassword);
					}

					// login request
					data = new NameValueCollection();
					data.Add("password", encryptedPassword64);
					data.Add("username", state.Username);
					data.Add("twofactorcode", state.AuthCode ?? string.Empty);
					data.Add("emailauth", (state.EmailAuthText != null ? state.EmailAuthText : string.Empty));
					data.Add("loginfriendlyname", "#login_emailauth_friendlyname_mobile");
					data.Add("captchagid", (state.CaptchaId != null ? state.CaptchaId : "-1"));
					data.Add("captcha_text", (state.CaptchaText != null ? state.CaptchaText : "enter above characters"));
					data.Add("emailsteamid", (state.EmailAuthText != null ? state.SteamId ?? string.Empty : string.Empty));
					data.Add("rsatimestamp", rsaresponse.SelectToken("timestamp").Value<string>());
					data.Add("remember_login", "false");
					data.Add("oauth_client_id", "DE45CD61");
					data.Add("oauth_scope", "read_profile write_profile read_client write_client");
					data.Add("donotache", new DateTime().ToUniversalTime().Subtract(new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).TotalMilliseconds.ToString());
					response = Request(COMMUNITY_BASE + "/login/dologin/", "POST", data, cookies);
					Dictionary<string, object> loginresponse = JsonConvert.DeserializeObject<Dictionary<string, object>>(response);

					if (loginresponse.ContainsKey("emailsteamid") == true)
					{
						state.SteamId = loginresponse["emailsteamid"] as string;
					}

					// require captcha
					if (loginresponse.ContainsKey("captcha_needed") == true && (bool)loginresponse["captcha_needed"] == true)
					{
						state.RequiresCaptcha = true;
						state.CaptchaId = (string)loginresponse["captcha_gid"];
						state.CaptchaUrl = COMMUNITY_BASE + "/public/captcha.php?gid=" + state.CaptchaId;
					}
					else
					{
						state.RequiresCaptcha = false;
						state.CaptchaId = null;
						state.CaptchaUrl = null;
						state.CaptchaText = null;
					}

					// require email auth
					if (loginresponse.ContainsKey("emailauth_needed") == true && (bool)loginresponse["emailauth_needed"] == true)
					{
						if (loginresponse.ContainsKey("emaildomain") == true)
						{
							var emaildomain = (string)loginresponse["emaildomain"];
							if (string.IsNullOrEmpty(emaildomain) == false)
							{
								state.EmailDomain = emaildomain;
							}
						}
						state.RequiresEmailAuth = true;
					}
					else
					{
						state.EmailDomain = null;
						state.RequiresEmailAuth = false;
					}

					// require email auth
					if (loginresponse.ContainsKey("requires_twofactor") == true && (bool)loginresponse["requires_twofactor"] == true)
					{
						state.Requires2FA = true;
					}
					else
					{
						state.Requires2FA = false;
					}

					// if we didn't login, return the result
					if (loginresponse.ContainsKey("login_complete") == false || (bool)loginresponse["login_complete"] == false || loginresponse.ContainsKey("oauth") == false)
					{
						if (loginresponse.ContainsKey("oauth") == false)
						{
							state.Error = "No OAuth token in response";
						}
						if (loginresponse.ContainsKey("message") == true)
						{
							state.Error = (string)loginresponse["message"];
						}

						return null;
					}

					// get the OAuth token
					string oauth = (string)loginresponse["oauth"];
					var oauthjson = JObject.Parse(oauth);
					state.OAuthToken = oauthjson.SelectToken("oauth_token").Value<string>();
					if (oauthjson.SelectToken("steamid") != null)
					{
						state.SteamId = oauthjson.SelectToken("steamid").Value<string>();

						// add the steamid into the data if missing
						var steamdata = JObject.Parse(this.SteamData);
						if (steamdata.SelectToken("steamid") == null)
						{
							steamdata.Add("steamid", state.SteamId);
							this.SteamData = steamdata.ToString(Newtonsoft.Json.Formatting.None);
						}
					}
				}

				// get servertime
				//var timeresponse = Request(SYNC_URL, "POST");
				//var timejson = JObject.Parse(timeresponse);
				//long servertime = timejson.SelectToken("response.server_time").Value<long>();
				long servertime = (CurrentTime + ServerTimeDiff) / 1000L;

				var jids = JObject.Parse(this.SteamData).SelectToken("identity_secret");
				string ids = (jids != null ? jids.Value<string>() : string.Empty);

				var timehash = CreateTimeHash(servertime, "conf", ids);

				data.Clear();
				data.Add("p", this.DeviceId);
				data.Add("a", state.SteamId);
				data.Add("k", timehash);
				data.Add("t", servertime.ToString());
				data.Add("m", "android");
				data.Add("tag", "conf");

				return Request(COMMUNITY_BASE + "/mobileconf/conf", "GET", data, state.Cookies);
			}
			catch (InvalidRequestException ex)
			{
				state.Error = ex.Message;
				throw new InvalidTradesResponseException("Error trading", ex);
			}
		}