arrays - 函数应返回 sha256/sha384/sha512 结果作为 byte slice

Question

我正在编写一个函数，它将输入数据作为字符串和要调用的 SHA 算法的位大小。它应该将生成的散列作为 byte slice 返回(第一次尝试):

package main

import (
    "crypto/sha256"
    "crypto/sha512"
    "errors"
    "fmt"
)

func main() {
    input := "This is a test."
    sha256, _ := shaSum(input, 256)
    sha384, _ := shaSum(input, 384)
    sha512, _ := shaSum(input, 512)
    fmt.Println(input, sha256, sha384, sha512)
}

func shaSum(data string, size uint) ([]byte, error) {
    input := []byte(data)
    switch size {
    case 256:
        return sha256.Sum256(input), nil
    case 384:
        return sha512.Sum384(input), nil
    case 512:
        return sha512.Sum512(input), nil
    default:
        return nil, errors.New("unsupported sha size")
    }
}

这当然行不通:

$ go run shasum.go
# command-line-arguments
./shasum.go:22:23: cannot use sha256.Sum256(input) (type [32]byte) as type []byte in return argument
./shasum.go:24:23: cannot use sha512.Sum384(input) (type [48]byte) as type []byte in return argument
./shasum.go:26:23: cannot use sha512.Sum512(input) (type [64]byte) as type []byte in return argument

所以我试图从散列函数的返回值中获取一个片段，在每次调用(第二次尝试)后添加 [:]:

func shaSum(data string, size uint) ([]byte, error) {
    input := []byte(data)
    switch size {
    case 256:
        return sha256.Sum256(input)[:], nil
    case 384:
        return sha512.Sum384(input)[:], nil
    case 512:
        return sha512.Sum512(input)[:], nil
    default:
        return nil, errors.New("unsupported sha size")
    }
}

这也行不通:

$ go run shasum.go
# command-line-arguments
./shasum.go:22:30: invalid operation sha256.Sum256(input)[:] (slice of unaddressable value)
./shasum.go:24:30: invalid operation sha512.Sum384(input)[:] (slice of unaddressable value)
./shasum.go:26:30: invalid operation sha512.Sum512(input)[:] (slice of unaddressable value)

所以我试图获取返回值的地址，使用括号确保先取表达式的地址然后 slice (第三次尝试):

func shaSum(data string, size uint) ([]byte, error) {
    input := []byte(data)
    switch size {
    case 256:
        return (&(sha256.Sum256(input)))[:], nil
    case 384:
        return (&(sha512.Sum384(input)))[:], nil
    case 512:
        return (&(sha512.Sum512(input)))[:], nil
    default:
        return nil, errors.New("unsupported sha size")
    }
}

这会产生此错误消息:

$ go run shasum.go
# command-line-arguments
./shasum.go:22:10: cannot take the address of sha256.Sum256(input)
./shasum.go:24:10: cannot take the address of sha512.Sum384(input)
./shasum.go:26:10: cannot take the address of sha512.Sum512(input)

所以我放弃并使用额外的行来解决它(第四次尝试):

func shaSum(data string, size uint) ([]byte, error) {
    input := []byte(data)
    switch size {
    case 256:
        bytes := sha256.Sum256(input)
        return bytes[:], nil
    case 384:
        bytes := sha512.Sum384(input)
        return bytes[:], nil
    case 512:
        bytes := sha512.Sum512(input)
        return bytes[:], nil
    default:
        return nil, errors.New("unsupported sha size")
    }
}

最终编译并运行。现在我想知道:为什么第四次尝试有效而其他尝试(尤其是第三次尝试)却没有？一个好的解决方案会是什么样子？有没有办法像第四次尝试那样避免那些额外的行？

编辑:我问题的根本问题不是如何从字节数组转换为字节 slice ，而是我对可寻址性概念以及如何表达解决方案缺乏理解我在 Go 中遇到的问题。

Answer 1

语言规范states this about the slice operator :

If the sliced operand is an array, it must be addressable and the result of the slice operation is a slice with the same element type as the array.

和this about addressability :

The operand must be addressable, that is, either a variable, pointer indirection, or slice indexing operation; or a field selector of an addressable struct operand; or an array indexing operation of an addressable array.

由此可见，第四次尝试是唯一有效的尝试。

这是使用 hash.Hash 的替代方法界面。

var hashFactory = map[int]func() hash.Hash{
    256: sha256.New,
    384: sha512.New384,
    512: sha512.New,
}

func shaSum(data string, size int) ([]byte, error) {
    f := hashFactory[size]
    if f == nil {
        return nil, errors.New("unsupported sha size")
    }
    h := f()
    io.WriteString(h, data)
    return h.Sum(nil), nil
}