1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
|
// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
/**
* @fileoverview U2F gnubbyd background page
*/
'use strict';
// Singleton tracking available devices.
var gnubbies = new Gnubbies();
llUsbGnubby.register(gnubbies);
// Only include HID support if it's available in this browser.
if (chrome.hid) {
llHidGnubby.register(gnubbies);
}
var GNUBBY_FACTORY = new UsbGnubbyFactory(gnubbies);
var TIMER_FACTORY = new CountdownTimerFactory();
var SIGN_HELPER_FACTORY =
new UsbSignHelperFactory(GNUBBY_FACTORY, TIMER_FACTORY);
var ENROLL_HELPER_FACTORY =
new UsbEnrollHelperFactory(GNUBBY_FACTORY, TIMER_FACTORY);
/**
* Response status codes
* @const
* @enum {number}
*/
var ErrorCodes = {
'OK': 0,
'OTHER_ERROR': 1,
'BAD_REQUEST': 2,
'CONFIGURATION_UNSUPPORTED': 3,
'DEVICE_INELIGIBLE': 4,
'TIMEOUT': 5
};
/**
* Message types for messsages to/from the extension
* @const
* @enum {string}
*/
var MessageTypes = {
U2F_REGISTER_REQUEST: 'u2f_register_request',
U2F_SIGN_REQUEST: 'u2f_sign_request',
U2F_REGISTER_RESPONSE: 'u2f_register_response',
U2F_SIGN_RESPONSE: 'u2f_sign_response'
};
/**
* Translates a U2F request into a Gnubbyd web request.
* @param {Object} request U2F Request to translate
* @return {Object} The old (gnubbyd) style web request
* @private
*/
function translateFromU2FRequest_(request) {
var newRequest = {};
if (request['type'] == MessageTypes.U2F_REGISTER_REQUEST) {
newRequest['type'] = GnubbyMsgTypes.ENROLL_WEB_REQUEST;
} else if (request['type'] == MessageTypes.U2F_SIGN_REQUEST) {
newRequest['type'] = GnubbyMsgTypes.SIGN_WEB_REQUEST;
} else {
return null;
}
if (request['signRequests']) {
newRequest['signData'] = request['signRequests'];
}
if (request['registerRequests']) {
newRequest['enrollChallenges'] = request['registerRequests'];
}
if (typeof request['timeoutSeconds'] !== 'undefined')
newRequest['requestId'] = request['requestId'];
// requestId is handled by the message handlers below
return newRequest;
}
/**
* Translates a Gnubbyd response to a U2F response
* @param {Object} response The old (gnubbyd) style web response
* @return {Object} The corresponding U2F response
* @private
*/
function translateToU2FResponse_(response) {
var newResponse = {};
if (response['type'] == GnubbyMsgTypes.ENROLL_WEB_REPLY) {
newResponse['type'] = MessageTypes.U2F_REGISTER_RESPONSE;
} else if (response['type'] == GnubbyMsgTypes.SIGN_WEB_REPLY) {
newResponse['type'] = MessageTypes.U2F_SIGN_RESPONSE;
} else {
return null;
}
if (response['code'] == GnubbyCodeTypes.OK) {
var gnubbyResponseData = response['responseData'];
var u2fResponseData = {};
u2fResponseData['clientData'] = gnubbyResponseData['browserData'];
if (gnubbyResponseData['keyHandle'])
u2fResponseData['keyHandle'] = gnubbyResponseData['keyHandle'];
if (gnubbyResponseData['signatureData'])
u2fResponseData['signatureData'] = gnubbyResponseData['signatureData'];
if (gnubbyResponseData['enrollData'])
u2fResponseData['registrationData'] = gnubbyResponseData['enrollData'];
newResponse['responseData'] = u2fResponseData;
} else {
var code;
switch (response['code']) {
case GnubbyCodeTypes.BAD_REQUEST:
code = ErrorCodes.BAD_REQUEST;
break;
case GnubbyCodeTypes.ALREADY_ENROLLED:
case GnubbyCodeTypes.NONE_PLUGGED_ENROLLED:
case GnubbyCodeTypes.NO_DEVICES_ENROLLED:
code = ErrorCodes.DEVICE_INELIGIBLE;
break;
case GnubbyCodeTypes.BAD_APP_ID:
console.error('Invalid appId');
code = ErrorCodes.BAD_REQUEST;
break;
case GnubbyCodeTypes.UNKNOWN_ERROR:
code = ErrorCodes.OTHER_ERROR;
break;
case GnubbyCodeTypes.WAIT_TOUCH:
code = ErrorCodes.TIMEOUT;
break;
case GnubbyCodeTypes.NO_GNUBBIES:
case GnubbyCodeTypes.BUSY:
console.warn('Ignoring a deprecated gnubbyd error', response);
return null;
}
var error = {'errorCode': code};
if (response['errorDetail'])
error['errorMessage'] = response['errorDetail'];
newResponse['responseData'] = error;
}
// requestId is handled by the message handlers below
return newResponse;
}
/**
* @param {Object} request Request object
* @param {MessageSender} sender Sender frame
* @param {Function} sendResponse Response callback
* @return {?Closeable} Optional handler object that should be closed when port
* closes
*/
function handleWebPageRequest(request, sender, sendResponse) {
var wrappedSendResponse = function(resp) {
console.log(JSON.stringify(resp));
var u2fResponse = translateToU2FResponse_(resp);
if (!u2fResponse) {
console.log('Dropping gnubby response which is not compatible with U2F',
resp);
return;
}
sendResponse(u2fResponse);
};
switch (request.type) {
case MessageTypes.U2F_REGISTER_REQUEST:
return handleEnrollRequest(ENROLL_HELPER_FACTORY, sender,
translateFromU2FRequest_(request), wrappedSendResponse);
case GnubbyMsgTypes.ENROLL_WEB_REQUEST:
return handleEnrollRequest(ENROLL_HELPER_FACTORY, sender,
request, sendResponse);
case MessageTypes.U2F_SIGN_REQUEST:
return handleSignRequest(SIGN_HELPER_FACTORY, sender,
translateFromU2FRequest_(request), wrappedSendResponse);
case GnubbyMsgTypes.SIGN_WEB_REQUEST:
return handleSignRequest(SIGN_HELPER_FACTORY, sender,
request, sendResponse);
default:
var response = {
'type': MessageTypes.U2F_REGISTER_RESPONSE,
'error': { 'errorCode': ErrorCodes.BAD_REQUEST }
};
sendResponse(response);
return null;
}
}
// Listen to individual messages sent from (whitelisted) webpages via
// chrome.runtime.sendMessage
function messageHandlerExternal(request, sender, sendResponse) {
var closeable = handleWebPageRequest(request, sender, function(response) {
response['requestId'] = request['requestId'];
sendResponse(response);
if (closeable) {
closeable.close();
}
});
}
chrome.runtime.onMessageExternal.addListener(messageHandlerExternal);
// Listen to direct connection events, and wire up a message handler on the port
chrome.runtime.onConnectExternal.addListener(function(port) {
var closeable;
port.onMessage.addListener(function(request) {
closeable = handleWebPageRequest(request, port.sender,
function(response) {
response['requestId'] = request['requestId'];
port.postMessage(response);
});
});
port.onDisconnect.addListener(function() {
if (closeable) {
closeable.close();
}
});
});
|
