1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
|
// Copyright The Notary Project 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 osutil
import (
"crypto/sha256"
"encoding/hex"
"fmt"
"io"
"io/fs"
"net/http"
"os"
"path/filepath"
"strings"
)
// MaxFileBytes is the maximum file bytes.
// When used, the value should be strictly less than this number.
var MaxFileBytes int64 = 256 * 1024 * 1024 // 256 MiB
// WriteFile writes to a path with all parent directories created.
func WriteFile(path string, data []byte) error {
if err := os.MkdirAll(filepath.Dir(path), 0700); err != nil {
return err
}
return os.WriteFile(path, data, 0600)
}
// WriteFileWithPermission writes to a path with all parent directories created.
func WriteFileWithPermission(path string, data []byte, perm fs.FileMode, overwrite bool) error {
if err := os.MkdirAll(filepath.Dir(path), 0700); err != nil {
return err
}
flag := os.O_WRONLY | os.O_CREATE
if overwrite {
flag |= os.O_TRUNC
} else {
flag |= os.O_EXCL
}
file, err := os.OpenFile(path, flag, perm)
if err != nil {
return err
}
_, err = file.Write(data)
if err != nil {
file.Close()
return err
}
return file.Close()
}
// CopyToDir copies the src file to dst. Existing file will be overwritten.
func CopyToDir(src, dst string) (int64, error) {
sourceFileStat, err := os.Stat(src)
if err != nil {
return 0, err
}
if !sourceFileStat.Mode().IsRegular() {
return 0, fmt.Errorf("%s is not a regular file", src)
}
source, err := os.Open(src)
if err != nil {
return 0, err
}
defer source.Close()
if err := os.MkdirAll(dst, 0700); err != nil {
return 0, err
}
dstFile := filepath.Join(dst, filepath.Base(src))
destination, err := os.Create(dstFile)
if err != nil {
return 0, err
}
defer destination.Close()
err = destination.Chmod(0600)
if err != nil {
return 0, err
}
return io.Copy(destination, source)
}
// IsRegularFile checks if path is a regular file
func IsRegularFile(path string) (bool, error) {
fileStat, err := os.Stat(path)
if err != nil {
return false, err
}
return fileStat.Mode().IsRegular(), nil
}
// CopyFromReaderToDir copies file from src to dst where dst is the destination
// file path.
func CopyFromReaderToDir(src io.Reader, dst string, perm fs.FileMode) error {
dstFile, err := os.Create(dst)
if err != nil {
return err
}
if _, err := io.Copy(dstFile, src); err != nil {
dstFile.Close()
return err
}
if err := dstFile.Chmod(perm); err != nil {
dstFile.Close()
return err
}
return dstFile.Close()
}
// DetectFileType returns a file's content type given path
func DetectFileType(path string) (string, error) {
rc, err := os.Open(path)
if err != nil {
return "", err
}
defer rc.Close()
lr := io.LimitReader(rc, 512)
header, err := io.ReadAll(lr)
if err != nil {
return "", err
}
return http.DetectContentType(header), nil
}
// ValidateSHA256Sum returns nil if SHA256 of file at path equals to checksum.
func ValidateSHA256Sum(path string, checksum string) error {
rc, err := os.Open(path)
if err != nil {
return err
}
defer rc.Close()
sha256Hash := sha256.New()
if _, err := io.Copy(sha256Hash, rc); err != nil {
return err
}
sha256sum := sha256Hash.Sum(nil)
enc := hex.EncodeToString(sha256sum[:])
if !strings.EqualFold(enc, checksum) {
return fmt.Errorf("plugin SHA-256 checksum does not match user input. Expecting %s", checksum)
}
return nil
}
|
