b157c1c · skrepka · git.iko.soy

git.iko.soy/skrepka

on master help sign in

Fix serverHost normalization mismatch, forward retry data loss, safeCompare timing leak, and SSRF gaps

b157c1ciko7 months ago

server.knot+47−36

compare with master

unifiedsplit

@@ -55,7 +55,7 @@ type GossipEvent = {eventType: Text, pubkey: Text, server: Text, timestamp: Int,

56*seqCounter : Int

58−*forwards : [{messageId: Text, toServer: Text, createdAt: Int}]

58+*forwards : [{messageId: Text, toServer: Text, createdAt: Int, toKey: Text, fromKey: Text, encryptedBlob: Text, timestamp: Int}]

60*ackedIds : [{messageId: Text, toKey: Text, ackedAt: Int}]

@@ -221,6 +221,12 @@ isAllDigitsOrDotsUntilColonOrEnd = \s ->

221 else if isDigitChar (take 1 s) || take 1 s == "." then isAllDigitsOrDotsUntilColonOrEnd (drop 1 s)

222 else False {}

223

224+isAllDigitsUntilColonOrEnd = \s ->

225+ if s == "" then True {}

226+ else if take 1 s == ":" then True {}

227+ else if isDigitChar (take 1 s) then isAllDigitsUntilColonOrEnd (drop 1 s)

228+ else False {}

229+

224toLowerChar = \c ->

230toLowerChar = \c ->

225 if c == "A" then "a" else if c == "B" then "b" else if c == "C" then "c"

231 if c == "A" then "a" else if c == "B" then "b" else if c == "C" then "c"

226 else if c == "D" then "d" else if c == "E" then "e" else if c == "F" then "f"

232 else if c == "D" then "d" else if c == "E" then "e" else if c == "F" then "f"

@@ -250,6 +256,8 @@ stripTrailingDot = \s ->

250

256

251normalizeServerName = \s -> toLower (stripTrailingDot s)

257normalizeServerName = \s -> toLower (stripTrailingDot s)

252

258

259+serverHostN = normalizeServerName serverHost

260+

253containsLocalhostSuffix = \s ->

261containsLocalhostSuffix = \s ->

254 if s == "" then False {}

262 if s == "" then False {}

255 else if take 10 s == ".localhost" && (drop 10 s == "" || take 1 (drop 10 s) == ":") then True {}

263 else if take 10 s == ".localhost" && (drop 10 s == "" || take 1 (drop 10 s) == ":") then True {}

@@ -281,7 +289,15 @@ isBadServerName = \s ->

281 || containsMultipleColons sn

289 || containsMultipleColons sn

282 || hasOctalOctet sn

290 || hasOctalOctet sn

283 || hasHexPrefix sn

291 || hasHexPrefix sn

284− || (isDigitChar (take 1 sn) && isAllDigitsOrDotsUntilColonOrEnd sn)

292+ || (isDigitChar (take 1 sn) && isAllDigitsUntilColonOrEnd sn)

293+ || take 4 sn == "224." || take 4 sn == "225." || take 4 sn == "226." || take 4 sn == "227."

294+ || take 4 sn == "228." || take 4 sn == "229." || take 4 sn == "230." || take 4 sn == "231."

295+ || take 4 sn == "232." || take 4 sn == "233." || take 4 sn == "234." || take 4 sn == "235."

296+ || take 4 sn == "236." || take 4 sn == "237." || take 4 sn == "238." || take 4 sn == "239."

297+ || take 4 sn == "240." || take 4 sn == "241." || take 4 sn == "242." || take 4 sn == "243."

298+ || take 4 sn == "244." || take 4 sn == "245." || take 4 sn == "246." || take 4 sn == "247."

299+ || take 4 sn == "248." || take 4 sn == "249." || take 4 sn == "250." || take 4 sn == "251."

300+ || take 4 sn == "252." || take 4 sn == "253." || take 4 sn == "254." || take 4 sn == "255."

285

301

286lookupSession = \sessions token t ->

302lookupSession = \sessions token t ->

287 single (do

303 single (do

@@ -312,8 +328,8 @@ verifyMaintenanceAuth = \authorization ->

312clampTtl = \ttl -> if ttl < 1 then 1 else if ttl > maxPresenceTtl then maxPresenceTtl else ttl

328clampTtl = \ttl -> if ttl < 1 then 1 else if ttl > maxPresenceTtl then maxPresenceTtl else ttl

313

329

314safeCompareLoop = \s1 s2 result ->

330safeCompareLoop = \s1 s2 result ->

315− if s2 == ""

331+ if s1 == "" && s2 == ""

316− then result + (if s1 == "" then 0 else 1)

332+ then result

317 else safeCompareLoop (drop 1 s1) (drop 1 s2) (result + (if take 1 s1 == take 1 s2 then 0 else 1))

333 else safeCompareLoop (drop 1 s1) (drop 1 s2) (result + (if take 1 s1 == take 1 s2 then 0 else 1))

318

334

319safeCompare = \a b ->

335safeCompare = \a b ->

@@ -330,7 +346,6 @@ sendToEach = \servers action ->

330 else do

346 else do

331 catch (action server) (\err -> do

347 catch (action server) (\err -> do

332 println ("federation: error reaching " ++ server ++ ", retrying: " ++ show err)

348 println ("federation: error reaching " ++ server ++ ", retrying: " ++ show err)

333− sleep 500

334 catch (action server) (\err2 -> do

349 catch (action server) (\err2 -> do

335 println ("federation: retry failed for " ++ server ++ ": " ++ show err2)

350 println ("federation: retry failed for " ++ server ++ ": " ++ show err2)

336 yield {}))

351 yield {}))

@@ -349,7 +364,7 @@ pruneExpired = \t -> do

349 yield s

364 yield s

350 presenceBefore <- *presence

365 presenceBefore <- *presence

351 let peerServersBefore = fold (\acc p ->

366 let peerServersBefore = fold (\acc p ->

352− if p.server == serverHost then acc

367+ if p.server == serverHostN then acc

353 else if count (do a <- acc; where a == p.server; yield a) > 0 then acc

368 else if count (do a <- acc; where a == p.server; yield a) > 0 then acc

354 else union acc [p.server]) [] presenceBefore

369 else union acc [p.server]) [] presenceBefore

355 let presenceAfter = do

370 let presenceAfter = do

@@ -375,11 +390,11 @@ pruneExpired = \t -> do

375 yield {expiredLocal: (do

390 yield {expiredLocal: (do

376 p <- presenceBefore

391 p <- presenceBefore

377 where p.expiresAt <= t

392 where p.expiresAt <= t

378− where p.server == serverHost

393+ where p.server == serverHostN

379 where count (do

394 where count (do

380 q <- presenceAfter

395 q <- presenceAfter

381 where q.pubkey == p.pubkey

396 where q.pubkey == p.pubkey

382− where q.server == serverHost

397+ where q.server == serverHostN

383 yield q) == 0

398 yield q) == 0

384 yield p), peerServers: peerServersBefore}

399 yield p), peerServers: peerServersBefore}

385

400

@@ -397,7 +412,7 @@ sendBatchedGossip = \peerServers allEvents ->

397 sendToEach peerServers (\server ->

412 sendToEach peerServers (\server ->

398 fetch (federationScheme ++ server) (RecvGossip {

413 fetch (federationScheme ++ server) (RecvGossip {

399 authorization: "Bearer " ++ federationSecret,

414 authorization: "Bearer " ++ federationSecret,

400− events: batch, hopsRemaining: 2, fromServer: serverHost}))

415+ events: batch, hopsRemaining: 2, fromServer: serverHostN}))

401 sendBatchedGossip peerServers rest

416 sendBatchedGossip peerServers rest

402

417

403broadcastOfflineGossip = \t peerServers expiredLocal -> do

418broadcastOfflineGossip = \t peerServers expiredLocal -> do

@@ -408,7 +423,7 @@ broadcastOfflineGossip = \t peerServers expiredLocal -> do

408 then do

423 then do

409 let gossipEvents = do

424 let gossipEvents = do

410 e <- expiredEntries

425 e <- expiredEntries

411− yield {eventType: "offline", pubkey: e.pubkey, server: serverHost, timestamp: t, ttl: e.ttl}

426+ yield {eventType: "offline", pubkey: e.pubkey, server: serverHostN, timestamp: t, ttl: e.ttl}

412 sendBatchedGossip peerServers gossipEvents

427 sendBatchedGossip peerServers gossipEvents

413 else yield {}

428 else yield {}

414

429

@@ -423,7 +438,7 @@ retryPendingForwards = \pending ->

423 else do

438 else do

424 catch (fetch (federationScheme ++ f.toServer) (ForwardMessage {

439 catch (fetch (federationScheme ++ f.toServer) (ForwardMessage {

425 toKey: f.toKey, fromKey: f.fromKey, encryptedBlob: f.encryptedBlob,

440 toKey: f.toKey, fromKey: f.fromKey, encryptedBlob: f.encryptedBlob,

426− timestamp: f.timestamp, originServer: serverHost, messageId: f.messageId,

441+ timestamp: f.timestamp, originServer: serverHostN, messageId: f.messageId,

427 authorization: "Bearer " ++ federationSecret})) (\err ->

442 authorization: "Bearer " ++ federationSecret})) (\err ->

428 println ("prune: retry forward to " ++ f.toServer ++ " failed: " ++ show err))

443 println ("prune: retry forward to " ++ f.toServer ++ " failed: " ++ show err))

429 retryPendingForwards rest

444 retryPendingForwards rest

@@ -525,7 +540,7 @@ serve = \req -> case req of

525 else sessions

540 else sessions

526 let presenceWithout = do

541 let presenceWithout = do

527 p <- presence

542 p <- presence

528− where not (p.pubkey == pubkey && p.server == serverHost)

543+ where not (p.pubkey == pubkey && p.server == serverHostN)

529 yield p

544 yield p

530 let oldestPresenceExp = fold (\acc p -> if acc == -1 || p.expiresAt < acc then p.expiresAt else acc) -1 presenceWithout

545 let oldestPresenceExp = fold (\acc p -> if acc == -1 || p.expiresAt < acc then p.expiresAt else acc) -1 presenceWithout

531 let presenceEvicted = if count presenceWithout >= maxPresenceEntries && oldestPresenceExp >= 0

546 let presenceEvicted = if count presenceWithout >= maxPresenceEntries && oldestPresenceExp >= 0

@@ -535,12 +550,12 @@ serve = \req -> case req of

535 else {removed: acc.removed, items: union acc.items [p]}) {removed: False {}, items: []} presenceWithout).items

550 else {removed: acc.removed, items: union acc.items [p]}) {removed: False {}, items: []} presenceWithout).items

