web-dev-qa-db-fra.com

Connexion à une URL distante nécessitant une authentification à l'aide de Java

Comment puis-je me connecter à une URL distante en Java qui nécessite une authentification? J'essaie de trouver un moyen de modifier le code suivant pour pouvoir fournir par programme un nom d'utilisateur/mot de passe afin qu'il ne lance pas un 401.

URL url = new URL(String.format("http://%s/manager/list", _Host + ":8080"));
HttpURLConnection connection = (HttpURLConnection)url.openConnection();
javahttpurlconnection
108
user14128

Vous pouvez définir l'authentificateur par défaut pour les demandes http comme ceci:

Authenticator.setDefault (new Authenticator() {
    protected PasswordAuthentication getPasswordAuthentication() {
        return new PasswordAuthentication ("username", "password".toCharArray());
    }
});

De plus, si vous avez besoin de plus de flexibilité, vous pouvez consulter/ Apache HttpClient , qui vous donnera plus d'options d'authentification (ainsi que le support de session, etc.).

122
James Van Huis

Il existe une alternative native et moins intrusive, qui ne fonctionne que pour votre appel.

URL url = new URL(“location address”);
URLConnection uc = url.openConnection();
String userpass = username + ":" + password;
String basicAuth = "Basic " + new String(Base64.getEncoder().encode(userpass.getBytes()));
uc.setRequestProperty ("Authorization", basicAuth);
InputStream in = uc.getInputStream();
112
Wanderson Santos

Vous pouvez également utiliser les éléments suivants, qui n'exigent pas l'utilisation de packages externes:

URL url = new URL(“location address”);
URLConnection uc = url.openConnection();

String userpass = username + ":" + password;
String basicAuth = "Basic " + javax.xml.bind.DatatypeConverter.printBase64Binary(userpass.getBytes());

uc.setRequestProperty ("Authorization", basicAuth);
InputStream in = uc.getInputStream();
76
gloo

Si vous utilisez le login normal en entrant le nom d'utilisateur et le mot de passe entre le protocole et le domaine, c'est plus simple. Cela fonctionne aussi avec et sans connexion.

Exemple d'URL: http: // utilisateur: [email protected]/url

URL url = new URL("http://user:[email protected]/url");
URLConnection urlConnection = url.openConnection();

if (url.getUserInfo() != null) {
    String basicAuth = "Basic " + new String(new Base64().encode(url.getUserInfo().getBytes()));
    urlConnection.setRequestProperty("Authorization", basicAuth);
}

InputStream inputStream = urlConnection.getInputStream();
37
javabeangrinder

Comme je suis venu ici à la recherche d'une réponse Android-Java, je vais faire un bref résumé:

  1. Utilisez Java.net.Authenticator comme indiqué par James van Huis
  2. Utilisez Client HTTP Apache Commons}, comme dans this Answer
  3. Utilisez basic Java.net.URLConnection et définissez manuellement l'en-tête d'authentification comme indiqué ici

Si vous voulez utiliser Java.net.URLConnection avec l'authentification de base dans Android, essayez ce code:

URL url = new URL("http://www.mywebsite.com/resource");
URLConnection urlConnection = url.openConnection();
String header = "Basic " + new String(Android.util.Base64.encode("user:pass".getBytes(), Android.util.Base64.NO_WRAP));
urlConnection.addRequestProperty("Authorization", header);
// go on setting more request headers, reading the response, etc
8
DaniEll

Soyez très prudent avec l’approche "Base64 (). Encode ()", mon équipe et moi avons reçu 400 problèmes de requêtes d’Apache car ils ajoutent un\r\n à la fin de la chaîne générée.

Nous l'avons trouvé en train de renifler des paquets grâce à Wireshark.

Voici notre solution:

import org.Apache.commons.codec.binary.Base64;

HttpGet getRequest = new HttpGet(endpoint);
getRequest.addHeader("Authorization", "Basic " + getBasicAuthenticationEncoding());

private String getBasicAuthenticationEncoding() {

        String userPassword = username + ":" + password;
        return new String(Base64.encodeBase64(userPassword.getBytes()));
    }

J'espère que ça aide!

3
lboix

Utilisez ce code pour l'authentification de base.

URL url = new URL(path);
String userPass = "username:password";
String basicAuth = "Basic " + Base64.encodeToString(userPass.getBytes(), Base64.DEFAULT);//or
//String basicAuth = "Basic " + new String(Base64.encode(userPass.getBytes(), Base64.No_WRAP));
HttpURLConnection urlConnection = (HttpURLConnection)url.openConnection();
urlConnection.setRequestProperty("Authorization", basicAuth);
urlConnection.connect();

3
Sarith Nob

J'aimerais apporter une réponse au cas où vous n'avez pas le contrôle du code qui ouvre la connexion. Comme je l’ai fait lors de l’utilisation de la variable URLClassLoader pour charger un fichier jar à partir d’un serveur protégé par mot de passe.

La solution Authenticator fonctionnerait, mais elle présentait l'inconvénient d'essayer tout d'abord de joindre le serveur sans mot de passe et uniquement après que le serveur en a demandé un. C'est un aller-retour inutile si vous savez déjà que le serveur aurait besoin d'un mot de passe.

public class MyStreamHandlerFactory implements URLStreamHandlerFactory {

    private final ServerInfo serverInfo;

