commit 71f2c74efbad1ec0f5802356e0bc2119cb3121cc · pyrox.dev/nixpkgs

pkgs/development/haskell-modules/configuration-darwin.nix

···

       289
       289
        
       

     

       290
       290
        
         # https://github.com/fpco/inline-c/issues/127

     

       291
       291
        
         inline-c-cpp = dontCheck super.inline-c-cpp;

     

       292
       292
       +
       

     

       293
       293
       +
         # https://github.com/haskell-crypto/cryptonite/issues/360

     

       294
       294
       +
         cryptonite = appendPatch ./patches/cryptonite-remove-argon2.patch super.cryptonite;

     

       292
       295
        
       })

+69

pkgs/development/haskell-modules/patches/cryptonite-remove-argon2.patch

···

       1
       1
       +
       diff --git a/Crypto/KDF/Argon2.hs b/Crypto/KDF/Argon2.hs

     

       2
       2
       +
       index 044ba00..31dc6f1 100644

     

       3
       3
       +
       --- a/Crypto/KDF/Argon2.hs

     

       4
       4
       +
       +++ b/Crypto/KDF/Argon2.hs

     

       5
       5
       +
       @@ -12,6 +12,7 @@

     

       6
       6
       +
        -- File started from Argon2.hs, from Oliver Charles

     

       7
       7
       +
        -- at https://github.com/ocharles/argon2

     

       8
       8
       +
        --

     

       9
       9
       +
       +{-# LANGUAGE DataKinds #-}

     

       10
       10
       +
        module Crypto.KDF.Argon2

     

       11
       11
       +
            (

     

       12
       12
       +
              Options(..)

     

       13
       13
       +
       @@ -32,6 +33,7 @@ import           Control.Monad (when)

     

       14
       14
       +
        import           Data.Word

     

       15
       15
       +
        import           Foreign.C

     

       16
       16
       +
        import           Foreign.Ptr

     

       17
       17
       +
       +import           Data.Proxy

     

       18
       18
       +
        

     

       19
       19
       +
        -- | Which variant of Argon2 to use. You should choose the variant that is most

     

       20
       20
       +
        -- applicable to your intention to hash inputs.

     

       21
       21
       +
       @@ -100,33 +102,12 @@ defaultOptions =

     

       22
       22
       +
                    }

     

       23
       23
       +
        

     

       24
       24
       +
        hash :: (ByteArrayAccess password, ByteArrayAccess salt, ByteArray out)

     

       25
       25
       +
       -     => Options

     

       26
       26
       +
       +     => [Proxy "cryptonite:Crypto.KDF.Argon2.hash is known to be broken on this architecture. See https://github.com/haskell-crypto/cryptonite/issues/360"]

     

       27
       27
       +
             -> password

     

       28
       28
       +
             -> salt

     

       29
       29
       +
             -> Int

     

       30
       30
       +
             -> CryptoFailable out

     

       31
       31
       +
       -hash options password salt outLen

     

       32
       32
       +
       -    | saltLen < saltMinLength  = CryptoFailed CryptoError_SaltTooSmall

     

       33
       33
       +
       -    | outLen < outputMinLength = CryptoFailed CryptoError_OutputLengthTooSmall

     

       34
       34
       +
       -    | outLen > outputMaxLength = CryptoFailed CryptoError_OutputLengthTooBig

     

       35
       35
       +
       -    | otherwise                = CryptoPassed $ B.allocAndFreeze outLen $ \out -> do

     

       36
       36
       +
       -        res <- B.withByteArray password $ \pPass ->

     

       37
       37
       +
       -               B.withByteArray salt     $ \pSalt ->

     

       38
       38
       +
       -                    argon2_hash (iterations options)

     

       39
       39
       +
       -                                (memory options)

     

       40
       40
       +
       -                                (parallelism options)

     

       41
       41
       +
       -                                pPass

     

       42
       42
       +
       -                                (csizeOfInt passwordLen)

     

       43
       43
       +
       -                                pSalt

     

       44
       44
       +
       -                                (csizeOfInt saltLen)

     

       45
       45
       +
       -                                out

     

       46
       46
       +
       -                                (csizeOfInt outLen)

     

       47
       47
       +
       -                                (cOfVariant $ variant options)

     

       48
       48
       +
       -                                (cOfVersion $ version options)

     

       49
       49
       +
       -        when (res /= 0) $ error "argon2: hash: internal error"

     

       50
       50
       +
       -  where

     

       51
       51
       +
       -    saltLen = B.length salt

     

       52
       52
       +
       -    passwordLen = B.length password

     

       53
       53
       +
       +hash options password salt outLen = error "cryptonite:Crypto.KDF.Argon2.hash is known to be broken on this architecture. See https://github.com/haskell-crypto/cryptonite/issues/360"

     

       54
       54
       +
        

     

       55
       55
       +
        data Pass

     

       56
       56
       +
        data Salt

     

       57
       57
       +
       diff --git a/tests/KAT_Argon2.hs b/tests/KAT_Argon2.hs

     

       58
       58
       +
       index a347fc5..fdba079 100644

     

       59
       59
       +
       --- a/tests/KAT_Argon2.hs

     

       60
       60
       +
       +++ b/tests/KAT_Argon2.hs

     

       61
       61
       +
       @@ -32,7 +32,7 @@ kdfTests = zipWith toKDFTest is vectors

     

       62
       62
       +
          where

     

       63
       63
       +
            toKDFTest i v =

     

       64
       64
       +
                testCase (show i)

     

       65
       65
       +
       -            (CryptoPassed (kdfResult v) @=? Argon2.hash (kdfOptions v) (kdfPass v) (kdfSalt v) (B.length $ kdfResult v))

     

       66
       66
       +
       +            (pure ())

     

       67
       67
       +
        

     

       68
       68
       +
            is :: [Int]

     

       69
       69
       +
            is = [1..]