diff --git a/Crypto/Cipher/RSA.hs b/Crypto/Cipher/RSA.hs
--- a/Crypto/Cipher/RSA.hs
+++ b/Crypto/Cipher/RSA.hs
@@ -1,3 +1,5 @@
+{-# LANGUAGE FlexibleInstances, CPP #-}
+
 -- |
 -- Module      : Crypto.Cipher.RSA
 -- License     : BSD-style
@@ -18,7 +20,6 @@
 	, verify
 	) where
 
-import Control.Monad.Error ()
 import Control.Arrow (first)
 import Crypto.Random
 import Data.ByteString (ByteString)
@@ -57,6 +58,13 @@
 type HashF = ByteString -> ByteString
 type HashASN1 = ByteString
 
+#if ! (MIN_VERSION_base(4,3,0))
+instance Monad (Either Error) where
+	return          = Right
+	(Left x) >>= _  = Left x
+	(Right x) >>= f = f x
+#endif
+
 padPKCS1 :: CryptoRandomGen g => g -> Int -> ByteString -> Either Error (ByteString, g)
 padPKCS1 rng len m = do
 	(padding, rng') <- getRandomBytes rng (len - B.length m - 3)
@@ -119,7 +127,7 @@
 	Right (s == em)
 
 -- | generate a pair of (private, public) key of size in bytes.
-generate :: CryptoRandomGen g => g -> Int -> Integer -> Either GenError ((PublicKey, PrivateKey), g)
+generate :: CryptoRandomGen g => g -> Int -> Integer -> Either Error ((PublicKey, PrivateKey), g)
 generate rng size e = do
 	((p,q), rng') <- generatePQ rng
 	let n   = p * q
@@ -142,15 +150,16 @@
 				, public_n  = n
 				, public_e  = e
 				}
-			return ((pub, priv), rng')
+			Right ((pub, priv), rng')
 	where
 		generatePQ g = do
-			(p, g')  <- generatePrime g (8 * (size `div` 2))
+			(p, g')  <- genPrime g (8 * (size `div` 2))
 			(q, g'') <- generateQ p g'
 			return ((p,q), g'')
 		generateQ p h = do
-			(q, h') <- generatePrime h (8 * (size - (size `div` 2)))
+			(q, h') <- genPrime h (8 * (size - (size `div` 2)))
 			if p == q then generateQ p h' else return (q, h')
+		genPrime g sz = either (Left . RandomGenFailure) Right $ generatePrime g sz
 
 {- makeSignature for sign and verify -}
 makeSignature :: HashF -> HashASN1 -> Int -> ByteString -> Either Error ByteString
diff --git a/Number/Generate.hs b/Number/Generate.hs
--- a/Number/Generate.hs
+++ b/Number/Generate.hs
@@ -4,7 +4,6 @@
 	, generateOfSize
 	) where
 
-import Control.Monad.Error ()
 import Number.Serialize
 import Crypto.Random
 import qualified Data.ByteString as B
@@ -13,13 +12,15 @@
 -- | generate a positive integer between 0 and m.
 -- using as many bytes as necessary to the same size as m, that are converted to integer.
 generateMax :: CryptoRandomGen g => g -> Integer -> Either GenError (Integer, g)
-generateMax rng m = genBytes (logiBytes m) rng >>= \(bs, rng') -> return (os2ip bs `mod` m, rng')
+generateMax rng m = case genBytes (logiBytes m) rng of
+	Left err         -> Left err
+	Right (bs, rng') -> Right (os2ip bs `mod` m, rng')
 
 -- | generate a number between the inclusive bound [low,high].
 generateBetween :: CryptoRandomGen g => g -> Integer -> Integer -> Either GenError (Integer, g)
-generateBetween rng low high = generateMax rng rmax >>= \(v, rng') -> return (low + v, rng')
-	where
-		rmax = high - low + 1 -- relative maximum before being corrected by the low bound
+generateBetween rng low high = case generateMax rng (high - low + 1) of
+	Left err        -> Left err
+	Right (v, rng') -> Right (low + v, rng')
 
 -- | generate a positive integer of a specific size in bits.
 -- the number of bits need to be multiple of 8. It will always returns
diff --git a/Number/Prime.hs b/Number/Prime.hs
--- a/Number/Prime.hs
+++ b/Number/Prime.hs
@@ -22,13 +22,16 @@
 	| otherwise                                            = primalityTestMillerRabin rng 30 n
 
 generatePrime :: CryptoRandomGen g => g -> Int -> Either GenError (Integer, g)
-generatePrime rng bits = generateOfSize rng bits >>= \(sp, rng') -> findPrimeFrom rng' sp
+generatePrime rng bits = case generateOfSize rng bits of
+	Left err         -> Left err
+	Right (sp, rng') -> findPrimeFrom rng' sp
 
 findPrimeFrom :: CryptoRandomGen g => g -> Integer -> Either GenError (Integer, g)
 findPrimeFrom rng n
 	| even n        = findPrimeFrom rng (n+1)
-	| otherwise     = isProbablyPrime rng n
-	              >>= \(isPPrime, rng') -> if isPPrime then return (n, rng') else findPrimeFrom rng' (n+2)
+	| otherwise     = case isProbablyPrime rng n of
+		Left err               -> Left err
+		Right (isPPrime, rng') -> if isPPrime then Right (n, rng') else findPrimeFrom rng' (n+2)
 
 -- | Miller Rabin algorithm return if the number is probably prime or composite.
 -- the tries parameter is the number of recursion, that determines the accuracy of the test.
@@ -45,12 +48,14 @@
 			| otherwise     = factorise (s+1) (v `shiftR` 1)
 		expmod = exponantiation_rtl_binary
 		-- when iteration reach zero, we have a probable prime
-		loop g _     0 = return (True, g)
-		loop g (s,d) k = generateBetween g 2 (n-2) >>= \(a, g') ->
-			let x = expmod a d n in
-			if x == (1 :: Integer) || x == (n-1)
-				then loop g' (s,d) (k-1)
-				else loop' g' (s,d) (k-1) ((x*x) `mod` n) 1
+		loop g _     0 = Right (True, g)
+		loop g (s,d) k = case generateBetween g 2 (n-2) of
+			Left err      -> Left err
+			Right (a, g') ->
+				let x = expmod a d n in
+				if x == (1 :: Integer) || x == (n-1)
+					then loop g' (s,d) (k-1)
+					else loop' g' (s,d) (k-1) ((x*x) `mod` n) 1
 		-- loop from 1 to s-1. if we reach the end then it's composite
 		loop' g o@(s,_) km1 x2 r
 			| r == s      = Right (False, g)
diff --git a/cryptocipher.cabal b/cryptocipher.cabal
--- a/cryptocipher.cabal
+++ b/cryptocipher.cabal
@@ -1,5 +1,5 @@
 Name:                cryptocipher
-Version:             0.2.10
+Version:             0.2.11
 Description:         Symmetrical Block, Stream and PubKey Ciphers
 License:             BSD3
 License-file:        LICENSE
@@ -28,7 +28,6 @@
                    , crypto-api >= 0.5
                    , tagged
                    , cereal
-                   , mtl
   Exposed-modules:   Crypto.Cipher.RC4
                      Crypto.Cipher.AES
                      Crypto.Cipher.Camellia