aboutsummaryrefslogtreecommitdiffstats
path: root/src/Network/WireGuard
diff options
context:
space:
mode:
Diffstat (limited to 'src/Network/WireGuard')
-rw-r--r--src/Network/WireGuard/Core.hs336
-rw-r--r--src/Network/WireGuard/Daemon.hs55
-rw-r--r--src/Network/WireGuard/Foreign/In6Addr.hsc90
-rw-r--r--src/Network/WireGuard/Foreign/Key.hs29
-rw-r--r--src/Network/WireGuard/Foreign/Tun.hs45
-rw-r--r--src/Network/WireGuard/Foreign/UAPI.hsc172
-rw-r--r--src/Network/WireGuard/Internal/Constant.hs55
-rw-r--r--src/Network/WireGuard/Internal/IPPacket.hs56
-rw-r--r--src/Network/WireGuard/Internal/Noise.hs98
-rw-r--r--src/Network/WireGuard/Internal/Packet.hs112
-rw-r--r--src/Network/WireGuard/Internal/PacketQueue.hs49
-rw-r--r--src/Network/WireGuard/Internal/State.hs242
-rw-r--r--src/Network/WireGuard/Internal/Types.hs78
-rw-r--r--src/Network/WireGuard/Internal/Util.hs62
-rw-r--r--src/Network/WireGuard/RPC.hs187
-rw-r--r--src/Network/WireGuard/TunListener.hs60
-rw-r--r--src/Network/WireGuard/UdpListener.hs61
17 files changed, 1787 insertions, 0 deletions
diff --git a/src/Network/WireGuard/Core.hs b/src/Network/WireGuard/Core.hs
new file mode 100644
index 0000000..f36b3c9
--- /dev/null
+++ b/src/Network/WireGuard/Core.hs
@@ -0,0 +1,336 @@
+{-# LANGUAGE RecordWildCards #-}
+
+module Network.WireGuard.Core
+ ( runCore
+ ) where
+
+import Control.Concurrent (getNumCapabilities,
+ threadDelay)
+import Control.Concurrent.Async (wait, withAsync)
+import Control.Monad (forM_, forever, unless,
+ void, when)
+import Control.Monad.IO.Class (liftIO)
+import Control.Monad.STM (atomically)
+import Control.Monad.Trans.Except (ExceptT, runExceptT,
+ throwE)
+import Crypto.Noise (HandshakeRole (..))
+import Crypto.Noise.DH (dhGenKey, dhPubEq,
+ dhPubToBytes)
+import qualified Data.ByteArray as BA
+import qualified Data.ByteString as BS
+import qualified Data.HashMap.Strict as HM
+import Data.IP (makeAddrRange)
+import qualified Data.IP.RouteTable as RT
+import Data.Maybe (fromMaybe, isJust,
+ isNothing)
+import Data.Serialize (putWord32be,
+ putWord64be, runGet,
+ runPut)
+import Foreign.C.Types (CTime (..))
+import Network.Socket (SockAddr)
+import System.IO (hPutStrLn, stderr)
+import System.Posix.Time (epochTime)
+import System.Random (randomIO)
+
+import Control.Concurrent.STM.TVar
+import Crypto.Hash.BLAKE2.BLAKE2s
+
+import Network.WireGuard.Internal.Constant
+import Network.WireGuard.Internal.IPPacket
+import Network.WireGuard.Internal.Noise
+import Network.WireGuard.Internal.Packet
+import Network.WireGuard.Internal.PacketQueue
+import Network.WireGuard.Internal.State
+import Network.WireGuard.Internal.Types
+import Network.WireGuard.Internal.Util
+
+runCore :: Device
+ -> PacketQueue TunPacket -> PacketQueue TunPacket
+ -> PacketQueue UdpPacket -> PacketQueue UdpPacket
+ -> IO ()
+runCore device readTunChan writeTunChan readUdpChan writeUdpChan = do
+ threads <- getNumCapabilities
+ loop threads []
+ where
+ heartbeatLoop = forever $ ignoreSyncExceptions $ do
+ withJust (readTVarIO (localKey device)) $ \key ->
+ runHeartbeat device key writeUdpChan
+ -- TODO: use accurate timer
+ threadDelay heartbeatWaitTime
+
+ loop 0 asyncs =
+ withAsync heartbeatLoop $ \ht ->
+ mapM_ wait asyncs >> wait ht
+ loop x asyncs =
+ withAsync (retryWithBackoff $ handleReadTun device readTunChan writeUdpChan) $ \rt ->
+ withAsync (retryWithBackoff $ handleReadUdp device readUdpChan writeTunChan writeUdpChan) $ \ru ->
+ loop (x-1) (rt:ru:asyncs)
+
+handleReadTun :: Device -> PacketQueue TunPacket -> PacketQueue UdpPacket -> IO ()
+handleReadTun device readTunChan writeUdpChan = forever $ do
+ tunPacket <- atomically $ popPacketQueue readTunChan
+ res <- runExceptT $ processTunPacket device writeUdpChan tunPacket
+ case res of
+ Right udpPacket -> atomically $ pushPacketQueue writeUdpChan udpPacket
+ Left err -> hPutStrLn stderr (show err) -- TODO: proper logging
+
+handleReadUdp :: Device -> PacketQueue UdpPacket -> PacketQueue TunPacket
+ -> PacketQueue UdpPacket
+ -> IO ()
+handleReadUdp device readUdpChan writeTunChan writeUdpChan = forever $ do
+ udpPacket <- atomically $ popPacketQueue readUdpChan
+ res <- runExceptT $ processUdpPacket device udpPacket
+ case res of
+ Left err -> hPutStrLn stderr (show err) -- TODO: proper logging
+ Right mpacket -> case mpacket of
+ Just (Right tunp) -> atomically $ pushPacketQueue writeTunChan tunp
+ Just (Left udpp) -> atomically $ pushPacketQueue writeUdpChan udpp
+ Nothing -> return ()
+
+processTunPacket :: Device -> PacketQueue UdpPacket -> TunPacket
+ -> ExceptT WireGuardError IO UdpPacket
+processTunPacket device@Device{..} writeUdpChan packet = do
+ key <- assertJust DeviceNotReadyError $ liftIO (readTVarIO localKey)
+ psk <- liftIO (readTVarIO presharedKey)
+ parsedPacket <- liftIO $ parseIPPacket packet
+ peer <- assertJust DestinationNotReachableError $ case parsedPacket of
+ InvalidIPPacket -> throwE InvalidIPPacketError
+ IPv4Packet _ dest4 -> RT.lookup (makeAddrRange dest4 32)
+ <$> liftIO (readTVarIO routeTable4)
+ IPv6Packet _ dest6 -> RT.lookup (makeAddrRange dest6 128)
+ <$> liftIO (readTVarIO routeTable6)
+ msession <- liftIO (getSession peer)
+ session <- case msession of
+ Just session -> return session
+ Nothing -> do
+ now0 <- liftIO epochTime
+ endp0 <- assertJust EndPointUnknownError $ liftIO $ readTVarIO (endPoint peer)
+ liftIO $ void $ checkAndTryInitiateHandshake device key psk writeUdpChan peer endp0 now0
+ liftIO $ atomically $ waitForSession peer
+ nonce <- liftIO $ atomically $ nextNonce session
+ let (msg, authtag) = encryptMessage (sessionKey session) nonce packet
+ encrypted = runPut $ buildPacket (error "internal error") $
+ PacketData (theirIndex session) nonce msg authtag
+ now <- liftIO epochTime
+ endp <- assertJust EndPointUnknownError $ liftIO $ readTVarIO (endPoint peer)
+ when (now >= renewTime session) $ liftIO $
+ void $ checkAndTryInitiateHandshake device key psk writeUdpChan peer endp now
+ liftIO $ atomically $ modifyTVar' (transferredBytes peer) (+fromIntegral (BA.length packet))
+ liftIO $ atomically $ writeTVar (lastTransferTime peer) now
+ return (encrypted, endp)
+
+processUdpPacket :: Device -> UdpPacket
+ -> ExceptT WireGuardError IO (Maybe (Either UdpPacket TunPacket))
+processUdpPacket device@Device{..} (packet, sock) = do
+ key <- assertJust DeviceNotReadyError $ liftIO (readTVarIO localKey)
+ psk <- liftIO (readTVarIO presharedKey)
+ let mp = runGet (parsePacket (getMac1 (snd key) psk)) packet
+ case mp of
+ Left errMsg -> throwE (InvalidWGPacketError errMsg)
+ Right parsedPacket -> processPacket device key psk sock parsedPacket
+
+processPacket :: Device -> KeyPair -> Maybe PresharedKey -> SockAddr -> Packet
+ -> ExceptT WireGuardError IO (Maybe (Either UdpPacket TunPacket))
+processPacket device@Device{..} key psk sock HandshakeInitiation{..} = do
+ ekey <- liftIO dhGenKey
+ let state0 = newNoiseState key psk ekey Nothing ResponderRole
+ outcome = recvFirstMessageAndReply state0 encryptedPayload mempty
+ case outcome of
+ Left err -> throwE (NoiseError err)
+ Right (reply, decryptedPayload, rpub, sks) -> do
+ when (BA.length decryptedPayload /= timestampLength) $
+ throwE $ InvalidWGPacketError "timestamp expected"
+ peer <- assertJust RemotePeerNotFoundError $
+ HM.lookup (getPeerId rpub) <$> liftIO (readTVarIO peers)
+ notReplayAttack <- liftIO $ atomically $ updateTai64n peer (BA.convert decryptedPayload)
+ unless notReplayAttack $ throwE HandshakeInitiationReplayError
+ now <- liftIO epochTime
+ seed <- liftIO randomIO
+ ourindex <- liftIO $ atomically $ do
+ ourindex <- acquireEmptyIndex device peer seed
+ void $ eraseResponderWait device peer Nothing
+ let rwait = ResponderWait ourindex senderIndex
+ (addTime now handshakeStopTime) sks
+ writeTVar (responderWait peer) (Just rwait)
+ return ourindex
+ let responsePacket = runPut $ buildPacket (getMac1 rpub psk) $
+ HandshakeResponse ourindex senderIndex reply
+ return (Just (Left (responsePacket, sock)))
+
+processPacket device@Device{..} _key _psk sock HandshakeResponse{..} = do
+ peer <- assertJust UnknownIndexError $
+ HM.lookup receiverIndex <$> liftIO (readTVarIO indexMap)
+ iwait <- assertJust OutdatedPacketError $ liftIO (readTVarIO (initiatorWait peer))
+ when (initOurIndex iwait /= receiverIndex) $ throwE OutdatedPacketError
+ let state1 = initNoise iwait
+ outcome = recvSecondMessage state1 encryptedPayload
+ case outcome of
+ Left err -> throwE (NoiseError err)
+ Right (decryptedPayload, rpub, sks) -> do
+ now <- liftIO epochTime
+ newCounter <- liftIO $ atomically $ newTVar 0
+ let newsession = Session receiverIndex senderIndex sks
+ (addTime now sessionRenewTime)
+ (addTime now sessionExpireTime)
+ newCounter
+ when (BA.length decryptedPayload /= 0) $
+ throwE $ InvalidWGPacketError "empty payload expected"
+ unless (rpub `dhPubEq` remotePub peer) $ throwE RemotePeerNotFoundError
+ succeeded <- liftIO $ atomically $ do
+ erased <- eraseInitiatorWait device peer (Just receiverIndex)
+ when erased $ do
+ addSession device peer newsession
+ writeTVar (lastHandshakeTime peer) (Just now)
+ return erased
+ unless succeeded $ throwE OutdatedPacketError
+ liftIO $ atomically $ updateEndPoint peer sock
+ return Nothing
+
+processPacket device@Device{..} _key _psk sock PacketData{..} = do
+ peer <- assertJust UnknownIndexError $
+ HM.lookup receiverIndex <$> liftIO (readTVarIO indexMap)
+ outcome <- liftIO $ atomically $ findSession peer receiverIndex
+ now <- liftIO epochTime
+ (isFromResponderWait, session) <- case outcome of
+ Nothing -> throwE OutdatedPacketError
+ Just (Right session) -> return (False, session)
+ Just (Left ResponderWait{..}) -> do
+ newCounter <- liftIO $ atomically $ newTVar 0
+ let newsession = Session respOurIndex respTheirIndex respSessionKey
+ (addTime now (sessionRenewTime + 2 * handshakeRetryTime))
+ (addTime now sessionExpireTime)
+ newCounter
+ return (True, newsession)
+ case decryptMessage (sessionKey session) counter (encryptedPayload, authTag) of
+ Nothing -> throwE DecryptFailureError
+ Just decryptedPayload -> do
+ when isFromResponderWait $ liftIO $ atomically $ do
+ erased <- eraseResponderWait device peer (Just receiverIndex)
+ when erased $ do
+ addSession device peer session
+ writeTVar (lastHandshakeTime peer) (Just now)
+ liftIO $ atomically $ updateEndPoint peer sock
+ if BA.length decryptedPayload /= 0
+ then do
+ parsedPacket <- liftIO $ parseIPPacket decryptedPayload
+ case parsedPacket of
+ InvalidIPPacket -> throwE InvalidIPPacketError
+ IPv4Packet src4 _ -> do
+ peer' <- assertJust SourceAddrBlockedError $
+ RT.lookup (makeAddrRange src4 32) <$> liftIO (readTVarIO routeTable4)
+ when (remotePub peer /= remotePub peer') $ throwE SourceAddrBlockedError
+ IPv6Packet src6 _ -> do
+ peer' <- assertJust SourceAddrBlockedError $
+ RT.lookup (makeAddrRange src6 128) <$> liftIO (readTVarIO routeTable6)
+ when (remotePub peer /= remotePub peer') $ throwE SourceAddrBlockedError
+ liftIO $ atomically $ writeTVar (lastReceiveTime peer) now
+ liftIO $ atomically $ modifyTVar' (receivedBytes peer) (+fromIntegral (BA.length decryptedPayload))
+ else do
+ liftIO $ atomically $ writeTVar (lastKeepaliveTime peer) now
+ return (Just (Right decryptedPayload))
+
+runHeartbeat :: Device -> KeyPair -> PacketQueue UdpPacket -> IO ()
+runHeartbeat device key chan = do
+ psk <- readTVarIO (presharedKey device)
+ now <- epochTime
+ peers' <- readTVarIO (peers device)
+ forM_ peers' $ \peer -> do
+ reinitiate <- atomically $ do
+ miwait <- readTVar (initiatorWait peer)
+ case miwait of
+ Just iwait | now >= initStopTime iwait -> do
+ void $ eraseInitiatorWait device peer Nothing
+ return Nothing
+ Just iwait | now >= initRetryTime iwait -> do
+ void $ eraseInitiatorWait device peer Nothing
+ return (Just (initStopTime iwait))
+ _ -> return Nothing
+ when (isJust reinitiate) $ withJust (readTVarIO (endPoint peer)) $ \endp ->
+ void $ tryInitiateHandshakeIfEmpty device key psk chan peer endp reinitiate
+ atomically $ withJust (readTVar (responderWait peer)) $ \rwait ->
+ when (now >= respStopTime rwait) $ void $ eraseResponderWait device peer Nothing
+ atomically $ filterSessions device peer ((now<).expireTime)
+ lastrecv <- readTVarIO (lastReceiveTime peer)
+ lastsent <- readTVarIO (lastTransferTime peer)
+ lastkeep <- readTVarIO (lastKeepaliveTime peer)
+ when (lastsent < lastrecv && lastrecv <= addTime now (-sessionKeepaliveTime)) $ do
+ atomically $ writeTVar (lastTransferTime peer) now
+ atomically $ writeTVar (lastReceiveTime peer) now
+ withJust (readTVarIO (endPoint peer)) $ \endp ->
+ withJust (getSession peer) $ \session -> do
+ nonce <- atomically $ nextNonce session
+ let (msg, authtag) = encryptMessage (sessionKey session) nonce mempty
+ keepalivePacket = runPut $ buildPacket (error "internal error") $
+ PacketData (theirIndex session) nonce msg authtag
+ atomically $ pushPacketQueue chan (keepalivePacket, endp)
+ when (lastrecv < lastsent && lastkeep < lastsent && lastsent <= addTime now (-(sessionKeepaliveTime + handshakeRetryTime))) $ do
+ atomically $ writeTVar (lastTransferTime peer) now
+ atomically $ writeTVar (lastReceiveTime peer) now
+ withJust (readTVarIO (endPoint peer)) $ \endp ->
+ void $ checkAndTryInitiateHandshake device key psk chan peer endp now
+
+checkAndTryInitiateHandshake :: Device -> KeyPair -> Maybe PresharedKey
+ -> PacketQueue UdpPacket -> Peer -> SockAddr -> Time
+ -> IO Bool
+checkAndTryInitiateHandshake device key psk chan peer@Peer{..} endp now = do
+ initiated <- readAndVerifyStopTime initStopTime initiatorWait (eraseInitiatorWait device peer Nothing)
+ responded <- readAndVerifyStopTime respStopTime responderWait (eraseResponderWait device peer Nothing)
+ if initiated || responded
+ then return False
+ else tryInitiateHandshakeIfEmpty device key psk chan peer endp Nothing
+ where
+ readAndVerifyStopTime getStopTime tvar erase = atomically $ do
+ ma <- readTVar tvar
+ case ma of
+ Just a | now > getStopTime a -> erase >> return False
+ Just _ -> return True
+ Nothing -> return False
+
+
+tryInitiateHandshakeIfEmpty :: Device -> KeyPair -> Maybe PresharedKey
+ -> PacketQueue UdpPacket -> Peer -> SockAddr -> Maybe Time
+ -> IO Bool
+tryInitiateHandshakeIfEmpty device key psk chan peer@Peer{..} endp stopTime = do
+ ekey <- dhGenKey
+ now <- epochTime
+ seed <- randomIO
+ let state0 = newNoiseState key psk ekey (Just remotePub) InitiatorRole
+ Right (payload, state1) = sendFirstMessage state0 timestamp
+ timestamp = BA.convert (genTai64n now)
+ atomically $ do
+ isEmpty <- isNothing <$> readTVar initiatorWait
+ if isEmpty
+ then do
+ index <- acquireEmptyIndex device peer seed
+ let iwait = InitiatorWait index
+ (addTime now handshakeRetryTime)
+ (fromMaybe (addTime now handshakeStopTime) stopTime)
+ state1
+ writeTVar initiatorWait (Just iwait)
+ let packet = runPut $ buildPacket (getMac1 remotePub psk) $
+ HandshakeInitiation index payload
+ void $ tryPushPacketQueue chan $ (packet, endp)
+ return True
+ else return False
+
+genTai64n :: Time -> TAI64n
+genTai64n (CTime now) = runPut $ do
+ putWord64be (fromIntegral now + 4611686018427387914)
+ putWord32be 0
+
+addTime :: Time -> Int -> Time
+addTime (CTime now) secs = CTime (now + fromIntegral secs)
+
+getMac1 :: PublicKey -> Maybe PresharedKey -> BS.ByteString -> BS.ByteString
+getMac1 pub mpsk payload =
+ finalize mac1Length $ update payload $ update (BA.convert (dhPubToBytes pub)) $
+ case mpsk of
+ Nothing -> initialize mac1Length
+ Just psk -> initialize' mac1Length (BA.convert psk)
+
+assertJust :: Monad m => e -> ExceptT e m (Maybe a) -> ExceptT e m a
+assertJust err ma = do
+ res <- ma
+ case res of
+ Just a -> return a
+ Nothing -> throwE err
diff --git a/src/Network/WireGuard/Daemon.hs b/src/Network/WireGuard/Daemon.hs
new file mode 100644
index 0000000..5b3f225
--- /dev/null
+++ b/src/Network/WireGuard/Daemon.hs
@@ -0,0 +1,55 @@
+module Network.WireGuard.Daemon
+ ( runDaemon
+ ) where
+
+import Control.Concurrent.Async (async, cancel)
+import Control.Concurrent.STM (atomically)
+import Control.Monad (void)
+import GHC.Conc.IO (closeFdWith)
+import System.Directory (removeFile)
+import System.Posix.IO (closeFd)
+import System.Posix.Types (Fd)
+
+import Control.Concurrent.MVar
+import System.Posix.Signals
+
+import Network.WireGuard.Core (runCore)
+import Network.WireGuard.Internal.State (createDevice)
+import Network.WireGuard.RPC (runRPC)
+import Network.WireGuard.TunListener (runTunListener)
+import Network.WireGuard.UdpListener (runUdpListener)
+
+import Network.WireGuard.Internal.Constant
+import Network.WireGuard.Internal.PacketQueue
+import Network.WireGuard.Internal.Util
+
+runDaemon :: String -> FilePath -> [Fd] -> IO ()
+runDaemon intfName sockPath tunFds = do
+ device <- atomically $ createDevice intfName
+
+ rpcThread <- async $ runRPC sockPath device
+
+ readTunChan <- atomically $ newPacketQueue maxQueuedTunPackets
+ writeTunChan <- atomically $ newPacketQueue maxQueuedTunPackets
+ tunListenerThread <- async $ runTunListener tunFds readTunChan writeTunChan
+
+ -- TODO: Support per-host packet queue
+ -- TODO: Add timestamp and discard really ancient UDP packets
+ readUdpChan <- atomically $ newPacketQueue maxQueuedUdpPackets
+ writeUdpChan <- atomically $ newPacketQueue maxQueuedUdpPackets
+ udpListenerThread <- async $ runUdpListener device readUdpChan writeUdpChan
+
+ coreThread <- async $ runCore device readTunChan writeTunChan readUdpChan writeUdpChan
+
+ died <- newEmptyMVar
+
+ let dieGracefully = do
+ mapM_ cancel [rpcThread, tunListenerThread, udpListenerThread, coreThread]
+ mapM_ (closeFdWith closeFd) tunFds
+ catchIOExceptionAnd (return ()) (removeFile sockPath)
+ putMVar died ()
+
+ void $ installHandler sigTERM (Catch dieGracefully) Nothing
+ void $ installHandler sigINT (Catch dieGracefully) Nothing
+
+ takeMVar died
diff --git a/src/Network/WireGuard/Foreign/In6Addr.hsc b/src/Network/WireGuard/Foreign/In6Addr.hsc
new file mode 100644
index 0000000..ef2cb32
--- /dev/null
+++ b/src/Network/WireGuard/Foreign/In6Addr.hsc
@@ -0,0 +1,90 @@
+--
+-- Copyright (c) 2002-2010, The University Court of the University of Glasgow.
+-- Copyright (c) 2007-2010, Johan Tibell
+--
+-- Redistribution and use in source and binary forms, with or without
+-- modification, are permitted provided that the following conditions are met:
+--
+-- - Redistributions of source code must retain the above copyright notice,
+-- this list of conditions and the following disclaimer.
+--
+-- - Redistributions in binary form must reproduce the above copyright notice,
+-- this list of conditions and the following disclaimer in the documentation
+-- and/or other materials provided with the distribution.
+--
+-- - Neither name of the University nor the names of its contributors may be
+-- used to endorse or promote products derived from this software without
+-- specific prior written permission.
+--
+-- THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY COURT OF THE UNIVERSITY OF
+-- GLASGOW AND THE CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+-- INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+-- FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+-- UNIVERSITY COURT OF THE UNIVERSITY OF GLASGOW OR THE CONTRIBUTORS BE LIABLE
+-- FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+-- DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+-- SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+-- CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+-- LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+-- OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+-- DAMAGE.
+--
+
+module Network.WireGuard.Foreign.In6Addr
+ ( In6Addr(..)
+ ) where
+
+import Foreign
+import Network.Socket.Internal
+
+#include "uapi.h"
+
+-- Extracted from network:Network/Socket/Types.hsc, with some modification.
+
+-- The peek32 and poke32 functions work around the fact that the RFCs
+-- don't require 32-bit-wide address fields to be present. We can
+-- only portably rely on an 8-bit field, s6_addr.
+
+s6_addr_offset :: Int
+s6_addr_offset = (#offset struct in6_addr, s6_addr)
+
+peek32 :: Ptr a -> Int -> IO Word32
+peek32 p i0 = do
+ let i' = i0 * 4
+ peekByte n = peekByteOff p (s6_addr_offset + i' + n) :: IO Word8
+ a `sl` i = fromIntegral a `shiftL` i
+ a0 <- peekByte 0
+ a1 <- peekByte 1
+ a2 <- peekByte 2
+ a3 <- peekByte 3
+ return ((a0 `sl` 24) .|. (a1 `sl` 16) .|. (a2 `sl` 8) .|. (a3 `sl` 0))
+
+poke32 :: Ptr a -> Int -> Word32 -> IO ()
+poke32 p i0 a = do
+ let i' = i0 * 4
+ pokeByte n = pokeByteOff p (s6_addr_offset + i' + n)
+ x `sr` i = fromIntegral (x `shiftR` i) :: Word8
+ pokeByte 0 (a `sr` 24)
+ pokeByte 1 (a `sr` 16)
+ pokeByte 2 (a `sr` 8)
+ pokeByte 3 (a `sr` 0)
+
+-- | Private newtype proxy for the Storable instance. To avoid orphan instances.
+newtype In6Addr = In6Addr { fromIn6Addr :: HostAddress6 }
+
+instance Storable In6Addr where
+ sizeOf _ = #const sizeof(struct in6_addr)
+ alignment _ = #alignment struct in6_addr
+
+ peek p = do
+ a <- peek32 p 0
+ b <- peek32 p 1
+ c <- peek32 p 2
+ d <- peek32 p 3
+ return $ In6Addr (a, b, c, d)
+
+ poke p (In6Addr (a, b, c, d)) = do
+ poke32 p 0 a
+ poke32 p 1 b
+ poke32 p 2 c
+ poke32 p 3 d
diff --git a/src/Network/WireGuard/Foreign/Key.hs b/src/Network/WireGuard/Foreign/Key.hs
new file mode 100644
index 0000000..2a0e7b8
--- /dev/null
+++ b/src/Network/WireGuard/Foreign/Key.hs
@@ -0,0 +1,29 @@
+module Network.WireGuard.Foreign.Key
+ ( Key
+ , fromByteString
+ , toByteString
+ ) where
+
+import qualified Data.ByteString as BS
+
+import Foreign
+
+import Network.WireGuard.Internal.Constant (keyLength)
+
+newtype Key = Key { fromKey :: [Word8] }
+
+instance Storable Key where
+ sizeOf _ = sizeOf (undefined :: Word8) * keyLength
+ alignment _ = alignment (undefined :: Word8)
+ peek ptr = Key <$> peekArray keyLength (castPtr ptr)
+ poke ptr (Key k)
+ | length k == keyLength = pokeArray (castPtr ptr) k
+ | otherwise = error "Key.poke: key length mismatch"
+
+fromByteString :: BS.ByteString -> Key
+fromByteString bs
+ | BS.length bs == keyLength = Key (BS.unpack bs)
+ | otherwise = error "Key.fromByteString: key length mismatch"
+
+toByteString :: Key -> BS.ByteString
+toByteString = BS.pack . fromKey
diff --git a/src/Network/WireGuard/Foreign/Tun.hs b/src/Network/WireGuard/Foreign/Tun.hs
new file mode 100644
index 0000000..c2b3a46
--- /dev/null
+++ b/src/Network/WireGuard/Foreign/Tun.hs
@@ -0,0 +1,45 @@
+{-# LANGUAGE CPP #-}
+
+module Network.WireGuard.Foreign.Tun
+ ( openTun
+ , fdReadBuf
+ , fdWriteBuf
+ ) where
+
+import System.Posix.Types (Fd (..))
+
+import Foreign
+import Foreign.C
+
+#ifdef OS_LINUX
+import System.Posix.IO (fdReadBuf, fdWriteBuf)
+#endif
+
+openTun :: String -> Int -> IO (Maybe [Fd])
+openTun intfName threads =
+ withCString intfName $ \intf_name_c ->
+ allocaArray threads $ \fds_c -> do
+ res <- tun_alloc_c intf_name_c (fromIntegral threads) fds_c -- TODO: handle exception
+ if res > 0
+ then Just . map Fd <$> peekArray (fromIntegral res) fds_c
+ else return Nothing
+
+foreign import ccall safe "tun.h tun_alloc" tun_alloc_c :: CString -> CInt -> Ptr CInt -> IO CInt
+
+#ifdef OS_MACOS
+fdReadBuf :: Fd -> Ptr Word8 -> CSize -> IO CSize
+fdReadBuf _fd _buf 0 = return 0
+fdReadBuf fd buf nbytes =
+ fmap fromIntegral $
+ throwErrnoIfMinus1Retry "fdReadBuf" $
+ utun_read_c (fromIntegral fd) (castPtr buf) nbytes
+
+fdWriteBuf :: Fd -> Ptr Word8 -> CSize -> IO CSize
+fdWriteBuf fd buf len =
+ fmap fromIntegral $
+ throwErrnoIfMinus1Retry "fdWriteBuf" $
+ utun_write_c (fromIntegral fd) (castPtr buf) len
+
+foreign import ccall safe "tun.h utun_read" utun_read_c :: CInt -> Ptr CChar -> CSize -> IO CSize
+foreign import ccall safe "tun.h utun_write" utun_write_c :: CInt -> Ptr CChar -> CSize -> IO CSize
+#endif
diff --git a/src/Network/WireGuard/Foreign/UAPI.hsc b/src/Network/WireGuard/Foreign/UAPI.hsc
new file mode 100644
index 0000000..b3e2948
--- /dev/null
+++ b/src/Network/WireGuard/Foreign/UAPI.hsc
@@ -0,0 +1,172 @@
+{-# LANGUAGE RecordWildCards #-}
+{-# OPTIONS_GHC -fno-warn-missing-signatures #-}
+
+module Network.WireGuard.Foreign.UAPI
+ ( WgIpmask(..)
+ , PeerFlags
+ , peerFlagRemoveMe
+ , peerFlagReplaceIpmasks
+ , WgPeer(..)
+ , DeviceFlags
+ , deviceFlagReplacePeers
+ , deviceFlagRemovePrivateKey
+ , deviceFlagRemovePresharedKey
+ , deviceFlagRemoveFwmark
+ , WgDevice(..)
+ , readConfig
+ , writeConfig
+ ) where
+
+import Data.ByteString.Internal (ByteString (..))
+import Network.Socket.Internal (HostAddress, HostAddress6,
+ SockAddr, peekSockAddr,
+ pokeSockAddr)
+import System.IO.Unsafe (unsafePerformIO)
+
+import Data.Char
+import Data.Int
+import Data.Word
+import Foreign
+import Foreign.C.String
+
+import qualified Network.WireGuard.Foreign.Key as K
+import Network.WireGuard.Internal.Util (zeroMemory)
+
+import Network.WireGuard.Foreign.In6Addr
+
+#include "uapi.h"
+
+data WgIpmask = WgIpmask
+ { ipmaskIp :: ! (Either HostAddress HostAddress6)
+ , ipmaskCidr :: ! #{type typeof((struct wgipmask){0}.cidr)}
+ }
+
+type PeerFlags = #{type typeof((struct wgpeer){0}.flags)}
+
+peerFlagRemoveMe = #{const WGPEER_REMOVE_ME} :: PeerFlags
+peerFlagReplaceIpmasks = #{const WGPEER_REPLACE_IPMASKS} :: PeerFlags
+
+data WgPeer = WgPeer
+ { peerPubKey :: ! ByteString -- TODO: use Bytes
+ , peerFlags :: ! PeerFlags
+ , peerAddr :: ! (Maybe SockAddr)
+ , peerLastHandshakeTime :: ! #{type typeof((struct wgpeer){0}.last_handshake_time.tv_sec)}
+ , peerReceivedBytes :: ! #{type typeof((struct wgpeer){0}.rx_bytes)}
+ , peerTransferredBytes :: ! #{type typeof((struct wgpeer){0}.tx_bytes)}
+ , peerKeepaliveInterval :: ! #{type typeof((struct wgpeer){0}.persistent_keepalive_interval)}
+ , peerNumIpmasks :: ! #{type typeof((struct wgpeer){0}.num_ipmasks)}
+ }
+
+type DeviceFlags = #{type typeof((struct wgdevice){0}.flags)}
+
+deviceFlagReplacePeers = #{const WGDEVICE_REPLACE_PEERS} :: DeviceFlags
+deviceFlagRemovePrivateKey = #{const WGDEVICE_REMOVE_PRIVATE_KEY} :: DeviceFlags
+deviceFlagRemovePresharedKey = #{const WGDEVICE_REMOVE_PRESHARED_KEY} :: DeviceFlags
+deviceFlagRemoveFwmark = #{const WGDEVICE_REMOVE_FWMARK} :: DeviceFlags
+
+data WgDevice = WgDevice
+ { deviceInterface :: ! String
+ , deviceFlags :: ! DeviceFlags
+ , devicePubkey :: ! ByteString -- TODO: use Bytes
+ , devicePrivkey :: ! ByteString -- TODO: use ScrubbedBytes
+ , devicePSK :: ! ByteString -- TODO: use ScrubbedBytes
+ , deviceFwmark :: ! #{type typeof((struct wgdevice){0}.fwmark)}
+ , devicePort :: ! #{type typeof((struct wgdevice){0}.port)}
+ , deviceNumPeers :: ! #{type typeof((struct wgdevice){0}.num_peers)}
+ }
+
+type IpmaskIpFamilyType = #{type typeof((struct wgipmask){0}.family)}
+
+instance Storable WgIpmask where
+ sizeOf _ = #{size struct wgipmask}
+ alignment _ = #{alignment struct wgipmask}
+ peek ptr = do
+ ipFamily <- #{peek struct wgipmask, family} ptr :: IO IpmaskIpFamilyType
+ ip <- case ipFamily of
+ #{const AF_INET} -> Left <$> #{peek struct wgipmask, ip4.s_addr} ptr
+ #{const AF_INET6} -> Right . fromIn6Addr <$> #{peek struct wgipmask, ip6} ptr
+ _ -> error "WgIpmask.peek: unknown ipfamily"
+ cidr <- #{peek struct wgipmask, cidr} ptr
+ return (WgIpmask ip cidr)
+
+ poke ptr self@WgIpmask{..} = do
+ zeroMemory ptr $ fromIntegral $ sizeOf self
+ case ipmaskIp of
+ Left ip4 -> do
+ #{poke struct wgipmask, family} ptr (#{const AF_INET} :: IpmaskIpFamilyType)
+ #{poke struct wgipmask, ip4.s_addr} ptr ip4
+ Right ip6 -> do
+ #{poke struct wgipmask, family} ptr (#{const AF_INET6} :: IpmaskIpFamilyType)
+ #{poke struct wgipmask, ip6} ptr (In6Addr ip6)
+ #{poke struct wgipmask, cidr} ptr ipmaskCidr
+
+type IpFamilyType = #{type sa_family_t}
+
+sockaddrOffset = #{offset struct wgpeer, endpoint.addr}
+ipfamilyOffset = #{offset struct wgpeer, endpoint.addr.sa_family}
+
+instance Storable WgPeer where
+ sizeOf _ = #{size struct wgpeer}
+ alignment _ = #{alignment struct wgpeer}
+ peek ptr = do
+ ipfamily <- peek (ptr `plusPtr` ipfamilyOffset) :: IO IpFamilyType
+ let sockaddrM = case ipfamily of
+ 0 -> return Nothing
+ _ -> Just <$> peekSockAddr (ptr `plusPtr` sockaddrOffset)
+ WgPeer <$> (K.toByteString <$> #{peek struct wgpeer, public_key} ptr)
+ <*> #{peek struct wgpeer, flags} ptr
+ <*> sockaddrM
+ <*> #{peek struct wgpeer, last_handshake_time.tv_sec} ptr
+ <*> #{peek struct wgpeer, rx_bytes} ptr
+ <*> #{peek struct wgpeer, tx_bytes} ptr
+ <*> #{peek struct wgpeer, persistent_keepalive_interval} ptr
+ <*> #{peek struct wgpeer, num_ipmasks} ptr
+ poke ptr self@WgPeer{..} = do
+ zeroMemory ptr $ fromIntegral $ sizeOf self
+ #{poke struct wgpeer, public_key} ptr (K.fromByteString peerPubKey)
+ #{poke struct wgpeer, flags} ptr peerFlags
+ case peerAddr of
+ Just addr -> pokeSockAddr (ptr `plusPtr` sockaddrOffset) addr
+ Nothing -> poke (ptr `plusPtr` ipfamilyOffset) (0 :: IpFamilyType)
+ #{poke struct wgpeer, last_handshake_time.tv_sec} ptr peerLastHandshakeTime
+ #{poke struct wgpeer, rx_bytes} ptr peerReceivedBytes
+ #{poke struct wgpeer, tx_bytes} ptr peerTransferredBytes
+ #{poke struct wgpeer, persistent_keepalive_interval} ptr peerKeepaliveInterval
+ #{poke struct wgpeer, num_ipmasks} ptr peerNumIpmasks
+
+instance Storable WgDevice where
+ sizeOf _ = #{size struct wgdevice}
+ alignment _ = #{alignment struct wgdevice}
+ peek ptr = WgDevice <$> peekCString (ptr `plusPtr` #{offset struct wgdevice, interface})
+ <*> #{peek struct wgdevice, flags} ptr
+ <*> (K.toByteString <$> #{peek struct wgdevice, public_key} ptr)
+ <*> (K.toByteString <$> #{peek struct wgdevice, private_key} ptr)
+ <*> (K.toByteString <$> #{peek struct wgdevice, preshared_key} ptr)
+ <*> #{peek struct wgdevice, fwmark} ptr
+ <*> #{peek struct wgdevice, port} ptr
+ <*> #{peek struct wgdevice, num_peers} ptr
+ poke ptr self@WgDevice{..}
+ | length deviceInterface >= #{const IFNAMSIZ} = error "interface name is too long"
+ | otherwise = do
+ zeroMemory ptr $ fromIntegral $ sizeOf self
+ pokeArray0 (0 :: Word8) (ptr `plusPtr` #{offset struct wgdevice, interface}) (map (fromIntegral.ord) deviceInterface)
+ #{poke struct wgdevice, flags} ptr deviceFlags
+ #{poke struct wgdevice, public_key} ptr (K.fromByteString devicePubkey)
+ #{poke struct wgdevice, private_key} ptr (K.fromByteString devicePrivkey)
+ #{poke struct wgdevice, preshared_key} ptr (K.fromByteString devicePSK)
+ #{poke struct wgdevice, fwmark} ptr deviceFwmark
+ #{poke struct wgdevice, port} ptr devicePort
+ #{poke struct wgdevice, num_peers} ptr deviceNumPeers
+
+readConfig :: Storable a => ByteString -> a
+readConfig (PS fptr off len)
+ | len == sizeOf output = output
+ | otherwise = error "UAPI.readConfig: length mismatch"
+ where
+ output = unsafePerformIO $ withForeignPtr fptr $ \ptr -> peek (ptr `plusPtr` off)
+
+writeConfig :: Storable a => a -> ByteString
+writeConfig input = unsafePerformIO $ do
+ fptr <- mallocForeignPtr
+ withForeignPtr fptr $ \ptr -> poke ptr input
+ return $ PS (castForeignPtr fptr) 0 (sizeOf input)
diff --git a/src/Network/WireGuard/Internal/Constant.hs b/src/Network/WireGuard/Internal/Constant.hs
new file mode 100644
index 0000000..c615a0f
--- /dev/null
+++ b/src/Network/WireGuard/Internal/Constant.hs
@@ -0,0 +1,55 @@
+module Network.WireGuard.Internal.Constant where
+
+authLength :: Int
+authLength = 16
+
+aeadLength :: Int -> Int
+aeadLength payload = payload + authLength
+
+keyLength :: Int
+keyLength = 32
+
+timestampLength :: Int
+timestampLength = 12
+
+mac1Length :: Int
+mac1Length = 16
+
+mac2Length :: Int
+mac2Length = 16
+
+maxQueuedUdpPackets :: Int
+maxQueuedUdpPackets = 4096
+
+maxQueuedTunPackets :: Int
+maxQueuedTunPackets = 4096
+
+udpReadBufferLength :: Int
+udpReadBufferLength = 4096
+
+tunReadBufferLength :: Int
+tunReadBufferLength = 4096
+
+retryMaxWaitTime :: Int
+retryMaxWaitTime = 5 * 1000000 -- 5 seconds
+
+handshakeRetryTime :: Int
+handshakeRetryTime = 5
+
+handshakeStopTime :: Int
+handshakeStopTime = 90
+
+sessionRenewTime :: Int
+sessionRenewTime = 120
+
+sessionExpireTime :: Int
+sessionExpireTime = 180
+
+sessionKeepaliveTime :: Int
+sessionKeepaliveTime = 10
+
+maxActiveSessions :: Int
+maxActiveSessions = 2
+
+heartbeatWaitTime :: Int
+heartbeatWaitTime = 250 * 1000 -- 0.25 second
diff --git a/src/Network/WireGuard/Internal/IPPacket.hs b/src/Network/WireGuard/Internal/IPPacket.hs
new file mode 100644
index 0000000..56f4461
--- /dev/null
+++ b/src/Network/WireGuard/Internal/IPPacket.hs
@@ -0,0 +1,56 @@
+module Network.WireGuard.Internal.IPPacket
+ ( IPPacket(..)
+ , parseIPPacket
+ ) where
+
+import qualified Data.ByteArray as BA
+import Data.IP (IPv4, IPv6, fromHostAddress,
+ fromHostAddress6)
+import Foreign.Ptr (Ptr)
+import Foreign.Storable (peekByteOff)
+
+import Data.Bits
+import Data.Word
+
+data IPPacket = InvalidIPPacket
+ | IPv4Packet { src4 :: IPv4, dest4 :: IPv4 }
+ | IPv6Packet { src6 :: IPv6, dest6 :: IPv6 }
+
+parseIPPacket :: BA.ByteArrayAccess ba => ba -> IO IPPacket
+parseIPPacket packet | BA.length packet < 20 = return InvalidIPPacket
+parseIPPacket packet = BA.withByteArray packet $ \ptr -> do
+ firstByte <- peekByteOff ptr 0 :: IO Word8
+ let version = firstByte `shiftR` 4
+ parse4 = do
+ s4 <- peekByteOff ptr 12
+ d4 <- peekByteOff ptr 16
+ return (IPv4Packet (fromHostAddress s4) (fromHostAddress d4))
+ parse6
+ | BA.length packet < 40 = return InvalidIPPacket
+ | otherwise = do
+ s6a <- peek32be ptr 8
+ s6b <- peek32be ptr 12
+ s6c <- peek32be ptr 16
+ s6d <- peek32be ptr 20
+ d6a <- peek32be ptr 24
+ d6b <- peek32be ptr 28
+ d6c <- peek32be ptr 32
+ d6d <- peek32be ptr 36
+ let s6 = (s6a, s6b, s6c, s6d)
+ d6 = (d6a, d6b, d6c, d6d)
+ return (IPv6Packet (fromHostAddress6 s6) (fromHostAddress6 d6))
+ case version of
+ 4 -> parse4
+ 6 -> parse6
+ _ -> return InvalidIPPacket
+
+peek32be :: Ptr a -> Int -> IO Word32
+peek32be ptr offset = do
+ a <- peekByteOff ptr offset :: IO Word8
+ b <- peekByteOff ptr (offset + 1) :: IO Word8
+ c <- peekByteOff ptr (offset + 2) :: IO Word8
+ d <- peekByteOff ptr (offset + 3) :: IO Word8
+ return $! (fromIntegral a `unsafeShiftL` 24) .|.
+ (fromIntegral b `unsafeShiftL` 16) .|.
+ (fromIntegral c `unsafeShiftL` 8) .|.
+ fromIntegral d
diff --git a/src/Network/WireGuard/Internal/Noise.hs b/src/Network/WireGuard/Internal/Noise.hs
new file mode 100644
index 0000000..b529d25
--- /dev/null
+++ b/src/Network/WireGuard/Internal/Noise.hs
@@ -0,0 +1,98 @@
+{-# LANGUAGE OverloadedStrings #-}
+module Network.WireGuard.Internal.Noise
+ ( NoiseStateWG
+ , newNoiseState
+ , sendFirstMessage
+ , recvFirstMessageAndReply
+ , recvSecondMessage
+ , encryptMessage
+ , decryptMessage
+ ) where
+
+import Control.Exception (SomeException)
+import Control.Lens ((&), (.~), (^.))
+import Control.Monad (unless)
+import Control.Monad.Catch (throwM)
+import qualified Crypto.Cipher.ChaChaPoly1305 as CCP
+import Crypto.Error (throwCryptoError)
+import Crypto.Noise.Cipher (cipherSymToBytes)
+import Crypto.Noise.Cipher.ChaChaPoly1305 (ChaChaPoly1305)
+import Crypto.Noise.DH.Curve25519 (Curve25519)
+import Crypto.Noise.HandshakePatterns (noiseIK)
+import Crypto.Noise.Hash.BLAKE2s (BLAKE2s)
+import Crypto.Noise.Internal.CipherState (csk)
+import Crypto.Noise.Internal.NoiseState (nsReceivingCipherState,
+ nsSendingCipherState)
+import Data.ByteArray (ScrubbedBytes, convert)
+import Data.ByteString (ByteString)
+import qualified Data.ByteString as BS
+import Data.Maybe (fromJust)
+import Data.Serialize (putWord64le, runPut)
+
+import Crypto.Noise
+
+import Network.WireGuard.Internal.Types
+
+type NoiseStateWG = NoiseState ChaChaPoly1305 Curve25519 BLAKE2s
+
+newNoiseState :: KeyPair -> Maybe PresharedKey -> KeyPair -> Maybe PublicKey -> HandshakeRole -> NoiseStateWG
+newNoiseState staticKey presharedKey ephemeralKey remotePub role =
+ noiseState $ defaultHandshakeOpts noiseIK role
+ & hoPrologue .~ "WireGuard v0 zx2c4 Jason@zx2c4.com"
+ & hoLocalStatic .~ Just staticKey
+ & hoPreSharedKey .~ presharedKey
+ & hoRemoteStatic .~ remotePub
+ & hoLocalEphemeral .~ Just ephemeralKey
+
+sendFirstMessage :: NoiseStateWG -> ScrubbedBytes
+ -> Either SomeException (ByteString, NoiseStateWG)
+sendFirstMessage state0 plaintext1 = writeMessage state0 plaintext1
+
+recvFirstMessageAndReply :: NoiseStateWG -> ByteString -> ScrubbedBytes
+ -> Either SomeException (ByteString, ScrubbedBytes, PublicKey, SessionKey)
+recvFirstMessageAndReply state0 ciphertext1 plaintext2 = do
+ (plaintext1, state1) <- readMessage state0 ciphertext1
+ (ciphertext2, state2) <- writeMessage state1 plaintext2
+ unless (handshakeComplete state2) internalError
+ case remoteStaticKey state2 of
+ Nothing -> internalError
+ Just rpub -> return (ciphertext2, plaintext1, rpub, extractSessionKey state2)
+
+recvSecondMessage :: NoiseStateWG -> ByteString
+ -> Either SomeException (ScrubbedBytes, PublicKey, SessionKey)
+recvSecondMessage state1 ciphertext2 = do
+ (plaintext2, state2) <- readMessage state1 ciphertext2
+ unless (handshakeComplete state2) internalError
+ case remoteStaticKey state2 of
+ Nothing -> internalError
+ Just rpub -> return (plaintext2, rpub, extractSessionKey state2)
+
+encryptMessage :: SessionKey -> Counter -> ScrubbedBytes -> (EncryptedPayload, AuthTag)
+encryptMessage key counter plaintext = (ciphertext, convert authtag)
+ where
+ st0 = throwCryptoError (CCP.initialize (sendKey key) (getNonce counter))
+ (ciphertext, st) = CCP.encrypt (convert plaintext) st0
+ authtag = CCP.finalize st
+
+decryptMessage :: SessionKey -> Counter -> (EncryptedPayload, AuthTag) -> Maybe ScrubbedBytes
+decryptMessage key counter (ciphertext, authtag)
+ | authtag == authtagExpected = Just (convert plaintext)
+ | otherwise = Nothing
+ where
+ st0 = throwCryptoError (CCP.initialize (recvKey key) (getNonce counter))
+ (plaintext, st) = CCP.decrypt ciphertext st0
+ authtagExpected = convert $ CCP.finalize st
+
+getNonce :: Counter -> CCP.Nonce
+getNonce counter = throwCryptoError (CCP.nonce8 constant iv)
+ where
+ constant = BS.replicate 4 0
+ iv = runPut (putWord64le counter)
+
+extractSessionKey :: NoiseStateWG -> SessionKey
+extractSessionKey ns =
+ SessionKey (cipherSymToBytes $ fromJust (ns ^. nsSendingCipherState) ^. csk)
+ (cipherSymToBytes $ fromJust (ns ^. nsReceivingCipherState) ^. csk)
+
+internalError :: Either SomeException a
+internalError = throwM (InvalidHandshakeOptions "internal error")
diff --git a/src/Network/WireGuard/Internal/Packet.hs b/src/Network/WireGuard/Internal/Packet.hs
new file mode 100644
index 0000000..ebc24fc
--- /dev/null
+++ b/src/Network/WireGuard/Internal/Packet.hs
@@ -0,0 +1,112 @@
+{-# LANGUAGE RecordWildCards #-}
+
+module Network.WireGuard.Internal.Packet
+ ( Packet(..)
+ , parsePacket
+ , buildPacket
+ ) where
+
+import Control.Monad (replicateM_, unless, when)
+import qualified Data.ByteString as BS
+import Foreign.Storable (sizeOf)
+
+import Data.Serialize
+
+import Network.WireGuard.Internal.Constant
+import Network.WireGuard.Internal.Types
+
+data Packet = HandshakeInitiation
+ { senderIndex :: !Index
+ , encryptedPayload :: !EncryptedPayload
+ }
+ | HandshakeResponse
+ { senderIndex :: !Index
+ , receiverIndex :: !Index
+ , encryptedPayload :: !EncryptedPayload
+ }
+ | PacketData
+ { receiverIndex :: !Index
+ , counter :: !Counter
+ , encryptedPayload :: !EncryptedPayload
+ , authTag :: !AuthTag
+ }
+ deriving (Show)
+
+parsePacket :: (BS.ByteString -> BS.ByteString) -> Get Packet
+parsePacket getMac1 = do
+ packetType <- lookAhead getWord8
+ case packetType of
+ 1 -> verifyLength (==handshakeInitiationPacketLength) $ verifyMac getMac1 parseHandshakeInitiation
+ 2 -> verifyLength (==handshakeResponsePacketLength) $ verifyMac getMac1 parseHandshakeResponse
+ 4 -> verifyLength (>=packetDataMinimumPacketLength) parsePacketData
+ _ -> fail "unknown packet"
+ where
+ handshakeInitiationPacketLength = 4 + indexSize + keyLength + aeadLength keyLength + aeadLength timestampLength + mac1Length + mac2Length
+ handshakeResponsePacketLength = 4 + indexSize + indexSize + keyLength + aeadLength 0 + mac1Length + mac2Length
+ packetDataMinimumPacketLength = 4 + indexSize + counterSize + aeadLength 0
+
+ indexSize = sizeOf (undefined :: Index)
+ counterSize = sizeOf (undefined :: Counter)
+
+parseHandshakeInitiation :: Get Packet
+parseHandshakeInitiation = do
+ skip 4
+ HandshakeInitiation <$> getWord32le <*> (remaining >>= getBytes)
+
+parseHandshakeResponse :: Get Packet
+parseHandshakeResponse = do
+ skip 4
+ HandshakeResponse <$> getWord32le <*> getWord32le <*> (remaining >>= getBytes)
+
+parsePacketData :: Get Packet
+parsePacketData = do
+ skip 4
+ PacketData <$> getWord32le <*> getWord64le <*>
+ (remaining >>= getBytes . subtract authLength) <*> getBytes authLength
+
+buildPacket :: (BS.ByteString -> BS.ByteString) -> Putter Packet
+buildPacket getMac1 HandshakeInitiation{..} = appendMac getMac1 $ do
+ putWord8 1
+ replicateM_ 3 (putWord8 0)
+ putWord32le senderIndex
+ putByteString encryptedPayload
+
+buildPacket getMac1 HandshakeResponse{..} = appendMac getMac1 $ do
+ putWord8 2
+ replicateM_ 3 (putWord8 0)
+ putWord32le senderIndex
+ putWord32le receiverIndex
+ putByteString encryptedPayload
+
+buildPacket _getMac1 PacketData{..} = do
+ putWord8 4
+ replicateM_ 3 (putWord8 0)
+ putWord32le receiverIndex
+ putWord64le counter
+ putByteString encryptedPayload
+ putByteString authTag
+
+verifyLength :: (Int -> Bool) -> Get a -> Get a
+verifyLength check ga = do
+ outcome <- check <$> remaining
+ unless outcome $ fail "wrong packet length"
+ ga
+
+verifyMac :: (BS.ByteString -> BS.ByteString) -> Get Packet -> Get Packet
+verifyMac getMac1 ga = do
+ bodyLength <- subtract (mac1Length + mac2Length) <$> remaining
+ when (bodyLength < 0) $ fail "packet too small"
+ expectedMac1 <- getMac1 <$> lookAhead (getBytes bodyLength)
+ parsed <- isolate bodyLength ga
+ receivedMac1 <- getBytes mac1Length
+ when (expectedMac1 /= receivedMac1) $ fail "wrong mac1"
+ skip mac2Length
+ return parsed
+
+appendMac :: (BS.ByteString -> BS.ByteString) -> Put -> Put
+appendMac getMac1 p = do
+ -- TODO: find a smart approach to avoid extra ByteString allocation
+ let bs = runPut p
+ putByteString bs
+ putByteString (getMac1 bs)
+ replicateM_ mac2Length (putWord8 0)
diff --git a/src/Network/WireGuard/Internal/PacketQueue.hs b/src/Network/WireGuard/Internal/PacketQueue.hs
new file mode 100644
index 0000000..bc390f8
--- /dev/null
+++ b/src/Network/WireGuard/Internal/PacketQueue.hs
@@ -0,0 +1,49 @@
+{-# LANGUAGE RecordWildCards #-}
+
+module Network.WireGuard.Internal.PacketQueue
+ ( PacketQueue
+ , newPacketQueue
+ , popPacketQueue
+ , pushPacketQueue
+ , tryPushPacketQueue
+ ) where
+
+import Control.Concurrent.STM
+
+data PacketQueue packet = PacketQueue
+ { tqueue :: TQueue packet
+ , allowance :: TVar Int
+ }
+
+-- | Create a new PacketQueue with size limit of |maxQueuedPackets|.
+newPacketQueue :: Int -> STM (PacketQueue packet)
+newPacketQueue maxQueuedPackets = PacketQueue <$> newTQueue <*> newTVar maxQueuedPackets
+
+-- | Pop a packet out from the queue, blocks if no packet is available.
+popPacketQueue :: PacketQueue packet -> STM packet
+popPacketQueue PacketQueue{..} = do
+ packet <- readTQueue tqueue
+ modifyTVar' allowance (+1)
+ return packet
+
+-- | Push a packet into the queue. Blocks if it's full.
+pushPacketQueue :: PacketQueue packet -> packet -> STM ()
+pushPacketQueue PacketQueue{..} packet = do
+ allowance' <- readTVar allowance
+ if allowance' <= 0
+ then retry
+ else do
+ writeTQueue tqueue packet
+ writeTVar allowance (allowance' - 1)
+
+-- | Try to push a packet into the queue. Returns True if it's pushed.
+tryPushPacketQueue :: PacketQueue packet -> packet -> STM Bool
+tryPushPacketQueue PacketQueue{..} packet = do
+ allowance' <- readTVar allowance
+ if allowance' <= 0
+ then return False
+ else do
+ writeTQueue tqueue packet
+ writeTVar allowance (allowance' - 1)
+ return True
+
diff --git a/src/Network/WireGuard/Internal/State.hs b/src/Network/WireGuard/Internal/State.hs
new file mode 100644
index 0000000..38866e8
--- /dev/null
+++ b/src/Network/WireGuard/Internal/State.hs
@@ -0,0 +1,242 @@
+{-# LANGUAGE RecordWildCards #-}
+{-# LANGUAGE TupleSections #-}
+
+module Network.WireGuard.Internal.State
+ ( PeerId
+ , Device(..)
+ , Peer(..)
+ , InitiatorWait(..)
+ , ResponderWait(..)
+ , Session(..)
+ , createDevice
+ , createPeer
+ , invalidateSessions
+ , buildRouteTables
+ , acquireEmptyIndex
+ , removeIndex
+ , nextNonce
+ , eraseInitiatorWait
+ , eraseResponderWait
+ , getSession
+ , waitForSession
+ , findSession
+ , addSession
+ , filterSessions
+ , updateTai64n
+ , updateEndPoint
+ ) where
+
+import Control.Monad (forM, when)
+import Crypto.Noise (NoiseState)
+import Crypto.Noise.Cipher.ChaChaPoly1305 (ChaChaPoly1305)
+import Crypto.Noise.DH.Curve25519 (Curve25519)
+import Crypto.Noise.Hash.BLAKE2s (BLAKE2s)
+import qualified Data.HashMap.Strict as HM
+import Data.IP (IPRange (..), IPv4, IPv6)
+import qualified Data.IP.RouteTable as RT
+import Data.Maybe (catMaybes, fromJust,
+ isNothing, mapMaybe)
+import Data.Word
+import Network.Socket.Internal (SockAddr)
+
+import Control.Concurrent.STM
+
+import Network.WireGuard.Internal.Constant
+import Network.WireGuard.Internal.Types
+
+data Device = Device
+ { intfName :: String
+ , localKey :: TVar (Maybe KeyPair)
+ , presharedKey :: TVar (Maybe PresharedKey)
+ , fwmark :: TVar Word
+ , port :: TVar Int
+ , peers :: TVar (HM.HashMap PeerId Peer)
+ , routeTable4 :: TVar (RT.IPRTable IPv4 Peer)
+ , routeTable6 :: TVar (RT.IPRTable IPv6 Peer)
+ , indexMap :: TVar (HM.HashMap Index Peer)
+ }
+
+data Peer = Peer
+ { remotePub :: !PublicKey
+ , ipmasks :: TVar [IPRange]
+ , endPoint :: TVar (Maybe SockAddr)
+ , lastHandshakeTime :: TVar (Maybe Time)
+ , receivedBytes :: TVar Word64
+ , transferredBytes :: TVar Word64
+ , keepaliveInterval :: TVar Int
+ , initiatorWait :: TVar (Maybe InitiatorWait)
+ , responderWait :: TVar (Maybe ResponderWait)
+ , sessions :: TVar [Session] -- last two active sessions
+ , lastTai64n :: TVar TAI64n
+ , lastReceiveTime :: TVar Time
+ , lastTransferTime :: TVar Time
+ , lastKeepaliveTime :: TVar Time
+ }
+
+data InitiatorWait = InitiatorWait
+ { initOurIndex :: !Index
+ , initRetryTime :: !Time
+ , initStopTime :: !Time
+ , initNoise :: !(NoiseState ChaChaPoly1305 Curve25519 BLAKE2s)
+ }
+
+data ResponderWait = ResponderWait
+ { respOurIndex :: !Index
+ , respTheirIndex :: !Index
+ , respStopTime :: !Time
+ , respSessionKey :: !SessionKey
+ }
+
+data Session = Session
+ { ourIndex :: !Index
+ , theirIndex :: !Index
+ , sessionKey :: !SessionKey
+ , renewTime :: !Time
+ , expireTime :: !Time
+ , sessionCounter :: TVar Counter
+ -- TODO: avoid nonce reuse from remote peer
+ }
+
+createDevice :: String -> STM Device
+createDevice intf = Device intf <$> newTVar Nothing
+ <*> newTVar Nothing
+ <*> newTVar 0
+ <*> newTVar 0
+ <*> newTVar HM.empty
+ <*> newTVar RT.empty
+ <*> newTVar RT.empty
+ <*> newTVar HM.empty
+
+createPeer :: PublicKey -> STM Peer
+createPeer rpub = Peer rpub <$> newTVar []
+ <*> newTVar Nothing
+ <*> newTVar Nothing
+ <*> newTVar 0
+ <*> newTVar 0
+ <*> newTVar 0
+ <*> newTVar Nothing
+ <*> newTVar Nothing
+ <*> newTVar []
+ <*> newTVar mempty
+ <*> newTVar farFuture
+ <*> newTVar farFuture
+ <*> newTVar 0
+
+invalidateSessions :: Device -> STM ()
+invalidateSessions Device{..} = do
+ writeTVar indexMap HM.empty
+ readTVar peers >>= mapM_ invalidatePeerSessions
+ where
+ invalidatePeerSessions Peer{..} = do
+ writeTVar lastHandshakeTime Nothing
+ writeTVar initiatorWait Nothing
+ writeTVar responderWait Nothing
+ writeTVar sessions []
+
+buildRouteTables :: Device -> STM ()
+buildRouteTables Device{..} = do
+ gather pickIPv4 >>= writeTVar routeTable4 . RT.fromList . concat
+ gather pickIPv6 >>= writeTVar routeTable6 . RT.fromList . concat
+ where
+ gather pick = do
+ peers' <- readTVar peers
+ forM peers' $ \peer ->
+ map (,peer) . mapMaybe pick <$> readTVar (ipmasks peer)
+ pickIPv4 (IPv4Range ipv4) = Just ipv4
+ pickIPv4 _ = Nothing
+ pickIPv6 (IPv6Range ipv6) = Just ipv6
+ pickIPv6 _ = Nothing
+
+acquireEmptyIndex :: Device -> Peer -> Index -> STM Index
+acquireEmptyIndex device peer seed = do
+ imap <- readTVar (indexMap device)
+ let findEmpty idx
+ | HM.member idx imap = findEmpty (idx * 3 + 1)
+ | otherwise = idx
+ emptyIndex = findEmpty seed
+ writeTVar (indexMap device) $ HM.insert emptyIndex peer imap
+ return emptyIndex
+
+removeIndex :: Device -> Index -> STM ()
+removeIndex device index = modifyTVar' (indexMap device) (HM.delete index)
+
+nextNonce :: Session -> STM Counter
+nextNonce Session{..} = do
+ nonce <- readTVar sessionCounter
+ writeTVar sessionCounter (nonce + 1)
+ return nonce
+
+eraseInitiatorWait :: Device -> Peer -> Maybe Index -> STM Bool
+eraseInitiatorWait device Peer{..} index = do
+ miwait <- readTVar initiatorWait
+ case miwait of
+ Just iwait | isNothing index || initOurIndex iwait == fromJust index -> do
+ writeTVar initiatorWait Nothing
+ when (isNothing index) $ removeIndex device (initOurIndex iwait)
+ return True
+ _ -> return False
+
+eraseResponderWait :: Device -> Peer -> Maybe Index -> STM Bool
+eraseResponderWait device Peer{..} index = do
+ mrwait <- readTVar responderWait
+ case mrwait of
+ Just rwait | isNothing index || respOurIndex rwait == fromJust index -> do
+ writeTVar responderWait Nothing
+ when (isNothing index) $ removeIndex device (respOurIndex rwait)
+ return True
+ _ -> return False
+
+getSession :: Peer -> IO (Maybe Session)
+getSession peer = do
+ sessions' <- readTVarIO (sessions peer)
+ case sessions' of
+ [] -> return Nothing
+ (s:_) -> return (Just s)
+
+waitForSession :: Peer -> STM Session
+waitForSession peer = do
+ sessions' <- readTVar (sessions peer)
+ case sessions' of
+ [] -> retry
+ (s:_) -> return s
+
+findSession :: Peer -> Index -> STM (Maybe (Either ResponderWait Session))
+findSession peer index = do
+ sessions' <- filter ((==index).ourIndex) <$> readTVar (sessions peer)
+ case sessions' of
+ (s:_) -> return (Just (Right s))
+ [] -> do
+ mrwait <- readTVar (responderWait peer)
+ case mrwait of
+ Just rwait | respOurIndex rwait == index -> return (Just (Left rwait))
+ _ -> return Nothing
+
+
+addSession :: Device -> Peer -> Session -> STM ()
+addSession device peer session = do
+ (toKeep, toDrop) <- splitAt maxActiveSessions . (session:) <$> readTVar (sessions peer)
+ mapM_ (removeIndex device . ourIndex) toDrop
+ writeTVar (sessions peer) toKeep
+
+filterSessions :: Device -> Peer -> (Session -> Bool) -> STM ()
+filterSessions device peer cond = do
+ sessions' <- readTVar (sessions peer)
+ filtered <- fmap catMaybes $ forM sessions' $ \session ->
+ if cond session
+ then return (Just session)
+ else do
+ removeIndex device (ourIndex session)
+ return Nothing
+ writeTVar (sessions peer) filtered
+
+updateTai64n :: Peer -> TAI64n -> STM Bool
+updateTai64n peer tai64n = do
+ lastTai64n' <- readTVar (lastTai64n peer)
+ if tai64n <= lastTai64n'
+ then return False
+ else do
+ writeTVar (lastTai64n peer) tai64n
+ return True
+
+updateEndPoint :: Peer -> SockAddr -> STM ()
+updateEndPoint peer sock = writeTVar (endPoint peer) (Just sock)
diff --git a/src/Network/WireGuard/Internal/Types.hs b/src/Network/WireGuard/Internal/Types.hs
new file mode 100644
index 0000000..3409e2a
--- /dev/null
+++ b/src/Network/WireGuard/Internal/Types.hs
@@ -0,0 +1,78 @@
+module Network.WireGuard.Internal.Types
+ ( Index
+ , Counter
+ , PeerId
+ , PublicKey
+ , PrivateKey
+ , KeyPair
+ , PresharedKey
+ , Time
+ , UdpPacket
+ , TunPacket
+ , EncryptedPayload
+ , AuthTag
+ , TAI64n
+ , SessionKey(..)
+ , WireGuardError(..)
+ , getPeerId
+ , farFuture
+ ) where
+
+import Control.Exception (Exception, SomeException)
+import qualified Crypto.Noise.DH as DH
+import Crypto.Noise.DH.Curve25519 (Curve25519)
+import Data.ByteArray (ScrubbedBytes)
+import qualified Data.ByteArray as BA
+import qualified Data.ByteString as BS
+import Foreign.C.Types (CTime (..))
+import Network.Socket (SockAddr)
+import System.Posix.Types (EpochTime)
+
+import Data.Word
+
+type Index = Word32
+type Counter = Word64
+type PeerId = BS.ByteString
+
+type PublicKey = DH.PublicKey Curve25519
+type PrivateKey = DH.SecretKey Curve25519
+type KeyPair = DH.KeyPair Curve25519
+type PresharedKey = ScrubbedBytes
+
+type Time = EpochTime
+
+type UdpPacket = (BS.ByteString, SockAddr)
+type TunPacket = ScrubbedBytes
+
+type EncryptedPayload = BS.ByteString
+type AuthTag = BS.ByteString
+type TAI64n = BS.ByteString
+
+data SessionKey = SessionKey
+ { sendKey :: !ScrubbedBytes
+ , recvKey :: !ScrubbedBytes
+ }
+
+data WireGuardError
+ = DecryptFailureError
+ | DestinationNotReachableError
+ | DeviceNotReadyError
+ | EndPointUnknownError
+ | HandshakeInitiationReplayError
+ | InvalidIPPacketError
+ | InvalidWGPacketError String
+ | NoiseError SomeException
+ | NonceReuseError
+ | OutdatedPacketError
+ | RemotePeerNotFoundError
+ | SourceAddrBlockedError
+ | UnknownIndexError
+ deriving (Show)
+
+instance Exception WireGuardError
+
+getPeerId :: PublicKey -> PeerId
+getPeerId = BA.convert . DH.dhPubToBytes
+
+farFuture :: Time
+farFuture = CTime maxBound
diff --git a/src/Network/WireGuard/Internal/Util.hs b/src/Network/WireGuard/Internal/Util.hs
new file mode 100644
index 0000000..f7ecde5
--- /dev/null
+++ b/src/Network/WireGuard/Internal/Util.hs
@@ -0,0 +1,62 @@
+{-# LANGUAGE ScopedTypeVariables #-}
+
+module Network.WireGuard.Internal.Util
+ ( retryWithBackoff
+ , ignoreSyncExceptions
+ , foreverWithBackoff
+ , catchIOExceptionAnd
+ , catchSomeExceptionAnd
+ , withJust
+ , zeroMemory
+ , copyMemory
+ ) where
+
+import Control.Concurrent (threadDelay)
+import Control.Exception (Exception (..),
+ IOException,
+ SomeAsyncException,
+ SomeException, throwIO)
+import Control.Monad.Catch (MonadCatch (..))
+import System.IO (hPutStrLn, stderr)
+
+import Foreign
+import Foreign.C
+
+import Network.WireGuard.Internal.Constant
+
+retryWithBackoff :: IO () -> IO ()
+retryWithBackoff = foreverWithBackoff . ignoreSyncExceptions
+
+ignoreSyncExceptions :: IO () -> IO ()
+ignoreSyncExceptions m = catch m handleExcept
+ where
+ handleExcept e = case fromException e of
+ Just asyncExcept -> throwIO (asyncExcept :: SomeAsyncException)
+ Nothing -> hPutStrLn stderr (displayException e) -- TODO: proper logging
+
+foreverWithBackoff :: IO () -> IO ()
+foreverWithBackoff m = loop 1
+ where
+ loop t = m >> threadDelay t >> loop (min (t * 2) retryMaxWaitTime)
+
+catchIOExceptionAnd :: MonadCatch m => m () -> m () -> m ()
+catchIOExceptionAnd what m = catch m $ \(_ :: IOException) -> what
+
+catchSomeExceptionAnd :: MonadCatch m => m () -> m () -> m ()
+catchSomeExceptionAnd what m = catch m $ \(_ :: SomeException) -> what
+
+withJust :: Monad m => m (Maybe a) -> (a -> m ()) -> m ()
+withJust mma func = do
+ ma <- mma
+ case ma of
+ Nothing -> return ()
+ Just a -> func a
+
+zeroMemory :: Ptr a -> CSize -> IO ()
+zeroMemory dest nbytes = memset dest 0 (fromIntegral nbytes)
+
+copyMemory :: Ptr a -> Ptr b -> CSize -> IO ()
+copyMemory dest src nbytes = memcpy dest src nbytes
+
+foreign import ccall unsafe "string.h" memset :: Ptr a -> CInt -> CSize -> IO ()
+foreign import ccall unsafe "string.h" memcpy :: Ptr a -> Ptr b -> CSize -> IO ()
diff --git a/src/Network/WireGuard/RPC.hs b/src/Network/WireGuard/RPC.hs
new file mode 100644
index 0000000..7ecb8de
--- /dev/null
+++ b/src/Network/WireGuard/RPC.hs
@@ -0,0 +1,187 @@
+{-# LANGUAGE RecordWildCards #-}
+
+module Network.WireGuard.RPC
+ ( runRPC
+ ) where
+
+import Control.Concurrent.STM (STM, atomically,
+ modifyTVar', readTVar,
+ writeTVar)
+import Control.Monad (replicateM, sequence,
+ when)
+import Control.Monad.IO.Class (liftIO)
+import qualified Crypto.Noise.DH as DH
+import qualified Data.ByteArray as BA
+import qualified Data.ByteString as BS
+import qualified Data.Conduit.Binary as CB
+import Data.Conduit.Network.Unix (appSink, appSource,
+ runUnixServer,
+ serverSettings)
+import qualified Data.HashMap.Strict as HM
+import Data.Int (Int32)
+import Data.List (genericLength)
+import Foreign.C.Types (CTime (..))
+
+import Data.Bits
+import Data.Conduit
+import Data.IP
+import Data.Maybe
+
+import Network.WireGuard.Foreign.UAPI
+import Network.WireGuard.Internal.Constant
+import Network.WireGuard.Internal.State
+import Network.WireGuard.Internal.Types
+import Network.WireGuard.Internal.Util
+
+-- | Run RPC service over a unix socket
+runRPC :: FilePath -> Device -> IO ()
+runRPC sockPath device = runUnixServer (serverSettings sockPath) $ \app ->
+ catchIOExceptionAnd (return ()) $ runConduit (appSource app =$= serveConduit =$= appSink app)
+ where
+ -- TODO: ensure that all bytestring over sockets will be erased
+ serveConduit = do
+ h <- CB.head
+ case h of
+ Just 0 -> showDevice device
+ Just byte -> do
+ leftover (BS.singleton byte)
+ mWgdev <- CB.sinkStorable
+ case mWgdev of
+ Just wgdev -> catchSomeExceptionAnd returnError (updateDevice wgdev)
+ Nothing -> mempty
+ Nothing -> mempty
+
+ returnError = yield $ writeConfig (-invalidValueError)
+
+ showDevice Device{..} = do
+ (wgdevice, peers') <- liftIO buildWgDevice
+ yield (writeConfig wgdevice)
+ mapM_ showPeer peers'
+ where
+ buildWgDevice = atomically $ do
+ localKey' <- readTVar localKey
+ let (pub, priv) = case localKey' of
+ Nothing -> (emptyKey, emptyKey)
+ Just (sec, pub') -> (pubToBytes pub', privToBytes sec)
+ psk' <- fmap pskToBytes <$> readTVar presharedKey
+ fwmark' <- fromIntegral <$> readTVar fwmark
+ port' <- fromIntegral <$> readTVar port
+ peers' <- readTVar peers
+ return (WgDevice intfName 0 pub priv (fromMaybe emptyKey psk')
+ fwmark' port' (fromIntegral $ HM.size peers'), peers')
+
+ showPeer Peer{..} = do
+ (wgpeer, ipmasks') <- liftIO buildWgPeer
+ yield (writeConfig wgpeer)
+ yield $ BS.concat (map (writeConfig . ipRangeToWgIpmask) ipmasks')
+ where
+ extractTime Nothing = 0
+ extractTime (Just (CTime t)) = fromIntegral t
+
+ buildWgPeer = atomically $ do
+ ipmasks' <- readTVar ipmasks
+ wgpeer <- WgPeer (pubToBytes remotePub)
+ <$> return 0
+ <*> readTVar endPoint
+ <*> (extractTime <$> readTVar lastHandshakeTime)
+ <*> (fromIntegral <$> readTVar receivedBytes)
+ <*> (fromIntegral <$> readTVar transferredBytes)
+ <*> (fromIntegral <$> readTVar keepaliveInterval)
+ <*> return (genericLength ipmasks')
+ return (wgpeer, ipmasks')
+
+ updateDevice wgdevice = do
+ setPeerMs <- replicateM (fromIntegral $ deviceNumPeers wgdevice) $ do
+ Just wgpeer <- CB.sinkStorable
+ -- TODO: replace fromJust
+ ipranges <- replicateM (fromIntegral $ peerNumIpmasks wgpeer)
+ (wgIpmaskToIpRange . fromJust <$> CB.sinkStorable)
+ return $ setPeer device wgpeer ipranges
+ liftIO $ atomically $ do
+ setDevice device wgdevice
+ anyIpMaskChanged <- or <$> sequence setPeerMs
+ -- TODO: modify routetable incrementally
+ when anyIpMaskChanged $ buildRouteTables device
+ yield $ writeConfig (0 :: Int32)
+
+-- | implementation of config.c::set_peer()
+setPeer :: Device -> WgPeer -> [IPRange] -> STM Bool
+setPeer Device{..} WgPeer{..} ipranges
+ | peerPubKey == emptyKey = return False
+ | testFlag peerFlags peerFlagRemoveMe = modifyTVar' peers (HM.delete peerPubKey) >> return False
+ | otherwise = do
+ peers' <- readTVar peers
+ Peer{..} <- case HM.lookup peerPubKey peers' of
+ Nothing -> do
+ newPeer <- createPeer (fromJust $ bytesToPub peerPubKey) -- TODO: replace fromJust
+ modifyTVar' peers (HM.insert peerPubKey newPeer)
+ return newPeer
+ Just p -> return p
+ when (isJust peerAddr) $ writeTVar endPoint peerAddr
+ let replaceIpmasks = testFlag peerFlags peerFlagReplaceIpmasks
+ changeIpmasks = replaceIpmasks || not (null ipranges)
+ when changeIpmasks $
+ if replaceIpmasks
+ then writeTVar ipmasks ipranges
+ else modifyTVar' ipmasks (++ipranges)
+ when (peerKeepaliveInterval /= complement 0) $
+ writeTVar keepaliveInterval (fromIntegral peerKeepaliveInterval)
+ return changeIpmasks
+
+-- | implementation of config.c::config_set_device()
+setDevice :: Device -> WgDevice -> STM ()
+setDevice device@Device{..} WgDevice{..} = do
+ when (deviceFwmark /= 0 || deviceFwmark == 0 && testFlag deviceFlags deviceFlagRemoveFwmark) $
+ writeTVar fwmark (fromIntegral deviceFwmark)
+ when (devicePort /= 0) $ writeTVar port (fromIntegral devicePort)
+ when (testFlag deviceFlags deviceFlagReplacePeers) $ writeTVar peers HM.empty
+
+ let removeLocalKey = testFlag deviceFlags deviceFlagRemovePrivateKey
+ changeLocalKey = removeLocalKey || devicePrivkey /= emptyKey
+ changeLocalKeyTo = if removeLocalKey then Nothing else bytesToPair devicePrivkey
+ when changeLocalKey $ writeTVar localKey changeLocalKeyTo
+
+ let removePSK = testFlag deviceFlags deviceFlagRemovePresharedKey
+ changePSK = removePSK || devicePSK /= emptyKey
+ changePSKTo = if removePSK then Nothing else Just (bytesToPSK devicePSK)
+ when changePSK $ writeTVar presharedKey changePSKTo
+
+ when (changeLocalKey || changePSK) $ invalidateSessions device
+
+ipRangeToWgIpmask :: IPRange -> WgIpmask
+ipRangeToWgIpmask (IPv4Range ipv4range) = case addrRangePair ipv4range of
+ (ipv4, prefix) -> WgIpmask (Left (toHostAddress ipv4)) (fromIntegral prefix)
+ipRangeToWgIpmask (IPv6Range ipv6range) = case addrRangePair ipv6range of
+ (ipv6, prefix) -> WgIpmask (Right (toHostAddress6 ipv6)) (fromIntegral prefix)
+
+wgIpmaskToIpRange :: WgIpmask -> IPRange
+wgIpmaskToIpRange (WgIpmask ip cidr) = case ip of
+ Left ipv4 -> IPv4Range $ makeAddrRange (fromHostAddress ipv4) (fromIntegral cidr)
+ Right ipv6 -> IPv6Range $ makeAddrRange (fromHostAddress6 ipv6) (fromIntegral cidr)
+
+invalidValueError :: Int32
+invalidValueError = 22 -- TODO: report back actual error
+
+emptyKey :: BS.ByteString
+emptyKey = BS.replicate keyLength 0
+
+testFlag :: Bits a => a -> a -> Bool
+testFlag a flag = (a .&. flag) /= zeroBits
+
+pubToBytes :: PublicKey -> BS.ByteString
+pubToBytes = BA.convert . DH.dhPubToBytes
+
+privToBytes :: PrivateKey -> BS.ByteString
+privToBytes = BA.convert . DH.dhSecToBytes
+
+pskToBytes :: PresharedKey -> BS.ByteString
+pskToBytes = BA.convert
+
+bytesToPair :: BS.ByteString -> Maybe KeyPair
+bytesToPair = DH.dhBytesToPair . BA.convert
+
+bytesToPub :: BS.ByteString -> Maybe PublicKey
+bytesToPub = DH.dhBytesToPub . BA.convert
+
+bytesToPSK :: BS.ByteString -> PresharedKey
+bytesToPSK = BA.convert
diff --git a/src/Network/WireGuard/TunListener.hs b/src/Network/WireGuard/TunListener.hs
new file mode 100644
index 0000000..d57cf98
--- /dev/null
+++ b/src/Network/WireGuard/TunListener.hs
@@ -0,0 +1,60 @@
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE RecordWildCards #-}
+
+module Network.WireGuard.TunListener
+ ( runTunListener
+ ) where
+
+import Control.Concurrent.Async (wait, withAsync)
+import Control.Monad (forever, void)
+import Control.Monad.STM (atomically)
+import qualified Data.ByteArray as BA
+import Data.Word (Word8)
+import Foreign.Marshal.Alloc (allocaBytes)
+import Foreign.Ptr (Ptr)
+import System.Posix.Types (Fd)
+
+import Network.WireGuard.Foreign.Tun (fdReadBuf, fdWriteBuf)
+
+import Network.WireGuard.Internal.Constant
+import Network.WireGuard.Internal.PacketQueue
+import Network.WireGuard.Internal.Types
+import Network.WireGuard.Internal.Util
+
+#ifdef OS_LINUX
+import Control.Concurrent (threadWaitRead,
+ threadWaitWrite)
+#endif
+
+runTunListener :: [Fd] -> PacketQueue TunPacket -> PacketQueue TunPacket -> IO ()
+runTunListener fds readTunChan writeTunChan = loop fds []
+ where
+ loop [] asyncs = mapM_ wait asyncs
+ loop (fd:rest) asyncs =
+ withAsync (retryWithBackoff $ handleRead readTunChan fd) $ \rt ->
+ withAsync (retryWithBackoff $ handleWrite writeTunChan fd) $ \wt ->
+ loop rest (rt:wt:asyncs)
+
+handleRead :: PacketQueue TunPacket -> Fd -> IO ()
+handleRead readTunChan fd = allocaBytes tunReadBufferLength $ \buf ->
+ forever (readFd buf fd >>= atomically . pushPacketQueue readTunChan)
+
+handleWrite :: PacketQueue TunPacket -> Fd -> IO ()
+handleWrite writeTunChan fd =
+ forever (atomically (popPacketQueue writeTunChan) >>= writeFd fd)
+
+readFd :: BA.ByteArray ba => Ptr Word8 -> Fd -> IO ba
+readFd buf fd = do
+#ifdef OS_LINUX
+ threadWaitRead fd
+#endif
+ nbytes <- fdReadBuf fd buf (fromIntegral tunReadBufferLength)
+ snd <$> BA.allocRet (fromIntegral nbytes)
+ (\ptr -> copyMemory ptr buf nbytes >> zeroMemory buf nbytes)
+
+writeFd :: BA.ByteArrayAccess ba => Fd -> ba -> IO ()
+writeFd fd ba = BA.withByteArray ba $ \ptr -> do
+#ifdef OS_LINUX
+ threadWaitWrite fd
+#endif
+ void $ fdWriteBuf fd ptr (fromIntegral (BA.length ba))
diff --git a/src/Network/WireGuard/UdpListener.hs b/src/Network/WireGuard/UdpListener.hs
new file mode 100644
index 0000000..77b8ae0
--- /dev/null
+++ b/src/Network/WireGuard/UdpListener.hs
@@ -0,0 +1,61 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+module Network.WireGuard.UdpListener
+ ( runUdpListener
+ ) where
+
+import Control.Concurrent.Async (cancel, wait,
+ withAsync)
+import Control.Concurrent.STM.TVar (TVar, readTVar)
+import Control.Exception (bracket)
+import Control.Monad (forever, void)
+import Control.Monad.STM (STM, atomically, retry)
+import Data.Streaming.Network (bindPortUDP,
+ bindRandomPortUDP)
+import Network.Socket (Socket, close)
+import Network.Socket.ByteString (recvFrom, sendTo)
+
+import Network.WireGuard.Internal.State (Device (..))
+
+import Network.WireGuard.Internal.Constant
+import Network.WireGuard.Internal.PacketQueue
+import Network.WireGuard.Internal.Types
+import Network.WireGuard.Internal.Util
+
+runUdpListener :: Device -> PacketQueue UdpPacket -> PacketQueue UdpPacket -> IO ()
+runUdpListener device readUdpChan writeUdpChan = loop 0
+ where
+ loop oport =
+ withAsync (handlePort oport readUdpChan writeUdpChan) $ \t -> do
+ nport <- atomically $ waitNewVar oport (port device)
+ cancel t
+ loop nport
+
+handlePort :: Int -> PacketQueue UdpPacket -> PacketQueue UdpPacket -> IO ()
+handlePort bindPort readUdpChan writeUdpChan = retryWithBackoff $
+ bracket (bind bindPort) close $ \sock ->
+ withAsync (handleRead sock readUdpChan) $ \rt ->
+ withAsync (handleWrite sock writeUdpChan) $ \wt -> do
+ wait rt
+ wait wt
+ where
+ -- TODO: prefer ipv6 binding here
+ bind 0 = snd <$> bindRandomPortUDP "!4"
+ bind p = bindPortUDP p "!4"
+
+handleRead :: Socket -> PacketQueue UdpPacket -> IO ()
+handleRead sock readUdpChan = forever $ do
+ packet <- recvFrom sock udpReadBufferLength
+ void $ atomically $ tryPushPacketQueue readUdpChan packet
+
+handleWrite :: Socket -> PacketQueue UdpPacket -> IO ()
+handleWrite sock writeUdpChan = forever $ do
+ (packet, dest) <- atomically $ popPacketQueue writeUdpChan
+ void $ sendTo sock packet dest
+
+waitNewVar :: Eq a => a -> TVar a -> STM a
+waitNewVar old tvar = do
+ now <- readTVar tvar
+ if now == old
+ then retry
+ else return now
Copyright © 1996 – 2023 Jason A. Donenfeld. All Rights Reverse Engineered.