Copy file from remote to byte[]

I'm trying to figure out how to implement copying files from remote and get the data []byte from the buffer.

I have succeeded in doing the implementation with the upload by referring to this guide: https://chuacw.ath.cx/development/b/chuacw/archive/2019/02/04/how-the-scp-protocol-works.aspx

Inside the go func there's the implementation of the upload process of the SCP but I have no idea how to change it.

Any advice ?

func download(con *ssh.Client, buf bytes.Buffer, path string,) ([]byte,error) {
	//https://chuacw.ath.cx/development/b/chuacw/archive/2019/02/04/how-the-scp-protocol-works.aspx
	session, err := con.NewSession()
	if err != nil {
		return nil,err
	}

	buf.WriteString("sudo scp -f " + path + "\n")

	stdin, err := session.StdinPipe()
	if err != nil {
		return nil,err
	}
	go func() {
		defer stdin.Close()
		fmt.Fprint(stdin, "C0660 "+strconv.Itoa(len(content))+" file\n")
		stdin.Write(content)
		fmt.Fprint(stdin, "\x00")
	}()

	output, err := session.CombinedOutput("sudo scp -f " + path)
	buf.Write(output)
	if err != nil {
		return nil,&DeployError{
			Err:    err,
			Output: buf.String(),
		}
	}

	session.Close()

	session, err = con.NewSession()
	if err != nil {
		return nil,err
	}
	defer session.Close()

	return output,nil
}

The sink side is significantly more difficult than the source side. Made an example which should get you close to what you want. Note that I have not tested this code, that the error handling is sub optimal and it only supports 1/4th the protocol messages SCP may use. So you will still need to do some work to get it perfect.

With all that said, this is what I came up with:

func download(con *ssh.Client, path string) ([]byte, error) {
	//https://chuacw.ath.cx/development/b/chuacw/archive/2019/02/04/how-the-scp-protocol-works.aspx
	session, err := con.NewSession()
	if err != nil {
		return nil, err
	}
	defer session.Close()

	// Local -> remote
	stdin, err := session.StdinPipe()
	if err != nil {
		return nil, err
	}
	defer stdin.Close()

	// Request a file, note that directories will require different handling
	_, err = stdin.Write([]byte("sudo scp -f " + path + "\n"))
	if err != nil {
		return nil, err
	}

	// Remote -> local
	stdout, err := session.StdoutPipe()
	if err != nil {
		return nil, err
	}

	// Make a buffer for the protocol messages
	const megabyte = 1 << 20
	b := make([]byte, megabyte)

	// Offset into the buffer
	off := 0

	var filesize int64

	// SCP may send multiple protocol messages, so keep reading
	for {
		n, err := stdout.Read(b[off:])
		if err != nil {
			return nil, err
		}

		nl := bytes.Index(b[:off+n], []byte("\n"))
		// If there is no newline in the buffer, we need to read more
		if nl == -1 {
			off = off + n
			continue
		}

		// We read a full message, reset the offset
		off = 0

		// if we did get a new line. We have the full protocol message
		msg := string(b[:nl])

		// Send back 0, which means OK, the SCP source will not send the next message otherwise
		_, err = stdin.Write([]byte("0\n"))
		if err != nil {
			return nil, err
		}

		// First char is the mode (C=file, D=dir, E=End of dir, T=Time metadata)
		mode := msg[0]
		if mode != 'C' {
			// Ignore other messags for now.
			continue
		}

		// File message = Cmmmm <length> <filename>
		msgParts := strings.Split(msg, " ")
		if len(msgParts) > 1 {
			// Parse the second part <length> as an base 10 integer
			filesize, err = strconv.ParseInt(msgParts[1], 10, 64)
			if err != nil {
				return nil, err
			}
		}

		// The file message will be followed with binary data containing the file
		break
	}

	// Wrap the stdout reader in a limit reader so we will not read more than the filesize
	fileReader := io.LimitReader(stdout, filesize)
	// Seed the bytes buffer with the existing byte slice, saves additional allocation if file <= 1mb
	buf := bytes.NewBuffer(b)

	// Copy the file into the bytes buffer
	_, err = io.Copy(buf, fileReader)
	return buf.Bytes(), err
}