httpsig_test.go

package httpsig

import (
	"bytes"
	"crypto"
	"crypto/rand"
	"crypto/rsa"
	"crypto/sha256"
	"crypto/x509"
	"encoding/base64"
	"encoding/pem"
	"fmt"
	"io/ioutil"
	"net/http"
	"net/http/httptest"
	"strconv"
	"strings"
	"testing"
)

const (
	testUrl     = "foo.net/bar/baz?q=test&r=ok"
	testUrlPath = "bar/baz"
	testDate    = "Tue, 07 Jun 2014 20:51:35 GMT"
	testDigest  = "SHA-256=X48E9qOokqqrvdts8nOJRJN3OWDUoyWxBf7kbu9DBPE="
	testMethod  = "GET"
)

type httpsigTest struct {
	name                       string
	prefs                      []Algorithm
	headers                    []string
	scheme                     SignatureScheme
	privKey                    crypto.PrivateKey
	pubKey                     crypto.PublicKey
	pubKeyId                   string
	expectedAlgorithm          Algorithm
	expectErrorSigningResponse bool
	expectRequestPath          bool
}

var (
	privKey               *rsa.PrivateKey
	macKey                []byte
	tests                 []httpsigTest
	testSpecRSAPrivateKey *rsa.PrivateKey
	testSpecRSAPublicKey  *rsa.PublicKey
)

func init() {
	var err error
	privKey, err = rsa.GenerateKey(rand.Reader, 2048)
	if err != nil {
		panic(err)
	}
	macKey = make([]byte, 128)
	err = readFullFromCrypto(macKey)
	if err != nil {
		panic(err)
	}
	tests = []httpsigTest{
		{
			name:              "rsa signature",
			prefs:             []Algorithm{RSA_SHA512},
			headers:           []string{"Date", "Digest"},
			scheme:            Signature,
			privKey:           privKey,
			pubKey:            privKey.Public(),
			pubKeyId:          "pubKeyId",
			expectedAlgorithm: RSA_SHA512,
		},
		{
			name:              "hmac signature",
			prefs:             []Algorithm{HMAC_SHA256},
			headers:           []string{"Date", "Digest"},
			scheme:            Signature,
			privKey:           macKey,
			pubKey:            macKey,
			pubKeyId:          "pubKeyId",
			expectedAlgorithm: HMAC_SHA256,
		},
		{
			name:              "rsa authorization",
			prefs:             []Algorithm{RSA_SHA512},
			headers:           []string{"Date", "Digest"},
			scheme:            Authorization,
			privKey:           privKey,
			pubKey:            privKey.Public(),
			pubKeyId:          "pubKeyId",
			expectedAlgorithm: RSA_SHA512,
		},
		{
			name:              "hmac authorization",
			prefs:             []Algorithm{HMAC_SHA256},
			headers:           []string{"Date", "Digest"},
			scheme:            Authorization,
			privKey:           macKey,
			pubKey:            macKey,
			pubKeyId:          "pubKeyId",
			expectedAlgorithm: HMAC_SHA256,
		},
		{
			name:              "default algo",
			headers:           []string{"Date", "Digest"},
			scheme:            Signature,
			privKey:           privKey,
			pubKey:            privKey.Public(),
			pubKeyId:          "pubKeyId",
			expectedAlgorithm: RSA_SHA256,
		},
		{
			name:              "default headers",
			prefs:             []Algorithm{RSA_SHA512},
			scheme:            Signature,
			privKey:           privKey,
			pubKey:            privKey.Public(),
			pubKeyId:          "pubKeyId",
			expectedAlgorithm: RSA_SHA512,
		},
		{
			name:              "different pub key id",
			prefs:             []Algorithm{RSA_SHA512},
			headers:           []string{"Date", "Digest"},
			scheme:            Signature,
			privKey:           privKey,
			pubKey:            privKey.Public(),
			pubKeyId:          "i write code that sucks",
			expectedAlgorithm: RSA_SHA512,
		},
		{
			name:                       "with request target",
			prefs:                      []Algorithm{RSA_SHA512},
			headers:                    []string{"Date", "Digest", RequestTarget},
			scheme:                     Signature,
			privKey:                    privKey,
			pubKey:                     privKey.Public(),
			pubKeyId:                   "pubKeyId",
			expectedAlgorithm:          RSA_SHA512,
			expectErrorSigningResponse: true,
			expectRequestPath:          true,
		},
	}

	testSpecRSAPrivateKey, err = loadPrivateKey([]byte(testSpecPrivateKeyPEM))
	if err != nil {
		panic(err)
	}

	testSpecRSAPublicKey, err = loadPublicKey([]byte(testSpecPublicKeyPEM))
	if err != nil {
		panic(err)
	}
}

