secp256k1 0.2.0 → 0.3.0
raw patch · 6 files changed
+316/−346 lines, 6 filessetup-changed
Files
- Setup.hs +4/−4
- haskell/src/Crypto/Secp256k1.hs +77/−56
- haskell/src/Crypto/Secp256k1/Internal.hs +36/−47
- haskell/test/Crypto/Secp256k1/Internal/Tests.hs +184/−224
- haskell/test/Crypto/Secp256k1/Tests.hs +14/−14
- secp256k1.cabal +1/−1
Setup.hs view
@@ -1,7 +1,7 @@-import Distribution.PackageDescription-import Distribution.Simple-import Distribution.Simple.Setup-import Distribution.Simple.Utils+import Distribution.PackageDescription+import Distribution.Simple+import Distribution.Simple.Setup+import Distribution.Simple.Utils main :: IO () main = defaultMainWithHooks autoconfUserHooks
haskell/src/Crypto/Secp256k1.hs view
@@ -12,26 +12,50 @@ Depends on <https://github.com/bitcoin/secp256k1 secp256k1>. -} module Crypto.Secp256k1-( -- * Messages- Msg, msg, getMsg- -- * Secret Key-, SecKey, importSecKey, exportSecKey, pubKey- -- ** Raw Secret Key-, secKey, getSecKey- -- * Public Key-, PubKey, importPubKey, exportPubKey- -- * Signature-, Sig, CompactSig(..)-, importSig, laxImportSig, exportSig-, exportCompactSig, importCompactSig-, signMsg, verifySig, normalizeSig- -- * Addition & Multiplication-, Tweak, tweak, getTweak-, tweakAddSecKey, tweakMulSecKey-, tweakAddPubKey, tweakMulPubKey-, combinePubKeys-) where+ ( -- * Messages+ Msg+ , msg+ , getMsg + -- * Secret Keys+ , SecKey+ , secKey+ , getSecKey+ , derivePubKey+ -- ** BER+ , importSecKey+ , exportSecKey++ -- * Public Keys+ , PubKey+ , importPubKey+ , exportPubKey++ -- * Signatures+ , Sig+ , CompactSig(..)+ , signMsg+ , verifySig+ , normalizeSig+ -- ** DER+ , importSig+ , laxImportSig+ , exportSig+ -- ** Compact+ , exportCompactSig+ , importCompactSig++ -- * Addition & Multiplication+ , Tweak+ , tweak+ , getTweak+ , tweakAddSecKey+ , tweakMulSecKey+ , tweakAddPubKey+ , tweakMulPubKey+ , combinePubKeys+ ) where+ import Control.Applicative import Control.Monad import Crypto.Secp256k1.Internal@@ -177,10 +201,10 @@ fp <- mallocForeignPtr ret <- withForeignPtr fp $ \p -> do poke p (SecKey32 bs)- ec_seckey_verify ctx p+ ecSecKeyVerify ctx p if isSuccess ret then return $ Just $ SecKey fp- else return $ Nothing+ else return Nothing | otherwise = Nothing -- | Convert signature to a normalized lower-S form. Boolean value 'True'@@ -190,7 +214,7 @@ normalizeSig (Sig fg) = unsafePerformIO $ do fg' <- mallocForeignPtr ret <- withForeignPtr fg $ \pg -> withForeignPtr fg' $ \pg' ->- ecdsa_signature_normalize ctx pg' pg+ ecdsaSignatureNormalize ctx pg' pg return (Sig fg', isSuccess ret) -- | Create internal tweak data from 32-byte 'ByteString'.@@ -212,26 +236,25 @@ -- | Get 32-byte message. getMsg :: Msg -> ByteString-getMsg (Msg fm) = getMsg32 $ unsafePerformIO $ withForeignPtr fm $ peek+getMsg (Msg fm) = getMsg32 $ unsafePerformIO $ withForeignPtr fm peek -- | Get 32-byte tweak. getTweak :: Tweak -> ByteString-getTweak (Tweak ft) = getTweak32 $ unsafePerformIO $ withForeignPtr ft $ peek+getTweak (Tweak ft) = getTweak32 $ unsafePerformIO $ withForeignPtr ft peek -- | Read DER-encoded public key. importPubKey :: ByteString -> Maybe PubKey-importPubKey bs = unsafePerformIO $ do- useByteString bs $ \(b, l) -> do- fp <- mallocForeignPtr- ret <- withForeignPtr fp $ \p -> ec_pubkey_parse ctx p b l- if isSuccess ret then return $ Just $ PubKey fp else return Nothing+importPubKey bs = unsafePerformIO $ useByteString bs $ \(b, l) -> do+ fp <- mallocForeignPtr+ ret <- withForeignPtr fp $ \p -> ecPubKeyParse ctx p b l+ if isSuccess ret then return $ Just $ PubKey fp else return Nothing -- | Encode public key as DER. First argument 'True' for compressed output. exportPubKey :: Bool -> PubKey -> ByteString exportPubKey compress (PubKey pub) = unsafePerformIO $ withForeignPtr pub $ \p -> alloca $ \l -> allocaBytes z $ \o -> do poke l (fromIntegral z)- ret <- ec_pubkey_serialize ctx o l p c+ ret <- ecPubKeySerialize ctx o l p c unless (isSuccess ret) $ error "could not serialize public key" n <- peek l packByteString (o, n)@@ -243,7 +266,7 @@ exportCompactSig :: Sig -> CompactSig exportCompactSig (Sig fg) = unsafePerformIO $ withForeignPtr fg $ \pg -> alloca $ \pc -> do- ret <- ecdsa_signature_serialize_compact ctx pc pg+ ret <- ecdsaSignatureSerializeCompact ctx pc pg unless (isSuccess ret) $ error "Could not obtain compact signature" peek pc @@ -252,7 +275,7 @@ importCompactSig c = unsafePerformIO $ alloca $ \pc -> do poke pc c fg <- mallocForeignPtr- ret <- withForeignPtr fg $ \pg -> ecdsa_signature_parse_compact ctx pg pc+ ret <- withForeignPtr fg $ \pg -> ecdsaSignatureParseCompact ctx pg pc if isSuccess ret then return $ Just $ Sig fg else return Nothing -- | Read DER-encoded signature.@@ -260,7 +283,7 @@ importSig bs = unsafePerformIO $ useByteString bs $ \(b, l) -> do fg <- mallocForeignPtr- ret <- withForeignPtr fg $ \g -> ecdsa_signature_parse_der ctx g b l+ ret <- withForeignPtr fg $ \g -> ecdsaSignatureParseDer ctx g b l if isSuccess ret then return $ Just $ Sig fg else return Nothing -- | Relaxed DER parsing. Allows certain DER errors and violations.@@ -268,7 +291,7 @@ laxImportSig bs = unsafePerformIO $ useByteString bs $ \(b, l) -> do fg <- mallocForeignPtr- ret <- withForeignPtr fg $ \g -> lax_der_parse ctx g b l+ ret <- withForeignPtr fg $ \g -> laxDerParse ctx g b l if isSuccess ret then return $ Just $ Sig fg else return Nothing -- | Encode signature as DER.@@ -276,7 +299,7 @@ exportSig (Sig fg) = unsafePerformIO $ withForeignPtr fg $ \g -> alloca $ \l -> allocaBytes 72 $ \o -> do poke l 72- ret <- ecdsa_signature_serialize_der ctx o l g+ ret <- ecdsaSignatureSerializeDer ctx o l g unless (isSuccess ret) $ error "could not serialize signature" n <- peek l packByteString (o, n)@@ -285,32 +308,31 @@ verifySig :: PubKey -> Sig -> Msg -> Bool verifySig (PubKey fp) (Sig fg) (Msg fm) = unsafePerformIO $ withForeignPtr fp $ \p -> withForeignPtr fg $ \g ->- withForeignPtr fm $ \m -> isSuccess <$> ecdsa_verify ctx g m p+ withForeignPtr fm $ \m -> isSuccess <$> ecdsaVerify ctx g m p -- | Sign message using secret key. signMsg :: SecKey -> Msg -> Sig signMsg (SecKey fk) (Msg fm) = unsafePerformIO $ withForeignPtr fk $ \k -> withForeignPtr fm $ \m -> do fg <- mallocForeignPtr- ret <- withForeignPtr fg $ \g -> ecdsa_sign ctx g m k nullFunPtr nullPtr+ ret <- withForeignPtr fg $ \g -> ecdsaSign ctx g m k nullFunPtr nullPtr unless (isSuccess ret) $ error "could not sign message" return $ Sig fg -- | Obtain public key from secret key.-pubKey :: SecKey -> PubKey-pubKey (SecKey fk) = unsafePerformIO $- withForeignPtr fk $ \k -> do- fp <- mallocForeignPtr- ret <- withForeignPtr fp $ \p -> ec_pubkey_create ctx p k- unless (isSuccess ret) $ error "could not compute public key"- return $ PubKey fp+derivePubKey :: SecKey -> PubKey+derivePubKey (SecKey fk) = unsafePerformIO $ withForeignPtr fk $ \k -> do+ fp <- mallocForeignPtr+ ret <- withForeignPtr fp $ \p -> ecPubKeyCreate ctx p k+ unless (isSuccess ret) $ error "could not compute public key"+ return $ PubKey fp -- | Read BER-encoded secret key. importSecKey :: ByteString -> Maybe SecKey importSecKey bs = unsafePerformIO $ useByteString bs $ \(b, l) -> do fk <- mallocForeignPtr- ret <- withForeignPtr fk $ \k -> ec_privkey_import ctx k b l+ ret <- withForeignPtr fk $ \k -> ecSecKeyImport ctx k b l if isSuccess ret then return $ Just $ SecKey fk else return Nothing -- | Encode secret key as BER. First argument 'True' for compressed output.@@ -318,7 +340,7 @@ exportSecKey compress (SecKey fk) = unsafePerformIO $ withForeignPtr fk $ \k -> alloca $ \l -> allocaBytes 279 $ \o -> do poke l 279- ret <- ec_privkey_export ctx o l k c+ ret <- ecSecKeyExport ctx o l k c unless (isSuccess ret) $ error "could not export secret key" n <- peek l packByteString (o, n)@@ -333,7 +355,7 @@ ret <- withForeignPtr fk' $ \k' -> do key <- peek k poke k' key- ec_privkey_tweak_add ctx k' t+ ecSecKeyTweakAdd ctx k' t if isSuccess ret then return $ Just $ SecKey fk' else return Nothing -- | Multiply secret key by tweak using ECDSA multiplication.@@ -344,7 +366,7 @@ ret <- withForeignPtr fk' $ \k' -> do key <- peek k poke k' key- ec_privkey_tweak_mul ctx k' t+ ecSecKeyTweakMul ctx k' t if isSuccess ret then return $ Just $ SecKey fk' else return Nothing -- | Perform ECDSA addition between the public key point and the point obtained@@ -356,7 +378,7 @@ ret <- withForeignPtr fp' $ \p' -> do pub <- peek p poke p' pub- ec_pubkey_tweak_add ctx p' t+ ecPubKeyTweakAdd ctx p' t if isSuccess ret then return $ Just $ PubKey fp' else return Nothing -- | Perform ECDSA multiplication between the public key point and the point@@ -368,7 +390,7 @@ ret <- withForeignPtr fp' $ \p' -> do pub <- peek p poke p' pub- ec_pubkey_tweak_mul ctx p' t+ ecPubKeyTweakMul ctx p' t if isSuccess ret then return $ Just $ PubKey fp' else return Nothing -- | Add multiple public keys together using ECDSA addition.@@ -378,7 +400,7 @@ pokeArray a ps fp <- mallocForeignPtr ret <- withForeignPtr fp $ \p ->- ec_pubkey_combine ctx p a (fromIntegral $ length ps)+ ecPubKeyCombine ctx p a (fromIntegral $ length ps) if isSuccess ret then return $ Just $ PubKey fp else return Nothing@@ -391,18 +413,17 @@ arbitrary = gen_msg where valid_bs = bs_gen `suchThat` isJust- bs_gen = (msg . BS.pack) <$> sequence (replicate 32 arbitrary)+ bs_gen = (msg . BS.pack) <$> replicateM 32 arbitrary gen_msg = fromJust <$> valid_bs instance Arbitrary SecKey where- arbitrary = gen_key- where+ arbitrary = gen_key where valid_bs = bs_gen `suchThat` isJust- bs_gen = (secKey . BS.pack) <$> sequence (replicate 32 arbitrary)+ bs_gen = (secKey . BS.pack) <$> replicateM 32 arbitrary gen_key = fromJust <$> valid_bs instance Arbitrary PubKey where arbitrary = do key <- arbitrary- return $ pubKey key+ return $ derivePubKey key
haskell/src/Crypto/Secp256k1/Internal.hs view
@@ -12,7 +12,7 @@ module Crypto.Secp256k1.Internal where import Control.Monad-import Data.Binary (get, put)+import Data.Binary (Binary, get, put) import Data.Binary.Get (runGet) import Data.Binary.Put (runPut) import Data.ByteString (ByteString, packCStringLen)@@ -116,14 +116,15 @@ instance Storable CompactSig where sizeOf _ = 64 alignment _ = 1- peek p = do- bs <- unsafePackCStringLen (castPtr p, 64)- let LargeKey r s = runGet get (fromStrict bs)+ peek p = (runGet get . fromStrict) <$> unsafePackCStringLen (castPtr p, 64)+ poke p cs = useByteString bs $ \(b, _) -> copyArray (castPtr p) b 64 where+ bs = toStrict $ runPut $ put cs++instance Binary CompactSig where+ get = do+ LargeKey r s <- get return $ CompactSig r s- poke p (CompactSig r s) = useByteString bs $- \(b, _) -> copyArray (castPtr p) b 64- where- bs = toStrict $ runPut $ put (LargeKey r s)+ put (CompactSig r s) = put (LargeKey r s) instance Storable Msg32 where sizeOf _ = 32@@ -175,32 +176,32 @@ {-# NOINLINE ctx #-} ctx :: Ptr Ctx ctx = unsafePerformIO $ do- x <- context_create signVerify+ x <- contextCreate signVerify e <- getEntropy 32- ret <- alloca $ \s -> poke s (Seed32 e) >> context_randomize x s+ ret <- alloca $ \s -> poke s (Seed32 e) >> contextRandomize x s unless (isSuccess ret) $ error "failed to randomize context" return x foreign import ccall "secp256k1.h secp256k1_context_create"- context_create+ contextCreate :: CtxFlags -> IO (Ptr Ctx) foreign import ccall "secp256k1.h secp256k1_context_clone"- context_clone+ contextClone :: Ptr Ctx -> IO (Ptr Ctx) foreign import ccall "secp256k1.h &secp256k1_context_destroy"- context_destroy+ contextDestroy :: FunPtr (Ptr Ctx -> IO ()) foreign import ccall "secp256k1.h secp256k1_context_set_illegal_callback"- set_illegal_callback+ setIllegalCallback :: Ptr Ctx -> FunPtr (CString -> Ptr a -> IO ()) -- ^ message, data -> Ptr a -- ^ data@@ -208,7 +209,7 @@ foreign import ccall "secp256k1.h secp256k1_context_set_error_callback"- set_error_callback+ setErrorCallback :: Ptr Ctx -> FunPtr (CString -> Ptr a -> IO ()) -- ^ message, data -> Ptr a -- ^ data@@ -216,7 +217,7 @@ foreign import ccall "secp256k1.h secp256k1_ec_pubkey_parse"- ec_pubkey_parse+ ecPubKeyParse :: Ptr Ctx -> Ptr PubKey64 -> Ptr CUChar -- ^ encoded public key array@@ -225,7 +226,7 @@ foreign import ccall "secp256k1.h secp256k1_ec_pubkey_serialize"- ec_pubkey_serialize+ ecPubKeySerialize :: Ptr Ctx -> Ptr CUChar -- ^ array for encoded public key, must be large enough -> Ptr CSize -- ^ size of encoded public key, will be updated@@ -235,7 +236,7 @@ foreign import ccall "secp256k1.h secp256k1_ecdsa_signature_parse_compact"- ecdsa_signature_parse_compact+ ecdsaSignatureParseCompact :: Ptr Ctx -> Ptr Sig64 -> Ptr CompactSig@@ -244,7 +245,7 @@ foreign import ccall "secp256k1.h secp256k1_ecdsa_signature_parse_der"- ecdsa_signature_parse_der+ ecdsaSignatureParseDer :: Ptr Ctx -> Ptr Sig64 -> Ptr CUChar -- ^ encoded DER signature@@ -253,7 +254,7 @@ foreign import ccall "secp256k1.h secp256k1_ecdsa_signature_serialize_der"- ecdsa_signature_serialize_der+ ecdsaSignatureSerializeDer :: Ptr Ctx -> Ptr CUChar -- ^ array for encoded signature, must be large enough -> Ptr CSize -- ^ size of encoded signature, will be updated@@ -262,7 +263,7 @@ foreign import ccall "secp256k1.h secp256k1_ecdsa_signature_serialize_compact"- ecdsa_signature_serialize_compact+ ecdsaSignatureSerializeCompact :: Ptr Ctx -> Ptr CompactSig -> Ptr Sig64@@ -270,7 +271,7 @@ foreign import ccall "secp256k1.h secp256k1_ecdsa_verify"- ecdsa_verify+ ecdsaVerify :: Ptr Ctx -> Ptr Sig64 -> Ptr Msg32@@ -279,7 +280,7 @@ foreign import ccall "secp256k1.h secp256k1_ecdsa_signature_normalize"- ecdsa_signature_normalize+ ecdsaSignatureNormalize :: Ptr Ctx -> Ptr Sig64 -- | output -> Ptr Sig64 -- | input@@ -287,28 +288,16 @@ foreign import ccall "lax_der.h lax_der_parse"- lax_der_parse+ laxDerParse :: Ptr Ctx -> Ptr Sig64 -> Ptr CUChar -> CSize -> IO Ret --- TODO:--- foreign import ccall--- "secp256k1.h &secp256k1_nonce_function_rfc6979"--- nonce_function_rfc6979--- :: FunPtr (NonceFunction Seed32)------ TODO:--- foreign import ccall--- "secp256k1.h &secp256k1_nonce_function_default"--- nonce_function_default--- :: FunPtr (NonceFunction Seed32)- foreign import ccall "secp256k1.h secp256k1_ecdsa_sign"- ecdsa_sign+ ecdsaSign :: Ptr Ctx -> Ptr Sig64 -> Ptr Msg32@@ -319,14 +308,14 @@ foreign import ccall "secp256k1.h secp256k1_ec_seckey_verify"- ec_seckey_verify+ ecSecKeyVerify :: Ptr Ctx -> Ptr SecKey32 -> IO Ret foreign import ccall "secp256k1.h secp256k1_ec_pubkey_create"- ec_pubkey_create+ ecPubKeyCreate :: Ptr Ctx -> Ptr PubKey64 -> Ptr SecKey32@@ -334,7 +323,7 @@ foreign import ccall "secp256k1.h secp256k1_ec_privkey_export"- ec_privkey_export+ ecSecKeyExport :: Ptr Ctx -> Ptr CUChar -- ^ array to store BER-encoded key (allocate 279 bytes) -> Ptr CSize -- ^ size of previous array, will be updated@@ -344,7 +333,7 @@ foreign import ccall "secp256k1.h secp256k1_ec_privkey_import"- ec_privkey_import+ ecSecKeyImport :: Ptr Ctx -> Ptr SecKey32 -> Ptr CUChar -- ^ BER-encoded private key@@ -353,7 +342,7 @@ foreign import ccall "secp256k1.h secp256k1_ec_privkey_tweak_add"- ec_privkey_tweak_add+ ecSecKeyTweakAdd :: Ptr Ctx -> Ptr SecKey32 -> Ptr Tweak32@@ -361,7 +350,7 @@ foreign import ccall "secp256k1.h secp256k1_ec_pubkey_tweak_add"- ec_pubkey_tweak_add+ ecPubKeyTweakAdd :: Ptr Ctx -> Ptr PubKey64 -> Ptr Tweak32@@ -369,7 +358,7 @@ foreign import ccall "secp256k1.h secp256k1_ec_privkey_tweak_mul"- ec_privkey_tweak_mul+ ecSecKeyTweakMul :: Ptr Ctx -> Ptr SecKey32 -> Ptr Tweak32@@ -377,7 +366,7 @@ foreign import ccall "secp256k1.h secp256k1_ec_pubkey_tweak_mul"- ec_pubkey_tweak_mul+ ecPubKeyTweakMul :: Ptr Ctx -> Ptr PubKey64 -> Ptr Tweak32@@ -385,14 +374,14 @@ foreign import ccall "secp256k1.h secp256k1_context_randomize"- context_randomize+ contextRandomize :: Ptr Ctx -> Ptr Seed32 -> IO Ret foreign import ccall "secp256k1.h secp256k1_ec_pubkey_combine"- ec_pubkey_combine+ ecPubKeyCombine :: Ptr Ctx -> Ptr PubKey64 -- ^ pointer to public key storage -> Ptr (Ptr PubKey64) -- ^ pointer to array of public keys
haskell/test/Crypto/Secp256k1/Internal/Tests.hs view
@@ -4,7 +4,7 @@ import Control.Monad import Control.Monad.Trans import Crypto.Secp256k1.Internal-import Data.ByteString (packCStringLen,+import Data.ByteString (ByteString, packCStringLen, useAsCStringLen) import qualified Data.ByteString.Base16 as B16 import Foreign@@ -17,91 +17,87 @@ tests :: [Test] tests = [ testGroup "Housekeeping"- [ testCase "Create context" create_context_test- , testCase "Randomize context" randomize_context_test- , testCase "Clone context" clone_context_test- -- TODO:- -- , testCase "Set illegal callback" set_illegal_callback_test- -- TODO:- -- , testCase "Set error callback" set_error_callback_test+ [ testCase "Create context" createContextTest+ , testCase "Randomize context" randomizeContextTest+ , testCase "Clone context" cloneContextTest ] , testGroup "Serialization"- [ testCase "Parse public key" ec_pubkey_parse_test- , testCase "Serialize public key" ec_pubkey_serialize_test- , testCase "Storable public key" pubkey_storable_test- , testCase "Storable signature" signature_storable_test- , testCase "Parse DER signature" ecdsa_signature_parse_der_test- , testCase "Lax parse DER signature" lax_der_parse_test- , testCase "Serialize DER signature" ecdsa_signature_serialize_der_test+ [ testCase "Parse public key" ecPubkeyParseTest+ , testCase "Serialize public key" ecPubKeySerializeTest+ , testCase "Storable public key" pubkeyStorableTest+ , testCase "Storable signature" signatureStorableTest+ , testCase "Parse DER signature" ecdsaSignatureParseDerTest+ , testCase "Lax parse DER signature" laxDerParseTest+ , testCase "Serialize DER signature" ecdsaSignatureSerializeDerTest ] , testGroup "Signatures"- [ testCase "ECDSA verify" ecdsa_verify_test+ [ testCase "ECDSA verify" ecdsaVerifyTest -- TODO: -- , testCase "RFC6979 nonce function" nonce_function_rfc6979_test- , testCase "ECDSA sign" ecdsa_sign_test+ , testCase "ECDSA sign" ecdsaSignTest ] , testGroup "Secret keys"- [ testCase "Verify secret key" ec_seckey_verify_test- , testCase "Create public key" ec_pubkey_create_test- , testCase "Serialize BER secret key" ec_privkey_export_test- , testCase "Import BER secret key" ec_privkey_import_test- , testCase "Tweak add secret key" ec_privkey_tweak_add_test- , testCase "Tweak mult. secret key" ec_privkey_tweak_mul_test+ [ testCase "Verify secret key" ecSecKeyVerifyTest+ , testCase "Create public key" ecPubkeyCreateTest+ , testCase "Serialize BER secret key" ecSecKeyExportTest+ , testCase "Import BER secret key" ecSecKeyImportTest+ , testCase "Tweak add secret key" ecSecKeyTweakAddTest+ , testCase "Tweak mult. secret key" ecSecKeyTweakMulTest ] , testGroup "Public keys"- [ testCase "Tweak add public key" ec_pubkey_tweak_add_test- , testCase "Tweak mult. public key" ec_pubkey_tweak_mul_test- , testCase "Combine public keys" ec_pubkey_combine_test+ [ testCase "Tweak add public key" ecPubKeyTweakAddTest+ , testCase "Tweak mult. public key" ecPubKeyTweakMulTest+ , testCase "Combine public keys" ecPubKeyCombineTest ] ] withEntropy :: (Ptr Seed32 -> IO a) -> IO a withEntropy f = getEntropy 32 >>= \e -> alloca $ \s -> poke s (Seed32 e) >> f s -create_context_test :: Assertion-create_context_test = do- context_ptr <- liftIO $ context_create signVerify+createContextTest :: Assertion+createContextTest = do+ context_ptr <- liftIO $ contextCreate signVerify assertBool "context not null" $ context_ptr /= nullPtr -randomize_context_test :: Assertion-randomize_context_test = do- ret <- liftIO $ context_create sign >>= \x ->- withEntropy (context_randomize x)+randomizeContextTest :: Assertion+randomizeContextTest = do+ ret <- liftIO $ contextCreate sign >>= \x ->+ withEntropy (contextRandomize x) assertBool "context randomized" $ isSuccess ret -clone_context_test :: Assertion-clone_context_test = do+cloneContextTest :: Assertion+cloneContextTest = do (x1, x2) <- liftIO $ do- x1 <- context_create signVerify- ret <- withEntropy $ context_randomize x1+ x1 <- contextCreate signVerify+ ret <- withEntropy $ contextRandomize x1 unless (isSuccess ret) $ error "failed to randomize context"- x2 <- context_clone(x1)+ x2 <- contextClone x1 return (x1, x2) assertBool "original context not null" $ x1 /= nullPtr assertBool "cloned context not null" $ x2 /= nullPtr assertBool "context ptrs different" $ x1 /= x2 -ec_pubkey_parse_test :: Assertion-ec_pubkey_parse_test = do+ecPubkeyParseTest :: Assertion+ecPubkeyParseTest = do ret <- liftIO $ useAsCStringLen der $ \(i, il) -> do- x <- context_create verify+ x <- contextCreate verify alloca $ \pubkey ->- ec_pubkey_parse x pubkey (castPtr i) (fromIntegral il)+ ecPubKeyParse x pubkey (castPtr i) (fromIntegral il) assertBool "parsed public key" (isSuccess ret) where der = fst $ B16.decode "03dded4203dac96a7e85f2c374a37ce3e9c9a155a72b64b4551b0bfe779dd44705" -ec_pubkey_serialize_test :: Assertion-ec_pubkey_serialize_test = do+ecPubKeySerializeTest :: Assertion+ecPubKeySerializeTest = do (ret, dec) <- liftIO $ useAsCStringLen der $ \(i, il) -> alloca $ \k -> alloca $ \ol -> allocaBytes 72 $ \o -> do poke ol 72- x <- context_create verify+ x <- contextCreate verify ret1 <-- ec_pubkey_parse x k (castPtr i) (fromIntegral il)+ ecPubKeyParse x k (castPtr i) (fromIntegral il) unless (isSuccess ret1) $ error "failed to parse pubkey"- ret2 <- ec_pubkey_serialize+ ret2 <- ecPubKeySerialize x o ol k compressed len <- fromIntegral <$> peek ol decoded <- packCStringLen (castPtr o, len)@@ -112,20 +108,20 @@ der = fst $ B16.decode "03dded4203dac96a7e85f2c374a37ce3e9c9a155a72b64b4551b0bfe779dd44705" -pubkey_storable_test :: Assertion-pubkey_storable_test = do+pubkeyStorableTest :: Assertion+pubkeyStorableTest = do (pk1, pk2, dec) <- liftIO $ useAsCStringLen der $ \(i, il) -> do- x <- context_create verify+ x <- contextCreate verify pk1 <- alloca $ \pk -> do ret <-- ec_pubkey_parse x pk (castPtr i) (fromIntegral il)+ ecPubKeyParse x pk (castPtr i) (fromIntegral il) unless (isSuccess ret) $ error "failed to parse pubkey" peek pk (pk2, dec) <- alloca $ \pk -> alloca $ \ol -> allocaBytes 72 $ \o -> do poke ol 72 poke pk pk1 ret <-- ec_pubkey_serialize x o ol pk compressed+ ecPubKeySerialize x o ol pk compressed unless (isSuccess ret) $ error "failed to serialize pubkey" len <- fromIntegral <$> peek ol dec <- packCStringLen (castPtr o, len)@@ -138,18 +134,18 @@ der = fst $ B16.decode "03dded4203dac96a7e85f2c374a37ce3e9c9a155a72b64b4551b0bfe779dd44705" -signature_storable_test :: Assertion-signature_storable_test = do+signatureStorableTest :: Assertion+signatureStorableTest = do (sig, ret) <- liftIO $ do- x <- context_create verify+ x <- contextCreate verify g <- alloca $ \pc -> alloca $ \pg -> do poke pc cpt- ret <- ecdsa_signature_parse_compact x pg (castPtr pc)+ ret <- ecdsaSignatureParseCompact x pg (castPtr pc) unless (isSuccess ret) $ error "failed to parse signature" peek pg alloca $ \pc -> alloca $ \pg -> do poke pg g- ret <- ecdsa_signature_serialize_compact x pc pg+ ret <- ecdsaSignatureSerializeCompact x pc pg c <- peek pc return (c, ret) assertBool "successful serialization" (isSuccess ret)@@ -159,111 +155,92 @@ 0xf502bfa07af43e7ef265618b0d929a7619ee01d6150e37eb6eaaf2c8bd37fb22 0x6f0415ab0e9a977afd78b2c26ef39b3952096d319fd4b101c768ad6c132e3045 -ecdsa_signature_parse_der_test :: Assertion-ecdsa_signature_parse_der_test = do+ecdsaSignatureParseDerTest :: Assertion+ecdsaSignatureParseDerTest = do ret <- liftIO $ useAsCStringLen der $ \(d, dl) -> alloca $ \s -> do- x <- context_create verify- ecdsa_signature_parse_der x s (castPtr d) (fromIntegral dl)+ x <- contextCreate verify+ ecdsaSignatureParseDer x s (castPtr d) (fromIntegral dl) assertBool "parsed signature successfully" $ isSuccess ret where- der = fst $ B16.decode $+ der = fst $ B16.decode "3045022100f502bfa07af43e7ef265618b0d929a7619ee01d6150e37eb6eaaf2c8bd37\ \fb2202206f0415ab0e9a977afd78b2c26ef39b3952096d319fd4b101c768ad6c132e30\ \45" -lax_der_parse_test :: Assertion-lax_der_parse_test = do+laxDerParseTest :: Assertion+laxDerParseTest = do ret <- liftIO $ useAsCStringLen der $ \(d, dl) -> alloca $ \s -> do- x <- context_create verify- lax_der_parse x s (castPtr d) (fromIntegral dl)+ x <- contextCreate verify+ laxDerParse x s (castPtr d) (fromIntegral dl) assertBool "parsed signature successfully" $ isSuccess ret where- der = fst $ B16.decode $+ der = fst $ B16.decode "30450220f502bfa07af43e7ef265618b0d929a7619ee01d6150e37eb6eaaf2c8bd37fb\ \2202206f0415ab0e9a977afd78b2c26ef39b3952096d319fd4b101c768ad6c132e3045" -ecdsa_signature_serialize_der_test :: Assertion-ecdsa_signature_serialize_der_test = do+parseDer :: Ptr Ctx -> ByteString -> IO Sig64+parseDer x bs = useAsCStringLen bs $ \(d, dl) -> alloca $ \s -> do+ ret <- ecdsaSignatureParseDer x s (castPtr d) (fromIntegral dl)+ unless (isSuccess ret) $ error "could not parse DER"+ peek s++ecdsaSignatureSerializeDerTest :: Assertion+ecdsaSignatureSerializeDerTest = do (ret, enc) <- liftIO $ do- x <- context_create verify- sig <- useAsCStringLen der $ \(d, dl) -> alloca $ \s -> do- ret <-- ecdsa_signature_parse_der x s (castPtr d) (fromIntegral dl)- unless (isSuccess ret) $ error "could not parse DER"- peek s+ x <- contextCreate verify+ sig <- parseDer x der alloca $ \s -> alloca $ \ol -> allocaBytes 72 $ \o -> do poke ol 72 poke s sig ret <-- ecdsa_signature_serialize_der x o ol s+ ecdsaSignatureSerializeDer x o ol s len <- fromIntegral <$> peek ol enc <- packCStringLen (castPtr o, len) return (ret, enc) assertBool "serialization successful" $ isSuccess ret assertEqual "signatures match" der enc where- der = fst $ B16.decode $+ der = fst $ B16.decode "3045022100f502bfa07af43e7ef265618b0d929a7619ee01d6150e37eb6eaaf2c8bd37\ \fb2202206f0415ab0e9a977afd78b2c26ef39b3952096d319fd4b101c768ad6c132e30\ \45" -ecdsa_verify_test :: Assertion-ecdsa_verify_test = do+ecdsaVerifyTest :: Assertion+ecdsaVerifyTest = do ret <- liftIO $ do- x <- context_create verify- sig <- useAsCStringLen der $ \(d, dl) -> alloca $ \s -> do- ret <-- ecdsa_signature_parse_der x s (castPtr d) (fromIntegral dl)- unless (isSuccess ret) $ error "could not parse DER"- peek s+ x <- contextCreate verify+ sig <- parseDer x der pk <- useAsCStringLen pub $ \(p, pl) -> alloca $ \k -> do ret <-- ec_pubkey_parse x k (castPtr p) (fromIntegral pl)+ ecPubKeyParse x k (castPtr p) (fromIntegral pl) unless (isSuccess ret) $ error "could not parse public key" peek k alloca $ \m -> alloca $ \k -> alloca $ \s -> do poke m msg poke k pk poke s sig- ecdsa_verify x s m k+ ecdsaVerify x s m k assertBool "signature valid" $ isSuccess ret where- der = fst $ B16.decode $+ der = fst $ B16.decode "3045022100f502bfa07af43e7ef265618b0d929a7619ee01d6150e37eb6eaaf2c8bd37\ \fb2202206f0415ab0e9a977afd78b2c26ef39b3952096d319fd4b101c768ad6c132e30\ \45"- pub = fst $ B16.decode $+ pub = fst $ B16.decode "04dded4203dac96a7e85f2c374a37ce3e9c9a155a72b64b4551b0bfe779dd447051221\ \3d5ed790522c042dee8e85c4c0ec5f96800b72bc5940c8bc1c5e11e4fcbf"- msg = Msg32 $ fst $ B16.decode $+ msg = Msg32 $ fst $ B16.decode "f5cbe7d88182a4b8e400f96b06128921864a18187d114c8ae8541b566c8ace00" --- TODO:--- nonce_function_rfc6979_test :: Assertion--- nonce_function_rfc6979_test = do--- (ret, nonce) <- alloca $ \n -> alloca $ \m -> alloca $ \k -> do--- poke m msg--- poke k key--- let ret = mkNonceFunction--- nonce_function_rfc6979 n m k nullPtr nullPtr 0--- nonce <- peek n--- return (ret, nonce)--- assertBool "nonce calculated" $ isSuccess ret--- assertEqual "nonce correct" expected nonce--- where--- msg = Msg32 $ fst $ B16.decode $--- "f5cbe7d88182a4b8e400f96b06128921864a18187d114c8ae8541b566c8ace00"--- key = SecKey32 $ fst $ B16.decode $--- "f65255094d7773ed8dd417badc9fc045c1f80fdc5b2d25172b031ce6933e039a"--- expected = Nonce $ fst $ B16.decode $--- "8f30c2bf5a3e1199b19a6703fa578376e5225d6ecfc7ecf817aa8b8b16203d64"+signCtx :: IO (Ptr Ctx)+signCtx = contextCreate sign >>= \c ->+ withEntropy (contextRandomize c) >>= \r ->+ unless (isSuccess r) (error "failed to randomize context") >> return c -ecdsa_sign_test :: Assertion-ecdsa_sign_test = do+ecdsaSignTest :: Assertion+ecdsaSignTest = do (ret, sig) <- liftIO $ do- x <- context_create sign- retr <- withEntropy $ context_randomize x- unless (isSuccess retr) $ error "failed to randomize context"+ x <- signCtx alloca $ \s -> alloca $ \m -> alloca $ \k -> alloca $ \ol -> allocaBytes 72 $ \o -> do poke ol 72@@ -271,9 +248,9 @@ poke k key ret1 <- -- TODO:- -- ecdsa_sign x s m k nonce_function_default nullPtr- ecdsa_sign x s m k nullFunPtr nullPtr- ret2 <- ecdsa_signature_serialize_der x o ol s+ -- ecdsaSign x s m k nonce_function_default nullPtr+ ecdsaSign x s m k nullFunPtr nullPtr+ ret2 <- ecdsaSignatureSerializeDer x o ol s unless (isSuccess ret2) $error "could not serialize signature" len <- peek ol sig <- packCStringLen (castPtr o, fromIntegral len)@@ -281,39 +258,35 @@ assertBool "successful signing" $ isSuccess ret assertEqual "signature matches" sig der where- msg = Msg32 $ fst $ B16.decode $+ msg = Msg32 $ fst $ B16.decode "f5cbe7d88182a4b8e400f96b06128921864a18187d114c8ae8541b566c8ace00"- key = SecKey32 $ fst $ B16.decode $+ key = SecKey32 $ fst $ B16.decode "f65255094d7773ed8dd417badc9fc045c1f80fdc5b2d25172b031ce6933e039a"- der = fst $ B16.decode $+ der = fst $ B16.decode "3045022100f502bfa07af43e7ef265618b0d929a7619ee01d6150e37eb6eaaf2c8bd37\ \fb2202206f0415ab0e9a977afd78b2c26ef39b3952096d319fd4b101c768ad6c132e30\ \45" -ec_seckey_verify_test :: Assertion-ec_seckey_verify_test = do+ecSecKeyVerifyTest :: Assertion+ecSecKeyVerifyTest = do ret <- liftIO $ alloca $ \k -> do poke k key- x <- context_create sign- retr <- withEntropy $ context_randomize x- unless (isSuccess retr) $ error "failed to randomize context"- ec_seckey_verify x k+ x <- signCtx+ ecSecKeyVerify x k assertBool "valid secret key" $ isSuccess ret where- key = SecKey32 $ fst $ B16.decode $+ key = SecKey32 $ fst $ B16.decode "f65255094d7773ed8dd417badc9fc045c1f80fdc5b2d25172b031ce6933e039a" -ec_pubkey_create_test :: Assertion-ec_pubkey_create_test = do+ecPubkeyCreateTest :: Assertion+ecPubkeyCreateTest = do (ret, pk) <- liftIO $ alloca $ \p -> alloca $ \k -> do poke k key- x <- context_create sign- retr <- withEntropy $ context_randomize x- unless (isSuccess retr) $ error "failed to randomize context"- ret <- ec_pubkey_create x p k+ x <- signCtx+ ret <- ecPubKeyCreate x p k allocaBytes 65 $ \o -> alloca $ \ol -> do poke ol 65- rets <- ec_pubkey_serialize+ rets <- ecPubKeySerialize x o ol p uncompressed unless (isSuccess rets) $ error "failed to serialive public key" len <- fromIntegral <$> peek ol@@ -322,187 +295,174 @@ assertBool "successful pubkey creation" $ isSuccess ret assertEqual "public key matches" pub pk where- key = SecKey32 $ fst $ B16.decode $+ key = SecKey32 $ fst $ B16.decode "f65255094d7773ed8dd417badc9fc045c1f80fdc5b2d25172b031ce6933e039a"- pub = fst $ B16.decode $+ pub = fst $ B16.decode "04dded4203dac96a7e85f2c374a37ce3e9c9a155a72b64b4551b0bfe779dd447051221\ \3d5ed790522c042dee8e85c4c0ec5f96800b72bc5940c8bc1c5e11e4fcbf" -ec_privkey_export_test :: Assertion-ec_privkey_export_test = do+ecSecKeyExportTest :: Assertion+ecSecKeyExportTest = do ret <- liftIO $ alloca $ \k -> allocaBytes 279 $ \o -> alloca $ \ol -> do poke ol 279 poke k key- x <- context_create sign- retr <- withEntropy $ context_randomize x- unless (isSuccess retr) $ error "failed to randomize context"- ec_privkey_export x o ol k uncompressed+ x <- signCtx+ ecSecKeyExport x o ol k uncompressed assertBool "successful secret key BER serialization" $ isSuccess ret where- key = SecKey32 $ fst $ B16.decode $+ key = SecKey32 $ fst $ B16.decode "f65255094d7773ed8dd417badc9fc045c1f80fdc5b2d25172b031ce6933e039a" -ec_privkey_import_test :: Assertion-ec_privkey_import_test = do+ecSecKeyImportTest :: Assertion+ecSecKeyImportTest = do (ret, dec) <- liftIO $ do- x <- context_create sign- retr <- withEntropy $ context_randomize x- unless (isSuccess retr) $ error "failed to randomize context"+ x <- signCtx ber <- allocaBytes 279 $ \o -> alloca $ \ol -> alloca $ \k -> do poke ol 279 poke k key- rets <- ec_privkey_export x o ol k uncompressed+ rets <- ecSecKeyExport x o ol k uncompressed unless (isSuccess rets) $ error "failed to serialize key" len <- fromIntegral <$> peek ol packCStringLen (castPtr o, len) useAsCStringLen ber $ \(b, bl) -> alloca $ \k -> do- ret <- ec_privkey_import x k (castPtr b) (fromIntegral bl)+ ret <- ecSecKeyImport x k (castPtr b) (fromIntegral bl) dec <- peek k return (ret, dec) assertBool "successful secret key BER deserialization" $ isSuccess ret assertEqual "keys match" key dec where- key = SecKey32 $ fst $ B16.decode $+ key = SecKey32 $ fst $ B16.decode "f65255094d7773ed8dd417badc9fc045c1f80fdc5b2d25172b031ce6933e039a" -ec_privkey_tweak_add_test :: Assertion-ec_privkey_tweak_add_test = do+ecSecKeyTweakAddTest :: Assertion+ecSecKeyTweakAddTest = do (ret, tweaked) <- liftIO $ do- x <- context_create sign- retr <- withEntropy $ context_randomize x- unless (isSuccess retr) $ error "failed to randomize context"+ x <- signCtx alloca $ \w -> alloca $ \k -> do poke w tweak poke k key- ret <- ec_privkey_tweak_add x k w+ ret <- ecSecKeyTweakAdd x k w tweaked <- peek k return (ret, tweaked) assertBool "successful secret key tweak" $ isSuccess ret assertEqual "tweaked keys match" expected tweaked where- key = SecKey32 $ fst $ B16.decode $+ key = SecKey32 $ fst $ B16.decode "f65255094d7773ed8dd417badc9fc045c1f80fdc5b2d25172b031ce6933e039a"- tweak = Tweak32 $ fst $ B16.decode $+ tweak = Tweak32 $ fst $ B16.decode "f5cbe7d88182a4b8e400f96b06128921864a18187d114c8ae8541b566c8ace00"- expected = SecKey32 $ fst $ B16.decode $+ expected = SecKey32 $ fst $ B16.decode "ec1e3ce1cefa18a671d51125e2b249688d934b0e28f5d1665384d9b02f929059" -ec_privkey_tweak_mul_test :: Assertion-ec_privkey_tweak_mul_test = do+ecSecKeyTweakMulTest :: Assertion+ecSecKeyTweakMulTest = do (ret, tweaked) <- liftIO $ do- x <- context_create sign- retr <- withEntropy $ context_randomize x+ x <- contextCreate sign+ retr <- withEntropy $ contextRandomize x unless (isSuccess retr) $ error "failed to randomize context" alloca $ \w -> alloca $ \k -> do poke w tweak poke k key- ret <- ec_privkey_tweak_mul x k w+ ret <- ecSecKeyTweakMul x k w tweaked <- peek k return (ret, tweaked) assertBool "successful secret key tweak" $ isSuccess ret assertEqual "tweaked keys match" expected tweaked where- key = SecKey32 $ fst $ B16.decode $+ key = SecKey32 $ fst $ B16.decode "f65255094d7773ed8dd417badc9fc045c1f80fdc5b2d25172b031ce6933e039a"- tweak = Tweak32 $ fst $ B16.decode $+ tweak = Tweak32 $ fst $ B16.decode "f5cbe7d88182a4b8e400f96b06128921864a18187d114c8ae8541b566c8ace00"- expected = SecKey32 $ fst $ B16.decode $+ expected = SecKey32 $ fst $ B16.decode "a96f5962493acb179f60a86a9785fc7a30e0c39b64c09d24fe064d9aef15e4c0" -ec_pubkey_tweak_add_test :: Assertion-ec_pubkey_tweak_add_test = do+serializeKey :: Ptr Ctx -> Ptr PubKey64 -> IO ByteString+serializeKey x p = allocaBytes 72 $ \d -> alloca $ \dl -> do+ ret <- ecPubKeySerialize x d dl p uncompressed+ unless (isSuccess ret) $ error "could not serialize public key"+ len <- peek dl+ packCStringLen (castPtr d, fromIntegral len)++parseKey :: Ptr Ctx -> ByteString -> IO PubKey64+parseKey x bs = alloca $ \p -> useAsCStringLen bs $ \(d, dl) -> do+ ret <- ecPubKeyParse x p (castPtr d) (fromIntegral dl)+ unless (isSuccess ret) $ error "could not parse public key"+ peek p++ecPubKeyTweakAddTest :: Assertion+ecPubKeyTweakAddTest = do (ret, tweaked) <- liftIO $ do- x <- context_create verify- pk <- alloca $ \p -> useAsCStringLen pub $ \(d, dl) -> do- ret <- ec_pubkey_parse x p (castPtr d) (fromIntegral dl)- unless (isSuccess ret) $ error "could not parse public key"- peek p- alloca $ \w -> alloca $ \p -> allocaBytes 72 $ \d -> alloca $ \dl -> do+ x <- contextCreate verify+ pk <- parseKey x pub+ alloca $ \w -> alloca $ \p -> do poke w tweak poke p pk- poke dl 72- ret <- ec_pubkey_tweak_add x p w- rets <- ec_pubkey_serialize x d dl p uncompressed- unless (isSuccess rets) $ error "could not serialize public key"- len <- peek dl- tweaked <- packCStringLen (castPtr d, fromIntegral len)+ ret <- ecPubKeyTweakAdd x p w+ tweaked <- serializeKey x p return (ret, tweaked) assertBool "successful secret key tweak" $ isSuccess ret assertEqual "tweaked keys match" expected tweaked where- pub = fst $ B16.decode $+ pub = fst $ B16.decode "04dded4203dac96a7e85f2c374a37ce3e9c9a155a72b64b4551b0bfe779dd447051221\ \3d5ed790522c042dee8e85c4c0ec5f96800b72bc5940c8bc1c5e11e4fcbf"- tweak = Tweak32 $ fst $ B16.decode $+ tweak = Tweak32 $ fst $ B16.decode "f5cbe7d88182a4b8e400f96b06128921864a18187d114c8ae8541b566c8ace00"- expected = fst $ B16.decode $+ expected = fst $ B16.decode "04441c3982b97576646e0df0c96736063df6b42f2ee566d13b9f6424302d1379e518fd\ \c87a14c5435bff7a5db4552042cb4120c6b86a4bbd3d0643f3c14ad01368" -ec_pubkey_tweak_mul_test :: Assertion-ec_pubkey_tweak_mul_test = do+ecPubKeyTweakMulTest :: Assertion+ecPubKeyTweakMulTest = do (ret, tweaked) <- liftIO $ do- x <- context_create verify- pk <- alloca $ \p -> useAsCStringLen pub $ \(d, dl) -> do- ret <- ec_pubkey_parse x p (castPtr d) (fromIntegral dl)- unless (isSuccess ret) $ error "could not parse public key"- peek p- alloca $ \w -> alloca $ \p -> allocaBytes 72 $ \d -> alloca $ \dl -> do+ x <- contextCreate verify+ pk <- parseKey x pub+ alloca $ \w -> alloca $ \p -> do poke w tweak poke p pk- poke dl 72- ret <- ec_pubkey_tweak_mul x p w- rets <- ec_pubkey_serialize x d dl p uncompressed- unless (isSuccess rets) $ error "could not serialize public key"- len <- peek dl- tweaked <- packCStringLen (castPtr d, fromIntegral len)+ ret <- ecPubKeyTweakMul x p w+ tweaked <- serializeKey x p return (ret, tweaked) assertBool "successful secret key tweak" $ isSuccess ret assertEqual "tweaked keys match" expected tweaked where- pub = fst $ B16.decode $+ pub = fst $ B16.decode "04dded4203dac96a7e85f2c374a37ce3e9c9a155a72b64b4551b0bfe779dd447051221\ \3d5ed790522c042dee8e85c4c0ec5f96800b72bc5940c8bc1c5e11e4fcbf"- tweak = Tweak32 $ fst $ B16.decode $+ tweak = Tweak32 $ fst $ B16.decode "f5cbe7d88182a4b8e400f96b06128921864a18187d114c8ae8541b566c8ace00"- expected = fst $ B16.decode $+ expected = fst $ B16.decode "04f379dc99cdf5c83e433defa267fbb3377d61d6b779c06a0e4ce29ae3ff5353b12ae4\ \9c9d07e7368f2ba5a446c203255ce912322991a2d6a9d5d5761c61ed1845" -ec_pubkey_combine_test :: Assertion-ec_pubkey_combine_test = do+ecPubKeyCombineTest :: Assertion+ecPubKeyCombineTest = do (ret, com) <- liftIO $ alloca $ \p1 -> alloca $ \p2 -> alloca $ \p3 ->- allocaBytes 72 $ \d -> alloca $ \dl -> allocaArray 3 $ \a ->- alloca $ \p -> do- x <- context_create verify- parse x pub1 p1- parse x pub2 p2- parse x pub3 p3- pokeArray a [p1, p2, p3]- poke dl 72- ret <- ec_pubkey_combine x p a 3- rets <- ec_pubkey_serialize- x d dl p uncompressed- unless (isSuccess rets) $ error "could not serialize public key"- len <- peek dl- com <- packCStringLen (castPtr d, fromIntegral len)- return (ret, com)+ allocaArray 3 $ \a -> alloca $ \p -> do+ x <- contextCreate verify+ parse x pub1 p1+ parse x pub2 p2+ parse x pub3 p3+ pokeArray a [p1, p2, p3]+ ret <- ecPubKeyCombine x p a 3+ com <- serializeKey x p+ return (ret, com) assertBool "successful key combination" $ isSuccess ret assertEqual "combined keys match" expected com where parse x pub p = useAsCStringLen pub $ \(d, dl) -> do- ret <- ec_pubkey_parse x p (castPtr d) (fromIntegral dl)+ ret <- ecPubKeyParse x p (castPtr d) (fromIntegral dl) unless (isSuccess ret) $ error "could not parse public key"- pub1 = fst $ B16.decode $+ pub1 = fst $ B16.decode "04dded4203dac96a7e85f2c374a37ce3e9c9a155a72b64b4551b0bfe779dd447051221\ \3d5ed790522c042dee8e85c4c0ec5f96800b72bc5940c8bc1c5e11e4fcbf"- pub2 = fst $ B16.decode $+ pub2 = fst $ B16.decode "0487d82042d93447008dfe2af762068a1e53ff394a5bf8f68a045fa642b99ea5d153f5\ \77dd2dba6c7ae4cfd7b6622409d7edd2d76dd13a8092cd3af97b77bd2c77"- pub3 = fst $ B16.decode $+ pub3 = fst $ B16.decode "049b101edcbe1ee37ff6b2318526a425b629e823d7d8d9154417880595a28000ee3feb\ \d908754b8ce4e491aa6fe488b41fb5d4bb3788e33c9ff95a7a9229166d59"- expected = fst $ B16.decode $+ expected = fst $ B16.decode "043d9a7ec70011efc23c33a7e62d2ea73cca87797e3b659d93bea6aa871aebde56c3bc\ \6134ca82e324b0ab9c0e601a6d2933afe7fb5d9f3aae900f5c5dc6e362c8"
haskell/test/Crypto/Secp256k1/Tests.hs view
@@ -33,7 +33,7 @@ signMsgTest :: (Msg, SecKey) -> Bool signMsgTest (fm, fk) = verifySig fp fg fm where- fp = pubKey fk+ fp = derivePubKey fk fg = signMsg fk fm badSignatureTest :: (Msg, SecKey, PubKey) -> Bool@@ -41,7 +41,7 @@ fg = signMsg fk fm normalizeSigTest :: (Msg, SecKey) -> Bool-normalizeSigTest (fm, fk) = norm == False && sig == fg where+normalizeSigTest (fm, fk) = not norm && sig == fg where fg = signMsg fk fm (sig, norm) = normalizeSig fg @@ -86,12 +86,12 @@ assertEqual "tweaked keys match" expected tweaked where tweaked = do- key <- secKey $ fst $ B16.decode $ B8.pack $+ key <- secKey $ fst $ B16.decode $ B8.pack "f65255094d7773ed8dd417badc9fc045c1f80fdc5b2d25172b031ce6933e039a"- twk <- tweak $ fst $ B16.decode $ B8.pack $+ twk <- tweak $ fst $ B16.decode $ B8.pack "f5cbe7d88182a4b8e400f96b06128921864a18187d114c8ae8541b566c8ace00" tweakAddSecKey key twk- expected = secKey $ fst $ B16.decode $ B8.pack $+ expected = secKey $ fst $ B16.decode $ B8.pack "ec1e3ce1cefa18a671d51125e2b249688d934b0e28f5d1665384d9b02f929059" tweakMulSecKeyTest :: Assertion@@ -99,12 +99,12 @@ assertEqual "tweaked keys match" expected tweaked where tweaked = do- key <- secKey $ fst $ B16.decode $ B8.pack $+ key <- secKey $ fst $ B16.decode $ B8.pack "f65255094d7773ed8dd417badc9fc045c1f80fdc5b2d25172b031ce6933e039a"- twk <- tweak $ fst $ B16.decode $ B8.pack $+ twk <- tweak $ fst $ B16.decode $ B8.pack "f5cbe7d88182a4b8e400f96b06128921864a18187d114c8ae8541b566c8ace00" tweakMulSecKey key twk- expected = secKey $ fst $ B16.decode $ B8.pack $+ expected = secKey $ fst $ B16.decode $ B8.pack "a96f5962493acb179f60a86a9785fc7a30e0c39b64c09d24fe064d9aef15e4c0" tweakAddPubKeyTest :: Assertion@@ -112,13 +112,13 @@ assertEqual "tweaked keys match" expected tweaked where tweaked = do- pub <- importPubKey $ fst $ B16.decode $ B8.pack $+ pub <- importPubKey $ fst $ B16.decode $ B8.pack "04dded4203dac96a7e85f2c374a37ce3e9c9a155a72b64b4551b0bfe779dd44705\ \12213d5ed790522c042dee8e85c4c0ec5f96800b72bc5940c8bc1c5e11e4fcbf"- twk <- tweak $ fst $ B16.decode $ B8.pack $+ twk <- tweak $ fst $ B16.decode $ B8.pack "f5cbe7d88182a4b8e400f96b06128921864a18187d114c8ae8541b566c8ace00" tweakAddPubKey pub twk- expected = importPubKey $ fst $ B16.decode $ B8.pack $+ expected = importPubKey $ fst $ B16.decode $ B8.pack "04441c3982b97576646e0df0c96736063df6b42f2ee566d13b9f6424302d1379e518fd\ \c87a14c5435bff7a5db4552042cb4120c6b86a4bbd3d0643f3c14ad01368" @@ -127,13 +127,13 @@ assertEqual "tweaked keys match" expected tweaked where tweaked = do- pub <- importPubKey $ fst $ B16.decode $ B8.pack $+ pub <- importPubKey $ fst $ B16.decode $ B8.pack "04dded4203dac96a7e85f2c374a37ce3e9c9a155a72b64b4551b0bfe779dd44705\ \12213d5ed790522c042dee8e85c4c0ec5f96800b72bc5940c8bc1c5e11e4fcbf"- twk <- tweak $ fst $ B16.decode $ B8.pack $+ twk <- tweak $ fst $ B16.decode $ B8.pack "f5cbe7d88182a4b8e400f96b06128921864a18187d114c8ae8541b566c8ace00" tweakMulPubKey pub twk- expected = importPubKey $ fst $ B16.decode $ B8.pack $+ expected = importPubKey $ fst $ B16.decode $ B8.pack "04f379dc99cdf5c83e433defa267fbb3377d61d6b779c06a0e4ce29ae3ff5353b12ae4\ \9c9d07e7368f2ba5a446c203255ce912322991a2d6a9d5d5761c61ed1845"
secp256k1.cabal view
@@ -1,5 +1,5 @@ name: secp256k1-version: 0.2.0+version: 0.3.0 synopsis: secp256k1 bindings for Haskell description: Please see README.md homepage: http://github.com/haskoin/secp256k1#readme