types: Fix PolicyTypeUnlockConditions validation

types/policy.go

@@ -177,20 +177,31 @@ func (p SpendPolicy) Verify(height uint64, medianTimestamp time.Time, sigHash Ha
 		case PolicyTypeUnlockConditions:
 			if err := verify(PolicyAbove(p.Timelock)); err != nil {
 				return err
-			} else if p.SignaturesRequired > 255 {
-				return fmt.Errorf("too many signatures required (%v > 255)", p.SignaturesRequired)
 			}
-			n := uint8(p.SignaturesRequired)
-			of := make([]SpendPolicy, len(p.PublicKeys))
 			for i, pk := range p.PublicKeys {
-				if pk.Algorithm != SpecifierEd25519 {
-					return fmt.Errorf("unsupported algorithm %v", pk.Algorithm)
-				} else if len(pk.Key) != len(PublicKey{}) {
-					return fmt.Errorf("invalid Ed25519 key length %v", len(pk.Key))
+				if p.SignaturesRequired == 0 || p.SignaturesRequired > uint64(len(p.PublicKeys[i:])) || p.SignaturesRequired > uint64(len(sigs)) {
+					break
 				}
-				of[i] = PolicyPublicKey(*(*PublicKey)(pk.Key))
+				switch pk.Algorithm {
+				case SpecifierEntropy:
+					return errors.New("policy uses an entropy public key")
+				case SpecifierEd25519:
+					var epk PublicKey
+					copy(epk[:], pk.Key)
+					if epk.VerifyHash(sigHash, sigs[0]) {
+						sigs = sigs[1:]
+						p.SignaturesRequired--
+					}
+				default:
+					// all other algorithms are considered valid by default
+					sigs = sigs[1:]
+					p.SignaturesRequired--
+				}
+			}
+			if p.SignaturesRequired == 0 {
+				return nil
 			}
-			return verify(PolicyThreshold(n, of))
+			return errors.New("threshold not reached")
 		default:
 			panic("invalid policy type") // developer error
 		}

types/policy_test.go

@@ -137,6 +137,16 @@ func TestPolicyVerify(t *testing.T) {
 			[]Signature{key.SignHash(sigHash)},
 			false,
 		},
+		{
+			"exceed threshold with keys",
+			PolicyThreshold(1, []SpendPolicy{
+				PolicyPublicKey(pk),
+				PolicyPublicKey(pk),
+			}),
+			11,
+			[]Signature{key.SignHash(sigHash), key.SignHash(sigHash)},
+			false,
+		},
 		{
 			"lower threshold, neither valid",
 			PolicyThreshold(1, []SpendPolicy{
@@ -177,6 +187,15 @@ func TestPolicyVerify(t *testing.T) {
 			nil,
 			false,
 		},
+		{
+			"unlock conditions, superfluous signatures",
+			SpendPolicy{PolicyTypeUnlockConditions{
+				SignaturesRequired: 0,
+			}},
+			1,
+			[]Signature{key.SignHash(sigHash)},
+			false,
+		},
 		{
 			"unlock conditions, wrong signature algorithm",
 			SpendPolicy{PolicyTypeUnlockConditions{
@@ -223,6 +242,16 @@ func TestPolicyVerify(t *testing.T) {
 			[]Signature{key.SignHash(sigHash)},
 			true,
 		},
+		{
+			"unlock conditions, valid with extra pubkeys",
+			SpendPolicy{PolicyTypeUnlockConditions{
+				PublicKeys:         []UnlockKey{pk.UnlockKey(), PublicKey{1, 2, 3}.UnlockKey(), pk.UnlockKey()},
+				SignaturesRequired: 2,
+			}},
+			1,
+			[]Signature{key.SignHash(sigHash), key.SignHash(sigHash)},
+			true,
+		},
 	} {
 		if err := test.p.Verify(test.height, time.Time{}, sigHash, test.sigs, nil); err != nil && test.valid {
 			t.Fatalf("%v: %v", test.desc, err)