haskell/cryptonite
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[RSA] remove ByteString from Primitive module

Browse Source
This commit is contained in:
Vincent Hanquez 2015-05-21 14:32:05 +01:00
parent c111dfeb8e
commit 28958a6d03
1 changed files with 6 additions and 6 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
Crypto/PubKey/RSA/Prim.hs
View File

@ -13,20 +13,20 @@ module Crypto.PubKey.RSA.Prim
, ep , ep
) where ) where
import Data.ByteString (ByteString)
import Crypto.PubKey.RSA.Types import Crypto.PubKey.RSA.Types
import Crypto.Number.ModArithmetic (expFast, expSafe) import Crypto.Number.ModArithmetic (expFast, expSafe)
import Crypto.Number.Serialize (os2ip, i2ospOf_) import Crypto.Number.Serialize (os2ip, i2ospOf_)
import Crypto.Internal.ByteArray (ByteArray)
{- dpSlow computes the decrypted message not using any precomputed cache value. {- dpSlow computes the decrypted message not using any precomputed cache value.
only n and d need to valid. -} only n and d need to valid. -}
dpSlow :: PrivateKey -> ByteString -> ByteString dpSlow :: ByteArray ba => PrivateKey -> ba -> ba
dpSlow pk c = i2ospOf_ (private_size pk) $ expSafe (os2ip c) (private_d pk) (private_n pk) dpSlow pk c = i2ospOf_ (private_size pk) $ expSafe (os2ip c) (private_d pk) (private_n pk)
{- dpFast computes the decrypted message more efficiently if the {- dpFast computes the decrypted message more efficiently if the
precomputed private values are available. mod p and mod q are faster precomputed private values are available. mod p and mod q are faster
to compute than mod pq -} to compute than mod pq -}
dpFast :: Blinder -> PrivateKey -> ByteString -> ByteString dpFast :: ByteArray ba => Blinder -> PrivateKey -> ba -> ba
dpFast (Blinder r rm1) pk c = dpFast (Blinder r rm1) pk c =
i2ospOf_ (private_size pk) (multiplication rm1 (m2 + h * (private_q pk)) (private_n pk)) i2ospOf_ (private_size pk) (multiplication rm1 (m2 + h * (private_q pk)) (private_n pk))
where where
@ -36,7 +36,7 @@ dpFast (Blinder r rm1) pk c =
m2 = expSafe iC (private_dQ pk) (private_q pk) m2 = expSafe iC (private_dQ pk) (private_q pk)
h = ((private_qinv pk) * (m1 - m2)) `mod` (private_p pk) h = ((private_qinv pk) * (m1 - m2)) `mod` (private_p pk)
dpFastNoBlinder :: PrivateKey -> ByteString -> ByteString dpFastNoBlinder :: ByteArray ba => PrivateKey -> ba -> ba
dpFastNoBlinder pk c = i2ospOf_ (private_size pk) (m2 + h * (private_q pk)) dpFastNoBlinder pk c = i2ospOf_ (private_size pk) (m2 + h * (private_q pk))
where iC = os2ip c where iC = os2ip c
m1 = expSafe iC (private_dP pk) (private_p pk) m1 = expSafe iC (private_dP pk) (private_p pk)
@ -46,13 +46,13 @@ dpFastNoBlinder pk c = i2ospOf_ (private_size pk) (m2 + h * (private_q pk))
-- | Compute the RSA decrypt primitive. -- | Compute the RSA decrypt primitive.
-- if the p and q numbers are available, then dpFast is used -- if the p and q numbers are available, then dpFast is used
-- otherwise, we use dpSlow which only need d and n. -- otherwise, we use dpSlow which only need d and n.
dp :: Maybe Blinder -> PrivateKey -> ByteString -> ByteString dp :: ByteArray ba => Maybe Blinder -> PrivateKey -> ba -> ba
dp blinder pk dp blinder pk
| private_p pk /= 0 && private_q pk /= 0 = maybe dpFastNoBlinder dpFast blinder $ pk | private_p pk /= 0 && private_q pk /= 0 = maybe dpFastNoBlinder dpFast blinder $ pk
| otherwise = dpSlow pk | otherwise = dpSlow pk
-- | Compute the RSA encrypt primitive -- | Compute the RSA encrypt primitive
ep :: PublicKey -> ByteString -> ByteString ep :: ByteArray ba => PublicKey -> ba -> ba
ep pk m = i2ospOf_ (public_size pk) $ expFast (os2ip m) (public_e pk) (public_n pk) ep pk m = i2ospOf_ (public_size pk) $ expFast (os2ip m) (public_e pk) (public_n pk)
-- | multiply 2 integers in Zm only performing the modulo operation if necessary -- | multiply 2 integers in Zm only performing the modulo operation if necessary