Usando cURL com um nome de usuário e senha?

Quero acessar um URL que exija um nome de usuário / senha. Eu gostaria de tentar acessá-lo com curl. No momento, estou fazendo algo como:

curl http://api.somesite.com/test/blah?something=123

Eu recebo um erro. Eu acho que preciso especificar um nome de usuário e senha junto com o comando acima.

Como eu posso fazer isso?

Use o -usinalizador para incluir um nome de usuário e o curl solicitará uma senha:

curl -u username http://example.com

Você também pode incluir a senha no comando, mas sua senha ficará visível no histórico do bash:

curl -u username:password http://example.com

É mais seguro fazer:

curl --netrc-file my-password-file http://example.com

... passar uma linha simples de usuário / senha na linha de comando é uma má idéia.

O formato do arquivo de senha é (conforme man curl):

machine <example.com> login <username> password <password>

Nota:

1. O nome da máquina não deve incluir https://ou semelhante! Apenas o nome do host.
2. As palavras ' machine', ' login' e ' password' são apenas palavras-chave; as informações reais são o material após essas palavras-chave.

Ou a mesma coisa, mas com sintaxe diferente

curl http://username:[email protected]/test/blah?something=123

Você também pode enviar o nome de usuário escrevendo:

curl -u USERNAME http://server.example

O Curl solicitará a senha e a senha não estará visível na tela (ou se você precisar copiar / colar o comando).

Para passar com segurança a senha em um script (ou seja, impedir que ela apareça no ps auxf ou nos logs), você pode fazê-lo com o sinalizador -K- (leia a configuração do stdin) e um heredoc:

curl --url url -K- <<< "--user user:password"

Geralmente, o comando CURL se refere como

curl https://example.com\?param\=ParamValue -u USERNAME:PASSWORD

se você não tiver nenhuma senha ou desejar pular o prompt de comando para exigir senha, deixe a seção de senha em branco.

ie curl https://example.com\?param\=ParamValue -u USERNAME:

