The Tor Browser / file comparison

comparison: toolkit/identity/RelyingParty.jsm

toolkit/identity/RelyingParty.jsm

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:0fe77cd2b5d8
1 /* -*- Mode: js2; js2-basic-offset: 2; indent-tabs-mode: nil; -*- */
2 /* vim: set ft=javascript ts=2 et sw=2 tw=80: */
3 /* This Source Code Form is subject to the terms of the Mozilla Public
4 * License, v. 2.0. If a copy of the MPL was not distributed with this file,
5 * You can obtain one at http://mozilla.org/MPL/2.0/. */
6
7 "use strict";
8
9 const Cu = Components.utils;
10 const Ci = Components.interfaces;
11 const Cc = Components.classes;
12 const Cr = Components.results;
13
14 Cu.import("resource://gre/modules/XPCOMUtils.jsm");
15 Cu.import("resource://gre/modules/Services.jsm");
16 Cu.import("resource://gre/modules/identity/LogUtils.jsm");
17 Cu.import("resource://gre/modules/identity/IdentityStore.jsm");
18
19 this.EXPORTED_SYMBOLS = ["RelyingParty"];
20
21 XPCOMUtils.defineLazyModuleGetter(this, "objectCopy",
22 "resource://gre/modules/identity/IdentityUtils.jsm");
23
24 XPCOMUtils.defineLazyModuleGetter(this,
25 "jwcrypto",
26 "resource://gre/modules/identity/jwcrypto.jsm");
27
28 function log(...aMessageArgs) {
29 Logger.log.apply(Logger, ["RP"].concat(aMessageArgs));
30 }
31 function reportError(...aMessageArgs) {
32 Logger.reportError.apply(Logger, ["RP"].concat(aMessageArgs));
33 }
34
35 function IdentityRelyingParty() {
36 // The store is a singleton shared among Identity, RelyingParty, and
37 // IdentityProvider. The Identity module takes care of resetting
38 // state in the _store on shutdown.
39 this._store = IdentityStore;
40
41 this.reset();
42 }
43
44 IdentityRelyingParty.prototype = {
45 QueryInterface: XPCOMUtils.generateQI([Ci.nsISupports, Ci.nsIObserver]),
46
47 observe: function observe(aSubject, aTopic, aData) {
48 switch (aTopic) {
49 case "quit-application-granted":
50 Services.obs.removeObserver(this, "quit-application-granted");
51 this.shutdown();
52 break;
53
54 }
55 },
56
57 reset: function RP_reset() {
58 // Forget all documents that call in. (These are sometimes
59 // referred to as callers.)
60 this._rpFlows = {};
61 },
62
63 shutdown: function RP_shutdown() {
64 this.reset();
65 Services.obs.removeObserver(this, "quit-application-granted");
66 },
67
68 /**
69 * Register a listener for a given windowID as a result of a call to
70 * navigator.id.watch().
71 *
72 * @param aCaller
73 * (Object) an object that represents the caller document, and
74 * is expected to have properties:
75 * - id (unique, e.g. uuid)
76 * - loggedInUser (string or null)
77 * - origin (string)
78 *
79 * and a bunch of callbacks
80 * - doReady()
81 * - doLogin()
82 * - doLogout()
83 * - doError()
84 * - doCancel()
85 *
86 */
87 watch: function watch(aRpCaller) {
88 this._rpFlows[aRpCaller.id] = aRpCaller;
89 let origin = aRpCaller.origin;
90 let state = this._store.getLoginState(origin) || { isLoggedIn: false, email: null };
91
92 log("watch: rpId:", aRpCaller.id,
93 "origin:", origin,
94 "loggedInUser:", aRpCaller.loggedInUser,
95 "loggedIn:", state.isLoggedIn,
96 "email:", state.email);
97
98 // If the user is already logged in, then there are three cases
99 // to deal with:
100 //
101 // 1. the email is valid and unchanged: 'ready'
102 // 2. the email is null: 'login'; 'ready'
103 // 3. the email has changed: 'login'; 'ready'
104 if (state.isLoggedIn) {
105 if (state.email && aRpCaller.loggedInUser === state.email) {
106 this._notifyLoginStateChanged(aRpCaller.id, state.email);
107 return aRpCaller.doReady();
108
109 } else if (aRpCaller.loggedInUser === null) {
110 // Generate assertion for existing login
111 let options = {loggedInUser: state.email, origin: origin};
112 return this._doLogin(aRpCaller, options);
113
114 } else {
115 // A loggedInUser different from state.email has been specified.
116 // Change login identity.
117
118 let options = {loggedInUser: state.email, origin: origin};
119 return this._doLogin(aRpCaller, options);
120 }
121
122 // If the user is not logged in, there are two cases:
123 //
124 // 1. a logged in email was provided: 'ready'; 'logout'
125 // 2. not logged in, no email given: 'ready';
126
127 } else {
128 if (aRpCaller.loggedInUser) {
129 return this._doLogout(aRpCaller, {origin: origin});
130
131 } else {
132 return aRpCaller.doReady();
133 }
134 }
135 },
136
137 /**
138 * A utility for watch() to set state and notify the dom
139 * on login
140 *
141 * Note that this calls _getAssertion
142 */
143 _doLogin: function _doLogin(aRpCaller, aOptions, aAssertion) {
144 log("_doLogin: rpId:", aRpCaller.id, "origin:", aOptions.origin);
145
146 let loginWithAssertion = function loginWithAssertion(assertion) {
147 this._store.setLoginState(aOptions.origin, true, aOptions.loggedInUser);
148 this._notifyLoginStateChanged(aRpCaller.id, aOptions.loggedInUser);
149 aRpCaller.doLogin(assertion);
150 aRpCaller.doReady();
151 }.bind(this);
152
153 if (aAssertion) {
154 loginWithAssertion(aAssertion);
155 } else {
156 this._getAssertion(aOptions, function gotAssertion(err, assertion) {
157 if (err) {
158 reportError("_doLogin:", "Failed to get assertion on login attempt:", err);
159 this._doLogout(aRpCaller);
160 } else {
161 loginWithAssertion(assertion);
162 }
163 }.bind(this));
164 }
165 },
166
167 /**
168 * A utility for watch() to set state and notify the dom
169 * on logout.
170 */
171 _doLogout: function _doLogout(aRpCaller, aOptions) {
172 log("_doLogout: rpId:", aRpCaller.id, "origin:", aOptions.origin);
173
174 let state = this._store.getLoginState(aOptions.origin) || {};
175
176 state.isLoggedIn = false;
177 this._notifyLoginStateChanged(aRpCaller.id, null);
178
179 aRpCaller.doLogout();
180 aRpCaller.doReady();
181 },
182
183 /**
184 * For use with login or logout, emit 'identity-login-state-changed'
185 *
186 * The notification will send the rp caller id in the properties,
187 * and the email of the user in the message.
188 *
189 * @param aRpCallerId
190 * (integer) The id of the RP caller
191 *
192 * @param aIdentity
193 * (string) The email of the user whose login state has changed
194 */
195 _notifyLoginStateChanged: function _notifyLoginStateChanged(aRpCallerId, aIdentity) {
196 log("_notifyLoginStateChanged: rpId:", aRpCallerId, "identity:", aIdentity);
197
198 let options = {rpId: aRpCallerId};
199 Services.obs.notifyObservers({wrappedJSObject: options},
200 "identity-login-state-changed",
201 aIdentity);
202 },
203
204 /**
205 * Initiate a login with user interaction as a result of a call to
206 * navigator.id.request().
207 *
208 * @param aRPId
209 * (integer) the id of the doc object obtained in .watch()
210 *
211 * @param aOptions
212 * (Object) options including privacyPolicy, termsOfService
213 */
214 request: function request(aRPId, aOptions) {
215 log("request: rpId:", aRPId);
216 let rp = this._rpFlows[aRPId];
217
218 // Notify UX to display identity picker.
219 // Pass the doc id to UX so it can pass it back to us later.
220 let options = {rpId: aRPId, origin: rp.origin};
221 objectCopy(aOptions, options);
222
223 // Append URLs after resolving
224 let baseURI = Services.io.newURI(rp.origin, null, null);
225 for (let optionName of ["privacyPolicy", "termsOfService"]) {
226 if (aOptions[optionName]) {
227 options[optionName] = baseURI.resolve(aOptions[optionName]);
228 }
229 }
230
231 Services.obs.notifyObservers({wrappedJSObject: options}, "identity-request", null);
232 },
233
234 /**
235 * Invoked when a user wishes to logout of a site (for instance, when clicking
236 * on an in-content logout button).
237 *
238 * @param aRpCallerId
239 * (integer) the id of the doc object obtained in .watch()
240 *
241 */
242 logout: function logout(aRpCallerId) {
243 log("logout: RP caller id:", aRpCallerId);
244 let rp = this._rpFlows[aRpCallerId];
245 if (rp && rp.origin) {
246 let origin = rp.origin;
247 log("logout: origin:", origin);
248 this._doLogout(rp, {origin: origin});
249 } else {
250 log("logout: no RP found with id:", aRpCallerId);
251 }
252 // We don't delete this._rpFlows[aRpCallerId], because
253 // the user might log back in again.
254 },
255
256 getDefaultEmailForOrigin: function getDefaultEmailForOrigin(aOrigin) {
257 let identities = this.getIdentitiesForSite(aOrigin);
258 let result = identities.lastUsed || null;
259 log("getDefaultEmailForOrigin:", aOrigin, "->", result);
260 return result;
261 },
262
263 /**
264 * Return the list of identities a user may want to use to login to aOrigin.
265 */
266 getIdentitiesForSite: function getIdentitiesForSite(aOrigin) {
267 let rv = { result: [] };
268 for (let id in this._store.getIdentities()) {
269 rv.result.push(id);
270 }
271 let loginState = this._store.getLoginState(aOrigin);
272 if (loginState && loginState.email)
273 rv.lastUsed = loginState.email;
274 return rv;
275 },
276
277 /**
278 * Obtain a BrowserID assertion with the specified characteristics.
279 *
280 * @param aCallback
281 * (Function) Callback to be called with (err, assertion) where 'err'
282 * can be an Error or NULL, and 'assertion' can be NULL or a valid
283 * BrowserID assertion. If no callback is provided, an exception is
284 * thrown.
285 *
286 * @param aOptions
287 * (Object) An object that may contain the following properties:
288 *
289 * "audience" : The audience for which the assertion is to be
290 * issued. If this property is not set an exception
291 * will be thrown.
292 *
293 * Any properties not listed above will be ignored.
294 */
295 _getAssertion: function _getAssertion(aOptions, aCallback) {
296 let audience = aOptions.origin;
297 let email = aOptions.loggedInUser || this.getDefaultEmailForOrigin(audience);
298 log("_getAssertion: audience:", audience, "email:", email);
299 if (!audience) {
300 throw "audience required for _getAssertion";
301 }
302
303 // We might not have any identity info for this email
304 if (!this._store.fetchIdentity(email)) {
305 this._store.addIdentity(email, null, null);
306 }
307
308 let cert = this._store.fetchIdentity(email)['cert'];
309 if (cert) {
310 this._generateAssertion(audience, email, function generatedAssertion(err, assertion) {
311 if (err) {
312 log("ERROR: _getAssertion:", err);
313 }
314 log("_getAssertion: generated assertion:", assertion);
315 return aCallback(err, assertion);
316 });
317 }
318 },
319
320 /**
321 * Generate an assertion, including provisioning via IdP if necessary,
322 * but no user interaction, so if provisioning fails, aCallback is invoked
323 * with an error.
324 *
325 * @param aAudience
326 * (string) web origin
327 *
328 * @param aIdentity
329 * (string) the email we're logging in with
330 *
331 * @param aCallback
332 * (function) callback to invoke on completion
333 * with first-positional parameter the error.
334 */
335 _generateAssertion: function _generateAssertion(aAudience, aIdentity, aCallback) {
336 log("_generateAssertion: audience:", aAudience, "identity:", aIdentity);
337
338 let id = this._store.fetchIdentity(aIdentity);
339 if (! (id && id.cert)) {
340 let errStr = "Cannot generate an assertion without a certificate";
341 log("ERROR: _generateAssertion:", errStr);
342 aCallback(errStr);
343 return;
344 }
345
346 let kp = id.keyPair;
347
348 if (!kp) {
349 let errStr = "Cannot generate an assertion without a keypair";
350 log("ERROR: _generateAssertion:", errStr);
351 aCallback(errStr);
352 return;
353 }
354
355 jwcrypto.generateAssertion(id.cert, kp, aAudience, aCallback);
356 },
357
358 /**
359 * Clean up references to the provisioning flow for the specified RP.
360 */
361 _cleanUpProvisionFlow: function RP_cleanUpProvisionFlow(aRPId, aProvId) {
362 let rp = this._rpFlows[aRPId];
363 if (rp) {
364 delete rp['provId'];
365 } else {
366 log("Error: Couldn't delete provision flow ", aProvId, " for RP ", aRPId);
367 }
368 },
369
370 };
371
372 this.RelyingParty = new IdentityRelyingParty();

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial