HTTP與HTTPS

在WWDC 2016上，蘋果在釋出iOS 9的同時也向開發者傳遞了一個訊息，那就是到2017年1月1日時App Store中所有應用都必須啟用 App Transport Security應用程式安全傳輸協議，從而提升應用和系統安全性。

HTTPS是Hyper Text Transfer Protocol Secure的縮寫，相比http，多了一個secure，這一個secure是怎麼來的呢？這是由TLS（SSL）提供的。

https和http都屬於應用層，基於TCP（以及UDP）協議。但是不同的是： 
HTTP 預設工作在TCP協議80埠 
HTTPS預設工作在TCP協議443埠

通俗一句話：相比http，https對於大部分人來說，意味著比較安全。

TLS

安全傳輸層協議（TLS）用於在兩個通訊應用程式之間提供保密性和資料完整性。 
The TLS/SSL is a public/private key infrastructure (PKI). For most common cases, each client and server must have a private key.

TLS與SSL的差異

SSLv2 and SSLv3 are completely different (and both are now considered insecure). SSLv3 and TLSv1.0 are very similar, but have a few differences.

You could consider TLSv1.0 as SSLv3.1

• 版本號：TLS記錄格式與SSL記錄格式相同，但版本號的值不同，TLS的版本1.0使用的版本號為SSLv3.1。

• 報文鑑別碼：SSLv3.0和TLS的MAC演算法及MAC計算的範圍不同。TLS使用了RFC-2104定義的HMAC演算法。SSLv3.0使用了相似的演算法，兩者差別在於SSLv3.0中，填充位元組與金鑰之間採用的是連線運算，而HMAC演算法採用的是異或運算。但是兩者的安全程度是相同的。

• 偽隨機函式：TLS使用了稱為PRF的偽隨機函式來將金鑰擴充套件成資料塊，是更安全的方式。

• 報警程式碼：TLS支援幾乎所有的SSLv3.0報警程式碼，而且TLS還補充定義了很多報警程式碼，如解密失敗（decryption_failed）、記錄溢位（record_overflow）、未知CA（unknown_ca）、拒絕訪問（access_denied）等。

• 密文族和客戶證書：SSLv3.0和TLS存在少量差別，即TLS不支援Fortezza金鑰交換、加密演算法和客戶證書。

• certificate_verify和finished訊息：SSLv3.0和TLS在用certificate_verify和finished訊息計算MD5和SHA-1雜湊碼時，計算的輸入有少許差別，但安全性相當。

• 加密計算：TLS與SSLv3.0在計算主密值（master secret）時採用的方式不同。

• 填充：使用者資料加密之前需要增加的填充位元組。在SSL中，填充後的資料長度要達到密文塊長度的最小整數倍。而在TLS中，填充後的資料長度可以是密文塊長度的任意整數倍（但填充的最大長度為255位元組），這種方式可以防止基於對報文長度進行分析的攻擊。

openssl 
openssl(www.openssl.org) 是sslv2,sslv3,tlsv1的一份完整實現,內部包含了大量加密演算法程式.其命令列提供了豐富的加密,驗證,證書生成等功能,甚至可以用其建立 一個完整的CA.與其同時,它也提供了一套完整的庫函式,可用開發用SSL/TLS的通訊程式.

插曲： 
2016年10月18日，錘子科技CEO羅永浩在錘子手機發佈會上，宣佈將200多萬元門票收入，以及原計劃成立的 Smartisan 公益基金近100萬元，全部捐贈給 OpenSSL 基金會和 OpenBSD 基金會。

crt、key以及pem的區別以及生成

crt — Alternate synonymous most common among *nix systems .pem (pubkey).

csr — Certficate Signing Requests (synonymous most common among *nix systems).

cer — Microsoft alternate form of .crt, you can use MS to convert .crt to .cer (DER encoded .cer, or base64[PEM] encoded cer).

pem = The PEM extension is used for different types of X.509v3 files which contain ASCII (Base64) armored data prefixed with a «—– BEGIN …» line. These files may also bear the cer or the crt extension.

der — The DER extension is used for binary DER encoded certificates.

