public IEnumerator UpdateAccountCoroutine(uLobby.IAccount account, uLobby.AccountUpdate update, uLobby.Request <uLobby.Account> request)
    {
        Request <AccountRecord> getAccountRequest;

        getAccountRequest = StorageLayerUtility.GetAccountRecord(account.id);
        yield return(getAccountRequest.WaitUntilDone()); if (StorageLayerUtility.RequestUtility.PropagateException(getAccountRequest, request))
        {
            yield break;
        }
        AccountRecord record = getAccountRequest.result;

        if (StorageLayerUtility.AccountUpdateUtility.isPasswordChanged(update))
        {
            record.passwordHash = SaltedPasswordHash.GenerateSaltedPasswordHash(SaltedPasswordHash.GeneratePasswordHash(StorageLayerUtility.AccountUpdateUtility.GetPassword(update) + record.name));
        }
        if (StorageLayerUtility.AccountUpdateUtility.IsDataChanged(update))
        {
            record.data = StorageLayerUtility.AccountUpdateUtility.GetData(update);
        }
        MySqlParameter[] paramsArray = new MySqlParameter[4];
        paramsArray[0] = new MySqlParameter("password", record.passwordHash.passwordHash);
        paramsArray[1] = new MySqlParameter("salt", record.passwordHash.salt);
        paramsArray[2] = new MySqlParameter("data", record.data);
        paramsArray[3] = new MySqlParameter("id", int.Parse(record.id.value));
        var operation = ExecuteNonQueryAsync.BeginInvoke(storageManager.connectionString, "UPDATE accounts SET password=@password,salt=@salt,data=@data WHERE id = @id", paramsArray, null, null);

        while (!operation.IsCompleted)
        {
            yield return(null);
        }
        Account updatedAccount = StorageLayerUtility.CreateAccount(record);

        StorageLayerUtility.RequestUtility.SetResult(request, updatedAccount);
    }
