security http轉https - 如何將所有HTTP請求重定向到HTTPS




自動跳轉https http自動轉https (16)

我試圖將我網站上的所有不安全HTTP請求(例如http://www.example.com )重定向到HTTPS( https://www.example.com )。 我使用PHP btw。 我可以在.htaccess中做到這一點嗎?


Answers

如果你使用的是Apache,mod_rewrite是最簡單的解決方案,並且在線有很多文檔如何做到這一點。 例如: http://www.askapache.com/htaccess/http-https-rewriterule-redirect.htmlhttp://www.askapache.com/htaccess/http-https-rewriterule-redirect.html


Apache文檔建議不要使用重寫:

要將http URL重定向到https ,請執行以下操作:

<VirtualHost *:80>
    ServerName www.example.com
    Redirect / https://www.example.com/
</VirtualHost>

<VirtualHost *:443>
    ServerName www.example.com
    # ... SSL configuration goes here
</VirtualHost>

這個片段應該進入主服務器配置文件, 而不是像問題中提到的那樣進入.htaccess

這篇文章可能只是在問題被提出並回答之後才提出來的,但似乎是目前的方式。


根據GoDaddy.com,這是使用.htaccess將HTTP重定向到HTTPS的正確方法。 第一行代碼是不言自明的。 第二行代碼檢查HTTPS是否關閉,如果是,則通過運行第三行代碼將HTTP重定向到HTTPS,否則會忽略第三行代碼。

RewriteEngine On
RewriteCond %{HTTPS} off
RewriteRule ^(.*)$ https://%{HTTP_HOST}%{REQUEST_URI} [L,R=301]

https://www.godaddy.com/help/redirect-http-to-https-automatically-8828


做所有上面解釋的重定向。 只需在您的標題中添加“HTTP嚴格傳輸安全性”即可。 這會避免中間人受到攻擊。

編輯你的apache配置文件(例如/etc/apache2/sites-enabled/website.conf和/etc/apache2/httpd.conf)並將以下內容添加到你的VirtualHost中:

# Optionally load the headers module:
LoadModule headers_module modules/mod_headers.so

<VirtualHost 67.89.123.45:443>
    Header always set Strict-Transport-Security "max-age=63072000; includeSubdomains; preload"
</VirtualHost>

https://en.wikipedia.org/wiki/HTTP_Strict_Transport_Security


在.htaccess文件中使用以下代碼會自動將訪問者重定向到您網站的HTTPS版本:

RewriteEngine On

RewriteCond %{HTTPS} off

RewriteRule ^(.*)$ https://%{HTTP_HOST}%{REQUEST_URI} [L,R=301]

如果您有一個現有的.htaccess文件:

不要復制RewriteEngine On。

確保以RewriteCond和RewriteRule開頭的行緊跟已有的RewriteEngine On。


負載平衡器進場時,這個問題的另一個優勢是。

情況如下: - 從瀏覽器到負載平衡器的流量,返回,是(應該是)HTTPS - 負載平衡器和實際WebServer之間的流量是HTTP。

因此,PHP或Apache中的所有服務器請求變量都表明該連接只是HTTP。 服務器上的HTTP和HTTPS目錄是相同的。

核准答案中的RewriteCondition不起作用。 它給出了一個循環,或者它不起作用。

問題是:如何在負載均衡器上使用此工作。

(或者負載平衡器配置錯誤,這是我所希望的,因為那樣我就可以將問題轉移到WebHosting公司:-))


我喜歡這種從http重定向到https的方法。 因為我不需要為每個網站進行編輯。

RewriteEngine On
RewriteCond %{HTTPS} off
RewriteRule (.*) https://%{HTTP_HOST}%{REQUEST_URI} [R,L]

我建議使用301重定向:

RewriteEngine On
RewriteCond %{HTTPS} off
RewriteRule (.*) https://%{HTTP_HOST}%{REQUEST_URI} [R=301,L]

除非你需要mod_rewrite來處理其他事情,否則使用Apache核心IF指令會更乾淨更快:

<If "%{HTTPS} == 'off'">
Redirect permanent / https://yoursite.com/
</If>

您可以向IF指令添加更多條件,例如確保沒有www前綴的單個規範域:

<If "req('Host') != 'myonetruesite.com' || %{HTTPS} == 'off'">
Redirect permanent / https://myonetruesite.com/
</If>

使用mod_rewrite的一切都有很多熟悉的慣性,但看看這是否適合你。

更多信息: https://httpd.apache.org/docs/2.4/mod/core.html#ifhttps://httpd.apache.org/docs/2.4/mod/core.html#if