證書(Certificate) .cer .crt 
私鑰(Private Key).key 
證書籤名請求(Certificate sign request) .csr 
至於pem和der，是編碼方式，以上三類均可以使用這兩種編碼方式，因此.pem和.der(少見)不一定是以上三種(Cert,Key,CSR)中的某一種

PEM - Privacy Enhanced Mail,開啟看文字格式,以”—–BEGIN…”開頭, “—–END…”結尾,內容是BASE64編碼. 
檢視PEM格式證書的資訊:openssl x509 -in certificate.pem -text -noout 
Apache和*NIX伺服器偏向於使用這種編碼格式.

DER - Distinguished Encoding Rules,開啟看是二進位制格式,不可讀. 
檢視DER格式證書的資訊:openssl x509 -in certificate.der -inform der -text -noout 
Java和Windows伺服器偏向於使用這種編碼格式.

x509 
X.509是一種非常通用的證書格式。所有的證書都符合ITU-T X.509國際標準，因此(理論上)為一種應用建立的證書可以用於任何其他符合X.509標準的應用。

x509證書一般會用到三類文，key，csr，crt。 
Key 是私用金鑰openssl格，通常是rsa演算法。 
Csr 是證書請求檔案，用於申請證書。在製作csr檔案的時，必須使用自己的私鑰來簽署申，還可以設定一個金鑰。 
crt是CA認證後的證書文，（windows下面的，其實是crt），簽署人用自己的key給你簽署的憑證。

生成.key 
rsa演算法：

openssl genrsa -out server.key 2048

ECDSA演算法：

openssl ecparam -genkey -name secp384r1 -out server.key

生成.crt

openssl req -new -x509 -sha256 -key server.key -out server.crt -days 3650

需要輸入一些資訊：

openssl req -new -x509 -sha256 -key server.key -out server.crt -days 3650
You are about to be asked to enter information that will be incorporated
into your certificate request.
What you are about to enter is what is called a Distinguished Name or a DN.
There are quite a few fields but you can leave some blank
For some fields there will be a default value,
If you enter '.', the field will be left blank.
-----
Country Name (2 letter code) [AU]:cn
State or Province Name (full name) [Some-State]:Beijing
Locality Name (eg, city) []:Beijing
Organization Name (eg, company) [Internet Widgits Pty Ltd]:wangshubo
Organizational Unit Name (eg, section) []:wangshubo
Common Name (e.g. server FQDN or YOUR name) []:wangshubo
Email Address []:[email protected]

生成pem和key

openssl req -new -nodes -x509 -out server.pem -keyout server.key -days 3650 -subj "/C=DE/ST=NRW/L=Earth/O=Random Company/OU=IT/CN=www.random.com/[email protected]"

crypto/tls包介紹

golang中為我們提供了tls包： 
Package tls partially implements TLS 1.2, as specified in RFC 5246.

func LoadX509KeyPair

func LoadX509KeyPair(certFile, keyFile string) (Certificate, error)

LoadX509KeyPair reads and parses a public/private key pair from a pair of files. The files must contain PEM encoded data. The certificate file may contain intermediate certificates following the leaf certificate to form a certificate chain. On successful return, Certificate.Leaf will be nil because the parsed form of the certificate is not retained.

type Config 
A Config structure is used to configure a TLS client or server. After one has been passed to a TLS function it must not be modified. A Config may be reused; the tls package will also not modify it.

type Config struct {

        Rand io.Reader

        Time func() time.Time

        Certificates []Certificate

        NameToCertificate map[string]*Certificate

        GetCertificate func(*ClientHelloInfo) (*Certificate, error)

        GetClientCertificate func(*CertificateRequestInfo) (*Certificate, error)

        GetConfigForClient func(*ClientHelloInfo) (*Config, error)

        VerifyPeerCertificate func(rawCerts [][]byte, verifiedChains [][]*x509.Certificate) error

        RootCAs *x509.CertPool

        NextProtos []string

        ServerName string

        ClientAuth ClientAuthType

        ClientCAs *x509.CertPool

        InsecureSkipVerify bool

        CipherSuites []uint16

        PreferServerCipherSuites bool

        SessionTicketsDisabled bool

        SessionTicketKey [32]byte

        ClientSessionCache ClientSessionCache

        MinVersion uint16

        MaxVersion uint16

        CurvePreferences []CurveID

        DynamicRecordSizingDisabled bool

        Renegotiation RenegotiationSupport

        KeyLogWriter io.Writer
}

