#!/usr/bin/perl -w
#
# dicepass
# jms1 2013-05-31
#
# 2023-03-22 jms1 - support 'infnoise' to choose random numbers
# - this requires that the 'infnoise' program be available, that it have the
#   correct permissions to access the hardware (i.e. setuid root), and that
#   the hardware be physically plugged into the machine.
# - hardware: https://www.crowdsupply.com/leetronics/infinite-noise-trng
# - software: https://github.com/waywardgeek/infnoise
#
# 2023-06-08 jms1 - updated $wordfile to point to keybase public folder

require 5.003 ;
use strict ;

use Getopt::Std ;

my %opt         = () ;
my $wordfile    = '/keybase/public/jms1/diceware/words-4d10.txt' ;

my $rcount      = 0 ;
my $icount      = 0 ;

my %words       = () ;      # "0000" => "aaaaa" (or whatever it is)

###############################################################################
#
# usage

sub usage(;$)
{
    my $msg = ( shift || '' ) ;

    print <<EOF ;
$0 [-h] [-w ___] [-r ___] [-i ___] [n [...]]

Reads a diceware word list into memory. Looks up one or more numbers in the
list and prints the corresponding words.

-h      Show this help message.

-w ___  Specify the wordlist file. If not specified, the default is
        $wordfile

-r ___  Choose a number of random words from the file instead of specifying
        word numbers on the command line. (Yes, this defeats the whole purpose
        of rolling dice, but sometimes you need to generate a LOT of random
        passwords.)

-i ___  Run 'infnoise' to generate random numbers, rather than requiring
        numbers on the command line. Generate the specified number of random
        words.

EOF

    if ( $msg )
    {
        print $msg ;
        exit 1 ;
    }

    exit 0 ;
}

###############################################################################
#
# Use 'infnoise' to gather random bytes and return a random number
# between 0 and (x-1)

sub infnoise($)
{
    my $max = shift ;

#    print "DEBUG infnoise($max) starting\n" ;

    ########################################
    # Read $max random bytes into $buf

    open( I , 'infnoise |' )
        or die "ERROR: can't run \"infnoise\": $!\n" ;
    binmode I ;

    my $buf = '' ;
    my $n   = 0 ;

    while ( $n < $max )
    {
#        print "DEBUG \$n=$n reading ", $max - $n , " bytes\n" ;

        my $b = sysread( I , $buf , ( $max - $n ) , $n ) ;
        unless ( defined( $b ) )
        {
            die "ERROR: reading 'infnoise' output: $!\n" ;
        }

        if ( $b < 1 )
        {
            die "ERROR: reading 'infnoise' output: sysread() returned 0\n" ;
        }

#        print "DEBUG   \$b=$b\n" ;
        $n += $b ;
    }

    close I ;

    ########################################
    # Calculate the total MOD max

    my $t = 0 ;

    for my $c ( split( // , $buf ) )
    {
        $t += ord($c) ;
    }

#    print "DEBUG \$t=$t\n" ;

    my $rv = ( $t % $max ) ;
#    print "DEBUG returning $rv\n" ;

    return $rv ;
}

###############################################################################
###############################################################################
###############################################################################
#
# Parse the command line

getopts ( 'hw:r:i:' , \%opt ) ;
$opt{'h'} && usage() ;
$wordfile = ( $opt{'w'} || $wordfile ) ;
$rcount   = ( $opt{'r'} || 0 ) ;
$icount   = ( $opt{'i'} || 0 ) ;

########################################
# Make sure we have exactly one source of word numbers

my $ccount  = $#ARGV + 1 ;
my $nsrc    = ( $icount > 0 ? 1 : 0 ) + ( $rcount > 0 ? 1 : 0 ) + ( $ccount > 0 ? 1 : 0 ) ;

if ( $nsrc < 1 )
{
    usage() ;
}

if ( $nsrc > 1 )
{
    usage "ERROR: do not mix '-i', '-r', and numbers on the command line\n" ;
}

###############################################################################
#
# Read the wordlist into memory

open ( I , '<' , $wordfile )
        or die "can't read \"$wordfile\": $!\n" ;
while ( my $line = <I> )
{
    next unless ( $line =~ m|^(\d+)\s+(\S+)| ) ;
    $words{$1} = $2 ;
}
close I ;

my $nwords = scalar( keys %words ) ;

###############################################################################
#
# Select words

if ( $rcount > 0 )
{
    ########################################
    # Generate pseudo-random words

    my @wkey = sort keys %words ;

    while ( $rcount > 0 )
    {
        my $n   = int( rand( $nwords ) ) ;
        my $k   = $wkey[$n] ;
        my $v   = $words{$k} ;

        printf "%s\t%s\n" , $k , $v ;

        $rcount -- ;
    }
}
elsif ( $icount > 0 )
{
    ########################################
    # Generate truly-random words

    my @wkey = sort keys %words ;

    while ( $icount > 0 )
    {
        my $n   = infnoise( $nwords ) ;
        my $k   = $wkey[$n] ;
        my $v   = $words{$k} ;

        printf "%s\t%s\n" , $k , $v ;

        $icount -- ;
    }
}
else
{
    ########################################
    # Process numbers from the command line

    while ( my $k = shift @ARGV )
    {
        printf "%s\t%s\n" , $k , ( ( exists $words{$k} ) ? $words{$k} : '(null)' ) ;
    }
}