servant-hmac-auth: Servant authentication with HMAC

[ cryptography, library, mit, program, web ] [ Propose Tags ]

Servant authentication with HMAC

[Skip to Readme]
Versions [faq] 0.0.0
Change log
Dependencies aeson (==1.3.*), base (>=4.11 && <5), base64-bytestring (==1.0.*), binary (==0.8.*), bytestring (==0.10.*), case-insensitive (==1.2.*), containers (>=0.5.7 && <0.7), cryptonite (==0.25.*), http-client (==0.5.*), http-types (==0.12.*), memory (>=0.14.14 && <0.15), mtl (>=2.2.2 && <2.3), servant (>=0.14.1 && <0.15), servant-client (==0.14.*), servant-client-core (>=0.14.1 && <0.15), servant-hmac-auth, servant-server (>=0.14.1 && <0.15), transformers (==0.5.*), wai (==3.2.*), warp (==3.2.*) [details]
License MIT
Copyright 2018 Holmusk
Author Holmusk
Category Web, Cryptography
Home page
Bug tracker
Source repo head: git clone
Uploaded by vrom911 at 2018-09-06T06:34:58Z
Distributions NixOS:0.0.0
Executables readme
Downloads 429 total (10 in the last 30 days)
Rating (no votes yet) [estimated by Bayesian average]
Your Rating
  • λ
  • λ
  • λ
Status Hackage Matrix CI
Docs uploaded by user [build log]
All reported builds failed as of 2018-09-06 [all 2 reports]




Maintainer's Corner

For package maintainers and hackage trustees

Readme for servant-hmac-auth-0.0.0

[back to package description]


Hackage MIT license Stackage Lts Stackage Nightly

Servant authentication with HMAC


In this section, we will introduce the client-server example. To run it locally you can:

$ cabal new-build
$ cabal new-exec readme

So,it will run this on your machine.

Setting up

Since this tutorial is written using Literate Haskell, first, let's write all necessary pragmas and imports.

{-# LANGUAGE DataKinds                  #-}
{-# LANGUAGE DeriveGeneric              #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE OverloadedStrings          #-}
{-# LANGUAGE TypeApplications           #-}
{-# LANGUAGE TypeOperators              #-}

import Control.Concurrent (forkIO, threadDelay)
import Data.Aeson (FromJSON, ToJSON)
import Data.Proxy (Proxy (..))
import GHC.Generics (Generic)
import Network.HTTP.Client (defaultManagerSettings, newManager)
import Network.Wai.Handler.Warp (run)
import Servant.API ((:>), Get, JSON)
import Servant.Client (BaseUrl (..), Scheme (..), ServantError, mkClientEnv)
import Servant.Server (Application, Server, serveWithContext)

import Servant.Auth.Hmac (HmacAuth, HmacClientM, SecretKey (..), hmacAuthServerContext, hmacClient,
                          runHmacClient, signSHA256)


Let's define our TheAnswer data type with the necessary instances for it.

newtype TheAnswer = TheAnswer Int
    deriving (Show, Generic, FromJSON, ToJSON)

getTheAnswer :: TheAnswer
getTheAnswer = TheAnswer 42

Now, let's introduce a very simple protected endpoint. The value of TheAnswer data type will be the value that our API endpoint returns. It our case we want it to return the number 42 for all signed requests.

type TheAnswerToEverythingUnprotectedAPI = "answer" :> Get '[JSON] TheAnswer
type TheAnswerToEverythingAPI = HmacAuth :> TheAnswerToEverythingUnprotectedAPI

As you can see this endpoint is protected by HmacAuth.

And now our server:

server42 :: Server TheAnswerToEverythingAPI
server42 = \_ -> pure getTheAnswer

Now we can turn server into an actual webserver:

topSecret :: SecretKey
topSecret = SecretKey "top-secret"

app42 :: Application
app42 = serveWithContext
    (Proxy @TheAnswerToEverythingAPI)
    (hmacAuthServerContext signSHA256 topSecret)


Now let's implement client that queries our server and signs every request automatically.

client42 :: HmacClientM TheAnswer
client42 = hmacClient @TheAnswerToEverythingUnprotectedAPI

Now we need to write function that runs our client:

runClient :: SecretKey -> HmacClientM a -> IO (Either ServantError a)
runClient sk client = do
    manager <- newManager defaultManagerSettings
    let env = mkClientEnv manager $ BaseUrl Http "localhost" 8080 ""
    runHmacClient signSHA256 sk env client


And we're able to run our server in separate thread and perform two quiries:

  • Properly signed
  • Signed with different key
main :: IO ()
main = do
    _ <- forkIO $ run 8080 app42

    print =<< runClient topSecret client42
    print =<< runClient (SecretKey "wrong!") client42

    threadDelay $ 10 ^ (6 :: Int)