Basic Usage

import io.github.libpasta.pasta;

public class hash {
  public static void main(String argv[]) {
    String password  = pasta.read_password("Please enter your password:");
    String hash = pasta.hash_password(password);
    System.out.println("The hashed password is: " + hash);
  }
}

from libpasta import *

password = read_password("Please enter your password:")
hash =  hash_password(password)
print("The hashed password is: ", hash)

require 'libpasta'

password = Pasta::read_password "Please enter your password:"
hash = Pasta::hash_password(password)
puts "The hashed password is: ", hash

extern crate libpasta;

// We re-export the rpassword crate for CLI password input.
use libpasta::rpassword::*;

fn main() {
    let password = prompt_password_stdout("Please enter your password:").unwrap();
    let password_hash = libpasta::hash_password(&password);
    println!("The hashed password is: '{}'", password_hash);
}

import io.github.libpasta.pasta;

public class verify {
    private String password_hash;

    public void authUser() {
        String password = pasta.read_password("Enter password:");
        if(pasta.verify_password(self.password_hash, password)) {
            System.out.println("The password is correct!");
            // ~> Handle correct password
        } else {
            System.out.println("Incorrect password.");
            // ~> Handle incorrect password
        }
    }
}

from libpasta import *

class User:
    password_hash = ""

    def auth_user():
        password = read_password("Enter password:")
        if verify_password(self.password_hash, password):
            print("The password is correct!")
            # ~> Handle correct password
        else:
            print("Incorrect password.")
            # ~> Handle incorrect password

require 'libpasta'

class User
    attr_accessor :pw_hash
    @pw_hash = ""

    def auth_user
        password = Pasta::read_password("Enter password: ")
        if Pasta::verify_password(self.pw_hash, password)
            puts "The password is correct!"
            # ~> Handle correct password
        else
            puts "Incorrect password."
            # ~> Handle incorrect password
        end
    end
end

extern crate libpasta;
use libpasta::rpassword::*;

struct User {
    // ...
    password_hash: String,
}

fn auth_user(user: &User) {
    let password = prompt_password_stdout("Enter password:").unwrap();
    if libpasta::verify_password(&user.password_hash, &password) {
        println!("The password is correct!");
        // ~> Handle correct password
    } else {
        println!("Incorrect password.");
        // ~> Handle incorrect password
    }
}

import io.github.libpasta.pasta;
import io.github.libpasta.HashUpdate;

class User {
    String pw_hash;

    public boolean auth_user() {
        String pw = pasta.read_password("Enter password:");

        HashUpdate res = pasta.verify_password_update_hash(pw_hash, pw);
        switch (res.getTag()) {
            case Updated:
                pw_hash = res.getUpdated();
            case Ok:
                return true;
        }
        return false;
    }

    public static void migrate_users(User[] users) {
        for(User user : users) {
            HashUpdate res = pasta.migrate_hash(user.pw_hash);
            switch (res.getTag()) {
                case Updated:
                    user.pw_hash = res.getUpdated();
                case Ok:
                    System.out.println("Password correct"); break;
                case Failed:
                    System.out.println("Password incorrect");
            }
        }
    }

}

from libpasta import *

class User:
    def auth_user(self):
        pw = read_password("Enter password")
        res = verify_password_update_hash(self.pw_hash, pw)
        if res.tag == HashUpdate.Updated:
            self.pw_hash = res.Updated
            return true
        elif res.tag == HashUpdate.Ok:
            return true
        else:
            return false

def migrate_users(users):
    for user in users:
        res = migrate_hash(user.pw_hash)
        if res.tag == HashUpdate.Updated:
            user.pw_hash = res.updated

require 'libpasta'

class User
    attr_accessor :pw_hash
    @pw_hash = ""


    def auth_user
        pw = Pasta::read_password("Enter password: ")
        res = Pasta::verify_password_update_hash(self.pw_hash, pw)
        case res.tag
        when Pasta::HashUpdate::Updated
            self.pw_hash = res.updated
            return true
        when  Pasta::HashUpdate::Ok
            return true
        else
            return false
        end
    end
end

def migrate_users(users)
    for user in users do
        res = Pasta::migrate_hash(user.pw_hash)
        if res.tag.eql? Pasta::HashUpdate::Updated
            user.pw_hash = res.updated
        end
    end
end

extern crate libpasta;
use libpasta::rpassword::*;
use libpasta::{migrate_hash, HashUpdate};

struct User {
    // ...
    password_hash: String,
}

fn migrate_users(users: Vec<&mut User>) {
    // Step 1: Wrap old hash
    for user in users {
        let hash = user.password_hash;
        if let HashUpdate::Verified(Some(new_hash)) = migrate_hash(hash) {
            user.password_hash = new_hash;
        }
    }
}

fn auth_user(user: &mut User) {
    // Step 2: Update algorithm during log in
    let password = prompt_password_stdout("Enter password:").unwrap();

    match libpasta::verify_password_update_hash(&user.password_hash, password) {
        HashUpdate::Verified(res) => {
            if let Some(new_hash) = res {
                user.password_hash = new_hash;
            }
            println!("Password correct, new hash: \n{}", user.password_hash);
        },
        HashUpdate::Failed => {
            println!("Password incorrect, hash unchanged: \n{}", user.password_hash);
        }
    }
}

import io.github.libpasta.Bcrypt;
import io.github.libpasta.Config;

public class config {
  public static void main(String[] args) {
    Bcrypt b = new Bcrypt(15);
    Config cfg = Config.with_primitive(b);
    String hash = cfg.hash_password("hunter2");
    System.out.println("The hashed password is: " + hash);
  }
}

from libpasta import *

config = Config.with_primitive(Bcrypt(15))
pw_hash = config.hash_password("hunter2")
print("The hashed password is: ", pw_hash)

require 'libpasta'

config = Pasta::Config.with_primitive(Pasta::Bcrypt.new(15))
pw_hash = config.hash_password("hunter2")
puts "The hashed password is: ", pw_hash

extern crate libpasta;

use libpasta::primitives::Bcrypt;
use libpasta::config::Config;

fn main() {
    let config = Config::with_primitive(Bcrypt::new(15));
    let password_hash = config.hash_password("hunter2");
    println!("The hashed password is: '{}'", password_hash);
    // Prints bcrypt hash
}

default: Custom
keyed: ~
primitive: 
  id: "scrypt"
  params: 
    ln: 11
    r: 8
    p: 1