Remove redundant return value for verification

yaronf · yaronf · commit dcd7e880c39c · 2022-01-26T09:39:37.000+02:00
diff --git a/client.go b/client.go
@@ -61,7 +61,7 @@ func (c *Client) Do(req *http.Request) (*http.Response, error) {
 	}
 
 	if c.verifier != nil {
-		_, err := VerifyResponse(c.sigName, *c.verifier, res)
+		err := VerifyResponse(c.sigName, *c.verifier, res)
 		if err != nil {
 			return nil, err
 		}
@@ -70,7 +70,7 @@ func (c *Client) Do(req *http.Request) (*http.Response, error) {
 		if err != nil {
 			return nil, err
 		}
-		_, err := VerifyResponse(sigName, *verifier, res)
+		err := VerifyResponse(sigName, *verifier, res)
 		if err != nil {
 			return nil, err
 		}
diff --git a/config.go b/config.go
@@ -2,6 +2,7 @@ package httpsign
 
 import (
 	"fmt"
+	"log"
 	"net/http"
 	"time"
 )
@@ -162,7 +163,8 @@ func defaultReqNotVerified(w http.ResponseWriter, _ *http.Request, err error) {
 	if err == nil { // should not happen
 		_, _ = fmt.Fprintf(w, "Unknown error")
 	}
-	_, _ = fmt.Fprintln(w, "Could not verify request signature: "+err.Error())
+	log.Println("Could not verify request signature: " + err.Error())
+	_, _ = fmt.Fprintln(w, "Could not verify request signature")
 }
 
 // SetReqNotVerified defines a callback to be called when a request fails to verify. The default
diff --git a/handler.go b/handler.go
@@ -134,8 +134,8 @@ func verifyServerRequest(w http.ResponseWriter, r *http.Request, config *Handler
 		config.reqNotVerified(w, r, fmt.Errorf("could not fetch a verifier, check key ID"))
 		return false
 	}
-	verified, err := VerifyRequest(sigName, *verifier, r)
-	if !verified {
+	err := VerifyRequest(sigName, *verifier, r)
+	if err != nil {
 		config.reqNotVerified(w, r, err)
 		return false
 	}
diff --git a/signatures.go b/signatures.go
@@ -141,18 +141,18 @@ func addPseudoHeaders(message *parsedMessage, config SignConfig) {
 }
 
 //
-// VerifyRequest verifies a signed HTTP request. Returns true if verification was successful.
+// VerifyRequest verifies a signed HTTP request. Returns an error if verification failed for any reason, otherwise nil.
 //
-func VerifyRequest(signatureName string, verifier Verifier, req *http.Request) (verified bool, err error) {
+func VerifyRequest(signatureName string, verifier Verifier, req *http.Request) (err error) {
 	if req == nil {
-		return false, fmt.Errorf("nil request")
+		return fmt.Errorf("nil request")
 	}
 	if signatureName == "" {
-		return false, fmt.Errorf("empty signature name")
+		return fmt.Errorf("empty signature name")
 	}
 	parsedMessage, err := parseRequest(req)
 	if err != nil {
-		return false, err
+		return err
 	}
 	return verifyMessage(*verifier.c, signatureName, verifier, *parsedMessage, verifier.f)
 }
@@ -216,60 +216,59 @@ func messageKeyID(signatureName string, parsedMessage parsedMessage) (keyID, alg
 }
 
 //
-// VerifyResponse verifies a signed HTTP response. Returns true if verification was successful.
+// VerifyResponse verifies a signed HTTP response. Returns an error if verification failed for any reason, otherwise nil.
 //
-func VerifyResponse(signatureName string, verifier Verifier, res *http.Response) (verified bool, err error) {
+func VerifyResponse(signatureName string, verifier Verifier, res *http.Response) (err error) {
 	if res == nil {
-		return false, fmt.Errorf("nil response")
+		return fmt.Errorf("nil response")
 	}
 	if signatureName == "" {
-		return false, fmt.Errorf("empty signature name")
+		return fmt.Errorf("empty signature name")
 	}
 	parsedMessage, err := parseResponse(res)
 	if err != nil {
-		return false, err
+		return err
 	}
 	return verifyMessage(*verifier.c, signatureName, verifier, *parsedMessage, verifier.f)
 }
 
-func verifyMessage(config VerifyConfig, name string, verifier Verifier, message parsedMessage, fields Fields) (bool, error) {
+func verifyMessage(config VerifyConfig, name string, verifier Verifier, message parsedMessage, fields Fields) error {
 	wsi, found := message.components[*fromHeaderName("signature-input")]
 	if !found {
-		return false, fmt.Errorf("missing \"signature-input\" header")
+		return fmt.Errorf("missing \"signature-input\" header")
 	}
 	wantSignatureInput := wsi[0]
 	ws, found := message.components[*fromHeaderName("signature")]
 	if !found {
-		return false, fmt.Errorf("missing \"signature\" header")
+		return fmt.Errorf("missing \"signature\" header")
 	}
 	wantSignature := ws[0]
 	delete(message.components, *fromHeaderName("signature-input"))
 	delete(message.components, *fromHeaderName("signature"))
 	err := validateFields(fields)
 	if err != nil {
-		return false, err
+		return err
 	}
 	wantSigRaw, err := parseWantSignature(wantSignature, name)
 	if err != nil {
-		return false, err
+		return err
 	}
 	psiSig, err := parseSignatureInput(wantSignatureInput, name)
 	if err != nil {
-		return false, err
+		return err
 	}
 	if !(psiSig.fields.contains(&fields)) {
-		return false, fmt.Errorf("actual signature does not cover all required fields")
+		return fmt.Errorf("actual signature does not cover all required fields")
 	}
 	err = applyVerificationPolicy(psiSig, config)
 	if err != nil {
-		return false, err
+		return err
 	}
 	signatureInput, err := generateSignatureInput(message, psiSig.fields, psiSig.origSigParams)
 	if err != nil {
-		return false, err
+		return err
 	}
-	verified, err := verifySignature(verifier, signatureInput, wantSigRaw)
-	return verified, err
+	return verifySignature(verifier, signatureInput, wantSigRaw)
 }
 
 func applyVerificationPolicy(psi *psiSignature, config VerifyConfig) error {
@@ -327,12 +326,12 @@ func applyVerificationPolicy(psi *psiSignature, config VerifyConfig) error {
 	return nil
 }
 
-func verifySignature(verifier Verifier, input string, signature []byte) (bool, error) {
+func verifySignature(verifier Verifier, input string, signature []byte) error {
 	verified, err := verifier.verify([]byte(input), signature)
-	if !verified && err == nil {
+	if !verified && (err == nil) {
 		err = fmt.Errorf("bad signature, check key or signature value")
 	}
-	return verified, err
+	return err
 }
 
 type psiSignature struct {
diff --git a/signatures_test.go b/signatures_test.go
@@ -545,13 +545,10 @@ func TestSignAndVerifyHMAC(t *testing.T) {
 	if err != nil {
 		t.Errorf("could not generate verifier: %s", err)
 	}
-	verified, err := VerifyRequest(signatureName, *verifier, req)
+	err = VerifyRequest(signatureName, *verifier, req)
 	if err != nil {
 		t.Errorf("verification error: %s", err)
 	}
-	if !verified {
-		t.Errorf("message did not pass verification")
-	}
 }
 
 func TestCreated(t *testing.T) {
@@ -571,7 +568,7 @@ func TestCreated(t *testing.T) {
 		if err != nil {
 			t.Errorf("could not generate verifier: %s", err)
 		}
-		_, err = VerifyResponse(signatureName, *verifier, res2)
+		err = VerifyResponse(signatureName, *verifier, res2)
 		if wantSuccess && err != nil {
 			t.Errorf("verification error: %s", err)
 		}
@@ -603,13 +600,10 @@ func TestSignAndVerifyResponseHMAC(t *testing.T) {
 	if err != nil {
 		t.Errorf("could not generate verifier: %s", err)
 	}
-	verified, err := VerifyResponse(signatureName, *verifier, res2)
+	err = VerifyResponse(signatureName, *verifier, res2)
 	if err != nil {
 		t.Errorf("verification error: %s", err)
 	}
-	if !verified {
-		t.Errorf("message did not pass verification")
-	}
 }
 
 func TestSignAndVerifyRSAPSS(t *testing.T) {
@@ -633,13 +627,10 @@ func TestSignAndVerifyRSAPSS(t *testing.T) {
 	if err != nil {
 		t.Errorf("could not generate verifier: %s", err)
 	}
-	verified, err := VerifyRequest(signatureName, *verifier, req)
+	err = VerifyRequest(signatureName, *verifier, req)
 	if err != nil {
 		t.Errorf("verification error: %s", err)
 	}
-	if !verified {
-		t.Errorf("message did not pass verification")
-	}
 }
 
 func TestSignAndVerifyRSA(t *testing.T) {
@@ -663,13 +654,10 @@ func TestSignAndVerifyRSA(t *testing.T) {
 	if err != nil {
 		t.Errorf("could not generate verifier: %s", err)
 	}
-	verified, err := VerifyRequest(signatureName, *verifier, req)
+	err = VerifyRequest(signatureName, *verifier, req)
 	if err != nil {
 		t.Errorf("verification error: %s", err)
 	}
-	if !verified {
-		t.Errorf("message did not pass verification")
-	}
 }
 
 func TestSignAndVerifyP256(t *testing.T) {
@@ -696,13 +684,10 @@ func TestSignAndVerifyP256(t *testing.T) {
 	if err != nil {
 		t.Errorf("could not generate verifier: %s", err)
 	}
-	verified, err := VerifyRequest(signatureName, *verifier, req)
+	err = VerifyRequest(signatureName, *verifier, req)
 	if err != nil {
 		t.Errorf("verification error: %s", err)
 	}
-	if !verified {
-		t.Errorf("message did not pass verification")
-	}
 }
 
 func TestSignResponse(t *testing.T) {
@@ -779,8 +764,8 @@ Signature:       sig77=:3e9KqLP62NHfHY5OMG4036+U6tvBowZF35ALzTjpsf0=:
 
 `
 	req, _ := http.ReadRequest(bufio.NewReader(strings.NewReader(reqStr)))
-	verified, _ := VerifyRequest("sig77", *verifier, req)
-	fmt.Printf("verified: %t", verified)
+	err := VerifyRequest("sig77", *verifier, req)
+	fmt.Printf("verified: %t", err == nil)
 	// Output: verified: true
 }
 
@@ -880,14 +865,11 @@ func TestVerifyRequest(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			got, err := VerifyRequest(tt.args.signatureName, tt.args.verifier, tt.args.req)
+			err := VerifyRequest(tt.args.signatureName, tt.args.verifier, tt.args.req)
 			if (err != nil) != tt.wantErr {
 				t.Errorf("VerifyRequest() error = %v, wantErr %v", err, tt.wantErr)
 				return
 			}
-			if got != tt.want {
-				t.Errorf("VerifyRequest() got = %v, want %v", got, tt.want)
-			}
 		})
 	}
 }

Original file line number	Diff line number	Diff line change
`@@ -61,7 +61,7 @@ func (c Client) Do(req http.Request) (*http.Response, error) {`
`61`	`61`	`}`
`62`	`62`
`63`	`63`	`if c.verifier != nil {`
`64`		`- _, err := VerifyResponse(c.sigName, *c.verifier, res)`
	`64`	`+ err := VerifyResponse(c.sigName, *c.verifier, res)`
`65`	`65`	`if err != nil {`
`66`	`66`	`return nil, err`
`67`	`67`	`}`
`@@ -70,7 +70,7 @@ func (c Client) Do(req http.Request) (*http.Response, error) {`
`70`	`70`	`if err != nil {`
`71`	`71`	`return nil, err`
`72`	`72`	`}`
`73`		`- _, err := VerifyResponse(sigName, *verifier, res)`
	`73`	`+ err := VerifyResponse(sigName, *verifier, res)`
`74`	`74`	`if err != nil {`
`75`	`75`	`return nil, err`
`76`	`76`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@ package httpsign`
`2`	`2`
`3`	`3`	`import (`
`4`	`4`	`"fmt"`
	`5`	`+ "log"`
`5`	`6`	`"net/http"`
`6`	`7`	`"time"`
`7`	`8`	`)`
`@@ -162,7 +163,8 @@ func defaultReqNotVerified(w http.ResponseWriter, _ *http.Request, err error) {`
`162`	`163`	`if err == nil { // should not happen`
`163`	`164`	`_, _ = fmt.Fprintf(w, "Unknown error")`
`164`	`165`	`}`
`165`		`- _, _ = fmt.Fprintln(w, "Could not verify request signature: "+err.Error())`
	`166`	`+ log.Println("Could not verify request signature: " + err.Error())`
	`167`	`+ _, _ = fmt.Fprintln(w, "Could not verify request signature")`
`166`	`168`	`}`
`167`	`169`
`168`	`170`	`// SetReqNotVerified defines a callback to be called when a request fails to verify. The default`
Original file line number	Diff line number	Diff line change
`@@ -134,8 +134,8 @@ func verifyServerRequest(w http.ResponseWriter, r http.Request, config Handler`
`134`	`134`	`config.reqNotVerified(w, r, fmt.Errorf("could not fetch a verifier, check key ID"))`
`135`	`135`	`return false`
`136`	`136`	`}`
`137`		`- verified, err := VerifyRequest(sigName, *verifier, r)`
`138`		`- if !verified {`
	`137`	`+ err := VerifyRequest(sigName, *verifier, r)`
	`138`	`+ if err != nil {`
`139`	`139`	`config.reqNotVerified(w, r, err)`
`140`	`140`	`return false`
`141`	`141`	`}`
Original file line number	Diff line number	Diff line change
`@@ -141,18 +141,18 @@ func addPseudoHeaders(message *parsedMessage, config SignConfig) {`
`141`	`141`	`}`
`142`	`142`
`143`	`143`	`//`
`144`		`-// VerifyRequest verifies a signed HTTP request. Returns true if verification was successful.`
	`144`	`+// VerifyRequest verifies a signed HTTP request. Returns an error if verification failed for any reason, otherwise nil.`
`145`	`145`	`//`
`146`		`-func VerifyRequest(signatureName string, verifier Verifier, req *http.Request) (verified bool, err error) {`
	`146`	`+func VerifyRequest(signatureName string, verifier Verifier, req *http.Request) (err error) {`
`147`	`147`	`if req == nil {`
`148`		`- return false, fmt.Errorf("nil request")`
	`148`	`+ return fmt.Errorf("nil request")`
`149`	`149`	`}`
`150`	`150`	`if signatureName == "" {`
`151`		`- return false, fmt.Errorf("empty signature name")`
	`151`	`+ return fmt.Errorf("empty signature name")`
`152`	`152`	`}`
`153`	`153`	`parsedMessage, err := parseRequest(req)`
`154`	`154`	`if err != nil {`
`155`		`- return false, err`
	`155`	`+ return err`
`156`	`156`	`}`
`157`	`157`	`return verifyMessage(verifier.c, signatureName, verifier, parsedMessage, verifier.f)`
`158`	`158`	`}`
`@@ -216,60 +216,59 @@ func messageKeyID(signatureName string, parsedMessage parsedMessage) (keyID, alg`
`216`	`216`	`}`
`217`	`217`
`218`	`218`	`//`
`219`		`-// VerifyResponse verifies a signed HTTP response. Returns true if verification was successful.`
	`219`	`+// VerifyResponse verifies a signed HTTP response. Returns an error if verification failed for any reason, otherwise nil.`
`220`	`220`	`//`
`221`		`-func VerifyResponse(signatureName string, verifier Verifier, res *http.Response) (verified bool, err error) {`
	`221`	`+func VerifyResponse(signatureName string, verifier Verifier, res *http.Response) (err error) {`
`222`	`222`	`if res == nil {`
`223`		`- return false, fmt.Errorf("nil response")`
	`223`	`+ return fmt.Errorf("nil response")`
`224`	`224`	`}`
`225`	`225`	`if signatureName == "" {`
`226`		`- return false, fmt.Errorf("empty signature name")`
	`226`	`+ return fmt.Errorf("empty signature name")`
`227`	`227`	`}`
`228`	`228`	`parsedMessage, err := parseResponse(res)`
`229`	`229`	`if err != nil {`
`230`		`- return false, err`
	`230`	`+ return err`
`231`	`231`	`}`
`232`	`232`	`return verifyMessage(verifier.c, signatureName, verifier, parsedMessage, verifier.f)`
`233`	`233`	`}`
`234`	`234`
`235`		`-func verifyMessage(config VerifyConfig, name string, verifier Verifier, message parsedMessage, fields Fields) (bool, error) {`
	`235`	`+func verifyMessage(config VerifyConfig, name string, verifier Verifier, message parsedMessage, fields Fields) error {`
`236`	`236`	`wsi, found := message.components[*fromHeaderName("signature-input")]`
`237`	`237`	`if !found {`
`238`		`- return false, fmt.Errorf("missing \"signature-input\" header")`
	`238`	`+ return fmt.Errorf("missing \"signature-input\" header")`
`239`	`239`	`}`
`240`	`240`	`wantSignatureInput := wsi[0]`
`241`	`241`	`ws, found := message.components[*fromHeaderName("signature")]`
`242`	`242`	`if !found {`
`243`		`- return false, fmt.Errorf("missing \"signature\" header")`
	`243`	`+ return fmt.Errorf("missing \"signature\" header")`
`244`	`244`	`}`
`245`	`245`	`wantSignature := ws[0]`
`246`	`246`	`delete(message.components, *fromHeaderName("signature-input"))`
`247`	`247`	`delete(message.components, *fromHeaderName("signature"))`
`248`	`248`	`err := validateFields(fields)`
`249`	`249`	`if err != nil {`
`250`		`- return false, err`
	`250`	`+ return err`
`251`	`251`	`}`
`252`	`252`	`wantSigRaw, err := parseWantSignature(wantSignature, name)`
`253`	`253`	`if err != nil {`
`254`		`- return false, err`
	`254`	`+ return err`
`255`	`255`	`}`
`256`	`256`	`psiSig, err := parseSignatureInput(wantSignatureInput, name)`
`257`	`257`	`if err != nil {`
`258`		`- return false, err`
	`258`	`+ return err`
`259`	`259`	`}`
`260`	`260`	`if !(psiSig.fields.contains(&fields)) {`
`261`		`- return false, fmt.Errorf("actual signature does not cover all required fields")`
	`261`	`+ return fmt.Errorf("actual signature does not cover all required fields")`
`262`	`262`	`}`
`263`	`263`	`err = applyVerificationPolicy(psiSig, config)`
`264`	`264`	`if err != nil {`
`265`		`- return false, err`
	`265`	`+ return err`
`266`	`266`	`}`
`267`	`267`	`signatureInput, err := generateSignatureInput(message, psiSig.fields, psiSig.origSigParams)`
`268`	`268`	`if err != nil {`
`269`		`- return false, err`
	`269`	`+ return err`
`270`	`270`	`}`
`271`		`- verified, err := verifySignature(verifier, signatureInput, wantSigRaw)`
`272`		`- return verified, err`
	`271`	`+ return verifySignature(verifier, signatureInput, wantSigRaw)`
`273`	`272`	`}`
`274`	`273`
`275`	`274`	`func applyVerificationPolicy(psi *psiSignature, config VerifyConfig) error {`
`@@ -327,12 +326,12 @@ func applyVerificationPolicy(psi *psiSignature, config VerifyConfig) error {`
`327`	`326`	`return nil`
`328`	`327`	`}`
`329`	`328`
`330`		`-func verifySignature(verifier Verifier, input string, signature []byte) (bool, error) {`
	`329`	`+func verifySignature(verifier Verifier, input string, signature []byte) error {`
`331`	`330`	`verified, err := verifier.verify([]byte(input), signature)`
`332`		`- if !verified && err == nil {`
	`331`	`+ if !verified && (err == nil) {`
`333`	`332`	`err = fmt.Errorf("bad signature, check key or signature value")`
`334`	`333`	`}`
`335`		`- return verified, err`
	`334`	`+ return err`
`336`	`335`	`}`
`337`	`336`
`338`	`337`	`type psiSignature struct {`
Original file line number	Diff line number	Diff line change
`@@ -545,13 +545,10 @@ func TestSignAndVerifyHMAC(t *testing.T) {`
`545`	`545`	`if err != nil {`
`546`	`546`	`t.Errorf("could not generate verifier: %s", err)`
`547`	`547`	`}`
`548`		`- verified, err := VerifyRequest(signatureName, *verifier, req)`
	`548`	`+ err = VerifyRequest(signatureName, *verifier, req)`
`549`	`549`	`if err != nil {`
`550`	`550`	`t.Errorf("verification error: %s", err)`
`551`	`551`	`}`
`552`		`- if !verified {`
`553`		`- t.Errorf("message did not pass verification")`
`554`		`- }`
`555`	`552`	`}`
`556`	`553`
`557`	`554`	`func TestCreated(t *testing.T) {`
`@@ -571,7 +568,7 @@ func TestCreated(t *testing.T) {`
`571`	`568`	`if err != nil {`
`572`	`569`	`t.Errorf("could not generate verifier: %s", err)`
`573`	`570`	`}`
`574`		`- _, err = VerifyResponse(signatureName, *verifier, res2)`
	`571`	`+ err = VerifyResponse(signatureName, *verifier, res2)`
`575`	`572`	`if wantSuccess && err != nil {`
`576`	`573`	`t.Errorf("verification error: %s", err)`
`577`	`574`	`}`
`@@ -603,13 +600,10 @@ func TestSignAndVerifyResponseHMAC(t *testing.T) {`
`603`	`600`	`if err != nil {`
`604`	`601`	`t.Errorf("could not generate verifier: %s", err)`
`605`	`602`	`}`
`606`		`- verified, err := VerifyResponse(signatureName, *verifier, res2)`
	`603`	`+ err = VerifyResponse(signatureName, *verifier, res2)`
`607`	`604`	`if err != nil {`
`608`	`605`	`t.Errorf("verification error: %s", err)`
`609`	`606`	`}`
`610`		`- if !verified {`
`611`		`- t.Errorf("message did not pass verification")`
`612`		`- }`
`613`	`607`	`}`
`614`	`608`
`615`	`609`	`func TestSignAndVerifyRSAPSS(t *testing.T) {`
`@@ -633,13 +627,10 @@ func TestSignAndVerifyRSAPSS(t *testing.T) {`
`633`	`627`	`if err != nil {`
`634`	`628`	`t.Errorf("could not generate verifier: %s", err)`
`635`	`629`	`}`
`636`		`- verified, err := VerifyRequest(signatureName, *verifier, req)`
	`630`	`+ err = VerifyRequest(signatureName, *verifier, req)`
`637`	`631`	`if err != nil {`
`638`	`632`	`t.Errorf("verification error: %s", err)`
`639`	`633`	`}`
`640`		`- if !verified {`
`641`		`- t.Errorf("message did not pass verification")`
`642`		`- }`
`643`	`634`	`}`
`644`	`635`
`645`	`636`	`func TestSignAndVerifyRSA(t *testing.T) {`
`@@ -663,13 +654,10 @@ func TestSignAndVerifyRSA(t *testing.T) {`
`663`	`654`	`if err != nil {`
`664`	`655`	`t.Errorf("could not generate verifier: %s", err)`
`665`	`656`	`}`
`666`		`- verified, err := VerifyRequest(signatureName, *verifier, req)`
	`657`	`+ err = VerifyRequest(signatureName, *verifier, req)`
`667`	`658`	`if err != nil {`
`668`	`659`	`t.Errorf("verification error: %s", err)`
`669`	`660`	`}`
`670`		`- if !verified {`
`671`		`- t.Errorf("message did not pass verification")`
`672`		`- }`
`673`	`661`	`}`
`674`	`662`
`675`	`663`	`func TestSignAndVerifyP256(t *testing.T) {`
`@@ -696,13 +684,10 @@ func TestSignAndVerifyP256(t *testing.T) {`
`696`	`684`	`if err != nil {`
`697`	`685`	`t.Errorf("could not generate verifier: %s", err)`
`698`	`686`	`}`
`699`		`- verified, err := VerifyRequest(signatureName, *verifier, req)`
	`687`	`+ err = VerifyRequest(signatureName, *verifier, req)`
`700`	`688`	`if err != nil {`
`701`	`689`	`t.Errorf("verification error: %s", err)`
`702`	`690`	`}`
`703`		`- if !verified {`
`704`		`- t.Errorf("message did not pass verification")`
`705`		`- }`
`706`	`691`	`}`
`707`	`692`
`708`	`693`	`func TestSignResponse(t *testing.T) {`
`@@ -779,8 +764,8 @@ Signature: sig77=:3e9KqLP62NHfHY5OMG4036+U6tvBowZF35ALzTjpsf0=:`
`779`	`764`
`780`	`765`	`
`781`	`766`	`req, _ := http.ReadRequest(bufio.NewReader(strings.NewReader(reqStr)))`
`782`		`- verified, _ := VerifyRequest("sig77", *verifier, req)`
`783`		`- fmt.Printf("verified: %t", verified)`
	`767`	`+ err := VerifyRequest("sig77", *verifier, req)`
	`768`	`+ fmt.Printf("verified: %t", err == nil)`
`784`	`769`	`// Output: verified: true`
`785`	`770`	`}`
`786`	`771`
`@@ -880,14 +865,11 @@ func TestVerifyRequest(t *testing.T) {`
`880`	`865`	`}`
`881`	`866`	`for _, tt := range tests {`
`882`	`867`	`t.Run(tt.name, func(t *testing.T) {`
`883`		`- got, err := VerifyRequest(tt.args.signatureName, tt.args.verifier, tt.args.req)`
	`868`	`+ err := VerifyRequest(tt.args.signatureName, tt.args.verifier, tt.args.req)`
`884`	`869`	`if (err != nil) != tt.wantErr {`
`885`	`870`	`t.Errorf("VerifyRequest() error = %v, wantErr %v", err, tt.wantErr)`
`886`	`871`	`return`
`887`	`872`	`}`
`888`		`- if got != tt.want {`
`889`		`- t.Errorf("VerifyRequest() got = %v, want %v", got, tt.want)`
`890`		`- }`
`891`	`873`	`})`
`892`	`874`	`}`
`893`	`875`	`}`