torchwood: add NewCosignatureVerifierFromKey

Author: FiloSottile

cosignature.go

@@ -204,23 +204,55 @@ func NewCosignatureVerifier(vkey string) (*CosignatureVerifier, error) {
 	hash16, key64, _ := strings.Cut(vkey, "+")
 	hash, err1 := strconv.ParseUint(hash16, 16, 32)
 	key, err2 := base64.StdEncoding.DecodeString(key64)
-	if len(hash16) != 8 || err1 != nil || err2 != nil || !isValidName(name) || len(key) == 0 {
+	if len(hash16) != 8 || err1 != nil || err2 != nil || len(key) == 0 {
 		return nil, errors.New("malformed verifier id")
 	}
-	if uint32(hash) != keyHash(name, key) {
-		return nil, errors.New("invalid verifier hash")
-	}
 	alg, key := key[0], key[1:]
+	var verifier *CosignatureVerifier
 	switch alg {
 	case algCosignatureEd25519:
 		if len(key) != ed25519.PublicKeySize {
 			return nil, errors.New("malformed verifier public key")
 		}
 		k := ed25519.PublicKey(key)
+		v, err := NewCosignatureVerifierFromKey(name, k)
+		if err != nil {
+			return nil, err
+		}
+		verifier = v
+	case algCosignatureMLDSA:
+		k, err := mldsa.NewPublicKey(mldsa.MLDSA44(), key)
+		if err != nil {
+			return nil, fmt.Errorf("malformed verifier public key: %w", err)
+		}
+		v, err := NewCosignatureVerifierFromKey(name, k)
+		if err != nil {
+			return nil, err
+		}
+		verifier = v
+	default:
+		return nil, errors.New("unknown verifier algorithm")
+	}
+	if uint32(hash) != verifier.KeyHash() {
+		return nil, errors.New("invalid verifier hash")
+	}
+	return verifier, nil
+}
+
+// NewCosignatureVerifierFromKey constructs a new [CosignatureVerifier] from a
+// public key. It supports [ed25519.PublicKey] and [*mldsa.PublicKey].
+func NewCosignatureVerifierFromKey(name string, key crypto.PublicKey) (*CosignatureVerifier, error) {
+	if !isValidName(name) {
+		return nil, errors.New("invalid name")
+	}
+
+	switch k := key.(type) {
+	case ed25519.PublicKey:
+		hash := keyHash(name, append([]byte{algCosignatureEd25519}, k...))
 		return &CosignatureVerifier{
 			verifier: verifier{
 				name: name,
-				hash: uint32(hash),
+				hash: hash,
 				verify: func(msg, sig []byte) bool {
 					if len(sig) != 8+ed25519.SignatureSize {
 						return false
@@ -237,17 +269,14 @@ func NewCosignatureVerifier(vkey string) (*CosignatureVerifier, error) {
 					return ed25519.Verify(k, m, sig)
 				},
 			},
-			key: ed25519.PublicKey(key),
+			key: k,
 		}, nil
-	case algCosignatureMLDSA:
-		k, err := mldsa.NewPublicKey(mldsa.MLDSA44(), key)
-		if err != nil {
-			return nil, fmt.Errorf("malformed verifier public key: %w", err)
-		}
+	case *mldsa.PublicKey:
+		hash := keyHash(name, append([]byte{algCosignatureMLDSA}, k.Bytes()...))
 		return &CosignatureVerifier{
 			verifier: verifier{
 				name: name,
-				hash: uint32(hash),
+				hash: hash,
 				verify: func(msg, sig []byte) bool {
 					if len(sig) != 8+mldsa.MLDSA44SignatureSize {
 						return false
@@ -267,7 +296,7 @@ func NewCosignatureVerifier(vkey string) (*CosignatureVerifier, error) {
 			key: k,
 		}, nil
 	default:
-		return nil, errors.New("unknown verifier algorithm")
+		return nil, errors.New("key type is not supported")
 	}
 }