    public MyStreamHandlerFactory(ServerInfo serverInfo) {
        this.serverInfo = serverInfo;
    }

    @Override
    public URLStreamHandler createURLStreamHandler(String protocol) {
        switch (protocol) {
            case "my":
                return new MyStreamHandler(serverInfo);
            default:
                return null;
        }
    }

}

public class MyStreamHandler extends URLStreamHandler {

    private final String encodedCredentials;

    public MyStreamHandler(ServerInfo serverInfo) {
        String strCredentials = serverInfo.getUsername() + ":" + serverInfo.getPassword();
        this.encodedCredentials = Base64.getEncoder().encodeToString(strCredentials.getBytes());
    }

    @Override
    protected URLConnection openConnection(URL url) throws IOException {
        String authority = url.getAuthority();
        String protocol = "http";
        URL directUrl = new URL(protocol, url.getHost(), url.getPort(), url.getFile());

        HttpURLConnection connection = (HttpURLConnection) directUrl.openConnection();
        connection.setRequestProperty("Authorization", "Basic " + encodedCredentials);

        return connection;
    }

}

Cela enregistre un nouveau protocole my qui est remplacé par http lorsque les informations d'identification sont ajoutées. Donc, lors de la création de la nouvelle URLClassLoader, remplacez simplement http par my et tout va bien. Je sais que URLClassLoader fournit un constructeur qui prend une URLStreamHandlerFactory, mais cette fabrique n'est pas utilisée si l'URL pointe vers un fichier JAR.

2
FLUXparticle

Depuis Java 9, vous pouvez le faire

URL url = new URL("http://www.example.com");
HttpURLConnection connection = (HttpURLConnection)url.openConnection();
connection.setAuthenticator(new Authenticator() {
    protected PasswordAuthentication getPasswordAuthentication() {
        return new PasswordAuthentication ("USER", "PASS".toCharArray());
    }
});
1
Punyapat

Était capable de définir l'auth en utilisant le HttpsURLConnection

           URL myUrl = new URL(httpsURL);
            HttpsURLConnection conn = (HttpsURLConnection)myUrl.openConnection();
            String userpass = username + ":" + password;
            String basicAuth = "Basic " + new String(Base64.getEncoder().encode(userpass.getBytes()));
            //httpsurlconnection
            conn.setRequestProperty("Authorization", basicAuth);

quelques-uns des changements extraits de ce post. et Base64 provient du package Java.util.

0
Tim

ANDROID IMPLEMENTATION Méthode complète pour demander une réponse de type données/chaîne au service Web demandant une autorisation avec un nom d'utilisateur et un mot de passe.

public static String getData(String uri, String userName, String userPassword) {
        BufferedReader reader = null;
        byte[] loginBytes = (userName + ":" + userPassword).getBytes();

        StringBuilder loginBuilder = new StringBuilder()
                .append("Basic ")
                .append(Base64.encodeToString(loginBytes, Base64.DEFAULT));

        try {
            URL url = new URL(uri);
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.addRequestProperty("Authorization", loginBuilder.toString());

            StringBuilder sb = new StringBuilder();
            reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
            String line;
            while ((line = reader.readLine())!= null){
                sb.append(line);
                sb.append("\n");
            }

            return  sb.toString();

        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            if (null != reader){
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
0
Emmanuel Mtali

je l'ai fait de cette façon, vous devez le faire il suffit de copier coller coller soit heureux

    HttpURLConnection urlConnection;
    String url;
 //   String data = json;
    String result = null;
    try {
        String username ="[email protected]";
        String password = "12345678";

        String auth =new String(username + ":" + password);
        byte[] data1 = auth.getBytes(UTF_8);
        String base64 = Base64.encodeToString(data1, Base64.NO_WRAP);
        //Connect
        urlConnection = (HttpURLConnection) ((new URL(urlBasePath).openConnection()));
        urlConnection.setDoOutput(true);
        urlConnection.setRequestProperty("Content-Type", "application/json");
        urlConnection.setRequestProperty("Authorization", "Basic "+base64);
        urlConnection.setRequestProperty("Accept", "application/json");
        urlConnection.setRequestMethod("POST");
        urlConnection.setConnectTimeout(10000);
        urlConnection.connect();
        JSONObject obj = new JSONObject();

        obj.put("MobileNumber", "+97333746934");
        obj.put("EmailAddress", "[email protected]");
        obj.put("FirstName", "Danish");
        obj.put("LastName", "Hussain");
        obj.put("Country", "BH");
        obj.put("Language", "EN");
        String data = obj.toString();
        //Write
        OutputStream outputStream = urlConnection.getOutputStream();
        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(outputStream, "UTF-8"));
        writer.write(data);
        writer.close();
        outputStream.close();
        int responseCode=urlConnection.getResponseCode();
        if (responseCode == HttpsURLConnection.HTTP_OK) {
            //Read
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(urlConnection.getInputStream(), "UTF-8"));

        String line = null;
        StringBuilder sb = new StringBuilder();

        while ((line = bufferedReader.readLine()) != null) {
            sb.append(line);
        }

        bufferedReader.close();
        result = sb.toString();

        }else {
        //    return new String("false : "+responseCode);
        new String("false : "+responseCode);
        }

    } catch (UnsupportedEncodingException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } catch (JSONException e) {
        e.printStackTrace();
    }
0
Syed Danish Haider