Building 70 Projects ranging from beginner to advanced so anyone can — learn from, build upon, use as a reference, or even copy directly. Owned by my cybersecurity company 👇
Go aicertificationcloud-engineeringcybercybersecuritycybersecurity-analystcybersecurity-certificationcybersecurity-certificationscybersecurity-educationcybersecurity-jobscybersecurity-portfoliocybersecurity-projectscybersecurity-toolsgrchackinglearningpentestingproject-repositoryprojetcspython
fix: close audit-pass-1 CRITICAL findings (Findings 1-6)
CarterPerez-dev2c7e743f57e7
diff --git a/PROJECTS/advanced/haskell-reverse-proxy/app/Main.hs b/PROJECTS/advanced/haskell-reverse-proxy/app/Main.hsindex 7ffd0af1..62d2ca7e 100644--- a/PROJECTS/advanced/haskell-reverse-proxy/app/Main.hs+++ b/PROJECTS/advanced/haskell-reverse-proxy/app/Main.hs@@ -3,8 +3,18 @@module Main (main) whereimport Aenebris.Config+import Aenebris.Connection+ ( defaultTimeoutConfig+ , microsPerSecond+ , tcUpstreamReadSeconds+ )import Aenebris.Proxy-import Network.HTTP.Client (newManager, defaultManagerSettings)+import Network.HTTP.Client+ ( ManagerSettings(..)+ , defaultManagerSettings+ , newManager+ , responseTimeoutMicro+ )import System.Environment (getArgs)import System.Exit (exitFailure)import System.IO (hPutStrLn, stderr)@@ -37,8 +47,12 @@ main = doRight () -> doputStrLn "Configuration loaded and validated successfully"- -- Create HTTP client manager with connection pooling- manager <- newManager defaultManagerSettings+ let upstreamMicros = tcUpstreamReadSeconds defaultTimeoutConfig+ * microsPerSecond+ managerSettings = defaultManagerSettings+ { managerResponseTimeout = responseTimeoutMicro upstreamMicros+ }+ manager <- newManager managerSettings-- Initialize proxy state (load balancers + health checkers)proxyState <- initProxyState config managerdiff --git a/PROJECTS/advanced/haskell-reverse-proxy/src/Aenebris/Connection.hs b/PROJECTS/advanced/haskell-reverse-proxy/src/Aenebris/Connection.hsindex 30f0fee6..319c9bf7 100644--- a/PROJECTS/advanced/haskell-reverse-proxy/src/Aenebris/Connection.hs+++ b/PROJECTS/advanced/haskell-reverse-proxy/src/Aenebris/Connection.hs@@ -1,3 +1,8 @@+{-+©AngelaMos | 2026+Connection.hs+-}+{-# LANGUAGE NumericUnderscores #-}{-# LANGUAGE OverloadedStrings #-}{-# LANGUAGE RecordWildCards #-}@@ -10,14 +15,14 @@ module Aenebris.Connection, isWebSocketUpgrade, isStreamingResponse, getTimeout+ , microsPerSecond+ , httpOkStatusCode) whereimport Data.ByteString (ByteString)import qualified Data.ByteString as BS-import qualified Data.ByteString.Char8 as BS8-import Data.CaseInsensitive (CI)import qualified Data.CaseInsensitive as CI-import Data.Maybe (isJust, fromMaybe)+import Data.Maybe (isJust)import Network.HTTP.Types (HeaderName, Status, statusCode)data ConnectionState@@ -35,23 +40,31 @@ data ConnectionType| ChunkedStreamderiving (Eq, Show)+microsPerSecond :: Int+microsPerSecond = 1_000_000++httpOkStatusCode :: Int+httpOkStatusCode = 200+data TimeoutConfig = TimeoutConfig- { tcHttpIdle :: Int- , tcWebSocketTunnel :: Int- , tcStreamingResponse :: Int- , tcProxyPingInterval :: Int- , tcPongTimeout :: Int- , tcConnectTimeout :: Int+ { tcHttpIdle :: !Int+ , tcWebSocketTunnel :: !Int+ , tcStreamingResponse :: !Int+ , tcProxyPingInterval :: !Int+ , tcPongTimeout :: !Int+ , tcConnectTimeout :: !Int+ , tcUpstreamReadSeconds :: !Int}defaultTimeoutConfig :: TimeoutConfigdefaultTimeoutConfig = TimeoutConfig- { tcHttpIdle = 60- , tcWebSocketTunnel = 3600- , tcStreamingResponse = 3600- , tcProxyPingInterval = 30- , tcPongTimeout = 10- , tcConnectTimeout = 5+ { tcHttpIdle = 60+ , tcWebSocketTunnel = 3600+ , tcStreamingResponse = 3600+ , tcProxyPingInterval = 30+ , tcPongTimeout = 10+ , tcConnectTimeout = 5+ , tcUpstreamReadSeconds = 30}getTimeout :: TimeoutConfig -> ConnectionState -> Int@@ -96,4 +109,7 @@ isStreamingResponse status headers =hasContentLength = isJust (lookup "Content-Length" headers)- isUnknownLength = statusCode status == 200 && not hasContentLength && not hasTransferEncodingChunked+ isUnknownLength =+ statusCode status == httpOkStatusCode+ && not hasContentLength+ && not hasTransferEncodingChunkeddiff --git a/PROJECTS/advanced/haskell-reverse-proxy/src/Aenebris/ML/Loader.hs b/PROJECTS/advanced/haskell-reverse-proxy/src/Aenebris/ML/Loader.hsindex dc1c5497..4b802487 100644--- a/PROJECTS/advanced/haskell-reverse-proxy/src/Aenebris/ML/Loader.hs+++ b/PROJECTS/advanced/haskell-reverse-proxy/src/Aenebris/ML/Loader.hs@@ -44,6 +44,12 @@ requiredNumClass = 1requiredNumTreePerIteration :: IntrequiredNumTreePerIteration = 1+maxNumLeaves :: Int+maxNumLeaves = 4096++maxNumTrees :: Int+maxNumTrees = 10000+postParseLineSentinel :: IntpostParseLineSentinel = -1@@ -355,18 +361,26 @@ requireField key mv = case mv of("Missing required header key: " <> key))runTrees :: [(Int, Text)] -> Either ParseError [Tree]-runTrees lns = case dropWhile (lineIsBlank . snd) lns of- [] -> Right []- ((n, ln):rest)- | T.strip ln == endOfTreesMarker -> Right []- | T.isPrefixOf baseTreeKeyPrefix (T.strip ln) -> do- let (block, after) = break (lineIsBlank . snd) rest- tree <- parseTreeBlock block- more <- runTrees after- Right (tree : more)- | otherwise -> Left- (ParseError n treeKey- ("Expected 'Tree=N' or 'end of trees', got: " <> ln))+runTrees = goTrees 0+ where+ goTrees :: Int -> [(Int, Text)] -> Either ParseError [Tree]+ goTrees treeCount lns+ | treeCount > maxNumTrees = Left+ (ParseError postParseLineSentinel treeKey+ ("Tree count exceeds maxNumTrees "+ <> T.pack (show maxNumTrees)))+ | otherwise = case dropWhile (lineIsBlank . snd) lns of+ [] -> Right []+ ((n, ln):rest)+ | T.strip ln == endOfTreesMarker -> Right []+ | T.isPrefixOf baseTreeKeyPrefix (T.strip ln) -> do+ let (block, after) = break (lineIsBlank . snd) rest+ tree <- parseTreeBlock block+ more <- goTrees (treeCount + 1) after+ Right (tree : more)+ | otherwise -> Left+ (ParseError n treeKey+ ("Expected 'Tree=N' or 'end of trees', got: " <> ln))parseTreeBlock :: [(Int, Text)] -> Either ParseError TreeparseTreeBlock block = do@@ -428,6 +442,14 @@ assignTreeField acc n key valfinalizeTree :: TreeAcc -> Either ParseError TreefinalizeTree acc = donL <- requireField keyNumLeaves (taNumLeaves acc)+ unless (nL > 0)+ (Left (ParseError postParseLineSentinel keyNumLeaves+ ("num_leaves must be positive: " <> T.pack (show nL))))+ unless (nL <= maxNumLeaves)+ (Left (ParseError postParseLineSentinel keyNumLeaves+ ("num_leaves " <> T.pack (show nL)+ <> " exceeds maxNumLeaves "+ <> T.pack (show maxNumLeaves))))nC <- requireField keyNumCat (taNumCat acc)leafValues <- requireField keyLeafValue (taLeafValue acc)unless (length leafValues == nL)diff --git a/PROJECTS/advanced/haskell-reverse-proxy/src/Aenebris/Proxy.hs b/PROJECTS/advanced/haskell-reverse-proxy/src/Aenebris/Proxy.hsindex cb148d83..c8e3aea6 100644--- a/PROJECTS/advanced/haskell-reverse-proxy/src/Aenebris/Proxy.hs+++ b/PROJECTS/advanced/haskell-reverse-proxy/src/Aenebris/Proxy.hs@@ -13,6 +13,12 @@ module Aenebris.Proxyimport Aenebris.Backendimport Aenebris.Configimport Aenebris.Connection+ ( ConnectionType(..)+ , defaultTimeoutConfig+ , detectConnectionType+ , microsPerSecond+ , tcUpstreamReadSeconds+ )import Aenebris.HealthCheckimport Aenebris.LoadBalancerimport Aenebris.TLS@@ -93,7 +99,9 @@ import Network.Wai.Handler.Warp, setTimeout)import Network.Wai.Handler.WarpTLS (runTLS)+import System.Exit (exitFailure)import System.IO (hPutStrLn, stderr)+import System.Timeout (timeout)import Data.ByteString (ByteString)import qualified Data.ByteString as BSimport qualified Data.ByteString.Char8 as BS8@@ -215,7 +223,9 @@ startProxy ProxyState{..} = doputStrLn $ "Health checking enabled for all upstreams"case configListen psConfig of- [] -> error "No listen ports configured"+ [] -> do+ hPutStrLn stderr "ERROR: No listen ports configured"+ exitFailurelistenConfigs -> docase psRateLimiter ofJust _ -> putStrLn "Rate limiting enabled"@@ -339,9 +349,9 @@ launchHTTPS port tlsConfig app = dotlsResult <- createTLSSettings certFile keyFilecase tlsResult ofLeft err -> do- hPutStrLn stderr $ "ERROR: Failed to load TLS certificate"+ hPutStrLn stderr "ERROR: Failed to load TLS certificate"hPutStrLn stderr $ " " ++ show err- error "TLS configuration error"+ exitFailureRight tlsSettings -> dolet warpSettings = defaultSettings & setPort port@@ -352,7 +362,9 @@ launchHTTPS port tlsConfig app = doputStrLn $ " └─ Strong cipher suites enforced"runTLS tlsSettings warpSettings app- _ -> error "TLS configuration error: cert and key required"+ _ -> do+ hPutStrLn stderr "ERROR: TLS configuration requires both cert and key"+ exitFailure-- | Launch HTTPS server with SNI support (multiple certificates)launchHTTPSWithSNI :: Int -> TLSConfig -> Application -> IO ()@@ -366,9 +378,9 @@ launchHTTPSWithSNI port tlsConfig app = dotlsResult <- createSNISettings domainList defaultCert defaultKeycase tlsResult ofLeft err -> do- hPutStrLn stderr $ "ERROR: Failed to load SNI certificates"+ hPutStrLn stderr "ERROR: Failed to load SNI certificates"hPutStrLn stderr $ " " ++ show err- error "SNI configuration error"+ exitFailureRight tlsSettings -> dolet warpSettings = defaultSettings & setPort port@@ -381,7 +393,10 @@ launchHTTPSWithSNI port tlsConfig app = doputStrLn $ " └─ Strong cipher suites enforced"runTLS tlsSettings warpSettings app- _ -> error "SNI configuration error: sni, default_cert, and default_key required"+ _ -> do+ hPutStrLn stderr+ "ERROR: SNI requires sni, default_cert, and default_key"+ exitFailure-- | Main proxy application (WAI)proxyApp :: Config -> Map Text LoadBalancer -> Manager -> Application@@ -525,25 +540,34 @@ forwardRequest manager clientReq backendHost respond = do, HTTP.requestBody = streamingBody}- withResponse backendReq manager $ \backendResponse -> do- let status = HTTP.responseStatus backendResponse- headers = HTTP.responseHeaders backendResponse- bodyReader = HTTP.responseBody backendResponse-- if shouldStreamResponse headers- then do- hPutStrLn stderr "[STREAM] Streaming response detected"- respond $ responseStream status (filterResponseHeaders headers) $ \write flush -> do- let loop = do- chunk <- brRead bodyReader- unless (BS.null chunk) $ do- write (byteString chunk)- flush- loop- loop- else do- body <- readFullBody bodyReader- respond $ responseLBS status (filterResponseHeaders headers) body+ let upstreamMicros = tcUpstreamReadSeconds defaultTimeoutConfig+ * microsPerSecond+ mResult <- timeout upstreamMicros $+ withResponse backendReq manager $ \backendResponse -> do+ let status = HTTP.responseStatus backendResponse+ headers = HTTP.responseHeaders backendResponse+ bodyReader = HTTP.responseBody backendResponse++ if shouldStreamResponse headers+ then do+ hPutStrLn stderr "[STREAM] Streaming response detected"+ respond $ responseStream status (filterResponseHeaders headers) $ \write flush -> do+ let loop = do+ chunk <- brRead bodyReader+ unless (BS.null chunk) $ do+ write (byteString chunk)+ flush+ loop+ loop+ else do+ body <- readFullBody bodyReader+ respond $ responseLBS status (filterResponseHeaders headers) body+ case mResult of+ Just rr -> return rr+ Nothing -> respond $ responseLBS+ status504+ [("Content-Type", "text/plain")]+ "504 Gateway Timeout: upstream did not respond in time"shouldStreamResponse :: [(HeaderName, BS.ByteString)] -> BoolshouldStreamResponse headers =diff --git a/PROJECTS/advanced/haskell-reverse-proxy/src/Aenebris/TLS.hs b/PROJECTS/advanced/haskell-reverse-proxy/src/Aenebris/TLS.hsindex 4e7b7d91..512d776d 100644--- a/PROJECTS/advanced/haskell-reverse-proxy/src/Aenebris/TLS.hs+++ b/PROJECTS/advanced/haskell-reverse-proxy/src/Aenebris/TLS.hs@@ -1,3 +1,7 @@+{-+©AngelaMos | 2026+TLS.hs+-}{-# LANGUAGE OverloadedStrings #-}{-# LANGUAGE RecordWildCards #-}{-# LANGUAGE ScopedTypeVariables #-}@@ -8,23 +12,27 @@ module Aenebris.TLS, createSNISettings, validateCertificate, CertificateError(..)+ , strongCipherSuites) where-import qualified Data.ByteString as BS+import Control.Exception (SomeException, try)+import qualified Data.ByteString.Lazy as LBS+import Data.Default.Class (def)+import Data.Map.Strict (Map)+import qualified Data.Map.Strict as Mapimport Data.Text (Text)import qualified Data.Text as T-import qualified Data.Text.Encoding as TE-import qualified Data.Map.Strict as Map-import Network.Wai.Handler.WarpTLS-import qualified Network.TLS as TLS-import qualified Network.TLS.Extra.Cipher as Cipher-import Data.Default.Class (def)import Data.X509 (SignedCertificate)import Data.X509.File (readSignedObject)+import qualified Network.TLS as TLS+import qualified Network.TLS.Extra.Cipher as Cipher+import Network.Wai.Handler.WarpTLSimport System.Directory (doesFileExist)-import Control.Exception (try, SomeException)+import System.IO (hPutStrLn, stderr)++httpsRequiredMessage :: LBS.ByteString+httpsRequiredMessage = "This server requires HTTPS"--- | Certificate loading errorsdata CertificateError= CertFileNotFound FilePath| KeyFileNotFound FilePath@@ -32,130 +40,128 @@ data CertificateError| InvalidKey FilePath Stringderiving (Show, Eq)--- | Create TLS settings for a single certificate (non-SNI)-createTLSSettings :: FilePath -> FilePath -> IO (Either CertificateError TLSSettings)+createTLSSettings+ :: FilePath+ -> FilePath+ -> IO (Either CertificateError TLSSettings)createTLSSettings certFile keyFile = do- -- Validate files existcertExists <- doesFileExist certFile- keyExists <- doesFileExist keyFile-+ keyExists <- doesFileExist keyFileif not certExists- then return $ Left (CertFileNotFound certFile)+ then pure (Left (CertFileNotFound certFile))else if not keyExists- then return $ Left (KeyFileNotFound keyFile)+ then pure (Left (KeyFileNotFound keyFile))else do- -- Try to load the credential to validate itresult <- try $ TLS.credentialLoadX509 certFile keyFilecase result ofLeft (err :: SomeException) ->- return $ Left (InvalidCertificate certFile (show err))-+ pure (Left (InvalidCertificate certFile (show err)))Right (Left err) ->- return $ Left (InvalidCertificate certFile err)-- Right (Right _credential) -> do- -- Create TLS settings with strong security- let tlsConfig = (tlsSettings certFile keyFile)- { tlsAllowedVersions = [TLS.TLS13, TLS.TLS12]- , tlsCiphers = strongCipherSuites- , onInsecure = DenyInsecure "This server requires HTTPS"- }-- return $ Right tlsConfig---- | Create TLS settings with SNI support for multiple domains-createSNISettings :: [(Text, FilePath, FilePath)] -> FilePath -> FilePath -> IO (Either CertificateError TLSSettings)+ pure (Left (InvalidCertificate certFile err))+ Right (Right _) ->+ pure (Right (configureTLS certFile keyFile))++configureTLS :: FilePath -> FilePath -> TLSSettings+configureTLS certFile keyFile = (tlsSettings certFile keyFile)+ { tlsAllowedVersions = [TLS.TLS13, TLS.TLS12]+ , tlsCiphers = strongCipherSuites+ , onInsecure = DenyInsecure httpsRequiredMessage+ }++createSNISettings+ :: [(Text, FilePath, FilePath)]+ -> FilePath+ -> FilePath+ -> IO (Either CertificateError TLSSettings)createSNISettings domains defaultCert defaultKey = do- -- Validate default certificate- defaultExists <- doesFileExist defaultCert- defaultKeyExists <- doesFileExist defaultKey-- if not defaultExists- then return $ Left (CertFileNotFound defaultCert)- else if not defaultKeyExists- then return $ Left (KeyFileNotFound defaultKey)+ defaultCertOk <- doesFileExist defaultCert+ defaultKeyOk <- doesFileExist defaultKey+ if not defaultCertOk+ then pure (Left (CertFileNotFound defaultCert))+ else if not defaultKeyOk+ then pure (Left (KeyFileNotFound defaultKey))else do- -- Validate all domain certificates exist- validationResults <- mapM validateDomainCert domains- case sequence validationResults of- Left err -> return $ Left err- Right _ -> do- -- Create SNI-enabled TLS settings using the default cert first- let baseTLS = tlsSettings defaultCert defaultKey- tlsConfig = baseTLS- { tlsAllowedVersions = [TLS.TLS13, TLS.TLS12]- , tlsCiphers = strongCipherSuites- , onInsecure = DenyInsecure "This server requires HTTPS"- , tlsServerHooks = def- { TLS.onServerNameIndication = \mHostname -> case mHostname of- Nothing -> loadCredentials defaultCert defaultKey- Just hostname -> sniCallback domains defaultCert defaultKey hostname- }- }-- return $ Right tlsConfig- where- validateDomainCert :: (Text, FilePath, FilePath) -> IO (Either CertificateError ())- validateDomainCert (domain, certFile, keyFile) = do- certExists <- doesFileExist certFile- keyExists <- doesFileExist keyFile-- if not certExists- then return $ Left (CertFileNotFound certFile)- else if not keyExists- then return $ Left (KeyFileNotFound keyFile)- else return $ Right ()---- | SNI callback function - returns credentials based on hostname-sniCallback :: [(Text, FilePath, FilePath)] -> FilePath -> FilePath -> String -> IO TLS.Credentials-sniCallback domains defaultCert defaultKey hostname = do- let hostnameText = T.pack hostname- -- Look up domain in map+ validations <- mapM validateDomainCert domains+ case sequence validations of+ Left err -> pure (Left err)+ Right _ -> pure (Right (configureSNI domains defaultCert defaultKey))++configureSNI+ :: [(Text, FilePath, FilePath)]+ -> FilePath+ -> FilePath+ -> TLSSettings+configureSNI domains defaultCert defaultKey =+ let baseTLS = tlsSettings defaultCert defaultKey+ in baseTLS+ { tlsAllowedVersions = [TLS.TLS13, TLS.TLS12]+ , tlsCiphers = strongCipherSuites+ , onInsecure = DenyInsecure httpsRequiredMessage+ , tlsServerHooks = def+ { TLS.onServerNameIndication = \mHostname -> case mHostname of+ Nothing -> credentialsOrDefault defaultCert defaultKey+ Just hostname ->+ sniCallback domains defaultCert defaultKey hostname+ }+ }++validateDomainCert+ :: (Text, FilePath, FilePath) -> IO (Either CertificateError ())+validateDomainCert (_domain, certFile, keyFile) = do+ certExists <- doesFileExist certFile+ keyExists <- doesFileExist keyFile+ if not certExists+ then pure (Left (CertFileNotFound certFile))+ else if not keyExists+ then pure (Left (KeyFileNotFound keyFile))+ else pure (Right ())++sniCallback+ :: [(Text, FilePath, FilePath)]+ -> FilePath+ -> FilePath+ -> String+ -> IO TLS.Credentials+sniCallback domains defaultCert defaultKey hostname =+ let domainMap :: Map Text (FilePath, FilePath)domainMap = Map.fromList [(d, (c, k)) | (d, c, k) <- domains]+ in case Map.lookup (T.pack hostname) domainMap of+ Nothing -> credentialsOrDefault defaultCert defaultKey+ Just (certFile, keyFile) ->+ credentialsOrDefault certFile keyFile- case Map.lookup hostnameText domainMap of- Nothing -> do- -- No match, use default certificate- loadCredentials defaultCert defaultKey-- Just (certFile, keyFile) -> do- -- Found matching domain, load its certificate- loadCredentials certFile keyFile---- | Load TLS credentials from certificate and key files-loadCredentials :: FilePath -> FilePath -> IO TLS.Credentials-loadCredentials certFile keyFile = do+credentialsOrDefault :: FilePath -> FilePath -> IO TLS.Credentials+credentialsOrDefault certFile keyFile = doresult <- TLS.credentialLoadX509 certFile keyFilecase result of- Left err ->- error $ "Failed to load certificate: " ++ err+ Left err -> do+ hPutStrLn stderr $+ "TLS: failed to load credential at "+ <> certFile <> " (" <> err <> "); SNI handler returns empty credentials"+ pure (TLS.Credentials [])Right credential ->- return $ TLS.Credentials [credential]+ pure (TLS.Credentials [credential])--- | Validate a certificate file (check if it's readable and valid)-validateCertificate :: FilePath -> IO (Either CertificateError [SignedCertificate])+validateCertificate+ :: FilePath -> IO (Either CertificateError [SignedCertificate])validateCertificate certFile = doexists <- doesFileExist certFileif not exists- then return $ Left (CertFileNotFound certFile)+ then pure (Left (CertFileNotFound certFile))else doresult <- try $ readSignedObject certFilecase result ofLeft (err :: SomeException) ->- return $ Left (InvalidCertificate certFile (show err))+ pure (Left (InvalidCertificate certFile (show err)))Right certs ->- return $ Right certs+ pure (Right certs)--- | Strong cipher suites for production (TLS 1.2 + TLS 1.3)strongCipherSuites :: [TLS.Cipher]strongCipherSuites =- -- TLS 1.3 cipher suites (preferred)- [ Cipher.cipher_TLS13_AES128GCM_SHA256- , Cipher.cipher_TLS13_AES256GCM_SHA384- , Cipher.cipher_TLS13_CHACHA20POLY1305_SHA256- ] ++- -- TLS 1.2 cipher suites (fallback, only ECDHE + AEAD)- [ Cipher.cipher_ECDHE_RSA_WITH_AES_128_GCM_SHA256+ [ Cipher.cipher13_AES_128_GCM_SHA256+ , Cipher.cipher13_AES_256_GCM_SHA384+ , Cipher.cipher13_CHACHA20_POLY1305_SHA256+ , Cipher.cipher_ECDHE_RSA_WITH_AES_128_GCM_SHA256, Cipher.cipher_ECDHE_RSA_WITH_AES_256_GCM_SHA384, Cipher.cipher_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256, Cipher.cipher_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256diff --git a/PROJECTS/advanced/haskell-reverse-proxy/src/Aenebris/Tunnel.hs b/PROJECTS/advanced/haskell-reverse-proxy/src/Aenebris/Tunnel.hsindex 8d81e404..99555c19 100644--- a/PROJECTS/advanced/haskell-reverse-proxy/src/Aenebris/Tunnel.hs+++ b/PROJECTS/advanced/haskell-reverse-proxy/src/Aenebris/Tunnel.hs@@ -1,27 +1,95 @@+{-+©AngelaMos | 2026+Tunnel.hs+-}+{-# LANGUAGE BangPatterns #-}+{-# LANGUAGE NumericUnderscores #-}{-# LANGUAGE OverloadedStrings #-}{-# LANGUAGE ScopedTypeVariables #-}-{-# LANGUAGE RecordWildCards #-}module Aenebris.Tunnel- ( tunnelWebSocket+ ( ConnectError(..)+ , connectToBackend+ , parseHostPort+ , parseUpgradeStatus+ , tunnelWebSocket, streamResponse, bidirectionalCopy) whereimport Control.Concurrent.Async (race_)-import Control.Exception (SomeException, try, bracket)+import Control.Exception+ ( SomeException+ , bracketOnError+ , finally+ , try+ )import Data.ByteString (ByteString)import qualified Data.ByteString as BSimport qualified Data.ByteString.Char8 as BS8import Data.CaseInsensitive (original)import Data.Text (Text)import qualified Data.Text as T-import Network.HTTP.Types (HeaderName)import Network.Socket (Socket)import qualified Network.Socket as Socketimport qualified Network.Socket.ByteString as SocketBSimport Network.Wai+ ( Request+ , rawPathInfo+ , rawQueryString+ , requestHeaders+ , requestMethod+ )import System.IO (hPutStrLn, stderr)+import System.Timeout (timeout)++defaultBackendPort :: Int+defaultBackendPort = 80++upgradeRecvChunkBytes :: Int+upgradeRecvChunkBytes = 4_096++maxUpgradeHeaderBytes :: Int+maxUpgradeHeaderBytes = 16_384++tunnelRecvChunkBytes :: Int+tunnelRecvChunkBytes = 65_536++connectTimeoutSeconds :: Int+connectTimeoutSeconds = 5++upgradeIdleSeconds :: Int+upgradeIdleSeconds = 30++microsPerSecond :: Int+microsPerSecond = 1_000_000++upgradeStatusSwitching :: Int+upgradeStatusSwitching = 101++badGatewayResponseLine :: ByteString+badGatewayResponseLine = "HTTP/1.1 502 Bad Gateway\r\n\r\n"++upgradeTerminator :: ByteString+upgradeTerminator = "\r\n\r\n"++httpHeaderLineEnd :: ByteString+httpHeaderLineEnd = "\r\n"++httpVersionAndCrlf :: ByteString+httpVersionAndCrlf = " HTTP/1.1\r\n"++httpFieldSeparator :: ByteString+httpFieldSeparator = ": "++requestPathSeparator :: ByteString+requestPathSeparator = " "++data ConnectError+ = ResolutionFailed !String !Int+ | ConnectTimeout !String !Int+ | ConnectFailed !String !Int !String+ deriving (Eq, Show)tunnelWebSocket:: Request@@ -31,39 +99,62 @@ tunnelWebSocket-> IO ()tunnelWebSocket clientReq backendHost clientSend clientRecv = dohPutStrLn stderr $ "[WS] Initiating tunnel to " ++ T.unpack backendHost-- result <- try $ do- let (host, port) = parseHostPort backendHost-- bracket- (connectToBackend host port)- Socket.close- $ \backendSocket -> do- sendUpgradeRequest backendSocket clientReq- upgradeResponse <- receiveUpgradeResponse backendSocket-- case parseUpgradeStatus upgradeResponse of- Just 101 -> do- hPutStrLn stderr "[WS] Backend accepted upgrade (101)"- clientSend upgradeResponse- bidirectionalCopy clientRecv clientSend- (SocketBS.recv backendSocket 65536)- (SocketBS.sendAll backendSocket)-- Just code -> do- hPutStrLn stderr $ "[WS] Backend rejected upgrade: " ++ show code- clientSend upgradeResponse-- Nothing -> do- hPutStrLn stderr "[WS] Invalid upgrade response"- clientSend "HTTP/1.1 502 Bad Gateway\r\n\r\n"-- case result of+ let (host, port) = parseHostPort backendHost+ outcome <- try $ do+ eSock <- connectToBackend host port+ case eSock of+ Left err -> do+ hPutStrLn stderr $ "[WS] Connection failed: " ++ show err+ clientSend badGatewayResponseLine+ Right sock ->+ runUpgrade clientReq clientSend clientRecv sock+ `finally` Socket.close sock+ case outcome ofLeft (e :: SomeException) ->hPutStrLn stderr $ "[WS] Tunnel error: " ++ show eRight () ->hPutStrLn stderr "[WS] Tunnel closed"+runUpgrade+ :: Request+ -> (ByteString -> IO ())+ -> IO ByteString+ -> Socket+ -> IO ()+runUpgrade clientReq clientSend clientRecv sock = do+ sendUpgradeRequest sock clientReq+ mResponse <- timeout+ (upgradeIdleSeconds * microsPerSecond)+ (receiveUpgradeResponse sock)+ case mResponse of+ Nothing -> do+ hPutStrLn stderr "[WS] Upgrade response timed out"+ clientSend badGatewayResponseLine+ Just upgradeResponse ->+ dispatchUpgrade sock clientSend clientRecv upgradeResponse++dispatchUpgrade+ :: Socket+ -> (ByteString -> IO ())+ -> IO ByteString+ -> ByteString+ -> IO ()+dispatchUpgrade sock clientSend clientRecv upgradeResponse =+ case parseUpgradeStatus upgradeResponse of+ Just code | code == upgradeStatusSwitching -> do+ hPutStrLn stderr "[WS] Backend accepted upgrade (101)"+ clientSend upgradeResponse+ bidirectionalCopy+ clientRecv clientSend+ (SocketBS.recv sock tunnelRecvChunkBytes)+ (SocketBS.sendAll sock)+ Just code -> do+ hPutStrLn stderr $ "[WS] Backend rejected upgrade: " ++ show code+ clientSend upgradeResponse+ Nothing -> do+ hPutStrLn stderr "[WS] Invalid upgrade response"+ clientSend badGatewayResponseLine+bidirectionalCopy:: IO ByteString-> (ByteString -> IO ())@@ -72,11 +163,9 @@ bidirectionalCopy-> IO ()bidirectionalCopy clientRecv clientSend backendRecv backendSend = dohPutStrLn stderr "[TUNNEL] Starting bidirectional copy"-race_(copyLoop "client->backend" clientRecv backendSend)(copyLoop "backend->client" backendRecv clientSend)-hPutStrLn stderr "[TUNNEL] Bidirectional copy ended"copyLoop :: String -> IO ByteString -> (ByteString -> IO ()) -> IO ()@@ -112,56 +201,74 @@ parseHostPort hostPort =[host, portStr] ->case reads (T.unpack portStr) of[(port, "")] -> (T.unpack host, port)- _ -> (T.unpack host, 80)- [host] -> (T.unpack host, 80)- _ -> (T.unpack hostPort, 80)+ _ -> (T.unpack host, defaultBackendPort)+ [host] -> (T.unpack host, defaultBackendPort)+ _ -> (T.unpack hostPort, defaultBackendPort)-connectToBackend :: String -> Int -> IO Socket+connectToBackend :: String -> Int -> IO (Either ConnectError Socket)connectToBackend host port = do- addrInfos <- Socket.getAddrInfo+ resolution <- try $ Socket.getAddrInfo(Just Socket.defaultHints { Socket.addrSocketType = Socket.Stream })(Just host)- (Just $ show port)-- case addrInfos of- [] -> error $ "Cannot resolve: " ++ host ++ ":" ++ show port- (addr:_) -> do- sock <- Socket.socket- (Socket.addrFamily addr)- Socket.Stream- Socket.defaultProtocol- Socket.connect sock (Socket.addrAddress addr)- return sock+ (Just (show port))+ case resolution of+ Left (_ :: SomeException) -> pure (Left (ResolutionFailed host port))+ Right [] -> pure (Left (ResolutionFailed host port))+ Right (addr : _) -> attemptConnect host port addr-sendUpgradeRequest :: Socket -> Request -> IO ()-sendUpgradeRequest sock req = do- let method = requestMethod req- path = rawPathInfo req <> rawQueryString req- headers = requestHeaders req+attemptConnect+ :: String -> Int -> Socket.AddrInfo -> IO (Either ConnectError Socket)+attemptConnect host port addr =+ bracketOnError+ (Socket.socket+ (Socket.addrFamily addr)+ Socket.Stream+ Socket.defaultProtocol)+ Socket.close+ $ \sock -> do+ mConnect <- timeout+ (connectTimeoutSeconds * microsPerSecond)+ (try (Socket.connect sock (Socket.addrAddress addr)))+ case mConnect of+ Nothing -> do+ Socket.close sock+ pure (Left (ConnectTimeout host port))+ Just (Left (e :: SomeException)) -> do+ Socket.close sock+ pure (Left (ConnectFailed host port (show e)))+ Just (Right ()) ->+ pure (Right sock)- requestLine = method <> " " <> path <> " HTTP/1.1\r\n"+sendUpgradeRequest :: Socket -> Request -> IO ()+sendUpgradeRequest sock req =+ let method = requestMethod req+ path = rawPathInfo req <> rawQueryString req+ headers = requestHeaders req+ requestLine = method <> requestPathSeparator <> path <> httpVersionAndCrlfheaderLines = BS.concat- [ original name <> ": " <> value <> "\r\n"+ [ original name <> httpFieldSeparator <> value <> httpHeaderLineEnd| (name, value) <- headers]- fullRequest = requestLine <> headerLines <> "\r\n"-- SocketBS.sendAll sock fullRequest+ fullRequest = requestLine <> headerLines <> httpHeaderLineEnd+ in SocketBS.sendAll sock fullRequestreceiveUpgradeResponse :: Socket -> IO ByteString-receiveUpgradeResponse sock = do- chunk <- SocketBS.recv sock 4096- if "\r\n\r\n" `BS.isInfixOf` chunk- then return chunk- else do- rest <- receiveUpgradeResponse sock- return $ chunk <> rest+receiveUpgradeResponse sock = go BS.empty+ where+ go !acc+ | upgradeTerminator `BS.isInfixOf` acc = pure acc+ | BS.length acc >= maxUpgradeHeaderBytes = pure acc+ | otherwise = do+ chunk <- SocketBS.recv sock upgradeRecvChunkBytes+ if BS.null chunk+ then pure acc+ else go (acc <> chunk)parseUpgradeStatus :: ByteString -> Maybe Int-parseUpgradeStatus response =- case BS8.words (head $ BS8.lines response) of- (_:codeBS:_) ->- case reads (BS8.unpack codeBS) of- [(code, "")] -> Just code- _ -> Nothing+parseUpgradeStatus response = case BS8.lines response of+ [] -> Nothing+ (firstLine : _) -> case BS8.words firstLine of+ (_ : codeBS : _) -> case reads (BS8.unpack codeBS) of+ [(code, "")] -> Just code+ _ -> Nothing_ -> Nothingdiff --git a/PROJECTS/advanced/haskell-reverse-proxy/src/Aenebris/WAF/Rule.hs b/PROJECTS/advanced/haskell-reverse-proxy/src/Aenebris/WAF/Rule.hsindex 5ea9854d..11d3e56b 100644--- a/PROJECTS/advanced/haskell-reverse-proxy/src/Aenebris/WAF/Rule.hs+++ b/PROJECTS/advanced/haskell-reverse-proxy/src/Aenebris/WAF/Rule.hs@@ -72,13 +72,16 @@ data Target| TargetUserAgentderiving (Eq, Show)-newtype CompiledRegex = CompiledRegex { unCompiledRegex :: Regex }+data CompiledRegex = CompiledRegex+ { unCompiledRegex :: !Regex+ , compiledRegexPattern :: !ByteString+ }instance Show CompiledRegex where- show _ = "<CompiledRegex>"+ show r = "<CompiledRegex " ++ show (compiledRegexPattern r) ++ ">"instance Eq CompiledRegex where- _ == _ = False+ a == b = compiledRegexPattern a == compiledRegexPattern bdata Operator= OpRegex !CompiledRegex@@ -115,13 +118,13 @@ compileRegex :: ByteString -> Either String CompiledRegexcompileRegex pat =case compile compOpts execOpts pat ofLeft err -> Left err- Right r -> Right (CompiledRegex r)+ Right r -> Right (CompiledRegex r pat)wherecompOpts = TDFA.defaultCompOpt { TDFA.caseSensitive = False }execOpts = TDFA.defaultExecOptrunRegex :: CompiledRegex -> ByteString -> Bool-runRegex (CompiledRegex r) input =- case execute r input of+runRegex cr input =+ case execute (unCompiledRegex cr) input ofRight (Just _) -> True_ -> Falsediff --git a/PROJECTS/advanced/haskell-reverse-proxy/test/Spec.hs b/PROJECTS/advanced/haskell-reverse-proxy/test/Spec.hsindex c9f1ca5e..d0914406 100644--- a/PROJECTS/advanced/haskell-reverse-proxy/test/Spec.hs+++ b/PROJECTS/advanced/haskell-reverse-proxy/test/Spec.hs@@ -817,6 +817,16 @@ wafSpec = describe "WAF" $ doseverityScore SevWarning `shouldBe` 3severityScore SevNotice `shouldBe` 2+ it "Eq CompiledRegex is reflexive (x == x)" $+ case compileRegex "abc" of+ Right r -> r `shouldBe` r+ Left err -> expectationFailure err++ it "Eq CompiledRegex distinguishes different patterns" $+ case (compileRegex "abc", compileRegex "def") of+ (Right r1, Right r2) -> (r1 == r2) `shouldBe` False+ _ -> expectationFailure "expected both to compile"+it "default ruleset includes rules" $length (rsRules defaultRuleSet) `shouldSatisfy` (> 0)@@ -2074,6 +2084,16 @@ mlLoaderSpec = describe "ML.Loader" $ do(T.replace "leaf_value=0.5\n" "leaf_value=0.5\nbogus=1\n" mlLoaderModel))`shouldSatisfy` isLeft+ it "rejects num_leaves above maxNumLeaves" $+ parseEnsemble+ (TE.encodeUtf8 (T.replace "num_leaves=1" "num_leaves=999999" mlLoaderModel))+ `shouldSatisfy` parseFailsAt "num_leaves"++ it "rejects num_leaves of 0" $+ parseEnsemble+ (TE.encodeUtf8 (T.replace "num_leaves=1" "num_leaves=0" mlLoaderModel))+ `shouldSatisfy` parseFailsAt "num_leaves"+describe "feature_names containing '='" $it "accepts feature_names with '=' in a name" $parseEnsemble