1 files changed, 52 insertions, 15 deletions

diff --git a/Data/OpenPGP/Util/DecryptSecretKey.hs b/Data/OpenPGP/Util/DecryptSecretKey.hs
index 9b63c8e..01728d3 100644
--- a/Data/OpenPGP/Util/DecryptSecretKey.hs
+++ b/Data/OpenPGP/Util/DecryptSecretKey.hs
@@ -21,24 +21,29 @@ import Control.Exception as Exception (IOException(..),catch)
 import Data.Binary.Put (runPut)
 import Control.Applicative ( (<$>) )
 
-import Crypto.Hash.SHA1 as SHA1
-
 import qualified Crypto.Cipher.AES as Vincent
 import qualified Crypto.Cipher.Blowfish as Vincent
 
 import qualified Crypto.Cipher.Types as Vincent
+
+#if defined(VERSION_cryptonite)
+import qualified Data.ByteArray as Bytes
+import Crypto.Hash.Algorithms
+import Crypto.Hash
+import Crypto.Error
+#else
 import qualified Data.Byteable as Vincent
+import Crypto.Hash.SHA1 as SHA1
+#endif
 
 import qualified Crypto.Random as Vincent
 
 import Crypto.Cipher.Cast5 (CAST5_128)
 import Crypto.Cipher.ThomasToVincent
-import Data.OpenPGP.Util.Base (toStrictBS,toLazyBS,hashBySymbol)
+import Data.OpenPGP.Util.Base
+import Data.OpenPGP.Util.Gen (makeGen)
 
-
-
-
-data Enciphered = 
+data Enciphered =
          EncipheredWithIV !LZ.ByteString -- initial vector is appended to front of ByteString
        | EncipheredZeroIV !LZ.ByteString -- initial vector is zero, ByteString contains only the block
 
@@ -47,9 +52,13 @@ withIV f (EncipheredWithIV s) = f iv bs
     where
     Just iv = Vincent.makeIV (toStrictBS ivbs)
     (ivbs,bs) = LZ.splitAt (fromIntegral ivlen) s
+#if defined(VERSION_cryptonite)
+    ivlen = Bytes.length iv
+#else
     ivlen = Vincent.byteableLength z
-    z = Vincent.nullIV
     _ = Vincent.constEqBytes z iv
+    z = Vincent.nullIV
+#endif
 withIV f (EncipheredZeroIV s) = f Vincent.nullIV s
 
 decryptSecretKey ::
