Summary

This program generates fully customizable random passwords, with almost any desired pattern or length, using the same syntax as Regular Expressions for character classes (POSIX-style), repetition ({N} or {M,N}) and capturing groups ((...)).

See examples for clarity.

Build and install

Run:

go get github.com/ilius/repassgen

This will compile and then copy repassgen executable file to $GOPATH/bin/ directory.

If you just want to compile without installing it

go get -d github.com/ilius/repassgen
cd $GOPATH/src/github.com/ilius/repassgen
go build

Then repassgen binary file will be created in current directory.

Features of regexp

• Simple repetition: {N}
• Range repetition: {M,N}
• Manual character range, like [a-z1-579]
• Repeatable groups with (...){N}, like ([a-z]{2}[1-9]){3}
• [:alnum:] Alphanumeric characters
• [:alpha:] Alphabetic characters
• [:word:], [:w:] or \w: Word characters (letters, numbers and underscores, same as [a-zA-Z0-9_])
• [:upper:] Uppercase letters
• [:lower:] Lowercase letters
• [:graph:] Visible characters
• [:print:] Visible characters and spaces (anything except control characters)
• [:digit:] or \d Digits
• [:xdigit:] Hexadecimal digits
• [:punct:] Punctuation (and symbols).
• [:space:] All whitespace characters, including line breaks
• [:blank:] Space and tab
• [:cntrl:] Control characters
• [:ascii:] ASCII characters
• Unicode code points, like [\u00e0-\u00ef]{5}
• Group references \1, \2, etc

Aditional Features (not part of regexp)

• Combined multiple named/manual character classes, for example:
  • [:digit:a-m]
  • [:digit::alpha:] = [:alnum:]
• [:b32:] Crockford's Base32 alphabet (lowercase)
• [:B32:] Crockford's Base32 alphabet (uppercase)
• [:B32STD:] Standard Base32 alphabet (uppercase)
• [:b64:] Standard Base64 alphabet
• [:b64url:] URL-safe Base64 alphabet
• $base64(...) Base64 encode function (input is hex-encoded)
• $base64url(...) URL-safe Base64 encode function (input is hex-encoded)
• $base32(...) Crockford's Base32 encode function (lowercase) (input is hex-encoded)
• $BASE32(...) Crockford's Base32 encode function (uppercase) (input is hex-encoded)
• $base32std(...) Standard Base32 encode function (uppercase, with no padding) (input is hex-encoded)
• $hex(...) Hex encode function (lowercase)
• $HEX(...) Hex encode function (uppercase)
• Show entropy of pattern
  • Use repassgen -entropy 'PATTERN' command
  • Indicates strength of generated passwords, the higher the better
  • We recommand at least 47 bits (equal to 8 alphanumeric: [:alnum:]{8})
  • Entropy of pattern is more important than entropy of password, if you re-use patterns
• $hex2dec(...) Convert hexadecimal number to decimal number
• $escape(...) Escape unicode characters, non-printable characters and double quote
• $?(...) Randomly include or omit the string/pattern (%50 chance, adds 1 bit to entropy)
• $bip39word(N) Generate N words from BIP-39 English mnemonic words
• $bip39encode(...) Encode hex-encoded bytes into some BIP-39 English mnemonic words
• $date(2000,2020,-) Generate a random date in the given year range
• $space(...) Adds spaces between each two characters of string (generated from given pattern)
• $expand(|...) Adds | (for example) between each two characters (similar to $space)
• $rjust(PATTERN,N,X) Justify to right, N is width (N>=1), X is the character to fill
• $ljust(PATTERN,N,X) Justify to left, similar to $rjust
• $center(PATTERN,N,X) Justify to center, similar to $rjust
• $pyhex(...) Convert hex-encoded bytes to Python bytes with hex values (like b'\x74\x65\x73\x74')
• $romaji(...) Converts Japanese hiragana/katakana string to Latin

Examples

• Alphanumeric password with length 12

  $ repassgen '[:alnum:]{12}'
  q8nrqhPQFNqj

• Alphabetic password with length 12

  $ repassgen '[:alpha:]{12}'
  wiADcFkhpjsk

• Lowercase alphabetic password with length 16

  $ repassgen '[:lower:]{16}'
  rnposblbuduotibe

• Uppercase alphabetic password with length 16

  $ repassgen '[:upper:]{16}'
  TQZZJHKQRKETOFNZ

• Numeric password with length 8

  $ repassgen '[:digit:]{8}'
  47036294

• A custom combination: 7 uppercase, space, 7 lowercase, space, 2 digits

  $ repassgen '[:upper:]{7} [:lower:]{7} [:digit:]{2}'
  UOHMGVM toubgvs 73

• Password with length 12, using only Base64 characters

  $ repassgen '[:b64:]{12}'
  6+BA71WCy90I

• Password with length 12, using only URL-safe Base64 characters

  $ repassgen '[:b64url:]{12}'
  j15w_qTncikR

• Password with length 16, using only Crockford's Base32 characters (lowercase)

  $ repassgen '[:b32:]{16}'
  zmt87n9hpcd2w28h

• Password with length 16, using only Crockford's Base32 characters (uppercase)

  $ repassgen '[:B32:]{16}'
  HJ48VSR4Y0DHQ9EV

• Password with length 16, using Crockford's Base32 characters and punctuations

  $ repassgen '[:b32::punct:]{16}'
  20s:z.5mbwws474y

• Specify character range manually: lowercase alphebetic with length 16

  $ repassgen '[a-z]{16}'
  qefqiocrabpiaags

• Specify character range manually: alphanumeric with length 12

  $ repassgen '[a-zA-Z0-9]{12}'
  XcwDAagzMlwv

• Include non-random characters in the password (here: Test / , .)

  $ repassgen 'Test-[:alpha:]{4}/[:alpha:]{4},[:alpha:]{4}.[:alpha:]{4}'
  Test-Jcis/uLwq,SazR.CEFJ

• A 16-digit number similar to a credit card number

  repassgen '[:digit:]{4}-[:digit:]{4}-[:digit:]{4}-[:digit:]{4}'
  3996-9634-1459-0656

• Alphabetic password with a length between 12 and 16 characters

  $ repassgen '[:alpha:]{12,16}'
  uamePKmuUUUcI

• Gerenate random bytes, then run Base64 encode function

  $ repassgen '$base64($byte(){12})'
  bsOuN8KuRsOFw5jClkDDjMOrFA==

• Gerenate random bytes, then run Crockford's Base32 encode function

  $ repassgen '$base32($byte(){12})'
  c51e2kk1aafe3jngm3gxqrazpwqva

• Use - or [ or ] inside [...]

  $ repassgen '[.\- ]{50}'
  - .-.-- --.------- --.. -.---.-.. -- --..-..  .---

  $ repassgen '[a-z\[\]\-]{20}'
  nylhjcdq-qcaajvpcxuo

• Use whitespace characters like newline or tab (inside or outside [...])

  $ repassgen '[a-z\t]{5}\t[a-z\t]{5}\n[a-z\t]{10}'
  caelk	zccqm
  zpbgjba	pm

• Generate 12 random mnemonic words from BIP-39 English words

  $ repassgen '$bip39word(12)'
  cinnamon purity funny pigeon arrive equal foil alter life accident bar roast

• Generate 16 random bytes, then encode it to BIP-39 English mnemonic words

  $ repassgen '$bip39encode($byte(){16})'
  useful come fall plunge breeze side skill another boil expose essence about