123 lines
2.7 KiB
Go
123 lines
2.7 KiB
Go
/*
|
|
* Copyright 2022 The Dragonfly 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.
|
|
*/
|
|
|
|
//go:generate mockgen -destination mocks/digest_reader_mock.go -source digest_reader.go -package mocks
|
|
|
|
package digest
|
|
|
|
import (
|
|
"crypto/md5"
|
|
"crypto/sha1"
|
|
"crypto/sha256"
|
|
"crypto/sha512"
|
|
"encoding/hex"
|
|
"errors"
|
|
"fmt"
|
|
"hash"
|
|
"io"
|
|
|
|
logger "d7y.io/dragonfly/v2/internal/dflog"
|
|
)
|
|
|
|
// Reader is the interface used for reading resource.
|
|
type Reader interface {
|
|
io.Reader
|
|
Encoded() string
|
|
}
|
|
|
|
// reader reads stream with RateLimiter.
|
|
type reader struct {
|
|
r io.Reader
|
|
encoded string
|
|
hash hash.Hash
|
|
logger *logger.SugaredLoggerOnWith
|
|
}
|
|
|
|
// Option is a functional option for digest reader.
|
|
type Option func(reader *reader)
|
|
|
|
// WithLogger sets the logger for digest reader.
|
|
func WithLogger(logger *logger.SugaredLoggerOnWith) Option {
|
|
return func(reader *reader) {
|
|
reader.logger = logger
|
|
}
|
|
}
|
|
|
|
// WithEncoded sets the encoded to be verified.
|
|
func WithEncoded(encoded string) Option {
|
|
return func(reader *reader) {
|
|
reader.encoded = encoded
|
|
}
|
|
}
|
|
|
|
// NewReader creates digest reader.
|
|
func NewReader(algorithm string, r io.Reader, options ...Option) (Reader, error) {
|
|
var h hash.Hash
|
|
switch algorithm {
|
|
case AlgorithmSHA1:
|
|
h = sha1.New()
|
|
case AlgorithmSHA256:
|
|
h = sha256.New()
|
|
case AlgorithmSHA512:
|
|
h = sha512.New()
|
|
case AlgorithmMD5:
|
|
h = md5.New()
|
|
default:
|
|
return nil, fmt.Errorf("invalid algorithm: %s", algorithm)
|
|
}
|
|
|
|
reader := &reader{
|
|
r: r,
|
|
hash: h,
|
|
logger: &logger.SugaredLoggerOnWith{},
|
|
}
|
|
|
|
for _, opt := range options {
|
|
opt(reader)
|
|
}
|
|
|
|
return reader, nil
|
|
}
|
|
|
|
// Read uses to read content and validate encoded.
|
|
func (r *reader) Read(p []byte) (int, error) {
|
|
n, err := r.r.Read(p)
|
|
if err != nil && err != io.EOF {
|
|
return n, err
|
|
}
|
|
|
|
if n > 0 {
|
|
r.hash.Write(p[:n])
|
|
}
|
|
|
|
if err == io.EOF && len(r.encoded) != 0 {
|
|
encoded := r.Encoded()
|
|
if encoded != r.encoded {
|
|
r.logger.Warnf("digest encoded not match, desired: %s, actual: %s", r.encoded, encoded)
|
|
return n, errors.New("digest encoded not match")
|
|
}
|
|
|
|
r.logger.Debugf("digest encoded match: %s", encoded)
|
|
}
|
|
|
|
return n, err
|
|
}
|
|
|
|
// Encoded returns the encoded of algorithm.
|
|
func (r *reader) Encoded() string {
|
|
return hex.EncodeToString(r.hash.Sum(nil))
|
|
}
|