這裡主要關注一下Certificates，是我們要用到的。

func Listen

func Listen(network, laddr string, config *Config) (net.Listener, error)

Listen creates a TLS listener accepting connections on the given network address using net.Listen. The configuration config must be non-nil and must include at least one certificate or else set GetCertificate.

func Dial

func Dial(network, addr string, config *Config) (*Conn, error)

Dial connects to the given network address using net.Dial and then initiates a TLS handshake, returning the resulting TLS connection. Dial interprets a nil configuration as equivalent to the zero configuration; see the documentation of Config for the defaults.

應用

// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Generate a self-signed X.509 certificate for a TLS server. Outputs to
// 'cert.pem' and 'key.pem' and will overwrite existing files.

package main

import (
    "crypto/ecdsa"
    "crypto/elliptic"
    "crypto/rand"
    "crypto/rsa"
    "crypto/x509"
    "crypto/x509/pkix"
    "encoding/pem"
    "flag"
    "fmt"
    "log"
    "math/big"
    "os"
    "time"
)

var (
    emailAddress = flag.String("email-address", "", "The email address of the user you wish to create the certificate for")
    validFrom    = flag.String("start-date", "", "Creation date formatted as Jan 1 15:04:05 2011")
    validFor     = flag.Duration("duration", 365*24*time.Hour, "Duration that certificate is valid for")
    isCA         = flag.Bool("ca", false, "whether this cert should be its own Certificate Authority")
    rsaBits      = flag.Int("rsa-bits", 2048, "Size of RSA key to generate. Ignored if --ecdsa-curve is set")
    ecdsaCurve   = flag.String("ecdsa-curve", "", "ECDSA curve to use to generate a key. Valid values are P224, P256, P384, P521")
)

func publicKey(priv interface{}) interface{} {
    switch k := priv.(type) {
    case *rsa.PrivateKey:
        return &k.PublicKey
    case *ecdsa.PrivateKey:
        return &k.PublicKey
    default:
        return nil
    }
}

func pemBlockForKey(priv interface{}) *pem.Block {
    switch k := priv.(type) {
    case *rsa.PrivateKey:
        return &pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(k)}
    case *ecdsa.PrivateKey:
        b, err := x509.MarshalECPrivateKey(k)
        if err != nil {
            fmt.Fprintf(os.Stderr, "Unable to marshal ECDSA private key: %v", err)
            os.Exit(2)
        }
        return &pem.Block{Type: "EC PRIVATE KEY", Bytes: b}
    default:
        return nil
    }
}

