native sha256(const key[], hash[], len = sizeof(hash));
native sha384(const key[], hash[], len = sizeof(hash)); 
native sha512(const key[], hash[], len = sizeof(hash));
native sha3(const key[], hash[], len = sizeof(hash));
native whirlpool(const key[], hash[], len = sizeof(hash));
native ripemd160(const key[], hash[], len = sizeof(hash));
native ripemd256(const key[], hash[], len = sizeof(hash));
native ripemd320(const key[], hash[], len = sizeof(hash));

native random_int(min, max); // Also works with negative values.
native random_string(length, output[], len = sizeof(output));

native base64_encode(const input[], output[], len = sizeof(output));
native base64_decode(const input[], output[], len = sizeof(output));
native hex_encode(const input[], output[], len = sizeof(output));
native hex_decode(const input[], output[], len = sizeof(output));

native hash_generate(const key[], iterations, const callback[], const format[], {Float,_}:...);
native hash_retrieve(hash[], salt[], hlen = sizeof(hash), slen = sizeof(salt));
native hash_validate(const key[], const hash[], const salt[], iterations, const callback[], const format[], {Float,_}:...);
native hash_is_equal();
native hash_unprocessed(); // Returns the internal number of unprocessed PBKDF2 workers. 
native hash_exec_time(); // Returns the execution time in milliseconds.
native hash_thread_limit(threads); // Sets the number of worker threads.

native md5sum(const file[], sum[], len = sizeof(sum));
native sha1sum(const file[], sum[], len = sizeof(sum));
native sha256sum(const file[], sum[], len = sizeof(sum));
native sha384sum(const file[], sum[], len = sizeof(sum));
native sha512sum(const file[], sum[], len = sizeof(sum));
native wpsum(const file[], sum[], len = sizeof(sum));

native slow_equals(const a[], const b[]);

#define PBKDF2_LENGTH 128
#define MD5_LENGTH 32
#define SHA1_LENGTH 40
#define SHA256_LENGTH 64
#define SHA384_LENGTH 96
#define SHA512_LENGTH 128
#define SHA3_LENGTH 128
#define WHIRLPOOL_LENGTH 128
#define RIPEMD160_LENGTH 40
#define RIPEMD256_LENGTH 64
#define RIPEMD320_LENGTH 80

#include <a_samp>
#include <hash>

#define ITERATIONS 150000

public OnDialogResponse(playerid, dialogid, response, listitem, inputtext[])
{
    switch(dialogid)
    {
        case DIALOG_REGISTER:
        {
            hash_generate(inputtext, ITERATIONS, "OnPasswordHash", "i", playerid);
            return 1;
        }
        case DIALOG_LOGIN:
        {
            new hash[PBKDF2_LENGTH + 1], salt[PBKDF2_LENGTH + 1];
            // The variable hash and salt are being fetched from database.
            hash_validate(inputtext, hash, salt, ITERATIONS, "OnPasswordValidate", "i", playerid);
            return 1;
        }
    }
    return 0;
}

forward public OnPasswordHash(playerid);
public OnPasswordHash(playerid)
{
    new hash[PBKDF2_LENGTH + 1], salt[PBKDF2_LENGTH + 1];
    hash_retrieve(hash, salt);
    
    SendClientMessage(playerid, 0xFFFFFFFF, "Your password has been hashed.");
    // You can now save hash and salt in the database.
    return 1;
}

forward public OnPasswordValidate(playerid);
public OnPasswordValidate(playerid)
{
    if(hash_is_equal())
    {
        SendClientMessage(playerid, 0xFFFFFFFF, "Correct password!");
    }
    else
    {
        SendClientMessage(playerid, 0xFFFFFFFF, "Invalid password!");
    }
    return 1;
}

#include <a_samp>
#include <hash>

public OnDialogResponse(playerid, dialogid, response, listitem, inputtext[])
{
    switch(dialogid)
    {
        case DIALOG_REGISTER:
        {
            new salt[33], string[128 + 33];
            random_string(32, salt);
            
            format(string, sizeof(string), "%s%s", inputtext, salt);
            
            new hash[SHA3_LENGTH + 1];
            sha3(string, hash);
            
            SCM(playerid, 0xFFFFFFFF, "Your password has been salted and hashed!");
            // Save salt and hash in the database.
            return 1;
        }
        case DIALOG_LOGIN:
        {
            new hash[SHA512_LENGTH + 1], salt[33];
            // The variable hash and salt are being fetched from database.
            
            new string[128 + 33], validate_hash[SHA3_LENGTH + 1];
            format(string, sizeof(string), "%s%s", inputtext, salt);
            sha3(string, validate_hash);
            
            if(!strcmp(hash, validate_hash))
            {
                SendClientMessage(playerid, 0xFFFFFFFF, "Correct password!");
            }
            else
            {
                SendClientMessage(playerid, 0xFFFFFFFF, "Invalid password!");
            }
            return 1;
        }
    }
    return 0;
}

plugins hash.so

plugins hash

NOTE: Boost is no longer required since version 0.0.5
Install gcc, g++ and make on your machine.
Download, extract boost and install boost:
# ./bootstrap.sh
# ./b2 address-model=32 variant=release install
Clone the Github project and find the directory which contains makefile.
Type make to start compiling.
After compiling hash.so will be located in the bin folder.

NOTE: Boost is no longer required since version 0.0.5
Download and extract boost.
Open a command line and navigate to the extracted folder.
> bootstrap
> b2 toolset=msvc-10.0 variant=release threading=multi link=static
Close the Github project and open it with Visual C++ 2010.
Select "Release" from the dropdown menu at the top.
Go to the solution property page -> VC++ Directories.
Point Include Directories and Library Directories to your boost installation folder.
Compile the project.
After compiling hash.dll will be located in the bin folder.