func toSignatureParameter(k, v string) string {
	return fmt.Sprintf("%s%s%s%s%s", k, parameterKVSeparater, parameterValueDelimiter, v, parameterValueDelimiter)
}

func toHeaderSignatureParameters(k string, vals []string) string {
	if len(vals) == 0 {
		vals = defaultHeaders
	}
	v := strings.Join(vals, headerParameterValueDelim)
	k = strings.ToLower(k)
	v = strings.ToLower(v)
	return fmt.Sprintf("%s%s%s%s%s", k, parameterKVSeparater, parameterValueDelimiter, v, parameterValueDelimiter)
}

func TestSignerRequest(t *testing.T) {
	testFn := func(t *testing.T, test httpsigTest) {
		s, a, err := NewSigner(test.prefs, test.headers, test.scheme)
		if err != nil {
			t.Fatalf("%s", err)
		}
		if a != test.expectedAlgorithm {
			t.Fatalf("got %s, want %s", a, test.expectedAlgorithm)
		}
		// Test request signing
		req, err := http.NewRequest(testMethod, testUrl, nil)
		if err != nil {
			t.Fatalf("%s", err)
		}
		req.Header.Set("Date", testDate)
		req.Header.Set("Digest", testDigest)
		err = s.SignRequest(test.privKey, test.pubKeyId, req)
		if err != nil {
			t.Fatalf("%s", err)
		}
		vals, ok := req.Header[string(test.scheme)]
		if !ok {
			t.Fatalf("not in header %s", test.scheme)
		}
		if len(vals) != 1 {
			t.Fatalf("too many in header %s: %d", test.scheme, len(vals))
		}
		if p := toSignatureParameter(keyIdParameter, test.pubKeyId); !strings.Contains(vals[0], p) {
			t.Fatalf("%s\ndoes not contain\n%s", vals[0], p)
		} else if p := toSignatureParameter(algorithmParameter, string(test.expectedAlgorithm)); !strings.Contains(vals[0], p) {
			t.Fatalf("%s\ndoes not contain\n%s", vals[0], p)
		} else if p := toHeaderSignatureParameters(headersParameter, test.headers); !strings.Contains(vals[0], p) {
			t.Fatalf("%s\ndoes not contain\n%s", vals[0], p)
		} else if !strings.Contains(vals[0], signatureParameter) {
			t.Fatalf("%s\ndoes not contain\n%s", vals[0], signatureParameter)
		}
		// For schemes with an authScheme, enforce its is present and at the beginning
		if len(test.scheme.authScheme()) > 0 {
			if !strings.HasPrefix(vals[0], test.scheme.authScheme()) {
				t.Fatalf("%s\ndoes not start with\n%s", vals[0], test.scheme.authScheme())
			}
		}
	}
	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			testFn(t, test)
		})
	}
}

func TestSignerResponse(t *testing.T) {
	testFn := func(t *testing.T, test httpsigTest) {
		s, _, err := NewSigner(test.prefs, test.headers, test.scheme)
		// Test response signing
		resp := httptest.NewRecorder()
		resp.HeaderMap.Set("Date", testDate)
		resp.HeaderMap.Set("Digest", testDigest)
		err = s.SignResponse(test.privKey, test.pubKeyId, resp)
		if test.expectErrorSigningResponse {
			if err != nil {
				// Skip rest of testing
				return
			} else {
				t.Fatalf("expected error, got nil")
			}
		}
		vals, ok := resp.HeaderMap[string(test.scheme)]
		if !ok {
			t.Fatalf("not in header %s", test.scheme)
		}
		if len(vals) != 1 {
			t.Fatalf("too many in header %s: %d", test.scheme, len(vals))
		}
		if p := toSignatureParameter(keyIdParameter, test.pubKeyId); !strings.Contains(vals[0], p) {
			t.Fatalf("%s\ndoes not contain\n%s", vals[0], p)
		} else if p := toSignatureParameter(algorithmParameter, string(test.expectedAlgorithm)); !strings.Contains(vals[0], p) {
			t.Fatalf("%s\ndoes not contain\n%s", vals[0], p)
		} else if p := toHeaderSignatureParameters(headersParameter, test.headers); !strings.Contains(vals[0], p) {
			t.Fatalf("%s\ndoes not contain\n%s", vals[0], p)
		} else if !strings.Contains(vals[0], signatureParameter) {
			t.Fatalf("%s\ndoes not contain\n%s", vals[0], signatureParameter)
		}
		// For schemes with an authScheme, enforce its is present and at the beginning
		if len(test.scheme.authScheme()) > 0 {
			if !strings.HasPrefix(vals[0], test.scheme.authScheme()) {
				t.Fatalf("%s\ndoes not start with\n%s", vals[0], test.scheme.authScheme())
			}
		}
	}
	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			testFn(t, test)
		})
	}
}

