mirror of
https://github.com/rclone/rclone.git
synced 2025-03-11 05:25:14 +08:00
401cf81034
This commit modernizes Go usage. This was done with:
go run golang.org/x/tools/gopls/internal/analysis/modernize/cmd/modernize@latest -fix -test ./...
Then files needed to be `go fmt`ed and a few comments needed to be
restored.
The modernizations include replacing
- if/else conditional assignment by a call to the built-in min or max functions added in go1.21
- sort.Slice(x, func(i, j int) bool) { return s[i] < s[j] } by a call to slices.Sort(s), added in go1.21
- interface{} by the 'any' type added in go1.18
- append([]T(nil), s...) by slices.Clone(s) or slices.Concat(s), added in go1.21
- loop around an m[k]=v map update by a call to one of the Collect, Copy, Clone, or Insert functions from the maps package, added in go1.21
- []byte(fmt.Sprintf...) by fmt.Appendf(nil, ...), added in go1.19
- append(s[:i], s[i+1]...) by slices.Delete(s, i, i+1), added in go1.21
- a 3-clause for i := 0; i < n; i++ {} loop by for i := range n {}, added in go1.22
64 lines
1.6 KiB
Go
64 lines
1.6 KiB
Go
// Package pkcs7 implements PKCS#7 padding
|
|
//
|
|
// This is a standard way of encoding variable length buffers into
|
|
// buffers which are a multiple of an underlying crypto block size.
|
|
package pkcs7
|
|
|
|
import "errors"
|
|
|
|
// Errors Unpad can return
|
|
var (
|
|
ErrorPaddingNotFound = errors.New("bad PKCS#7 padding - not padded")
|
|
ErrorPaddingNotAMultiple = errors.New("bad PKCS#7 padding - not a multiple of blocksize")
|
|
ErrorPaddingTooLong = errors.New("bad PKCS#7 padding - too long")
|
|
ErrorPaddingTooShort = errors.New("bad PKCS#7 padding - too short")
|
|
ErrorPaddingNotAllTheSame = errors.New("bad PKCS#7 padding - not all the same")
|
|
)
|
|
|
|
// Pad buf using PKCS#7 to a multiple of n.
|
|
//
|
|
// Appends the padding to buf - make a copy of it first if you don't
|
|
// want it modified.
|
|
func Pad(n int, buf []byte) []byte {
|
|
if n <= 1 || n >= 256 {
|
|
panic("bad multiple")
|
|
}
|
|
length := len(buf)
|
|
padding := n - (length % n)
|
|
for range padding {
|
|
buf = append(buf, byte(padding))
|
|
}
|
|
if (len(buf) % n) != 0 {
|
|
panic("padding failed")
|
|
}
|
|
return buf
|
|
}
|
|
|
|
// Unpad buf using PKCS#7 from a multiple of n returning a slice of
|
|
// buf or an error if malformed.
|
|
func Unpad(n int, buf []byte) ([]byte, error) {
|
|
if n <= 1 || n >= 256 {
|
|
panic("bad multiple")
|
|
}
|
|
length := len(buf)
|
|
if length == 0 {
|
|
return nil, ErrorPaddingNotFound
|
|
}
|
|
if (length % n) != 0 {
|
|
return nil, ErrorPaddingNotAMultiple
|
|
}
|
|
padding := int(buf[length-1])
|
|
if padding > n {
|
|
return nil, ErrorPaddingTooLong
|
|
}
|
|
if padding == 0 {
|
|
return nil, ErrorPaddingTooShort
|
|
}
|
|
for i := range padding {
|
|
if buf[length-1-i] != byte(padding) {
|
|
return nil, ErrorPaddingNotAllTheSame
|
|
}
|
|
}
|
|
return buf[:length-padding], nil
|
|
}
|