sha512

Pure Haskell SHA-512, HMAC-SHA512 (docs.ppad.tech/sha512).
git clone git://git.ppad.tech/sha512.git
Log | Files | Refs | README | LICENSE

Lazy.hs (4339B)


      1 {-# OPTIONS_HADDOCK hide #-}
      2 {-# LANGUAGE BangPatterns #-}
      3 {-# LANGUAGE ViewPatterns #-}
      4 
      5 -- |
      6 -- Module: Crypto.Hash.SHA512.Lazy
      7 -- Copyright: (c) 2024 Jared Tobin
      8 -- License: MIT
      9 -- Maintainer: Jared Tobin <jared@ppad.tech>
     10 --
     11 -- Pure SHA-512 and HMAC-SHA512 implementations for lazy ByteStrings,
     12 -- as specified by RFC's
     13 -- [6234](https://datatracker.ietf.org/doc/html/rfc6234) and
     14 -- [2104](https://datatracker.ietf.org/doc/html/rfc2104).
     15 
     16 module Crypto.Hash.SHA512.Lazy (
     17   -- * SHA-512 message digest functions
     18     hash_lazy
     19 
     20   -- * SHA512-based MAC functions
     21   , hmac_lazy
     22   ) where
     23 
     24 import Crypto.Hash.SHA512.Internal
     25 import qualified Crypto.Hash.SHA512.Pure as Pure
     26 import qualified Data.Bits as B
     27 import qualified Data.ByteString as BS
     28 import qualified Data.ByteString.Builder as BSB
     29 import qualified Data.ByteString.Internal as BI
     30 import qualified Data.ByteString.Lazy as BL
     31 import qualified Data.ByteString.Lazy.Internal as BLI
     32 import Data.Word (Word64)
     33 import Foreign.ForeignPtr (plusForeignPtr)
     34 
     35 fi :: (Integral a, Num b) => a -> b
     36 fi = fromIntegral
     37 {-# INLINE fi #-}
     38 
     39 -- utility types for more efficient ByteString management
     40 
     41 data SSPair = SSPair
     42   {-# UNPACK #-} !BS.ByteString
     43   {-# UNPACK #-} !BS.ByteString
     44 
     45 data SLPair = SLPair {-# UNPACK #-} !BS.ByteString !BL.ByteString
     46 
     47 -- unsafe version of splitAt that does no bounds checking
     48 --
     49 -- invariant:
     50 --   0 <= n <= l
     51 unsafe_splitAt :: Int -> BS.ByteString -> SSPair
     52 unsafe_splitAt n (BI.BS x l) =
     53   SSPair (BI.BS x n) (BI.BS (plusForeignPtr x n) (l - n))
     54 
     55 -- variant of Data.ByteString.Lazy.splitAt that returns the initial
     56 -- component as a strict, unboxed ByteString
     57 splitAt128 :: BL.ByteString -> SLPair
     58 splitAt128 = splitAt' (128 :: Int) where
     59   splitAt' _ BLI.Empty        = SLPair mempty BLI.Empty
     60   splitAt' n (BLI.Chunk c@(BI.PS _ _ l) cs) =
     61     if    n < l
     62     then
     63       -- n < BS.length c, so unsafe_splitAt is safe
     64       let !(SSPair c0 c1) = unsafe_splitAt n c
     65       in  SLPair c0 (BLI.Chunk c1 cs)
     66     else
     67       let SLPair cs' cs'' = splitAt' (n - l) cs
     68       in  SLPair (c <> cs') cs''
     69 
     70 -- builder realization strategies
     71 
     72 to_strict :: BSB.Builder -> BS.ByteString
     73 to_strict = BL.toStrict . BSB.toLazyByteString
     74 
     75 -- message padding and parsing
     76 -- https://datatracker.ietf.org/doc/html/rfc6234#section-4.1
     77 
     78 -- k such that (l + 1 + k) mod 128 = 112
     79 sol :: Word64 -> Word64
     80 sol l = (111 - l) B..&. 127 -- wraps mod 2^64, a multiple of 128
     81 
     82 -- RFC 6234 4.1 (lazy)
     83 pad_lazy :: BL.ByteString -> BL.ByteString
     84 pad_lazy (BL.toChunks -> m) = BL.fromChunks (walk 0 m) where
     85   walk !l bs = case bs of
     86     (c:cs) -> c : walk (l + fi (BS.length c)) cs
     87     [] -> [padding l]
     88 
     89   padding l = to_strict $
     90        BSB.word8 0x80
     91     <> BSB.byteString (BS.replicate (fi (sol l)) 0x00)
     92     <> BSB.word64BE 0x00
     93     <> BSB.word64BE (l * 8)
     94 
     95 -- | Compute a condensed representation of a lazy bytestring via
     96 --   SHA-512.
     97 --
     98 --   The 512-bit output digest is returned as a strict bytestring.
     99 --
    100 --   >>> hash_lazy "lazy bytestring input"
    101 --   "<strict 512-bit message digest>"
    102 hash_lazy :: BL.ByteString -> BS.ByteString
    103 hash_lazy bl = cat (go (iv ()) (pad_lazy bl)) where
    104   go :: Registers -> BL.ByteString -> Registers
    105   go !acc bs
    106     | BL.null bs = acc
    107     | otherwise = case splitAt128 bs of
    108         SLPair c r -> go (update acc (parse c 0)) r
    109 
    110 -- HMAC -----------------------------------------------------------------------
    111 -- https://datatracker.ietf.org/doc/html/rfc2104#section-2
    112 
    113 -- | Produce a message authentication code for a lazy bytestring, based
    114 --   on the provided (strict, bytestring) key, via SHA-512.
    115 --
    116 --   The 512-bit MAC is returned as a strict bytestring.
    117 --
    118 --   Per RFC 2104, the key /should/ be a minimum of 64 bytes long. Keys
    119 --   exceeding 128 bytes in length will first be hashed (via SHA-512).
    120 --
    121 --   >>> hmac_lazy "strict bytestring key" "lazy bytestring input"
    122 --   "<strict 512-bit MAC>"
    123 hmac_lazy
    124   :: BS.ByteString -- ^ key
    125   -> BL.ByteString -- ^ text
    126   -> MAC
    127 hmac_lazy mk@(BI.PS _ _ l) text =
    128     let step1 = k <> BS.replicate (128 - lk) 0x00
    129         step2 = BS.map (B.xor 0x36) step1
    130         step3 = BL.fromStrict step2 <> text
    131         step4 = hash_lazy step3
    132         step5 = BS.map (B.xor 0x5C) step1
    133         step6 = step5 <> step4
    134     in  MAC (Pure.hash step6)
    135   where
    136     !(k, lk) = if l > 128 then (Pure.hash mk, 64) else (mk, l)