@@ -76,11 +85,17 @@ decryptSecretKey pass k@(OpenPGP.SecretKeyPacket {
         (OpenPGP.secret_key_fields kalgo)) material
     (material, chk) = LZ.splitAt (LZ.length decd - chkSize) decd
     (chkSize, chkF)
-        | OpenPGP.s2k_useage k == 254 = (20, SHA1.hash . toStrictBS)
+        | OpenPGP.s2k_useage k == 254 = (20, sha1 . toStrictBS)
         | otherwise = (2, toStrictBS . encode . checksum . toStrictBS)
         -- Words16s are written as 2 bytes in big-endian (network) order
     decd = withS2K simpleUnCFB salgo s2k (toLazyBS pass) (EncipheredWithIV encd)
 
+#if defined(VERSION_cryptonite)
+    sha1 x = Bytes.convert (hash x :: Digest SHA1)
+#else
+    sha1 = SHA1.hash
+#endif
+
 decryptSecretKey _ _ = Nothing
 
 checksum :: BS.ByteString -> Word16
@@ -111,7 +126,8 @@ withS2K codec OpenPGP.AES128 s2k s   = withIV $ codec (string2key s2k s :: Vince
 withS2K codec OpenPGP.AES192 s2k s   = withIV $ codec (string2key s2k s :: Vincent.AES192)
 withS2K codec OpenPGP.AES256 s2k s   = withIV $ codec (string2key s2k s :: Vincent.AES256)
 withS2K codec OpenPGP.Blowfish s2k s = withIV $ codec (string2key s2k s :: Vincent.Blowfish128)
-withS2K codec OpenPGP.CAST5 s2k s    = withIV $ codec (string2key s2k s :: ThomasToVincent CAST5_128)
+-- TODO: cast5 support
+-- withS2K codec OpenPGP.CAST5 s2k s    = withIV $ codec (string2key s2k s :: ThomasToVincent CAST5_128)
 withS2K codec algo _ _ = error $ "Unsupported symmetric algorithm : " ++ show algo ++ " in Data.OpenPGP.CryptoAPI.withS2K"
 
 withS2K' :: OpenPGP.SymmetricAlgorithm -> OpenPGP.S2K -> LZ.ByteString
@@ -120,21 +136,27 @@ withS2K' OpenPGP.AES128   s2k s f = f (string2key s2k s :: Vincent.AES128)
 withS2K' OpenPGP.AES192   s2k s f = f (string2key s2k s :: Vincent.AES192)
 withS2K' OpenPGP.AES256   s2k s f = f (string2key s2k s :: Vincent.AES256)
 withS2K' OpenPGP.Blowfish s2k s f = f (string2key s2k s :: Vincent.Blowfish128)
-withS2K' OpenPGP.CAST5    s2k s f = f (string2key s2k s :: ThomasToVincent CAST5_128)
+-- TODO: cast5 support
+-- withS2K' OpenPGP.CAST5    s2k s f = f (string2key s2k s :: ThomasToVincent CAST5_128)
 
 -- decryption codec for withS2K
 simpleUnCFB :: (Vincent.BlockCipher k) => k -> Vincent.IV k -> LZ.ByteString -> LZ.ByteString
 simpleUnCFB k iv = padThenUnpad k (toLazyBS . Vincent.cfbDecrypt k iv . toStrictBS)
 
-simpleCFB :: (Vincent.BlockCipher k, Vincent.CPRG g) => g -> k -> LZ.ByteString -> (LZ.ByteString, g)
+simpleCFB :: (Vincent.BlockCipher k, RG g) => g -> k -> LZ.ByteString -> (LZ.ByteString, g)
 simpleCFB g k bs = ( padThenUnpad k (LZ.fromChunks . (ivbs:) . (:[]) . Vincent.cfbEncrypt k iv . toStrictBS) bs
                    , g' )
  where
     Just iv = Vincent.makeIV ivbs
+#if defined(VERSION_cryptonite)
+    (ivbs,g') = Vincent.randomBytesGenerate ivlen g
+    ivlen = Bytes.length iv
+#else
+    z = Vincent.nullIV
     (ivbs,g') = Vincent.cprgGenerate ivlen g
     ivlen = Vincent.byteableLength z
-    z = Vincent.nullIV
     _ = Vincent.constEqBytes z iv
+#endif
 
 -- Apply a function f to a zero-padded bytestring s to a multiple
 -- of the blocksize for cyper k.
@@ -147,12 +169,28 @@ padThenUnpad k f s = dropPadEnd (f padded)
         padAmount = blksize - (LZ.length s `mod` blksize)
         blksize = fromIntegral $ Vincent.blockSize k
 
+{-
+Data/OpenPGP/Util/DecryptSecretKey.hs:172:20:
+    Couldn't match expected type ‘k’
+                with actual type ‘cryptonite-0.15:Crypto.Error.Types.CryptoFailable
+                                    cipher0’
+      ‘k’ is a rigid type variable bound by
+          the type signature for
+            string2key :: Vincent.BlockCipher k =>
+                          OpenPGP.S2K -> LZ.ByteString -> k
+          at Data/OpenPGP/Util/DecryptSecretKey.hs:171:15
+-}
 string2key :: (Vincent.BlockCipher k) => OpenPGP.S2K -> LZ.ByteString -> k
 string2key s2k s = cipher
     where
+#if defined(VERSION_cryptonite)
+    CryptoPassed cipher = Vincent.cipherInit k
+    k = toStrictBS $ LZ.take ksize $ OpenPGP.string2key hashBySymbol s2k s
+#else
     cipher = Vincent.cipherInit k
     Right k = Vincent.makeKey $ toStrictBS $
         LZ.take ksize $ OpenPGP.string2key hashBySymbol s2k s
+#endif
     ksize = case Vincent.cipherKeySize cipher of
                 Vincent.KeySizeFixed n -> fromIntegral n
                 Vincent.KeySizeEnum xs -> error $ "Unknown key size in string2key"
@@ -164,8 +202,7 @@ catchIO_ a h = Exception.catch a (\(_ :: IOException) -> h)
 encryptSecretKey :: BS.ByteString ->  OpenPGP.S2K -> OpenPGP.SymmetricAlgorithm -> OpenPGP.Packet -> IO (Maybe OpenPGP.Packet)
 encryptSecretKey passphrase s2k salgo plain = do
     flip catchIO_ (return Nothing) $ do
-    g <- fmap Vincent.cprgCreate $ Vincent.createEntropyPool
-    let _ = g :: Vincent.SystemRNG
+    g <- makeGen Nothing
     return $ Just
       plain { OpenPGP.key = [ x | x <- OpenPGP.key plain
                             , fst x `elem` OpenPGP.public_key_fields (OpenPGP.key_algorithm plain) ]