
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 U StrongIdentityObject

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 U StrongConversationObject


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[];
}.
 
     XNSAuthImpl.mesa
Copyright Ó 1989, 1991 by Xerox Corporation.  All rights reserved.
Demers, November 15, 1989 12:27:33 pm PST
Tim Diebert: December 4, 1989 5:19:04 pm PST

NOTE: The observed behavior of authentication service is that new credentials expire in one day (!).  The refresh heuristics are designed around this, and will need to be fixed if the behvaior changes.
PCedar Notes: SIZE[SeqWordObject[0]] really does seem to be the right thing and is portable.  SIZE[Auth.StrongVerifier] IS WRONG.
Willie-s, December 10, 1991 10:43 am PST
Christian Jacobi, July 24, 1992 1:50 pm PDT

This isn't supposed to happen, but occasionally it does!
Initiator
Identities
Conversations
Note there is no simple conversation cache on the initiator's side, since creating a simple conversation does not require contacting the authentication service.
Public Procedures
Recipient
Simple Conversations
Strong Conversations
Cache Invalidation on Rollback
Public Procedures
Private Utilities
Just return if okay, else raise CallError or AuthenticationError.
Key and Password Administration
Public Utilities
DESFace.EncryptBlock[key~ki, from~@bi, to~LOOPHOLE[LONG[@ki]]] };
Daemon
Private Utilities
Store len chars in block using 16-bit encoding.
???? Word size dependent. ????
Locating Authentication Servers and Performing Remote Calls
These are necessary for machines with only 3Mb Ethernets, because it can take so long for the routing and translation caches to fill.  They should go away after improvements are made in the underlying transport.
Delete old entry for this address (hops may have changed)
Add new entry in correct position (sorted by hops)
Debugging Stuff
Main Line Code
Rollback: Booting.RollbackProc ~ {
InvalidateRecipientCaches[];
InvalidateServerCache[];
InitialBroadcastForServers[];
};

Ę+$  (cedarcode) styleNewlineDelimiter
 Icode
Ďe7BJ)K,J JÉJJ(J+J Ďk		K´ÍK1K
+XKP[K^kK	(K@QK"K3@K%5K
K:CKERK K1HK!KK ĎnKKhKKK0K KKK K
K+KKKKK(K0K.KKK
"KK K K-K KIK K\\K KK3K0K/K K1K0K K>K K=MK 
'K1@K 9K	1HKK K$K K8K49K KK	'K head	
K0%KK
KKKKK K0%KK"KK
Ďc+;KKKK K
 Đcm DK K0K$(K KK +K 
DdK-K!K DgKK#(K
KK	K&*K$(KKK KkK K"K 5K,K27KK K
4tKKKĽłKK6CKK]{^K$$KKK0=KKKK KQKKK8K-J^K$$KKK0=KK 5K
KKKEKKKKKK%*KKKK KK.K 3K"K !WK[|KK FK	3K8)KKKK K8)KKKKKK  KKK'KK K Ą PK K K BKKKK"	$>KKKEK	KK LrKKKKK %MK8KK&KK#' KKB "KK	KKKK
4sKK$
KQmKKK@K@ŢKKKKKKK '@KK!  K!!KK,K(DKbK7(pK#K##K>IKK"2K5K5K=K3KK)5KKKK 	3KK!  K!!K//KK55KKK [KK!  K0!!K$KKK >aKK!  K!!K4KKK VKK!  K*  K	bKJNKRVKH;KKKK 2dKK!  K16  K1KX)K@K#-KK	K:*KKKKKKK K%:K04K 
HKKK(K *	8RKKK#MK	KKK SzKK-K*K /XKKK%)KK	KKKEKKK:*KKKK3K'KK K%:K04K 
HKKK(K *	8RKKK#MK	KKK SzKK-K*K /XKKK%)KK	KKKEKKK #KKK
dˇKK(K/WK<K¸ÁKKK 
c-žK(K/4KKżĹKKKK 6eKKKC
0QK))K˘KK!K33KK KK c+çKKCK!KTKŻ˝KK)E#	"KKJJK		K	+@(9KvK=
%rK&O?CKj. K%K&2KK8K44KK16KKK 2CKAAK$7KCK 'K16K%K1K((K<K((KK 4PK(2K  KrrK(K:K&5KKK (FK(2K  KllK(K:K&5KKK 'CK(2K  KGGK(K:K&5KKK ?[K(2K  KOOK(K:K&5KKK 3QK(2K  KIIK(K:K&5KKK 'CK(2K  KGGK(K:K&5KK
JKK)K"K
K5K%	K/5KK*
AK44KKK 'KKK 
"]KK-KK!#KK#KKKK XKK }ĹK!  K&K&K.KK  K&K2K"K*KKKK XK!K/SKIKKK 
'K$
KKKKKKKKK +JżKK!KKK%K>K
KK!KKKKCK)K55KKK7K%K9KK
KKKK%KK  KK
6K,  K 7K+#K-KKK "`K!#K)-KK !MKfqKKK$K*KK PKFQK&,K dKKKKK,K*K#KK,K+K$;K'QKK-KK bKKKKK,K+KK(K	DK,K, JKKK 
qKKK,K&K/K	 K3KKKK 
%lK	KK1K&K0KKKK 
jK!<KKKKKK 
$hK!<KKKKKK 
rKK.K)K,/K,/KKJKK 
mKK ;KKKK 
#"KAK/YK6K8K?KK 
"!K?K?K8KK iK/KKK	K!#KK$KKKKKKKK 
gK=K7K7KK 
"eK9K3K3KK 
FKK :K->K%KK MK28K "bK"K$K 
HK
VK  SK	SK	?K	 ,!)'K#-!3KK	KdK	`K&NKKK  SKK		AK	?K!<K	 ,	KdK	`K&NKKK K		QK #UK	LK#;KK#K1QK1QKK1QKK&MKK #D*KKWK&MK:QK:QK#K:QKKK;K(!KK
 #@KKK K,K1KKK K&K"K$K K"	%KÓK 0WK 2JKK9$7K1KKK %#gKK9KK
P
K	K#KKK?KK2KK
IKK9KK -	KK$ LKK K#K'K%OK@pśKKK K %K /KKK 	K66K&KK&&K( 6KK@^K	CKK7KVgK/mK	K	KKK 
 <KKK
K%MK %KK07	 K:AKKK K)K?K&.K KKK K##K'K#2KKKKKK*1KKKK(K9KaK\KKKKKK LKKKKKKKK*1KK!K((K KKPWK'&]KKKKL,K>RK "KKKKK K+KKK     §l  Ů  