예제 #2
0
    // UpdateAccountCoroutine
    IEnumerator IAccountOperations.UpdateAccountCoroutine(IAccount account, AccountUpdate update, Request <Account> request)
    {
        Request <AccountRecord> getAccountRequest;

        getAccountRequest = StorageLayerUtility.GetAccountRecord(account.id);
        yield return(getAccountRequest.WaitUntilDone()); if (StorageLayerUtility.RequestUtility.PropagateException(getAccountRequest, request))
        {
            yield break;
        }
        AccountRecord record = getAccountRequest.result;

        if (StorageLayerUtility.AccountUpdateUtility.isPasswordChanged(update))
        {
            record.passwordHash = SaltedPasswordHash.GenerateSaltedPasswordHash(SaltedPasswordHash.GeneratePasswordHash(StorageLayerUtility.AccountUpdateUtility.GetPassword(update) + record.name));
        }

        if (StorageLayerUtility.AccountUpdateUtility.IsDataChanged(update))
        {
            record.data = StorageLayerUtility.AccountUpdateUtility.GetData(update);
        }

        Account updatedAccount = StorageLayerUtility.CreateAccount(record);

        StorageLayerUtility.RequestUtility.SetResult(request, updatedAccount);
        yield break;
    }
 // Verify password method
 public static bool Verify(string password, string passwordHash)
 {
     string[] passwordHashes = passwordHash.Split(':');
     if (passwordHashes.Length == 2)
     {
         var saltedPasswordHash = new SaltedPasswordHash(passwordHashes[0], passwordHashes[1]);
         return(saltedPasswordHash.Verify(password));
     }
     return(false);
 }
 // Password verify
 public static bool Verify(string password, string passwordHash)
 {
     string[] hashSalted = passwordHash.Split(':');
     if (hashSalted.Length == 2)
     {
         var saltedPaswordHash = new SaltedPasswordHash(hashSalted[0], hashSalted[1]);
         return(saltedPaswordHash.Verify(password));
     }
     return(false);
 }
        public void CanVerifyPasswordCreatedWithClearTextAgainstPasswordCreatedFromCorrectHashAndSalt()
        {
            // Arrange
            var password = "******";

            // Act
            var  passwordHash     = new SaltedPasswordHash(password);
            var  verificationHash = new SaltedPasswordHash(passwordHash.Hash, passwordHash.Salt);
            bool valid            = verificationHash == passwordHash;

            // Assert
            valid.Should().Be.True();
        }
        public void CanVerifyClearTextPasswordAgainstHashedAndSaltedPassword()
        {
            // Arrange
            var clearTextPassword    = "******";
            var originalPasswordHash = new SaltedPasswordHash(clearTextPassword);
            var retrivedPasswordHash = new SaltedPasswordHash(originalPasswordHash.Hash, originalPasswordHash.Salt);

            // Act
            bool valid = retrivedPasswordHash.Verify(clearTextPassword);

            // Assert
            valid.Should().Be.True();
        }
        public void CanVerifyClearTextPasswordAgainstHashedAndSaltedPassword()
        {
            // Arrange
            var clearTextPassword = "******";
            var originalPasswordHash = new SaltedPasswordHash(clearTextPassword);
            var retrivedPasswordHash = new SaltedPasswordHash(originalPasswordHash.Hash, originalPasswordHash.Salt);

            // Act
            bool valid = retrivedPasswordHash.Verify(clearTextPassword);

            // Assert
            valid.Should().Be.True();
        }
        public void CanDetermineIfHashedNotEqual()
        {
            // Arrange
            var password  = "******";
            var password2 = "boguspassword";

            // Act
            var passwordHash1 = new SaltedPasswordHash(password);
            var passwordHash2 = new SaltedPasswordHash(password2);

            bool valid = passwordHash1 != passwordHash2;

            // Assert
            valid.Should().Be.True();
        }
        public void CanNotVerifyTwoIdenticalPasswordsCreatedFromClearText()
        {
            // Arrange
            var password  = "******";
            var password2 = "testpassword";

            // Act
            var passwordHash1 = new SaltedPasswordHash(password);
            var passwordHash2 = new SaltedPasswordHash(password2);

            bool valid = passwordHash1 == passwordHash2;

            // Assert
            valid.Should().Be.False();
        }
        public void CanNotVerifyTwoIdenticalPasswordsCreatedFromClearText()
        {
            // Arrange
            var password = "******";
            var password2 = "testpassword";

            // Act
            var passwordHash1 = new SaltedPasswordHash(password);
            var passwordHash2 = new SaltedPasswordHash(password2);

            bool valid = passwordHash1 == passwordHash2;

            // Assert
            valid.Should().Be.False();
        }
        public void CanDetermineIfHashedNotEqual()
        {
            // Arrange
            var password = "******";
            var password2 = "boguspassword";

            // Act
            var passwordHash1 = new SaltedPasswordHash(password);
            var passwordHash2 = new SaltedPasswordHash(password2);

            bool valid = passwordHash1 != passwordHash2;

            // Assert
            valid.Should().Be.True();
        }
        public void CanVerifyTwoPasswordHashedCreatedFromClearTextPasswordsButTheyHashesAreNotEqual()
        {
            // Arrange
            var clearTextPassword = "******";
            var hash1             = new SaltedPasswordHash(clearTextPassword);
            var hash2             = new SaltedPasswordHash(clearTextPassword);

            // Act
            bool equalHashed           = hash1 == hash2;
            bool hash1VerifiesPassword = hash1.Verify(clearTextPassword);
            bool hash2VerifiesPassword = hash2.Verify(clearTextPassword);

            // Assert
            equalHashed.Should().Be.False();
            hash1VerifiesPassword.Should().Be.True();
            hash2VerifiesPassword.Should().Be.True();
        }
    // CreateAccount
    public static IEnumerator CreateAccount(string accountId, string email, string password)
    {
        // Test accounts
        if (GameDB.IsTestAccount(email))
        {
            password = email;
        }

        // Log
        LogManager.General.Log(accountId + ", " + email + ", " + password);

        // SHA 512 encryption
        password = GameDB.EncryptPasswordString(password);

        // AccountNameToID
        yield return(GameDB.instance.StartCoroutine(GameDB.Set <string>(
                                                        "AccountNameToID",
                                                        email,
                                                        accountId,
                                                        null
                                                        )));

        // Create password hash
        LogManager.General.Log("Generating password hash");
        var saltedPasswordHash = SaltedPasswordHash.GenerateSaltedPasswordHash(SaltedPasswordHash.GeneratePasswordHash(password + email));

        // Create game account
        var gameAccount = new GameAccount(
            accountId,
            email,
            saltedPasswordHash.passwordHash,
            saltedPasswordHash.salt
            );

        // Save game account
        LogManager.General.Log("Saving game account: " + accountId);
        yield return(GameDB.instance.StartCoroutine(GameDB.Set <GameAccount>(
                                                        "Accounts",
                                                        accountId,
                                                        gameAccount,
                                                        null
                                                        )));
    }
