based/src/Encoding/Base64.hs

module Encoding.Base64
  ( enc64
  , dec64
  , enc64url
  , dec64url
  ) where

import Data.ByteString.UTF8 as BSU      -- from utf8-string
import qualified Data.ByteString.Char8 as C
import qualified Codec.Binary.Base64 as B64
import qualified Data.ByteString.Base64 as B64L
import qualified Codec.Binary.Base64Url as B64U

import qualified Data.Text as T
import qualified Data.Text.Encoding as T
import qualified Data.Text.IO as T

encodeToBase64 :: C.ByteString -> Either String C.ByteString
encodeToBase64 bs =
   case B64.encode bs of
     encoded | C.null encoded -> Left "Failed to encode Base64.\n"
             | otherwise -> Right encoded

decodeFromBase64 :: C.ByteString -> Either String C.ByteString
decodeFromBase64 bs =
   case B64L.decodeLenient bs of 
     decoded | C.null decoded -> Left "Failed to decode from Base64.\n"
             | otherwise -> Right decoded
             -- | otherwise -> Right (BSU.toString decoded)
     -- Left err -> Left $ "Failed to decode from base64: " ++ err
     -- Right decoded -> Right decoded

dec64 :: String -> String
dec64 input =
   case decodeFromBase64 (BSU.fromString input) of
     Right  byteString -> T.unpack (T.decodeUtf8 byteString)
     Left errMsg -> "Error: " ++ errMsg

enc64 :: String -> String
enc64 input =
   case encodeToBase64 (BSU.fromString input) of
     Right byteString -> C.unpack byteString
     Left errMsg -> "Error: " ++ errMsg

dec64url :: String -> String
dec64url input =
   case B64.decode (BSU.fromString input)  of
     Right decoded -> T.unpack (T.decodeUtf8 decoded)
     Left _ -> "Error decoding Base64 for URLs.\n"

enc64url :: String -> String
enc64url = C.unpack . B64U.encode . BSU.fromString