func main() {
    flag.Parse()

    if len(*emailAddress) == 0 {
        log.Fatalf("Missing required --email-address parameter")
    }

    var priv interface{}
    var err error
    switch *ecdsaCurve {
    case "":
        priv, err = rsa.GenerateKey(rand.Reader, *rsaBits)
    case "P224":
        priv, err = ecdsa.GenerateKey(elliptic.P224(), rand.Reader)
    case "P256":
        priv, err = ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
    case "P384":
        priv, err = ecdsa.GenerateKey(elliptic.P384(), rand.Reader)
    case "P521":
        priv, err = ecdsa.GenerateKey(elliptic.P521(), rand.Reader)
    default:
        fmt.Fprintf(os.Stderr, "Unrecognized elliptic curve: %q", *ecdsaCurve)
        os.Exit(1)
    }
    if err != nil {
        log.Fatalf("failed to generate private key: %s", err)
    }

    var notBefore time.Time
    if len(*validFrom) == 0 {
        notBefore = time.Now()
    } else {
        notBefore, err = time.Parse("Jan 2 15:04:05 2006", *validFrom)
        if err != nil {
            fmt.Fprintf(os.Stderr, "Failed to parse creation date: %s\n", err)
            os.Exit(1)
        }
    }

    notAfter := notBefore.Add(*validFor)

    serialNumberLimit := new(big.Int).Lsh(big.NewInt(1), 128)
    serialNumber, err := rand.Int(rand.Reader, serialNumberLimit)
    if err != nil {
        log.Fatalf("failed to generate serial number: %s", err)
    }

    template := x509.Certificate{
        SerialNumber: serialNumber,
        Subject: pkix.Name{
            Organization: []string{"Acme Co"},
        },
        NotBefore: notBefore,
        NotAfter:  notAfter,

        KeyUsage: x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature,
        ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth,
            x509.ExtKeyUsageClientAuth},
        BasicConstraintsValid: true,
    }
    template.DNSNames = append(template.DNSNames, "localhost")
    template.EmailAddresses = append(template.EmailAddresses, *emailAddress)

    if *isCA {
        template.IsCA = true
        template.KeyUsage |= x509.KeyUsageCertSign
    }

    derBytes, err := x509.CreateCertificate(rand.Reader, &template, &template, publicKey(priv), priv)
    if err != nil {
        log.Fatalf("Failed to create certificate: %s", err)
    }

    certOut, err := os.Create("cert.pem")
    if err != nil {
        log.Fatalf("failed to open cert.pem for writing: %s", err)
    }
    pem.Encode(certOut, &pem.Block{Type: "CERTIFICATE", Bytes: derBytes})
    certOut.Close()
    log.Print("written cert.pem\n")

    keyOut, err := os.OpenFile("key.pem", os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
    if err != nil {
        log.Print("failed to open key.pem for writing:", err)
        return
    }
    pem.Encode(keyOut, pemBlockForKey(priv))
    keyOut.Close()
    log.Print("written key.pem\n")
}

golang中使用HTTPS

package main

import (
    "log"
    "net/http"
)

func HelloServer(w http.ResponseWriter, req *http.Request) {
    w.Header().Set("Content-Type", "text/plain")
    w.Write([]byte("This is an example using https in golang.\n"))
}

func main() {
    http.HandleFunc("/hello", HelloServer)
    err := http.ListenAndServeTLS(":443", "server.crt", "server.key", nil)
    if err != nil {
        log.Fatal("ListenAndServe: ", err)
    }
}

golang中使用tls 
server.go

package main

import (
    "bufio"
    "crypto/tls"
    "log"
    "net"
)

func main() {
    log.SetFlags(log.Lshortfile)

    cer, err := tls.LoadX509KeyPair("server.crt", "server.key")
    if err != nil {
        log.Println(err)
        return
    }

    config := &tls.Config{Certificates: []tls.Certificate{cer}}
    ln, err := tls.Listen("tcp", ":443", config)
    if err != nil {
        log.Println(err)
        return
    }
    defer ln.Close()

    for {
        conn, err := ln.Accept()
        if err != nil {
            log.Println(err)
            continue
        }
        go handleConnection(conn)
    }
}

func handleConnection(conn net.Conn) {
    defer conn.Close()
    r := bufio.NewReader(conn)
    for {
        msg, err := r.ReadString('\n')
        if err != nil {
            log.Println(err)
            return
        }

        println(msg)

        n, err := conn.Write([]byte("jude\n"))
        if err != nil {
            log.Println(n, err)
            return
        }
    }
}

client.go

package main

import (
    "crypto/tls"
    "log"
)

func main() {
    log.SetFlags(log.Lshortfile)

    conf := &tls.Config{
        InsecureSkipVerify: true,
    }

    conn, err := tls.Dial("tcp", "127.0.0.1:443", conf)
    if err != nil {
        log.Println(err)
        return
    }
    defer conn.Close()

    n, err := conn.Write([]byte("hi\n"))
    if err != nil {
        log.Println(n, err)
        return
    }

    buf := make([]byte, 100)
    n, err = conn.Read(buf)
    if err != nil {
        log.Println(n, err)
        return
    }

    println(string(buf[:n]))
}

這裡編寫client程式碼時候需要注意：InsecureSkipVerify: true 
也就是說上面的程式碼中客戶端不對服務端的證書進行驗證。 
go實現的Client端預設也是要對服務端傳過來的數字證書進行校驗的，但客戶端提示：這個證書是由不知名CA簽發的！