summaryrefslogtreecommitdiff
path: root/SybilLimit.hs
blob: 91433ba817b53b986bad24c562053c321568b122 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
{-# LANGUAGE StandaloneDeriving #-}
module SybilLimit where

import Data.List ( foldl', minimumBy )
import Data.Maybe ( fromMaybe )
import Data.Ord ( comparing )
import Data.IntMap.Strict ( IntMap, (!) )
import qualified Data.IntMap.Strict as IntMap
import Data.Traversable ( sequenceA )
import Control.Applicative
-- import System.Random
import Data.Map.Strict ( Map )
import qualified Data.Map as Map

import Stochastic

data NodeId

deriving instance Ord NodeId
deriving instance Eq NodeId

data ThisNode = ThisNode
    { selfId :: NodeId
    , friends :: IntMap FriendNode
    , friendById :: Map NodeId Int
    , routeTails :: IntMap (NodeId,NodeId)
    -- ^ Terminal edge by instance number.
    , tailCounters :: IntMap Int
    -- ^ verificaiton counter by instance number.
    , routeCount :: Int
    -- ^ The r parameter of SybilLimit.
    , pendingVerifications :: Map NodeId PendingIntersection
    }

data FriendNode = FriendNode
    { friendId :: NodeId
    , routesTo :: IntMap Int
    -- ^ Forward random-route hop by instance number.
    , routesFrom :: IntMap Int
    -- ^ Backward random-route hop by instance number.
    , registeredTerminal :: Maybe NodeId
    -- ^ Currently registered terminal edge.
    -- The NodeId indicates the source vertex, friendId is the destination vertex.
    }


-- | When 'iPendingTails' is empty, the intersection condition is passed if and
-- only if 'iVerifiedTails' is not empty.
data PendingIntersection = PendingIntersection
    { iSuspect :: NodeId -- todo: neccessary?
    , iPendingTails :: Map (NodeId,NodeId) [Int]
    , iVerifiedTails :: Map (NodeId,NodeId) [Int]
    }

data PeerMessage
    = ForwardRRMessage { rrRoute :: Int
                       , rrCount :: Int
                       , rrSuspect :: NodeId }
    | BackwardRRMessage { rrRoute :: Int
                        , rrCount :: Int
                        , rrTail :: (NodeId,NodeId) }
    | RegistrationQuery { rrSuspect :: NodeId
                        , rrRegisteredFrom :: NodeId }
    | RegistrationResponse { rrSuspect :: NodeId
                           , rrRegisteredFrom :: NodeId
                           , rrValidRegistration :: Bool }


data SybilCheck
    = SybilCheck { chkSuspect :: NodeId
                 , chkAccepted :: Bool }

data MessageReaction = MessageReaction
    { changedState :: ThisNode
    , outgoingMessages :: [(NodeId, PeerMessage)]
    , sybilChecks :: [SybilCheck]
    }

friendNode :: NodeId -> FriendNode
friendNode nid = FriendNode nid IntMap.empty IntMap.empty Nothing

friendCount :: ThisNode -> Int
friendCount me = IntMap.size $ friends me

todo :: a
todo = error "unimplemented"

-- | @ addFriend @ adds a friend and updates the random route instances.
--
-- Arguments:
--
--   [@them@] The 'NodeId' of the friend being added.
--
--   [@me@]   'ThisNode' prior to the friend being added.
--
-- Returns the altered 'ThisNode' and the list of friend numbers
-- for which we should send notifications about the change.
--
addFriend :: NodeId -> ThisNode -> Stochastic ( ThisNode, [Int] )
addFriend them me = fmap (\ks -> (addFriend' ks them me,ks)) mks
 where
    d   = friendCount me
    mks = sequenceA $ replicate (routeCount me) $ random 0 d

    addFriend' :: [Int] -> NodeId -> ThisNode -> ThisNode
    addFriend' ks them me = me { friends = fs, friendById = ids }
     where
        d   = friendCount me
        fs0 = IntMap.insert d (friendNode them) $ friends me
        ids = Map.insert them d (friendById me)
        fs  = foldl' (flip $ uncurry updateRoute) fs0 edges
            where edges = zip [0..] (map mkEdge ks)
                  mkEdge k = if k==d then (d,d) else (k,d)

-- | @ updateRoute @ updates one of the random routes used by SybilLimit.
--
--  [@i@]     The random route instance number.
--
--  [@(k,j)@] A pair of friend numbers.  The routes inbound from friend @k@
--            will be routed out to friend @j@ for the s-direction (forwards)
--            and vice versa for the v-direction (backwards).
--
--  [@fs@]    The current friend map prior to changed route.
--
-- Returns:  The friend map with changes applied.
--
updateRoute :: Int -> (Int,Int) -> IntMap FriendNode -> IntMap FriendNode
updateRoute i (k,j) fs = jfromk $ ktoj fs
 where
    ktoj fs   = IntMap.insert k (setTo   i j (fs!k)) fs
    jfromk fs = IntMap.insert j (setFrom i k (fs!j)) fs

    setTo i x f   = f { routesTo   = IntMap.insert i x (routesTo f)}
    setFrom i x f = f { routesFrom = IntMap.insert i x (routesFrom f)}


forwardMessage :: ThisNode -> (FriendNode -> IntMap Int) -> (NodeId,PeerMessage) -> (NodeId, PeerMessage)
forwardMessage me next (srcId,msg) = msg'
      where msg' = ( dest, msg { rrCount = rrCount msg + 1 } )
            srcno = friendById me Map.! srcId
            destno = next (friends me ! srcno) ! rrRoute msg
            dest = friendId (friends me ! destno)

reactToMessage :: Int -> (NodeId,PeerMessage) -> ThisNode -> MessageReaction
reactToMessage w (srcId, msg@(RegistrationResponse {})) me =
    MessageReaction me' [] sybils
 where
    me0 = me { pendingVerifications = vs' }
    vs' :: Map NodeId PendingIntersection
    vs' = Map.adjust adj (rrSuspect msg) $ pendingVerifications me
    tail = (rrRegisteredFrom msg, srcId)
    adj p = p { iPendingTails = Map.delete tail $ iPendingTails p
              , iVerifiedTails =
                    if rrValidRegistration msg then goodTail else iVerifiedTails p
              }
        where goodTail = Map.insert tail indexes
                                    $ iVerifiedTails p
              indexes = fromMaybe [] $ Map.lookup tail $ iPendingTails p
    icheck = pendingVerifications me0 Map.! rrSuspect msg
    (me',sybils) = if Map.null (iPendingTails icheck) then bcheck else (me0, [])
        where bcheck = if Map.null (iVerifiedTails icheck)
                        then (me0, dishonest)
                        else balanceCheck
              dishonest = [SybilCheck (rrSuspect msg) False]
              indexes = fromMaybe [] $ Map.lookup tail $ iVerifiedTails icheck
              balanceCheck = second chk $ balanceCondition tail indexes me0
                where chk = (:[]) . SybilCheck (rrSuspect msg)
                      second f (x,y) = (x,f y)

reactToMessage w (srcId, msg@(RegistrationQuery {})) me =
    MessageReaction me [(srcId,resp)] []
 where
    resp = RegistrationResponse { rrSuspect = rrSuspect msg
                                , rrRegisteredFrom = rrRegisteredFrom msg
                                , rrValidRegistration = check }
    key = friendById me Map.! rrRegisteredFrom msg
    check = registeredTerminal (friends me ! key) == Just (rrSuspect msg)

reactToMessage w (srcId, msg) me =
    if rrCount msg == w then terminate
                        else MessageReaction me [forwardMessage me next (srcId,msg)] []
 where
    (terminate,next) = case msg of
                        ForwardRRMessage {} -> ( terminateForward, routesTo )
                        BackwardRRMessage {} -> ( terminateBackward, routesFrom )

    terminateForward = MessageReaction me { friends = friends' }
                                       [pong]
                                       []
      where pong =( srcId, BackwardRRMessage { rrCount = 1
                                             , rrRoute = rrRoute msg
                                             , rrTail = (srcId, selfId me)
                                             } )
            friends' = IntMap.adjust adj suspectNo $ friends me
            suspectNo = friendById me Map.! rrSuspect msg
            adj f = f { registeredTerminal = Just $ rrSuspect msg }

    terminateBackward = MessageReaction me' [] []
      where me' = me { routeTails =
                        IntMap.insert (rrRoute msg) (rrTail msg)
                                     $ routeTails me
                     }

balanceCondition :: (NodeId,NodeId) -> [Int] -> ThisNode -> (ThisNode, Bool)
balanceCondition (ka,kb) routeNums me = (me',didPass)
 where
    me' = me { tailCounters = counters' }
     where
        counters' = if didPass then incremented else tailCounters me
        incremented = IntMap.adjust (+1) cmin $ tailCounters me

    didPass = fromIntegral (cmin + 1) <= b

    b = h * max (logBase 2 r) a :: Double
     where
        r = fromIntegral $ routeCount me
        a = fromIntegral ( 1 + sum (IntMap.elems $ tailCounters me) ) / r
        h = 4 -- h > 1 is some universal constant that is not too small (they used
              -- h = 4 in their experiments).
    cmin = minimumBy indexCompare routeNums
     where
        indexCompare ca cb = tieBreak $ comparing (tailCounters me !) ca cb
         where
            tieBreak EQ = compare ca cb
            tieBreak x = x