]> ruderich.org/simon Gitweb - safcm/safcm.git/blob - dial.go
909ec7e1aaf7e70193af9e05d29cbbdd07769f79
[safcm/safcm.git] / dial.go
1 // Simple RPC-like protocol: establish new connection and upload helper
2
3 // Copyright (C) 2021  Simon Ruderich
4 //
5 // This program is free software: you can redistribute it and/or modify
6 // it under the terms of the GNU General Public License as published by
7 // the Free Software Foundation, either version 3 of the License, or
8 // (at your option) any later version.
9 //
10 // This program is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 // GNU General Public License for more details.
14 //
15 // You should have received a copy of the GNU General Public License
16 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
17
18 package rpc
19
20 import (
21         "bufio"
22         "bytes"
23         "crypto/sha512"
24         "encoding/hex"
25         "fmt"
26         "io"
27         "os/exec"
28         "strconv"
29         "strings"
30
31         "ruderich.org/simon/safcm"
32         "ruderich.org/simon/safcm/remote"
33 )
34
35 func (c *Conn) DialSSH(user, host, sshConfig string) error {
36         if c.events == nil {
37                 return fmt.Errorf("cannot reuse Conn")
38         }
39
40         remote := host
41         if user != "" {
42                 remote = user + "@" + host
43         }
44         c.debugf("DialSSH: connecting to %q", remote)
45
46         opts := "-eu"
47         if c.debug {
48                 // Help debugging by showing executed shell commands
49                 opts += "x"
50         }
51
52         c.sshRemote = remote
53         if sshConfig != "" {
54                 c.sshOpts = []string{"-F", sshConfig}
55         }
56         c.cmd = exec.Command("ssh",
57                 append(append([]string{}, c.sshOpts...),
58                         c.sshRemote, "/bin/sh", opts)...)
59
60         stdin, err := c.cmd.StdinPipe()
61         if err != nil {
62                 return err
63         }
64         stdout, err := c.cmd.StdoutPipe()
65         if err != nil {
66                 return err
67         }
68         err = c.handleStderrAsEvents(c.cmd)
69         if err != nil {
70                 return err
71         }
72
73         err = c.cmd.Start()
74         if err != nil {
75                 return err
76         }
77
78         err = c.dialSSH(stdin, stdout)
79         if err != nil {
80                 c.Kill()
81                 return err
82         }
83         c.conn = safcm.NewGobConn(stdout, stdin)
84
85         return nil
86 }
87
88 func (c *Conn) dialSSH(stdin io.Writer, stdout_ io.Reader) error {
89         stdout := bufio.NewReader(stdout_)
90
91         goos, err := connGetGoos(stdin, stdout)
92         if err != nil {
93                 return err
94         }
95         goarch, err := connGetGoarch(stdin, stdout)
96         if err != nil {
97                 return err
98         }
99         uid, err := connGetUID(stdin, stdout)
100         if err != nil {
101                 return err
102         }
103
104         path := fmt.Sprintf("/tmp/safcm-remote-%d", uid)
105
106         c.debugf("DialSSH: probing remote at %q", path)
107
108         // Compatibility for different operating systems
109         var compat string
110         switch goos {
111         case "linux":
112                 compat = `
113 dir_stat='drwxrwxrwt 0 0'
114 file_stat="-rwx------ $(id -u) $(id -g)"
115 compat_stat() {
116         stat -c '%A %u %g' "$1"
117 }
118 compat_sha512sum() {
119         sha512sum "$1"
120 }
121 `
122         case "freebsd", "openbsd":
123                 compat = `
124 dir_stat='41777 0 0'
125 file_stat="100700 $(id -u) $(id -g)"
126 compat_stat() {
127         stat -f '%p %u %g' "$1"
128 }
129 compat_sha512sum() {
130         sha512 -q "$1"
131 }
132 `
133         default:
134                 return fmt.Errorf("internal error: no support for %q", goos)
135         }
136
137         // Use a function so the shell cannot execute the input line-wise.
138         // This is important because we're also using stdin to send data to
139         // the script. If the shell executes the input line-wise then our
140         // script is interpreted as input for `read`.
141         //
142         // The target directory must no permit other users to delete our files
143         // or symlink attacks and arbitrary code execution is possible. For
144         // /tmp this is guaranteed by the sticky bit. The code verifies the
145         // directory has the proper permissions.
146         //
147         // We cannot use `test -f && test -O` because this is open to TOCTOU
148         // attacks. `stat` gives use the full file state. If the file is owned
149         // by us and not a symlink then it's safe to use (assuming sticky
150         // directory or directory not writable by others).
151         //
152         // `test -e` is only used to prevent error messages if the file
153         // doesn't exist. It does not guard against any races.
154         _, err = fmt.Fprintf(stdin, `
155 %s
156 f() {
157         x=%q
158
159         dir="$(dirname "$x")"
160         if ! test "$(compat_stat "$dir")" = "$dir_stat"; then
161                 echo "unsafe permissions on $dir, aborting" >&2
162                 exit 1
163         fi
164
165         if test -e "$x" && test "$(compat_stat "$x")" = "$file_stat"; then
166                 # Report checksum
167                 compat_sha512sum "$x"
168         else
169                 # Empty checksum to request upload
170                 echo
171         fi
172
173         # Wait for signal to continue
174         read upload
175
176         if test -n "$upload"; then
177                 tmp="$(mktemp "$x.XXXXXX")"
178                 # Report filename for upload
179                 echo "$tmp"
180
181                 # Wait for upload to complete
182                 read unused
183
184                 # Safely create new file (ln does not follow symlinks)
185                 rm -f "$x"
186                 ln "$tmp" "$x"
187                 rm "$tmp"
188                 # Make file executable
189                 chmod 0700 "$x"
190                 # Some BSD create files with group wheel in /tmp
191                 chgrp "$(id -g)" "$x"
192         fi
193
194         exec "$x" sync
195 }
196 f
197 `, compat, path)
198         if err != nil {
199                 return err
200         }
201         remoteSum, err := stdout.ReadString('\n')
202         if err != nil {
203                 return err
204         }
205
206         // Get embedded helper binary
207         helper, err := remote.Helpers.ReadFile(
208                 fmt.Sprintf("helpers/%s-%s", goos, goarch))
209         if err != nil {
210                 return fmt.Errorf("remote not built for GOOS/GOARCH %s/%s",
211                         goos, goarch)
212         }
213
214         var upload bool
215         if remoteSum == "\n" {
216                 upload = true
217                 c.debugf("DialSSH: remote not present or invalid permissions")
218
219         } else {
220                 x := strings.Fields(remoteSum)
221                 if len(x) < 1 {
222                         return fmt.Errorf("got unexpected checksum line %q",
223                                 remoteSum)
224                 }
225                 sha := sha512.Sum512(helper)
226                 hex := hex.EncodeToString(sha[:])
227                 if hex == x[0] {
228                         c.debugf("DialSSH: remote checksum matches")
229                 } else {
230                         upload = true
231                         c.debugf("DialSSH: remote checksum does not match")
232                 }
233         }
234
235         if upload {
236                 // Notify user that an upload is going to take place.
237                 c.events <- ConnEvent{
238                         Type: ConnEventUpload,
239                 }
240
241                 // Tell script we want to upload a new file.
242                 _, err = fmt.Fprintln(stdin, "upload")
243                 if err != nil {
244                         return err
245                 }
246                 // Get path to temporary file for upload.
247                 //
248                 // Write to the temporary file instead of the final path so
249                 // that a concurrent run of this function won't use a
250                 // partially written file. The rm in the script could still
251                 // cause a missing file but at least no file with unknown
252                 // content is executed.
253                 path, err := stdout.ReadString('\n')
254                 if err != nil {
255                         return err
256                 }
257                 path = strings.TrimSuffix(path, "\n")
258
259                 c.debugf("DialSSH: uploading new remote to %q at %q",
260                         c.sshRemote, path)
261
262                 cmd := exec.Command("ssh",
263                         append(append([]string{}, c.sshOpts...),
264                                 c.sshRemote,
265                                 fmt.Sprintf("cat > %q", path))...)
266                 cmd.Stdin = bytes.NewReader(helper)
267                 err = c.handleStderrAsEvents(cmd) // cmd.Stderr
268                 if err != nil {
269                         return err
270                 }
271                 err = cmd.Run()
272                 if err != nil {
273                         return err
274                 }
275         }
276
277         // Tell script to continue and execute the remote helper
278         _, err = fmt.Fprintln(stdin, "")
279         if err != nil {
280                 return err
281         }
282
283         return nil
284 }
285
286 func connGetGoos(stdin io.Writer, stdout *bufio.Reader) (string, error) {
287         _, err := fmt.Fprintln(stdin, "uname")
288         if err != nil {
289                 return "", err
290         }
291         x, err := stdout.ReadString('\n')
292         if err != nil {
293                 return "", err
294         }
295         x = strings.TrimSpace(x)
296
297         // NOTE: Adapt helper uploading in dialSSH() when adding new systems
298         var goos string
299         switch x {
300         case "Linux":
301                 goos = "linux"
302         case "FreeBSD":
303                 goos = "freebsd"
304         case "OpenBSD":
305                 goos = "openbsd"
306         default:
307                 return "", fmt.Errorf("unsupported OS %q (`uname`)", x)
308         }
309         return goos, nil
310 }
311
312 func connGetGoarch(stdin io.Writer, stdout *bufio.Reader) (string, error) {
313         _, err := fmt.Fprintln(stdin, "uname -m")
314         if err != nil {
315                 return "", err
316         }
317         x, err := stdout.ReadString('\n')
318         if err != nil {
319                 return "", err
320         }
321         x = strings.TrimSpace(x)
322
323         // NOTE: Adapt cmd/safcm-remote/build.sh when adding new architectures
324         var goarch string
325         switch x {
326         case "x86_64", "amd64":
327                 goarch = "amd64"
328         case "armv7l":
329                 goarch = "armv7l"
330         default:
331                 return "", fmt.Errorf("unsupported arch %q (`uname -m`)", x)
332         }
333         return goarch, nil
334 }
335
336 func connGetUID(stdin io.Writer, stdout *bufio.Reader) (int, error) {
337         _, err := fmt.Fprintln(stdin, "id -u")
338         if err != nil {
339                 return -1, err
340         }
341         x, err := stdout.ReadString('\n')
342         if err != nil {
343                 return -1, err
344         }
345         x = strings.TrimSpace(x)
346
347         uid, err := strconv.Atoi(x)
348         if err != nil {
349                 return -1, fmt.Errorf("invalid UID %q (`id -u`)", x)
350         }
351         return uid, nil
352 }