要看到它的行動(嘗試沒有www。或https://,或與.net而不是.com): https://nohodental.com/https://nohodental.com/ (我正在工作的網站)。


將下面的代碼添加到.htaccess文件中:

Options +SymLinksIfOwnerMatch
RewriteEngine On
RewriteCond %{SERVER_PORT} !=443
RewriteRule ^ https://[your domain name]%{REQUEST_URI} [R,L]

你的域名是你網站的域名。

您還可以將以上代碼的最後一行替換為您的域名的特定文件夾:

RewriteRule ^ https://[your domain name]/[directory name]%{REQUEST_URI} [R,L]

如果您處於無法直接訪問您的站點的Apache配置的情況,那麼許多託管平台仍然以這種方式受到限制,那麼我實際上會推薦採用兩步式方法。 Apache本身為什麼要記錄你應該首先使用它們的配置選項,而不是使用mod_rewrite來使用HTTP到HTTPS。

首先,如上所述,您可以設置您的.htaccess mod_rewrite規則:

RewriteEngine On
RewriteCond %{HTTPS} off
RewriteRule ^ https://%{HTTP_HOST}%{REQUEST_URI} [R=301,L]

然後,在您的PHP文件中(您需要這樣做,以便適合您的情況,有些網站會通過一個PHP文件匯集所有請求,其他網站則根據其需要和要求提供各種頁面):

<?php if ($_SERVER['HTTPS'] != 'on') { exit(1); } ?>

上面的代碼需要在任何可能在不安全的環境中公開安全數據的代碼之前運行。 因此,您的站點通過HTACCESS和mod_rewrite使用自動重定向,而腳本確保在未通過HTTPS訪問時不提供輸出。

我想大多數人不會這樣想,因此Apache建議您盡可能不要使用這種方法。 但是,它只需在開發結束時進行額外檢查,以確保用戶的數據安全。 希望這可以幫助其他可能需要考慮使用非推薦方法的人員,因為我們的託管服務受到限制。


我發現https和www域名上的最佳方式是

RewriteCond %{HTTPS} off 
RewriteCond %{HTTPS_HOST} !^www.cheapcarhire.gr$ [NC]
RewriteRule ^(.*)$ https://www.cheapcarhire.gr/$1 [L,R=301]

這是它工作的html重定向方法,但不是最好的。

 <meta http-equiv="Refresh" content="0;URL=https://www.example.com" />

PHP方法

<?php
function redirectTohttps() {
    if ($_SERVER['HTTPS']!="on") {
        $redirect= "https://".$_SERVER['HTTP_HOST'].$_SERVER['REQUEST_URI'];
        header("Location:$redirect"); 
    } 
}
?>

.htaccess正在接受

RewriteEngine On
RewriteCond %{HTTPS} off
RewriteRule (.*) https://%{HTTP_HOST}%{REQUEST_URI}

複製自www.letuslook.org


要將所有http請求重定向到https ,您可以使用:

RewriteEngine on
RewriteCond %{HTTPS} off
RewriteRule ^ https://%{HTTP_HOST}%{REQUEST_URI} [NE,L,R]

如果mod-rewrite沒有啟用,並且你在apache 2.4上,你也可以在if命令中使用Redirecthttp請求重定向到https

Apache 2.4。

<if "%{HTTPS} !~ /on/">
Redirect / https://www.example.com/
</if>

最好的解決方案取決於您的要求。 這是添加了一些上下文的以前發布的答案的摘要。

如果您使用Apache Web服務器並可以更改其配置,請遵循Apache文檔

<VirtualHost *:80>
    ServerName www.example.com
    Redirect "/" "https://www.example.com/"
</VirtualHost>

<VirtualHost *:443>
    ServerName www.example.com
    # ... SSL configuration goes here
</VirtualHost>

但是你也問過你是否可以在.htaccess文件中做到這一點。 在這種情況下,您可以使用Apache的RewriteEngine

RewriteEngine On
RewriteCond %{HTTPS} off
RewriteRule (.*) https://%{HTTP_HOST}%{REQUEST_URI} [L]

如果一切工作正常,並且希望瀏覽器記住此重定向,則可以通過將最後一行更改為以下內容將其聲明為永久性的:

RewriteRule (.*) https://%{HTTP_HOST}%{REQUEST_URI} [R=301,L]

但要小心,如果你可能改變你的想法在這個重定向。 瀏覽器記住它很長一段時間,並不會檢查它是否發生了變化。

取決於Web服務器配置,您可能不需要第一行RewriteEngine On

如果您尋找PHP解決方案,請查看$ _SERVER數組標題函數

if (!$_SERVER['HTTPS']) {
    header("Location: https://" . $_SERVER['HTTP_HOST'] . $_SERVER['REQUEST_URI']); 
} 

我對這個回應也很有啟發。

我經常在需要做一些HTTP的項目上工作,而且我可能不想引入很多第三方依賴項(引入其他內容等等)

我開始根據一些對話編寫我自己的實用程序(不是在哪裡完成的):

package org.boon.utils;


import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLConnection;
import java.util.Map;

import static org.boon.utils.IO.read;

public class HTTP {

然後就是一堆或靜態方法。

public static String get(
        final String url) {

    Exceptions.tryIt(() -> {
        URLConnection connection;
        connection = doGet(url, null, null, null);
        return extractResponseString(connection);
    });
    return null;
}

public static String getWithHeaders(
        final String url,
        final Map<String, ? extends Object> headers) {
    URLConnection connection;
    try {
        connection = doGet(url, headers, null, null);
        return extractResponseString(connection);
    } catch (Exception ex) {
        Exceptions.handle(ex);
        return null;
    }
}

public static String getWithContentType(
        final String url,
        final Map<String, ? extends Object> headers,
        String contentType) {
    URLConnection connection;
    try {
        connection = doGet(url, headers, contentType, null);
        return extractResponseString(connection);
    } catch (Exception ex) {
        Exceptions.handle(ex);
        return null;
    }
}
public static String getWithCharSet(
        final String url,
        final Map<String, ? extends Object> headers,
        String contentType,
        String charSet) {
    URLConnection connection;
    try {
        connection = doGet(url, headers, contentType, charSet);
        return extractResponseString(connection);
    } catch (Exception ex) {
        Exceptions.handle(ex);
        return null;
    }
}

然後發布...

public static String postBody(
        final String url,
        final String body) {
    URLConnection connection;
    try {
        connection = doPost(url, null, "text/plain", null, body);
        return extractResponseString(connection);
    } catch (Exception ex) {
        Exceptions.handle(ex);
        return null;
    }
}

public static String postBodyWithHeaders(
        final String url,
        final Map<String, ? extends Object> headers,
        final String body) {
    URLConnection connection;
    try {
        connection = doPost(url, headers, "text/plain", null, body);
        return extractResponseString(connection);
    } catch (Exception ex) {
        Exceptions.handle(ex);
        return null;
    }
}



public static String postBodyWithContentType(
        final String url,
        final Map<String, ? extends Object> headers,
        final String contentType,
        final String body) {

    URLConnection connection;
    try {
        connection = doPost(url, headers, contentType, null, body);


        return extractResponseString(connection);


    } catch (Exception ex) {
        Exceptions.handle(ex);
        return null;
    }


}


public static String postBodyWithCharset(
        final String url,
        final Map<String, ? extends Object> headers,
        final String contentType,
        final String charSet,
        final String body) {

    URLConnection connection;
    try {
        connection = doPost(url, headers, contentType, charSet, body);


        return extractResponseString(connection);


    } catch (Exception ex) {
        Exceptions.handle(ex);
        return null;
    }


}

private static URLConnection doPost(String url, Map<String, ? extends Object> headers,
                                    String contentType, String charset, String body
                                    ) throws IOException {
    URLConnection connection;/* Handle output. */
    connection = new URL(url).openConnection();
    connection.setDoOutput(true);
    manageContentTypeHeaders(contentType, charset, connection);

    manageHeaders(headers, connection);


    IO.write(connection.getOutputStream(), body, IO.CHARSET);
    return connection;
}

private static void manageHeaders(Map<String, ? extends Object> headers, URLConnection connection) {
    if (headers != null) {
        for (Map.Entry<String, ? extends Object> entry : headers.entrySet()) {
            connection.setRequestProperty(entry.getKey(), entry.getValue().toString());
        }
    }
}

private static void manageContentTypeHeaders(String contentType, String charset, URLConnection connection) {
    connection.setRequestProperty("Accept-Charset", charset == null ? IO.CHARSET : charset);
    if (contentType!=null && !contentType.isEmpty()) {
        connection.setRequestProperty("Content-Type", contentType);
    }
}

private static URLConnection doGet(String url, Map<String, ? extends Object> headers,
                                    String contentType, String charset) throws IOException {
    URLConnection connection;/* Handle output. */
    connection = new URL(url).openConnection();
    manageContentTypeHeaders(contentType, charset, connection);

    manageHeaders(headers, connection);

    return connection;
}

private static String extractResponseString(URLConnection connection) throws IOException {
/* Handle input. */
    HttpURLConnection http = (HttpURLConnection)connection;
    int status = http.getResponseCode();
    String charset = getCharset(connection.getHeaderField("Content-Type"));

    if (status==200) {
        return readResponseBody(http, charset);
    } else {
        return readErrorResponseBody(http, status, charset);
    }
}

private static String readErrorResponseBody(HttpURLConnection http, int status, String charset) {
    InputStream errorStream = http.getErrorStream();
    if ( errorStream!=null ) {
        String error = charset== null ? read( errorStream ) :
            read( errorStream, charset );
        throw new RuntimeException("STATUS CODE =" + status + "\n\n" + error);
    } else {
        throw new RuntimeException("STATUS CODE =" + status);
    }
}

private static String readResponseBody(HttpURLConnection http, String charset) throws IOException {
    if (charset != null) {
        return read(http.getInputStream(), charset);
    } else {
        return read(http.getInputStream());
    }
}

private static String getCharset(String contentType) {
    if (contentType==null)  {
        return null;
    }
    String charset = null;
    for (String param : contentType.replace(" ", "").split(";")) {
        if (param.startsWith("charset=")) {
            charset = param.split("=", 2)[1];
            break;
        }
    }
    charset = charset == null ?  IO.CHARSET : charset;

    return charset;
}

反正你懂這個意思....

這裡是測試:

static class MyHandler implements HttpHandler {
    public void handle(HttpExchange t) throws IOException {

        InputStream requestBody = t.getRequestBody();
        String body = IO.read(requestBody);
        Headers requestHeaders = t.getRequestHeaders();
        body = body + "\n" + copy(requestHeaders).toString();
        t.sendResponseHeaders(200, body.length());
        OutputStream os = t.getResponseBody();
        os.write(body.getBytes());
        os.close();
    }
}


@Test
public void testHappy() throws Exception {

    HttpServer server = HttpServer.create(new InetSocketAddress(9212), 0);
    server.createContext("/test", new MyHandler());
    server.setExecutor(null); // creates a default executor
    server.start();

    Thread.sleep(10);


    Map<String,String> headers = map("foo", "bar", "fun", "sun");

    String response = HTTP.postBodyWithContentType("http://localhost:9212/test", headers, "text/plain", "hi mom");

    System.out.println(response);

    assertTrue(response.contains("hi mom"));
    assertTrue(response.contains("Fun=[sun], Foo=[bar]"));


    response = HTTP.postBodyWithCharset("http://localhost:9212/test", headers, "text/plain", "UTF-8", "hi mom");

    System.out.println(response);

    assertTrue(response.contains("hi mom"));
    assertTrue(response.contains("Fun=[sun], Foo=[bar]"));

    response = HTTP.postBodyWithHeaders("http://localhost:9212/test", headers, "hi mom");

    System.out.println(response);

    assertTrue(response.contains("hi mom"));
    assertTrue(response.contains("Fun=[sun], Foo=[bar]"));


    response = HTTP.get("http://localhost:9212/test");

    System.out.println(response);


    response = HTTP.getWithHeaders("http://localhost:9212/test", headers);

    System.out.println(response);

    assertTrue(response.contains("Fun=[sun], Foo=[bar]"));



    response = HTTP.getWithContentType("http://localhost:9212/test", headers, "text/plain");

    System.out.println(response);

    assertTrue(response.contains("Fun=[sun], Foo=[bar]"));



    response = HTTP.getWithCharSet("http://localhost:9212/test", headers, "text/plain", "UTF-8");

    System.out.println(response);

    assertTrue(response.contains("Fun=[sun], Foo=[bar]"));

    Thread.sleep(10);

    server.stop(0);


}

@Test
public void testPostBody() throws Exception {

    HttpServer server = HttpServer.create(new InetSocketAddress(9220), 0);
    server.createContext("/test", new MyHandler());
    server.setExecutor(null); // creates a default executor
    server.start();

    Thread.sleep(10);


    Map<String,String> headers = map("foo", "bar", "fun", "sun");

    String response = HTTP.postBody("http://localhost:9220/test", "hi mom");

    assertTrue(response.contains("hi mom"));


    Thread.sleep(10);

    server.stop(0);


}

@Test(expected = RuntimeException.class)
public void testSad() throws Exception {

    HttpServer server = HttpServer.create(new InetSocketAddress(9213), 0);
    server.createContext("/test", new MyHandler());
    server.setExecutor(null); // creates a default executor
    server.start();

    Thread.sleep(10);


    Map<String,String> headers = map("foo", "bar", "fun", "sun");

    String response = HTTP.postBodyWithContentType("http://localhost:9213/foo", headers, "text/plain", "hi mom");

    System.out.println(response);

    assertTrue(response.contains("hi mom"));
    assertTrue(response.contains("Fun=[sun], Foo=[bar]"));

    Thread.sleep(10);

    server.stop(0);


}

你可以在這裡找到其他的:

https://github.com/RichardHightower/boon

我的目標是提供人們想要以更簡單的方式進行的常見事情....





security http .htaccess redirect https