Generating the SHA hash of a string using golang

Can someone show me a working example of how to generate a SHA hash of a string that I have, say myPassword := "beautiful", using Go?

An example :

import (
    "crypto/sha1"
    "encoding/base64"
)

func (ms *MapServer) storee(bv []byte) {
    hasher := sha1.New()
    hasher.Write(bv)
    sha := base64.URLEncoding.EncodeToString(hasher.Sum(nil))
        ...
}

In this example I make a sha from a byte array. You can get the byte array using

bv := []byte(myPassword) 

Of course you don't need to encode it in base64 if you don't have to : you may use the raw byte array returned by the Sum function.

There seems to be some little confusion in comments below. So let's clarify for next users the best practices on conversions to strings:

• you never store a SHA as a string in a database, but as raw bytes

• when you want to display a SHA to a user, a common way is Hexadecimal

• when you want a string representation because it must fit in an URL or in a filename, the usual solution is Base64, which is more compact

Go By Example has a page on sha1 hashing.

package main

import (
	"fmt"
	"crypto/sha1"
    "encoding/hex"
)

func main() {

	s := "sha1 this string"
	h := sha1.New()
	h.Write([]byte(s))
	sha1_hash := hex.EncodeToString(h.Sum(nil))

	fmt.Println(s, sha1_hash)
}

You can run this example on play.golang.org

The package documentation at http://golang.org/pkg/crypto/sha1/ does have an example that demonstrates this. It's stated as an example of the New function, but it's the only example on the page and it has a link right near the top of the page so it is worth looking at. The complete example is,

> Code:

h := sha1.New()
io.WriteString(h, "His money is twice tainted: 'taint yours and 'taint mine.")
fmt.Printf("% x", h.Sum(nil))

> Output:

> 59 7f 6a 54 00 10 f9 4c 15 d7 18 06 a9 9a 2c 87 10 e7 47 bd

You can actually do this in a much more concise and idiomatic manner:

// Assuming 'r' is set to some inbound net/http request
form_value := []byte(r.PostFormValue("login_password"))
sha1_hash := fmt.Sprintf("%x", sha1.Sum(form_value))

// Then output optionally, to test
fmt.Println(sha1_hash)

In this trivial example of a [http.Request](http://golang.org/pkg/net/http/#Request "Godoc") POST containing a login_password field, it is worth noting that [fmt.Sprintf()](http://golang.org/pkg/fmt/#Sprintf "Godoc") called with %x converted the hash value to hex without having to include an import "encoding/hex" declaration.

( We used [fmt.Sprintf()](http://golang.org/pkg/fmt/#Sprintf "Godoc") as opposed to [fmt.Printf()](http://golang.org/pkg/fmt/#Printf "Godoc") as we were outputting a string to a variable assignment, not an [io.Writer](http://golang.org/pkg/io/#Writer "Godoc") interface. )

Also of reference, is that the [sha1.Sum()](http://golang.org/src/crypto/sha1/sha1.go?s=2235:2267#L115 "Golang source") function verbosely instantiates in the same manner as the [sha1.New()](http://golang.org/src/crypto/sha1/sha1.go?s=900:920#L41 "Golang source") definition:

func New() hash.Hash {
    d := new(digest)
    d.Reset()
    return d
}

func Sum(data []byte) [Size]byte {
    var d digest
    d.Reset()
    d.Write(data)
    return d.checkSum()
}

This holds true ( at least at the time of posting ) for the Sha library variants in Golang's standard crypto set, such as [Sha512](http://golang.org/src/crypto/sha512/sha512.go "Golang source").

Lastly, if one wanted to, they could follow Golang's [to]String() implementation with something like func (h hash.Hash) String() string {...} to encapsulate the process.

That is most likely beyond the desired scope of the original question.

<!-- language: golang -->

h := sha1.New()
h.Write(content)
sha := h.Sum(nil)  // "sha" is uint8 type, encoded in base16

shaStr := hex.EncodeToString(sha)  // String representation

fmt.Printf("%x\n", sha)
fmt.Println(shaStr)

Here's some good examples:

• http://golang.org/src/pkg/crypto/hmac/hmac_test.go
• http://www.jokecamp.com/blog/examples-of-creating-base64-hashes-using-hmac-sha256-in-different-languages/#go

The second example targets sha256, to do sha1 hexadecimal you'd do:

// Calculate the hexadecimal HMAC SHA1 of requestDate using sKey                
key := []byte(c.SKey)                                                           
h := hmac.New(sha1.New, key)                                                    
h.Write([]byte(requestDate))                                                    
hmacString := hex.EncodeToString(h.Sum(nil))

(from https://github.com/soniah/dnsmadeeasy)

Here is a function you could use to generate a SHA1 hash:

// SHA1 hashes using sha1 algorithm
func SHA1(text string) string {
    algorithm := sha1.New()
	algorithm.Write([]byte(text))
    return hex.EncodeToString(algorithm.Sum(nil))
}

I put together a group of those utility hash functions here: https://github.com/shomali11/util

You will find FNV32, FNV32a, FNV64, FNV65a, MD5, SHA1, SHA256 and SHA512

As a one liner hashing in Go is more convenient:

sha := sha256.Sum256([]byte())

The result is a []byte and might be transformed into hex or base64.

// Get sha1 from string
func Hashstr(Txt string) string {
    h := sha1.New()
    h.Write([]byte(Txt))
    bs  := h.Sum(nil)
    sh:= string(fmt.Sprintf("%x\n", bs))
    return sh
}