Re: OT:Password strength
On 2014-12-03 Wed 15:04 PM |, Ted Unangst wrote: If you want strong, short passwords that look ridiculous: dd if=/dev/random bs=1 count=9 | b64encode password $ pkg_info apg Information for inst:apg-2.2.3p0 Comment: automated password generator Description: APG (Automated Password Generator) is the tool set for random password generation. It features: a built-in ANSI X9.17 RNG (Random Number Generator)(CAST/SHA1), two methods for password generation: FIPS 181 and truly random, configurable lengths and numbers of passwords. Two components are supported, a network daemon (apgd) and a command line client (apg). The command line tool does not require the network daemon. Maintainer: The OpenBSD ports mailing-list po...@openbsd.org WWW: http://www.adel.nursat.kz/apg/ Cheers -- 3 days of follk music dancing in the Scottish Highlands: https://twitter.com/Craig_Skinner/status/525669043756630016
Re: OT:Password strength
On Sun, Nov 30, 2014 at 04:21:50PM -0500, Ted Unangst wrote: On Sun, Nov 30, 2014 at 15:37, thornton.rich...@gmail.com wrote: Where do you store these passwords? On a napkin? Wherever you like. A shorter password with all the o's turned into 0's is hardly more secure. I'd say on a napkin until you remember it; which doesn't take long if you use it several times a day. Tor
Re: OT:Password strength
On 11/30/14 15:20, Ted Unangst wrote: Examples: treetykaveprethicooputhedu soonataviceenoopatecoge gootrozapiceelytrithunula preezypeendothanundipeesooka That defeats the purpose of the second example in the OPs question. -- This message has been scanned for viruses and dangerous content by MailScanner, and is believed to be clean.
Re: OT:Password strength
On Wed, Dec 03, 2014 at 08:27, Brad Smith wrote: On 11/30/14 15:20, Ted Unangst wrote: Examples: treetykaveprethicooputhedu soonataviceenoopatecoge gootrozapiceelytrithunula preezypeendothanundipeesooka That defeats the purpose of the second example in the OPs question. If you want strong, short passwords that look ridiculous: dd if=/dev/random bs=1 count=9 | b64encode password
Re: OT:Password strength
On 12/03/2014 12:04 PM, Ted Unangst wrote: On Wed, Dec 03, 2014 at 08:27, Brad Smith wrote: On 11/30/14 15:20, Ted Unangst wrote: Examples: treetykaveprethicooputhedu soonataviceenoopatecoge gootrozapiceelytrithunula preezypeendothanundipeesooka That defeats the purpose of the second example in the OPs question. If you want strong, short passwords that look ridiculous: dd if=/dev/random bs=1 count=9 | b64encode password And then try to remember that mess, or type it, especially into a smartphone. Gaak! 8-O -- Those who do not understand Unix are condemned to reinvent it, poorly.
Re: OT:Password strength
On December 3, 2014 9:10:42 PM CET, Jason Adams adams...@gmail.com wrote: On 12/03/2014 12:04 PM, Ted Unangst wrote: On Wed, Dec 03, 2014 at 08:27, Brad Smith wrote: On 11/30/14 15:20, Ted Unangst wrote: Examples: treetykaveprethicooputhedu soonataviceenoopatecoge gootrozapiceelytrithunula preezypeendothanundipeesooka That defeats the purpose of the second example in the OPs question. If you want strong, short passwords that look ridiculous: dd if=/dev/random bs=1 count=9 | b64encode password And then try to remember that mess, or type it, especially into a smartphone. Gaak! 8-O base64 ain't that bad, but might lack those special symbols which we all know makes all the difference between a bad and a good password...
Re: [Bulk] Re: OT:Password strength
On Wed, 03 Dec 2014 22:53:22 +0100
Alexander Hall wrote:
If you want strong, short passwords that look ridiculous:
dd if=/dev/random bs=1 count=9 | b64encode password
And then try to remember that mess, or type it, especially into
a smartphone. Gaak! 8-O
base64 ain't that bad, but might lack those special symbols which we all know
makes all the difference between a bad and a good password...
This is what I came up with
#!/bin/sh
n=$1
max=500
rn=$(($RANDOM %max + 1 ))
[[ -n $n ]] || n=12
if [[ $n -lt 8 ]]; then
echo Using 12 as the password length, a length of $n would be too weak
fi
rn2=$rn
let rn2=$rn2+$n-1
p=$( /bin/dd if=/dev/urandom bs=2000 count=1 2/dev/null | tr -cd
a-zA-Z0-9?.,!\-()@/:_;+%*=$[]{}/\~^#| | cut -c $rn-$rn2 )
echo ${p}
Re: OT:Password strength
On 12/03/14 15:04, Ted Unangst wrote: On Wed, Dec 03, 2014 at 08:27, Brad Smith wrote: On 11/30/14 15:20, Ted Unangst wrote: Examples: treetykaveprethicooputhedu soonataviceenoopatecoge gootrozapiceelytrithunula preezypeendothanundipeesooka That defeats the purpose of the second example in the OPs question. If you want strong, short passwords that look ridiculous: dd if=/dev/random bs=1 count=9 | b64encode password Still not getting it. -- This message has been scanned for viruses and dangerous content by MailScanner, and is believed to be clean.
Re: OT:Password strength
On Wed, Dec 3, 2014, at 08:27 AM, Brad Smith wrote: On 11/30/14 15:20, Ted Unangst wrote: Examples: treetykaveprethicooputhedu soonataviceenoopatecoge gootrozapiceelytrithunula preezypeendothanundipeesooka That defeats the purpose of the second example in the OPs question. I think I like Schneier's scheme: So if you want your password to be hard to guess, you should choose something that this process will miss. My advice is to take a sentence and turn it into a password. Something like This little piggy went to market might become tlpWENT2m. That nine-character password won't be in anyone's dictionary. Of course, don't use this one, because I've written about it. Choose your own sentence -- something personal. https://www.schneier.com/blog/archives/2014/03/choosing_secure_1.html This scheme generates long hard passwords that are fairly easy to remember. And if I had read this article first I never would have asked my original question. Thanks to all who contributed, but I think we can kill this thread now.
Re: OT:Password strength
From owner-misc+M145030=deraadt=cvs.openbsd@openbsd.org Wed Dec 3 20:37:28 2014 Delivered-To: dera...@cvs.openbsd.org DKIM-Signature: v=1; a=rsa-sha1; c=relaxed/relaxed; d=fastmail.net; h= message-id:x-sasl-enc:from:to:cc:mime-version :content-transfer-encoding:content-type:subject:date:in-reply-to :references; s=mesmtp; bh=N05hQ0kRdtamdXiI1uPUYYy4D/4=; b=iA54AY ZyBQ3QX5T6ydBrioyWSy2EirHi4z0WRKUcPO8g1TG5UXqeODEtuA0N/7HR0Vfqpf IxWfA/cECXnW2CRgxfbAuLyM5lC6/aNxeOYMQFWk4lvk2bG5OQ9LlI3YfD8t03aG aGpj4kEdGlfRI82Ol9CYUc2K/x6LeqSGdRLZE= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed/relaxed; d= messagingengine.com; h=message-id:x-sasl-enc:from:to:cc :mime-version:content-transfer-encoding:content-type:subject :date:in-reply-to:references; s=smtpout; bh=N05hQ0kRdtamdXiI1uPU YYy4D/4=; b=EmDvqWm+BO76xbaxG50X0DaOQVnloAlOTlWNz4FVQpekab134n7N R2VEC9YywqMmdYI2nLDXYQ3eDh5yj0f+ordWvFaWPidz+GxTJ3EM1ZU30ywQVMPJ CSbO/+h4Cw4xQklCxk602nePjo/RtEELvBXDOz1tflZDcDMoy83HG+Y= X-Sasl-Enc: MhT9Z3YiPDIsQoZKvCLrU99Bm5DjpuN8O7iVQLFa843l 1417664177 From: Eric Furman ericfur...@fastmail.net To: Brad Smith b...@comstyle.com Cc: Ted Unangst t...@tedunangst.com, OpenBSD Misc misc@openbsd.org MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Content-Type: text/plain X-Mailer: MessagingEngine.com Webmail Interface - html Subject: Re: OT:Password strength Date: Wed, 03 Dec 2014 22:36:17 -0500 In-Reply-To: 547f0fb8.6070...@comstyle.com References: 1417316824.2046833.196840165.39fa2...@webmail.messagingengine.com 9ea3e8f9bed545a68834d6bd42a0a...@tedunangst.com 547f0fb8.6070...@comstyle.com List-Help: mailto:majord...@openbsd.org?body=help List-ID: misc.openbsd.org List-Owner: mailto:owner-m...@openbsd.org List-Post: mailto:misc@openbsd.org List-Subscribe: mailto:majord...@openbsd.org?body=sub%20misc List-Unsubscribe: mailto:majord...@openbsd.org?body=unsub%20misc X-Loop: misc@openbsd.org Precedence: list Sender: owner-m...@openbsd.org On Wed, Dec 3, 2014, at 08:27 AM, Brad Smith wrote: On 11/30/14 15:20, Ted Unangst wrote: Examples: treetykaveprethicooputhedu soonataviceenoopatecoge gootrozapiceelytrithunula preezypeendothanundipeesooka That defeats the purpose of the second example in the OPs question. I think I like Schneier's scheme: So if you want your password to be hard to guess, you should choose something that this process will miss. My advice is to take a sentence and turn it into a password. Something like This little piggy went to market might become tlpWENT2m. That nine-character password won't be in anyone's dictionary. Of course, don't use this one, because I've written about it. Choose your own sentence -- something personal. https://www.schneier.com/blog/archives/2014/03/choosing_secure_1.html This scheme generates long hard passwords that are fairly easy to remember. And if I had read this article first I never would have asked my original question. Thanks to all who contributed, but I think we can kill this thread now.
Re: OT:Password strength
On Sat, Nov 29, 2014 at 22:07, Eric Furman wrote:
OFF TOPIC. This has nothing to do with OpenBSD,
but a lot of guys here know about this stuff.
I've done some reading, but still not sure.
OK, at the risk of looking stupid,which of these passwords is better;
kMH65?3
or
mylittlelambjumpedovertenredbarns
I think it's a mistake to reverse a password into entropy. If your
pool of possible passwords is sentences from common nursery rhymes,
for example, they may look awesome but in reality there are only a few
thousand possibilities.
Instead, pick a generating algorithm. It can be random letters, random
symbols, whatever. Random words. Random fake words consisting of
alternating consonants and vowels. You know how big the search space
is for each atom. Divide desired password strength (e.g. 64 bits) by
bits per atom to determine required number of atoms.
For the consonant/vowel example, here's a luajit script that makes
passwords. Even though they are all lower case, they are at least 64
bits hard.
local letters = {
c, k, t, tr, rt, p, pr, d,
v, n, l, nd, z, g, th, s }
local vowels = { a, e, i, o, u, y, oo, ee }
local letterbits = 4
local vowelbits = 3
local wantedbits = 64
local bits = 0
local ffi = require ffi
ffi.cdef[[uint32_t arc4random_uniform(uint32_t);]]
local function rand(max)
return ffi.C.arc4random_uniform(max) + 1
end
local atoms = { }
while bits wantedbits do
table.insert(atoms, letters[rand(16)])
table.insert(atoms, vowels[rand(8)])
bits = bits + letterbits + vowelbits
end
print(table.concat(atoms))
Examples:
treetykaveprethicooputhedu
soonataviceenoopatecoge
gootrozapiceelytrithunula
preezypeendothanundipeesooka
Re: OT:Password strength
Examples: treetykaveprethicooputhedu soonataviceenoopatecoge gootrozapiceelytrithunula preezypeendothanundipeesooka These stand no chance against a finnish attacker! Miod
Re: OT:Password strength
Where do you store these passwords? On a napkin?
Original Message
From: Ted Unangst
Sent: Sunday, November 30, 2014 3:21 PM
To: Eric Furman
Cc: OpenBSD Misc
Subject: Re: OT:Password strength
On Sat, Nov 29, 2014 at 22:07, Eric Furman wrote:
OFF TOPIC. This has nothing to do with OpenBSD,
but a lot of guys here know about this stuff.
I've done some reading, but still not sure.
OK, at the risk of looking stupid,which of these passwords is better;
kMH65?3
or
mylittlelambjumpedovertenredbarns
I think it's a mistake to reverse a password into entropy. If your
pool of possible passwords is sentences from common nursery rhymes,
for example, they may look awesome but in reality there are only a few
thousand possibilities.
Instead, pick a generating algorithm. It can be random letters, random
symbols, whatever. Random words. Random fake words consisting of
alternating consonants and vowels. You know how big the search space
is for each atom. Divide desired password strength (e.g. 64 bits) by
bits per atom to determine required number of atoms.
For the consonant/vowel example, here's a luajit script that makes
passwords. Even though they are all lower case, they are at least 64
bits hard.
local letters = {
c, k, t, tr, rt, p, pr, d,
v, n, l, nd, z, g, th, s }
local vowels = { a, e, i, o, u, y, oo, ee }
local letterbits = 4
local vowelbits = 3
local wantedbits = 64
local bits = 0
local ffi = require ffi
ffi.cdef[[uint32_t arc4random_uniform(uint32_t);]]
local function rand(max)
return ffi.C.arc4random_uniform(max) + 1
end
local atoms = { }
while bits wantedbits do
table.insert(atoms, letters[rand(16)])
table.insert(atoms, vowels[rand(8)])
bits = bits + letterbits + vowelbits
end
print(table.concat(atoms))
Examples:
treetykaveprethicooputhedu
soonataviceenoopatecoge
gootrozapiceelytrithunula
preezypeendothanundipeesooka
Re: OT:Password strength
On Sun, Nov 30, 2014 at 15:37, thornton.rich...@gmail.com wrote: Where do you store these passwords? On a napkin? Wherever you like. A shorter password with all the o's turned into 0's is hardly more secure.
Re: OT:Password strength
I get why network admins and CIO types live and breath security and hardened passwords, but the average user has gone mad. I like leading alpha characters in combination with an old phone number, with a few non-alpha characters, leading and trailing. Thus a password that I can remember, but not something easy to guess. Example: I worked at Empire Blue Cross 20 years ago. My phone was x3699. 212 476 3699. Thus say, =EmpBC3699 would be fairly good, and I could recall it without writing it down. One could say that 3699 is too easy, perhaps, buts its a quick example of a easy analog way to create a password which is ok, and easy to remember. Original Message From: Ted Unangst Sent: Sunday, November 30, 2014 4:21 PM To: thornton.rich...@gmail.com Cc: Eric Furman; OpenBSD Misc Subject: Re: OT:Password strength On Sun, Nov 30, 2014 at 15:37, thornton.rich...@gmail.com wrote: Where do you store these passwords? On a napkin? Wherever you like. A shorter password with all the o's turned into 0's is hardly more secure.
Re: OT:Password strength
On Sun, Nov 30, 2014, at 05:02 PM, thornton.rich...@gmail.com wrote: I get why network admins and CIO types live and breath security and hardened passwords, but the average user has gone mad. I like leading alpha characters in combination with an old phone number, with a few non-alpha characters, leading and trailing. Thus a password that I can remember, but not something easy to guess. Example: I worked at Empire Blue Cross 20 years ago. My phone was x3699. 212 476 3699. Thus say, =EmpBC3699 would be fairly good, and I could recall it without writing it down. One could say that 3699 is too easy, perhaps, buts its a quick example of a easy analog way to create a password which is ok, and easy to remember. But according to this article; https://www.schneier.com/blog/archives/2007/01/choosing_secure.html if an attacker did have some of this personal info your password would be easy to crack.
Re: OT:Password strength
On Sun, Nov 30, 2014, at 03:20 PM, Ted Unangst wrote:
On Sat, Nov 29, 2014 at 22:07, Eric Furman wrote:
OFF TOPIC. This has nothing to do with OpenBSD,
but a lot of guys here know about this stuff.
I've done some reading, but still not sure.
OK, at the risk of looking stupid,which of these passwords is better;
kMH65?3
or
mylittlelambjumpedovertenredbarns
I think it's a mistake to reverse a password into entropy. If your
pool of possible passwords is sentences from common nursery rhymes,
for example, they may look awesome but in reality there are only a few
thousand possibilities.
Instead, pick a generating algorithm. It can be random letters, random
symbols, whatever. Random words. Random fake words consisting of
alternating consonants and vowels. You know how big the search space
is for each atom. Divide desired password strength (e.g. 64 bits) by
bits per atom to determine required number of atoms.
For the consonant/vowel example, here's a luajit script that makes
passwords. Even though they are all lower case, they are at least 64
bits hard.
local letters = {
c, k, t, tr, rt, p, pr, d,
v, n, l, nd, z, g, th, s }
local vowels = { a, e, i, o, u, y, oo, ee }
local letterbits = 4
local vowelbits = 3
local wantedbits = 64
local bits = 0
local ffi = require ffi
ffi.cdef[[uint32_t arc4random_uniform(uint32_t);]]
local function rand(max)
return ffi.C.arc4random_uniform(max) + 1
end
local atoms = { }
while bits wantedbits do
table.insert(atoms, letters[rand(16)])
table.insert(atoms, vowels[rand(8)])
bits = bits + letterbits + vowelbits
end
print(table.concat(atoms))
Examples:
treetykaveprethicooputhedu
soonataviceenoopatecoge
gootrozapiceelytrithunula
preezypeendothanundipeesooka
Bruce Schneier agrees. :)
According to him modern password crackers find string of word passwords,
like in XKCD, to be easy to crack.
https://www.schneier.com/blog/archives/2014/03/choosing_secure_1.html
But I can't always use a password manager and those passwords are
impossible to remember.
Re: OT:Password strength
On Sun, Nov 30, 2014, at 12:48 AM, Nick Holland wrote: On 11/29/14 22:06, Eric Furman wrote: OFF TOPIC. This has nothing to do with OpenBSD, but a lot of guys here know about this stuff. I've done some reading, but still not sure. OK, at the risk of looking stupid,which of these passwords is better; kMH65?3 or mylittlelambjumpedovertenredbarns there's an XKCD comic along these lines. I'm too lazy to dig it up. It's complicated. Both have eight things. The later is drawn from a much much larger set (words (thousands), vs. characters (not 100)). So, looks like a simple win for the second over the first, right? Problem is the words connect to humans. little is more likely to be followed by lamb than it is red (though if red follows little I bet the next word would be wagon). red is more likely to be followed by barn than lamb. Still, there's a huge number of choices for each word, so I'd say the phrases still win. (sorta related side note: At least with names, there's some curious clusters that are seen -- for example, a friend of mine and her two siblings have (basically) the same names as three of Adolph Hitler's siblings (one is a slight stretch, the other two are dead-on, which is impressive considering the very different ethnic backgrounds). I don't think my friend's parents would have permitted this had they known. I've seen similar groupings of names in other families. (Did I just win the award for most unexpected use of hitler in an internet discussion?)) Simply saying there are X words of five letters or less and there are eight of them in my pw means there are X^8 PWs someone would have to try to get my PW is wrong by probably several orders of magnitude. That's not how humans pick passwords, and if the computer does it for you, it might be as hard or harder than if you use random characters. Then there is the system where it is stored. If you are working on a stock Solaris 9 or AIX system with the default settings, only the first eight chars are used, so the random string is much better than mylittle, and if you, like most people, reuse passwords or don't know that the target system only uses the first eight characters, you can end up using a trivial pw that you thought was really good. Yes, part of the reason for asking this question was that I am aware that some authentication schemes only use the first 8 characters. Is there any way of knowing if they do ignore any characters after the first eight? Are authentication schemes that don't recognize more than eight characters still common? One of my banking sites won't except certain special characters. Like $, %, ? Which messes up my best short passwords that I actually remember.
Re: OT:Password strength
On Sun, November 30, 2014 8:09 pm, Eric Furman wrote: On Sun, Nov 30, 2014, at 12:48 AM, Nick Holland wrote: lots snipped Then there is the system where it is stored. If you are working on a stock Solaris 9 or AIX system with the default settings, only the first eight chars are used, so the random string is much better than mylittle, and if you, like most people, reuse passwords or don't know that the target system only uses the first eight characters, you can end up using a trivial pw that you thought was really good. Yes, part of the reason for asking this question was that I am aware that some authentication schemes only use the first 8 characters. Is there any way of knowing if they do ignore any characters after the first eight? sure. after setting your password to more than eight characters, try logging in by entering just the first eight characters. Are authentication schemes that don't recognize more than eight characters still common? try it and see. One of my banking sites won't except certain special characters. Like $, %, ? Which messes up my best short passwords that I actually remember. i too find it annoying when the set of valid password characters is not listed somewhere easy for the user to find. -wes
Re: OT:Password strength
On Sun, 30 Nov 2014, Miod Vallat wrote: From: Miod Vallat m...@online.fr To: Ted Unangst t...@tedunangst.com Cc: Eric Furman ericfur...@fastmail.net, OpenBSD Misc misc@openbsd.org Date: Sun, 30 Nov 2014 20:34:01 Subject: Re: OT:Password strength Examples: treetykaveprethicooputhedu soonataviceenoopatecoge gootrozapiceelytrithunula preezypeendothanundipeesooka These stand no chance against a finnish attacker! Are you sure? I thought these passwords would be low-hanging fruit for the Swedish chef from the Muppets[1]. [1] http://en.wikipedia.org/wiki/Swedish_Chef -- Dennis Davis dennisda...@fastmail.fm
Re: OT:Password strength
On Sun, Nov 30, 2014 at 7:00 PM, david...@ling.ohio-state.edu wrote: On Sun, November 30, 2014 8:09 pm, Eric Furman wrote: On Sun, Nov 30, 2014, at 12:48 AM, Nick Holland wrote: lots snipped Then there is the system where it is stored. If you are working on a stock Solaris 9 or AIX system with the default settings, only the first eight chars are used, so the random string is much better than mylittle, and if you, like most people, reuse passwords or don't know that the target system only uses the first eight characters, you can end up using a trivial pw that you thought was really good. Yes, part of the reason for asking this question was that I am aware that some authentication schemes only use the first 8 characters. Is there any way of knowing if they do ignore any characters after the first eight? sure. after setting your password to more than eight characters, try logging in by entering just the first eight characters. Are authentication schemes that don't recognize more than eight characters still common? try it and see. One of my banking sites won't except certain special characters. Like $, %, ? Which messes up my best short passwords that I actually remember. i too find it annoying when the set of valid password characters is not listed somewhere easy for the user to find. -wes -- Darren Spruell phatbuck...@gmail.com
OT:Password strength
OFF TOPIC. This has nothing to do with OpenBSD, but a lot of guys here know about this stuff. I've done some reading, but still not sure. OK, at the risk of looking stupid,which of these passwords is better; kMH65?3 or mylittlelambjumpedovertenredbarns
Re: OT:Password strength
The latter, I would bet. On 11/29/2014 10:07 PM, Eric Furman wrote: OFF TOPIC. This has nothing to do with OpenBSD, but a lot of guys here know about this stuff. I've done some reading, but still not sure. OK, at the risk of looking stupid,which of these passwords is better; kMH65?3 or mylittlelambjumpedovertenredbarns
Re: OT:Password strength
On 30.11.2014 04:07, Eric Furman wrote: OFF TOPIC. This has nothing to do with OpenBSD, but a lot of guys here know about this stuff. I've done some reading, but still not sure. OK, at the risk of looking stupid,which of these passwords is better; kMH65?3 or mylittlelambjumpedovertenredbarns Nice updated FAQ about that http://www.baekdal.com/insights/the-usability-of-passwords-faq (on start it links to original worth-to-read article)
Re: OT:Password strength
On 11/29/14 22:06, Eric Furman wrote: OFF TOPIC. This has nothing to do with OpenBSD, but a lot of guys here know about this stuff. I've done some reading, but still not sure. OK, at the risk of looking stupid,which of these passwords is better; kMH65?3 or mylittlelambjumpedovertenredbarns there's an XKCD comic along these lines. I'm too lazy to dig it up. It's complicated. Both have eight things. The later is drawn from a much much larger set (words (thousands), vs. characters (not 100)). So, looks like a simple win for the second over the first, right? Problem is the words connect to humans. little is more likely to be followed by lamb than it is red (though if red follows little I bet the next word would be wagon). red is more likely to be followed by barn than lamb. Still, there's a huge number of choices for each word, so I'd say the phrases still win. (sorta related side note: At least with names, there's some curious clusters that are seen -- for example, a friend of mine and her two siblings have (basically) the same names as three of Adolph Hitler's siblings (one is a slight stretch, the other two are dead-on, which is impressive considering the very different ethnic backgrounds). I don't think my friend's parents would have permitted this had they known. I've seen similar groupings of names in other families. (Did I just win the award for most unexpected use of hitler in an internet discussion?)) Simply saying there are X words of five letters or less and there are eight of them in my pw means there are X^8 PWs someone would have to try to get my PW is wrong by probably several orders of magnitude. That's not how humans pick passwords, and if the computer does it for you, it might be as hard or harder than if you use random characters. Then there is the system where it is stored. If you are working on a stock Solaris 9 or AIX system with the default settings, only the first eight chars are used, so the random string is much better than mylittle, and if you, like most people, reuse passwords or don't know that the target system only uses the first eight characters, you can end up using a trivial pw that you thought was really good. If the back-end storage gives away the length of the pw in any way and you see the pw is 33 chars long, you can probably bet it isn't going to be random characters, so you would probably set your PW guesser to use dictionary words rather than random characters, reducing the advantage. Which is easier to remember for real people? Which is easier to type? No contest -- and for that reason, I'd say the overall benefit is with the string of eight words over the string of eight random characters. But... Realistically, most attacks seem to be based on breaking TRIVIAL passwords, social engineering, or use software flaws that permit access to things that allow access to things that allow access to things ...so either is probably more than sufficient to make sure that a password guess of either of those accounts was NOT the reason for a security breach. Kinda like escaping from a hungry lion...you don't need to outrun the lion, you just need to outrun your friend. You don't need an unbreakable password, you just need one better than management uses, and you can't be able to be blamed for the breach. Anything more than that is probably wasted effort. If there is a breach that permits the download of the hashed PW file, both may be similarly prone to off-line brute-forcing. Sounds cynical, but really, if you are arguing over which is the better password, you are wasting time that should be spent looking for more likely security problems. That kinda brings it back to OpenBSD for you. :) Nick.
Re: OT:Password strength
On 30.11.2014 06:48, Nick Holland wrote: On 11/29/14 22:06, Eric Furman wrote: OFF TOPIC. This has nothing to do with OpenBSD, but a lot of guys here know about this stuff. I've done some reading, but still not sure. OK, at the risk of looking stupid,which of these passwords is better; kMH65?3 or mylittlelambjumpedovertenredbarns there's an XKCD comic along these lines. I'm too lazy to dig it up. You mean this one I think http://xkcd.com/936/ It's complicated. Both have eight things. The later is drawn from a much much larger set (words (thousands), vs. characters (not 100)). So, looks like a simple win for the second over the first, right? Problem is the words connect to humans. little is more likely to be followed by lamb than it is red (though if red follows little I bet the next word would be wagon). red is more likely to be followed by barn than lamb. Still, there's a huge number of choices for each word, so I'd say the phrases still win. (sorta related side note: At least with names, there's some curious clusters that are seen -- for example, a friend of mine and her two siblings have (basically) the same names as three of Adolph Hitler's siblings (one is a slight stretch, the other two are dead-on, which is impressive considering the very different ethnic backgrounds). I don't think my friend's parents would have permitted this had they known. I've seen similar groupings of names in other families. (Did I just win the award for most unexpected use of hitler in an internet discussion?)) Simply saying there are X words of five letters or less and there are eight of them in my pw means there are X^8 PWs someone would have to try to get my PW is wrong by probably several orders of magnitude. That's not how humans pick passwords, and if the computer does it for you, it might be as hard or harder than if you use random characters. Then there is the system where it is stored. If you are working on a stock Solaris 9 or AIX system with the default settings, only the first eight chars are used, so the random string is much better than mylittle, and if you, like most people, reuse passwords or don't know that the target system only uses the first eight characters, you can end up using a trivial pw that you thought was really good. If the back-end storage gives away the length of the pw in any way and you see the pw is 33 chars long, you can probably bet it isn't going to be random characters, so you would probably set your PW guesser to use dictionary words rather than random characters, reducing the advantage. Which is easier to remember for real people? Which is easier to type? No contest -- and for that reason, I'd say the overall benefit is with the string of eight words over the string of eight random characters. But... Realistically, most attacks seem to be based on breaking TRIVIAL passwords, social engineering, or use software flaws that permit access to things that allow access to things that allow access to things ...so either is probably more than sufficient to make sure that a password guess of either of those accounts was NOT the reason for a security breach. Kinda like escaping from a hungry lion...you don't need to outrun the lion, you just need to outrun your friend. You don't need an unbreakable password, you just need one better than management uses, and you can't be able to be blamed for the breach. Anything more than that is probably wasted effort. If there is a breach that permits the download of the hashed PW file, both may be similarly prone to off-line brute-forcing. Yeah you can do a lot for eg. friend's computer, but then he will start to use regular browser and JavaScript and such and then suddenly most of that you done doesn't matter anymore http://www.youtube.com/watch?v=0QT4YJn7oVI :-) Sounds cynical, but really, if you are arguing over which is the better password, you are wasting time that should be spent looking for more likely security problems. That kinda brings it back to OpenBSD for you. :) Nick.
