mirror of
https://github.com/libp2p/go-openssl.git
synced 2024-12-26 23:40:07 +08:00
597b8983b0
Fix `staticcheck` issues: - S1028 use `fmt.Errorf` to construct formatted errors - ST1017 yoda conditions - ST1005 error message capitalization - ST1006 avoid `self` as receiver name - S1030 use `buf.String` - S1011 avoid redundant loop when `append` suffices - SA4006 unused value - S1019 remove redundant capacity on `make` call - SA2002 `t.Fatal` called outside of test Exported error violates ST1012, which is ignored by this PR since rename may cause breaking changes. Remove redundant parentheses wrapping, and use CamelCase naming while at it.
90 lines
2.2 KiB
Go
90 lines
2.2 KiB
Go
// Copyright (C) 2017. See AUTHORS.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package openssl
|
|
|
|
// #include "shim.h"
|
|
import "C"
|
|
|
|
import (
|
|
"errors"
|
|
"runtime"
|
|
"unsafe"
|
|
)
|
|
|
|
type SHA256Hash struct {
|
|
ctx *C.EVP_MD_CTX
|
|
engine *Engine
|
|
}
|
|
|
|
func NewSHA256Hash() (*SHA256Hash, error) { return NewSHA256HashWithEngine(nil) }
|
|
|
|
func NewSHA256HashWithEngine(e *Engine) (*SHA256Hash, error) {
|
|
hash := &SHA256Hash{engine: e}
|
|
hash.ctx = C.X_EVP_MD_CTX_new()
|
|
if hash.ctx == nil {
|
|
return nil, errors.New("openssl: sha256: unable to allocate ctx")
|
|
}
|
|
runtime.SetFinalizer(hash, func(hash *SHA256Hash) { hash.Close() })
|
|
if err := hash.Reset(); err != nil {
|
|
return nil, err
|
|
}
|
|
return hash, nil
|
|
}
|
|
|
|
func (s *SHA256Hash) Close() {
|
|
if s.ctx != nil {
|
|
C.X_EVP_MD_CTX_free(s.ctx)
|
|
s.ctx = nil
|
|
}
|
|
}
|
|
|
|
func (s *SHA256Hash) Reset() error {
|
|
if C.X_EVP_DigestInit_ex(s.ctx, C.X_EVP_sha256(), engineRef(s.engine)) != 1 {
|
|
return errors.New("openssl: sha256: cannot init digest ctx")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *SHA256Hash) Write(p []byte) (n int, err error) {
|
|
if len(p) == 0 {
|
|
return 0, nil
|
|
}
|
|
if C.X_EVP_DigestUpdate(s.ctx, unsafe.Pointer(&p[0]),
|
|
C.size_t(len(p))) != 1 {
|
|
return 0, errors.New("openssl: sha256: cannot update digest")
|
|
}
|
|
return len(p), nil
|
|
}
|
|
|
|
func (s *SHA256Hash) Sum() (result [32]byte, err error) {
|
|
if C.X_EVP_DigestFinal_ex(s.ctx,
|
|
(*C.uchar)(unsafe.Pointer(&result[0])), nil) != 1 {
|
|
return result, errors.New("openssl: sha256: cannot finalize ctx")
|
|
}
|
|
return result, s.Reset()
|
|
}
|
|
|
|
func SHA256(data []byte) (result [32]byte, err error) {
|
|
hash, err := NewSHA256Hash()
|
|
if err != nil {
|
|
return result, err
|
|
}
|
|
defer hash.Close()
|
|
if _, err := hash.Write(data); err != nil {
|
|
return result, err
|
|
}
|
|
return hash.Sum()
|
|
}
|