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
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
|
// -*- indent-tabs-mode: nil; js-indent-level: 2 -*-
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
import { AppConstants } from "resource://gre/modules/AppConstants.sys.mjs";
const lazy = {};
ChromeUtils.defineESModuleGetters(lazy, {
ContextualIdentityService:
"resource://gre/modules/ContextualIdentityService.sys.mjs",
FormHistory: "resource://gre/modules/FormHistory.sys.mjs",
PlacesUtils: "resource://gre/modules/PlacesUtils.sys.mjs",
PrincipalsCollector: "resource://gre/modules/PrincipalsCollector.sys.mjs",
});
XPCOMUtils.defineLazyPreferenceGetter(
lazy,
"useOldClearHistoryDialog",
"privacy.sanitize.useOldClearHistoryDialog",
false
);
var logConsole;
function log(msg) {
if (!logConsole) {
logConsole = console.createInstance({
prefix: "** Sanitizer.jsm",
maxLogLevelPref: "browser.sanitizer.loglevel",
});
}
logConsole.log(msg);
}
// Used as unique id for pending sanitizations.
var gPendingSanitizationSerial = 0;
var gPrincipalsCollector = null;
export var Sanitizer = {
/**
* Whether we should sanitize on shutdown.
*/
PREF_SANITIZE_ON_SHUTDOWN: "privacy.sanitize.sanitizeOnShutdown",
/**
* During a sanitization this is set to a JSON containing an array of the
* pending sanitizations. This allows to retry sanitizations on startup in
* case they dind't run or were interrupted by a crash.
* Use addPendingSanitization and removePendingSanitization to manage it.
*/
PREF_PENDING_SANITIZATIONS: "privacy.sanitize.pending",
/**
* Pref branches to fetch sanitization options from.
*/
PREF_CPD_BRANCH: "privacy.cpd.",
PREF_SHUTDOWN_BRANCH: "privacy.clearOnShutdown.",
PREF_SHUTDOWN_V2_BRANCH: "privacy.clearOnShutdown_v2.",
/**
* The fallback timestamp used when no argument is given to
* Sanitizer.getClearRange.
*/
PREF_TIMESPAN: "privacy.sanitize.timeSpan",
/**
* Pref to newTab segregation. If true, on shutdown, the private container
* used in about:newtab is cleaned up. Exposed because used in tests.
*/
PREF_NEWTAB_SEGREGATION:
"privacy.usercontext.about_newtab_segregation.enabled",
/**
* Time span constants corresponding to values of the privacy.sanitize.timeSpan
* pref. Used to determine how much history to clear, for various items
*/
TIMESPAN_EVERYTHING: 0,
TIMESPAN_HOUR: 1,
TIMESPAN_2HOURS: 2,
TIMESPAN_4HOURS: 3,
TIMESPAN_TODAY: 4,
TIMESPAN_5MIN: 5,
TIMESPAN_24HOURS: 6,
/**
* Mapping time span constants to get total time in ms from the selected
* time spans
*/
timeSpanMsMap: {
TIMESPAN_5MIN: 300000, // 5*60*1000
TIMESPAN_HOUR: 3600000, // 60*60*1000
TIMESPAN_2HOURS: 7200000, // 2*60*60*1000
TIMESPAN_4HOURS: 14400000, // 4*60*60*1000
TIMESPAN_24HOURS: 86400000, // 24*60*60*1000
get TIMESPAN_TODAY() {
return Date.now() - new Date().setHours(0, 0, 0, 0);
}, // time spent today
},
/**
* Whether we should sanitize on shutdown.
* When this is set, a pending sanitization should also be added and removed
* when shutdown sanitization is complete. This allows to retry incomplete
* sanitizations on startup.
*/
shouldSanitizeOnShutdown: false,
/**
* Whether we should sanitize the private container for about:newtab.
*/
shouldSanitizeNewTabContainer: false,
/**
* Shows a sanitization dialog to the user. Returns after the dialog box has
* closed.
*
* @param parentWindow the browser window to use as parent for the created
* dialog.
* @param {string} mode - flag to let the dialog know if it is opened
* using the clear on shutdown (clearOnShutdown) settings option
* in about:preferences or in a clear site data context (clearSiteData)
*
* @throws if parentWindow is undefined or doesn't have a gDialogBox.
*/
showUI(parentWindow, mode) {
// Treat the hidden window as not being a parent window:
if (
parentWindow?.document.documentURI ==
"chrome://browser/content/hiddenWindowMac.xhtml"
) {
parentWindow = null;
}
let dialogFile = lazy.useOldClearHistoryDialog
? "sanitize.xhtml"
: "sanitize_v2.xhtml";
if (parentWindow?.gDialogBox) {
parentWindow.gDialogBox.open(`chrome://browser/content/${dialogFile}`, {
inBrowserWindow: true,
mode,
});
} else {
Services.ww.openWindow(
parentWindow,
`chrome://browser/content/${dialogFile}`,
"Sanitize",
"chrome,titlebar,dialog,centerscreen,modal",
{ needNativeUI: true, mode }
);
}
},
/**
* Performs startup tasks:
* - Checks if sanitizations were not completed during the last session.
* - Registers sanitize-on-shutdown.
*/
async onStartup() {
// First, collect pending sanitizations from the last session, before we
// add pending sanitizations for this session.
let pendingSanitizations = getAndClearPendingSanitizations();
// Check if we should sanitize on shutdown.
this.shouldSanitizeOnShutdown = Services.prefs.getBoolPref(
Sanitizer.PREF_SANITIZE_ON_SHUTDOWN,
false
);
Services.prefs.addObserver(Sanitizer.PREF_SANITIZE_ON_SHUTDOWN, this, true);
// Add a pending shutdown sanitization, if necessary.
if (this.shouldSanitizeOnShutdown) {
let itemsToClear = getItemsToClearFromPrefBranch(
Sanitizer.PREF_SHUTDOWN_BRANCH
);
addPendingSanitization("shutdown", itemsToClear, {});
}
// Shutdown sanitization is always pending, but the user may change the
// sanitize on shutdown prefs during the session. Then the pending
// sanitization would become stale and must be updated.
Services.prefs.addObserver(Sanitizer.PREF_SHUTDOWN_BRANCH, this, true);
// Make sure that we are triggered during shutdown.
let shutdownClient = lazy.PlacesUtils.history.shutdownClient.jsclient;
// We need to pass to sanitize() (through sanitizeOnShutdown) a state object
// that tracks the status of the shutdown blocker. This `progress` object
// will be updated during sanitization and reported with the crash in case of
// a shutdown timeout.
// We use the `options` argument to pass the `progress` object to sanitize().
let progress = { isShutdown: true, clearHonoringExceptions: true };
shutdownClient.addBlocker(
"sanitize.js: Sanitize on shutdown",
() => sanitizeOnShutdown(progress),
{ fetchState: () => ({ progress }) }
);
this.shouldSanitizeNewTabContainer = Services.prefs.getBoolPref(
this.PREF_NEWTAB_SEGREGATION,
false
);
if (this.shouldSanitizeNewTabContainer) {
addPendingSanitization("newtab-container", [], {});
}
let i = pendingSanitizations.findIndex(s => s.id == "newtab-container");
if (i != -1) {
pendingSanitizations.splice(i, 1);
sanitizeNewTabSegregation();
}
// Finally, run the sanitizations that were left pending, because we crashed
// before completing them.
for (let { itemsToClear, options } of pendingSanitizations) {
try {
// We need to set this flag to watch out for the users exceptions like we do on shutdown
options.progress = { clearHonoringExceptions: true };
await this.sanitize(itemsToClear, options);
} catch (ex) {
console.error(
"A previously pending sanitization failed: ",
itemsToClear,
ex
);
}
}
},
/**
* Returns a 2 element array representing the start and end times,
* in the uSec-since-epoch format that PRTime likes. If we should
* clear everything, this function returns null.
*
* @param ts [optional] a timespan to convert to start and end time.
* Falls back to the privacy.sanitize.timeSpan preference
* if this argument is omitted.
* If this argument is provided, it has to be one of the
* Sanitizer.TIMESPAN_* constants. This function will
* throw an error otherwise.
*
* @return {Array} a 2-element Array containing the start and end times.
*/
getClearRange(ts) {
if (ts === undefined) {
ts = Services.prefs.getIntPref(Sanitizer.PREF_TIMESPAN);
}
if (ts === Sanitizer.TIMESPAN_EVERYTHING) {
return null;
}
// PRTime is microseconds while JS time is milliseconds
var endDate = Date.now() * 1000;
switch (ts) {
case Sanitizer.TIMESPAN_5MIN:
var startDate = endDate - 300000000; // 5*60*1000000
break;
case Sanitizer.TIMESPAN_HOUR:
startDate = endDate - 3600000000; // 1*60*60*1000000
break;
case Sanitizer.TIMESPAN_2HOURS:
startDate = endDate - 7200000000; // 2*60*60*1000000
break;
case Sanitizer.TIMESPAN_4HOURS:
startDate = endDate - 14400000000; // 4*60*60*1000000
break;
case Sanitizer.TIMESPAN_TODAY:
var d = new Date(); // Start with today
d.setHours(0); // zero us back to midnight...
d.setMinutes(0);
d.setSeconds(0);
d.setMilliseconds(0);
startDate = d.valueOf() * 1000; // convert to epoch usec
break;
case Sanitizer.TIMESPAN_24HOURS:
startDate = endDate - 86400000000; // 24*60*60*1000000
break;
default:
throw new Error("Invalid time span for clear private data: " + ts);
}
return [startDate, endDate];
},
/**
* Deletes privacy sensitive data in a batch, according to user preferences.
* Returns a promise which is resolved if no errors occurred. If an error
* occurs, a message is reported to the console and all other items are still
* cleared before the promise is finally rejected.
*
* @param [optional] itemsToClear
* Array of items to be cleared. if specified only those
* items get cleared, irrespectively of the preference settings.
* @param [optional] options
* Object whose properties are options for this sanitization:
* - ignoreTimespan (default: true): Time span only makes sense in
* certain cases. Consumers who want to only clear some private
* data can opt in by setting this to false, and can optionally
* specify a specific range.
* If timespan is not ignored, and range is not set, sanitize() will
* use the value of the timespan pref to determine a range.
* - range (default: null): array-tuple of [from, to] timestamps
* - privateStateForNewWindow (default: "non-private"): when clearing
* open windows, defines the private state for the newly opened window.
* @returns {object} An object containing debug information about the
* sanitization progress. This state object is also used as
* AsyncShutdown metadata.
*/
async sanitize(itemsToClear = null, options = {}) {
let progress = options.progress;
// initialise the principals collector
gPrincipalsCollector = new lazy.PrincipalsCollector();
if (!progress) {
progress = options.progress = {};
}
if (!itemsToClear) {
itemsToClear = getItemsToClearFromPrefBranch(this.PREF_CPD_BRANCH);
}
let promise = sanitizeInternal(this.items, itemsToClear, options);
// Depending on preferences, the sanitizer may perform asynchronous
// work before it starts cleaning up the Places database (e.g. closing
// windows). We need to make sure that the connection to that database
// hasn't been closed by the time we use it.
// Though, if this is a sanitize on shutdown, we already have a blocker.
if (!progress.isShutdown) {
let shutdownClient = lazy.PlacesUtils.history.shutdownClient.jsclient;
shutdownClient.addBlocker("sanitize.js: Sanitize", promise, {
fetchState: () => ({ progress }),
});
}
try {
await promise;
} finally {
Services.obs.notifyObservers(null, "sanitizer-sanitization-complete");
}
return progress;
},
observe(subject, topic, data) {
if (topic == "nsPref:changed") {
if (
data.startsWith(this.PREF_SHUTDOWN_BRANCH) &&
this.shouldSanitizeOnShutdown
) {
// Update the pending shutdown sanitization.
removePendingSanitization("shutdown");
let itemsToClear = getItemsToClearFromPrefBranch(
Sanitizer.PREF_SHUTDOWN_BRANCH
);
addPendingSanitization("shutdown", itemsToClear, {});
} else if (data == this.PREF_SANITIZE_ON_SHUTDOWN) {
this.shouldSanitizeOnShutdown = Services.prefs.getBoolPref(
Sanitizer.PREF_SANITIZE_ON_SHUTDOWN,
false
);
removePendingSanitization("shutdown");
if (this.shouldSanitizeOnShutdown) {
let itemsToClear = getItemsToClearFromPrefBranch(
Sanitizer.PREF_SHUTDOWN_BRANCH
);
addPendingSanitization("shutdown", itemsToClear, {});
}
} else if (data == this.PREF_NEWTAB_SEGREGATION) {
this.shouldSanitizeNewTabContainer = Services.prefs.getBoolPref(
this.PREF_NEWTAB_SEGREGATION,
false
);
removePendingSanitization("newtab-container");
if (this.shouldSanitizeNewTabContainer) {
addPendingSanitization("newtab-container", [], {});
}
}
}
},
QueryInterface: ChromeUtils.generateQI([
"nsIObserver",
"nsISupportsWeakReference",
]),
// This method is meant to be used by tests.
async runSanitizeOnShutdown() {
// The collector needs to be reset for each test, as the collection only happens
// once and does not update after that.
// Pretend that it has never been initialized to mimic the actual browser behavior
// by setting it to null.
// The actually initialization will happen either via sanitize() or directly in
// sanitizeOnShutdown.
gPrincipalsCollector = null;
return sanitizeOnShutdown({
isShutdown: true,
clearHonoringExceptions: true,
});
},
/**
* Migrate old sanitize on shutdown prefs to the new prefs for the new
* clear on shutdown dialog. Does nothing if the migration was completed before
* based on the pref privacy.sanitize.sanitizeOnShutdown.hasMigratedToNewPrefs
*
*/
maybeMigrateSanitizeOnShutdownPrefs() {
if (
Services.prefs.getBoolPref(
"privacy.sanitize.sanitizeOnShutdown.hasMigratedToNewPrefs"
)
) {
return;
}
let cookies = Services.prefs.getBoolPref("privacy.clearOnShutdown.cookies");
let history = Services.prefs.getBoolPref("privacy.clearOnShutdown.history");
let cache = Services.prefs.getBoolPref("privacy.clearOnShutdown.cache");
let siteSettings = Services.prefs.getBoolPref(
"privacy.clearOnShutdown.siteSettings"
);
// We set cookiesAndStorage to true if cookies are enabled for clearing on shutdown
// regardless of what sessions and offlineApps are set to
// This is because cookie clearing behaviour takes precedence over sessions and offlineApps clearing.
Services.prefs.setBoolPref(
"privacy.clearOnShutdown_v2.cookiesAndStorage",
cookies
);
// we set historyFormDataAndDownloads to true if history is enabled for clearing on
// shutdown, regardless of what form data is set to.
// This is because history clearing behavious takes precedence over formdata clearing.
Services.prefs.setBoolPref(
"privacy.clearOnShutdown_v2.historyFormDataAndDownloads",
history
);
// cache and siteSettings follow the old dialog prefs
Services.prefs.setBoolPref("privacy.clearOnShutdown_v2.cache", cache);
Services.prefs.setBoolPref(
"privacy.clearOnShutdown_v2.siteSettings",
siteSettings
);
Services.prefs.setBoolPref(
"privacy.sanitize.sanitizeOnShutdown.hasMigratedToNewPrefs",
true
);
},
// When making any changes to the sanitize implementations here,
// please check whether the changes are applicable to Android
// (mobile/android/modules/geckoview/GeckoViewStorageController.jsm) as well.
items: {
cache: {
async clear(range) {
let refObj = {};
TelemetryStopwatch.start("FX_SANITIZE_CACHE", refObj);
await clearData(range, Ci.nsIClearDataService.CLEAR_ALL_CACHES);
TelemetryStopwatch.finish("FX_SANITIZE_CACHE", refObj);
},
},
cookies: {
async clear(range, { progress }, clearHonoringExceptions) {
let refObj = {};
TelemetryStopwatch.start("FX_SANITIZE_COOKIES_2", refObj);
// This is true if called by sanitizeOnShutdown.
// On shutdown we clear by principal to be able to honor the users exceptions
if (clearHonoringExceptions) {
progress.step = "getAllPrincipals";
let principalsForShutdownClearing =
await gPrincipalsCollector.getAllPrincipals(progress);
await maybeSanitizeSessionPrincipals(
progress,
principalsForShutdownClearing,
Ci.nsIClearDataService.CLEAR_COOKIES |
Ci.nsIClearDataService.CLEAR_COOKIE_BANNER_EXECUTED_RECORD |
Ci.nsIClearDataService.CLEAR_FINGERPRINTING_PROTECTION_STATE |
Ci.nsIClearDataService.CLEAR_BOUNCE_TRACKING_PROTECTION_STATE
);
} else {
// Not on shutdown
await clearData(
range,
Ci.nsIClearDataService.CLEAR_COOKIES |
Ci.nsIClearDataService.CLEAR_COOKIE_BANNER_EXECUTED_RECORD |
Ci.nsIClearDataService.CLEAR_FINGERPRINTING_PROTECTION_STATE |
Ci.nsIClearDataService.CLEAR_BOUNCE_TRACKING_PROTECTION_STATE
);
}
await clearData(range, Ci.nsIClearDataService.CLEAR_MEDIA_DEVICES);
TelemetryStopwatch.finish("FX_SANITIZE_COOKIES_2", refObj);
},
},
offlineApps: {
async clear(range, { progress }, clearHonoringExceptions) {
// This is true if called by sanitizeOnShutdown.
// On shutdown we clear by principal to be able to honor the users exceptions
if (clearHonoringExceptions) {
progress.step = "getAllPrincipals";
let principalsForShutdownClearing =
await gPrincipalsCollector.getAllPrincipals(progress);
await maybeSanitizeSessionPrincipals(
progress,
principalsForShutdownClearing,
Ci.nsIClearDataService.CLEAR_DOM_STORAGES |
Ci.nsIClearDataService.CLEAR_COOKIE_BANNER_EXECUTED_RECORD |
Ci.nsIClearDataService.CLEAR_FINGERPRINTING_PROTECTION_STATE
);
} else {
// Not on shutdown
await clearData(
range,
Ci.nsIClearDataService.CLEAR_DOM_STORAGES |
Ci.nsIClearDataService.CLEAR_COOKIE_BANNER_EXECUTED_RECORD |
Ci.nsIClearDataService.CLEAR_FINGERPRINTING_PROTECTION_STATE
);
}
},
},
history: {
async clear(range, { progress }) {
// TODO: This check is needed for the case that this method is invoked directly and not via the sanitizer.sanitize API.
// This can be removed once bug 1803799 has landed.
if (!gPrincipalsCollector) {
gPrincipalsCollector = new lazy.PrincipalsCollector();
}
progress.step = "getAllPrincipals";
let principals = await gPrincipalsCollector.getAllPrincipals(progress);
let refObj = {};
TelemetryStopwatch.start("FX_SANITIZE_HISTORY", refObj);
progress.step = "clearing browsing history";
await clearData(
range,
Ci.nsIClearDataService.CLEAR_HISTORY |
Ci.nsIClearDataService.CLEAR_SESSION_HISTORY |
Ci.nsIClearDataService.CLEAR_CONTENT_BLOCKING_RECORDS
);
// storageAccessAPI permissions record every site that the user
// interacted with and thus mirror history quite closely. It makes
// sense to clear them when we clear history. However, since their absence
// indicates that we can purge cookies and site data for tracking origins without
// user interaction, we need to ensure that we only delete those permissions that
// do not have any existing storage.
progress.step = "clearing user interaction";
await new Promise(resolve => {
Services.clearData.deleteUserInteractionForClearingHistory(
principals,
range ? range[0] : 0,
resolve
);
});
TelemetryStopwatch.finish("FX_SANITIZE_HISTORY", refObj);
},
},
formdata: {
async clear(range) {
let seenException;
let refObj = {};
TelemetryStopwatch.start("FX_SANITIZE_FORMDATA", refObj);
try {
// Clear undo history of all search bars.
for (let currentWindow of Services.wm.getEnumerator(
"navigator:browser"
)) {
let currentDocument = currentWindow.document;
// searchBar may not exist if it's in the customize mode.
let searchBar = currentDocument.getElementById("searchbar");
if (searchBar) {
let input = searchBar.textbox;
input.value = "";
input.editor?.clearUndoRedo();
}
let tabBrowser = currentWindow.gBrowser;
if (!tabBrowser) {
// No tab browser? This means that it's too early during startup (typically,
// Session Restore hasn't completed yet). Since we don't have find
// bars at that stage and since Session Restore will not restore
// find bars further down during startup, we have nothing to clear.
continue;
}
for (let tab of tabBrowser.tabs) {
if (tabBrowser.isFindBarInitialized(tab)) {
tabBrowser.getCachedFindBar(tab).clear();
}
}
// Clear any saved find value
tabBrowser._lastFindValue = "";
}
} catch (ex) {
seenException = ex;
}
try {
let change = { op: "remove" };
if (range) {
[change.firstUsedStart, change.firstUsedEnd] = range;
}
await lazy.FormHistory.update(change).catch(e => {
seenException = new Error("Error " + e.result + ": " + e.message);
});
} catch (ex) {
seenException = ex;
}
TelemetryStopwatch.finish("FX_SANITIZE_FORMDATA", refObj);
if (seenException) {
throw seenException;
}
},
},
downloads: {
async clear(range) {
let refObj = {};
TelemetryStopwatch.start("FX_SANITIZE_DOWNLOADS", refObj);
await clearData(range, Ci.nsIClearDataService.CLEAR_DOWNLOADS);
TelemetryStopwatch.finish("FX_SANITIZE_DOWNLOADS", refObj);
},
},
sessions: {
async clear(range) {
let refObj = {};
TelemetryStopwatch.start("FX_SANITIZE_SESSIONS", refObj);
await clearData(
range,
Ci.nsIClearDataService.CLEAR_AUTH_TOKENS |
Ci.nsIClearDataService.CLEAR_AUTH_CACHE
);
TelemetryStopwatch.finish("FX_SANITIZE_SESSIONS", refObj);
},
},
siteSettings: {
async clear(range) {
let refObj = {};
TelemetryStopwatch.start("FX_SANITIZE_SITESETTINGS", refObj);
await clearData(
range,
Ci.nsIClearDataService.CLEAR_PERMISSIONS |
Ci.nsIClearDataService.CLEAR_CONTENT_PREFERENCES |
Ci.nsIClearDataService.CLEAR_DOM_PUSH_NOTIFICATIONS |
Ci.nsIClearDataService.CLEAR_CLIENT_AUTH_REMEMBER_SERVICE |
Ci.nsIClearDataService.CLEAR_CERT_EXCEPTIONS |
Ci.nsIClearDataService.CLEAR_CREDENTIAL_MANAGER_STATE |
Ci.nsIClearDataService.CLEAR_COOKIE_BANNER_EXCEPTION |
Ci.nsIClearDataService.CLEAR_FINGERPRINTING_PROTECTION_STATE
);
TelemetryStopwatch.finish("FX_SANITIZE_SITESETTINGS", refObj);
},
},
openWindows: {
_canCloseWindow(win) {
if (win.CanCloseWindow()) {
// We already showed PermitUnload for the window, so let's
// make sure we don't do it again when we actually close the
// window.
win.skipNextCanClose = true;
return true;
}
return false;
},
_resetAllWindowClosures(windowList) {
for (let win of windowList) {
win.skipNextCanClose = false;
}
},
async clear(range, { privateStateForNewWindow = "non-private" }) {
// NB: this closes all *browser* windows, not other windows like the library, about window,
// browser console, etc.
// Keep track of the time in case we get stuck in la-la-land because of onbeforeunload
// dialogs
let startDate = Date.now();
// First check if all these windows are OK with being closed:
let windowList = [];
for (let someWin of Services.wm.getEnumerator("navigator:browser")) {
windowList.push(someWin);
// If someone says "no" to a beforeunload prompt, we abort here:
if (!this._canCloseWindow(someWin)) {
this._resetAllWindowClosures(windowList);
throw new Error(
"Sanitize could not close windows: cancelled by user"
);
}
// ...however, beforeunload prompts spin the event loop, and so the code here won't get
// hit until the prompt has been dismissed. If more than 1 minute has elapsed since we
// started prompting, stop, because the user might not even remember initiating the
// 'forget', and the timespans will be all wrong by now anyway:
if (Date.now() > startDate + 60 * 1000) {
this._resetAllWindowClosures(windowList);
throw new Error("Sanitize could not close windows: timeout");
}
}
if (!windowList.length) {
return;
}
// If/once we get here, we should actually be able to close all windows.
let refObj = {};
TelemetryStopwatch.start("FX_SANITIZE_OPENWINDOWS", refObj);
// First create a new window. We do this first so that on non-mac, we don't
// accidentally close the app by closing all the windows.
let handler = Cc["@mozilla.org/browser/clh;1"].getService(
Ci.nsIBrowserHandler
);
let defaultArgs = handler.defaultArgs;
let features = "chrome,all,dialog=no," + privateStateForNewWindow;
let newWindow = windowList[0].openDialog(
AppConstants.BROWSER_CHROME_URL,
"_blank",
features,
defaultArgs
);
let onFullScreen = null;
if (AppConstants.platform == "macosx") {
onFullScreen = function (e) {
newWindow.removeEventListener("fullscreen", onFullScreen);
let docEl = newWindow.document.documentElement;
let sizemode = docEl.getAttribute("sizemode");
if (!newWindow.fullScreen && sizemode == "fullscreen") {
docEl.setAttribute("sizemode", "normal");
e.preventDefault();
e.stopPropagation();
return false;
}
return undefined;
};
newWindow.addEventListener("fullscreen", onFullScreen);
}
let promiseReady = new Promise(resolve => {
// Window creation and destruction is asynchronous. We need to wait
// until all existing windows are fully closed, and the new window is
// fully open, before continuing. Otherwise the rest of the sanitizer
// could run too early (and miss new cookies being set when a page
// closes) and/or run too late (and not have a fully-formed window yet
// in existence). See bug 1088137.
let newWindowOpened = false;
let onWindowOpened = function (subject, topic, data) {
if (subject != newWindow) {
return;
}
Services.obs.removeObserver(
onWindowOpened,
"browser-delayed-startup-finished"
);
if (AppConstants.platform == "macosx") {
newWindow.removeEventListener("fullscreen", onFullScreen);
}
newWindowOpened = true;
// If we're the last thing to happen, invoke callback.
if (numWindowsClosing == 0) {
TelemetryStopwatch.finish("FX_SANITIZE_OPENWINDOWS", refObj);
resolve();
}
};
let numWindowsClosing = windowList.length;
let onWindowClosed = function () {
numWindowsClosing--;
if (numWindowsClosing == 0) {
Services.obs.removeObserver(
onWindowClosed,
"xul-window-destroyed"
);
// If we're the last thing to happen, invoke callback.
if (newWindowOpened) {
TelemetryStopwatch.finish("FX_SANITIZE_OPENWINDOWS", refObj);
resolve();
}
}
};
Services.obs.addObserver(
onWindowOpened,
"browser-delayed-startup-finished"
);
Services.obs.addObserver(onWindowClosed, "xul-window-destroyed");
});
// Start the process of closing windows
while (windowList.length) {
windowList.pop().close();
}
newWindow.focus();
await promiseReady;
},
},
pluginData: {
async clear(range) {},
},
// Combine History and Form Data clearing for the
// new clear history dialog box.
historyFormDataAndDownloads: {
async clear(range, { progress }) {
progress.step = "getAllPrincipals";
let principals = await gPrincipalsCollector.getAllPrincipals(progress);
let refObj = {};
TelemetryStopwatch.start("FX_SANITIZE_HISTORY", refObj);
progress.step = "clearing browsing history";
await clearData(
range,
Ci.nsIClearDataService.CLEAR_HISTORY |
Ci.nsIClearDataService.CLEAR_SESSION_HISTORY |
Ci.nsIClearDataService.CLEAR_CONTENT_BLOCKING_RECORDS
);
// storageAccessAPI permissions record every site that the user
// interacted with and thus mirror history quite closely. It makes
// sense to clear them when we clear history. However, since their absence
// indicates that we can purge cookies and site data for tracking origins without
// user interaction, we need to ensure that we only delete those permissions that
// do not have any existing storage.
progress.step = "clearing user interaction";
await new Promise(resolve => {
Services.clearData.deleteUserInteractionForClearingHistory(
principals,
range ? range[0] : 0,
resolve
);
});
TelemetryStopwatch.finish("FX_SANITIZE_HISTORY", refObj);
// Clear form data
let seenException;
refObj = {};
TelemetryStopwatch.start("FX_SANITIZE_FORMDATA", refObj);
try {
// Clear undo history of all search bars.
for (let currentWindow of Services.wm.getEnumerator(
"navigator:browser"
)) {
let currentDocument = currentWindow.document;
// searchBar may not exist if it's in the customize mode.
let searchBar = currentDocument.getElementById("searchbar");
if (searchBar) {
let input = searchBar.textbox;
input.value = "";
input.editor?.clearUndoRedo();
}
let tabBrowser = currentWindow.gBrowser;
if (!tabBrowser) {
// No tab browser? This means that it's too early during startup (typically,
// Session Restore hasn't completed yet). Since we don't have find
// bars at that stage and since Session Restore will not restore
// find bars further down during startup, we have nothing to clear.
continue;
}
for (let tab of tabBrowser.tabs) {
if (tabBrowser.isFindBarInitialized(tab)) {
tabBrowser.getCachedFindBar(tab).clear();
}
}
// Clear any saved find value
tabBrowser._lastFindValue = "";
}
} catch (ex) {
seenException = ex;
}
try {
let change = { op: "remove" };
if (range) {
[change.firstUsedStart, change.firstUsedEnd] = range;
}
await lazy.FormHistory.update(change).catch(e => {
seenException = new Error("Error " + e.result + ": " + e.message);
});
} catch (ex) {
seenException = ex;
}
TelemetryStopwatch.finish("FX_SANITIZE_FORMDATA", refObj);
if (seenException) {
throw seenException;
}
// clear Downloads
refObj = {};
TelemetryStopwatch.start("FX_SANITIZE_DOWNLOADS", refObj);
await clearData(range, Ci.nsIClearDataService.CLEAR_DOWNLOADS);
TelemetryStopwatch.finish("FX_SANITIZE_DOWNLOADS", refObj);
},
},
cookiesAndStorage: {
async clear(range, { progress }, clearHonoringExceptions) {
let refObj = {};
TelemetryStopwatch.start("FX_SANITIZE_COOKIES_2", refObj);
// This is true if called by sanitizeOnShutdown.
// On shutdown we clear by principal to be able to honor the users exceptions
if (clearHonoringExceptions) {
progress.step = "getAllPrincipals";
let principalsForShutdownClearing =
await gPrincipalsCollector.getAllPrincipals(progress);
await maybeSanitizeSessionPrincipals(
progress,
principalsForShutdownClearing,
Ci.nsIClearDataService.CLEAR_COOKIES |
Ci.nsIClearDataService.CLEAR_COOKIE_BANNER_EXECUTED_RECORD |
Ci.nsIClearDataService.CLEAR_DOM_STORAGES |
Ci.nsIClearDataService.CLEAR_AUTH_TOKENS |
Ci.nsIClearDataService.CLEAR_AUTH_CACHE |
Ci.nsIClearDataService.CLEAR_FINGERPRINTING_PROTECTION_STATE |
Ci.nsIClearDataService.CLEAR_BOUNCE_TRACKING_PROTECTION_STATE
);
} else {
// Not on shutdown
await clearData(
range,
Ci.nsIClearDataService.CLEAR_COOKIES |
Ci.nsIClearDataService.CLEAR_COOKIE_BANNER_EXECUTED_RECORD |
Ci.nsIClearDataService.CLEAR_DOM_STORAGES |
Ci.nsIClearDataService.CLEAR_AUTH_TOKENS |
Ci.nsIClearDataService.CLEAR_AUTH_CACHE |
Ci.nsIClearDataService.CLEAR_FINGERPRINTING_PROTECTION_STATE |
Ci.nsIClearDataService.CLEAR_BOUNCE_TRACKING_PROTECTION_STATE
);
}
await clearData(range, Ci.nsIClearDataService.CLEAR_MEDIA_DEVICES);
TelemetryStopwatch.finish("FX_SANITIZE_COOKIES_2", refObj);
},
},
},
};
async function sanitizeInternal(items, aItemsToClear, options) {
let { ignoreTimespan = true, range, progress } = options;
let seenError = false;
// Shallow copy the array, as we are going to modify it in place later.
if (!Array.isArray(aItemsToClear)) {
throw new Error("Must pass an array of items to clear.");
}
let itemsToClear = [...aItemsToClear];
// Store the list of items to clear, in case we are killed before we
// get a chance to complete.
let uid = gPendingSanitizationSerial++;
// Shutdown sanitization is managed outside.
if (!progress.isShutdown) {
addPendingSanitization(uid, itemsToClear, options);
}
// Store the list of items to clear, for debugging/forensics purposes
for (let k of itemsToClear) {
progress[k] = "ready";
// Create a progress object specific to each cleaner. We'll pass down this
// to the cleaners instead of the main progress object, so they don't end
// up overriding properties each other.
// This specific progress is deleted if the cleaner completes successfully,
// so the metadata will only contain progress of unresolved cleaners.
progress[k + "Progress"] = {};
}
// Ensure open windows get cleared first, if they're in our list, so that
// they don't stick around in the recently closed windows list, and so we
// can cancel the whole thing if the user selects to keep a window open
// from a beforeunload prompt.
let openWindowsIndex = itemsToClear.indexOf("openWindows");
if (openWindowsIndex != -1) {
itemsToClear.splice(openWindowsIndex, 1);
await items.openWindows.clear(
null,
Object.assign(options, { progress: progress.openWindowsProgress })
);
progress.openWindows = "cleared";
delete progress.openWindowsProgress;
}
// If we ignore timespan, clear everything,
// otherwise, pick a range.
if (!ignoreTimespan && !range) {
range = Sanitizer.getClearRange();
}
// For performance reasons we start all the clear tasks at once, then wait
// for their promises later.
// Some of the clear() calls may raise exceptions (for example bug 265028),
// we catch and store them, but continue to sanitize as much as possible.
// Callers should check returned errors and give user feedback
// about items that could not be sanitized
let refObj = {};
TelemetryStopwatch.start("FX_SANITIZE_TOTAL", refObj);
let annotateError = (name, ex) => {
progress[name] = "failed";
seenError = true;
console.error("Error sanitizing " + name, ex);
};
// Array of objects in form { name, promise }.
// `name` is the item's name and `promise` may be a promise, if the
// sanitization is asynchronous, or the function return value, otherwise.
let handles = [];
for (let name of itemsToClear) {
progress[name] = "blocking";
let item = items[name];
try {
// Catch errors here, so later we can just loop through these.
handles.push({
name,
promise: item
.clear(
range,
Object.assign(options, { progress: progress[name + "Progress"] }),
progress.clearHonoringExceptions
)
.then(
() => {
progress[name] = "cleared";
delete progress[name + "Progress"];
},
ex => annotateError(name, ex)
),
});
} catch (ex) {
annotateError(name, ex);
}
}
await Promise.all(handles.map(h => h.promise));
// Sanitization is complete.
TelemetryStopwatch.finish("FX_SANITIZE_TOTAL", refObj);
if (!progress.isShutdown) {
removePendingSanitization(uid);
}
progress = {};
if (seenError) {
throw new Error("Error sanitizing");
}
}
async function sanitizeOnShutdown(progress) {
log("Sanitizing on shutdown");
if (lazy.useOldClearHistoryDialog) {
progress.sanitizationPrefs = {
privacy_sanitize_sanitizeOnShutdown: Services.prefs.getBoolPref(
"privacy.sanitize.sanitizeOnShutdown"
),
privacy_clearOnShutdown_cookies: Services.prefs.getBoolPref(
"privacy.clearOnShutdown.cookies"
),
privacy_clearOnShutdown_history: Services.prefs.getBoolPref(
"privacy.clearOnShutdown.history"
),
privacy_clearOnShutdown_formdata: Services.prefs.getBoolPref(
"privacy.clearOnShutdown.formdata"
),
privacy_clearOnShutdown_downloads: Services.prefs.getBoolPref(
"privacy.clearOnShutdown.downloads"
),
privacy_clearOnShutdown_cache: Services.prefs.getBoolPref(
"privacy.clearOnShutdown.cache"
),
privacy_clearOnShutdown_sessions: Services.prefs.getBoolPref(
"privacy.clearOnShutdown.sessions"
),
privacy_clearOnShutdown_offlineApps: Services.prefs.getBoolPref(
"privacy.clearOnShutdown.offlineApps"
),
privacy_clearOnShutdown_siteSettings: Services.prefs.getBoolPref(
"privacy.clearOnShutdown.siteSettings"
),
privacy_clearOnShutdown_openWindows: Services.prefs.getBoolPref(
"privacy.clearOnShutdown.openWindows"
),
};
} else {
// Perform a migration if this is the first time sanitizeOnShutdown is
// running for the user with the new dialog
Sanitizer.maybeMigrateSanitizeOnShutdownPrefs();
progress.sanitizationPrefs = {
privacy_sanitize_sanitizeOnShutdown: Services.prefs.getBoolPref(
"privacy.sanitize.sanitizeOnShutdown"
),
privacy_clearOnShutdown_v2_cookiesAndStorage: Services.prefs.getBoolPref(
"privacy.clearOnShutdown_v2.cookiesAndStorage"
),
privacy_clearOnShutdown_v2_historyFormDataAndDownloads:
Services.prefs.getBoolPref(
"privacy.clearOnShutdown_v2.historyFormDataAndDownloads"
),
privacy_clearOnShutdown_v2_cache: Services.prefs.getBoolPref(
"privacy.clearOnShutdown_v2.cache"
),
privacy_clearOnShutdown_v2_siteSettings: Services.prefs.getBoolPref(
"privacy.clearOnShutdown_v2.siteSettings"
),
};
}
let needsSyncSavePrefs = false;
if (Sanitizer.shouldSanitizeOnShutdown) {
// Need to sanitize upon shutdown
progress.advancement = "shutdown-cleaner";
let shutdownBranch = lazy.useOldClearHistoryDialog
? Sanitizer.PREF_SHUTDOWN_BRANCH
: Sanitizer.PREF_SHUTDOWN_V2_BRANCH;
let itemsToClear = getItemsToClearFromPrefBranch(shutdownBranch);
await Sanitizer.sanitize(itemsToClear, { progress });
// We didn't crash during shutdown sanitization, so annotate it to avoid
// sanitizing again on startup.
removePendingSanitization("shutdown");
needsSyncSavePrefs = true;
}
if (Sanitizer.shouldSanitizeNewTabContainer) {
progress.advancement = "newtab-segregation";
sanitizeNewTabSegregation();
removePendingSanitization("newtab-container");
needsSyncSavePrefs = true;
}
if (needsSyncSavePrefs) {
Services.prefs.savePrefFile(null);
}
if (!Sanitizer.shouldSanitizeOnShutdown) {
// In case the user has not activated sanitizeOnShutdown but has explicitely set exceptions
// to always clear particular origins, we clear those here
progress.advancement = "session-permission";
let exceptions = 0;
let selectedPrincipals = [];
// Let's see if we have to forget some particular site.
for (let permission of Services.perms.all) {
if (
permission.type != "cookie" ||
permission.capability != Ci.nsICookiePermission.ACCESS_SESSION
) {
continue;
}
// We consider just permissions set for http, https and file URLs.
if (!isSupportedPrincipal(permission.principal)) {
continue;
}
log(
"Custom session cookie permission detected for: " +
permission.principal.asciiSpec
);
exceptions++;
// We use just the URI here, because permissions ignore OriginAttributes.
// The principalsCollector is lazy, this is computed only once
if (!gPrincipalsCollector) {
gPrincipalsCollector = new lazy.PrincipalsCollector();
}
let principals = await gPrincipalsCollector.getAllPrincipals(progress);
selectedPrincipals.push(
...extractMatchingPrincipals(principals, permission.principal.host)
);
}
await maybeSanitizeSessionPrincipals(
progress,
selectedPrincipals,
Ci.nsIClearDataService.CLEAR_ALL_CACHES |
Ci.nsIClearDataService.CLEAR_COOKIES |
Ci.nsIClearDataService.CLEAR_DOM_STORAGES |
Ci.nsIClearDataService.CLEAR_EME |
Ci.nsIClearDataService.CLEAR_BOUNCE_TRACKING_PROTECTION_STATE
);
progress.sanitizationPrefs.session_permission_exceptions = exceptions;
}
progress.advancement = "done";
}
// Extracts the principals matching matchUri as root domain.
function extractMatchingPrincipals(principals, matchHost) {
return principals.filter(principal => {
return Services.eTLD.hasRootDomain(matchHost, principal.host);
});
}
/** This method receives a list of principals and it checks if some of them or
* some of their sub-domain need to be sanitize.
* @param {Object} progress - Object to keep track of the sanitization progress, prefs and mode
* @param {nsIPrincipal[]} principals - The principals generated by the PrincipalsCollector
* @param {int} flags - The cleaning categories that need to be cleaned for the principals.
* @returns {Promise} - Resolves once the clearing of the principals to be cleared is done
*/
async function maybeSanitizeSessionPrincipals(progress, principals, flags) {
log("Sanitizing " + principals.length + " principals");
let promises = [];
let permissions = new Map();
Services.perms.getAllWithTypePrefix("cookie").forEach(perm => {
permissions.set(perm.principal.origin, perm);
});
principals.forEach(principal => {
progress.step = "checking-principal";
let cookieAllowed = cookiesAllowedForDomainOrSubDomain(
principal,
permissions
);
progress.step = "principal-checked:" + cookieAllowed;
if (!cookieAllowed) {
promises.push(sanitizeSessionPrincipal(progress, principal, flags));
}
});
progress.step = "promises:" + promises.length;
if (promises.length) {
await Promise.all(promises);
await new Promise(resolve =>
Services.clearData.cleanupAfterDeletionAtShutdown(flags, resolve)
);
}
progress.step = "promises resolved";
}
function cookiesAllowedForDomainOrSubDomain(principal, permissions) {
log("Checking principal: " + principal.asciiSpec);
// If we have the 'cookie' permission for this principal, let's return
// immediately.
let cookiePermission = checkIfCookiePermissionIsSet(principal);
if (cookiePermission != null) {
return cookiePermission;
}
for (let perm of permissions.values()) {
if (perm.type != "cookie") {
permissions.delete(perm.principal.origin);
continue;
}
// We consider just permissions set for http, https and file URLs.
if (!isSupportedPrincipal(perm.principal)) {
permissions.delete(perm.principal.origin);
continue;
}
// We don't care about scheme, port, and anything else.
if (Services.eTLD.hasRootDomain(perm.principal.host, principal.host)) {
log("Cookie check on principal: " + perm.principal.asciiSpec);
let rootDomainCookiePermission = checkIfCookiePermissionIsSet(
perm.principal
);
if (rootDomainCookiePermission != null) {
return rootDomainCookiePermission;
}
}
}
log("Cookie not allowed.");
return false;
}
/**
* Checks if a cookie permission is set for a given principal
* @returns {boolean} - true: cookie permission "ACCESS_ALLOW", false: cookie permission "ACCESS_DENY"/"ACCESS_SESSION"
* @returns {null} - No cookie permission is set for this principal
*/
function checkIfCookiePermissionIsSet(principal) {
let p = Services.perms.testPermissionFromPrincipal(principal, "cookie");
if (p == Ci.nsICookiePermission.ACCESS_ALLOW) {
log("Cookie allowed!");
return true;
}
if (
p == Ci.nsICookiePermission.ACCESS_DENY ||
p == Ci.nsICookiePermission.ACCESS_SESSION
) {
log("Cookie denied or session!");
return false;
}
// This is an old profile with unsupported permission values
if (p != Ci.nsICookiePermission.ACCESS_DEFAULT) {
log("Not supported cookie permission: " + p);
return false;
}
return null;
}
async function sanitizeSessionPrincipal(progress, principal, flags) {
log("Sanitizing principal: " + principal.asciiSpec);
await new Promise(resolve => {
progress.sanitizePrincipal = "started";
Services.clearData.deleteDataFromPrincipal(
principal,
true /* user request */,
flags,
resolve
);
});
progress.sanitizePrincipal = "completed";
}
function sanitizeNewTabSegregation() {
let identity = lazy.ContextualIdentityService.getPrivateIdentity(
"userContextIdInternal.thumbnail"
);
if (identity) {
Services.clearData.deleteDataFromOriginAttributesPattern({
userContextId: identity.userContextId,
});
}
}
/**
* Gets an array of items to clear from the given pref branch.
* @param branch The pref branch to fetch.
* @return Array of items to clear
*/
function getItemsToClearFromPrefBranch(branch) {
branch = Services.prefs.getBranch(branch);
return Object.keys(Sanitizer.items).filter(itemName => {
try {
return branch.getBoolPref(itemName);
} catch (ex) {
return false;
}
});
}
/**
* These functions are used to track pending sanitization on the next startup
* in case of a crash before a sanitization could happen.
* @param id A unique id identifying the sanitization
* @param itemsToClear The items to clear
* @param options The Sanitize options
*/
function addPendingSanitization(id, itemsToClear, options) {
let pendingSanitizations = safeGetPendingSanitizations();
pendingSanitizations.push({ id, itemsToClear, options });
Services.prefs.setStringPref(
Sanitizer.PREF_PENDING_SANITIZATIONS,
JSON.stringify(pendingSanitizations)
);
}
function removePendingSanitization(id) {
let pendingSanitizations = safeGetPendingSanitizations();
let i = pendingSanitizations.findIndex(s => s.id == id);
let [s] = pendingSanitizations.splice(i, 1);
Services.prefs.setStringPref(
Sanitizer.PREF_PENDING_SANITIZATIONS,
JSON.stringify(pendingSanitizations)
);
return s;
}
function getAndClearPendingSanitizations() {
let pendingSanitizations = safeGetPendingSanitizations();
if (pendingSanitizations.length) {
Services.prefs.clearUserPref(Sanitizer.PREF_PENDING_SANITIZATIONS);
}
return pendingSanitizations;
}
function safeGetPendingSanitizations() {
try {
return JSON.parse(
Services.prefs.getStringPref(Sanitizer.PREF_PENDING_SANITIZATIONS, "[]")
);
} catch (ex) {
console.error("Invalid JSON value for pending sanitizations: ", ex);
return [];
}
}
async function clearData(range, flags) {
if (range) {
await new Promise(resolve => {
Services.clearData.deleteDataInTimeRange(
range[0],
range[1],
true /* user request */,
flags,
resolve
);
});
} else {
await new Promise(resolve => {
Services.clearData.deleteData(flags, resolve);
});
}
}
function isSupportedPrincipal(principal) {
return ["http", "https", "file"].some(scheme => principal.schemeIs(scheme));
}
|