From 61eab24ba48f1e823021a3c46e2dd1b5c317b7f4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Aur=C3=A9lie=20DELHAIE?= Date: Tue, 12 Aug 2025 21:03:07 +0200 Subject: [PATCH] add more algo --- README.md | 10 +++- commands/argon2/argon2.go | 83 ++++++++++++++++++++++++++ commands/crc16/crc16.go | 112 ++++++++++++++++++++++++++++++++++++ commands/crc32/crc32.go | 83 ++++++++++++++++++++++++++ commands/crc64/crc64.go | 80 ++++++++++++++++++++++++++ commands/crc8/crc8.go | 11 ++-- commands/sha3/sha3.go | 84 +++++++++++++++++++++++++++ commands/version/version.go | 2 +- go.mod | 3 + go.sum | 4 ++ main.go | 8 +++ tools/tools.go | 21 +++++++ 12 files changed, 494 insertions(+), 7 deletions(-) create mode 100644 commands/argon2/argon2.go create mode 100644 commands/crc16/crc16.go create mode 100644 commands/crc32/crc32.go create mode 100644 commands/crc64/crc64.go create mode 100644 commands/sha3/sha3.go diff --git a/README.md b/README.md index 2c81e73..aa25388 100644 --- a/README.md +++ b/README.md @@ -5,8 +5,14 @@ This is a simple tool box with basic functionality. ## Supported tools - BCrypt - MD5 - - SHA (1, 256, 512) + - SHA1 + - SHA2 + - SHA3 - CRC8 - - Base64 (not a hash algo but idc) + - CRC16 + - CRC32 + - CRC64 + - Argon2 + - Base64 (not a hash but idc) more later... \ No newline at end of file diff --git a/commands/argon2/argon2.go b/commands/argon2/argon2.go new file mode 100644 index 0000000..8502ab9 --- /dev/null +++ b/commands/argon2/argon2.go @@ -0,0 +1,83 @@ +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)) +} diff --git a/commands/crc16/crc16.go b/commands/crc16/crc16.go new file mode 100644 index 0000000..4b245fb --- /dev/null +++ b/commands/crc16/crc16.go @@ -0,0 +1,112 @@ +package crc16 + +import ( + "context" + "flag" + "fmt" + "hash_utils/tools" + "os" + + "github.com/google/subcommands" + "github.com/sigurn/crc16" +) + +type ( + CRC16Cmd struct { + file string + table string + } +) + +var ( + tables = []crc16.Params{ + crc16.CRC16_ARC, + crc16.CRC16_AUG_CCITT, + crc16.CRC16_BUYPASS, + crc16.CRC16_CCITT_FALSE, + crc16.CRC16_CDMA2000, + crc16.CRC16_CRC_A, + crc16.CRC16_DDS_110, + crc16.CRC16_DECT_R, + crc16.CRC16_DECT_X, + crc16.CRC16_DNP, + crc16.CRC16_EN_13757, + crc16.CRC16_GENIBUS, + crc16.CRC16_KERMIT, + crc16.CRC16_MAXIM, + crc16.CRC16_MCRF4XX, + crc16.CRC16_MODBUS, + crc16.CRC16_RIELLO, + crc16.CRC16_T10_DIF, + crc16.CRC16_TELEDISK, + crc16.CRC16_TMS37157, + crc16.CRC16_USB, + crc16.CRC16_XMODEM, + crc16.CRC16_X_25, + } +) + +func (*CRC16Cmd) Name() string { return "crc16" } +func (*CRC16Cmd) Synopsis() string { return "" } +func (*CRC16Cmd) Usage() string { + res := "Usage: hash_utils crc16\n\n" + res += "Algorithm available:\n" + for _, table := range tables { + res += " - " + table.Name + "\n" + } + res += "\nOptions:\n" + return res +} + +func (p *CRC16Cmd) SetFlags(f *flag.FlagSet) { + f.StringVar(&p.file, "file", "", "get the checksum of a file") + f.StringVar(&p.table, "table", crc16.CRC16_ARC.Name, "Predefined CRC-16 algorithms") +} + +func (p *CRC16Cmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{}) subcommands.ExitStatus { + var err error + param := crc16.CRC16_ARC + if len(p.table) > 0 { + param, err = parse(p.table) + if err != nil { + fmt.Printf("Available tables: ") + for _, table := range tables { + fmt.Printf("%s ", table.Name) + } + fmt.Println() + fmt.Fprintln(os.Stderr, "error:", err) + + return subcommands.ExitFailure + } + } + + if len(p.file) > 0 { + b, err := os.ReadFile(p.file) + if err != nil { + fmt.Fprintln(os.Stderr, "error: failed to read file:", err) + return subcommands.ExitFailure + } + + h := tools.CRC16(b, param) + + fmt.Printf("%s: %s\n", f.Name(), h) + + return subcommands.ExitSuccess + } + + for _, arg := range f.Args() { + h := tools.CRC16([]byte(arg), param) + fmt.Printf("%s: %s\n", arg, h) + } + + return subcommands.ExitSuccess +} + +func parse(tableName string) (crc16.Params, error) { + for _, table := range tables { + if table.Name == tableName { + return table, nil + } + } + return crc16.CRC16_ARC, fmt.Errorf("invalid table name: %s", tableName) +} diff --git a/commands/crc32/crc32.go b/commands/crc32/crc32.go new file mode 100644 index 0000000..3c2082a --- /dev/null +++ b/commands/crc32/crc32.go @@ -0,0 +1,83 @@ +package crc32 + +import ( + "context" + "flag" + "fmt" + "hash/crc32" + "hash_utils/tools" + "os" + + "github.com/google/subcommands" +) + +type ( + CRC32Cmd struct { + file string + table string + } +) + +func (*CRC32Cmd) Name() string { return "crc32" } +func (*CRC32Cmd) Synopsis() string { return "" } +func (*CRC32Cmd) Usage() string { + return `Usage: hash_utils crc32 + +Algorithm available: + - Castagnoli + - Koopman + - IEEE + +Options: +` +} + +func (p *CRC32Cmd) SetFlags(f *flag.FlagSet) { + f.StringVar(&p.file, "file", "", "get the checksum of a file") + f.StringVar(&p.table, "table", "IEEE", "Predefined CRC-32 algorithms") +} + +func (p *CRC32Cmd) Execute(ctx context.Context, f *flag.FlagSet, args ...interface{}) subcommands.ExitStatus { + var err error + var param uint32 = crc32.IEEE + if len(p.table) > 0 { + param, err = parse(p.table) + if err != nil { + fmt.Printf("Available tables: IEEE Castagnoli Koopman") + return subcommands.ExitFailure + } + } + + if len(p.file) > 0 { + b, err := os.ReadFile(p.file) + if err != nil { + fmt.Fprintln(os.Stderr, "error: failed to read file:", err) + return subcommands.ExitFailure + } + + h := tools.CRC32(b, param) + + fmt.Printf("%s: %s\n", f.Name(), h) + + return subcommands.ExitSuccess + } + + for _, arg := range f.Args() { + h := tools.CRC32([]byte(arg), param) + fmt.Printf("%s: %s\n", arg, h) + } + + return subcommands.ExitSuccess +} + +func parse(tableName string) (uint32, error) { + switch tableName { + case "Castagnoli": + return crc32.Castagnoli, nil + case "Koopman": + return crc32.Koopman, nil + case "IEEE": + return crc32.IEEE, nil + } + return 0, fmt.Errorf("invalid table name: %s", tableName) +} diff --git a/commands/crc64/crc64.go b/commands/crc64/crc64.go new file mode 100644 index 0000000..5b1b4d4 --- /dev/null +++ b/commands/crc64/crc64.go @@ -0,0 +1,80 @@ +package crc64 + +import ( + "context" + "flag" + "fmt" + "hash/crc64" + "hash_utils/tools" + "os" + + "github.com/google/subcommands" +) + +type ( + CRC64Cmd struct { + file string + table string + } +) + +func (*CRC64Cmd) Name() string { return "crc64" } +func (*CRC64Cmd) Synopsis() string { return "" } +func (*CRC64Cmd) Usage() string { + return `Usage: hash_utils crc64 + +Algorithm available: + - ECMA + - ISO + +Options: +` +} + +func (p *CRC64Cmd) SetFlags(f *flag.FlagSet) { + f.StringVar(&p.file, "file", "", "get the checksum of a file") + f.StringVar(&p.table, "table", "ISO", "Predefined CRC-64 algorithms") +} + +func (p *CRC64Cmd) Execute(ctx context.Context, f *flag.FlagSet, args ...interface{}) subcommands.ExitStatus { + var err error + var param uint64 = crc64.ISO + if len(p.table) > 0 { + param, err = parse(p.table) + if err != nil { + fmt.Printf("Available tables: IEEE Castagnoli Koopman") + return subcommands.ExitFailure + } + } + + if len(p.file) > 0 { + b, err := os.ReadFile(p.file) + if err != nil { + fmt.Fprintln(os.Stderr, "error: failed to read file:", err) + return subcommands.ExitFailure + } + + h := tools.CRC64(b, param) + + fmt.Printf("%s: %s\n", f.Name(), h) + + return subcommands.ExitSuccess + } + + for _, arg := range f.Args() { + h := tools.CRC64([]byte(arg), param) + fmt.Printf("%s: %s\n", arg, h) + } + + return subcommands.ExitSuccess +} + +func parse(tableName string) (uint64, error) { + switch tableName { + case "Castagnoli": + return crc64.ISO, nil + case "Koopman": + return crc64.ECMA, nil + } + return 0, fmt.Errorf("invalid table name: %s", tableName) +} diff --git a/commands/crc8/crc8.go b/commands/crc8/crc8.go index 3886670..dc8505a 100644 --- a/commands/crc8/crc8.go +++ b/commands/crc8/crc8.go @@ -36,10 +36,13 @@ var ( func (*CRC8Cmd) Name() string { return "crc8" } func (*CRC8Cmd) Synopsis() string { return "" } func (*CRC8Cmd) Usage() string { - return `Usage: hash_utils crc8 - -Options: -` + res := "Usage: hash_utils crc8\n\n" + res += "Algorithm available:\n" + for _, table := range tables { + res += " - " + table.Name + "\n" + } + res += "\nOptions:\n" + return res } func (p *CRC8Cmd) SetFlags(f *flag.FlagSet) { diff --git a/commands/sha3/sha3.go b/commands/sha3/sha3.go new file mode 100644 index 0000000..9ebcc30 --- /dev/null +++ b/commands/sha3/sha3.go @@ -0,0 +1,84 @@ +package sha3 + +import ( + "context" + "crypto/sha3" + "flag" + "fmt" + "hash_utils/tools" + "os" + "strings" + + "github.com/google/subcommands" +) + +type ( + SHA3Cmd struct { + file string + length int + } +) + +func (*SHA3Cmd) Name() string { return "sha3" } +func (*SHA3Cmd) Synopsis() string { return "" } +func (*SHA3Cmd) Usage() string { + return `Usage: hash_utils sha2 + +Options: +` +} + +func (p *SHA3Cmd) SetFlags(f *flag.FlagSet) { + f.StringVar(&p.file, "file", "", "get the checksum of a file") + f.IntVar(&p.length, "length", 256, "change the length, supported length is 224, 256, 384 and 512") +} + +func (p *SHA3Cmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{}) subcommands.ExitStatus { + h, err := parseBitLength(p.length) + if err != nil { + fmt.Fprintln(os.Stderr, "error:", err) + return subcommands.ExitUsageError + } + if len(p.file) > 0 { + file, err := os.OpenFile(p.file, os.O_RDONLY, 0) + if err != nil { + fmt.Fprintln(os.Stderr, "error: failed to open the file:", err) + return subcommands.ExitFailure + } + defer file.Close() + + h, err := tools.Hash(h, file) + if err != nil { + fmt.Fprintln(os.Stderr, "error:", err) + return subcommands.ExitFailure + } + fmt.Printf("%s: %s\n", f.Name(), h) + + return subcommands.ExitSuccess + } + + for _, arg := range f.Args() { + h, err := tools.Hash(h, strings.NewReader(arg)) + if err != nil { + fmt.Fprintln(os.Stderr, "error:", err) + return subcommands.ExitFailure + } + fmt.Printf("%s: %s\n", arg, h) + } + + return subcommands.ExitSuccess +} + +func parseBitLength(length int) (*sha3.SHA3, error) { + switch length { + case 224: + return sha3.New224(), nil + case 256: + return sha3.New256(), nil + case 384: + return sha3.New384(), nil + case 512: + return sha3.New512(), nil + } + return nil, fmt.Errorf("invalid length: supported length is 224, 256, 384 and 512") +} diff --git a/commands/version/version.go b/commands/version/version.go index 5ea4886..1768842 100644 --- a/commands/version/version.go +++ b/commands/version/version.go @@ -10,7 +10,7 @@ import ( ) const ( - version string = "2.0.0" + version string = "2.0.1" ) type ( diff --git a/go.mod b/go.mod index ed40445..874da49 100644 --- a/go.mod +++ b/go.mod @@ -4,6 +4,9 @@ go 1.24 require ( github.com/google/subcommands v1.2.0 + github.com/sigurn/crc16 v0.0.0-20240131213347-83fcde1e29d1 github.com/sigurn/crc8 v0.0.0-20220107193325-2243fe600f9f golang.org/x/crypto v0.41.0 ) + +require golang.org/x/sys v0.35.0 // indirect diff --git a/go.sum b/go.sum index c2b0f92..104594d 100644 --- a/go.sum +++ b/go.sum @@ -1,6 +1,10 @@ github.com/google/subcommands v1.2.0 h1:vWQspBTo2nEqTUFita5/KeEWlUL8kQObDFbub/EN9oE= github.com/google/subcommands v1.2.0/go.mod h1:ZjhPrFU+Olkh9WazFPsl27BQ4UPiG37m3yTrtFlrHVk= +github.com/sigurn/crc16 v0.0.0-20240131213347-83fcde1e29d1 h1:NVK+OqnavpyFmUiKfUMHrpvbCi2VFoWTrcpI7aDaJ2I= +github.com/sigurn/crc16 v0.0.0-20240131213347-83fcde1e29d1/go.mod h1:9/etS5gpQq9BJsJMWg1wpLbfuSnkm8dPF6FdW2JXVhA= github.com/sigurn/crc8 v0.0.0-20220107193325-2243fe600f9f h1:1R9KdKjCNSd7F8iGTxIpoID9prlYH8nuNYKt0XvweHA= github.com/sigurn/crc8 v0.0.0-20220107193325-2243fe600f9f/go.mod h1:vQhwQ4meQEDfahT5kd61wLAF5AAeh5ZPLVI4JJ/tYo8= golang.org/x/crypto v0.41.0 h1:WKYxWedPGCTVVl5+WHSSrOBT0O8lx32+zxmHxijgXp4= golang.org/x/crypto v0.41.0/go.mod h1:pO5AFd7FA68rFak7rOAGVuygIISepHftHnr8dr6+sUc= +golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI= +golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k= diff --git a/main.go b/main.go index 0ca5cf2..6a961f3 100644 --- a/main.go +++ b/main.go @@ -3,8 +3,12 @@ package main import ( "context" "flag" + "hash_utils/commands/argon2" "hash_utils/commands/base64" "hash_utils/commands/bcrypt" + "hash_utils/commands/crc16" + "hash_utils/commands/crc32" + "hash_utils/commands/crc64" "hash_utils/commands/crc8" "hash_utils/commands/md5" "hash_utils/commands/sha1" @@ -28,8 +32,12 @@ func main() { subcommands.Register(&sha512.SHA512Cmd{}, "unkeyed cryptographic hash functions") subcommands.Register(&crc8.CRC8Cmd{}, "cyclic redundancy checks") + subcommands.Register(&crc16.CRC16Cmd{}, "cyclic redundancy checks") + subcommands.Register(&crc32.CRC32Cmd{}, "cyclic redundancy checks") + subcommands.Register(&crc64.CRC64Cmd{}, "cyclic redundancy checks") subcommands.Register(&bcrypt.BCryptCmd{}, "password hashing functions") + subcommands.Register(&argon2.Argon2Cmd{}, "password hashing functions") subcommands.Register(&base64.Base64Cmd{}, "other") diff --git a/tools/tools.go b/tools/tools.go index c9f370e..cfc0a1d 100644 --- a/tools/tools.go +++ b/tools/tools.go @@ -4,8 +4,11 @@ import ( "encoding/hex" "fmt" "hash" + "hash/crc32" + "hash/crc64" "io" + "github.com/sigurn/crc16" "github.com/sigurn/crc8" ) @@ -21,3 +24,21 @@ func CRC8(s []byte, param crc8.Params) string { crc := crc8.Checksum(s, table) return fmt.Sprintf("%X", crc) } + +func CRC16(s []byte, param crc16.Params) string { + table := crc16.MakeTable(param) + crc := crc16.Checksum(s, table) + return fmt.Sprintf("%X", crc) +} + +func CRC32(s []byte, param uint32) string { + table := crc32.MakeTable(param) + crc := crc32.Checksum(s, table) + return fmt.Sprintf("%X", crc) +} + +func CRC64(s []byte, param uint64) string { + table := crc64.MakeTable(param) + crc := crc64.Checksum(s, table) + return fmt.Sprintf("%X", crc) +}