func TestNewSignerRequestMissingHeaders(t *testing.T) {
	failingTests := []struct {
		name              string
		prefs             []Algorithm
		headers           []string
		scheme            SignatureScheme
		privKey           crypto.PrivateKey
		pubKeyId          string
		expectedAlgorithm Algorithm
	}{
		{
			name:              "wants digest",
			prefs:             []Algorithm{RSA_SHA512},
			headers:           []string{"Date", "Digest"},
			scheme:            Signature,
			privKey:           privKey,
			pubKeyId:          "pubKeyId",
			expectedAlgorithm: RSA_SHA512,
		},
	}
	for _, test := range failingTests {
		t.Run(test.name, func(t *testing.T) {
			test := test
			s, a, err := NewSigner(test.prefs, test.headers, test.scheme)
			if err != nil {
				t.Fatalf("%s", err)
			}
			if a != test.expectedAlgorithm {
				t.Fatalf("got %s, want %s", a, test.expectedAlgorithm)
			}
			req, err := http.NewRequest(testMethod, testUrl, nil)
			if err != nil {
				t.Fatalf("%s", err)
			}
			req.Header.Set("Date", testDate)
			err = s.SignRequest(test.privKey, test.pubKeyId, req)
			if err == nil {
				t.Fatalf("expect error but got nil")
			}
		})
	}
}

func TestNewSignerResponseMissingHeaders(t *testing.T) {
	failingTests := []struct {
		name                       string
		prefs                      []Algorithm
		headers                    []string
		scheme                     SignatureScheme
		privKey                    crypto.PrivateKey
		pubKeyId                   string
		expectedAlgorithm          Algorithm
		expectErrorSigningResponse bool
	}{
		{
			name:              "want digest",
			prefs:             []Algorithm{RSA_SHA512},
			headers:           []string{"Date", "Digest"},
			scheme:            Signature,
			privKey:           privKey,
			pubKeyId:          "pubKeyId",
			expectedAlgorithm: RSA_SHA512,
		},
	}
	for _, test := range failingTests {
		t.Run(test.name, func(t *testing.T) {
			test := test
			s, a, err := NewSigner(test.prefs, test.headers, test.scheme)
			if err != nil {
				t.Fatalf("%s", err)
			}
			if a != test.expectedAlgorithm {
				t.Fatalf("got %s, want %s", a, test.expectedAlgorithm)
			}
			resp := httptest.NewRecorder()
			resp.HeaderMap.Set("Date", testDate)
			resp.HeaderMap.Set("Digest", testDigest)
			err = s.SignResponse(test.privKey, test.pubKeyId, resp)
			if err != nil {
				t.Fatalf("expected error, got nil")
			}
		})
	}
}

func TestNewVerifier(t *testing.T) {
	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			test := test
			// Prepare
			req, err := http.NewRequest(testMethod, testUrl, nil)
			if err != nil {
				t.Fatalf("%s", err)
			}
			req.Header.Set("Date", testDate)
			req.Header.Set("Digest", testDigest)
			s, _, err := NewSigner(test.prefs, test.headers, test.scheme)
			if err != nil {
				t.Fatalf("%s", err)
			}
			err = s.SignRequest(test.privKey, test.pubKeyId, req)
			if err != nil {
				t.Fatalf("%s", err)
			}
			// Test verification
			v, err := NewVerifier(req)
			if err != nil {
				t.Fatalf("%s", err)
			}
			if v.KeyId() != test.pubKeyId {
				t.Fatalf("got %s, want %s", v.KeyId(), test.pubKeyId)
			}
			err = v.Verify(test.pubKey, test.expectedAlgorithm)
			if err != nil {
				t.Fatalf("%s", err)
			}
		})
	}
}

