forked from direnv/direnv
/
rc.go
315 lines (265 loc) · 6.57 KB
/
rc.go
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
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
package cmd
import (
"context"
"crypto/sha256"
"fmt"
"io"
"os"
"os/exec"
"os/signal"
"path/filepath"
"strings"
"time"
)
// RC represents the .envrc or .env file
type RC struct {
path string
allowPath string
times FileTimes
config *Config
}
// FindRC looks for ".envrc" and ".env" files up in the file hierarchy.
func FindRC(wd string, config *Config) (*RC, error) {
rcPath := findEnvUp(wd, config.LoadDotenv)
if rcPath == "" {
return nil, nil
}
return RCFromPath(rcPath, config)
}
// RCFromPath inits the RC from a given path
func RCFromPath(path string, config *Config) (*RC, error) {
hash, err := fileHash(path)
if err != nil {
return nil, err
}
allowPath := filepath.Join(config.AllowDir(), hash)
times := NewFileTimes()
err = times.Update(path)
if err != nil {
return nil, err
}
err = times.Update(allowPath)
if err != nil {
return nil, err
}
return &RC{path, allowPath, times, config}, nil
}
// RCFromEnv inits the RC from the environment
func RCFromEnv(path, marshalledTimes string, config *Config) *RC {
times := NewFileTimes()
err := times.Unmarshal(marshalledTimes)
if err != nil {
return nil
}
return &RC{path, "", times, config}
}
// Allow grants the RC as allowed to load
func (rc *RC) Allow() (err error) {
if rc.allowPath == "" {
return fmt.Errorf("cannot allow empty path")
}
if err = os.MkdirAll(filepath.Dir(rc.allowPath), 0755); err != nil {
return
}
if err = allow(rc.path, rc.allowPath); err != nil {
return
}
err = rc.times.Update(rc.allowPath)
return
}
// Deny revokes the permission of the RC file to load
func (rc *RC) Deny() error {
return os.Remove(rc.allowPath)
}
// Allowed checks if the RC file has been granted loading
func (rc *RC) Allowed() bool {
// happy path is if this envrc has been explicitly allowed, O(1)ish common case
_, err := os.Stat(rc.allowPath)
if err == nil {
return true
}
// when whitelisting we want to be (path) absolutely sure we've not been duped with a symlink
path, err := filepath.Abs(rc.path)
// seems unlikely that we'd hit this, but have to handle it
if err != nil {
return false
}
// exact whitelists are O(1)ish to check, so look there first
if rc.config.WhitelistExact[path] {
return true
}
// finally we check if any of our whitelist prefixes match
for _, prefix := range rc.config.WhitelistPrefix {
if strings.HasPrefix(path, prefix) {
return true
}
}
return false
}
// Path returns the path to the RC file
func (rc *RC) Path() string {
return rc.path
}
// Touch updates the mtime of the RC file. This is mainly used to trigger a
// reload in direnv.
func (rc *RC) Touch() error {
return touch(rc.path)
}
const notAllowed = "%s is blocked. Run `direnv allow` to approve its content"
// Load evaluates the RC file and returns the new Env or error.
//
// This functions is key to the implementation of direnv.
func (rc *RC) Load(previousEnv Env) (newEnv Env, err error) {
config := rc.config
wd := config.WorkDir
direnv := config.SelfPath
newEnv = previousEnv.Copy()
newEnv[DIRENV_WATCHES] = rc.times.Marshal()
defer func() {
// Record directory changes even if load is disallowed or fails
newEnv[DIRENV_DIR] = "-" + filepath.Dir(rc.path)
newEnv[DIRENV_FILE] = rc.path
newEnv[DIRENV_DIFF] = previousEnv.Diff(newEnv).Serialize()
}()
// Abort if the file is not allowed
if !rc.Allowed() {
err = fmt.Errorf(notAllowed, rc.Path())
return
}
// Allow RC loads to be canceled with SIGINT
ctx, cancel := context.WithCancel(context.Background())
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt)
go func() {
<-c
cancel()
}()
// check what type of RC we're processing
// use different exec method for each
fn := "source_env"
if filepath.Base(rc.path) == ".env" {
fn = "dotenv"
}
// Set stdin based on the config
var stdin *os.File
if config.DisableStdin {
stdin, err = os.Open(os.DevNull)
if err != nil {
return
}
} else {
stdin = os.Stdin
}
prelude := ""
if config.StrictEnv {
prelude = "set -euo pipefail && "
}
// Non-Windows platforms will already use slashes. However, on Windows
// backslashes are used by default which can result in unexpected escapes
// like \b or \r in paths. Force slash usage to avoid issues on Windows.
slashSeparatedPath := filepath.ToSlash(rc.Path())
arg := fmt.Sprintf(
`%seval "$("%s" stdlib)" && __main__ %s %s`,
prelude,
direnv,
fn,
BashEscape(slashSeparatedPath),
)
// G204: Subprocess launched with function call as argument or cmd arguments
// #nosec
cmd := exec.CommandContext(ctx, config.BashPath, "-c", arg)
cmd.Dir = wd
cmd.Env = newEnv.ToGoEnv()
cmd.Stdin = stdin
cmd.Stderr = os.Stderr
var out []byte
if out, err = cmd.Output(); err == nil && len(out) > 0 {
var newEnv2 Env
newEnv2, err = LoadEnvJSON(out)
if err == nil {
newEnv = newEnv2
}
}
return
}
/// Utils
func eachDir(path string) (paths []string) {
path, err := filepath.Abs(path)
if err != nil {
return
}
paths = []string{path}
if path == "/" {
return
}
for i := len(path) - 1; i >= 0; i-- {
if path[i] == os.PathSeparator {
path = path[:i]
if path == "" {
path = "/"
}
paths = append(paths, path)
}
}
return
}
func fileExists(path string) bool {
// Some broken filesystems like SSHFS return file information on stat() but
// then cannot open the file. So we use os.Open.
f, err := os.Open(path)
if err != nil {
return false
}
defer f.Close()
// Next, check that the file is a regular file.
fi, err := f.Stat()
if err != nil {
return false
}
return fi.Mode().IsRegular()
}
func fileHash(path string) (hash string, err error) {
if path, err = filepath.Abs(path); err != nil {
return
}
fd, err := os.Open(path)
if err != nil {
return
}
hasher := sha256.New()
_, err = hasher.Write([]byte(path + "\n"))
if err != nil {
return
}
if _, err = io.Copy(hasher, fd); err != nil {
return
}
return fmt.Sprintf("%x", hasher.Sum(nil)), nil
}
// Creates a file
func touch(path string) (err error) {
t := time.Now()
return os.Chtimes(path, t, t)
}
func allow(path string, allowPath string) (err error) {
// G306: Expect WriteFile permissions to be 0600 or less
// #nosec
return os.WriteFile(allowPath, []byte(path+"\n"), 0644)
}
func findEnvUp(searchDir string, loadDotenv bool) (path string) {
if loadDotenv {
return findUp(searchDir, ".envrc", ".env")
}
return findUp(searchDir, ".envrc")
}
func findUp(searchDir string, fileNames ...string) (path string) {
for _, dir := range eachDir(searchDir) {
for _, fileName := range fileNames {
path := filepath.Join(dir, fileName)
if fileExists(path) {
return path
}
}
}
return ""
}