curl -X GET -u username:password  {{ http://www.example.com/filename.txt }} -O

Para deixar a senha pelo menos não aparecer na sua .bash_history:

curl -u user:$(cat .password-file) http://example-domain.tld

bem fácil, faça o seguinte:

curl -X GET/POST/PUT <URL> -u username:password

Outras respostas sugeriram ao netrc para especificar nome de usuário e senha, com base no que li, concordo. Aqui estão alguns detalhes de sintaxe:

https://ec.haxx.se/usingcurl-netrc.html

Como outras respostas, gostaria de enfatizar a necessidade de prestar atenção à segurança em relação a essa pergunta.

Embora eu não seja um especialista, achei esses links interessantes:

https://ec.haxx.se/cmdline-passwords.html

Para resumir:

O uso das versões criptografadas dos protocolos (HTTPS vs HTTP) (FTPS vs FTP) pode ajudar a evitar vazamento de rede.

O uso do netrc pode ajudar a evitar vazamento da linha de comando.

Para dar um passo adiante, parece que você também pode criptografar os arquivos netrc usando gpg

https://brandur.org/fragments/gpg-curl

Com isso, suas credenciais não estão "em repouso" (armazenadas) como texto sem formatação.

De maneira clara e simples, a maneira mais segura seria usar variáveis ​​de ambiente para armazenar / recuperar suas credenciais. Assim, um comando curl como:

curl -Lk -XGET -u "${API_USER}:${API_HASH}" -b cookies.txt -c cookies.txt -- "http://api.somesite.com/test/blah?something=123"

Chamaria sua API repousante e passaria o WWW_Authenticationcabeçalho http com os valores codificados em Base64 de API_USERe API_HASH. O -Lkjust diz ao curl para seguir os redirecionamentos http 30x e usar o tratamento inseguro de tls (ou seja, ignorar erros de ssl). Enquanto o double --é apenas bash sugar sugar para parar o processamento de sinalizadores de linha de comando. Além disso, os sinalizadores -b cookies.txte -c cookies.txtlidam com cookies com o -benvio de cookies e-c armazenando cookies localmente.

O manual tem mais exemplos de métodos de autenticação .

Você pode usar comandos como,

curl -u user-name -p http://www.example.com/path-to-file/file-name.ext > new-file-name.ext

A senha HTTP será acionada.

Referência: http://www.asempt.com/article/how-use-curl-http-password-protected-site

A maneira mais segura de passar credenciais para ondular deve ser solicitada para inseri-las. É o que acontece ao passar o nome de usuário, conforme sugerido anteriormente (-u USERNAME ).

Mas e se você não puder passar o nome de usuário dessa maneira? Por exemplo, o nome de usuário pode precisar fazer parte do URL e apenas a senha fazer parte de uma carga útil do json.

tl; dr: Isto é como usar o curl com segurança neste caso:

read -p "Username: " U; read -sp "Password: " P; curl --request POST -d "{\"password\":\"${P}\"}" https://example.com/login/${U}; unset P U

read solicitará o nome de usuário e a senha na linha de comando e armazenará os valores enviados em duas variáveis ​​que podem ser referências em comandos subseqüentes e finalmente desabilitadas.

Vou explicar por que as outras soluções não são ideais.

Por que as variáveis ​​de ambiente são inseguras

1. O modo de acesso e exposição do conteúdo de uma variável de ambiente não pode ser rastreado (ps -eww), pois o ambiente está implicitamente disponível para um processo
2. Geralmente, os aplicativos capturam todo o ambiente e registram-no para fins de depuração ou monitoramento (às vezes em arquivos de log em texto sem formatação no disco, especialmente depois que um aplicativo falha)
3. Variáveis ​​de ambiente são passadas para processos filhos (quebrando, portanto, o princípio do menor privilégio)
4. Mantê-los é um problema: os novos engenheiros não sabem que estão lá e não estão cientes dos requisitos ao seu redor - por exemplo, para não repassá-los aos subprocessos - já que eles não são impostos ou documentados.

Por que não é seguro digitá-lo diretamente em um comando na linha de comando? Porque seu segredo acaba sendo visível por qualquer outro usuário em execução, ps -auxuma vez que lista os comandos enviados para cada processo em execução no momento. Também porque o seu segredo acaba no histórico do bash (quando o shell termina).

Por que não é seguro incluí-lo em um arquivo local? A restrição estrita de acesso POSIX no arquivo pode reduzir o risco nesse cenário. No entanto, ainda é um arquivo no seu sistema de arquivos, não criptografado em repouso.

Eu tinha a mesma necessidade no bash (Ubuntu 16.04 LTS) e os comandos fornecidos nas respostas não funcionaram no meu caso. Eu tive que usar:

curl -X POST -F 'username="$USER"' -F 'password="$PASS"' "http://api.somesite.com/test/blah?something=123"

As aspas duplas nos -Fargumentos serão necessárias apenas se você estiver usando variáveis, portanto, a partir da linha de comando ... -F 'username=myuser' ..., tudo bem.

Aviso de segurança relevante: como o Sr. Mark Ribau aponta nos comentários, este comando mostra a senha (variável $ PASS, expandida) na lista de processos!

Se você estiver em um sistema com o aplicativo de chaveiro Gnome, uma solução que evite expor a senha diretamente é usar gkeyring.py para extrair a senha do chaveiro:

server=server.example.com
file=path/to/my/file
user=my_user_name
pass=$(gkeyring.py -k login -tnetwork -p user=$user,server=$server -1)

curl -u $user:$pass ftps://$server/$file -O

Isso é MUITO mais do que o OP pediu, mas como esse é o melhor resultado para a passagem segura de senhas curl, estou adicionando essas soluções aqui para outras pessoas que chegam aqui procurando por isso.

NOTA: -sarg para o readcomando não é POSIX e, portanto, não está disponível em todos os lugares, portanto não será usado abaixo. Vamos usar stty -echoe, em stty echovez disso.

NOTA: Todas as variáveis ​​bash abaixo podem ser declaradas como locais se estiverem em uma função, em vez de serem desmarcadas.

NOTA: perlé muito geralmente disponíveis em todos os sistemas que eu tentei, devido a ser uma dependência para muitas coisas, enquanto rubye pythonnão são, portanto, usando perlaqui. Se você pode garantir ruby/ pythononde está fazendo isso, pode substituir o perlcomando pelo equivalente.

NOTA: Testado em bash3.2.57 no macOS 10.14.4. Alguma pequena tradução pode ser necessária para outros shells / instalações.

Solicite com segurança ao usuário uma senha (reutilizável) a ser transmitida. Particularmente útil se você precisar chamar o enrolamento várias vezes.

Para cascas modernas, onde echoestá um embutido (verifique via which echo):

url='https://example.com'
printf "Username: "
read username
printf "Password: "
stty -echo  # disables echoing user input, POSIX equivalent for 'read -s'
read pass
printf "\n" # we need to move the line ahead
stty echo   # re-enable echoing user input
echo ${pass} | sed -e "s/^/-u ${username}:/" | curl --url "${url}" -K-
unset username
unset pass

Para shells mais antigos, onde echoé algo parecido /bin/echo(onde tudo o que ecoa pode ser visto na lista de processos):
ESTA VERSÃO NÃO PODE REUTILIZAR A SENHA , veja em baixo.

url='https://example.com'
printf "Username: "
read username
printf "Password: "
stty -echo  # disables echoing user input, POSIX equivalent for 'read -s'
perl -e '
    my $val=<STDIN>;
    chomp $val;
    print STDERR "\n";  # we need to move the line ahead, but not send a newline down the pipe
    print $val;
' | sed -e "s/^/-u ${username}:/" | curl --url "${url}" -K-
stty echo   # re-enable echoing user input
unset username

Se você precisar armazenar temporariamente a senha em um arquivo, reutilizá-la para vários comandos antes de limpá-la (por exemplo, você está usando funções para reutilização de código e não deseja repetir o código e não pode passe o valor através de eco). (Sim, eles parecem um pouco engenhosos neste formulário, não sendo funções em bibliotecas diferentes; tentei reduzi-los ao código mínimo necessário para mostrá-lo.)

Quando o eco é embutido (isso é especialmente artificial, pois o eco é um embutido, mas é fornecido com integridade):

url='https://example.com'
filepath="$(mktemp)"  # random path, only readable by current user
printf "Username: "
read username
printf "Password: "
stty -echo  # disables echoing user input, POSIX equivalent for 'read -s'
read pass
echo "${pass}" > "${filepath}"
unset pass
printf "\n" # we need to move the line ahead
stty echo   # re-enable echoing user input

cat "${filepath}" | sed -e "s/^/-u ${username}:/" | curl --url "${url}" -K-

rm "${filepath}"  # don't forget to delete the file when done!!
unset username

Quando eco é algo como /bin/echo:

url='https://example.com'
filepath="$(mktemp)"  # random path, only readable by current user
printf "Username: "
read username
printf "Password: "
stty -echo  # disables echoing user input, POSIX equivalent for 'read -s'
$(perl -e '
    my $val=<STDIN>;
    chomp $val;
    open(my $fh, ">", $ARGV[0]) or die "Could not open file \"$ARGV[0]\" $\!";
    print $fh $val;
    close $fh;
' "$filepath")
printf "\n" # we need to move the line ahead
stty echo   # re-enable echoing user input

cat "${filepath}" | sed -e "s/^/-u ${username}:/" | curl --url "${url}" -K-

rm "${filepath}"  # don't forget to delete the file when done!!
unset username