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?
Respostas:
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
print -- '-u username:password' > somewhere && curl -K somewhere http://...
--netrc-file) é mais segura. Ele mantém a senha fora do histórico, ps, seu script etc. Essa é a única forma que eu uso em todos os meus scripts e para todos os usos autenticados de curl.
É 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:
https://ou semelhante! Apenas o nome do host.machine', ' login' e ' password' são apenas palavras-chave; as informações reais são o material após essas palavras-chave.-K <file>ou --config <file>para receber sinalizadores de ondulação via arquivo ou entrada padrão. (Atenção: não deve ser confundido com -kou --insecure!)
.netrcarquivo com permissões adequadamente rigorosas, portanto, apenas o seu usuário possa lê-lo, do que outros mecanismos (por exemplo, argumentos de linha de comando) que permitem que outros usuários leiam as informações.
Ou a mesma coisa, mas com sintaxe diferente
curl http://username:password@api.somesite.com/test/blah?something=123
start "" "http://username:password@api.somesite.com/test/blah?something=123". Pode ser lançado de qualquer lugar. Isso também se aplica a logons de ftp; D
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"
--configopção (-K) ... possivelmente uma solução melhor seria colocar "--user user: password" em um arquivo e simplesmente -K the filepara que você tenha apenas uma cópia da senha e uma cópia em cada script . Muito mais fácil proteger um único arquivo.
cat "${password_filepath}" | sed -e "s/^/-u ${username}:/" | curl --url "${url}" -K-. Eu tive que colocar -K-antes do URL para o antigo macOS bash, YMMV.
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
ps auxw |grep curlna hora certa. Da mesma forma, a senha será registrada se for executada viasudo
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
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