#! /usr/bin/perl

# hash-md5-salt -- generate salted hashes using crypt(3).
#                  Check if plain text matches a given salted hash.

# Copyright (C) 2015  Nick Urbanik <nicku@nicku.org>

# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.

# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.

# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

use strict;
use warnings;
use Getopt::Long;

my %LEN = ( 1 => 8, 5 => 12, 6 => 16 );

sub usage {
    ( my $prog = $0 ) =~ s{.*/}{};
    print <<END_USAGE;
$prog [--debug] [--quiet] CLEAR_PASS [SALT]
$prog [--help]

If SALT is of the form \$1\$ or \$5\$ or \$6\$, then we generate a salt
of length $LEN{1} for \$1\$, $LEN{5} for \$5\$ or $LEN{6} for \$6\$.

If no SALT is provided, then work the same as if \$1\$ were provided.

We use Math::Random::Secure to generate the salt if it is available
otherwise just rand.  We warn if using plain rand; it is not
cryptographically secure.

--quiet suppresses a warning if Math::Random::Secure is not available.

You can provide the original hash, complete as the SALT.
The result will be the same if CLEAR_PASS matches.

From man 3 crypt:

If salt is a  character  string  starting  with  the  characters
"\$id\$" followed by a string terminated by "\$":

      \$id\$salt\$encrypted

then instead of using the DES machine, id identifies the encryp‐
tion method used and this then determines how the  rest  of  the
password  string is interpreted.  The following values of id are
supported:

       ID  | Method
       ─────────────────────────────────────────────────────────
       1   | MD5
       2a  | Blowfish (not in mainline glibc; added in some
           | Linux distributions)
       5   | SHA-256 (since glibc 2.7)
       6   | SHA-512 (since glibc 2.7)

So  \$5\$salt\$encrypted  is  an  SHA-256  encoded   password   and
\$6\$salt\$encrypted is an SHA-512 encoded one.

"salt"  stands  for  the up to 16 characters following "\$id\$" in
the salt.  The encrypted part of  the  password  string  is  the
actual computed password.  The size of this string is fixed:

MD5     | 22 characters
SHA-256 | 43 characters
SHA-512 | 86 characters

The  characters in "salt" and "encrypted" are drawn from the set
[a-zA-Z0-9./].  In the MD5 and SHA  implementations  the  entire
key is significant.
END_USAGE
    exit 0;
}

my @LEGAL = ( 'a' .. 'z', 'A' .. 'Z', '0' .. '9', q{.} );

GetOptions(
    help => \&usage,
    debug => \my $debug,
    quiet => \my $quiet,
) or usage;

sub random {
    my ( $upper ) = @_;
    eval {
        require Math::Random::Secure;
    };
    if ( $@ ) {
        warn "Math::Random::Secure not installed: using plain rand\n"
            unless $quiet;
        return rand $upper;
    }
    return Math::Random::Secure::irand $upper;
}

sub gensalt {
    my ( $len ) = @_;
    $len ||= 8;
    return join q{}, map { $LEGAL[ random( scalar @LEGAL ) ] } 1 .. $len;
}

my $clear = shift or usage;
my $salt  = shift || '$1$';

# Deal specially with the case where SALT is of the form $1$, $5$ or $6$.
if ( $salt =~ m{^\$([156])\$$} ) {
    my $len = $LEN{$1};
    $salt .= gensalt( $len ) . q{$};
}

print "SALT='$salt'\n" if $debug;

$salt = "\$1\$$salt\$" unless $salt =~ m{^\$[156]\$[^\$]{2,}};

print "SALT2='$salt'\n" if $debug;

my $hash = crypt $clear, $salt;

print "$hash\n";

my $match;

if ( length $hash eq length $salt ) {
    $match = $hash eq $salt ? 'MATCHES' : 'NO MATCH';
    print "$match\n";
}