<> <> <> <> <<>> <> <> <> <> <<>> DIRECTORY AuthenticationP14V2 USING [AuthenticationError, CallError, CallProblem, ChangeSimpleKey, ChangeStrongKey, CheckSimpleCredentials, CreateSimpleKey, CreateStrongKey, CredentialsPackage, DeleteSimpleKey, DeleteStrongKey, GetStrongCredentials, HashedPassword, Problem, SeqWords, SeqWordsObject, StrongCredentials, StrongVerifier, Which], Basics USING [BITXOR, HWORD, LongNumber, Word16], BasicTime USING [earliestGMT, FromNSTime, GetClockPulses, GMT, latestGMT, Now, OutOfRange, Period, TimeNotKnown, ToNSTime, Unpack, Unpacked, Update], CrRPC USING [CreateClientHandle, DestroyClientHandle, Error, Handle, MarshalledRopeHWords], DESFace USING [Block, Blocks, CBCCheckDecrypt, CBCCheckEncrypt, CorrectParity, EncryptBlock, Key, nullKey], Finalize USING [Handle, HandleToObject], FinalizeOps USING [CallQueue, CreateCallQueue, EnableFinalization, FinalizeProc], Process USING [Detach, PauseMsec], RefText USING [InlineAppendChar, ObtainScratch, ReleaseScratch], Rope USING [Equal, FromRefText, Fetch, Length, ROPE], TimeP15V2 USING [Time], XNS USING [Address, GetThisHost, Host, unknownHost, unknownSocket], XNSAuth USING [Credentials, CredentialsType, HashedPassword, Key, Name, Verifier], XNSRouter USING [GetHops, Hops], XNSServerLocation USING [EachAddressProc, LocateServers, StopBroadcast], XNSWKS USING [authenticationInfo] ; XNSAuthImpl: CEDAR MONITOR LOCKS lock USING lock: Lock IMPORTS AuthenticationP14V2, Basics, BasicTime, CrRPC, DESFace, Finalize, FinalizeOps, Process, RefText, Rope, XNS, XNSRouter, XNSServerLocation EXPORTS XNSAuth ~ { OPEN Auth: AuthenticationP14V2, Time: TimeP15V2; authPgmNum: CARD32 ~ 14; authVersionNum: CARD16 ~ 2; SeqWords: TYPE ~ Auth.SeqWords; SeqWordsObject: TYPE ~ Auth.SeqWordsObject; GMT: TYPE ~ BasicTime.GMT; Block: TYPE ~ DESFace.Block; ROPE: TYPE ~ Rope.ROPE; NSTime: TYPE ~ Time.Time; Credentials: TYPE ~ XNSAuth.Credentials; CredentialsType: TYPE ~ XNSAuth.CredentialsType; HashedPassword: TYPE ~ XNSAuth.HashedPassword; Key: TYPE ~ XNSAuth.Key; Name: TYPE ~ XNSAuth.Name; Verifier: TYPE ~ XNSAuth.Verifier; HostNumber: TYPE ~ XNS.Host; myHostNumber: HostNumber Ź XNS.GetThisHost[]; authSvcName: Name Ź ["CHServers", "CHServers", "Authentication Service"]; initialStrongVerifier: Auth.StrongVerifier ~ [BasicTime.ToNSTime[BasicTime.earliestGMT], 0]; oneMinuteOfSeconds: INT ~ 60; oneHourOfSeconds: INT ~ INT[60]*oneMinuteOfSeconds; oneDayOfSeconds: INT ~ INT[24]*oneHourOfSeconds; oneWeekOfSeconds: INT ~ INT[7]*oneDayOfSeconds; strongCredentialsLifetime: INT ~ oneDayOfSeconds; strongVerifierTimeout: INT ~ oneMinuteOfSeconds; msecBetweenSweeps: INT Ź INT[10]*oneMinuteOfSeconds*INT[1000]; unknownTime: GMT Ź BasicTime.Update[BasicTime.earliestGMT, oneWeekOfSeconds]; Now: PROC RETURNS [now: GMT] ~ INLINE { now Ź BasicTime.Now[ ! BasicTime.TimeNotKnown => { now Ź unknownTime; CONTINUE } ] }; AuthenticationError: PUBLIC ERROR [problem: Auth.Problem] Ź Auth.AuthenticationError; CallError: PUBLIC ERROR[problem: Auth.CallProblem, whichArg: Auth.Which] Ź Auth.CallError; MarshallError: PRIVATE ERROR ~ CODE; CantContactAuthServer: PROC ~ { <> ERROR CallError[problem~other, whichArg~notApplicable] }; Lock: TYPE ~ REF LockObject; LockObject: TYPE ~ MONITORED RECORD []; <> <> SimpleIdentity: TYPE ~ REF SimpleIdentityObject; SimpleIdentityObject: TYPE ~ RECORD [ name: Name, password: ROPE, valid: BOOL Ź TRUE, credentials: Credentials, verifier: Verifier ]; StrongIdentity: TYPE ~ REF StrongIdentityObject; StrongIdentityObject: TYPE ~ RECORD [ next: Finalize.Handle, conversations: StrongConversation, name: Name, password: ROPE, -- optional, if present must agree with key valid: BOOL Ź TRUE, key: Key ]; Identity: TYPE ~ REF; -- SimpleIdentityObject initiatorCacheLock: Lock ~ NEW[LockObject Ź []]; strongIdentities: Finalize.Handle Ź NIL; IdFromH: PROC [it: Finalize.Handle] RETURNS [id: StrongIdentity] ~ INLINE { id Ź NARROW[Finalize.HandleToObject[it]] }; AddNewStrongIdentity: ENTRY PROC [lock: Lock Ź initiatorCacheLock, newIDHandle: Finalize.Handle] ~ { IdFromH[newIDHandle].next Ź strongIdentities; strongIdentities Ź newIDHandle }; RemoveOldStrongIdentity: ENTRY PROC [lock: Lock Ź initiatorCacheLock, oldIDHandle: Finalize.Handle] ~ { h, hPrev: Finalize.Handle; h Ź strongIdentities; hPrev Ź NIL; WHILE (h # NIL) AND (h # oldIDHandle) DO hPrev Ź h; h Ź IdFromH[h].next; ENDLOOP; IF h # NIL THEN { IF hPrev # NIL THEN IdFromH[hPrev].next Ź IdFromH[h].next ELSE strongIdentities Ź IdFromH[h].next }; }; strongIdentityFinalizerQueue: FinalizeOps.CallQueue Ź FinalizeOps.CreateCallQueue[StrongIdentityFinalizer]; droppedStrongIdentities: CARD Ź 0; StrongIdentityFinalizer: FinalizeOps.FinalizeProc ~ { RemoveOldStrongIdentity[oldIDHandle~handle]; droppedStrongIdentities Ź droppedStrongIdentities.SUCC; }; MakeIdentity: PUBLIC PROC[name: Name, password: ROPE, credentialsType: CredentialsType Ź strong, check: BOOL Ź TRUE] RETURNS [identity: Identity] ~ { SELECT credentialsType FROM simple => { simpleID: SimpleIdentity; simpleID Ź NEW[SimpleIdentityObject Ź [name~name, password~password, credentials~CredentialsFromName[name], verifier~VerifierFromHashedPassword[SimpleKeyFromPassword[password]]]]; identity Ź simpleID; IF check THEN CheckSimple[simpleID.credentials, simpleID.verifier]; }; strong => { strongID: StrongIdentity Ź NEW[StrongIdentityObject Ź [name~name, password~password, key~StrongKeyFromPassword[password]]]; { h: Finalize.Handle Ź FinalizeOps.EnableFinalization[strongID, strongIdentityFinalizerQueue]; AddNewStrongIdentity[newIDHandle~h]; }; identity Ź strongID; IF check THEN Terminate[Initiate[identity, authSvcName, 60]]; }; ENDCASE => ERROR; }; MakeStrongIdentityUsingKey: PUBLIC PROC[name: Name, key: Key, check: BOOL Ź TRUE] RETURNS [identity: Identity] ~ { strongID: StrongIdentity; TRUSTED { DESFace.CorrectParity[LOOPHOLE[LONG[@key]]] }; strongID Ź NEW[StrongIdentityObject Ź [name~name, password~NIL, key~key]]; { h: Finalize.Handle Ź FinalizeOps.EnableFinalization[strongID, strongIdentityFinalizerQueue]; AddNewStrongIdentity[newIDHandle~h]; }; identity Ź strongID; IF check THEN Terminate[Initiate[identity, authSvcName, 60]]; }; DestroyIdentity: PUBLIC PROC [identity: Identity] ~ { IF identity = NIL THEN RETURN; WITH identity SELECT FROM simpleID: SimpleIdentity => { simpleID.valid Ź FALSE; simpleID.password Ź NIL; simpleID.verifier Ź VerifierFromHashedPassword[SimpleKeyFromPassword[NIL]]; }; strongID: StrongIdentity => { strongID.valid Ź FALSE; strongID.conversations Ź NIL; strongID.password Ź NIL; strongID.key Ź StrongKeyFromPassword[NIL]; }; ENDCASE => ERROR; }; nullIdentity: Identity Ź NIL; nullIdentityLock: Lock ~ NEW[LockObject Ź []]; GetNullIdentity: PUBLIC PROC RETURNS [Identity] ~ { RETURN [EntryGetNullIdentity[]] }; EntryGetNullIdentity: ENTRY PROC [lock: Lock Ź nullIdentityLock] RETURNS [Identity] ~ { IF nullIdentity = NIL THEN nullIdentity Ź MakeIdentity[name~["", "", ""], password~"", credentialsType~simple, check~FALSE]; RETURN [nullIdentity] }; NonNilIdentity: PROC [in: Identity] RETURNS [out: Identity] ~ INLINE { out Ź IF in # NIL THEN in ELSE GetNullIdentity[] }; <> SimpleConversation: TYPE ~ REF SimpleConversationObject; SimpleConversationObject: TYPE ~ RECORD [ initiatorID: SimpleIdentity, recipientName: Name ]; StrongConversation: TYPE ~ REF StrongConversationObject; StrongConversationObject: TYPE ~ RECORD [ next: StrongConversation, initiatorID: StrongIdentity, timeStamp: GMT, referenced: BOOL Ź TRUE, recipientName: Name, recipientHostNumber: HostNumber, credentials: Credentials, conversationKey: Key, lastStrongVerifier: Auth.StrongVerifier ]; Conversation: TYPE ~ REF; -- SimpleConversationObject <> StrongConversationCacheGet: ENTRY PROC[lock: Lock Ź initiatorCacheLock, id: StrongIdentity, name: Name] RETURNS[StrongConversation] ~ { ENABLE UNWIND => NULL; p, prev: StrongConversation; prev Ź NIL; p Ź id.conversations; WHILE (p # NIL) AND (NOT EqualNames[name, p.recipientName]) DO prev Ź p; p Ź p.next; ENDLOOP; IF p # NIL THEN { IF prev # NIL THEN prev.next Ź p.next ELSE id.conversations Ź p.next; p.next Ź NIL }; RETURN [p] }; StrongConversationCachePut: ENTRY PROC[lock: Lock Ź initiatorCacheLock, c: StrongConversation, id: StrongIdentity] ~ { ENABLE UNWIND => NULL; c.next Ź id.conversations; id.conversations Ź c }; SweepStrongConversationCache: ENTRY PROC[lock: Lock Ź initiatorCacheLock] ~ { ENABLE UNWIND => NULL; FOR h: Finalize.Handle Ź strongIdentities, IdFromH[h].next WHILE h # NIL DO strongID: StrongIdentity Ź IdFromH[h]; p, prev: StrongConversation; p Ź strongID.conversations; prev Ź NIL; WHILE p # NIL DO IF NOT p.referenced THEN -- delete the entry -- { p Ź p.next; IF prev = NIL THEN strongID.conversations Ź p ELSE prev.next Ź p } ELSE -- leave the entry alone -- { p.referenced Ź FALSE; prev Ź p; p Ź p.next }; ENDLOOP; ENDLOOP; }; <> Initiate: PUBLIC PROC [identity: Identity, recipientName: Name, seconds: CARD] RETURNS [conversation: Conversation] ~ { identity Ź NonNilIdentity[identity]; WITH identity SELECT FROM simpleID: SimpleIdentity => { c: SimpleConversation Ź NEW[SimpleConversationObject Ź [initiatorID~simpleID, recipientName~recipientName]]; conversation Ź c }; strongID: StrongIdentity => { c: StrongConversation; c Ź StrongConversationCacheGet[id~strongID, name~recipientName]; IF c = NIL THEN c Ź NEW[StrongConversationObject Ź [timeStamp~BasicTime.earliestGMT, recipientName~recipientName, recipientHostNumber~XNS.unknownHost, credentials~[strong,NIL], conversationKey~, lastStrongVerifier~initialStrongVerifier]]; c.initiatorID Ź strongID; c.referenced Ź TRUE; Refresh[c, seconds]; conversation Ź c }; ENDCASE => ERROR; }; Refresh: PUBLIC PROC [conversation: Conversation, seconds: CARD] ~ { IF conversation = NIL THEN ERROR; WITH conversation SELECT FROM simpleC: SimpleConversation => { NULL }; strongC: StrongConversation => { seqWords: SeqWords; credentialsPackage: Auth.CredentialsPackage; nonce: CARD; DoGetStrongCredentials: PROC [h: CrRPC.Handle, host: HostNumber] ~ { seqWords Ź Auth.GetStrongCredentials[h, strongC.initiatorID.name, strongC.recipientName, nonce] }; IF (BasicTime.Period[from~strongC.timeStamp, to~Now[]] + INT[seconds]) <= strongCredentialsLifetime THEN RETURN; nonce Ź BasicTime.GetClockPulses[]; CallRemote[DoGetStrongCredentials]; seqWords Ź DecryptSeqWords[strongC.initiatorID.key, seqWords]; [cp~credentialsPackage] Ź FetchCredentialsPackageFromSeqWords[seqWords, 0 ! MarshallError => GOTO Bad]; IF credentialsPackage.nonce # nonce THEN GOTO Bad; strongC.recipientName Ź credentialsPackage.recipient; strongC.credentials Ź credentialsPackage.credentials; strongC.conversationKey Ź credentialsPackage.conversationKey; strongC.lastStrongVerifier Ź initialStrongVerifier; strongC.timeStamp Ź Now[]; EXITS Bad => ERROR AuthenticationError[credentialsInvalid]; }; ENDCASE => ERROR; }; Terminate: PUBLIC PROC [conversation: Conversation] ~ { IF conversation = NIL THEN ERROR; WITH conversation SELECT FROM simpleC: SimpleConversation => { NULL }; strongC: StrongConversation => { strongID: StrongIdentity ~ strongC.initiatorID; strongC.initiatorID Ź NIL; StrongConversationCachePut[c~strongC, id~strongID] }; ENDCASE => ERROR; }; GetCredentials: PUBLIC PROC [conversation: Conversation] RETURNS [credentials: Credentials] ~ { IF conversation = NIL THEN ERROR; WITH conversation SELECT FROM simpleC: SimpleConversation => { credentials Ź simpleC.initiatorID.credentials }; strongC: StrongConversation => { credentials Ź strongC.credentials }; ENDCASE => ERROR; }; SetRecipientHostNumber: PUBLIC PROC [conversation: Conversation, recipientHostNumber: HostNumber] ~ { IF conversation = NIL THEN ERROR; WITH conversation SELECT FROM simpleC: SimpleConversation => { NULL }; strongC: StrongConversation => { strongC.recipientHostNumber Ź recipientHostNumber }; ENDCASE => ERROR; }; GetNextVerifier: PUBLIC PROC [conversation: Conversation] RETURNS [verifier: Verifier] ~ { IF conversation = NIL THEN ERROR; WITH conversation SELECT FROM simpleC: SimpleConversation => { verifier Ź simpleC.initiatorID.verifier }; strongC: StrongConversation => { now: GMT ~ Now[]; IF BasicTime.Period[ from~BasicTime.FromNSTime[strongC.lastStrongVerifier.timeStamp], to~now ] > 0 THEN strongC.lastStrongVerifier Ź [timeStamp~BasicTime.ToNSTime[now], ticks~0] ELSE strongC.lastStrongVerifier Ź IncrementStrongVerifier[strongC.lastStrongVerifier]; verifier Ź EncryptedVerifierFromStrongVerifier[strongC.conversationKey, LOOPHOLE[strongC.recipientHostNumber], strongC.lastStrongVerifier]; }; ENDCASE => ERROR; }; ReplyVerifierChecks: PUBLIC PROC [conversation: Conversation, verifier: Verifier] RETURNS [ok: BOOL] ~ { IF conversation = NIL THEN ERROR; WITH conversation SELECT FROM simpleC: SimpleConversation => { ERROR AuthenticationError[inappropriateCredentials] }; strongC: StrongConversation => { ENABLE MarshallError => { ok Ź FALSE; CONTINUE }; sV: Auth.StrongVerifier ~ StrongVerifierFromEncryptedVerifier[ strongC.conversationKey, LOOPHOLE[strongC.recipientHostNumber], verifier]; ok Ź (sV = IncrementStrongVerifier[strongC.lastStrongVerifier]); IF ok THEN strongC.lastStrongVerifier Ź sV }; ENDCASE => ERROR; }; <> <> RSimpleConversation: TYPE ~ REF RSimpleConversationObject; RSimpleConversationObject: TYPE ~ RECORD [ next: RSimpleConversation, referenced: BOOL Ź TRUE, initiatorName: Name, credentials: Credentials, verifier: Verifier ]; rSimpleConversationCacheLock: Lock Ź NEW[LockObject Ź []]; rSimpleConversationCache: RSimpleConversation Ź NIL; RSimpleConversationCacheGet: ENTRY PROC [ lock: Lock Ź rSimpleConversationCacheLock, credentials: Credentials] RETURNS [RSimpleConversation] ~ { ENABLE UNWIND => NULL; p, prev: RSimpleConversation; IF credentials.type # simple THEN ERROR; prev Ź NIL; p Ź rSimpleConversationCache; WHILE (p # NIL) AND (NOT EqualSeqWords[credentials.value, p.credentials.value]) DO prev Ź p; p Ź p.next; ENDLOOP; IF p # NIL THEN { IF prev # NIL THEN prev.next Ź p.next ELSE rSimpleConversationCache Ź p.next; p.next Ź NIL; p.referenced Ź TRUE }; RETURN [p] }; RSimpleConversationCachePut: ENTRY PROC[ lock: Lock Ź rSimpleConversationCacheLock, conversation: RSimpleConversation] ~ { ENABLE UNWIND => NULL; conversation.next Ź rSimpleConversationCache; rSimpleConversationCache Ź conversation }; SweepRSimpleConversationCache: ENTRY PROC[lock: Lock Ź rSimpleConversationCacheLock] ~ { ENABLE UNWIND => NULL; p, prev: RSimpleConversation; p Ź rSimpleConversationCache; prev Ź NIL; WHILE p # NIL DO IF p.referenced THEN { p.referenced Ź FALSE; prev Ź p; p Ź p.next } ELSE { p Ź p.next; IF prev = NIL THEN rSimpleConversationCache Ź p ELSE prev.next Ź p }; ENDLOOP; }; <> RStrongConversation: TYPE ~ REF RStrongConversationObject; RStrongConversationObject: TYPE ~ RECORD [ next: RStrongConversation, referenced: BOOL Ź TRUE, credentials: Credentials, decryptedStrongCredentials: Auth.StrongCredentials, lastStrongVerifier: Auth.StrongVerifier ]; rStrongConversationCacheLock: Lock Ź NEW[LockObject Ź []]; rStrongConversationCache: RStrongConversation Ź NIL; RStrongConversationCacheGet: ENTRY PROC [ lock: Lock Ź rStrongConversationCacheLock, credentials: Credentials] RETURNS [RStrongConversation] ~ { ENABLE UNWIND => NULL; p, prev: RStrongConversation; IF credentials.type # strong THEN ERROR; prev Ź NIL; p Ź rStrongConversationCache; WHILE (p # NIL) AND (NOT EqualSeqWords[credentials.value, p.credentials.value]) DO prev Ź p; p Ź p.next; ENDLOOP; IF p # NIL THEN { IF prev # NIL THEN prev.next Ź p.next ELSE rStrongConversationCache Ź p.next; p.next Ź NIL; p.referenced Ź TRUE }; RETURN [p] }; RStrongConversationCachePut: ENTRY PROC[ lock: Lock Ź rStrongConversationCacheLock, conversation: RStrongConversation] ~ { ENABLE UNWIND => NULL; conversation.next Ź rStrongConversationCache; rStrongConversationCache Ź conversation }; SweepRStrongConversationCache: ENTRY PROC[lock: Lock Ź rStrongConversationCacheLock] ~ { ENABLE UNWIND => NULL; p, prev: RStrongConversation; p Ź rStrongConversationCache; prev Ź NIL; WHILE p # NIL DO IF p.referenced THEN { p.referenced Ź FALSE; prev Ź p; p Ź p.next } ELSE { p Ź p.next; IF prev = NIL THEN rStrongConversationCache Ź p ELSE prev.next Ź p }; ENDLOOP; }; <> InvalidateRecipientCaches: PROC ~ { rSimpleConversationCache Ź NIL; rStrongConversationCache Ź NIL; }; <> Authenticate: PUBLIC PROC [myIdentity: Identity, hisCredentials: Credentials, hisVerifier: Verifier, allowSimpleCredentials: BOOL, useExpiredCredentials: BOOL] RETURNS [hisName: Name] ~ { myIdentity Ź NonNilIdentity[myIdentity]; SELECT hisCredentials.type FROM simple => { IF NOT allowSimpleCredentials THEN ERROR AuthenticationError[inappropriateCredentials]; hisName Ź AuthenticateSimple[hisCredentials, hisVerifier] }; strong => { [hisName~hisName] Ź AuthenticateStrong[myIdentity~myIdentity, hisCredentials~hisCredentials, hisVerifier~hisVerifier, useExpiredCredentials~useExpiredCredentials, computeReplyVerifier~FALSE] }; ENDCASE => ERROR; }; AuthenticateAndReply: PUBLIC PROC [myIdentity: Identity, hisCredentials: Credentials, hisVerifier: Verifier, useExpiredCredentials: BOOL] RETURNS [hisName: Name, replyVerifier: Verifier] ~ { myIdentity Ź NonNilIdentity[myIdentity]; SELECT hisCredentials.type FROM simple => { ERROR AuthenticationError[inappropriateCredentials]; }; strong => { [hisName, replyVerifier] Ź AuthenticateStrong[myIdentity~myIdentity, hisCredentials~hisCredentials, hisVerifier~hisVerifier, useExpiredCredentials~useExpiredCredentials, computeReplyVerifier~TRUE]; }; ENDCASE => ERROR; }; <> AuthenticateSimple: PROC [hisCredentials: Credentials, hisVerifier: Verifier] RETURNS [hisName: Name] ~ { rSimpleC: RSimpleConversation; rSimpleC Ź RSimpleConversationCacheGet[credentials~hisCredentials]; IF (rSimpleC = NIL) OR (NOT EqualSeqWords[hisVerifier, rSimpleC.verifier]) THEN { CheckSimple[hisCredentials, hisVerifier]; rSimpleC Ź NEW[RSimpleConversationObject Ź [initiatorName~FetchNameFromSeqWords[hisCredentials.value, 0].name, credentials~hisCredentials, verifier~hisVerifier]]; }; hisName Ź rSimpleC.initiatorName; RSimpleConversationCachePut[conversation~rSimpleC]; }; verifierTimeout: INT ~ 60; AuthenticateStrong: PROC [myIdentity: Identity, hisCredentials: Credentials, hisVerifier: Verifier, useExpiredCredentials: BOOL Ź FALSE, computeReplyVerifier: BOOL Ź FALSE] RETURNS [hisName: Name, replyVerifier: Verifier Ź NIL] ~ { rStrongC: RStrongConversation; WITH myIdentity SELECT FROM myStrongID: StrongIdentity => { rStrongC Ź RStrongConversationCacheGet[credentials~hisCredentials]; IF rStrongC = NIL THEN { ENABLE MarshallError => CONTINUE; temp: SeqWords Ź DecryptSeqWords[key~myStrongID.key, seqWords~hisCredentials.value]; rStrongC Ź NEW[RStrongConversationObject Ź [credentials~hisCredentials, decryptedStrongCredentials~FetchStrongCredentialsFromSeqWords[temp,0].sc, lastStrongVerifier~initialStrongVerifier]]; }; IF rStrongC = NIL THEN ERROR AuthenticationError[credentialsInvalid]; IF NOT useExpiredCredentials THEN { expired: BOOL ~ (BasicTime.Period[ from~Now[], to~BasicTime.FromNSTime[rStrongC.decryptedStrongCredentials.expirationTime ]] <= 0); IF expired THEN ERROR AuthenticationError[credentialsExpired] }; { ENABLE MarshallError, BasicTime.OutOfRange => GOTO Bad; temp: Auth.StrongVerifier Ź StrongVerifierFromEncryptedVerifier[ rStrongC.decryptedStrongCredentials.conversationKey, LOOPHOLE[myHostNumber], hisVerifier]; IF NOT StrongVerifierGT[new~temp, old~rStrongC.lastStrongVerifier] THEN ERROR AuthenticationError[verifierReused]; IF StrongVerifierExpired[temp] THEN ERROR AuthenticationError[verifierExpired]; IF computeReplyVerifier THEN { rStrongC.lastStrongVerifier Ź IncrementStrongVerifier[temp]; replyVerifier Ź EncryptedVerifierFromStrongVerifier[ rStrongC.decryptedStrongCredentials.conversationKey, LOOPHOLE[myHostNumber], rStrongC.lastStrongVerifier] } ELSE { rStrongC.lastStrongVerifier Ź temp }; EXITS Bad => ERROR AuthenticationError[verifierInvalid]; }; hisName Ź rStrongC.decryptedStrongCredentials.initiator; RStrongConversationCachePut[conversation: rStrongC]; }; mySimpleID: SimpleIdentity => { ERROR AuthenticationError[inappropriateCredentials] }; ENDCASE => ERROR; }; CheckSimple: PROC[credentials: Credentials, verifier: Verifier] ~ { <> okay: BOOL Ź FALSE; DoCheckSimple: PROC [h: CrRPC.Handle, host: HostNumber] ~ { okay Ź Auth.CheckSimpleCredentials[h, credentials, verifier] }; CallRemote[DoCheckSimple]; IF NOT okay -- can this happen? -- THEN ERROR AuthenticationError[problem~credentialsInvalid]; }; <> ChangeMyPasswords: PUBLIC PROC [myIdentity: Identity, newPassword: ROPE, changeStrong: BOOL Ź TRUE, changeSimple: BOOL Ź TRUE] ~ { IF changeStrong THEN { newKey: Key Ź StrongKeyFromPassword[newPassword]; ChangeMyStrongKey[myIdentity, newKey] }; IF changeSimple THEN { newKey: HashedPassword Ź SimpleKeyFromPassword[newPassword]; ChangeMySimpleKey[myIdentity, newKey] }; }; CreateStrongKey: PUBLIC PROC [myIdentity: Identity, name: Name, newKey: Key] ~ { c: Conversation; DoIt: PROC [h: CrRPC.Handle, host: HostNumber] ~ { SetRecipientHostNumber[c, host]; Auth.CreateStrongKey[h, GetCredentials[c], GetNextVerifier[c], name, EncryptKey[GetConversationKey[c], newKey]] }; myIdentity Ź NonNilIdentity[myIdentity]; c Ź Initiate[myIdentity, authSvcName, oneMinuteOfSeconds]; { ENABLE UNWIND => Terminate[c]; CallRemote[DoIt] }; Terminate[c]; }; ChangeMyStrongKey: PUBLIC PROC [myIdentity: Identity, newKey: Key] ~ { c: Conversation; DoIt: PROC [h: CrRPC.Handle, host: HostNumber] ~ { SetRecipientHostNumber[c, host]; Auth.ChangeStrongKey[h, GetCredentials[c], GetNextVerifier[c], EncryptKey[GetConversationKey[c], newKey]] }; myIdentity Ź NonNilIdentity[myIdentity]; c Ź Initiate[myIdentity, authSvcName, oneMinuteOfSeconds]; { ENABLE UNWIND => Terminate[c]; CallRemote[DoIt] }; Terminate[c]; }; DeleteStrongKey: PUBLIC PROC [myIdentity: Identity, name: Name] ~ { c: Conversation; DoIt: PROC [h: CrRPC.Handle, host: HostNumber] ~ { SetRecipientHostNumber[c, host]; Auth.DeleteStrongKey[h, GetCredentials[c], GetNextVerifier[c], name] }; myIdentity Ź NonNilIdentity[myIdentity]; c Ź Initiate[myIdentity, authSvcName, oneMinuteOfSeconds]; { ENABLE UNWIND => Terminate[c]; CallRemote[DoIt] }; Terminate[c]; }; CreateSimpleKey: PUBLIC PROC [myIdentity: Identity, name: Name, newKey: HashedPassword] ~ { c: Conversation; DoIt: PROC [h: CrRPC.Handle, host: HostNumber] ~ { SetRecipientHostNumber[c, host]; Auth.CreateSimpleKey[h, GetCredentials[c], GetNextVerifier[c], name, newKey] }; myIdentity Ź NonNilIdentity[myIdentity]; c Ź Initiate[myIdentity, authSvcName, oneMinuteOfSeconds]; { ENABLE UNWIND => Terminate[c]; CallRemote[DoIt] }; Terminate[c]; }; ChangeMySimpleKey: PUBLIC PROC [myIdentity: Identity, newKey: HashedPassword] ~ { c: Conversation; DoIt: PROC [h: CrRPC.Handle, host: HostNumber] ~ { SetRecipientHostNumber[c, host]; Auth.ChangeSimpleKey[h, GetCredentials[c], GetNextVerifier[c], newKey] }; myIdentity Ź NonNilIdentity[myIdentity]; c Ź Initiate[myIdentity, authSvcName, oneMinuteOfSeconds]; { ENABLE UNWIND => Terminate[c]; CallRemote[DoIt] }; Terminate[c]; }; DeleteSimpleKey: PUBLIC PROC [myIdentity: Identity, name: Name] ~ { c: Conversation; DoIt: PROC [h: CrRPC.Handle, host: HostNumber] ~ { SetRecipientHostNumber[c, host]; Auth.DeleteSimpleKey[h, GetCredentials[c], GetNextVerifier[c], name] }; myIdentity Ź NonNilIdentity[myIdentity]; c Ź Initiate[myIdentity, authSvcName, oneMinuteOfSeconds]; { ENABLE UNWIND => Terminate[c]; CallRemote[DoIt] }; Terminate[c]; }; <> StrongKeyFromPassword: PUBLIC PROC [password: ROPE] RETURNS [key: Key] ~ { index: INT; passwordLen: INT ~ Rope.Length[password]; ki: DESFace.Key Ź DESFace.nullKey; bi: Block; biPlus1: Block; FOR index Ź 0, index + 4 WHILE index < passwordLen DO len: INT ~ MIN[4, passwordLen-index]; TRUSTED { StoreSubropeInBlock[password, index, len, @bi, TRUE]; DESFace.CorrectParity[@ki]; <> DESFace.EncryptBlock[key~ki, from~@bi, to~@biPlus1]; ki Ź LOOPHOLE[biPlus1] }; ENDLOOP; TRUSTED { DESFace.CorrectParity[@ki] }; RETURN [ LOOPHOLE[ki] ]; }; SimpleKeyFromPassword: PUBLIC PROC [password: ROPE] RETURNS [hashVal: HashedPassword Ź 0] ~ { c: CHAR; acc: Basics.LongNumber; FOR i: INT IN [0 .. Rope.Length[password]) DO c Ź Rope.Fetch[password, i]; SELECT c FROM IN ['A .. 'Z] => c Ź 'a + (c - 'A); ENDCASE; acc.hi Ź hashVal; acc.lo Ź ORD[c]; hashVal Ź acc.lc MOD 65357; ENDLOOP; }; GetCredentialsType: PUBLIC PROC [credentials: Credentials] RETURNS [CredentialsType] ~ { RETURN [credentials.type] }; GetConversationDetails: PUBLIC PROC [conversation: Conversation] RETURNS [ recipientName: Name, recipientHostNumber: HostNumber, credentials: Credentials, conversationKey: Key, owner: Identity] ~ { IF conversation = NIL THEN ERROR; WITH conversation SELECT FROM simpleC: SimpleConversation => { recipientName Ź simpleC.recipientName; recipientHostNumber Ź XNS.unknownHost; credentials Ź simpleC.initiatorID.credentials; conversationKey Ź ALL[0]; owner Ź simpleC.initiatorID }; strongC: StrongConversation => { recipientName Ź strongC.recipientName; recipientHostNumber Ź strongC.recipientHostNumber; credentials Ź strongC.credentials; conversationKey Ź strongC.conversationKey; owner Ź strongC.initiatorID }; ENDCASE => ERROR; }; GetConversationKey: PROC [conversation: Conversation] RETURNS [conversationKey: Key] ~ { IF conversation = NIL THEN ERROR; WITH conversation SELECT FROM simpleC: SimpleConversation => ERROR AuthenticationError[inappropriateCredentials]; strongC: StrongConversation => conversationKey Ź strongC.conversationKey; ENDCASE => ERROR; }; GetIdentityDetails: PUBLIC PROC [identity: Identity] RETURNS [ name: Name, password: ROPE, credentialsType: CredentialsType] ~ { identity Ź NonNilIdentity[identity]; WITH identity SELECT FROM simpleI: SimpleIdentity => { name Ź simpleI.name; password Ź simpleI.password; credentialsType Ź simple }; strongI: StrongIdentity => { name Ź strongI.name; password Ź strongI.password; credentialsType Ź strong }; ENDCASE => ERROR; }; GetCredentialsDetails: PUBLIC PROC [myKey: Key, hisCredentials: Credentials] RETURNS [ok: BOOL, credentialsType: CredentialsType, conversationKey: Key, expirationTime: GMT, hisName: Name] ~ { ok Ź FALSE; SELECT hisCredentials.type FROM simple => { ENABLE MarshallError => CONTINUE; credentialsType Ź simple; conversationKey Ź ALL[0]; expirationTime Ź BasicTime.latestGMT; hisName Ź FetchNameFromSeqWords[hisCredentials.value, 0].name; ok Ź TRUE; }; strong => { ENABLE MarshallError => CONTINUE; rStrongC: RStrongConversation; sC: Auth.StrongCredentials; credentialsType Ź strong; rStrongC Ź RStrongConversationCacheGet[credentials~hisCredentials]; IF rStrongC # NIL THEN { sC Ź rStrongC.decryptedStrongCredentials; RStrongConversationCachePut[conversation: rStrongC] } ELSE { temp: SeqWords Ź DecryptSeqWords[key~myKey, seqWords~hisCredentials.value]; [sc~sC] Ź FetchStrongCredentialsFromSeqWords[temp,0] }; conversationKey Ź sC.conversationKey; expirationTime Ź BasicTime.FromNSTime[sC.expirationTime]; hisName Ź sC.initiator; ok Ź TRUE; }; ENDCASE => ERROR; }; <> Daemon: PROC ~ { DO Process.PauseMsec[msecBetweenSweeps]; SweepStrongConversationCache[]; SweepRStrongConversationCache[]; ENDLOOP; }; <> EqualNames: PROC [a: Name, b: Name] RETURNS [BOOL] ~ { RETURN[Rope.Equal[a.organization, b.organization, FALSE] AND Rope.Equal[a.domain, b.domain, FALSE] AND Rope.Equal[a.object, b.object, FALSE]] }; EqualSeqWords: PROC [a, b: SeqWords] RETURNS [BOOL] ~ { IF a.length # b.length THEN RETURN [FALSE]; FOR i: CARDINAL IN [0..a.length) DO IF a.body[i] # b.body[i] THEN RETURN [FALSE]; ENDLOOP; RETURN [TRUE] }; IncrementStrongVerifier: PROC [v: Auth.StrongVerifier] RETURNS [result: Auth.StrongVerifier] ~ { result.timeStamp Ź v.timeStamp; IF (result.ticks Ź v.ticks + 1) = 0 THEN result.timeStamp Ź result.timeStamp + 1; }; StrongVerifierGT: PROC [new, old: Auth.StrongVerifier] RETURNS [gt: BOOL] ~ { deltaT: INT ~ BasicTime.Period[from~BasicTime.FromNSTime[old.timeStamp], to~BasicTime.FromNSTime[new.timeStamp]]; SELECT deltaT FROM > 0 => RETURN [TRUE]; < 0 => RETURN [FALSE]; 0 => RETURN [new.ticks > old.ticks]; ENDCASE => RETURN [new.ticks > old.ticks]; }; StrongVerifierExpired: PROC [v: Auth.StrongVerifier] RETURNS [expired: BOOL] ~ { deltaT: INT ~ BasicTime.Period[from~BasicTime.FromNSTime[v.timeStamp], to~Now[]]; RETURN [ deltaT > strongVerifierTimeout ] }; FetchRopeFromSeqWords: PROC [s: SeqWords, where: CARDINAL] RETURNS [newWhere: CARDINAL, r: ROPE] ~ { i, count, seqLen: CARDINAL; w: Basics.Word16; buf: REF TEXT; seqLen Ź s.length; IF where >= seqLen THEN ERROR MarshallError; count Ź s.body[where]; where Ź where + 1; buf Ź RefText.ObtainScratch[count]; i Ź 0; WHILE i < count DO IF where >= seqLen THEN ERROR MarshallError; w.card Ź s.body[where]; where Ź where + 1; buf Ź RefText.InlineAppendChar[buf, VAL[w.hi]]; i Ź i + 1; IF i < count THEN { buf Ź RefText.InlineAppendChar[buf, VAL[w.lo]]; i Ź i + 1 }; ENDLOOP; newWhere Ź where; r Ź Rope.FromRefText[buf]; RefText.ReleaseScratch[buf] }; StoreRopeInSeqWords: PROC [r: ROPE, s: SeqWords, where: CARDINAL] RETURNS [newWhere: CARDINAL] ~ { i, length, seqLen: CARDINAL; w: Basics.Word16; length Ź Rope.Length[r]; seqLen Ź s.length; IF where >= seqLen THEN ERROR MarshallError; s.body[where] Ź length; where Ź where + 1; i Ź 0; WHILE i < length DO w.hi Ź ORD[Rope.Fetch[r,i]]; i Ź i + 1; w.lo Ź (IF i < length THEN ORD[Rope.Fetch[r,i]] ELSE 0); i Ź i + 1; IF where >= seqLen THEN ERROR MarshallError; s.body[where] Ź w.card; where Ź where + 1; -- USED TO BE LOOPHOLE[w] ???? ENDLOOP; RETURN [where] }; FetchSeqWordsFromSeqWords: PROC [s: SeqWords, where: CARDINAL] RETURNS [newWhere: CARDINAL, result: SeqWords] ~ { n, seqLen: CARDINAL; seqLen Ź s.length; IF where >= seqLen THEN ERROR MarshallError; n Ź s.body[where]; where Ź where + 1; IF (n+where) > seqLen THEN ERROR MarshallError; result Ź NEW[SeqWordsObject[n]]; FOR i: CARDINAL IN [0..n) DO result.body[i] Ź s.body[where]; where Ź where + 1; ENDLOOP; newWhere Ź where; }; StoreSeqWordsInSeqWords: PROC [s: SeqWords, arg: SeqWords, where: CARDINAL] RETURNS [newWhere: CARDINAL] ~ { n: CARDINAL ~ arg.length; seqLen: CARDINAL ~ s.length; IF (where+n+1) > seqLen THEN ERROR MarshallError; s.body[where] Ź n; where Ź where + 1; FOR i: CARDINAL IN [0..n) DO s.body[where] Ź arg.body[i]; where Ź where + 1; ENDLOOP; newWhere Ź where; }; FetchBlockFromSeqWords: PROC [s: SeqWords, where: CARDINAL] RETURNS [newWhere: CARDINAL, block: Block] ~ { IF (newWhere Ź where+4) > s.length THEN ERROR MarshallError; block[0] Ź s.body[where]; block[1] Ź s.body[where+1]; block[2] Ź s.body[where+2]; block[3] Ź s.body[where+3]; }; StoreBlockInSeqWords: PROC [s: SeqWords, block: Block, where: CARDINAL] RETURNS [newWhere: CARDINAL] ~ { IF (newWhere Ź where+4) > s.length THEN ERROR MarshallError; s.body[where] Ź block[0]; s.body[where+1] Ź block[1]; s.body[where+2] Ź block[2]; s.body[where+3] Ź block[3]; }; FetchCredentialsFromSeqWords: PROC [s: SeqWords, where: CARDINAL] RETURNS [newWhere: CARDINAL, c: Credentials] ~ { type: CARDINAL; IF where >= s.length THEN ERROR MarshallError; type Ź s.body[where]; where Ź where + 1; SELECT type FROM ORD[CredentialsType.strong] => c.type Ź strong; ORD[CredentialsType.simple] => c.type Ź simple; ENDCASE => ERROR MarshallError; [newWhere~newWhere, result~c.value] Ź FetchSeqWordsFromSeqWords[s, where]; }; FetchCard32FromSeqWords: PROC [s: SeqWords, where: CARDINAL] RETURNS [newWhere: CARDINAL, result: CARD32] ~ { n: Basics.LongNumber; IF(newWhere Ź where+2) > s.length THEN ERROR MarshallError; n.hi Ź s.body[where]; n.lo Ź s.body[where+1]; result Ź n.lc }; FetchCredentialsPackageFromSeqWords: PROC [s: SeqWords, where: CARDINAL] RETURNS [newWhere: CARDINAL, cp: Auth.CredentialsPackage] ~ { [where, cp.credentials] Ź FetchCredentialsFromSeqWords[s, where]; IF cp.credentials.type # strong THEN ERROR AuthenticationError[inappropriateCredentials]; [where, cp.nonce] Ź FetchCard32FromSeqWords[s, where]; [where, cp.recipient] Ź FetchNameFromSeqWords[s, where]; [where, cp.conversationKey] Ź FetchBlockFromSeqWords[s, where]; newWhere Ź where }; FetchStrongCredentialsFromSeqWords: PROC [s: SeqWords, where: CARDINAL] RETURNS [newWhere: CARDINAL, sc: Auth.StrongCredentials] ~ { [where, sc.conversationKey] Ź FetchBlockFromSeqWords[s, where]; [where, sc.expirationTime] Ź FetchCard32FromSeqWords[s, where]; [where, sc.initiator] Ź FetchNameFromSeqWords[s, where]; newWhere Ź where }; StoreSubropeInBlock: PROC [r: ROPE, index, len: INT, to: LONG POINTER TO Block, mapCase: BOOL Ź TRUE] ~ { <> c: CHAR; blockIndex: INT Ź 0; WHILE blockIndex < len DO c Ź Rope.Fetch[r, index]; IF mapCase THEN SELECT c FROM IN ['A .. 'Z] => c Ź 'a + (c - 'A); ENDCASE; TRUSTED { to[blockIndex] Ź ORD[c] }; index Ź index + 1; blockIndex Ź blockIndex + 1; ENDLOOP; WHILE blockIndex < 4 DO TRUSTED { to[blockIndex] Ź 0 }; blockIndex Ź blockIndex + 1; ENDLOOP; }; FetchNameFromSeqWords: PROC [s: SeqWords, where: CARDINAL] RETURNS [newWhere: CARDINAL, name: Name] ~ { [where, name.organization] Ź FetchRopeFromSeqWords[s, where]; [where, name.domain] Ź FetchRopeFromSeqWords[s, where]; [where, name.object] Ź FetchRopeFromSeqWords[s, where]; newWhere Ź where }; StoreNameInSeqWords: PROC [name: Name, s: SeqWords, where: CARDINAL] RETURNS [newWhere: CARDINAL] ~ { where Ź StoreRopeInSeqWords[name.organization, s, where]; where Ź StoreRopeInSeqWords[name.domain, s, where]; where Ź StoreRopeInSeqWords[name.object, s, where]; RETURN [where] }; MarshalledNameHwords: PROC [name: Name] RETURNS [hWords: CARDINAL] ~ { RETURN [CrRPC.MarshalledRopeHWords[name.organization] + CrRPC.MarshalledRopeHWords[name.domain] + CrRPC.MarshalledRopeHWords[name.object]] }; SeqWordsFromName: PROC [name: Name] RETURNS [SeqWords] ~ { s: SeqWords Ź NEW[SeqWordsObject[MarshalledNameHwords[name]]]; [] Ź StoreNameInSeqWords[name, s, 0]; RETURN [s] }; CredentialsFromName: PROC [name: Name] RETURNS [credentials: Credentials] ~ { RETURN[ [type~simple, value~SeqWordsFromName[name]] ] }; VerifierFromHashedPassword: PROC [hashedPassword: HashedPassword] RETURNS [verifier: Verifier] ~ { verifier Ź NEW[SeqWordsObject[1]]; verifier.body[0] Ź hashedPassword }; EncryptKey: PROC [key: Key, data: Key] RETURNS [result: Key] ~ TRUSTED { DESFace.EncryptBlock[LOOPHOLE[key], LOOPHOLE[LONG[@data]], LOOPHOLE[LONG[@result]]] }; EncryptSeqWords: PROC [key: Key, seqWords: SeqWords] RETURNS [result: SeqWords] ~ { nBlocks: CARDINAL Ź (seqWords.length*BITS[CARD16] + BITS[Block] - 1) / BITS[Block]; roundedLength: CARDINAL Ź nBlocks * (BITS[Block]/BITS[CARD16]); result Ź NEW[SeqWordsObject[roundedLength]]; IF roundedLength # seqWords.length THEN { FOR i: CARDINAL IN [0..seqWords.length) DO result.body[i] Ź seqWords.body[i] ENDLOOP; FOR i: CARDINAL IN [seqWords.length..roundedLength) DO result.body[i] Ź 0 ENDLOOP; seqWords Ź result }; TRUSTED { blocksFrom: DESFace.Blocks ~ LOOPHOLE[ LOOPHOLE[seqWords, LONG POINTER] + SIZE[SeqWordsObject[0]] ]; blocksTo: DESFace.Blocks ~ LOOPHOLE[ LOOPHOLE[result, LONG POINTER] + SIZE[SeqWordsObject[0]] ]; DESFace.CBCCheckEncrypt[LOOPHOLE[key], nBlocks, blocksFrom, blocksTo, ALL[0]]; }; }; DecryptSeqWords: PROC [key: Key, seqWords: SeqWords] RETURNS [result: SeqWords] ~ { <> nBlocks: CARDINAL ~ (seqWords.length*BITS[CARD16]) / BITS[Block]; roundedLength: CARDINAL Ź nBlocks * (BITS[Block]/BITS[CARD16]); IF seqWords.length # roundedLength THEN ERROR MarshallError; result Ź NEW[SeqWordsObject[roundedLength]]; TRUSTED { blocksFrom: DESFace.Blocks ~ LOOPHOLE[ LOOPHOLE[seqWords, LONG POINTER] + SIZE[SeqWordsObject[0]] ]; blocksTo: DESFace.Blocks ~ LOOPHOLE[ LOOPHOLE[result, LONG POINTER] + SIZE[SeqWordsObject[0]] ]; DESFace.CBCCheckDecrypt[LOOPHOLE[key], nBlocks, blocksFrom, blocksTo, ALL[0]]; }; }; PackBytes: PROC[hi, lo: BYTE] RETURNS [CARD16] ~ INLINE { RETURN [256*hi + lo] }; EncryptedVerifierFromStrongVerifier: PROC [conversationKey: Key, hostNumber: HostNumber, strongVerifier: Auth.StrongVerifier] RETURNS [verifier: Verifier] ~ { verifierInHWords: CARDINAL ~ BYTES[Auth.StrongVerifier]/BYTES[Basics.HWORD]; seqWords: SeqWords ~ NEW[SeqWordsObject[verifierInHWords]]; temp: Basics.LongNumber; temp.lc Ź strongVerifier.timeStamp; seqWords.body[0] Ź Basics.BITXOR[temp.hi, PackBytes[hostNumber.a, hostNumber.b]]; seqWords.body[1] Ź Basics.BITXOR[temp.lo, PackBytes[hostNumber.c, hostNumber.d]]; temp.lc Ź strongVerifier.ticks; seqWords.body[2] Ź Basics.BITXOR[temp.hi, PackBytes[hostNumber.e, hostNumber.f]]; seqWords.body[3] Ź temp.lo; verifier Ź EncryptSeqWords[key~LOOPHOLE[conversationKey], seqWords~seqWords]; }; StrongVerifierFromEncryptedVerifier: PROC [conversationKey: Key, hostNumber: HostNumber, verifier: Verifier] RETURNS [strongVerifier: Auth.StrongVerifier] ~ { temp: Basics.LongNumber; IF verifier.length # (BITS[Auth.StrongVerifier]/BITS[CARD16]) THEN ERROR MarshallError; verifier Ź DecryptSeqWords[key~LOOPHOLE[conversationKey], seqWords~verifier]; temp.hi Ź Basics.BITXOR[verifier.body[0], PackBytes[hostNumber.a, hostNumber.b]]; temp.lo Ź Basics.BITXOR[verifier.body[1], PackBytes[hostNumber.c, hostNumber.d]]; strongVerifier.timeStamp Ź temp.lc; temp.hi Ź Basics.BITXOR[verifier.body[2], PackBytes[hostNumber.e, hostNumber.f]]; temp.lo Ź verifier.body[3]; strongVerifier.ticks Ź temp.lc; }; <> ServerInfo: TYPE ~ REF ServerInfoObject; ServerInfoObject: TYPE ~ RECORD [ next: ServerInfo, refAddress: REF XNS.Address, -- REF conforms to CrRPC.RefAddress hops: XNSRouter.Hops ]; serverInfoLock: Lock Ź NEW[LockObject Ź []]; serverBroadcastLock: Lock Ź NEW[LockObject Ź []]; serverInfo: ServerInfo Ź NIL; serverInfoTimestamp: GMT; defaultServerHops: XNSRouter.Hops ~ 3; maxServerHops: XNSRouter.Hops ~ 6; secondsBetweenBroadcasts: INT ~ 600; broadcastPauseLimit: CARDINAL Ź 3; broadcastPauseMsec: CARDINAL Ź 11000; <> InvalidateServerCache: ENTRY PROC [lock: Lock Ź serverInfoLock] ~ { serverInfo Ź NIL }; DeleteServer: ENTRY PROC [lock: Lock Ź serverInfoLock, it: ServerInfo] ~ { ENABLE UNWIND => NULL; IF it = serverInfo THEN { serverInfo Ź it.next; RETURN }; FOR p: ServerInfo Ź serverInfo, p.next WHILE p # NIL DO IF p.next = it THEN { p.next Ź it.next; RETURN }; ENDLOOP; }; AddServerAddress: ENTRY PROC [lock: Lock Ź serverInfoLock, addr: XNS.Address, hops: XNSRouter.Hops] ~ { ENABLE UNWIND => NULL; p, prev, new: ServerInfo; <> prev Ź NIL; p Ź serverInfo; WHILE (p # NIL) AND (p.refAddress # addr) DO { prev Ź p; p Ź p.next } ENDLOOP; IF p = NIL THEN { new Ź NEW[ServerInfoObject Ź [ next~NIL, refAddress~NEW[XNS.Address Ź addr], hops~hops]] } ELSE { IF prev # NIL THEN prev.next Ź p.next ELSE serverInfo Ź p.next; new Ź p; new.hops Ź hops; }; <> prev Ź NIL; p Ź serverInfo; WHILE (p # NIL) AND (p.hops < hops) DO { prev Ź p; p Ź p.next } ENDLOOP; new.next Ź p; IF prev # NIL THEN prev.next Ź new ELSE serverInfo Ź new; }; BroadcastForServers: ENTRY PROC [lock: Lock Ź serverBroadcastLock, maxHops: CARDINAL, nWanted: CARDINAL Ź 0, tryLimit: CARDINAL Ź 0] ~ { ENABLE UNWIND => NULL; nGot: CARDINAL Ź 0; EachAddress: XNSServerLocation.EachAddressProc -- [addr: XNS.Address] -- ~ { hops: XNSRouter.Hops; addr.socket Ź XNS.unknownSocket; hops Ź XNSRouter.GetHops[addr.net]; AddServerAddress[addr~addr, hops~hops]; IF (nGot Ź nGot.SUCC) = nWanted THEN ERROR XNSServerLocation.StopBroadcast[] }; XNSServerLocation.LocateServers[eachAddress~EachAddress, socket~XNSWKS.authenticationInfo, remotePgm~authPgmNum, remotePgmVersion~authVersionNum, maxHops~maxHops, tryLimit~tryLimit]; serverInfoTimestamp Ź Now[]; }; numBroadcastPauses: INT Ź 0; -- DEBUG GetBestServer: PROC RETURNS [p: ServerInfo] ~ { nBroadcasts: CARDINAL Ź 0; DO currentHops: XNSRouter.Hops; p Ź serverInfo; -- ATOMIC SELECT TRUE FROM (p = NIL) => { BroadcastForServers[maxHops~maxServerHops, nWanted~1]; nBroadcasts Ź nBroadcasts.SUCC; IF ((p Ź serverInfo) = NIL) AND (nBroadcasts <= broadcastPauseLimit) THEN { Process.PauseMsec[broadcastPauseMsec]; numBroadcastPauses Ź numBroadcastPauses.SUCC; -- DEBUG LOOP }; TRUSTED { Process.Detach[ FORK BroadcastForServers[maxHops~defaultServerHops, tryLimit~1] ] }; RETURN }; ((currentHops Ź XNSRouter.GetHops[p.refAddress.net]) # p.hops) => { DeleteServer[it~p]; AddServerAddress[addr~p.refAddress, hops~currentHops]; LOOP }; ((p.hops > 0) AND (BasicTime.Period[from~serverInfoTimestamp, to~Now[]] > secondsBetweenBroadcasts)) => TRUSTED { Process.Detach[ FORK BroadcastForServers[maxHops~MIN[(p.hops-1), defaultServerHops], tryLimit~1] ]; RETURN }; ENDCASE => { RETURN }; ENDLOOP; }; CallRemote: PROC [proc: PROC [CrRPC.Handle, HostNumber]] ~ { h: CrRPC.Handle Ź NIL; p: ServerInfo; maxTries: CARDINAL ~ 10; CleanUp: PROC ~ { IF h # NIL THEN { CrRPC.DestroyClientHandle[h]; h Ź NIL }}; FOR try: CARDINAL IN [1..maxTries] DO BEGIN ENABLE { UNWIND => CleanUp[]; CrRPC.Error => { CleanUp[]; DeleteServer[it~p]; LOOP }; CallError => SELECT problem FROM tooBusy, databaseFull => { CleanUp[]; DeleteServer[it~p]; LOOP }; ENDCASE => REJECT; }; IF (p Ź GetBestServer[]) = NIL THEN EXIT; h Ź CrRPC.CreateClientHandle[class~$CMUX, remote~p.refAddress]; proc[h, p.refAddress.host]; CleanUp[]; RETURN; END; ENDLOOP; CleanUp[]; CantContactAuthServer[]; }; <> GetStrongCredentialsLifetime: PROC [name: Name, password: ROPE] RETURNS [ok: BOOL Ź FALSE, seconds: INT Ź 0, from, to: BasicTime.Unpacked] ~ { ENABLE CallError, AuthenticationError => CONTINUE; id: Identity; c: Conversation; t1, t2, tExp: GMT; myKey: Key; hisCredentials: Credentials; id Ź MakeIdentity[name, password, strong, FALSE]; t1 Ź Now[]; c Ź Initiate[id, name, 3600]; t2 Ź Now[]; myKey Ź StrongKeyFromPassword[password]; [credentials~hisCredentials] Ź GetConversationDetails[c]; [ok~ok, expirationTime~tExp] Ź GetCredentialsDetails[myKey~myKey, hisCredentials~hisCredentials]; IF ok THEN { seconds Ź (BasicTime.Period[from~t1, to~tExp] + BasicTime.Period[from~t2, to~tExp] + 1) / 2; from Ź BasicTime.Unpack[t1]; to Ź BasicTime.Unpack[tExp]; }; Terminate[c]; }; AuthenticateToSelf: PROC [name: Name, password: ROPE, howMany: CARDINAL] ~ { count: CARDINAL Ź 0; id: Identity; c: Conversation; credentials: Credentials; verifier: Verifier; replyVerifier: Verifier; myHostNumber: HostNumber; id Ź MakeIdentity[name, password, strong, FALSE]; c Ź Initiate[id, name, 3600]; myHostNumber Ź XNS.GetThisHost[]; SetRecipientHostNumber[c, myHostNumber]; WHILE count < howMany DO credentials Ź GetCredentials[c]; verifier Ź GetNextVerifier[c]; [replyVerifier~replyVerifier] Ź AuthenticateAndReply[id, credentials, verifier, FALSE]; IF NOT ReplyVerifierChecks[c, replyVerifier] THEN ERROR AuthenticationError[verifierInvalid]; count Ź count + 1; ENDLOOP; Terminate[c]; }; <
> InitialBroadcastForServers: PROC ~ TRUSTED { Process.Detach[ FORK BroadcastForServers[maxHops~defaultServerHops, nWanted~2]] }; <> <> <> <> <<};>> <<>> TRUSTED { Process.Detach[ FORK Daemon[]] }; InitialBroadcastForServers[]; }.