btcec/schnorr: zero out signature parsing allocations

Make ParseSignature short and simple, becoming eligible to inlining
which avoids allocations.

Author: allocz

btcec/schnorr/signature.go

@@ -62,39 +62,52 @@ func (sig Signature) Serialize() []byte {
 	return b[:]
 }
 
-// ParseSignature parses a signature according to the BIP-340 specification and
-// enforces the following additional restrictions specific to secp256k1:
-//
-// - The r component must be in the valid range for secp256k1 field elements
-// - The s component must be in the valid range for secp256k1 scalars
-func ParseSignature(sig []byte) (*Signature, error) {
+// parseSignature exists to make ParseSignature eligible to inlining and
+// therefore avoid allocations.
+func parseSignature(sig *Signature, sigb []byte) error {
 	// The signature must be the correct length.
-	sigLen := len(sig)
+	sigLen := len(sigb)
 	if sigLen < SignatureSize {
 		str := fmt.Sprintf("malformed signature: too short: %d < %d", sigLen,
 			SignatureSize)
-		return nil, signatureError(ecdsa_schnorr.ErrSigTooShort, str)
+		return signatureError(ecdsa_schnorr.ErrSigTooShort, str)
 	}
 	if sigLen > SignatureSize {
 		str := fmt.Sprintf("malformed signature: too long: %d > %d", sigLen,
 			SignatureSize)
-		return nil, signatureError(ecdsa_schnorr.ErrSigTooLong, str)
+		return signatureError(ecdsa_schnorr.ErrSigTooLong, str)
 	}
 
 	// The signature is validly encoded at this point, however, enforce
 	// additional restrictions to ensure r is in the range [0, p-1], and s is in
 	// the range [0, n-1] since valid Schnorr signatures are required to be in
 	// that range per spec.
 	var r btcec.FieldVal
-	if overflow := r.SetByteSlice(sig[0:32]); overflow {
+	if overflow := r.SetByteSlice(sigb[0:32]); overflow {
 		str := "invalid signature: r >= field prime"
-		return nil, signatureError(ecdsa_schnorr.ErrSigRTooBig, str)
+		return signatureError(ecdsa_schnorr.ErrSigRTooBig, str)
 	}
 	var s btcec.ModNScalar
-	s.SetByteSlice(sig[32:64])
+	s.SetByteSlice(sigb[32:64])
+
+	// Return the normalized signature.
+	sig.r = r
+	sig.s = s
+	sig.r.Normalize()
+	return nil
+}
 
-	// Return the signature.
-	return NewSignature(&r, &s), nil
+// ParseSignature parses a signature according to the BIP-340 specification and
+// enforces the following additional restrictions specific to secp256k1:
+//
+// - The r component must be in the valid range for secp256k1 field elements
+// - The s component must be in the valid range for secp256k1 scalars
+func ParseSignature(sig []byte) (*Signature, error) {
+	s := new(Signature)
+	if err := parseSignature(s, sig); err != nil {
+		return nil, err
+	}
+	return s, nil
 }
 
 // IsEqual compares this Signature instance to the one passed, returning true