HTTPURL La connessione non segue il reindirizzamento da HTTP a HTTPS

Non riesco a capire perché Java HttpURLConnectionnon segue un reindirizzamento HTTP da un HTTP a un URL HTTPS. Uso il codice seguente per ottenere la pagina su https://httpstat.us/ :

import java.net.URL;
import java.net.HttpURLConnection;
import java.io.InputStream;

public class Tester {

    public static void main(String argv[]) throws Exception{
        InputStream is = null;

        try {
            String httpUrl = "http://httpstat.us/301";
            URL resourceUrl = new URL(httpUrl);
            HttpURLConnection conn = (HttpURLConnection)resourceUrl.openConnection();
            conn.setConnectTimeout(15000);
            conn.setReadTimeout(15000);
            conn.connect();
            is = conn.getInputStream();
            System.out.println("Original URL: "+httpUrl);
            System.out.println("Connected to: "+conn.getURL());
            System.out.println("HTTP response code received: "+conn.getResponseCode());
            System.out.println("HTTP response message received: "+conn.getResponseMessage());
       } finally {
            if (is != null) is.close();
        }
    }
}

L'output di questo programma è:

URL originale: http://httpstat.us/301
Collegato a: http://httpstat.us/301
Codice di risposta HTTP ricevuto: 301
Messaggio di risposta HTTP ricevuto: spostato in modo permanente

Una richiesta a http://httpstat.us/301 restituisce la seguente risposta (abbreviata) (che sembra assolutamente corretta!):

HTTP/1.1 301 Moved Permanently
Cache-Control: private
Content-Length: 21
Content-Type: text/plain; charset=utf-8
Location: https://httpstat.us

Sfortunatamente, Java HttpURLConnectionnon segue il reindirizzamento!

Si noti che se si modifica l'URL originale per HTTPS ( https://httpstat.us/301 ), Java sarà seguire il reindirizzamento come previsto !?

I reindirizzamenti vengono seguiti solo se utilizzano lo stesso protocollo. (Vedere il followRedirect()metodo nel codice sorgente.) Non è possibile disabilitare questo controllo.

Anche se sappiamo che rispecchia HTTP, dal punto di vista del protocollo HTTP, HTTPS è solo un altro protocollo sconosciuto, completamente diverso. Non sarebbe sicuro seguire il reindirizzamento senza l'approvazione dell'utente.

Ad esempio, supponiamo che l'applicazione sia configurata per eseguire automaticamente l'autenticazione del client. L'utente si aspetta di navigare in modo anonimo perché utilizza HTTP. Ma se il suo client segue HTTPS senza chiedere, la sua identità viene rivelata al server.

HttpURLConnection by design non reindirizzerà automaticamente da HTTP a HTTPS (o viceversa). Seguire il reindirizzamento potrebbe avere gravi conseguenze sulla sicurezza. SSL (da qui HTTPS) crea una sessione che è univoca per l'utente. Questa sessione può essere riutilizzata per più richieste. Pertanto, il server può tenere traccia di tutte le richieste effettuate da una singola persona. Questa è una forma debole di identità ed è sfruttabile. Inoltre, l'handshake SSL può richiedere il certificato del client. Se inviato al server, l'identità del client viene fornita al server.

Come sottolinea Erickson , supponiamo che l'applicazione sia configurata per eseguire automaticamente l'autenticazione del client. L'utente si aspetta di navigare in modo anonimo perché utilizza HTTP. Ma se il suo client segue HTTPS senza chiedere, la sua identità viene rivelata al server.

Il programmatore deve eseguire passaggi aggiuntivi per garantire che le credenziali, i certificati client o l'ID di sessione SSL non vengano inviati prima del reindirizzamento da HTTP a HTTPS. L'impostazione predefinita è inviarli. Se il reindirizzamento danneggia l'utente, non seguire il reindirizzamento. Questo è il motivo per cui il reindirizzamento automatico non è supportato.

Detto ciò, ecco il codice che seguirà i reindirizzamenti.

  URL resourceUrl, base, next;
  Map<String, Integer> visited;
  HttpURLConnection conn;
  String location;
  int times;

  ...
  visited = new HashMap<>();

  while (true)
  {
     times = visited.compute(url, (key, count) -> count == null ? 1 : count + 1);

     if (times > 3)
        throw new IOException("Stuck in redirect loop");

     resourceUrl = new URL(url);
     conn        = (HttpURLConnection) resourceUrl.openConnection();

     conn.setConnectTimeout(15000);
     conn.setReadTimeout(15000);
     conn.setInstanceFollowRedirects(false);   // Make the logic below easier to detect redirections
     conn.setRequestProperty("User-Agent", "Mozilla/5.0...");

     switch (conn.getResponseCode())
     {
        case HttpURLConnection.HTTP_MOVED_PERM:
        case HttpURLConnection.HTTP_MOVED_TEMP:
           location = conn.getHeaderField("Location");
           location = URLDecoder.decode(location, "UTF-8");
           base     = new URL(url);               
           next     = new URL(base, location);  // Deal with relative URLs
           url      = next.toExternalForm();
           continue;
     }

     break;
  }

  is = conn.openStream();
  ...

Qualcosa ha chiamato HttpURLConnection.setFollowRedirects(false)per caso?

Potresti sempre chiamare

conn.setInstanceFollowRedirects(true);

se vuoi assicurarti di non influenzare il resto del comportamento dell'app.

Come accennato da alcuni di voi sopra, setFollowRedirect e setInstanceFollowRedirect funzionano automaticamente solo quando il protocollo reindirizzato è lo stesso. cioè da http a http e da https a https.

setFolloRedirect è a livello di classe e lo imposta per tutte le istanze della connessione URL, mentre setInstanceFollowRedirects è solo per una determinata istanza. In questo modo possiamo avere comportamenti diversi per istanze diverse.

Ho trovato un ottimo esempio qui http://www.mkyong.com/java/java-httpurlconnection-follow-redirect-example/

Un'altra opzione può essere quella di utilizzare Apache HttpComponents Client :

<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
</dependency>

Codice di esempio:

CloseableHttpClient httpclient = HttpClients.createDefault();
HttpGet httpget = new HttpGet("https://media-hearth.cursecdn.com/avatars/330/498/212.png");
CloseableHttpResponse response = httpclient.execute(httpget);
final HttpEntity entity = response.getEntity();
final InputStream is = entity.getContent();

HTTPUrlConnection non è responsabile della gestione della risposta dell'oggetto. Funziona come previsto, acquisisce il contenuto dell'URL richiesto. Spetta all'utente della funzionalità interpretare la risposta. Non è in grado di leggere le intenzioni dello sviluppatore senza specifica.