Add async overloads to passwordHash and passwordVerify

Async is the recommended way to call both functions

Author: jushar

Shared/mods/deathmatch/logic/lua/CLuaShared.cpp

@@ -81,3 +81,13 @@ void CLuaShared::AddClasses(lua_State* luaVM)
     CLuaFileDefs::AddClass ( luaVM );
     CLuaXMLDefs::AddClass ( luaVM );
 }
+
+
+SharedUtil::CAsyncTaskScheduler* CLuaShared::GetAsyncTaskScheduler()
+{
+#ifdef MTA_CLIENT
+    return g_pClientGame->GetAsyncTaskScheduler();
+#else
+    return g_pGame->GetAsyncTaskScheduler();
+#endif
+}

Shared/mods/deathmatch/logic/lua/CLuaShared.h

@@ -28,4 +28,8 @@ class CLuaShared
     static bool CheckUTF8BOMAndUpdate ( const char** pcpOutBuffer, uint* puiOutSize );
     static void LoadFunctions ( void );
     static void AddClasses ( lua_State* luaVM );
+
+    // Shared scripting is the only place where we need the async task scheduler
+    // so just go with a hack here
+    static SharedUtil::CAsyncTaskScheduler* GetAsyncTaskScheduler();
 };

Shared/mods/deathmatch/logic/luadefs/CLuaCryptDefs.cpp

@@ -178,16 +178,23 @@ int CLuaCryptDefs::Base64decode ( lua_State* luaVM )
 
 int CLuaCryptDefs::PasswordHash(lua_State* luaVM)
 {
-//  string password_hash(string password, string algorithm, table options = {})
+//  string password_hash(string password, string algorithm, table options = {} [, function callback])
     SString password;
     PasswordHashFunction algorithm;
     std::unordered_map<SString, SString> options;
+    CLuaFunctionRef luaFunctionRef;
 
     CScriptArgReader argStream(luaVM);
     argStream.ReadString(password);
     argStream.ReadEnumString(algorithm);
     argStream.ReadStringMap(options, true);
 
+    if (argStream.NextIsFunction())
+    {
+        argStream.ReadFunction(luaFunctionRef);
+        argStream.ReadFunctionComplete();
+    }
+
     if (!argStream.HasErrors())
     {
         if (algorithm == PasswordHashFunction::Bcrypt)
@@ -202,14 +209,45 @@ int CLuaCryptDefs::PasswordHash(lua_State* luaVM)
 
             if (!ss.fail())
             {
-                SString hash = SharedUtil::BcryptHash(password, options["salt"], cost);
-                if (!hash.empty())
+                // Sync
+                if (luaFunctionRef == CLuaFunctionRef{})
+                {
+                    SString hash = SharedUtil::BcryptHash(password, options["salt"], cost);
+                    if (!hash.empty())
+                    {
+                        lua_pushstring(luaVM, hash);
+                        return 1;
+                    }
+                    else
+                        m_pScriptDebugging->LogCustom(luaVM, "Invalid value for field 'salt'");
+                }
+                else // Async
                 {
-                    lua_pushstring(luaVM, hash);
-                    return 1;
+                    CLuaMain* pLuaMain = m_pLuaManager->GetVirtualMachine(luaVM);
+                    if (pLuaMain)
+                    {
+                        CLuaShared::GetAsyncTaskScheduler()->PushTask<SString>([password, salt = options["salt"], cost] {
+                            // Execute time-consuming task
+                            return SharedUtil::BcryptHash(password, salt, cost);
+
+                        }, [luaFunctionRef, pLuaMain](const SString& hash) {
+                            CLuaArguments arguments;
+
+                            if (hash.empty())
+                            {
+                                m_pScriptDebugging->LogCustom(pLuaMain->GetVM(), "Invalid value for field 'salt'");
+                                arguments.PushBoolean(false);
+                            }
+                            else
+                                arguments.PushString(hash);
+
+                            arguments.Call(pLuaMain, luaFunctionRef);
+                        });
+
+                        lua_pushboolean(luaVM, true);
+                        return 1;
+                    }
                 }
-                else
-                    m_pScriptDebugging->LogCustom(luaVM, "Invalid value for field 'salt'");
             }
             else
                 m_pScriptDebugging->LogWarning(luaVM, "Invalid value for field 'cost'");
@@ -224,19 +262,49 @@ int CLuaCryptDefs::PasswordHash(lua_State* luaVM)
 
 int CLuaCryptDefs::PasswordVerify(lua_State* luaVM)
 {
-//  bool passwordVerify(string password, string hash)
+//  bool passwordVerify(string password, string hash [, function callback])
     SString password;
     SString hash;
+    CLuaFunctionRef luaFunctionRef;
 
     CScriptArgReader argStream(luaVM);
     argStream.ReadString(password);
     argStream.ReadString(hash);
 
+    if (argStream.NextIsFunction())
+    {
+        argStream.ReadFunction(luaFunctionRef);
+        argStream.ReadFunctionComplete();
+    }
+
     if (!argStream.HasErrors())
     {
         if (hash.BeginsWith("$2y$"))
         {
-            lua_pushboolean(luaVM, SharedUtil::BcryptVerify(password, hash));
+            // Sync
+            if (luaFunctionRef == CLuaFunctionRef())
+            {
+                lua_pushboolean(luaVM, SharedUtil::BcryptVerify(password, hash));
+            }
+            else // Async
+            {
+                CLuaMain* pLuaMain = m_pLuaManager->GetVirtualMachine(luaVM);
+                if (pLuaMain)
+                {
+                    CLuaShared::GetAsyncTaskScheduler()->PushTask<bool>([password, hash]{
+                        // Execute time-consuming task
+                        return SharedUtil::BcryptVerify(password, hash);
+
+                    }, [luaFunctionRef, pLuaMain](const bool& correct) {
+                        CLuaArguments arguments;
+                        arguments.PushBoolean(correct);
+
+                        arguments.Call(pLuaMain, luaFunctionRef);
+                    });
+
+                    lua_pushboolean(luaVM, true);
+                }
+            }
             return 1;
         }
         else