536 else presenceWithout

551 else presenceWithout

537 let updatedPresence = if sigValid

552 let updatedPresence = if sigValid

538− then union presenceEvicted [{pubkey: pubkey, server: serverHost, expiresAt: expiry, timestamp: t}]

553+ then union presenceEvicted [{pubkey: pubkey, server: serverHostN, expiresAt: expiry, timestamp: t}]

539 else presence

554 else presence

540 set *presence = updatedPresence

555 set *presence = updatedPresence

541 let peerServers = if sigValid && not (federationSecret == "")

556 let peerServers = if sigValid && not (federationSecret == "")

542 then fold (\acc p ->

557 then fold (\acc p ->

543− if p.server == serverHost then acc

558+ if p.server == serverHostN then acc

544 else if count (do a <- acc; where a == p.server; yield a) > 0 then acc

559 else if count (do a <- acc; where a == p.server; yield a) > 0 then acc

545 else union acc [p.server]) [] updatedPresence

560 else union acc [p.server]) [] updatedPresence

546 else []

561 else []

@@ -552,7 +567,7 @@ serve = \req -> case req of

552 then sendToEach result.peerServers (\server ->

567 then sendToEach result.peerServers (\server ->

553 fetch (federationScheme ++ server) (RecvGossip {

568 fetch (federationScheme ++ server) (RecvGossip {

554 authorization: "Bearer " ++ federationSecret,

569 authorization: "Bearer " ++ federationSecret,

555− events: [{eventType: "online", pubkey: pubkey, server: serverHost, timestamp: t, ttl: onlineGossipTtl}], hopsRemaining: 2, fromServer: serverHost}))

570+ events: [{eventType: "online", pubkey: pubkey, server: serverHostN, timestamp: t, ttl: onlineGossipTtl}], hopsRemaining: 2, fromServer: serverHostN}))

