well, if you right rotate instead, you can use chop.

sub rot_same
{
    my( $word )= @_;
    my %seen;

    for(1..length $word)
    {
        ## rotate right
        $word= chop($word) . $word;
        return 1 if exists $seen{$word};
        $seen{$word}++;
    }
}

print $_, ' => ', rot_same($_), $/ for qw(abcdef aaaaaa abcabc);

__END__
abcdef =>
aaaaaa => 1
abcabc => 1
[download]

and if you calculate the maximum number of same characters once, it will speed things up.

sub too_many_repetitions
{
    my( $word )= @_;
    my $same_char_percent= 0.5;

    my $max_same_char= $same_char_percent * length $word;

    my @chars= split // => $word;
    my %seen;

    $seen{$_}++ for @chars;
    return 1 if $max_same_char < pop @{[sort values %seen]};
}

print $_, ' => ', too_many_repetitions($_), $/ 
    for qw(abcdef aaaaaa abcabc);
__END__
abcdef =>
aaaaaa => 1
abcabc =>
[download]

~Particle *accelerates*

Since the title of this node includes the word summary I wanted to add this:

There is no such thing as a secure password and passwords aren't the end all of security. Even if the perfect program/script were to be written which was unbreakable, the password would still have it's greatest weakness in the user, who could tell someone the password, use it on a different non-secure site, or etc...

Not saying this directly to anyone, not even bronto, just wanted it added since this had the word summary. Besides that nice looking code and bronto++.

"Pain is weakness leaving the body, I find myself in pain everyday" -me

There is no such thing as a secure password and passwords aren't the end all of security. Even if the perfect program/script were to be written which was unbreakable, the password would still have it's greatest weakness in the user, who could tell someone the password, use it on a different non-secure site, or etc...

I agree with you. Nevertheless, applying security is like building walls around your systems, and doors on the walls; and none of the doors should be too easy to open.

A password is such a door. And every door should be secured as much as possible, compatibly with the environment around the system itself. Obviously, it doesn't make sense to have an uncatchable password when you leave yourself logged in on a publicly accessible terminal :-)

Ciao!
--bronto

---

The very nature of Perl to be like natural language--inconsistant and full of dwim and special cases--makes it impossible to know it all without simply memorizing the documentation (which is not complete or totally correct anyway).
--John M. Dlugosz

It looks like it will let pass your username with some disguise:

my $doubt= 'br0n7o1.';  #  (also 8r0n7o1.) reads bronto1.
is($ok,passcheck($username, $doubt, @userinfo), "$doubt is good");
[download]

Perhaps you should do some minimal conversion before checking for personal info, such as  tr/128075/izbots/.

Yesterday night I worked on your suggestion: unfortunately there are many symbols that cannot be mapped uniquely; for example the number 1 could well be mapped to 'l' and 'i' and 'I'; the same holds for other symbols that could be mapped to more than one letter. Taking each and every possibile combination could take a lot of time, and you are always leaving something out.

That's why I chose not to implement it even in a simple form. But if you have some efficient code that takes into account the special cases, you are welcome :-)

Ciao!
--bronto

---

The very nature of Perl to be like natural language--inconsistant and full of dwim and special cases--makes it impossible to know it all without simply memorizing the documentation (which is not complete or totally correct anyway).
--John M. Dlugosz

There is a simple way. Instead of checking if a password looks like a username, you can first translate the username into this sort of "code" and then check if they look the same. Something along the lines of

my %codes = (
  l => 1, L => 1,
  i => 1, I => 1,
  z => 2, Z => 2,
  e => 3, E => 3,
  h => 4, H => 4,
  s => 5, S => 5,
  G => 6, g => 9,
  t => 7, T => 7,
  b => 8, B => 8,
  o => 0, O => 0
  );
my $user = 'pileofdung';
my $translated;

for (split //, $user) {
    $translated .= (defined $codes{$_}) ?  $codes{$_} : $_;
}

print $translated,$/; # p1130fdun9

my $password = 'p113.0f.dun9%';

my $match =0;
for (split //, $translated) {
    $match++  if $password =~ /$_/
}
print "they match\n" if $match >= length($password) -2;
# you can choose how lax you want to be by
# setting an appropriate number of characters that
# you want to be different between username and password
# in this case if all but 2 characters are the same, it
# is a bad password
[download]

Of course, you can use any other comparing methods, but just to give you some ideas to play with.

sub passcheck2 {
  my ($u, $p) = splice @_, 2;
  "password ok" eq passcheck( $u, $p, @_ ) and
  "password ok" eq passcheck( $u, reverse($p), @_ )
}
[download]

I thought about it yesterday and implemented in my nightly programming session :-)

I am going to post the new code later

Ciao!
--bronto

Update: posted!, with a test script, too.

---

The very nature of Perl to be like natural language--inconsistant and full of dwim and special cases--makes it impossible to know it all without simply memorizing the documentation (which is not complete or totally correct anyway).
--John M. Dlugosz