func TestNewResponseVerifier(t *testing.T) {
	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			test := test
			if test.expectErrorSigningResponse {
				return
			}
			// Prepare
			resp := httptest.NewRecorder()
			resp.HeaderMap.Set("Date", testDate)
			resp.HeaderMap.Set("Digest", testDigest)
			s, _, err := NewSigner(test.prefs, test.headers, test.scheme)
			if err != nil {
				t.Fatalf("%s", err)
			}
			err = s.SignResponse(test.privKey, test.pubKeyId, resp)
			if err != nil {
				t.Fatalf("%s", err)
			}
			// Test verification
			v, err := NewResponseVerifier(resp.Result())
			if err != nil {
				t.Fatalf("%s", err)
			}
			if v.KeyId() != test.pubKeyId {
				t.Fatalf("got %s, want %s", v.KeyId(), test.pubKeyId)
			}
			err = v.Verify(test.pubKey, test.expectedAlgorithm)
			if err != nil {
				t.Fatalf("%s", err)
			}
		})
	}
}

// Test_Signing_HTTP_Messages_AppendixC these tests implement Appendix C from the http signatures specification https://tools.ietf.org/html/draft-cavage-http-signatures-10#appendix-C
func Test_Signing_HTTP_Messages_AppendixC(t *testing.T) {
	specTests := []struct {
		name              string
		headers           []string
		expectedSignature string
		setHeaders        func(r *http.Request)
	}{
		{
			name:              "C.1.  Default Test",
			headers:           []string{},
			expectedSignature: `Authorization: Signature keyId="Test",algorithm="rsa-sha256",signature="SjWJWbWN7i0wzBvtPl8rbASWz5xQW6mcJmn+ibttBqtifLN7Sazz6m79cNfwwb8DMJ5cou1s7uEGKKCs+FLEEaDV5lp7q25WqS+lavg7T8hc0GppauB6hbgEKTwblDHYGEtbGmtdHgVCk9SuS13F0hZ8FD0k/5OxEPXe5WozsbM="`,
			setHeaders:        func(r *http.Request) {},
		},
		{
			name:              "C.2.  Basic Test",
			headers:           []string{"(request-target)", "host", "date"},
			expectedSignature: `Authorization: Signature keyId="Test",algorithm="rsa-sha256",headers="(request-target) host date",signature="qdx+H7PHHDZgy4y/Ahn9Tny9V3GP6YgBPyUXMmoxWtLbHpUnXS2mg2+SbrQDMCJypxBLSPQR2aAjn7ndmw2iicw3HMbe8VfEdKFYRqzic+efkb3nndiv/x1xSHDJWeSWkx3ButlYSuBskLu6kd9Fswtemr3lgdDEmn04swr2Os0="`,
			setHeaders:        func(r *http.Request) {},
		},
		{
			name:              "C.3.  All Headers Test",
			headers:           []string{"(request-target)", "host", "date", "content-type", "digest", "content-length"},
			expectedSignature: `Authorization: Signature keyId="Test",algorithm="rsa-sha256",headers="(request-target) host date content-type digest content-length",signature="vSdrb+dS3EceC9bcwHSo4MlyKS59iFIrhgYkz8+oVLEEzmYZZvRs8rgOp+63LEM3v+MFHB32NfpB2bEKBIvB1q52LaEUHFv120V01IL+TAD48XaERZFukWgHoBTLMhYS2Gb51gWxpeIq8knRmPnYePbF5MOkR0Zkly4zKH7s1dE="`,
			setHeaders:        func(r *http.Request) {},
		},
	}

	for _, test := range specTests {
		t.Run(test.name, func(t *testing.T) {
			test := test
			r, err := http.NewRequest("POST", "http://example.com/foo?param=value&pet=dog", bytes.NewBuffer([]byte(testSpecBody)))
			if err != nil {
				t.Fatalf("error creating request: %s", err)
			}

			r.Header["Date"] = []string{testSpecDate}
			r.Header["Host"] = []string{r.URL.Host}
			r.Header["Content-Length"] = []string{strconv.Itoa(len(testSpecBody))}
			r.Header["Content-Type"] = []string{"application/json"}
			setDigest(r)

			s, _, err := NewSigner([]Algorithm{RSA_SHA256}, test.headers, Authorization)
			if err != nil {
				t.Fatalf("error creating signer: %s", err)
			}

			if err := s.SignRequest(testSpecRSAPrivateKey, "Test", r); err != nil {
				t.Fatalf("error signing request: %s", err)
			}

			expectedAuth := test.expectedSignature
			gotAuth := fmt.Sprintf("Authorization: %s", r.Header["Authorization"][0])
			if gotAuth != expectedAuth {
				t.Errorf("%s\nGot: %s\nWant:%s", test.name, gotAuth, expectedAuth)
			}
		})
	}
}

