You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
240 lines
5.6 KiB
240 lines
5.6 KiB
package coreutils |
|
|
|
import ( |
|
"bufio" |
|
"crypto/md5" |
|
"crypto/sha1" |
|
"crypto/sha256" |
|
"crypto/sha512" |
|
"errors" |
|
"fmt" |
|
"hash" |
|
"io" |
|
"os" |
|
"regexp" |
|
|
|
"github.com/alexflint/go-arg" |
|
) |
|
|
|
var MD5Regex = regexp.MustCompile("^(?P<hash>[0-9a-f]{32}) (?P<filename>.*)$") |
|
var SHA1Regex = regexp.MustCompile("^(?P<hash>[0-9a-f]{40}) (?P<filename>.*)$") |
|
var SHA224Regex = regexp.MustCompile("^(?P<hash>[0-9a-f]{56}) (?P<filename>.*)$") |
|
var SHA256Regex = regexp.MustCompile("^(?P<hash>[0-9a-f]{64}) (?P<filename>.*)$") |
|
var SHA384Regex = regexp.MustCompile("^(?P<hash>[0-9a-f]{96}) (?P<filename>.*)$") |
|
var SHA512Regex = regexp.MustCompile("^(?P<hash>[0-9a-f]{128}) (?P<filename>.*)$") |
|
var SHA512_224Regex = SHA224Regex |
|
var SHA512_256Regex = SHA256Regex |
|
|
|
// SumFunc is a type of function that computes a hash.Hash for data in io.Reader |
|
type SumFunc func(io.Reader) (hash.Hash, error) |
|
|
|
func copyIntoHash(r io.Reader, h hash.Hash) (hash.Hash, error) { |
|
if _, err := io.Copy(h, r); err != nil { |
|
return nil, err |
|
} |
|
return h, nil |
|
} |
|
|
|
func MD5Sum(r io.Reader) (hash.Hash, error) { |
|
return copyIntoHash(r, md5.New()) |
|
} |
|
|
|
func SHA1Sum(r io.Reader) (hash.Hash, error) { |
|
return copyIntoHash(r, sha1.New()) |
|
} |
|
|
|
func SHA224Sum(r io.Reader) (hash.Hash, error) { |
|
return copyIntoHash(r, sha256.New224()) |
|
} |
|
|
|
func SHA256Sum(r io.Reader) (hash.Hash, error) { |
|
return copyIntoHash(r, sha256.New()) |
|
} |
|
|
|
func SHA384Sum(r io.Reader) (hash.Hash, error) { |
|
return copyIntoHash(r, sha512.New384()) |
|
} |
|
|
|
func SHA512Sum(r io.Reader) (hash.Hash, error) { |
|
return copyIntoHash(r, sha512.New()) |
|
} |
|
|
|
func SHA512_224Sum(r io.Reader) (hash.Hash, error) { |
|
return copyIntoHash(r, sha512.New512_224()) |
|
} |
|
|
|
func SHA512_256Sum(r io.Reader) (hash.Hash, error) { |
|
return copyIntoHash(r, sha512.New512_256()) |
|
} |
|
|
|
type CheckingResults struct { |
|
ImproperlyFormattedCount uint |
|
InvalidChecksumCount uint |
|
FilesNotRead uint |
|
} |
|
|
|
// ImproperlyFormattedErr is an error return when a line for checking |
|
// has an incorrect number or set of characters |
|
var ImproperlyFormattedErr = errors.New("improperly formatted line") |
|
|
|
func printHash(h hash.Hash, filename string) { |
|
fmt.Printf("%x %v\n", h.Sum(nil), filename) |
|
} |
|
|
|
// PrintSumForFile prints checksum computed by f for file with filename |
|
func PrintSumForFile(filename string, f SumFunc) error { |
|
file, err := os.Open(filename) |
|
if err != nil { |
|
return err |
|
} |
|
defer file.Close() |
|
|
|
h, err := f(file) |
|
if err != nil { |
|
return err |
|
} |
|
|
|
printHash(h, filename) |
|
return nil |
|
} |
|
|
|
// PrintSumForStdin prints checksum computed by f for data from stdin |
|
func PrintSumForStdin(f SumFunc) { |
|
h, err := f(os.Stdin) |
|
if err != nil { |
|
PrintToStderr(err) |
|
os.Exit(1) |
|
} |
|
printHash(h, "<stdin>") |
|
os.Exit(0) |
|
} |
|
|
|
func checkLine(line string, re *regexp.Regexp, f SumFunc) (valid bool, err error) { |
|
matches := re.MatchString(line) |
|
if !matches { |
|
err = ImproperlyFormattedErr |
|
valid = false |
|
return |
|
} |
|
submatches := re.FindStringSubmatch(line) |
|
hash := submatches[1] |
|
filename := submatches[2] |
|
|
|
file, err := os.Open(filename) |
|
if err != nil { |
|
valid = false |
|
return |
|
} |
|
defer file.Close() |
|
h, err := f(file) |
|
if err != nil { |
|
valid = false |
|
return |
|
} |
|
|
|
result := "OK" |
|
valid = true |
|
if fmt.Sprintf("%x", h.Sum(nil)) != hash { |
|
result = "FAILED" |
|
valid = false |
|
} |
|
fmt.Printf("%s: %s\n", filename, result) |
|
|
|
return |
|
} |
|
|
|
// CheckSumsInReader checks checksums in r using f |
|
func CheckSumsInReader(r io.Reader, re *regexp.Regexp, f SumFunc) (*CheckingResults, error) { |
|
scanner := bufio.NewScanner(r) |
|
|
|
results := CheckingResults{} |
|
for scanner.Scan() { |
|
valid, err := checkLine(scanner.Text(), re, f) |
|
if err == ImproperlyFormattedErr { |
|
results.ImproperlyFormattedCount++ |
|
} else if err != nil { |
|
PrintToStderr(err) |
|
results.FilesNotRead++ |
|
} else if !valid { |
|
results.InvalidChecksumCount++ |
|
} |
|
} |
|
return &results, scanner.Err() |
|
} |
|
|
|
// CheckSumsInFile checks checksums in file with filename using f |
|
func CheckSumsInFile(filename string, re *regexp.Regexp, f SumFunc) (*CheckingResults, error) { |
|
file, err := os.Open(filename) |
|
if err != nil { |
|
return nil, err |
|
} |
|
defer file.Close() |
|
|
|
return CheckSumsInReader(file, re, f) |
|
} |
|
|
|
// PrintCheckingResults prints the number of mismatched checksums and improperly formatted lines to os.Stderr |
|
func PrintCheckingResults(results CheckingResults) { |
|
if results.InvalidChecksumCount > 0 { |
|
PrintToStderr( |
|
fmt.Sprintf("%v computed checksums did NOT match", results.InvalidChecksumCount), |
|
) |
|
} |
|
if results.ImproperlyFormattedCount > 0 { |
|
PrintToStderr( |
|
fmt.Sprintf("%v lines are improperly formatted", results.ImproperlyFormattedCount), |
|
) |
|
} |
|
if results.FilesNotRead > 0 { |
|
PrintToStderr( |
|
fmt.Sprintf("%v listed files could not be read", results.FilesNotRead), |
|
) |
|
} |
|
} |
|
|
|
// SumMain is a function you're supposed to run in main of a hash sum utility |
|
func SumMain(re *regexp.Regexp, f SumFunc) { |
|
var args struct { |
|
Check bool `arg:"-c"` |
|
Files []string `arg:"positional"` |
|
} |
|
|
|
arg.MustParse(&args) |
|
|
|
exitCode := 0 |
|
if len(args.Files) == 0 { |
|
if !args.Check { |
|
PrintSumForStdin(f) |
|
} else { |
|
results, err := CheckSumsInReader(os.Stdin, re, f) |
|
if err != nil { |
|
PrintToStderr(err) |
|
exitCode = 1 |
|
} |
|
PrintCheckingResults(*results) |
|
} |
|
} |
|
|
|
totalResults := CheckingResults{} |
|
for _, filename := range args.Files { |
|
if !args.Check { |
|
err := PrintSumForFile(filename, f) |
|
if err != nil { |
|
PrintToStderr(err) |
|
exitCode = 1 |
|
} |
|
} else { |
|
results, err := CheckSumsInFile(filename, re, f) |
|
if err != nil { |
|
PrintToStderr(err) |
|
exitCode = 1 |
|
} |
|
if results != nil { |
|
totalResults.ImproperlyFormattedCount += results.ImproperlyFormattedCount |
|
totalResults.InvalidChecksumCount += results.InvalidChecksumCount |
|
} |
|
} |
|
} |
|
PrintCheckingResults(totalResults) |
|
os.Exit(exitCode) |
|
}
|
|
|