A very flexible random password generator based on a regexp-like pattern, written in Golang
LGPL-3.0 License
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.
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.
{N}
{M,N}
[a-z1-579]
(...){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[\u00e0-\u00ef]{5}
\1
, \2
, etc[: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)repassgen -entropy 'PATTERN'
command[:alnum:]{8}
)$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 LatinAlphanumeric 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