break up importSignature since DER sigs can be any length, even if unlikely

Author: ProofOfKeags

src/Crypto/Secp256k1.hs

@@ -35,7 +35,8 @@ module Crypto.Secp256k1 (
     exportPubKeyXY,
     importPubKeyXO,
     exportPubKeyXO,
-    importSignature,
+    importSignatureCompact,
+    importSignatureDer,
     exportSignatureCompact,
     exportSignatureDer,
     importRecoverableSignature,
@@ -80,6 +81,7 @@ module Crypto.Secp256k1 (
     ecdh,
 ) where
 
+import Control.Applicative (Alternative (..))
 import Control.DeepSeq (NFData (..))
 import Control.Monad (replicateM, unless, (<=<))
 import Control.Monad.Trans.Class (lift)
@@ -269,7 +271,7 @@ instance Show Signature where
 instance Read Signature where
     readsPrec i cs = case decodeBase16 $ B8.pack token of
         Left e -> []
-        Right a -> maybeToList $ (,rest) <$> importSignature a
+        Right a -> maybeToList $ (,rest) <$> (importSignatureCompact a <|> importSignatureDer a)
         where
             trimmed = dropWhile isSpace cs
             (token, rest) = span isAlphaNum trimmed
@@ -414,24 +416,33 @@ exportPubKeyXO (PubKeyXO pkFPtr) = unsafePerformIO $ do
     unsafePackByteString (outBuf, 32)
 
 
--- | Parses 'Signature' from DER (71 | 72 | 73 bytes) or Compact (64 bytes) representations.
-importSignature :: ByteString -> Maybe Signature
-importSignature bs = unsafePerformIO $
+-- | Parses 'Signature' from Compact (64 bytes) representation.
+importSignatureCompact :: ByteString -> Maybe Signature
+importSignatureCompact bs = unsafePerformIO $
     unsafeUseByteString bs $ \(inBuf, len) -> do
         outBuf <- mallocBytes 64
         ret <-
-            if
+            if len == 64
                 -- compact
-                | len == 64 -> Prim.ecdsaSignatureParseCompact ctx outBuf inBuf
-                -- der
-                | len >= 69 && len <= 73 -> Prim.ecdsaSignatureParseDer ctx outBuf inBuf len
+                then Prim.ecdsaSignatureParseCompact ctx outBuf inBuf
                 -- invalid
-                | otherwise -> pure 0
+                else pure 0
         if isSuccess ret
             then Just . Signature <$> newForeignPtr finalizerFree outBuf
             else free outBuf $> Nothing
 
 
+-- | Parses 'Signature' from DER representation.
+importSignatureDer :: ByteString -> Maybe Signature
+importSignatureDer bs = unsafePerformIO $
+    unsafeUseByteString bs $ \(inBuf, len) -> do
+        outBuf <- mallocBytes 64
+        ret <- Prim.ecdsaSignatureParseDer ctx outBuf inBuf len
+        if isSuccess ret
+            then Just . Signature <$> newForeignPtr finalizerFree outBuf
+            else pure Nothing
+
+
 -- | Serializes 'Signature' to Compact (64 byte) representation
 exportSignatureCompact :: Signature -> ByteString
 exportSignatureCompact (Signature fptr) = unsafePerformIO $ do

test/Crypto/Secp256k1Prop.hs

@@ -123,7 +123,8 @@ prop_signatureParseInvertsSerialize = property $ do
     let serialized = export sig
     annotateShow serialized
     annotateShow (BS.length serialized)
-    case importSignature serialized of
+    let parse = if exportDer then importSignatureDer else importSignatureCompact
+    case parse serialized of
         Nothing -> failure
         Just x -> x === sig
 
@@ -185,12 +186,12 @@ prop_ecdsaSignatureValidityPreservedOverSerialization = property $ do
     msg <- forAll $ bytes (singleton 32)
     sig <- maybe failure pure $ ecdsaSign sk msg
     useDer <- forAll enumBounded
-    let export =
+    let (serialize, parse) =
             if useDer
-                then exportSignatureDer
-                else exportSignatureCompact
-    let serialized = export sig
-    let parsed = fromJust (importSignature serialized)
+                then (exportSignatureDer, importSignatureDer)
+                else (exportSignatureCompact, importSignatureCompact)
+    let serialized = serialize sig
+    let parsed = fromJust (parse serialized)
     assert $ ecdsaVerify msg (derivePubKey sk) parsed
 
 

test/Crypto/Secp256k1Spec.hs

@@ -3,6 +3,7 @@ module Crypto.Secp256k1Spec (spec) where
 import Control.Monad.Par qualified as P
 import Crypto.Secp256k1
 import Crypto.Secp256k1.Internal
+import Data.ByteArray.Encoding (Base (Base16), convertFromBase)
 import Data.ByteString qualified as BS
 import Data.ByteString.Char8 qualified as B8
 import Data.Either (fromRight)
@@ -69,7 +70,7 @@ parSerializePubKeyTest ps = P.runPar $ do
 
 serializeSigTest :: (BS.ByteString, SecKey) -> Bool
 serializeSigTest (fm, fk) =
-    (fg >>= importSignature . exportSignatureDer) == fg && isJust fg
+    (fg >>= importSignatureDer . exportSignatureDer) == fg && isJust fg
     where
         fg = ecdsaSign fk fm
 
@@ -82,7 +83,7 @@ parSerializeSigTest ms = P.runPar $ do
 
 serializeCompactSigTest :: (BS.ByteString, SecKey) -> Bool
 serializeCompactSigTest (fm, fk) =
-    (fg >>= importSignature . exportSignatureCompact) == fg && isJust fg
+    (fg >>= importSignatureCompact . exportSignatureCompact) == fg && isJust fg
     where
         fg = ecdsaSign fk fm