84 lines
2.2 KiB
Go
84 lines
2.2 KiB
Go
package argon2
|
|
|
|
import (
|
|
"context"
|
|
"crypto/rand"
|
|
"encoding/base64"
|
|
"flag"
|
|
"fmt"
|
|
"os"
|
|
"runtime"
|
|
|
|
"github.com/google/subcommands"
|
|
"golang.org/x/crypto/argon2"
|
|
)
|
|
|
|
type (
|
|
Argon2Cmd struct {
|
|
memory int
|
|
iterations int
|
|
parallelism int
|
|
saltLength int
|
|
keyLength int
|
|
version bool
|
|
}
|
|
)
|
|
|
|
func (*Argon2Cmd) Name() string { return "argon2" }
|
|
func (*Argon2Cmd) Synopsis() string { return "" }
|
|
func (*Argon2Cmd) Usage() string {
|
|
return `Usage: hash_utils argon2
|
|
|
|
Options:
|
|
`
|
|
}
|
|
|
|
func (p *Argon2Cmd) SetFlags(f *flag.FlagSet) {
|
|
f.IntVar(&p.memory, "memory", 64*1024, "the amount of memory used by the algorithm (in kibibytes)")
|
|
f.IntVar(&p.iterations, "iterations", 3, "the number of iterations over the memory.")
|
|
f.IntVar(&p.parallelism, "parallelism", runtime.NumCPU(), "the number of threads used by the algorithm.")
|
|
f.IntVar(&p.saltLength, "salt-length", 16, "length of the random salt. 16 bytes is recommended for password hashing")
|
|
f.IntVar(&p.keyLength, "key-length", 16, "length of the generated key (or password hash). 16 bytes or more is recommended")
|
|
f.BoolVar(&p.version, "v", false, "show the version of argon2")
|
|
}
|
|
|
|
func (p *Argon2Cmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{}) subcommands.ExitStatus {
|
|
if p.version {
|
|
fmt.Println(argon2.Version)
|
|
return subcommands.ExitSuccess
|
|
}
|
|
if f.NArg() != 1 {
|
|
fmt.Fprintln(os.Stderr, "error: too many or no argument. this command required 1 argument")
|
|
return subcommands.ExitUsageError
|
|
}
|
|
salt, err := salt(p.saltLength)
|
|
if err != nil {
|
|
fmt.Fprintln(os.Stderr, "error:", err)
|
|
return subcommands.ExitUsageError
|
|
}
|
|
hash := argon2.IDKey([]byte(f.Arg(0)), salt, uint32(p.iterations), uint32(p.memory), uint8(p.parallelism), uint32(p.keyLength))
|
|
|
|
fmt.Println(p.toString(salt, hash))
|
|
return subcommands.ExitSuccess
|
|
}
|
|
|
|
func salt(n int) ([]byte, error) {
|
|
b := make([]byte, n)
|
|
_, err := rand.Read(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return b, nil
|
|
}
|
|
|
|
func (p *Argon2Cmd) toString(s, h []byte) string {
|
|
return fmt.Sprintf("$argon2id$v=%d$m=%d,t=%d,p=%d$%s$%s",
|
|
argon2.Version,
|
|
p.memory,
|
|
p.iterations,
|
|
p.parallelism,
|
|
base64.RawStdEncoding.EncodeToString(s),
|
|
base64.RawStdEncoding.EncodeToString(h))
|
|
}
|