556 else yield {}

571 else yield {}

557 broadcastOfflineGossip t result.offlinePeers (do

572 broadcastOfflineGossip t result.offlinePeers (do

558 p <- result.expiredLocal

573 p <- result.expiredLocal

@@ -635,7 +650,7 @@ serve = \req -> case req of

635 Just {value: _} -> count (do

650 Just {value: _} -> count (do

636 p <- presence

651 p <- presence

637 where p.pubkey == to

652 where p.pubkey == to

638− where p.server == serverHost

653+ where p.server == serverHostN

639 where p.expiresAt > t

654 where p.expiresAt > t

640 yield p) > 0

655 yield p) > 0

641 let remoteServers = case session of

656 let remoteServers = case session of

@@ -643,7 +658,7 @@ serve = \req -> case req of

643 Just {value: _} -> do

658 Just {value: _} -> do

644 p <- presence

659 p <- presence

645 where p.pubkey == to

660 where p.pubkey == to

646− where not (p.server == serverHost)

661+ where not (p.server == serverHostN)

647 where p.expiresAt > t

662 where p.expiresAt > t

648 yield p.server

663 yield p.server

649 let fromKey = case session of

664 let fromKey = case session of

@@ -658,7 +673,7 @@ serve = \req -> case req of

658 forwards <- *forwards

673 forwards <- *forwards

659 let forwardsAtCapacity = count forwards >= maxForwardsEntries

674 let forwardsAtCapacity = count forwards >= maxForwardsEntries

660 set *forwards = if shouldInsert && not forwardsAtCapacity && count remoteServers > 0

675 set *forwards = if shouldInsert && not forwardsAtCapacity && count remoteServers > 0

661− then union forwards (do s <- remoteServers; yield {messageId: msgId, toServer: s, createdAt: t})

676+ then union forwards (do s <- remoteServers; yield {messageId: msgId, toServer: s, createdAt: t, toKey: to, fromKey: fromKey, encryptedBlob: encryptedBlob, timestamp: clampedTs})

662 else forwards

677 else forwards

663 yield {status: status, remoteServers: remoteServers, fromKey: fromKey, expiredLocal: pr.expiredLocal, peerServers: pr.peerServers, forwardsAtCapacity: forwardsAtCapacity}

678 yield {status: status, remoteServers: remoteServers, fromKey: fromKey, expiredLocal: pr.expiredLocal, peerServers: pr.peerServers, forwardsAtCapacity: forwardsAtCapacity}

664 let finalStatus = if result.status == "federated" && federationSecret == "" then "queued" else result.status

679 let finalStatus = if result.status == "federated" && federationSecret == "" then "queued" else result.status

@@ -667,7 +682,7 @@ serve = \req -> case req of

667 then sendToEach result.remoteServers (\server ->

682 then sendToEach result.remoteServers (\server ->

668 fetch (federationScheme ++ server) (ForwardMessage {

683 fetch (federationScheme ++ server) (ForwardMessage {

669 toKey: to, fromKey: result.fromKey, encryptedBlob: encryptedBlob,

684 toKey: to, fromKey: result.fromKey, encryptedBlob: encryptedBlob,

670− timestamp: clampedTs, originServer: serverHost, messageId: msgId,

685+ timestamp: clampedTs, originServer: serverHostN, messageId: msgId,

671 authorization: "Bearer " ++ federationSecret}))

686 authorization: "Bearer " ++ federationSecret}))

672 else yield {}

687 else yield {}

673 if result.forwardsAtCapacity && count result.remoteServers > 0 && not (result.status == "unauthorized") && not (result.status == "invalid")

688 if result.forwardsAtCapacity && count result.remoteServers > 0 && not (result.status == "unauthorized") && not (result.status == "invalid")

@@ -703,7 +718,7 @@ serve = \req -> case req of

703 let ackedFederated = do

718 let ackedFederated = do

704 m <- ackedMessages

719 m <- ackedMessages

705 where not (m.originServer == "")

720 where not (m.originServer == "")

706− where not (m.originServer == serverHost)

721+ where not (m.originServer == serverHostN)

707 yield {messageId: m.messageId, toKey: m.toKey, ackedAt: t}

722 yield {messageId: m.messageId, toKey: m.toKey, ackedAt: t}

708 ackedIds <- *ackedIds

723 ackedIds <- *ackedIds

709 set *ackedIds = union ackedIds ackedFederated

724 set *ackedIds = union ackedIds ackedFederated

@@ -714,7 +729,7 @@ serve = \req -> case req of

714 let fedMessages = do

729 let fedMessages = do

715 m <- result.ackedMessages

730 m <- result.ackedMessages

716 where not (m.originServer == "")

731 where not (m.originServer == "")

717− where not (m.originServer == serverHost)

732+ where not (m.originServer == serverHostN)

718 yield m

733 yield m

719 let originServers = fold (\acc m ->

734 let originServers = fold (\acc m ->

720 if count (do a <- acc; where a == m.originServer; yield a) > 0 then acc

735 if count (do a <- acc; where a == m.originServer; yield a) > 0 then acc

@@ -725,7 +740,7 @@ serve = \req -> case req of

725 fetch (federationScheme ++ server) (FederationAck {

740 fetch (federationScheme ++ server) (FederationAck {

726 authorization: "Bearer " ++ federationSecret,

741 authorization: "Bearer " ++ federationSecret,

727 messageIds: (do m <- fedMessages; where m.originServer == server; yield m.messageId),

742 messageIds: (do m <- fedMessages; where m.originServer == server; yield m.messageId),

728− originServer: server, fromServer: serverHost}))

743+ originServer: server, fromServer: serverHostN}))

729 else yield {}

744 else yield {}

730 broadcastOfflineGossip t result.peerServers result.expiredLocal

745 broadcastOfflineGossip t result.peerServers result.expiredLocal

731

746

@@ -753,7 +768,7 @@ serve = \req -> case req of

753 then ""

768 then ""

754 else case single (do

769 else case single (do

755 p <- valid

770 p <- valid

756− where p.server == serverHost

771+ where p.server == serverHostN

757 yield p) of

772 yield p) of

758 Just {value: p} -> p.server

773 Just {value: p} -> p.server

759 Nothing {} -> (fold (\acc p -> if p.expiresAt > acc.best then {server: p.server, best: p.expiresAt} else acc) {server: "", best: 0} valid).server

774 Nothing {} -> (fold (\acc p -> if p.expiresAt > acc.best then {server: p.server, best: p.expiresAt} else acc) {server: "", best: 0} valid).server

@@ -766,7 +781,7 @@ serve = \req -> case req of

766 let authorized = verifyFederationAuth authorization

781 let authorized = verifyFederationAuth authorization

767 let cappedHops = if hopsRemaining > 5 then 5 else hopsRemaining

782 let cappedHops = if hopsRemaining > 5 then 5 else hopsRemaining

768 let fromServer = normalizeServerName fromServer

783 let fromServer = normalizeServerName fromServer

769− let validRequest = authorized && cappedHops >= 1 && not (fromServer == "") && not (fromServer == serverHost) && not (tooLong fromServer maxServerNameLen) && not (isBadServerName fromServer) && count events <= maxGossipEvents

784+ let validRequest = authorized && cappedHops >= 1 && not (fromServer == "") && not (fromServer == serverHostN) && not (tooLong fromServer maxServerNameLen) && not (isBadServerName fromServer) && count events <= maxGossipEvents

770 let onlineEntries = do

785 let onlineEntries = do

771 e <- events

786 e <- events

772 where validRequest

787 where validRequest

@@ -777,7 +792,7 @@ serve = \req -> case req of

777 where not (tooLong e.server maxServerNameLen)

792 where not (tooLong e.server maxServerNameLen)

778 where not (isBadServerName e.server)

793 where not (isBadServerName e.server)

779 where isValidHex e.pubkey

794 where isValidHex e.pubkey

780− where not (normalizeServerName e.server == serverHost)

795+ where not (normalizeServerName e.server == serverHostN)

781 where e.timestamp <= t + clockSkewTolerance

796 where e.timestamp <= t + clockSkewTolerance

782 where e.timestamp + (clampTtl e.ttl) * 1000 > t

797 where e.timestamp + (clampTtl e.ttl) * 1000 > t

783 yield {pubkey: normalizeHex e.pubkey, server: normalizeServerName e.server, expiresAt: e.timestamp + (clampTtl e.ttl) * 1000, timestamp: e.timestamp}

798 yield {pubkey: normalizeHex e.pubkey, server: normalizeServerName e.server, expiresAt: e.timestamp + (clampTtl e.ttl) * 1000, timestamp: e.timestamp}

@@ -791,7 +806,7 @@ serve = \req -> case req of

791 where not (tooLong e.server maxServerNameLen)

806 where not (tooLong e.server maxServerNameLen)

792 where not (isBadServerName e.server)

807 where not (isBadServerName e.server)

793 where isValidHex e.pubkey

808 where isValidHex e.pubkey

794− where not (normalizeServerName e.server == serverHost)

809+ where not (normalizeServerName e.server == serverHostN)

795 where e.timestamp <= t + clockSkewTolerance

810 where e.timestamp <= t + clockSkewTolerance

796 where t - e.timestamp < (clampTtl e.ttl) * 1000

811 where t - e.timestamp < (clampTtl e.ttl) * 1000

797 yield {pubkey: normalizeHex e.pubkey, server: normalizeServerName e.server, timestamp: e.timestamp}

812 yield {pubkey: normalizeHex e.pubkey, server: normalizeServerName e.server, timestamp: e.timestamp}

@@ -954,7 +969,7 @@ serve = \req -> case req of

954 else presence

969 else presence

955 set *presence = finalPresence

970 set *presence = finalPresence

956 let gossipPeerServers = fold (\acc p ->

971 let gossipPeerServers = fold (\acc p ->

957− if p.server == serverHost then acc

972+ if p.server == serverHostN then acc

958 else if count (do a <- acc; where a == p.server; yield a) > 0 then acc

973 else if count (do a <- acc; where a == p.server; yield a) > 0 then acc

959 else union acc [p.server]) [] finalPresence

974 else union acc [p.server]) [] finalPresence

960 yield {appliedKeys: (if withinCapacity then union appliedOnline appliedOffline else union appliedOnlineUpdates appliedOffline), expiredLocal: pr.expiredLocal, peerServers: pr.peerServers, gossipPeerServers: gossipPeerServers, withinCapacity: withinCapacity}

975 yield {appliedKeys: (if withinCapacity then union appliedOnline appliedOffline else union appliedOnlineUpdates appliedOffline), expiredLocal: pr.expiredLocal, peerServers: pr.peerServers, gossipPeerServers: gossipPeerServers, withinCapacity: withinCapacity}

@@ -968,7 +983,7 @@ serve = \req -> case req of

968 where not (tooLong e.server maxServerNameLen)

983 where not (tooLong e.server maxServerNameLen)

969 where not (isBadServerName e.server)

984 where not (isBadServerName e.server)

970 where isValidHex e.pubkey

985 where isValidHex e.pubkey

971− where not (normalizeServerName e.server == serverHost)

986+ where not (normalizeServerName e.server == serverHostN)

972 where e.timestamp <= t + clockSkewTolerance

987 where e.timestamp <= t + clockSkewTolerance

973 where e.timestamp + (clampTtl e.ttl) * 1000 > t

988 where e.timestamp + (clampTtl e.ttl) * 1000 > t

974 where not (e.eventType == "online" && count (do

989 where not (e.eventType == "online" && count (do

@@ -998,7 +1013,7 @@ serve = \req -> case req of

998 sendToEach targets (\server ->

1013 sendToEach targets (\server ->

999 fetch (federationScheme ++ server) (RecvGossip {

1014 fetch (federationScheme ++ server) (RecvGossip {

1000 authorization: "Bearer " ++ federationSecret,

1015 authorization: "Bearer " ++ federationSecret,

1001− events: effectiveEvents, hopsRemaining: cappedHops - 1, fromServer: serverHost}))

1016+ events: effectiveEvents, hopsRemaining: cappedHops - 1, fromServer: serverHostN}))

1002 else yield {}

1017 else yield {}

1003 broadcastOfflineGossip t gossipResult.peerServers gossipResult.expiredLocal

1018 broadcastOfflineGossip t gossipResult.peerServers gossipResult.expiredLocal

1004

1019

@@ -1011,7 +1026,7 @@ serve = \req -> case req of

1011 let originServer = normalizeServerName originServer

1026 let originServer = normalizeServerName originServer

1012 t <- now

1027 t <- now

1013 let authorized = verifyFederationAuth authorization

1028 let authorized = verifyFederationAuth authorization

1014− let validOrigin = not (originServer == "") && not (originServer == serverHost) && not (tooLong originServer maxServerNameLen) && not (isBadServerName originServer)

1029+ let validOrigin = not (originServer == "") && not (originServer == serverHostN) && not (tooLong originServer maxServerNameLen) && not (isBadServerName originServer)

1015 let clampedTs = if timestamp > t then t else if timestamp < t - messageMaxAge then t - messageMaxAge else timestamp

1030 let clampedTs = if timestamp > t then t else if timestamp < t - messageMaxAge then t - messageMaxAge else timestamp

1016 result <- atomic do

1031 result <- atomic do

1017 pr <- pruneExpired t

1032 pr <- pruneExpired t

@@ -1059,7 +1074,7 @@ serve = \req -> case req of

1059 else if not (isValidHex mid) then acc

1074 else if not (isValidHex mid) then acc

1060 else if count (do a <- acc; where a == normalizeHex mid; yield a) > 0 then acc

1075 else if count (do a <- acc; where a == normalizeHex mid; yield a) > 0 then acc

1061 else union acc [normalizeHex mid]) [] messageIds

1076 else union acc [normalizeHex mid]) [] messageIds

1062− let validAckFields = authorized && originServer == serverHost && not (fromServer == "") && not (fromServer == serverHost) && not (tooLong fromServer maxServerNameLen) && not (isBadServerName fromServer)

1077+ let validAckFields = authorized && originServer == serverHostN && not (fromServer == "") && not (fromServer == serverHostN) && not (tooLong fromServer maxServerNameLen) && not (isBadServerName fromServer)

1063 pruneResult <- atomic do

1078 pruneResult <- atomic do

1064 pr <- pruneExpired t

1079 pr <- pruneExpired t

1065 forwards <- *forwards

1080 forwards <- *forwards

@@ -1085,13 +1100,9 @@ serve = \req -> case req of

1085 result <- atomic do

1100 result <- atomic do

1086 pr <- pruneExpired t

1101 pr <- pruneExpired t

1087 forwards <- *forwards

1102 forwards <- *forwards

1088− messages <- *messages

1089 let pendingForwards = do

1103 let pendingForwards = do

1090 f <- forwards

1104 f <- forwards

1091− m <- messages

1092− where m.messageId == f.messageId

1093− where m.originServer == ""

1094− yield {toServer: f.toServer, toKey: m.toKey, fromKey: m.fromKey, encryptedBlob: m.encryptedBlob, timestamp: m.timestamp, messageId: m.messageId}

1105+ yield {toServer: f.toServer, toKey: f.toKey, fromKey: f.fromKey, encryptedBlob: f.encryptedBlob, timestamp: f.timestamp, messageId: f.messageId}

1095 yield {expiredLocal: pr.expiredLocal, peerServers: pr.peerServers, pendingForwards: pendingForwards}

1106 yield {expiredLocal: pr.expiredLocal, peerServers: pr.peerServers, pendingForwards: pendingForwards}

1096 respond {ok: True {}}

1107 respond {ok: True {}}

1097 broadcastOfflineGossip t result.peerServers result.expiredLocal

1108 broadcastOfflineGossip t result.peerServers result.expiredLocal