Tension Software Password Creator

wkleem

I'll post this link from Tension Software here although I rarely use my Mac now. It may help someone as 1Password has a max 64 character limit on password generation. I am uncertain what Password Creator’s maximum is.

http://www.tensionsoftware.com/osx/passwordcreator/

It might also give Agilebits some ideas.

jpgoldberg

I would really like to offer a stand-alone password generator that uses our underlying engine, but exposes its full expressive power. Underlyingly our Strong Password Generator can do more than what is exposed in the UI.

Perhaps I will have a chance to get back to working on that.

wkleem

@jpgoldberg,

Thanks for giving a 1Passwors Generator App some thought.

AGAlumB

I'd love to see that too. It would just be weird if it had "1Password" in the name. Maybe "1nfnitePassword". :lol:

jpgoldberg

It would just be weird if [a password generator] had "1Password" in the name. Maybe "1nfnitePassword".

You're not wrong. But I'm going to get unnecessarily pedantic because I'm just in the mood to be. The maximum "length" that it will take is a signed golang int which is 2^63 - 1. This is length in units, that could be words from a word list. The maximum size wordlist this hands is a Uint32. So if you provide a maximum size wordlist and use the maximum number of words, then it would generate (2^32)^(2^63 - 1) distinct passwords.

But wait, there is more. This generator has the ability to randomly capitalize (actually Title-case) words. So if the word list is comprised solely of things with distinct capitalization (so the first character of each word must be a lowercase letter that can be capitalized) and that there aren't pairs like "polish" and "Polish" on the list then asking for random capitalization adds another 2^(63 - 1) possibilities.

So the maximum number for any one recipe will be (1 + 2^32)^(2^63 - 1). Yeah, sure. We can call that infinite.

Capitalization math

A note on capitalizability. Here is one of the test "word lists" we use to test the calculation of the entropy of generated passwords in the unit tests.

cl := []string{"正確", "Polish", "polish", "one", "two", "three", "4", "five", "one"}

This is in a test that also checks correct computation when there are duplicates on the supplied list.

If everything on the (de-duplicated) list can be capitalized to something that isn't otherwise on the list, then computing the strength added by setting to capitalization scheme to "random" is simple. It adds "length" bits, where length is the number of words in the list. But when some words on the list don't uniquely capitalize things get weird because we no longer get a uniform distribution. So if our word list contains just two words, "正確" and "word", and we set for random capitalization and a length of 2, these are the passwords we can generate.

word word
Word word
word Word
Word Word

正確 正確 // there are four different ways to get this identical result

正確 word // two ways to generate this
正確 Word // two ways to generate this

word 正確  // two ways to generate this
Word 正確  // two ways to generate this

So there are nine possible distinct outcomes through 16 ways to generate stuff, but the most likely is four times as likely as the least likely ones. And some are twice as likely as the least likely ones.

It is very hard to coherently define the strength of a password generation scheme which is non-uniform. I've argued that in these cases we should use min-entropy. That is, we look at the likelihood of the most common possible result out of all possibilities. This will work at to log2(16/4), which is exactly 2 bits. Calculating the min-entropy by tallying up the possibilities when we have a longer set of words is a computational nightmare, but it turns out to be identical to what we get if we just ignore that entropy contribution of random capitalization in the case where at least one word on the list doesn't capitalize nicely.

If our two words were "pass" and "word", then there would be 16 distinct outcomes, each equally likely, and so 3-bits would be correct strength for such a generation scheme.

Although this seems like ignoring a lot of randomness, as long as there is at least one word in the list, let's call it W, that can't be distinctly capitalized then it will always be possible for the generator to create a password that is just that word repeated L times (where L is the length of the passwords to be generated. So if L is 5, then we could generate a password

"W W W W W"

which could be generated 2^L ways, while any password that does not contain W can only be generated one way.

Note: I never would have worked this out correctly without the help of @rob.

Min-entropy

Using min-entropy does seem like a waste, but in the talk that I point to, I show that Shannon entropy (and other reasonable alternatives to min-entropy) can grossly over-estimate the strength of a non-uniform system. You can find the slides for the talk (view the PDF in "single page mode").

On the whole a password generator must produce things from a uniform distribution. The random capitalization scheme along with words that don't distinctly capitalize produce a non-uniform distribution, so we need to go with the most conservative estimate of the strength of generating passwords that way.

rob

"Unnecessarily pedantic" indeed, haha. :tongue: