oauth <h1> - Come impostare l'intestazione di autorizzazione usando curl




manca seo (8)

Come posso passare l'intestazione dell'autorizzazione utilizzando cURL? (eseguibile in /usr/bin/curl ).


Answers

Questo ha funzionato per me:

 curl -H "Authorization: Token xxxxxxxxxxxxxx" https://www.example.com/

Aggiungendo solo così non devi fare clic-through:

curl --user name:password http://www.example.com

o se stai provando a fare l'autenticazione di invio per OAuth 2:

curl -H "Authorization: OAuth <ACCESS_TOKEN>" http://www.example.com

Se non si dispone del token al momento della chiamata, sarà necessario effettuare due chiamate, una per ottenere il token e l'altra per estrarre il token dalla risposta, prestare attenzione a

gettone grep | taglia -d, -f1 | taglia -d \ "-f4

in quanto è la parte che si occupa dell'estrazione del token dalla risposta.

echo "Getting token response and extracting token"    
def token = sh (returnStdout: true, script: """
    curl -S -i -k -X POST https://www.example.com/getToken -H \"Content-Type: application/json\" -H \"Accept: application/json\" -d @requestFile.json | grep token | cut -d, -f1 | cut -d\\" -f4
""").split()

Dopo aver estratto il token puoi usare il token per effettuare chiamate successive come segue.

echo "Token : ${token[-1]}"       
echo "Making calls using token..."       
curl -S -i -k  -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Bearer ${token[-1]}" https://www.example.com/api/resources 

http://curl.haxx.se/docs/httpscripting.html

Vedere la parte 6. Autenticazione HTTP

Autenticazione HTTP

L'autenticazione HTTP è la capacità di comunicare al server il tuo nome utente e la tua password in modo che possa verificare che sei autorizzato a fare la richiesta che stai facendo. L'autenticazione di base utilizzata in HTTP (che per impostazione predefinita è il tipo arricciato) è basata su testo semplice , il che significa che invia nome utente e password solo leggermente offuscati, ma comunque completamente leggibili da chiunque annusa sulla rete tra te e il server remoto.

Dire a curl di usare un utente e una password per l'autenticazione:

curl --user name:password http://www.example.com

Il sito potrebbe richiedere un metodo di autenticazione diverso (controlla le intestazioni restituite dal server), quindi --ntlm, --digest, --notify o even --anyauth potrebbero essere le opzioni più adatte a te.

A volte l'accesso HTTP è disponibile solo tramite l'uso di un proxy HTTP. Questo sembra essere particolarmente comune in varie aziende. Un proxy HTTP può richiedere il proprio utente e password per consentire al client di accedere a Internet. Per specificare quelli con arricciatura, eseguire qualcosa come:

curl --proxy-user proxyuser:proxypassword curl.haxx.se

Se il tuo proxy richiede che l'autenticazione venga eseguita usando il metodo NTLM, usa --proxy-ntlm, se richiede l'uso di Digest --proxy-digest.

Se si utilizza una di queste opzioni utente + password ma si omette la parte password, arricciatura richiederà la password in modo interattivo.

Si noti che quando viene eseguito un programma, è possibile che i suoi parametri siano visibili quando si elencano i processi in esecuzione del sistema. Pertanto, altri utenti potrebbero essere in grado di guardare le tue password se le si passa come semplici opzioni da linea di comando. Ci sono modi per aggirare questo.

Vale la pena notare che mentre questo è il modo in cui l'autenticazione HTTP funziona, molti siti Web non utilizzeranno questo concetto quando forniscono accessi, ecc. Vedere il capitolo Accesso Web più avanti per ulteriori dettagli.


curl -H "Authorization: token_str" http://www.example.com attenzione quando usi: curl -H "Authorization: token_str" http://www.example.com

token_str e Authorization devono essere separati da uno spazio bianco, altrimenti il ‚Äč‚Äčlato server non otterrà l'ambiente HTTP_AUTHORIZATION .


Per l'autenticazione di base HTTP:

curl -H "Authorization: Basic <_your_token_>" http://www.example.com

sostituisci _your_token_ e l'URL.


(per coloro che cercano una risposta php-curl )

$service_url = 'https://example.com/something/something.json';
$curl = curl_init($service_url);
curl_setopt($curl, CURLOPT_HTTPAUTH, CURLAUTH_BASIC);
curl_setopt($curl, CURLOPT_USERPWD, "username:password"); //Your credentials goes here
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
curl_setopt($curl, CURLOPT_POST, true);
curl_setopt($curl, CURLOPT_POSTFIELDS, $curl_post_data);
curl_setopt($curl, CURLOPT_SSL_VERIFYPEER, false); //IMP if the url has https and you don't want to verify source certificate

$curl_response = curl_exec($curl);
$response = json_decode($curl_response);
curl_close($curl);

var_dump($response);

Sono d'accordo con la risposta di TheWhiteRabbit, ma se hai un sacco di chiamate usando HttpClient il codice sembra un po 'ripetitivo a mio parere.

Penso che ci siano 2 modi per migliorare la risposta un po '.

Crea una classe helper per creare il client:

public static class ClientHelper
{
    // Basic auth
    public static HttpClient GetClient(string username,string password)
    {
            var authValue = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(Encoding.UTF8.GetBytes($"{username}:{password}")));

            var client = new HttpClient(){
                DefaultRequestHeaders = { Authorization = authValue}
                //Set some other client defaults like timeout / BaseAddress
            };
            return client;
    }

    // Auth with bearer token
    public static HttpClient GetClient(string token)
    {
            var authValue = new AuthenticationHeaderValue("Bearer", token);

            var client = new HttpClient(){
                DefaultRequestHeaders = { Authorization = authValue}
                //Set some other client defaults like timeout / BaseAddress
            };
            return client;
    }
}

Uso:

using(var client = ClientHelper.GetClient(username,password))
{
    //Perform some http call
}

using(var client = ClientHelper.GetClient(token))
{
    //Perform some http call
}

Crea un metodo di estensione:

Non vince un premio di bellezza ma funziona benissimo :)

    public static class HttpClientExtentions
    {
        public static AuthenticationHeaderValue ToAuthHeaderValue(this string username, string password)
        {
            return new AuthenticationHeaderValue("Basic",
        Convert.ToBase64String(
            System.Text.Encoding.ASCII.GetBytes(
                $"{username}:{password}")));
        }
    }

Uso:

using (var client = new HttpClient())
{
    client.DefaultRequestHeaders.Authorization = _username.ToAuthHeaderValue(_password); 
}

Ancora una volta penso che 2 opzioni precedenti rendano il client che usa l'istruzione un po 'meno ripetitivo. Tieni presente che è consigliabile riutilizzare HttpClient se si effettuano più chiamate http, ma penso che sia un po 'fuori portata per questa domanda.





curl oauth