mirror of
https://github.com/libp2p/go-openssl.git
synced 2024-12-26 23:40:07 +08:00
46d44e1dfd
* Fix build with OpenSSL 3.0 - FIPS_mode_set() does not exist in OpenSSL 3.0 [1] - X509_check_* functions declarated in openssl/x509v3.h instead of openssl/x509.h [2] - X509_chack_* functions have const char arg inserad of const unsigned char [2] - skip MD4 tests if it is unsupported by OpenSSL - the patch does not change behavior under OpenSSL version != 3 - the patch just fixes build under OpenSSL 3.0 and doesn't update deprecated code or behavior 1. https://wiki.openssl.org/index.php/OpenSSL_3.0#Upgrading_from_the_OpenSSL_2.0_FIPS_Object_Module 2. https://www.openssl.org/docs/man3.0/man3/X509_check_host.html * Add Ubuntu 22.04 runner to GitHub Actions go test workflow * Fix flaky tests on Ubuntu 22.04 It is necessary to handle OpenSSL errors very carefully. Otherwise, errors may appear in unexpected places. For example, we didn't catch an error from EVP_DigestInit_ex() and it appears sometimes in conn.go: func (c *Conn) getErrorHandler(rv C.int, errno error) func() error { errcode := C.SSL_get_error(c.ssl, rv) // <- here
93 lines
2.2 KiB
Go
93 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 MD4Hash struct {
|
|
ctx *C.EVP_MD_CTX
|
|
engine *Engine
|
|
}
|
|
|
|
func NewMD4Hash() (*MD4Hash, error) { return NewMD4HashWithEngine(nil) }
|
|
|
|
func NewMD4HashWithEngine(e *Engine) (*MD4Hash, error) {
|
|
hash := &MD4Hash{engine: e}
|
|
hash.ctx = C.X_EVP_MD_CTX_new()
|
|
if hash.ctx == nil {
|
|
return nil, errors.New("openssl: md4: unable to allocate ctx")
|
|
}
|
|
runtime.SetFinalizer(hash, func(hash *MD4Hash) { hash.Close() })
|
|
if err := hash.Reset(); err != nil {
|
|
return nil, err
|
|
}
|
|
return hash, nil
|
|
}
|
|
|
|
func (s *MD4Hash) Close() {
|
|
if s.ctx != nil {
|
|
C.X_EVP_MD_CTX_free(s.ctx)
|
|
s.ctx = nil
|
|
}
|
|
}
|
|
|
|
func (s *MD4Hash) Reset() error {
|
|
runtime.LockOSThread()
|
|
defer runtime.UnlockOSThread()
|
|
if C.X_EVP_DigestInit_ex(s.ctx, C.X_EVP_md4(), engineRef(s.engine)) != 1 {
|
|
return errors.New("openssl: md4: cannot init digest ctx: " +
|
|
errorFromErrorQueue().Error())
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *MD4Hash) 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: md4: cannot update digest")
|
|
}
|
|
return len(p), nil
|
|
}
|
|
|
|
func (s *MD4Hash) Sum() (result [16]byte, err error) {
|
|
if C.X_EVP_DigestFinal_ex(s.ctx,
|
|
(*C.uchar)(unsafe.Pointer(&result[0])), nil) != 1 {
|
|
return result, errors.New("openssl: md4: cannot finalize ctx")
|
|
}
|
|
return result, s.Reset()
|
|
}
|
|
|
|
func MD4(data []byte) (result [16]byte, err error) {
|
|
hash, err := NewMD4Hash()
|
|
if err != nil {
|
|
return result, err
|
|
}
|
|
defer hash.Close()
|
|
if _, err := hash.Write(data); err != nil {
|
|
return result, err
|
|
}
|
|
return hash.Sum()
|
|
}
|