Password Utilities

Provide your users the necessary utilities to generate strong and secure passwords

The Password Manager SDK provides utility methods to help generate strong passwords and calculate the strength of a password.

Generating Passwords

Help users adopt strong passwords by using the generatePassword method. Passwords are generated from a criteria of five different input options; length, allowUpperCase, allowLowercase, allowNumbers, and allowSymbols. By default, the generator will generate passwords of 20 characters, but will not allow a user to generate a password that is less than six characters. If all options are marked false, the password generator will apply all options, the same as if all options had been marked true, resulting in at least one character from each option.

TypeScript

// Generate a password
const password = client.generatePassword({
    length: 20, // defaults to 20
    allowUppercase: true,
    allowLowercase: true,
    allowNumbers: true,
    allowSymbols: true,
})

Swift

// Generate a password
let password = generatePassword(
                length: 20, // defaults to 20
                allowUppercase: true, 
                allowLowercase: true, 
                allowNumbers: true, 
                allowSymbols: true
                )

Kotlin

// Generate a password
val password = generatePassword(
    length = 20, // length defaults to 20
    allowUppercase = true,
    allowLowercase = true,
    allowNumbers = true, 
    allowSymbols = true
)

General criteria applied for generating passwords:

• Password length (>5)

• Uppercase (A-Z)

• Lowercase (a-z)

• Numbers (0-9)

• Symbols (! ? @ * . _ -)

Calculating a Password's Strength

Use the calculateStrengthOfPassword method to measure the strength of the user's password. A strength level from an enum containing five strength levels (VeryWeak, Weak, Moderate, Strong, VeryStrong) will be returned after measuring the password. The criteria is based on how easy the password is to guess. A VeryWeak result means the password is risky and too guessable while a VeryStrong result it is extremely difficult to guess and has strong protection from offline slow-hash attacks. Use this method to rate current passwords and encourage user's to adopt stronger passwords.

TypeScript

// Calculate strength of password
const strength = client.calculateStrengthOfPassword(password) // returns a `PasswordStrength`.

// PasswordStrength enum
enum PasswordStrength {
    case VeryWeak
    case Weak
    case Moderate
    case Strong
    case VeryStrong
}

Swift

// Calculate strength of password
let strength = calculateStrength(of: password) // returns a `PasswordStrength`

// PasswordStrength enum
public enum PasswordStrength {
    case veryWeak
    case weak
    case moderate
    case strong
    case veryStrong
}

Kotlin

// Calculate strength of password
val strength = calculateStrengthOfPassword(password) // returns a `PasswordStrength`
when (strength) {
    PasswordStrength.VeryWeak,
    PasswordStrength.Weak -> println("Please choose a stronger password")
    else -> {}
}

// PasswordStrength enum
enum class PasswordStrength {
    VeryWeak,
    Weak,
    Moderate,
    Strong,
    VeryStrong,
}