Introduce signature version flags

Author: ComputerCraftr

src/key.cpp

@@ -246,8 +246,8 @@ bool CKey::VerifyPubKey(const CPubKey& pubkey) const {
     return pubkey.Verify(hash, vchSig);
 }
 
-bool CKey::SignCompact(const uint256 &hash, std::vector<unsigned char>& vchSig) const {
-    if (!keydata)
+bool CKey::SignCompact(const uint256 &hash, std::vector<unsigned char>& vchSig, unsigned char header) const {
+    if (!keydata || header > CPubKey::SigFlag::VERSION_SIG_MASK)
         return false;
     vchSig.resize(CPubKey::COMPACT_SIGNATURE_SIZE);
     int rec = -1;
@@ -257,7 +257,7 @@ bool CKey::SignCompact(const uint256 &hash, std::vector<unsigned char>& vchSig)
     ret = secp256k1_ecdsa_recoverable_signature_serialize_compact(secp256k1_context_sign, &vchSig[1], &rec, &rsig);
     assert(ret);
     assert(rec != -1);
-    vchSig[0] = 27 + rec + (fCompressed ? 4 : 0);
+    vchSig[0] = header + rec + (fCompressed ? 4 : 0);
     // Additional verification step to prevent using a potentially corrupted signature
     secp256k1_pubkey epk, rpk;
     ret = secp256k1_ec_pubkey_create(secp256k1_context_sign, &epk, UCharCast(begin()));

src/key.h

@@ -153,7 +153,7 @@ class CKey
      *                  0x1D = second key with even y, 0x1E = second key with odd y,
      *                  add 0x04 for compressed keys.
      */
-    bool SignCompact(const uint256& hash, std::vector<unsigned char>& vchSig) const;
+    bool SignCompact(const uint256& hash, std::vector<unsigned char>& vchSig, unsigned char header = 27) const;
 
     /**
      * Create a BIP-340 Schnorr signature, for the xonly-pubkey corresponding to *this,

src/pubkey.cpp

@@ -53,7 +53,7 @@ int ecdsa_signature_parse_der_lax(secp256k1_ecdsa_signature* sig, const unsigned
     secp256k1_ecdsa_signature_parse_compact(secp256k1_context_static, sig, tmpsig);
 
     /* Sequence tag byte */
-    if (pos == inputlen || input[pos] != 0x30) {
+    if (pos == inputlen || input[pos] != CPubKey::SigFlag::VERSION_SIG_DER) {
         return 0;
     }
     pos++;
@@ -291,11 +291,11 @@ bool CPubKey::Verify(const uint256 &hash, const std::vector<unsigned char>& vchS
     return secp256k1_ecdsa_verify(secp256k1_context_static, &sig, hash.begin(), &pubkey);
 }
 
-bool CPubKey::RecoverCompact(const uint256 &hash, const std::vector<unsigned char>& vchSig) {
-    if (vchSig.size() != COMPACT_SIGNATURE_SIZE)
+bool CPubKey::RecoverCompact(const uint256 &hash, const std::vector<unsigned char>& vchSig, unsigned char header) {
+    if (vchSig.size() != COMPACT_SIGNATURE_SIZE || header > vchSig[0] || header > CPubKey::SigFlag::VERSION_SIG_MASK)
         return false;
-    int recid = (vchSig[0] - 27) & 3;
-    bool fComp = ((vchSig[0] - 27) & 4) != 0;
+    int recid = (vchSig[0] - header) & 3;
+    bool fComp = ((vchSig[0] - header) & 4) != 0;
     secp256k1_pubkey pubkey;
     secp256k1_ecdsa_recoverable_signature sig;
     if (!secp256k1_ecdsa_recoverable_signature_parse_compact(secp256k1_context_static, &sig, &vchSig[1], recid)) {

src/pubkey.h

@@ -48,6 +48,42 @@ class CPubKey
         SIZE >= COMPRESSED_SIZE,
         "COMPRESSED_SIZE is larger than SIZE");
 
+    enum SigType : int {
+        SIG_COMPACT = 0,
+        SIG_DER = 1,
+        SIG_COUNT
+    };
+
+    enum SigFlag : unsigned char {
+        // must be greater than zero to avoid being interpreted as an uncompressed public key
+        VERSION_SIG_COMPACT = 1 << 3,
+        VERSION_SIG_DER = 6 << 3,
+        VERSION_SIG_MASK = 31 << 3
+    };
+
+    static int GetSigType(unsigned char flag)
+    {
+        switch (flag & VERSION_SIG_MASK) {
+        case VERSION_SIG_COMPACT:
+            return SIG_COMPACT;
+        case VERSION_SIG_DER:
+            return SIG_DER;
+        default:
+            return -1;
+        }
+    }
+
+    static unsigned char GetSigFlag(int type)
+    {
+        switch (type) {
+        case SIG_COMPACT:
+            return VERSION_SIG_COMPACT;
+        case SIG_DER:
+        default:
+            return VERSION_SIG_DER;
+        }
+    }
+
 private:
 
     /**
@@ -218,7 +254,7 @@ class CPubKey
     static bool CheckLowS(const std::vector<unsigned char>& vchSig);
 
     //! Recover a public key from a compact signature.
-    bool RecoverCompact(const uint256& hash, const std::vector<unsigned char>& vchSig);
+    bool RecoverCompact(const uint256& hash, const std::vector<unsigned char>& vchSig, unsigned char header = 27);
 
     //! Turn this public key into an uncompressed public key.
     bool Decompress();

src/script/interpreter.cpp

@@ -122,7 +122,7 @@ bool static IsValidSignatureEncoding(const std::vector<unsigned char> &sig) {
     if (sig.size() > 73) return false;
 
     // A signature is of type 0x30 (compound).
-    if (sig[0] != 0x30) return false;
+    if (sig[0] != CPubKey::SigFlag::VERSION_SIG_DER) return false;
 
     // Make sure the length covers the entire signature.
     if (sig[1] != sig.size() - 3) return false;

src/script/sign.cpp

@@ -721,7 +721,7 @@ class DummySignatureCreator final : public BaseSignatureCreator {
     {
         // Create a dummy signature that is a valid DER-encoding
         vchSig.assign(m_r_len + m_s_len + 7, '\000');
-        vchSig[0] = 0x30;
+        vchSig[0] = CPubKey::SigFlag::VERSION_SIG_DER;
         vchSig[1] = m_r_len + m_s_len + 4;
         vchSig[2] = 0x02;
         vchSig[3] = m_r_len;