Once you know how a computer represents single characters, it is not difficult to go from random numbers to random strings. This section will present a technique for creating difficult-to-guess passwords based on the Go code of randomNumbers.go, which was presented in the previous section. The name of the Go program for this task will be generatePassword.go, and it will be presented in four parts. The utility requires just one command-line parameter, which is the length of the password that you want to generate.

The first part of generatePassword.go contains the following Go code:

package main 
 
import ( 
    "fmt" 
    "math/rand" 
    "os" 
    "strconv" 
    "time" 
) 
 
func random(min, max int) int { 
    return rand.Intn(max-min) + min 
} 

The second code portion of generatePassword.go contains the following Go code:

func main() { 
    MIN := 0 
    MAX := 94 
    SEED := time.Now().Unix() 
    var LENGTH int64 = 8 
 
    arguments := os.Args 

As we only want to get printable ASCII characters, we limit the range of random numbers that can be generated. The number of printable characters in the ASCII table is 94. This means that the range of the random numbers that the program can generate should be from 0 to 94, not including 94.

The third code segment of generatePassword.go is shown in the following Go code:

    switch len(arguments) { 
    case 2: 
            LENGTH, _ = strconv.ParseInt(os.Args[1], 10, 64) 
    default: 
            fmt.Println("Using default values!") 
    } 
 
    rand.Seed(SEED) 

The last part of generatePassword.go is as follows:

    startChar := "!" 
    var i int64 = 1 
    for { 
            myRand := random(MIN, MAX) 
            newChar := string(startChar[0] + byte(myRand)) 
            fmt.Print(newChar) 
            if i == LENGTH { 
                    break 
            } 
            i++ 
    } 
    fmt.Println() 
} 

The startChar variable holds the first ASCII character that can be generated by the utility, which in this case is the exclamation mark that has a decimal ASCII value of 33. Given that the program can generate random numbers up to 94, the maximum ASCII value that can be generated is 93 + 33, which is equal to 126, which is the ASCII value of ~. The following output shows the ASCII table with the corresponding decimal values for each character:

The decimal set:

  0 nul   1 soh   2 st   3 etx   4 eot   5 enq   6 ack   7 bel
  8 bs    9 ht   10 nl  11 vt   12 np   13 cr   14 so   15 si
 16 dle  17 dc1  18 dc  19 dc3  20 dc4  21 nak  22 syn  23 etb
 24 can  25 em   26 su  27 esc  28 fs   29 gs   30 rs   31 us
 32 sp   33 !    34 "   35 #    36 $    37 %    38 &    39  '
 40 (    41 )    42 *   43 +    44 ,    45 -    46 .    47  /
 48 0    49 1    50 2   51 3    52 4    53 5    54 6    55  7
 56 8    57 9    58 :   59 ;    60 <    61 =    62 >    63  ?
 64 @    65 A    66 B   67 C    68 D    69 E    70 F    71  G
 72 H    73 I    74 J   75 K    76 L    77 M    78 N    79  O
 80 P    81 Q    82 R   83 S    84 T    85 U    86 V    87  W
 88 X    89 Y    90 Z   91 [    92     93 ]    94 ^    95  _
 96 '    97 a    98 b   99 c    100 d   101 e   102 f  103  g
104 h   105 i   106 j  107 k    108 l   109 m   110 n  111  o
112 p   113 q   114 r  115 s    116 t   117 u   118 v  119  w
120 x   121 y   122 z  123 {    124 |   125 }   126 ~  127 del

Executing generatePassword.go with the appropriate command-line parameters will create the following type of output:

$ go run generatePassword.go
Using default values!
ugs$5mvl
$ go run generatePassword.go
Using default values!
PA/8hA@?
$ go run generatePassword.go 20
HBR+=3UA'B@ExT4QG|o
$ go run generatePassword.go 20
XLcr|R{*pX/::'t2u^T'