예제 #14
0
    // UpdateAccountCoroutine
    IEnumerator IAccountOperations.UpdateAccountCoroutine(IAccount account, AccountUpdate update, Request <Account> request)
    {
        // Get account record
        Request <AccountRecord> getAccountRequest;

        getAccountRequest = StorageLayerUtility.GetAccountRecord(account.id);
        yield return(getAccountRequest.WaitUntilDone());

        // Did it cause an exception?
        if (StorageLayerUtility.RequestUtility.PropagateException(getAccountRequest, request))
        {
            yield break;
        }

        AccountRecord record = getAccountRequest.result;

        // Password change
        if (StorageLayerUtility.AccountUpdateUtility.isPasswordChanged(update))
        {
            record.passwordHash = SaltedPasswordHash.GenerateSaltedPasswordHash(SaltedPasswordHash.GeneratePasswordHash(StorageLayerUtility.AccountUpdateUtility.GetPassword(update) + record.name));
        }

        Account updatedAccount = StorageLayerUtility.CreateAccount(record);

        // Save in accounts database
        yield return(GameDB.instance.StartCoroutine(GameDB.Set <GameAccount>(
                                                        "Accounts",
                                                        updatedAccount.id.value,
                                                        new GameAccount(record),
                                                        data => {
            if (data != null)
            {
                StorageLayerUtility.RequestUtility.SetResult(request, updatedAccount);
            }
        }
                                                        )));
    }
        // Hash password method
        public static string Hash(string password)
        {
            var saltedPasswordHash = new SaltedPasswordHash(password, 8);

            return(saltedPasswordHash.Hash + ":" + saltedPasswordHash.Salt);
        }
        // Hash encoding
        public static string HashEncode(string password)
        {
            var passwordHash = new SaltedPasswordHash(password, 20);

            return(passwordHash.Hash + ":" + passwordHash.Salt);
        }
        public void CanVerifyPasswordCreatedWithClearTextAgainstPasswordCreatedFromCorrectHashAndSalt()
        {
            // Arrange
            var password = "******";

            // Act
            var passwordHash = new SaltedPasswordHash(password);
            var verificationHash = new SaltedPasswordHash(passwordHash.Hash, passwordHash.Salt);
            bool valid = verificationHash == passwordHash;

            // Assert
            valid.Should().Be.True();
        }
        public void CanVerifyTwoPasswordHashedCreatedFromClearTextPasswordsButTheyHashesAreNotEqual()
        {
            // Arrange
            var clearTextPassword = "******";
            var hash1 = new SaltedPasswordHash(clearTextPassword);
            var hash2 = new SaltedPasswordHash(clearTextPassword);

            // Act
            bool equalHashed = hash1 == hash2;
            bool hash1VerifiesPassword = hash1.Verify(clearTextPassword);
            bool hash2VerifiesPassword = hash2.Verify(clearTextPassword);

            // Assert
            equalHashed.Should().Be.False();
            hash1VerifiesPassword.Should().Be.True();
            hash2VerifiesPassword.Should().Be.True();
        }