func loadPrivateKey(keyData []byte) (*rsa.PrivateKey, error) {
	pem, _ := pem.Decode(keyData)
	if pem.Type != "RSA PRIVATE KEY" {
		return nil, fmt.Errorf("RSA private key is of the wrong type: %s", pem.Type)
	}

	return x509.ParsePKCS1PrivateKey(pem.Bytes)
}

func loadPublicKey(keyData []byte) (*rsa.PublicKey, error) {
	pem, _ := pem.Decode(keyData)
	if pem.Type != "PUBLIC KEY" {
		return nil, fmt.Errorf("public key is of the wrong type: %s", pem.Type)
	}

	key, err := x509.ParsePKIXPublicKey(pem.Bytes)
	if err != nil {
		return nil, err
	}

	return key.(*rsa.PublicKey), nil
}

func setDigest(r *http.Request) ([]byte, error) {
	var bodyBytes []byte
	if _, ok := r.Header["Digest"]; !ok {
		body := ""
		if r.Body != nil {
			var err error
			bodyBytes, err = ioutil.ReadAll(r.Body)
			if err != nil {
				return nil, fmt.Errorf("error reading body. %v", err)
			}

			// And now set a new body, which will simulate the same data we read:
			r.Body = ioutil.NopCloser(bytes.NewBuffer(bodyBytes))
			body = string(bodyBytes)
		}

		d := sha256.Sum256([]byte(body))
		r.Header["Digest"] = []string{fmt.Sprintf("SHA-256=%s", base64.StdEncoding.EncodeToString(d[:]))}
	}

	return bodyBytes, nil
}

const testSpecBody = `{"hello": "world"}`

const testSpecDate = `Sun, 05 Jan 2014 21:31:40 GMT`

const testSpecPrivateKeyPEM = `-----BEGIN RSA PRIVATE KEY-----
MIICXgIBAAKBgQDCFENGw33yGihy92pDjZQhl0C36rPJj+CvfSC8+q28hxA161QF
NUd13wuCTUcq0Qd2qsBe/2hFyc2DCJJg0h1L78+6Z4UMR7EOcpfdUE9Hf3m/hs+F
UR45uBJeDK1HSFHD8bHKD6kv8FPGfJTotc+2xjJwoYi+1hqp1fIekaxsyQIDAQAB
AoGBAJR8ZkCUvx5kzv+utdl7T5MnordT1TvoXXJGXK7ZZ+UuvMNUCdN2QPc4sBiA
QWvLw1cSKt5DsKZ8UETpYPy8pPYnnDEz2dDYiaew9+xEpubyeW2oH4Zx71wqBtOK
kqwrXa/pzdpiucRRjk6vE6YY7EBBs/g7uanVpGibOVAEsqH1AkEA7DkjVH28WDUg
f1nqvfn2Kj6CT7nIcE3jGJsZZ7zlZmBmHFDONMLUrXR/Zm3pR5m0tCmBqa5RK95u
412jt1dPIwJBANJT3v8pnkth48bQo/fKel6uEYyboRtA5/uHuHkZ6FQF7OUkGogc
mSJluOdc5t6hI1VsLn0QZEjQZMEOWr+wKSMCQQCC4kXJEsHAve77oP6HtG/IiEn7
kpyUXRNvFsDE0czpJJBvL/aRFUJxuRK91jhjC68sA7NsKMGg5OXb5I5Jj36xAkEA
gIT7aFOYBFwGgQAQkWNKLvySgKbAZRTeLBacpHMuQdl1DfdntvAyqpAZ0lY0RKmW
G6aFKaqQfOXKCyWoUiVknQJAXrlgySFci/2ueKlIE1QqIiLSZ8V8OlpFLRnb1pzI
7U1yQXnTAEFYM560yJlzUpOb1V4cScGd365tiSMvxLOvTA==
-----END RSA PRIVATE KEY-----`

const testSpecPublicKeyPEM = `-----BEGIN PUBLIC KEY-----
MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDCFENGw33yGihy92pDjZQhl0C3
6rPJj+CvfSC8+q28hxA161QFNUd13wuCTUcq0Qd2qsBe/2hFyc2DCJJg0h1L78+6
Z4UMR7EOcpfdUE9Hf3m/hs+FUR45uBJeDK1HSFHD8bHKD6kv8FPGfJTotc+2xjJw
oYi+1hqp1fIekaxsyQIDAQAB
-----END PUBLIC KEY-----`