Como o WinSCP é capaz de fornecer um usuário sudo para executar o scp?

Question

A ferramenta WinSCP é capaz de executar um sudo na máquina remota para executar o scp como o usuário sudo. Isso me leva a pensar que isso deve ser possível com a versão de linha de comando de scp também.

Nos envoltórios, como o WinSCP está executando isso?

Eu não quero trabalhar com uma solução com um diretório intermediário de usuário . Os arquivos podem ser tão grandes que preciso postar diretamente usando o usuário sudo . Como resultado, o arquivo foi copiado, mas para o meu diretório local, não o diretório sudo.

Uma solução pode ser canalizando manualmente o ssh :

tar zcvf -  MyBackups | ssh user@server "cat > /path/to/backup/foo.tgz"

O que eu acho que poderia personalizar para fazer o sudo da seguinte forma:

cat local.txt | ssh user@server "sudo -u sudouser cat > ~/remote_file"

O único problema é que, ao fazer isso dessa maneira, tenho muito trabalho a resolver que já foi implementado usando a base scp . Por essa e outras razões, também não quero usar essa solução.

Como posso deixar scp manipular uma cópia direta para o remoto usando sudo para alterar o usuário para que eu tenha acesso aos seus privilégios.

    

Answer 1

Como o SCP funciona

O funcionamento interno de scp depende de duas formas não documentadas de scp , que é scp -f e scp -t . Eles são basicamente servidores remotos ouvindo stdin e gerando dados sobre stdout. Esses processos usam um protocolo semelhante ao que o sftp faria. Mais informações podem ser encontradas em um Blog da Oracle .

Quando scp for iniciado, primeiro ele iniciará uma sessão ssh para iniciar scp -t ou scp -f . Seu processo scp local se comunicará com o processo scp remoto por meio de stdout e stdin canalizado para ssh (totalmente criptografado) e servirá como stdin / stdout para sua sessão scp remota.

Como personalizar

O comando scp fornece uma opção -s que permite personalizar o programa usado para configurar a sessão scp remota. Espera-se lidar com todas as opções típicas de ssh . Para ajudar a depurar como isso pode parecer, configuramos um programa fictício que apenas elimina os parâmetros:

/tmp/scp-dump.sh:

echo $0 $*

Vamos executá-lo da seguinte forma:

scp -S /tmp/scp-dump.sh /tmp/dump.txt [email protected]:/tmp

E, apropriadamente, obtemos a seguinte saída:

/home/me/dump.sh \
    -x -oForwardAgent=no \
    -oPermitLocalCommand=no \
    -oClearAllForwardings=yes \
    -l me -- server.com scp -t /tmp

Quebras de linha com contrabarra foram adicionadas para facilitar a leitura.

Isso nos permite uma oportunidade de modificar os parâmetros e comandos antes de enviá-lo para o comando ssh .

Configurando o sudo

agora podemos escrever um programa para modificar os parâmetros conforme necessário, iniciar o ssh e usar um formulário modificado para iniciar o scp -t . Basicamente capturaremos os parâmetros, prendemos aqueles que queremos usar internamente, apenas adicionamos outros e fazemos alterações.

/tmp/scp-sudo.sh :

add_ssh_option() {
  local option
  if [ $# = 2 ]; then
    option="$1 \"$2\""
  else
    option="$1"
  fi
  if [ -z "${ssh_options}" ]; then
    ssh_options=${option}
  else
    ssh_options="${ssh_options} ${option}"
  fi
}

parse_options() {
  ssh_options=
  local option
  while [ $# > 0 ] ; do
    case $1 in
      -oSudoUser=* )
        SSH_SUDO_USER=${option##*=}
        shift
        ;;
      -l ) ssh_user=$2 ; shift 2 ;;
      -i ) add_ssh_option "$1" "$2" ; shift 2 ;;
      -- ) shift ; break ;;
      -* ) add_ssh_option "${1}" ; shift ;;
      *  ) break ;;
    esac
  done
  ssh_host=$1
  shift
  ssh_command="$*"
}

parse_options "$@"
# To avoid intererence with Standard-In, we change this to
# Strict:
add_ssh_option "-oStrictHostKeyChecking=yes"

if [ -z "${SSH_SUDO_USER}" ]; then
  # As before without sudo
  cat | ssh $ssh_options -l $ssh_user $ssh_host $ssh_command
  exit $?
else
  # Send standard-in to the customized "scp -t" sink.
  cat | ssh $ssh_options -l $ssh_user $ssh_host sudo -i -u ${SSH_SUDO_USER} $ssh_command
  exit $?
fi

Agora podemos usar o formulário scp modificado:

scp -oSudoUser=other \
    -i /tmp/me-id_rsa \
    /tmp/scp-sudo.sh \
    /tmp/dump.txt \
    [email protected]:/tmp

Isso funciona bem para enviar um arquivo para remoto. No entanto, quando eu recuperar um arquivo remoto, de alguma forma, trava. Quando eu quebro a sessão (control-c), vejo que a transferência foi bem sucedida, mas de alguma forma eu tenho um arquivo extra chamado "0". Imagino se alguém pode me ajudar com isso?

Melhor Opção: sftp

No entanto, o sftp é muito melhor.

1. tem a opção -S - permitindo definir toda a linha de comando ssh. Eu tive dificuldade em descobrir e fazer funcionar. Eu suspeito que eu não entendo como vincular corretamente stdin / stdout de dentro de um wrapper shell-ssh.
2. tem uma opção -s (minúscula) - permitindo definir apenas o subcomando responsável por configurar apenas o servidor remoto. Eu achei mais fácil fazer isso funcionar.
3. Você pode definir o caminho remoto, permissões de arquivos remotos, fazer as duas coisas, etc. de acordo com as páginas de manual do sftp.

Neste caso, simplesmente

sftp -s "sudo -u sudo-user -- /usr/libexec/openssh/sftp-server" [email protected]

Isso me deu o alerta " sftp> " feliz

Observe que o subprograma às vezes está localizado em caminhos diferentes, por exemplo, /usr/libexec/openssh/sftp-server . Eu sugeriria a análise da string " Subsystem sftp " de dentro do arquivo /etc/ssh/sshd_conf ?

    

Answer 2

O Scp funciona fazendo uma conexão ssh com o servidor remoto, depois usando essa conexão para executar outro comando scp no sistema remoto. A instância scp local e a instância remota se comunicam através do link ssh para enviar ou receber arquivos.

O OpenSSH scp, em particular, constrói uma cadeia de comandos do scp para ser executada no sistema remoto. Em seguida, ele inicia o ssh para executar esse comando. O comando ssh eventual invocado é o equivalente a isto:

/path/to/ssh [ssh options...] "scp [scp options...]"

• / path / to / ssh é normalmente um caminho interno para o programa ssh.
• [opções ssh ...] é uma ou mais opções para o programa ssh.
• "scp [scp options ...]" é um único argumento que contém o comando scp e seus argumentos para serem executados no sistema remoto.

O OpenSSH scp não oferece muitas opções para alterar a forma do comando scp remoto. Não há como invocar algo diferente de "scp", ou inserir algo como "sudo" na frente da parte "scp".

Como você notou, o scp tem uma opção para invocar algum outro programa ao invés de ssh. Alguém que sabia como escrever um programa wrapper ssh e ter o scp invoca o wrapper em vez de invocar o ssh diretamente. O wrapper teria que examinar seus argumentos de linha de comando para encontrar o que continha o comando scp, alterar o comando como desejado e depois invocar o ssh com os argumentos de linha de comando alterados.