# Password Utilities

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.

{% tabs %}
{% tab title="TypeScript" %}

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

{% endtab %}

{% tab title="Swift" %}

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

{% endtab %}

{% tab title="Kotlin" %}

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

{% endtab %}
{% endtabs %}

{% hint style="info" %}
General criteria applied for generating passwords:

* Password length (>5)
* Uppercase (A-Z)
* Lowercase (a-z)
* Numbers (0-9)
* Symbols (! ? @ \* . \_ -)
  {% endhint %}

## 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.

{% tabs %}
{% tab title="TypeScript" %}

```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
}
```

{% endtab %}

{% tab title="Swift" %}

```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
}
```

{% endtab %}

{% tab title="Kotlin" %}

```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,
}
```

{% endtab %}
{% endtabs %}