cmd/meta4-check/main.go

   1 /*
   2 meta4a -- Metalink 4.0 checker
   3 Copyright (C) 2021-2022 Sergey Matveev <stargrave@stargrave.org>
   4
   5 This program is free software: you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation, version 3 of the License.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 GNU General Public License for more details.
  13
  14 You should have received a copy of the GNU General Public License
  15 along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16 */
  17
  18 // Metalink 4.0 checker
  19 package main
  20
  21 import (
  22         "bufio"
  23         "crypto/sha256"
  24         "crypto/sha512"
  25         "encoding/hex"
  26         "encoding/xml"
  27         "flag"
  28         "fmt"
  29         "hash"
  30         "io"
  31         "io/fs"
  32         "log"
  33         "os"
  34
  35         "go.stargrave.org/meta4ra"
  36 )
  37
  38 func main() {
  39         extractSig := flag.Bool("extract-sig", false, "Extract signature files")
  40         log.SetFlags(log.Lshortfile)
  41         flag.Parse()
  42         sha256Hasher := sha256.New()
  43         sha512Hasher := sha512.New()
  44         bad := false
  45         for _, metaPath := range flag.Args() {
  46                 data, err := os.ReadFile(metaPath)
  47                 if err != nil {
  48                         log.Fatalln(err)
  49                 }
  50                 var meta meta4ra.Metalink
  51                 err = xml.Unmarshal(data, &meta)
  52                 if err != nil {
  53                         log.Fatalln(err)
  54                 }
  55                 for _, f := range meta.Files {
  56                         if f.Signature != nil && *extractSig {
  57                                 if err = os.WriteFile(
  58                                         f.Name+".asc",
  59                                         []byte(f.Signature.Signature),
  60                                         fs.FileMode(0666),
  61                                 ); err != nil {
  62                                         fmt.Println("Error:", f.Name, "can not save signature:", err)
  63                                         bad = true
  64                                 }
  65                         }
  66                         var sha256Digest string
  67                         var sha512Digest string
  68                         fd, err := os.Open(f.Name)
  69                         if err != nil {
  70                                 continue
  71                         }
  72                         for _, h := range f.Hashes {
  73                                 switch h.Type {
  74                                 case meta4ra.HashSHA256:
  75                                         sha256Digest = h.Hash
  76                                 case meta4ra.HashSHA512:
  77                                         sha512Digest = h.Hash
  78                                 }
  79                         }
  80                         var digestTheir string
  81                         var digestName string
  82                         var hasher hash.Hash
  83                         if sha512Digest != "" {
  84                                 digestName = meta4ra.HashSHA512
  85                                 digestTheir = sha512Digest
  86                                 hasher = sha512Hasher
  87                         } else if sha256Digest != "" {
  88                                 digestName = meta4ra.HashSHA256
  89                                 digestTheir = sha256Digest
  90                                 hasher = sha256Hasher
  91                         } else {
  92                                 fd.Close()
  93                                 fmt.Println("Error:", f.Name, "no satisfiable hash algorithm found")
  94                                 bad = true
  95                                 continue
  96                         }
  97                         hasher.Reset()
  98                         _, err = io.Copy(hasher, bufio.NewReader(fd))
  99                         fd.Close()
 100                         if err != nil {
 101                                 fmt.Println("Error:", f.Name, err)
 102                                 bad = true
 103                                 continue
 104                         }
 105                         digestOur := hex.EncodeToString(hasher.Sum(nil))
 106                         if digestOur == digestTheir {
 107                                 fmt.Println(f.Name, digestName, "good")
 108                         } else {
 109                                 fmt.Println(
 110                                         "Hash does not match:", f.Name, digestName,
 111                                         "our:", digestOur,
 112                                         "their:", digestTheir,
 113                                 )
 114                                 bad = true
 115                                 continue
 116                         }
 117                 }
 118         }
 119         if bad {
 120                 os.Exit(1)
 121         }
 122 }