Come calcolare sha256 checksum file in Go

Question

ho bisogno di utility per Windows che calcola sha256 checksum del file in modo che quando si scarica fedora posso verificare checksum da qui: https://fedoraproject.org/static/checksums/Fedora-18-i386-CHECKSUM

utilità Microsoft da http://support.microsoft.com/kb/889768 fa solo MD5 e SHA1.

Non voglio utilizzare altri strumenti scaricabili non firmati e non disponibili da https o da fonti che non conosco, perché non ha senso scaricare codice non firmato su una connessione non crittografata o da fonte non attendibile per verificare la firma di un altro codice per considerarlo affidabile.

Fortunatamente google offre la possibilità di utilizzare https per tutti i download, così posso scaricare Go over secure connection e iniziare da lì.

Ecco un semplice codice che lo fa per un file di piccole dimensioni, ma non è molto buono per i file di grandi dimensioni perché non è lo streaming.

package main 

import (
    "io/ioutil" 
    "crypto/sha256" 
    "os" 
    "log" 
    "encoding/hex" 
) 

func main() { 
    hasher := sha256.New() 
    s, err := ioutil.ReadFile(os.Args[1])  
    hasher.Write(s) 
    if err != nil { 
     log.Fatal(err) 
    } 

    os.Stdout.WriteString(hex.EncodeToString(hasher.Sum(nil))) 
} 

Come fare per utilizzare gli stream in modo che funzioni su qualsiasi dimensione di file.

Answer 1

SHA256 hasher implementa l'interfaccia io.Writer, quindi un'opzione potrebbe essere quella di utilizzare la funzione io.Copy() per copiare i dati da un appropriato io.Reader in blocchi. Qualcosa del genere dovrebbe fare:

f, err := os.Open(os.Args[1]) 
if err != nil { 
    log.Fatal(err) 
} 
defer f.Close() 
if _, err := io.Copy(hasher, f); err != nil { 
    log.Fatal(err) 
} 

Answer 2

esempio completa di md5sum:

func md5sum(filePath string) (result string, err error) { 
    file, err := os.Open(filePath) 
    if err != nil { 
     return 
    } 
    defer file.Close() 

    hash := md5.New() 
    _, err = io.Copy(hash, file) 
    if err != nil { 
     return 
    } 

    result = hex.EncodeToString(hash.Sum(nil)) 
    return 
} 

EncodeToString non omette leader 0 byte, quindi fmt.Println(hex.EncodeToString([]byte{0x00, 0x00, 0xA, 0xB, 0xC})) dà 00000a0b0c

Answer 3

Il crypto/sha256 godoc ha in realtà una snippet che spettacoli come farlo (è praticamente lo stesso codice di James):

package main 

import (
    "crypto/sha256" 
    "fmt" 
    "io" 
    "log" 
    "os" 
) 

func main() { 
    f, err := os.Open("file.txt") 
    if err != nil { 
    log.Fatal(err) 
    } 
    defer f.Close() 

    h := sha256.New() 
    if _, err := io.Copy(h, f); err != nil { 
    log.Fatal(err) 
    } 

    fmt.Printf("%x", h.Sum(nil)) 
}