securemem 0.1.2 → 0.1.3

raw patch · 3 files changed

+34/−8 lines, 3 filesdep ~basePVP ok

version bump matches the API change (PVP)

Dependency ranges changed: base

API changes (from Hackage documentation)

Files

• Data/SecureMem.hs +28/−7
• README.md +5/−0
• securemem.cabal +1/−1

@@ -8,6 +8,7 @@ {-# LANGUAGE ForeignFunctionInterface #-} {-# LANGUAGE BangPatterns #-} {-# LANGUAGE MagicHash #-}+{-# LANGUAGE CPP #-} module Data.SecureMem     ( SecureMem     , secureMemGetSize@@ -29,13 +30,17 @@ import Foreign.C.Types import Foreign.ForeignPtr (withForeignPtr, finalizeForeignPtr) import Foreign.Ptr+#if MIN_VERSION_base(4,6,0) import GHC.Types (Int(..)) import GHC.ForeignPtr (ForeignPtr(..), ForeignPtrContents(..), mallocForeignPtrBytes, addForeignPtrConcFinalizer) import GHC.Prim (sizeofMutableByteArray#) import GHC.Ptr (Ptr(..))+#else+import Foreign.ForeignPtr (ForeignPtr, mallocForeignPtrBytes)+#endif import Data.Word (Word8) import Data.Monoid-import Control.Applicative ((<$>))+import Control.Applicative import Control.Monad (foldM, void) import Data.ByteString (ByteString) import Data.Byteable@@ -46,14 +51,20 @@ -- * Being scrubbed after its goes out of scope. -- * A Show instance that doesn't actually show any content -- * A Eq instance that is constant time-newtype SecureMem = SecureMem (ForeignPtr Word8)+#if MIN_VERSION_base(4,6,0)+newtype SecureMem = SecureMem { getForeignPtr :: ForeignPtr Word8 }+#else+data SecureMem = SecureMem { getForeignPtr :: ForeignPtr Word8, secureMemGetSize :: Int }+#endif +#if MIN_VERSION_base(4,6,0) -- | Return the size of the memory allocated by this secure mem. secureMemGetSize :: SecureMem -> Int secureMemGetSize (SecureMem (ForeignPtr _ fpc)) =     case fpc of         MallocPtr mba _ -> I# (sizeofMutableByteArray# mba)         _               -> error "cannot happen"+#endif  secureMemEq :: SecureMem -> SecureMem -> Bool secureMemEq sm1 sm2 = sz1 == sz2 && B.inlinePerformIO meq@@ -83,14 +94,14 @@ secureMemConcat l = unsafeCreateSecureMem total $ \dst -> void $ foldM copy dst l   where total = sum $ map secureMemGetSize l         copy dst s = withSecureMemPtr s $ \sp -> do-                    B.memcpy dst sp sz+                    B.memcpy dst sp (fromIntegral sz)                     return (dst `plusPtr` sz)           where sz = secureMemGetSize s  secureMemCopy :: SecureMem -> IO SecureMem secureMemCopy src =     createSecureMem sz $ \dst ->-    withSecureMemPtr src $ \s -> B.memcpy dst s sz+    withSecureMemPtr src $ \s -> B.memcpy dst s (fromIntegral sz)   where sz = secureMemGetSize src  withSecureMemCopy :: SecureMem -> (Ptr Word8 -> IO ()) -> IO SecureMem@@ -139,6 +150,7 @@ foreign import ccall "compare_eq128" compareEq128 :: Ptr Word8 -> Ptr Word8 -> IO Bool foreign import ccall "compare_eq256" compareEq256 :: Ptr Word8 -> Ptr Word8 -> IO Bool +#if MIN_VERSION_base(4,6,0) -- | Scruber finalizers foreign import ccall "finalizer_scrub8" finalizerScrub8     :: Finalizer foreign import ccall "finalizer_scrub16" finalizerScrub16   :: Finalizer@@ -159,22 +171,31 @@ szToScruber 128 = finalizerScrub128 szToScruber 256 = finalizerScrub256 szToScruber n   = finalizerScrubVar (fromIntegral n)+#endif  -- | Allocate a foreign ptr which will be scrubed before memory free. -- the memory is allocated on the haskell heap allocateScrubedForeignPtr :: Int -> IO (ForeignPtr a) allocateScrubedForeignPtr sz = do+#if MIN_VERSION_base(4,6,0)     fptr@(ForeignPtr addr _) <- mallocForeignPtrBytes sz     addForeignPtrConcFinalizer fptr (scruber (Ptr addr))     return fptr   where !scruber = szToScruber sz+#else+    mallocForeignPtrBytes sz+#endif  -- | Allocate a new SecureMem -- -- The memory is allocated on the haskell heap, and will be scrubed -- before being released. allocateSecureMem :: Int -> IO SecureMem+#if MIN_VERSION_base(4,6,0) allocateSecureMem sz = SecureMem <$> allocateScrubedForeignPtr sz+#else+allocateSecureMem sz = SecureMem <$> allocateScrubedForeignPtr sz <*> pure sz+#endif  -- | Create a new secure mem and running an initializer function createSecureMem :: Int -> (Ptr Word8 -> IO ()) -> IO SecureMem@@ -194,15 +215,15 @@ -- -- this is similary to withForeignPtr for a ForeignPtr withSecureMemPtr :: SecureMem -> (Ptr Word8 -> IO b) -> IO b-withSecureMemPtr (SecureMem fptr) f = withForeignPtr fptr f+withSecureMemPtr sm f = withForeignPtr (getForeignPtr sm) f  -- | similar to withSecureMem but also include the size of the pointed memory. withSecureMemPtrSz :: SecureMem -> (Int -> Ptr Word8 -> IO b) -> IO b-withSecureMemPtrSz sm@(SecureMem fptr) f = withForeignPtr fptr (f (secureMemGetSize sm))+withSecureMemPtrSz sm f = withForeignPtr (getForeignPtr sm) (f (secureMemGetSize sm))  -- | Finalize a SecureMem early finalizeSecureMem :: SecureMem -> IO ()-finalizeSecureMem (SecureMem fptr) = finalizeForeignPtr fptr+finalizeSecureMem sm = finalizeForeignPtr $ getForeignPtr sm  -- | Create a bytestring from a Secure Mem secureMemToByteString :: SecureMem -> ByteString

@@ -2,3 +2,8 @@ =======  Documentation: [securemem on hackage](http://hackage.haskell.org/package/securemem)++older base+----------++An older base, the memory is not scrubed: upgrade your GHC to 7.6.0 or above.

@@ -1,5 +1,5 @@ Name:                securemem-Version:             0.1.2+Version:             0.1.3 Synopsis:            abstraction to an auto scrubbing and const time eq, memory chunk. Description:     SecureMem is similar to ByteString, except that it provides a memory chunk that