',
restrict: 'A',
scope: {
password: '=passwordMeter',
username: '=passwordMeterUsername',
outerClass: '@?'
},
link: function (scope) {
var measureStrength = function (username, password) {
if (!password || password === username) {
return 0;
}
var strength = password.length;
if (username && username !== '') {
if (username.indexOf(password) !== -1) strength -= 15;
if (password.indexOf(username) !== -1) strength -= username.length;
}
if (password.length > 0 && password.length <= 4) strength += password.length;
else if (password.length >= 5 && password.length <= 7) strength += 6;
else if (password.length >= 8 && password.length <= 15) strength += 12;
else if (password.length >= 16) strength += 18;
if (password.match(/[a-z]/)) strength += 1;
if (password.match(/[A-Z]/)) strength += 5;
if (password.match(/\d/)) strength += 5;
if (password.match(/.*\d.*\d.*\d/)) strength += 5;
if (password.match(/[!,@,#,$,%,^,&,*,?,_,~]/)) strength += 5;
if (password.match(/.*[!,@,#,$,%,^,&,*,?,_,~].*[!,@,#,$,%,^,&,*,?,_,~]/)) strength += 5;
if (password.match(/(?=.*[a-z])(?=.*[A-Z])/)) strength += 2;
if (password.match(/(?=.*\d)(?=.*[a-z])(?=.*[A-Z])/)) strength += 2;
if (password.match(/(?=.*\d)(?=.*[a-z])(?=.*[A-Z])(?=.*[!,@,#,$,%,^,&,*,?,_,~])/)) strength += 2;
strength = Math.round(strength * 2);
return Math.max(0, Math.min(100, strength));
};
var getClass = function (strength) {
switch (Math.round(strength / 33)) {
case 0:
case 1:
return 'danger';
case 2:
return 'warning';
case 3:
return 'success';
}
};
var updateMeter = function (scope) {
scope.value = measureStrength(scope.username, scope.password);
scope.valueClass = getClass(scope.value);
};
scope.$watch('password', function () {
updateMeter(scope);
});
scope.$watch('username', function () {
updateMeter(scope);
});
},
};
});
angular
.module('bit.directives')
.directive('passwordViewer', function () {
return {
restrict: 'A',
link: function (scope, element, attr) {
var passwordViewer = attr.passwordViewer;
if (!passwordViewer) {
return;
}
element.onclick = function (event) { };
element.on('click', function (event) {
var passwordElement = $(passwordViewer);
if (passwordElement && passwordElement.attr('type') === 'password') {
element.removeClass('fa-eye').addClass('fa-eye-slash');
passwordElement.attr('type', 'text');
}
else if (passwordElement && passwordElement.attr('type') === 'text') {
element.removeClass('fa-eye-slash').addClass('fa-eye');
passwordElement.attr('type', 'password');
}
});
}
};
});
angular
.module('bit.directives')
// ref: https://stackoverflow.com/a/14165848/1090359
.directive('stopClick', function () {
return function (scope, element, attrs) {
$(element).click(function (event) {
event.preventDefault();
});
};
});
angular
.module('bit.directives')
.directive('stopProp', function () {
return function (scope, element, attrs) {
$(element).click(function (event) {
event.stopPropagation();
});
};
});
angular
.module('bit.directives')
.directive('totp', ["$timeout", "$q", function ($timeout, $q) {
return {
template: '',
restrict: 'A',
scope: {
key: '=totp'
},
link: function (scope) {
var interval = null;
var Totp = function () {
var b32Chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
var leftpad = function (s, l, p) {
if (l + 1 >= s.length) {
s = Array(l + 1 - s.length).join(p) + s;
}
return s;
};
var dec2hex = function (d) {
return (d < 15.5 ? '0' : '') + Math.round(d).toString(16);
};
var hex2dec = function (s) {
return parseInt(s, 16);
};
var hex2bytes = function (s) {
var bytes = new Uint8Array(s.length / 2);
for (var i = 0; i < s.length; i += 2) {
bytes[i / 2] = parseInt(s.substr(i, 2), 16);
}
return bytes;
};
var buff2hex = function (buff) {
var bytes = new Uint8Array(buff);
var hex = [];
for (var i = 0; i < bytes.length; i++) {
hex.push((bytes[i] >>> 4).toString(16));
hex.push((bytes[i] & 0xF).toString(16));
}
return hex.join('');
};
var b32tohex = function (s) {
s = s.toUpperCase();
var cleanedInput = '';
var i;
for (i = 0; i < s.length; i++) {
if (b32Chars.indexOf(s[i]) < 0) {
continue;
}
cleanedInput += s[i];
}
s = cleanedInput;
var bits = '';
var hex = '';
for (i = 0; i < s.length; i++) {
var byteIndex = b32Chars.indexOf(s.charAt(i));
if (byteIndex < 0) {
continue;
}
bits += leftpad(byteIndex.toString(2), 5, '0');
}
for (i = 0; i + 4 <= bits.length; i += 4) {
var chunk = bits.substr(i, 4);
hex = hex + parseInt(chunk, 2).toString(16);
}
return hex;
};
var b32tobytes = function (s) {
return hex2bytes(b32tohex(s));
};
var sign = function (keyBytes, timeBytes) {
return window.crypto.subtle.importKey('raw', keyBytes,
{ name: 'HMAC', hash: { name: 'SHA-1' } }, false, ['sign']).then(function (key) {
return window.crypto.subtle.sign({ name: 'HMAC', hash: { name: 'SHA-1' } }, key, timeBytes);
}).then(function (signature) {
return buff2hex(signature);
}).catch(function (err) {
return null;
});
};
this.getCode = function (keyb32) {
var epoch = Math.round(new Date().getTime() / 1000.0);
var timeHex = leftpad(dec2hex(Math.floor(epoch / 30)), 16, '0');
var timeBytes = hex2bytes(timeHex);
var keyBytes = b32tobytes(keyb32);
if (!keyBytes.length || !timeBytes.length) {
return $q(function (resolve, reject) {
resolve(null);
});
}
return sign(keyBytes, timeBytes).then(function (hashHex) {
if (!hashHex) {
return null;
}
var offset = hex2dec(hashHex.substring(hashHex.length - 1));
var otp = (hex2dec(hashHex.substr(offset * 2, 8)) & hex2dec('7fffffff')) + '';
otp = (otp).substr(otp.length - 6, 6);
return otp;
});
};
};
var totp = new Totp();
var updateCode = function (scope) {
totp.getCode(scope.key).then(function (code) {
$timeout(function () {
if (code) {
scope.codeFormatted = code.substring(0, 3) + ' ' + code.substring(3);
scope.code = code;
}
else {
scope.code = null;
if (interval) {
clearInterval(interval);
}
}
});
});
};
var tick = function (scope) {
$timeout(function () {
var epoch = Math.round(new Date().getTime() / 1000.0);
var mod = epoch % 30;
var sec = 30 - mod;
scope.sec = sec;
scope.dash = (2.62 * mod).toFixed(2);
scope.low = sec <= 7;
if (mod === 0) {
updateCode(scope);
}
});
};
scope.$watch('key', function () {
if (!scope.key) {
scope.code = null;
if (interval) {
clearInterval(interval);
}
return;
}
updateCode(scope);
tick(scope);
if (interval) {
clearInterval(interval);
}
interval = setInterval(function () {
tick(scope);
}, 1000);
});
scope.$on('$destroy', function () {
if (interval) {
clearInterval(interval);
}
});
scope.clipboardError = function (e) {
alert('Your web browser does not support easy clipboard copying.');
};
},
};
}]);
angular
.module('bit.filters')
.filter('enumLabelClass', function () {
return function (input, name) {
if (typeof input !== 'number') {
return input.toString();
}
var output;
switch (name) {
case 'OrgUserStatus':
switch (input) {
case 0:
output = 'label-default';
break;
case 1:
output = 'label-warning';
break;
case 2:
/* falls through */
default:
output = 'label-success';
}
break;
default:
output = 'label-default';
}
return output;
};
});
angular
.module('bit.filters')
.filter('enumName', function () {
return function (input, name) {
if (typeof input !== 'number') {
return input.toString();
}
var output;
switch (name) {
case 'OrgUserStatus':
switch (input) {
case 0:
output = 'Invited';
break;
case 1:
output = 'Accepted';
break;
case 2:
/* falls through */
default:
output = 'Confirmed';
}
break;
case 'OrgUserType':
switch (input) {
case 0:
output = 'Owner';
break;
case 1:
output = 'Admin';
break;
case 2:
/* falls through */
default:
output = 'User';
}
break;
default:
output = input.toString();
}
return output;
};
});
angular
.module('bit.global')
.controller('mainController', ["$scope", "$state", "authService", "appSettings", "toastr", "$window", "$document", "cryptoService", "$uibModal", "apiService", function ($scope, $state, authService, appSettings, toastr, $window, $document,
cryptoService, $uibModal, apiService) {
var vm = this;
vm.skinClass = appSettings.selfHosted ? 'skin-blue-light' : 'skin-blue';
vm.bodyClass = '';
vm.usingControlSidebar = vm.openControlSidebar = false;
vm.searchVaultText = null;
vm.version = appSettings.version;
vm.outdatedBrowser = $window.navigator.userAgent.indexOf('MSIE') !== -1 ||
$window.navigator.userAgent.indexOf('SamsungBrowser') !== -1;
$scope.currentYear = new Date().getFullYear();
$scope.$on('$viewContentLoaded', function () {
authService.getUserProfile().then(function (profile) {
vm.userProfile = profile;
});
if ($.AdminLTE) {
if ($.AdminLTE.layout) {
$.AdminLTE.layout.fix();
$.AdminLTE.layout.fixSidebar();
}
if ($.AdminLTE.pushMenu) {
$.AdminLTE.pushMenu.expandOnHover();
}
$document.off('click', '.sidebar li a');
}
});
$scope.$on('$stateChangeSuccess', function (event, toState, toParams, fromState, fromParams) {
vm.usingEncKey = !!cryptoService.getEncKey();
vm.searchVaultText = null;
if (toState.data.bodyClass) {
vm.bodyClass = toState.data.bodyClass;
return;
}
else {
vm.bodyClass = '';
}
vm.usingControlSidebar = !!toState.data.controlSidebar;
vm.openControlSidebar = vm.usingControlSidebar && $document.width() > 768;
});
$scope.addCipher = function () {
$scope.$broadcast('vaultAddCipher');
};
$scope.addFolder = function () {
$scope.$broadcast('vaultAddFolder');
};
$scope.addOrganizationCipher = function () {
$scope.$broadcast('organizationVaultAddCipher');
};
$scope.addOrganizationCollection = function () {
$scope.$broadcast('organizationCollectionsAdd');
};
$scope.inviteOrganizationUser = function () {
$scope.$broadcast('organizationPeopleInvite');
};
$scope.addOrganizationGroup = function () {
$scope.$broadcast('organizationGroupsAdd');
};
$scope.updateKey = function () {
$uibModal.open({
animation: true,
templateUrl: 'app/settings/views/settingsUpdateKey.html',
controller: 'settingsUpdateKeyController'
});
};
$scope.verifyEmail = function () {
if ($scope.sendingVerify) {
return;
}
$scope.sendingVerify = true;
apiService.accounts.verifyEmail({}, null).$promise.then(function () {
toastr.success('Verification email sent.');
$scope.sendingVerify = false;
$scope.verifyEmailSent = true;
}).catch(function () {
toastr.success('Verification email failed.');
$scope.sendingVerify = false;
});
};
$scope.updateBrowser = function () {
$window.open('https://browser-update.org/update.html', '_blank');
};
// Append dropdown menu somewhere else
var bodyScrollbarWidth,
appendedDropdownMenu,
appendedDropdownMenuParent;
var dropdownHelpers = {
scrollbarWidth: function () {
if (!bodyScrollbarWidth) {
var bodyElem = $('body');
bodyElem.addClass('bit-position-body-scrollbar-measure');
bodyScrollbarWidth = $window.innerWidth - bodyElem[0].clientWidth;
bodyScrollbarWidth = isFinite(bodyScrollbarWidth) ? bodyScrollbarWidth : 0;
bodyElem.removeClass('bit-position-body-scrollbar-measure');
}
return bodyScrollbarWidth;
},
scrollbarInfo: function () {
return {
width: dropdownHelpers.scrollbarWidth(),
visible: $document.height() > $($window).height()
};
}
};
$(window).on('show.bs.dropdown', function (e) {
/*jshint -W120 */
var target = appendedDropdownMenuParent = $(e.target);
var appendTo = target.data('appendTo');
if (!appendTo) {
return true;
}
appendedDropdownMenu = target.find('.dropdown-menu');
var appendToEl = $(appendTo);
appendToEl.append(appendedDropdownMenu.detach());
var offset = target.offset();
var css = {
display: 'block',
top: offset.top + target.outerHeight() - (appendTo !== 'body' ? $(window).scrollTop() : 0)
};
if (appendedDropdownMenu.hasClass('dropdown-menu-right')) {
var scrollbarInfo = dropdownHelpers.scrollbarInfo();
var scrollbarWidth = 0;
if (scrollbarInfo.visible && scrollbarInfo.width) {
scrollbarWidth = scrollbarInfo.width;
}
css.right = $window.innerWidth - scrollbarWidth - (offset.left + target.prop('offsetWidth')) + 'px';
css.left = 'auto';
}
else {
css.left = offset.left + 'px';
css.right = 'auto';
}
appendedDropdownMenu.css(css);
});
$(window).on('hide.bs.dropdown', function (e) {
if (!appendedDropdownMenu) {
return true;
}
$(e.target).append(appendedDropdownMenu.detach());
appendedDropdownMenu.hide();
appendedDropdownMenu = null;
appendedDropdownMenuParent = null;
});
$scope.$on('removeAppendedDropdownMenu', function (event, args) {
if (!appendedDropdownMenu && !appendedDropdownMenuParent) {
return true;
}
appendedDropdownMenuParent.append(appendedDropdownMenu.detach());
appendedDropdownMenu.hide();
appendedDropdownMenu = null;
appendedDropdownMenuParent = null;
});
}]);
angular
.module('bit.global')
.controller('paidOrgRequiredController', ["$scope", "$state", "$uibModalInstance", "$analytics", "$uibModalStack", "orgId", "constants", "authService", function ($scope, $state, $uibModalInstance, $analytics, $uibModalStack, orgId,
constants, authService) {
$analytics.eventTrack('paidOrgRequiredController', { category: 'Modal' });
authService.getUserProfile().then(function (profile) {
$scope.admin = profile.organizations[orgId].type !== constants.orgUserType.user;
});
$scope.go = function () {
if (!$scope.admin) {
return;
}
$analytics.eventTrack('Get Paid Org');
$state.go('backend.org.billing', { orgId: orgId }).then(function () {
$uibModalStack.dismissAll();
});
};
$scope.close = function () {
$uibModalInstance.dismiss('close');
};
}]);
angular
.module('bit.global')
.controller('premiumRequiredController', ["$scope", "$state", "$uibModalInstance", "$analytics", "$uibModalStack", function ($scope, $state, $uibModalInstance, $analytics, $uibModalStack) {
$analytics.eventTrack('premiumRequiredController', { category: 'Modal' });
$scope.go = function () {
$analytics.eventTrack('Get Premium');
$state.go('backend.user.settingsPremium').then(function () {
$uibModalStack.dismissAll();
});
};
$scope.close = function () {
$uibModalInstance.dismiss('close');
};
}]);
angular
.module('bit.global')
.controller('sideNavController', ["$scope", "$state", "authService", "toastr", "$analytics", "constants", "appSettings", function ($scope, $state, authService, toastr, $analytics, constants, appSettings) {
$scope.$state = $state;
$scope.params = $state.params;
$scope.orgs = [];
$scope.name = '';
if(appSettings.selfHosted) {
$scope.orgIconBgColor = '#ffffff';
$scope.orgIconBorder = '3px solid #a0a0a0';
$scope.orgIconTextColor = '#333333';
}
else {
$scope.orgIconBgColor = '#2c3b41';
$scope.orgIconBorder = '3px solid #1a2226';
$scope.orgIconTextColor = '#ffffff';
}
authService.getUserProfile().then(function (userProfile) {
$scope.name = userProfile.extended && userProfile.extended.name ?
userProfile.extended.name : userProfile.email;
if (!userProfile.organizations) {
return;
}
if ($state.includes('backend.org') && ($state.params.orgId in userProfile.organizations)) {
$scope.orgProfile = userProfile.organizations[$state.params.orgId];
}
else {
var orgs = [];
for (var orgId in userProfile.organizations) {
if (userProfile.organizations.hasOwnProperty(orgId) &&
(userProfile.organizations[orgId].enabled || userProfile.organizations[orgId].type < 2)) { // 2 = User
orgs.push(userProfile.organizations[orgId]);
}
}
$scope.orgs = orgs;
}
});
$scope.viewOrganization = function (org) {
if (org.type === constants.orgUserType.user) {
toastr.error('You cannot manage this organization.');
return;
}
$analytics.eventTrack('View Organization From Side Nav');
$state.go('backend.org.dashboard', { orgId: org.id });
};
$scope.isOrgOwner = function (org) {
return org && org.type === constants.orgUserType.owner;
};
}]);
angular
.module('bit.global')
.controller('topNavController', ["$scope", function ($scope) {
$scope.toggleControlSidebar = function () {
var bod = $('body');
if (!bod.hasClass('control-sidebar-open')) {
bod.addClass('control-sidebar-open');
}
else {
bod.removeClass('control-sidebar-open');
}
};
}]);
angular
.module('bit.organization')
.controller('organizationBillingAdjustSeatsController', ["$scope", "$state", "$uibModalInstance", "apiService", "$analytics", "toastr", "add", function ($scope, $state, $uibModalInstance, apiService,
$analytics, toastr, add) {
$analytics.eventTrack('organizationBillingAdjustSeatsController', { category: 'Modal' });
$scope.add = add;
$scope.seatAdjustment = 0;
$scope.submit = function () {
var request = {
seatAdjustment: $scope.seatAdjustment
};
if (!add) {
request.seatAdjustment *= -1;
}
$scope.submitPromise = apiService.organizations.putSeat({ id: $state.params.orgId }, request)
.$promise.then(function (response) {
if (add) {
$analytics.eventTrack('Added Seats');
toastr.success('You have added ' + $scope.seatAdjustment + ' seats.');
}
else {
$analytics.eventTrack('Removed Seats');
toastr.success('You have removed ' + $scope.seatAdjustment + ' seats.');
}
$uibModalInstance.close();
});
};
$scope.close = function () {
$uibModalInstance.dismiss('cancel');
};
}]);
angular
.module('bit.organization')
.controller('organizationBillingAdjustStorageController', ["$scope", "$state", "$uibModalInstance", "apiService", "$analytics", "toastr", "add", function ($scope, $state, $uibModalInstance, apiService,
$analytics, toastr, add) {
$analytics.eventTrack('organizationBillingAdjustStorageController', { category: 'Modal' });
$scope.add = add;
$scope.storageAdjustment = 0;
$scope.submit = function () {
var request = {
storageGbAdjustment: $scope.storageAdjustment
};
if (!add) {
request.storageGbAdjustment *= -1;
}
$scope.submitPromise = apiService.organizations.putStorage({ id: $state.params.orgId }, request)
.$promise.then(function (response) {
if (add) {
$analytics.eventTrack('Added Organization Storage');
toastr.success('You have added ' + $scope.storageAdjustment + ' GB.');
}
else {
$analytics.eventTrack('Removed Organization Storage');
toastr.success('You have removed ' + $scope.storageAdjustment + ' GB.');
}
$uibModalInstance.close();
});
};
$scope.close = function () {
$uibModalInstance.dismiss('cancel');
};
}]);
angular
.module('bit.organization')
.controller('organizationBillingChangePaymentController', ["$scope", "$state", "$uibModalInstance", "apiService", "$analytics", "toastr", "existingPaymentMethod", "stripe", function ($scope, $state, $uibModalInstance, apiService,
$analytics, toastr, existingPaymentMethod
/* jshint ignore:start */
, stripe
/* jshint ignore:end */
) {
$analytics.eventTrack('organizationBillingChangePaymentController', { category: 'Modal' });
$scope.existingPaymentMethod = existingPaymentMethod;
$scope.paymentMethod = 'card';
$scope.showPaymentOptions = true;
$scope.hidePaypal = true;
$scope.card = {};
$scope.bank = {};
$scope.changePaymentMethod = function (val) {
$scope.paymentMethod = val;
};
$scope.submit = function () {
var stripeReq = null;
if ($scope.paymentMethod === 'card') {
stripeReq = stripe.card.createToken($scope.card);
}
else if ($scope.paymentMethod === 'bank') {
$scope.bank.currency = 'USD';
$scope.bank.country = 'US';
stripeReq = stripe.bankAccount.createToken($scope.bank);
}
else {
return;
}
$scope.submitPromise = stripeReq.then(function (response) {
var request = {
paymentToken: response.id
};
return apiService.organizations.putPayment({ id: $state.params.orgId }, request).$promise;
}, function (err) {
throw err.message;
}).then(function (response) {
$scope.card = null;
if (existingPaymentMethod) {
$analytics.eventTrack('Changed Organization Payment Method');
toastr.success('You have changed your payment method.');
}
else {
$analytics.eventTrack('Added Organization Payment Method');
toastr.success('You have added a payment method.');
}
$uibModalInstance.close();
});
};
$scope.close = function () {
$uibModalInstance.dismiss('cancel');
};
}]);
angular
.module('bit.organization')
.controller('organizationBillingChangePlanController', ["$scope", "$state", "apiService", "$uibModalInstance", "toastr", "$analytics", function ($scope, $state, apiService, $uibModalInstance,
toastr, $analytics) {
$analytics.eventTrack('organizationBillingChangePlanController', { category: 'Modal' });
$scope.submit = function () {
};
$scope.close = function () {
$uibModalInstance.dismiss('cancel');
};
}]);
angular
.module('bit.organization')
.controller('organizationBillingController', ["$scope", "apiService", "$state", "$uibModal", "toastr", "$analytics", "appSettings", "tokenService", "$window", function ($scope, apiService, $state, $uibModal, toastr, $analytics,
appSettings, tokenService, $window) {
$scope.selfHosted = appSettings.selfHosted;
$scope.charges = [];
$scope.paymentSource = null;
$scope.plan = null;
$scope.subscription = null;
$scope.loading = true;
var license = null;
$scope.expiration = null;
$scope.$on('$viewContentLoaded', function () {
load();
});
$scope.changePayment = function () {
if ($scope.selfHosted) {
return;
}
var modal = $uibModal.open({
animation: true,
templateUrl: 'app/settings/views/settingsBillingChangePayment.html',
controller: 'organizationBillingChangePaymentController',
resolve: {
existingPaymentMethod: function () {
return $scope.paymentSource ? $scope.paymentSource.description : null;
}
}
});
modal.result.then(function () {
load();
});
};
$scope.changePlan = function () {
if ($scope.selfHosted) {
return;
}
var modal = $uibModal.open({
animation: true,
templateUrl: 'app/organization/views/organizationBillingChangePlan.html',
controller: 'organizationBillingChangePlanController',
resolve: {
plan: function () {
return $scope.plan;
}
}
});
modal.result.then(function () {
load();
});
};
$scope.adjustSeats = function (add) {
if ($scope.selfHosted || !$scope.canAdjustSeats) {
return;
}
var modal = $uibModal.open({
animation: true,
templateUrl: 'app/organization/views/organizationBillingAdjustSeats.html',
controller: 'organizationBillingAdjustSeatsController',
resolve: {
add: function () {
return add;
}
}
});
modal.result.then(function () {
load();
});
};
$scope.adjustStorage = function (add) {
if ($scope.selfHosted) {
return;
}
var modal = $uibModal.open({
animation: true,
templateUrl: 'app/settings/views/settingsBillingAdjustStorage.html',
controller: 'organizationBillingAdjustStorageController',
resolve: {
add: function () {
return add;
}
}
});
modal.result.then(function () {
load();
});
};
$scope.verifyBank = function () {
if ($scope.selfHosted) {
return;
}
var modal = $uibModal.open({
animation: true,
templateUrl: 'app/organization/views/organizationBillingVerifyBank.html',
controller: 'organizationBillingVerifyBankController'
});
modal.result.then(function () {
load();
});
};
$scope.cancel = function () {
if ($scope.selfHosted) {
return;
}
if (!confirm('Are you sure you want to cancel? All users will lose access to the organization ' +
'at the end of this billing cycle.')) {
return;
}
apiService.organizations.putCancel({ id: $state.params.orgId }, {})
.$promise.then(function (response) {
$analytics.eventTrack('Canceled Plan');
toastr.success('Organization subscription has been canceled.');
load();
});
};
$scope.reinstate = function () {
if ($scope.selfHosted) {
return;
}
if (!confirm('Are you sure you want to remove the cancellation request and reinstate this organization?')) {
return;
}
apiService.organizations.putReinstate({ id: $state.params.orgId }, {})
.$promise.then(function (response) {
$analytics.eventTrack('Reinstated Plan');
toastr.success('Organization cancellation request has been removed.');
load();
});
};
$scope.updateLicense = function () {
if (!$scope.selfHosted) {
return;
}
var modal = $uibModal.open({
animation: true,
templateUrl: 'app/settings/views/settingsBillingUpdateLicense.html',
controller: 'organizationBillingUpdateLicenseController'
});
modal.result.then(function () {
load();
});
};
$scope.license = function () {
if ($scope.selfHosted) {
return;
}
var installationId = prompt("Enter your installation id");
if (!installationId || installationId === '') {
return;
}
apiService.organizations.getLicense({
id: $state.params.orgId,
installationId: installationId
}, function (license) {
var licenseString = JSON.stringify(license, null, 2);
var licenseBlob = new Blob([licenseString]);
// IE hack. ref http://msdn.microsoft.com/en-us/library/ie/hh779016.aspx
if (window.navigator.msSaveOrOpenBlob) {
window.navigator.msSaveBlob(licenseBlob, 'bitwarden_organization_license.json');
}
else {
var a = window.document.createElement('a');
a.href = window.URL.createObjectURL(licenseBlob, { type: 'text/plain' });
a.download = 'bitwarden_organization_license.json';
document.body.appendChild(a);
// IE: "Access is denied".
// ref: https://connect.microsoft.com/IE/feedback/details/797361/ie-10-treats-blob-url-as-cross-origin-and-denies-access
a.click();
document.body.removeChild(a);
}
}, function (err) {
if (err.status === 400) {
toastr.error("Invalid installation id.");
}
else {
toastr.error("Unable to generate license.");
}
});
};
$scope.viewInvoice = function (charge) {
if ($scope.selfHosted) {
return;
}
var url = appSettings.apiUri + '/organizations/' + $state.params.orgId +
'/billing-invoice/' + charge.invoiceId + '?access_token=' + tokenService.getToken();
$window.open(url);
};
function load() {
apiService.organizations.getBilling({ id: $state.params.orgId }, function (org) {
$scope.loading = false;
$scope.noSubscription = org.PlanType === 0;
$scope.canAdjustSeats = org.PlanType > 1;
var i = 0;
$scope.expiration = org.Expiration;
license = org.License;
$scope.plan = {
name: org.Plan,
type: org.PlanType,
seats: org.Seats
};
$scope.storage = null;
if ($scope && org.MaxStorageGb) {
$scope.storage = {
currentGb: org.StorageGb || 0,
maxGb: org.MaxStorageGb,
currentName: org.StorageName || '0 GB'
};
$scope.storage.percentage = +(100 * ($scope.storage.currentGb / $scope.storage.maxGb)).toFixed(2);
}
$scope.subscription = null;
if (org.Subscription) {
$scope.subscription = {
trialEndDate: org.Subscription.TrialEndDate,
cancelledDate: org.Subscription.CancelledDate,
status: org.Subscription.Status,
cancelled: org.Subscription.Cancelled,
markedForCancel: !org.Subscription.Cancelled && org.Subscription.CancelAtEndDate
};
}
$scope.nextInvoice = null;
if (org.UpcomingInvoice) {
$scope.nextInvoice = {
date: org.UpcomingInvoice.Date,
amount: org.UpcomingInvoice.Amount
};
}
if (org.Subscription && org.Subscription.Items) {
$scope.subscription.items = [];
for (i = 0; i < org.Subscription.Items.length; i++) {
$scope.subscription.items.push({
amount: org.Subscription.Items[i].Amount,
name: org.Subscription.Items[i].Name,
interval: org.Subscription.Items[i].Interval,
qty: org.Subscription.Items[i].Quantity
});
}
}
$scope.paymentSource = null;
if (org.PaymentSource) {
$scope.paymentSource = {
type: org.PaymentSource.Type,
description: org.PaymentSource.Description,
cardBrand: org.PaymentSource.CardBrand,
needsVerification: org.PaymentSource.NeedsVerification
};
}
var charges = [];
for (i = 0; i < org.Charges.length; i++) {
charges.push({
date: org.Charges[i].CreatedDate,
paymentSource: org.Charges[i].PaymentSource ? org.Charges[i].PaymentSource.Description : '-',
amount: org.Charges[i].Amount,
status: org.Charges[i].Status,
failureMessage: org.Charges[i].FailureMessage,
refunded: org.Charges[i].Refunded,
partiallyRefunded: org.Charges[i].PartiallyRefunded,
refundedAmount: org.Charges[i].RefundedAmount,
invoiceId: org.Charges[i].InvoiceId
});
}
$scope.charges = charges;
});
}
}]);
angular
.module('bit.organization')
.controller('organizationBillingUpdateLicenseController', ["$scope", "$state", "$uibModalInstance", "apiService", "$analytics", "toastr", "validationService", function ($scope, $state, $uibModalInstance, apiService,
$analytics, toastr, validationService) {
$analytics.eventTrack('organizationBillingUpdateLicenseController', { category: 'Modal' });
$scope.submit = function (form) {
var fileEl = document.getElementById('file');
var files = fileEl.files;
if (!files || !files.length) {
validationService.addError(form, 'file', 'Select a license file.', true);
return;
}
var fd = new FormData();
fd.append('license', files[0]);
$scope.submitPromise = apiService.organizations.putLicense({ id: $state.params.orgId }, fd)
.$promise.then(function (response) {
$analytics.eventTrack('Updated License');
toastr.success('You have updated your license.');
$uibModalInstance.close();
});
};
$scope.close = function () {
$uibModalInstance.dismiss('cancel');
};
}]);
angular
.module('bit.organization')
.controller('organizationBillingVerifyBankController', ["$scope", "$state", "$uibModalInstance", "apiService", "$analytics", "toastr", function ($scope, $state, $uibModalInstance, apiService,
$analytics, toastr) {
$analytics.eventTrack('organizationBillingVerifyBankController', { category: 'Modal' });
$scope.submit = function () {
var request = {
amount1: $scope.amount1,
amount2: $scope.amount2
};
$scope.submitPromise = apiService.organizations.postVerifyBank({ id: $state.params.orgId }, request)
.$promise.then(function (response) {
$analytics.eventTrack('Verified Bank Account');
toastr.success('You have successfully verified your bank account.');
$uibModalInstance.close();
});
};
$scope.close = function () {
$uibModalInstance.dismiss('cancel');
};
}]);
angular
.module('bit.organization')
.controller('organizationCollectionsAddController', ["$scope", "$state", "$uibModalInstance", "apiService", "cipherService", "$analytics", "authService", function ($scope, $state, $uibModalInstance, apiService, cipherService,
$analytics, authService) {
$analytics.eventTrack('organizationCollectionsAddController', { category: 'Modal' });
var groupsLength = 0;
$scope.groups = [];
$scope.selectedGroups = {};
$scope.loading = true;
$scope.useGroups = false;
$uibModalInstance.opened.then(function () {
return authService.getUserProfile();
}).then(function (profile) {
if (profile.organizations) {
var org = profile.organizations[$state.params.orgId];
$scope.useGroups = !!org.useGroups;
}
if ($scope.useGroups) {
return apiService.groups.listOrganization({ orgId: $state.params.orgId }).$promise;
}
return null;
}).then(function (groups) {
if (!groups) {
$scope.loading = false;
return;
}
var groupsArr = [];
for (var i = 0; i < groups.Data.length; i++) {
groupsArr.push({
id: groups.Data[i].Id,
name: groups.Data[i].Name,
accessAll: groups.Data[i].AccessAll
});
if (!groups.Data[i].AccessAll) {
groupsLength++;
}
}
$scope.groups = groupsArr;
$scope.loading = false;
});
$scope.toggleGroupSelectionAll = function ($event) {
var groups = {};
if ($event.target.checked) {
for (var i = 0; i < $scope.groups.length; i++) {
groups[$scope.groups[i].id] = {
id: $scope.groups[i].id,
readOnly: ($scope.groups[i].id in $scope.selectedGroups) ?
$scope.selectedGroups[$scope.groups[i].id].readOnly : false
};
}
}
$scope.selectedGroups = groups;
};
$scope.toggleGroupSelection = function (id) {
if (id in $scope.selectedGroups) {
delete $scope.selectedGroups[id];
}
else {
$scope.selectedGroups[id] = {
id: id,
readOnly: false
};
}
};
$scope.toggleGroupReadOnlySelection = function (group) {
if (group.id in $scope.selectedGroups) {
$scope.selectedGroups[group.id].readOnly = !group.accessAll && !!!$scope.selectedGroups[group.id].readOnly;
}
};
$scope.groupSelected = function (group) {
return group.id in $scope.selectedGroups || group.accessAll;
};
$scope.allSelected = function () {
return Object.keys($scope.selectedGroups).length >= groupsLength;
};
$scope.submit = function (model) {
var collection = cipherService.encryptCollection(model, $state.params.orgId);
if ($scope.useGroups) {
collection.groups = [];
for (var groupId in $scope.selectedGroups) {
if ($scope.selectedGroups.hasOwnProperty(groupId)) {
for (var i = 0; i < $scope.groups.length; i++) {
if ($scope.groups[i].id === $scope.selectedGroups[groupId].id) {
if (!$scope.groups[i].accessAll) {
collection.groups.push($scope.selectedGroups[groupId]);
}
break;
}
}
}
}
}
$scope.submitPromise = apiService.collections.post({ orgId: $state.params.orgId }, collection, function (response) {
$analytics.eventTrack('Created Collection');
var decCollection = cipherService.decryptCollection(response, $state.params.orgId, true);
$uibModalInstance.close(decCollection);
}).$promise;
};
$scope.close = function () {
$uibModalInstance.dismiss('cancel');
};
}]);
angular
.module('bit.organization')
.controller('organizationCollectionsController', ["$scope", "$state", "apiService", "$uibModal", "cipherService", "$filter", "toastr", "$analytics", "$uibModalStack", function ($scope, $state, apiService, $uibModal, cipherService, $filter,
toastr, $analytics, $uibModalStack) {
$scope.collections = [];
$scope.loading = true;
$scope.$on('$viewContentLoaded', function () {
loadList();
});
$scope.$on('organizationCollectionsAdd', function (event, args) {
$scope.add();
});
$scope.add = function () {
var modal = $uibModal.open({
animation: true,
templateUrl: 'app/organization/views/organizationCollectionsAdd.html',
controller: 'organizationCollectionsAddController'
});
modal.result.then(function (collection) {
$scope.collections.push(collection);
});
};
$scope.edit = function (collection) {
var modal = $uibModal.open({
animation: true,
templateUrl: 'app/organization/views/organizationCollectionsEdit.html',
controller: 'organizationCollectionsEditController',
resolve: {
id: function () { return collection.id; }
}
});
modal.result.then(function (editedCollection) {
var existingCollections = $filter('filter')($scope.collections, { id: editedCollection.id }, true);
if (existingCollections && existingCollections.length > 0) {
existingCollections[0].name = editedCollection.name;
}
});
};
$scope.users = function (collection) {
var modal = $uibModal.open({
animation: true,
templateUrl: 'app/organization/views/organizationCollectionsUsers.html',
controller: 'organizationCollectionsUsersController',
size: 'lg',
resolve: {
collection: function () { return collection; }
}
});
modal.result.then(function () {
// nothing to do
});
};
$scope.groups = function (collection) {
var modal = $uibModal.open({
animation: true,
templateUrl: 'app/organization/views/organizationCollectionsGroups.html',
controller: 'organizationCollectionsGroupsController',
resolve: {
collection: function () { return collection; }
}
});
modal.result.then(function () {
// nothing to do
});
};
$scope.delete = function (collection) {
if (!confirm('Are you sure you want to delete this collection (' + collection.name + ')?')) {
return;
}
apiService.collections.del({ orgId: $state.params.orgId, id: collection.id }, function () {
var index = $scope.collections.indexOf(collection);
if (index > -1) {
$scope.collections.splice(index, 1);
}
$analytics.eventTrack('Deleted Collection');
toastr.success(collection.name + ' has been deleted.', 'Collection Deleted');
}, function () {
toastr.error(collection.name + ' was not able to be deleted.', 'Error');
});
};
function loadList() {
apiService.collections.listOrganization({ orgId: $state.params.orgId }, function (list) {
$scope.collections = cipherService.decryptCollections(list.Data, $state.params.orgId, true);
$scope.loading = false;
if ($state.params.search) {
$uibModalStack.dismissAll();
$scope.filterSearch = $state.params.search;
$('#filterSearch').focus();
}
});
}
}]);
angular
.module('bit.organization')
.controller('organizationCollectionsEditController', ["$scope", "$state", "$uibModalInstance", "apiService", "cipherService", "$analytics", "id", "authService", function ($scope, $state, $uibModalInstance, apiService, cipherService,
$analytics, id, authService) {
$analytics.eventTrack('organizationCollectionsEditController', { category: 'Modal' });
var groupsLength = 0;
$scope.collection = {};
$scope.groups = [];
$scope.selectedGroups = {};
$scope.loading = true;
$scope.useGroups = false;
$uibModalInstance.opened.then(function () {
return apiService.collections.getDetails({ orgId: $state.params.orgId, id: id }).$promise;
}).then(function (collection) {
$scope.collection = cipherService.decryptCollection(collection);
var groups = {};
if (collection.Groups) {
for (var i = 0; i < collection.Groups.length; i++) {
groups[collection.Groups[i].Id] = {
id: collection.Groups[i].Id,
readOnly: collection.Groups[i].ReadOnly
};
}
}
$scope.selectedGroups = groups;
return authService.getUserProfile();
}).then(function (profile) {
if (profile.organizations) {
var org = profile.organizations[$state.params.orgId];
$scope.useGroups = !!org.useGroups;
}
if ($scope.useGroups) {
return apiService.groups.listOrganization({ orgId: $state.params.orgId }).$promise;
}
return null;
}).then(function (groups) {
if (!groups) {
$scope.loading = false;
return;
}
var groupsArr = [];
for (var i = 0; i < groups.Data.length; i++) {
groupsArr.push({
id: groups.Data[i].Id,
name: groups.Data[i].Name,
accessAll: groups.Data[i].AccessAll
});
if (!groups.Data[i].AccessAll) {
groupsLength++;
}
}
$scope.groups = groupsArr;
$scope.loading = false;
});
$scope.toggleGroupSelectionAll = function ($event) {
var groups = {};
if ($event.target.checked) {
for (var i = 0; i < $scope.groups.length; i++) {
groups[$scope.groups[i].id] = {
id: $scope.groups[i].id,
readOnly: ($scope.groups[i].id in $scope.selectedGroups) ?
$scope.selectedGroups[$scope.groups[i].id].readOnly : false
};
}
}
$scope.selectedGroups = groups;
};
$scope.toggleGroupSelection = function (id) {
if (id in $scope.selectedGroups) {
delete $scope.selectedGroups[id];
}
else {
$scope.selectedGroups[id] = {
id: id,
readOnly: false
};
}
};
$scope.toggleGroupReadOnlySelection = function (group) {
if (group.id in $scope.selectedGroups) {
$scope.selectedGroups[group.id].readOnly = !group.accessAll && !!!$scope.selectedGroups[group.id].readOnly;
}
};
$scope.groupSelected = function (group) {
return group.id in $scope.selectedGroups || group.accessAll;
};
$scope.allSelected = function () {
return Object.keys($scope.selectedGroups).length >= groupsLength;
};
$scope.submit = function (model) {
var collection = cipherService.encryptCollection(model, $state.params.orgId);
if ($scope.useGroups) {
collection.groups = [];
for (var groupId in $scope.selectedGroups) {
if ($scope.selectedGroups.hasOwnProperty(groupId)) {
for (var i = 0; i < $scope.groups.length; i++) {
if ($scope.groups[i].id === $scope.selectedGroups[groupId].id) {
if (!$scope.groups[i].accessAll) {
collection.groups.push($scope.selectedGroups[groupId]);
}
break;
}
}
}
}
}
$scope.submitPromise = apiService.collections.put({
orgId: $state.params.orgId,
id: id
}, collection, function (response) {
$analytics.eventTrack('Edited Collection');
var decCollection = cipherService.decryptCollection(response, $state.params.orgId, true);
$uibModalInstance.close(decCollection);
}).$promise;
};
$scope.close = function () {
$uibModalInstance.dismiss('cancel');
};
}]);
angular
.module('bit.organization')
.controller('organizationCollectionsUsersController', ["$scope", "$state", "$uibModalInstance", "apiService", "cipherService", "$analytics", "collection", "toastr", function ($scope, $state, $uibModalInstance, apiService, cipherService,
$analytics, collection, toastr) {
$analytics.eventTrack('organizationCollectionsUsersController', { category: 'Modal' });
$scope.loading = true;
$scope.collection = collection;
$scope.users = [];
$uibModalInstance.opened.then(function () {
$scope.loading = false;
apiService.collections.listUsers(
{
orgId: $state.params.orgId,
id: collection.id
},
function (userList) {
if (userList && userList.Data.length) {
var users = [];
for (var i = 0; i < userList.Data.length; i++) {
users.push({
organizationUserId: userList.Data[i].OrganizationUserId,
name: userList.Data[i].Name,
email: userList.Data[i].Email,
type: userList.Data[i].Type,
status: userList.Data[i].Status,
readOnly: userList.Data[i].ReadOnly,
accessAll: userList.Data[i].AccessAll
});
}
$scope.users = users;
}
});
});
$scope.remove = function (user) {
if (!confirm('Are you sure you want to remove this user (' + user.email + ') from this ' +
'collection (' + collection.name + ')?')) {
return;
}
apiService.collections.delUser(
{
orgId: $state.params.orgId,
id: collection.id,
orgUserId: user.organizationUserId
}, null, function () {
toastr.success(user.email + ' has been removed.', 'User Removed');
$analytics.eventTrack('Removed User From Collection');
var index = $scope.users.indexOf(user);
if (index > -1) {
$scope.users.splice(index, 1);
}
}, function () {
toastr.error('Unable to remove user.', 'Error');
});
};
$scope.close = function () {
$uibModalInstance.dismiss('cancel');
};
}]);
angular
.module('bit.organization')
.controller('organizationDashboardController', ["$scope", "authService", "$state", "appSettings", function ($scope, authService, $state, appSettings) {
$scope.selfHosted = appSettings.selfHosted;
$scope.$on('$viewContentLoaded', function () {
authService.getUserProfile().then(function (userProfile) {
if (!userProfile.organizations) {
return;
}
$scope.orgProfile = userProfile.organizations[$state.params.orgId];
});
});
$scope.goBilling = function () {
$state.go('backend.org.billing', { orgId: $state.params.orgId });
};
}]);
angular
.module('bit.organization')
.controller('organizationDeleteController', ["$scope", "$state", "apiService", "$uibModalInstance", "cryptoService", "authService", "toastr", "$analytics", function ($scope, $state, apiService, $uibModalInstance, cryptoService,
authService, toastr, $analytics) {
$analytics.eventTrack('organizationDeleteController', { category: 'Modal' });
$scope.submit = function () {
$scope.submitPromise = cryptoService.hashPassword($scope.masterPassword).then(function (hash) {
return apiService.organizations.del({ id: $state.params.orgId }, {
masterPasswordHash: hash
}).$promise;
}).then(function () {
$uibModalInstance.dismiss('cancel');
authService.removeProfileOrganization($state.params.orgId);
$analytics.eventTrack('Deleted Organization');
return $state.go('backend.user.vault');
}).then(function () {
toastr.success('This organization and all associated data has been deleted.', 'Organization Deleted');
});
};
$scope.close = function () {
$uibModalInstance.dismiss('cancel');
};
}]);
angular
.module('bit.organization')
.controller('organizationEventsController', ["$scope", "$state", "apiService", "$uibModal", "$filter", "toastr", "$analytics", "constants", "eventService", "$compile", "$sce", function ($scope, $state, apiService, $uibModal, $filter,
toastr, $analytics, constants, eventService, $compile, $sce) {
$scope.events = [];
$scope.orgUsers = [];
$scope.loading = true;
$scope.continuationToken = null;
var defaultFilters = eventService.getDefaultDateFilters();
$scope.filterStart = defaultFilters.start;
$scope.filterEnd = defaultFilters.end;
$scope.$on('$viewContentLoaded', function () {
load();
});
$scope.refresh = function () {
loadEvents(true);
};
$scope.next = function () {
loadEvents(false);
};
var i = 0,
orgUsersUserIdDict = {},
orgUsersIdDict = {};
function load() {
apiService.organizationUsers.list({ orgId: $state.params.orgId }).$promise.then(function (list) {
var users = [];
for (i = 0; i < list.Data.length; i++) {
var user = {
id: list.Data[i].Id,
userId: list.Data[i].UserId,
name: list.Data[i].Name,
email: list.Data[i].Email
};
users.push(user);
var displayName = user.name || user.email;
orgUsersUserIdDict[user.userId] = displayName;
orgUsersIdDict[user.id] = displayName;
}
$scope.orgUsers = users;
return loadEvents(true);
});
}
function loadEvents(clearExisting) {
var filterResult = eventService.formatDateFilters($scope.filterStart, $scope.filterEnd);
if (filterResult.error) {
alert(filterResult.error);
return;
}
if (clearExisting) {
$scope.continuationToken = null;
$scope.events = [];
}
$scope.loading = true;
return apiService.events.listOrganization({
orgId: $state.params.orgId,
start: filterResult.start,
end: filterResult.end,
continuationToken: $scope.continuationToken
}).$promise.then(function (list) {
$scope.continuationToken = list.ContinuationToken;
var events = [];
for (i = 0; i < list.Data.length; i++) {
var userId = list.Data[i].ActingUserId || list.Data[i].UserId;
var eventInfo = eventService.getEventInfo(list.Data[i]);
var htmlMessage = $compile('' + eventInfo.message + '')($scope);
events.push({
message: $sce.trustAsHtml(htmlMessage[0].outerHTML),
appIcon: eventInfo.appIcon,
appName: eventInfo.appName,
userId: userId,
userName: userId ? (orgUsersUserIdDict[userId] || '-') : '-',
date: list.Data[i].Date,
ip: list.Data[i].IpAddress
});
}
if ($scope.events && $scope.events.length > 0) {
$scope.events = $scope.events.concat(events);
}
else {
$scope.events = events;
}
$scope.loading = false;
});
}
}]);
angular
.module('bit.organization')
.controller('organizationGroupsAddController', ["$scope", "$state", "$uibModalInstance", "apiService", "cipherService", "$analytics", function ($scope, $state, $uibModalInstance, apiService, cipherService,
$analytics) {
$analytics.eventTrack('organizationGroupsAddController', { category: 'Modal' });
$scope.collections = [];
$scope.selectedCollections = {};
$scope.loading = true;
$uibModalInstance.opened.then(function () {
return apiService.collections.listOrganization({ orgId: $state.params.orgId }).$promise;
}).then(function (collections) {
$scope.collections = cipherService.decryptCollections(collections.Data, $state.params.orgId, true);
$scope.loading = false;
});
$scope.toggleCollectionSelectionAll = function ($event) {
var collections = {};
if ($event.target.checked) {
for (var i = 0; i < $scope.collections.length; i++) {
collections[$scope.collections[i].id] = {
id: $scope.collections[i].id,
readOnly: ($scope.collections[i].id in $scope.selectedCollections) ?
$scope.selectedCollections[$scope.collections[i].id].readOnly : false
};
}
}
$scope.selectedCollections = collections;
};
$scope.toggleCollectionSelection = function (id) {
if (id in $scope.selectedCollections) {
delete $scope.selectedCollections[id];
}
else {
$scope.selectedCollections[id] = {
id: id,
readOnly: false
};
}
};
$scope.toggleCollectionReadOnlySelection = function (id) {
if (id in $scope.selectedCollections) {
$scope.selectedCollections[id].readOnly = !!!$scope.selectedCollections[id].readOnly;
}
};
$scope.collectionSelected = function (collection) {
return collection.id in $scope.selectedCollections;
};
$scope.allSelected = function () {
return Object.keys($scope.selectedCollections).length === $scope.collections.length;
};
$scope.submit = function (model) {
var group = {
name: model.name,
accessAll: !!model.accessAll,
externalId: model.externalId
};
if (!group.accessAll) {
group.collections = [];
for (var collectionId in $scope.selectedCollections) {
if ($scope.selectedCollections.hasOwnProperty(collectionId)) {
group.collections.push($scope.selectedCollections[collectionId]);
}
}
}
$scope.submitPromise = apiService.groups.post({ orgId: $state.params.orgId }, group, function (response) {
$analytics.eventTrack('Created Group');
$uibModalInstance.close({
id: response.Id,
name: response.Name
});
}).$promise;
};
$scope.close = function () {
$uibModalInstance.dismiss('cancel');
};
}]);
angular
.module('bit.organization')
.controller('organizationGroupsController', ["$scope", "$state", "apiService", "$uibModal", "$filter", "toastr", "$analytics", "$uibModalStack", function ($scope, $state, apiService, $uibModal, $filter,
toastr, $analytics, $uibModalStack) {
$scope.groups = [];
$scope.loading = true;
$scope.$on('$viewContentLoaded', function () {
loadList();
});
$scope.$on('organizationGroupsAdd', function (event, args) {
$scope.add();
});
$scope.add = function () {
var modal = $uibModal.open({
animation: true,
templateUrl: 'app/organization/views/organizationGroupsAdd.html',
controller: 'organizationGroupsAddController'
});
modal.result.then(function (group) {
$scope.groups.push(group);
});
};
$scope.edit = function (group) {
var modal = $uibModal.open({
animation: true,
templateUrl: 'app/organization/views/organizationGroupsEdit.html',
controller: 'organizationGroupsEditController',
resolve: {
id: function () { return group.id; }
}
});
modal.result.then(function (editedGroup) {
var existingGroups = $filter('filter')($scope.groups, { id: editedGroup.id }, true);
if (existingGroups && existingGroups.length > 0) {
existingGroups[0].name = editedGroup.name;
}
});
};
$scope.users = function (group) {
var modal = $uibModal.open({
animation: true,
templateUrl: 'app/organization/views/organizationGroupsUsers.html',
controller: 'organizationGroupsUsersController',
size: 'lg',
resolve: {
group: function () { return group; }
}
});
modal.result.then(function () {
// nothing to do
});
};
$scope.delete = function (group) {
if (!confirm('Are you sure you want to delete this group (' + group.name + ')?')) {
return;
}
apiService.groups.del({ orgId: $state.params.orgId, id: group.id }, function () {
var index = $scope.groups.indexOf(group);
if (index > -1) {
$scope.groups.splice(index, 1);
}
$analytics.eventTrack('Deleted Group');
toastr.success(group.name + ' has been deleted.', 'Group Deleted');
}, function () {
toastr.error(group.name + ' was not able to be deleted.', 'Error');
});
};
function loadList() {
apiService.groups.listOrganization({ orgId: $state.params.orgId }, function (list) {
var groups = [];
for (var i = 0; i < list.Data.length; i++) {
groups.push({
id: list.Data[i].Id,
name: list.Data[i].Name
});
}
$scope.groups = groups;
$scope.loading = false;
if ($state.params.search) {
$uibModalStack.dismissAll();
$scope.filterSearch = $state.params.search;
$('#filterSearch').focus();
}
});
}
}]);
angular
.module('bit.organization')
.controller('organizationGroupsEditController', ["$scope", "$state", "$uibModalInstance", "apiService", "cipherService", "$analytics", "id", function ($scope, $state, $uibModalInstance, apiService, cipherService,
$analytics, id) {
$analytics.eventTrack('organizationGroupsEditController', { category: 'Modal' });
$scope.collections = [];
$scope.selectedCollections = {};
$scope.loading = true;
$uibModalInstance.opened.then(function () {
return apiService.groups.getDetails({ orgId: $state.params.orgId, id: id }).$promise;
}).then(function (group) {
$scope.group = {
id: id,
name: group.Name,
externalId: group.ExternalId,
accessAll: group.AccessAll
};
var collections = {};
if (group.Collections) {
for (var i = 0; i < group.Collections.length; i++) {
collections[group.Collections[i].Id] = {
id: group.Collections[i].Id,
readOnly: group.Collections[i].ReadOnly
};
}
}
$scope.selectedCollections = collections;
return apiService.collections.listOrganization({ orgId: $state.params.orgId }).$promise;
}).then(function (collections) {
$scope.collections = cipherService.decryptCollections(collections.Data, $state.params.orgId, true);
$scope.loading = false;
});
$scope.toggleCollectionSelectionAll = function ($event) {
var collections = {};
if ($event.target.checked) {
for (var i = 0; i < $scope.collections.length; i++) {
collections[$scope.collections[i].id] = {
id: $scope.collections[i].id,
readOnly: ($scope.collections[i].id in $scope.selectedCollections) ?
$scope.selectedCollections[$scope.collections[i].id].readOnly : false
};
}
}
$scope.selectedCollections = collections;
};
$scope.toggleCollectionSelection = function (id) {
if (id in $scope.selectedCollections) {
delete $scope.selectedCollections[id];
}
else {
$scope.selectedCollections[id] = {
id: id,
readOnly: false
};
}
};
$scope.toggleCollectionReadOnlySelection = function (id) {
if (id in $scope.selectedCollections) {
$scope.selectedCollections[id].readOnly = !!!$scope.selectedCollections[id].readOnly;
}
};
$scope.collectionSelected = function (collection) {
return collection.id in $scope.selectedCollections;
};
$scope.allSelected = function () {
return Object.keys($scope.selectedCollections).length === $scope.collections.length;
};
$scope.submit = function () {
var group = {
name: $scope.group.name,
accessAll: !!$scope.group.accessAll,
externalId: $scope.group.externalId
};
if (!group.accessAll) {
group.collections = [];
for (var collectionId in $scope.selectedCollections) {
if ($scope.selectedCollections.hasOwnProperty(collectionId)) {
group.collections.push($scope.selectedCollections[collectionId]);
}
}
}
$scope.submitPromise = apiService.groups.put({
orgId: $state.params.orgId,
id: id
}, group, function (response) {
$analytics.eventTrack('Edited Group');
$uibModalInstance.close({
id: response.Id,
name: response.Name
});
}).$promise;
};
$scope.close = function () {
$uibModalInstance.dismiss('cancel');
};
}]);
angular
.module('bit.organization')
.controller('organizationGroupsUsersController', ["$scope", "$state", "$uibModalInstance", "apiService", "$analytics", "group", "toastr", function ($scope, $state, $uibModalInstance, apiService,
$analytics, group, toastr) {
$analytics.eventTrack('organizationGroupUsersController', { category: 'Modal' });
$scope.loading = true;
$scope.group = group;
$scope.users = [];
$uibModalInstance.opened.then(function () {
return apiService.groups.listUsers({
orgId: $state.params.orgId,
id: group.id
}).$promise;
}).then(function (userList) {
var users = [];
if (userList && userList.Data.length) {
for (var i = 0; i < userList.Data.length; i++) {
users.push({
organizationUserId: userList.Data[i].OrganizationUserId,
name: userList.Data[i].Name,
email: userList.Data[i].Email,
type: userList.Data[i].Type,
status: userList.Data[i].Status,
accessAll: userList.Data[i].AccessAll
});
}
}
$scope.users = users;
$scope.loading = false;
});
$scope.remove = function (user) {
if (!confirm('Are you sure you want to remove this user (' + user.email + ') from this ' +
'group (' + group.name + ')?')) {
return;
}
apiService.groups.delUser({ orgId: $state.params.orgId, id: group.id, orgUserId: user.organizationUserId }, null,
function () {
toastr.success(user.email + ' has been removed.', 'User Removed');
$analytics.eventTrack('Removed User From Group');
var index = $scope.users.indexOf(user);
if (index > -1) {
$scope.users.splice(index, 1);
}
}, function () {
toastr.error('Unable to remove user.', 'Error');
});
};
$scope.close = function () {
$uibModalInstance.dismiss('cancel');
};
}]);
angular
.module('bit.organization')
.controller('organizationPeopleController', ["$scope", "$state", "$uibModal", "cryptoService", "apiService", "authService", "toastr", "$analytics", "$filter", "$uibModalStack", function ($scope, $state, $uibModal, cryptoService, apiService, authService,
toastr, $analytics, $filter, $uibModalStack) {
$scope.users = [];
$scope.useGroups = false;
$scope.useEvents = false;
$scope.$on('$viewContentLoaded', function () {
loadList();
authService.getUserProfile().then(function (profile) {
if (profile.organizations) {
var org = profile.organizations[$state.params.orgId];
$scope.useGroups = !!org.useGroups;
$scope.useEvents = !!org.useEvents;
}
});
});
$scope.reinvite = function (user) {
apiService.organizationUsers.reinvite({ orgId: $state.params.orgId, id: user.id }, null, function () {
$analytics.eventTrack('Reinvited User');
toastr.success(user.email + ' has been invited again.', 'User Invited');
}, function () {
toastr.error('Unable to invite user.', 'Error');
});
};
$scope.delete = function (user) {
if (!confirm('Are you sure you want to remove this user (' + user.email + ')?')) {
return;
}
apiService.organizationUsers.del({ orgId: $state.params.orgId, id: user.id }, null, function () {
$analytics.eventTrack('Deleted User');
toastr.success(user.email + ' has been removed.', 'User Removed');
var index = $scope.users.indexOf(user);
if (index > -1) {
$scope.users.splice(index, 1);
}
}, function () {
toastr.error('Unable to remove user.', 'Error');
});
};
$scope.confirm = function (user) {
apiService.users.getPublicKey({ id: user.userId }, function (userKey) {
var orgKey = cryptoService.getOrgKey($state.params.orgId);
if (!orgKey) {
toastr.error('Unable to confirm user.', 'Error');
return;
}
var key = cryptoService.rsaEncrypt(orgKey.key, userKey.PublicKey);
apiService.organizationUsers.confirm({ orgId: $state.params.orgId, id: user.id }, { key: key }, function () {
user.status = 2;
$analytics.eventTrack('Confirmed User');
toastr.success(user.email + ' has been confirmed.', 'User Confirmed');
}, function () {
toastr.error('Unable to confirm user.', 'Error');
});
}, function () {
toastr.error('Unable to confirm user.', 'Error');
});
};
$scope.$on('organizationPeopleInvite', function (event, args) {
$scope.invite();
});
$scope.invite = function () {
var modal = $uibModal.open({
animation: true,
templateUrl: 'app/organization/views/organizationPeopleInvite.html',
controller: 'organizationPeopleInviteController'
});
modal.result.then(function () {
loadList();
});
};
$scope.edit = function (orgUser) {
var modal = $uibModal.open({
animation: true,
templateUrl: 'app/organization/views/organizationPeopleEdit.html',
controller: 'organizationPeopleEditController',
resolve: {
orgUser: function () { return orgUser; }
}
});
modal.result.then(function () {
loadList();
});
};
$scope.groups = function (user) {
var modal = $uibModal.open({
animation: true,
templateUrl: 'app/organization/views/organizationPeopleGroups.html',
controller: 'organizationPeopleGroupsController',
resolve: {
orgUser: function () { return user; }
}
});
modal.result.then(function () {
});
};
$scope.events = function (user) {
$uibModal.open({
animation: true,
templateUrl: 'app/organization/views/organizationPeopleEvents.html',
controller: 'organizationPeopleEventsController',
resolve: {
orgUser: function () { return user; },
orgId: function () { return $state.params.orgId; }
}
});
};
function loadList() {
apiService.organizationUsers.list({ orgId: $state.params.orgId }, function (list) {
var users = [];
for (var i = 0; i < list.Data.length; i++) {
var user = {
id: list.Data[i].Id,
userId: list.Data[i].UserId,
name: list.Data[i].Name,
email: list.Data[i].Email,
status: list.Data[i].Status,
type: list.Data[i].Type,
accessAll: list.Data[i].AccessAll
};
users.push(user);
}
$scope.users = users;
if ($state.params.search) {
$uibModalStack.dismissAll();
$scope.filterSearch = $state.params.search;
$('#filterSearch').focus();
}
if ($state.params.viewEvents) {
$uibModalStack.dismissAll();
var eventUser = $filter('filter')($scope.users, { id: $state.params.viewEvents });
if (eventUser && eventUser.length) {
$scope.events(eventUser[0]);
}
}
});
}
}]);
angular
.module('bit.organization')
.controller('organizationPeopleEditController', ["$scope", "$state", "$uibModalInstance", "apiService", "cipherService", "orgUser", "$analytics", function ($scope, $state, $uibModalInstance, apiService, cipherService,
orgUser, $analytics) {
$analytics.eventTrack('organizationPeopleEditController', { category: 'Modal' });
$scope.loading = true;
$scope.collections = [];
$scope.selectedCollections = {};
$uibModalInstance.opened.then(function () {
apiService.collections.listOrganization({ orgId: $state.params.orgId }, function (list) {
$scope.collections = cipherService.decryptCollections(list.Data, $state.params.orgId, true);
$scope.loading = false;
});
apiService.organizationUsers.get({ orgId: $state.params.orgId, id: orgUser.id }, function (user) {
var collections = {};
if (user && user.Collections) {
for (var i = 0; i < user.Collections.length; i++) {
collections[user.Collections[i].Id] = {
id: user.Collections[i].Id,
readOnly: user.Collections[i].ReadOnly
};
}
}
$scope.email = orgUser.email;
$scope.type = user.Type;
$scope.accessAll = user.AccessAll;
$scope.selectedCollections = collections;
});
});
$scope.toggleCollectionSelectionAll = function ($event) {
var collections = {};
if ($event.target.checked) {
for (var i = 0; i < $scope.collections.length; i++) {
collections[$scope.collections[i].id] = {
id: $scope.collections[i].id,
readOnly: ($scope.collections[i].id in $scope.selectedCollections) ?
$scope.selectedCollections[$scope.collections[i].id].readOnly : false
};
}
}
$scope.selectedCollections = collections;
};
$scope.toggleCollectionSelection = function (id) {
if (id in $scope.selectedCollections) {
delete $scope.selectedCollections[id];
}
else {
$scope.selectedCollections[id] = {
id: id,
readOnly: false
};
}
};
$scope.toggleCollectionReadOnlySelection = function (id) {
if (id in $scope.selectedCollections) {
$scope.selectedCollections[id].readOnly = !!!$scope.selectedCollections[id].readOnly;
}
};
$scope.collectionSelected = function (collection) {
return collection.id in $scope.selectedCollections;
};
$scope.allSelected = function () {
return Object.keys($scope.selectedCollections).length === $scope.collections.length;
};
$scope.submitPromise = null;
$scope.submit = function (model) {
var collections = [];
if (!$scope.accessAll) {
for (var collectionId in $scope.selectedCollections) {
if ($scope.selectedCollections.hasOwnProperty(collectionId)) {
collections.push($scope.selectedCollections[collectionId]);
}
}
}
$scope.submitPromise = apiService.organizationUsers.put(
{
orgId: $state.params.orgId,
id: orgUser.id
}, {
type: $scope.type,
collections: collections,
accessAll: $scope.accessAll
}, function () {
$analytics.eventTrack('Edited User');
$uibModalInstance.close();
}).$promise;
};
$scope.close = function () {
$uibModalInstance.dismiss('cancel');
};
}]);
angular
.module('bit.organization')
.controller('organizationPeopleEventsController', ["$scope", "apiService", "$uibModalInstance", "orgUser", "$analytics", "eventService", "orgId", "$compile", "$sce", function ($scope, apiService, $uibModalInstance,
orgUser, $analytics, eventService, orgId, $compile, $sce) {
$analytics.eventTrack('organizationPeopleEventsController', { category: 'Modal' });
$scope.email = orgUser.email;
$scope.events = [];
$scope.loading = true;
$scope.continuationToken = null;
var defaultFilters = eventService.getDefaultDateFilters();
$scope.filterStart = defaultFilters.start;
$scope.filterEnd = defaultFilters.end;
$uibModalInstance.opened.then(function () {
loadEvents(true);
});
$scope.refresh = function () {
loadEvents(true);
};
$scope.next = function () {
loadEvents(false);
};
function loadEvents(clearExisting) {
var filterResult = eventService.formatDateFilters($scope.filterStart, $scope.filterEnd);
if (filterResult.error) {
alert(filterResult.error);
return;
}
if (clearExisting) {
$scope.continuationToken = null;
$scope.events = [];
}
$scope.loading = true;
return apiService.events.listOrganizationUser({
orgId: orgId,
id: orgUser.id,
start: filterResult.start,
end: filterResult.end,
continuationToken: $scope.continuationToken
}).$promise.then(function (list) {
$scope.continuationToken = list.ContinuationToken;
var events = [];
for (var i = 0; i < list.Data.length; i++) {
var eventInfo = eventService.getEventInfo(list.Data[i]);
var htmlMessage = $compile('' + eventInfo.message + '')($scope);
events.push({
message: $sce.trustAsHtml(htmlMessage[0].outerHTML),
appIcon: eventInfo.appIcon,
appName: eventInfo.appName,
date: list.Data[i].Date,
ip: list.Data[i].IpAddress
});
}
if ($scope.events && $scope.events.length > 0) {
$scope.events = $scope.events.concat(events);
}
else {
$scope.events = events;
}
$scope.loading = false;
});
}
$scope.close = function () {
$uibModalInstance.dismiss('cancel');
};
}]);
angular
.module('bit.organization')
.controller('organizationPeopleGroupsController', ["$scope", "$state", "$uibModalInstance", "apiService", "orgUser", "$analytics", function ($scope, $state, $uibModalInstance, apiService,
orgUser, $analytics) {
$analytics.eventTrack('organizationPeopleGroupsController', { category: 'Modal' });
$scope.loading = true;
$scope.groups = [];
$scope.selectedGroups = {};
$scope.orgUser = orgUser;
$uibModalInstance.opened.then(function () {
return apiService.groups.listOrganization({ orgId: $state.params.orgId }).$promise;
}).then(function (groupsList) {
var groups = [];
for (var i = 0; i < groupsList.Data.length; i++) {
groups.push({
id: groupsList.Data[i].Id,
name: groupsList.Data[i].Name
});
}
$scope.groups = groups;
return apiService.organizationUsers.listGroups({ orgId: $state.params.orgId, id: orgUser.id }).$promise;
}).then(function (groupIds) {
var selectedGroups = {};
if (groupIds) {
for (var i = 0; i < groupIds.length; i++) {
selectedGroups[groupIds[i]] = true;
}
}
$scope.selectedGroups = selectedGroups;
$scope.loading = false;
});
$scope.toggleGroupSelectionAll = function ($event) {
var groups = {};
if ($event.target.checked) {
for (var i = 0; i < $scope.groups.length; i++) {
groups[$scope.groups[i].id] = true;
}
}
$scope.selectedGroups = groups;
};
$scope.toggleGroupSelection = function (id) {
if (id in $scope.selectedGroups) {
delete $scope.selectedGroups[id];
}
else {
$scope.selectedGroups[id] = true;
}
};
$scope.groupSelected = function (group) {
return group.id in $scope.selectedGroups;
};
$scope.allSelected = function () {
return Object.keys($scope.selectedGroups).length === $scope.groups.length;
};
$scope.submitPromise = null;
$scope.submit = function (model) {
var groups = [];
for (var groupId in $scope.selectedGroups) {
if ($scope.selectedGroups.hasOwnProperty(groupId)) {
groups.push(groupId);
}
}
$scope.submitPromise = apiService.organizationUsers.putGroups({ orgId: $state.params.orgId, id: orgUser.id }, {
groupIds: groups,
}, function () {
$analytics.eventTrack('Edited User Groups');
$uibModalInstance.close();
}).$promise;
};
$scope.close = function () {
$uibModalInstance.dismiss('cancel');
};
}]);
angular
.module('bit.organization')
.controller('organizationPeopleInviteController', ["$scope", "$state", "$uibModalInstance", "apiService", "cipherService", "$analytics", function ($scope, $state, $uibModalInstance, apiService, cipherService,
$analytics) {
$analytics.eventTrack('organizationPeopleInviteController', { category: 'Modal' });
$scope.loading = true;
$scope.collections = [];
$scope.selectedCollections = {};
$scope.model = {
type: 'User'
};
$uibModalInstance.opened.then(function () {
apiService.collections.listOrganization({ orgId: $state.params.orgId }, function (list) {
$scope.collections = cipherService.decryptCollections(list.Data, $state.params.orgId, true);
$scope.loading = false;
});
});
$scope.toggleCollectionSelectionAll = function ($event) {
var collections = {};
if ($event.target.checked) {
for (var i = 0; i < $scope.collections.length; i++) {
collections[$scope.collections[i].id] = {
id: $scope.collections[i].id,
readOnly: ($scope.collections[i].id in $scope.selectedCollections) ?
$scope.selectedCollections[$scope.collections[i].id].readOnly : false
};
}
}
$scope.selectedCollections = collections;
};
$scope.toggleCollectionSelection = function (id) {
if (id in $scope.selectedCollections) {
delete $scope.selectedCollections[id];
}
else {
$scope.selectedCollections[id] = {
id: id,
readOnly: false
};
}
};
$scope.toggleCollectionReadOnlySelection = function (id) {
if (id in $scope.selectedCollections) {
$scope.selectedCollections[id].readOnly = !!!$scope.selectedCollections[id].readOnly;
}
};
$scope.collectionSelected = function (collection) {
return collection.id in $scope.selectedCollections;
};
$scope.allSelected = function () {
return Object.keys($scope.selectedCollections).length === $scope.collections.length;
};
$scope.submitPromise = null;
$scope.submit = function (model) {
var collections = [];
if (!model.accessAll) {
for (var collectionId in $scope.selectedCollections) {
if ($scope.selectedCollections.hasOwnProperty(collectionId)) {
collections.push($scope.selectedCollections[collectionId]);
}
}
}
var splitEmails = model.emails.trim().split(/\s*,\s*/);
$scope.submitPromise = apiService.organizationUsers.invite({ orgId: $state.params.orgId }, {
emails: splitEmails,
type: model.type,
collections: collections,
accessAll: model.accessAll
}, function () {
$analytics.eventTrack('Invited User');
$uibModalInstance.close();
}).$promise;
};
$scope.close = function () {
$uibModalInstance.dismiss('cancel');
};
}]);
angular
.module('bit.organization')
.controller('organizationSettingsController', ["$scope", "$state", "apiService", "toastr", "authService", "$uibModal", "$analytics", "appSettings", "constants", "$filter", function ($scope, $state, apiService, toastr, authService, $uibModal,
$analytics, appSettings, constants, $filter) {
$scope.selfHosted = appSettings.selfHosted;
$scope.model = {};
$scope.twoStepProviders = $filter('filter')(constants.twoFactorProviderInfo, { organization: true });
$scope.use2fa = false;
$scope.$on('$viewContentLoaded', function () {
apiService.organizations.get({ id: $state.params.orgId }).$promise.then(function (org) {
$scope.model = {
name: org.Name,
billingEmail: org.BillingEmail,
businessName: org.BusinessName,
businessAddress1: org.BusinessAddress1,
businessAddress2: org.BusinessAddress2,
businessAddress3: org.BusinessAddress3,
businessCountry: org.BusinessCountry,
businessTaxNumber: org.BusinessTaxNumber
};
$scope.use2fa = org.Use2fa;
if (org.Use2fa) {
return apiService.twoFactor.listOrganization({ orgId: $state.params.orgId }).$promise;
}
else {
return null;
}
}).then(function (response) {
if (!response || !response.Data) {
return;
}
for (var i = 0; i < response.Data.length; i++) {
if (!response.Data[i].Enabled) {
continue;
}
var provider = $filter('filter')($scope.twoStepProviders, { type: response.Data[i].Type });
if (provider.length) {
provider[0].enabled = true;
}
}
});
});
$scope.generalSave = function () {
if ($scope.selfHosted) {
return;
}
$scope.generalPromise = apiService.organizations.put({ id: $state.params.orgId }, $scope.model, function (org) {
authService.updateProfileOrganization(org).then(function (updatedOrg) {
$analytics.eventTrack('Updated Organization Settings');
toastr.success('Organization has been updated.', 'Success!');
});
}).$promise;
};
$scope.import = function () {
$uibModal.open({
animation: true,
templateUrl: 'app/tools/views/toolsImport.html',
controller: 'organizationSettingsImportController'
});
};
$scope.export = function () {
$uibModal.open({
animation: true,
templateUrl: 'app/tools/views/toolsExport.html',
controller: 'organizationSettingsExportController'
});
};
$scope.delete = function () {
$uibModal.open({
animation: true,
templateUrl: 'app/organization/views/organizationDelete.html',
controller: 'organizationDeleteController'
});
};
$scope.edit = function (provider) {
if (provider.type === constants.twoFactorProvider.organizationDuo) {
typeName = 'Duo';
}
else {
return;
}
var modal = $uibModal.open({
animation: true,
templateUrl: 'app/settings/views/settingsTwoStep' + typeName + '.html',
controller: 'settingsTwoStep' + typeName + 'Controller',
resolve: {
enabled: function () { return provider.enabled; },
orgId: function () { return $state.params.orgId; }
}
});
modal.result.then(function (enabled) {
if (enabled || enabled === false) {
// do not adjust when undefined or null
provider.enabled = enabled;
}
});
};
}]);
angular
.module('bit.organization')
.controller('organizationSettingsExportController', ["$scope", "apiService", "$uibModalInstance", "cipherService", "$q", "toastr", "$analytics", "$state", "constants", function ($scope, apiService, $uibModalInstance, cipherService,
$q, toastr, $analytics, $state, constants) {
$analytics.eventTrack('organizationSettingsExportController', { category: 'Modal' });
$scope.export = function (model) {
$scope.startedExport = true;
var decCiphers = [],
decCollections = [];
var collectionsPromise = apiService.collections.listOrganization({ orgId: $state.params.orgId },
function (collections) {
decCollections = cipherService.decryptCollections(collections.Data, $state.params.orgId, true);
}).$promise;
var ciphersPromise = apiService.ciphers.listOrganizationDetails({ organizationId: $state.params.orgId },
function (ciphers) {
decCiphers = cipherService.decryptCiphers(ciphers.Data);
}).$promise;
$q.all([collectionsPromise, ciphersPromise]).then(function () {
if (!decCiphers.length) {
toastr.error('Nothing to export.', 'Error!');
$scope.close();
return;
}
var i;
var collectionsDict = {};
for (i = 0; i < decCollections.length; i++) {
collectionsDict[decCollections[i].id] = decCollections[i];
}
try {
var exportCiphers = [];
for (i = 0; i < decCiphers.length; i++) {
// only export logins and secure notes
if (decCiphers[i].type !== constants.cipherType.login &&
decCiphers[i].type !== constants.cipherType.secureNote) {
continue;
}
var cipher = {
collections: [],
type: null,
name: decCiphers[i].name,
notes: decCiphers[i].notes,
fields: null,
// Login props
login_uri: null,
login_username: null,
login_password: null,
login_totp: null
};
var j;
if (decCiphers[i].collectionIds) {
for (j = 0; j < decCiphers[i].collectionIds.length; j++) {
if (collectionsDict.hasOwnProperty(decCiphers[i].collectionIds[j])) {
cipher.collections.push(collectionsDict[decCiphers[i].collectionIds[j]].name);
}
}
}
if (decCiphers[i].fields) {
for (j = 0; j < decCiphers[i].fields.length; j++) {
if (!cipher.fields) {
cipher.fields = '';
}
else {
cipher.fields += '\n';
}
cipher.fields += ((decCiphers[i].fields[j].name || '') + ': ' + decCiphers[i].fields[j].value);
}
}
switch (decCiphers[i].type) {
case constants.cipherType.login:
cipher.type = 'login';
cipher.login_uri = null;
cipher.login_username = decCiphers[i].login.username;
cipher.login_password = decCiphers[i].login.password;
cipher.login_totp = decCiphers[i].login.totp;
if (decCiphers[i].login.uris && decCiphers[i].login.uris.length) {
cipher.login_uri = [];
for (j = 0; j < decCiphers[i].login.uris.length; j++) {
cipher.login_uri.push(decCiphers[i].login.uris[j].uri);
}
}
break;
case constants.cipherType.secureNote:
cipher.type = 'note';
break;
default:
continue;
}
exportCiphers.push(cipher);
}
var csvString = Papa.unparse(exportCiphers);
var csvBlob = new Blob([csvString]);
// IE hack. ref http://msdn.microsoft.com/en-us/library/ie/hh779016.aspx
if (window.navigator.msSaveOrOpenBlob) {
window.navigator.msSaveBlob(csvBlob, makeFileName());
}
else {
var a = window.document.createElement('a');
a.href = window.URL.createObjectURL(csvBlob, { type: 'text/plain' });
a.download = makeFileName();
document.body.appendChild(a);
// IE: "Access is denied".
// ref: https://connect.microsoft.com/IE/feedback/details/797361/ie-10-treats-blob-url-as-cross-origin-and-denies-access
a.click();
document.body.removeChild(a);
}
$analytics.eventTrack('Exported Organization Data');
toastr.success('Your data has been exported. Check your browser\'s downloads folder.', 'Success!');
$scope.close();
}
catch (err) {
toastr.error('Something went wrong. Please try again.', 'Error!');
$scope.close();
}
}, function () {
toastr.error('Something went wrong. Please try again.', 'Error!');
$scope.close();
});
};
$scope.close = function () {
$uibModalInstance.dismiss('cancel');
};
function makeFileName() {
var now = new Date();
var dateString =
now.getFullYear() + '' + padNumber(now.getMonth() + 1, 2) + '' + padNumber(now.getDate(), 2) +
padNumber(now.getHours(), 2) + '' + padNumber(now.getMinutes(), 2) +
padNumber(now.getSeconds(), 2);
return 'bitwarden_org_export_' + dateString + '.csv';
}
function padNumber(number, width, paddingCharacter) {
paddingCharacter = paddingCharacter || '0';
number = number + '';
return number.length >= width ? number : new Array(width - number.length + 1).join(paddingCharacter) + number;
}
}]);
angular
.module('bit.organization')
.controller('organizationSettingsImportController', ["$scope", "$state", "apiService", "$uibModalInstance", "cipherService", "toastr", "importService", "$analytics", "$sce", "validationService", "cryptoService", function ($scope, $state, apiService, $uibModalInstance, cipherService,
toastr, importService, $analytics, $sce, validationService, cryptoService) {
$analytics.eventTrack('organizationSettingsImportController', { category: 'Modal' });
$scope.model = { source: '' };
$scope.source = {};
$scope.splitFeatured = false;
$scope.options = [
{
id: 'bitwardencsv',
name: 'Bitwarden (csv)',
featured: true,
sort: 1,
instructions: $sce.trustAsHtml('Export using the web vault (vault.bitwarden.com). ' +
'Log into the web vault and navigate to your organization\'s admin area. Then to go ' +
'"Settings" > "Tools" > "Export".')
},
{
id: 'lastpass',
name: 'LastPass (csv)',
featured: true,
sort: 2,
instructions: $sce.trustAsHtml('See detailed instructions on our help site at ' +
'' +
'https://help.bitwarden.com/article/import-from-lastpass/')
}
];
$scope.setSource = function () {
for (var i = 0; i < $scope.options.length; i++) {
if ($scope.options[i].id === $scope.model.source) {
$scope.source = $scope.options[i];
break;
}
}
};
$scope.setSource();
$scope.import = function (model, form) {
if (!model.source || model.source === '') {
validationService.addError(form, 'source', 'Select the format of the import file.', true);
return;
}
var file = document.getElementById('file').files[0];
if (!file && (!model.fileContents || model.fileContents === '')) {
validationService.addError(form, 'file', 'Select the import file or copy/paste the import file contents.', true);
return;
}
$scope.processing = true;
importService.importOrg(model.source, file || model.fileContents, importSuccess, importError);
};
function importSuccess(collections, ciphers, collectionRelationships) {
if (!collections.length && !ciphers.length) {
importError('Nothing was imported.');
return;
}
else if (ciphers.length) {
var halfway = Math.floor(ciphers.length / 2);
var last = ciphers.length - 1;
if (cipherIsBadData(ciphers[0]) && cipherIsBadData(ciphers[halfway]) && cipherIsBadData(ciphers[last])) {
importError('Data is not formatted correctly. Please check your import file and try again.');
return;
}
}
apiService.ciphers.importOrg({ orgId: $state.params.orgId }, {
collections: cipherService.encryptCollections(collections, $state.params.orgId),
ciphers: cipherService.encryptCiphers(ciphers, cryptoService.getOrgKey($state.params.orgId)),
collectionRelationships: collectionRelationships
}, function () {
$uibModalInstance.dismiss('cancel');
$state.go('backend.org.vault', { orgId: $state.params.orgId }).then(function () {
$analytics.eventTrack('Imported Org Data', { label: $scope.model.source });
toastr.success('Data has been successfully imported into your vault.', 'Import Success');
});
}, importError);
}
function cipherIsBadData(cipher) {
return (cipher.name === null || cipher.name === '--') &&
(cipher.login && (cipher.login.password === null || cipher.login.password === ''));
}
function importError(error) {
$analytics.eventTrack('Import Org Data Failed', { label: $scope.model.source });
$uibModalInstance.dismiss('cancel');
if (error) {
var data = error.data;
if (data && data.ValidationErrors) {
var message = '';
for (var key in data.ValidationErrors) {
if (!data.ValidationErrors.hasOwnProperty(key)) {
continue;
}
for (var i = 0; i < data.ValidationErrors[key].length; i++) {
message += (key + ': ' + data.ValidationErrors[key][i] + ' ');
}
}
if (message !== '') {
toastr.error(message);
return;
}
}
else if (data && data.Message) {
toastr.error(data.Message);
return;
}
else {
toastr.error(error);
return;
}
}
toastr.error('Something went wrong. Try again.', 'Oh No!');
}
$scope.close = function () {
$uibModalInstance.dismiss('cancel');
};
}]);
angular
.module('bit.organization')
.controller('organizationVaultAddCipherController', ["$scope", "apiService", "$uibModalInstance", "cryptoService", "cipherService", "passwordService", "$analytics", "authService", "orgId", "$uibModal", "constants", "selectedType", function ($scope, apiService, $uibModalInstance, cryptoService,
cipherService, passwordService, $analytics, authService, orgId, $uibModal, constants, selectedType) {
$analytics.eventTrack('organizationVaultAddCipherController', { category: 'Modal' });
$scope.constants = constants;
$scope.selectedType = selectedType ? selectedType.toString() : constants.cipherType.login.toString();
$scope.cipher = {
type: selectedType || constants.cipherType.login,
login: {
uris: [{
uri: null,
match: null,
matchValue: null
}]
},
identity: {},
card: {},
secureNote: {
type: '0'
}
};
$scope.hideFolders = $scope.hideFavorite = $scope.fromOrg = true;
authService.getUserProfile().then(function (userProfile) {
var orgProfile = userProfile.organizations[orgId];
$scope.useTotp = orgProfile.useTotp;
});
$scope.typeChanged = function () {
$scope.cipher.type = parseInt($scope.selectedType);
};
$scope.savePromise = null;
$scope.save = function () {
$scope.cipher.organizationId = orgId;
var cipher = cipherService.encryptCipher($scope.cipher);
$scope.savePromise = apiService.ciphers.postAdmin(cipher, function (cipherResponse) {
$analytics.eventTrack('Created Organization Cipher');
var decCipher = cipherService.decryptCipherPreview(cipherResponse);
$uibModalInstance.close(decCipher);
}).$promise;
};
$scope.generatePassword = function () {
if (!$scope.cipher.login.password || confirm('Are you sure you want to overwrite the current password?')) {
$analytics.eventTrack('Generated Password From Add');
$scope.cipher.login.password = passwordService.generatePassword({ length: 14, special: true });
}
};
$scope.addUri = function () {
if (!$scope.cipher.login) {
return;
}
if (!$scope.cipher.login.uris) {
$scope.cipher.login.uris = [];
}
$scope.cipher.login.uris.push({
uri: null,
match: null,
matchValue: null
});
};
$scope.removeUri = function (uri) {
if (!$scope.cipher.login || !$scope.cipher.login.uris) {
return;
}
var index = $scope.cipher.login.uris.indexOf(uri);
if (index > -1) {
$scope.cipher.login.uris.splice(index, 1);
}
};
$scope.uriMatchChanged = function (uri) {
if ((!uri.matchValue && uri.matchValue !== 0) || uri.matchValue === '') {
uri.match = null;
}
else {
uri.match = parseInt(uri.matchValue);
}
};
$scope.addField = function () {
if (!$scope.cipher.fields) {
$scope.cipher.fields = [];
}
$scope.cipher.fields.push({
type: constants.fieldType.text.toString(),
name: null,
value: null
});
};
$scope.removeField = function (field) {
var index = $scope.cipher.fields.indexOf(field);
if (index > -1) {
$scope.cipher.fields.splice(index, 1);
}
};
$scope.clipboardSuccess = function (e) {
e.clearSelection();
selectPassword(e);
};
$scope.clipboardError = function (e, password) {
if (password) {
selectPassword(e);
}
alert('Your web browser does not support easy clipboard copying. Copy it manually instead.');
};
function selectPassword(e) {
var target = $(e.trigger).parent().prev();
if (target.attr('type') === 'text') {
target.select();
}
}
$scope.close = function () {
$uibModalInstance.dismiss('close');
};
$scope.showUpgrade = function () {
$uibModal.open({
animation: true,
templateUrl: 'app/views/paidOrgRequired.html',
controller: 'paidOrgRequiredController',
resolve: {
orgId: function () { return orgId; }
}
});
};
}]);
angular
.module('bit.organization')
.controller('organizationVaultAttachmentsController', ["$scope", "apiService", "$uibModalInstance", "cryptoService", "cipherService", "cipherId", "$analytics", "validationService", "toastr", "$timeout", function ($scope, apiService, $uibModalInstance, cryptoService,
cipherService, cipherId, $analytics, validationService, toastr, $timeout) {
$analytics.eventTrack('organizationVaultAttachmentsController', { category: 'Modal' });
$scope.cipher = {};
$scope.loading = true;
$scope.isPremium = true;
$scope.canUseAttachments = true;
var closing = false;
apiService.ciphers.getAdmin({ id: cipherId }, function (cipher) {
$scope.cipher = cipherService.decryptCipher(cipher);
$scope.loading = false;
}, function () {
$scope.loading = false;
});
$scope.save = function (form) {
var files = document.getElementById('file').files;
if (!files || !files.length) {
validationService.addError(form, 'file', 'Select a file.', true);
return;
}
var key = cryptoService.getOrgKey($scope.cipher.organizationId);
$scope.savePromise = cipherService.encryptAttachmentFile(key, files[0]).then(function (encValue) {
var fd = new FormData();
var blob = new Blob([encValue.data], { type: 'application/octet-stream' });
fd.append('data', blob, encValue.fileName);
return apiService.ciphers.postAttachmentAdmin({ id: cipherId }, fd).$promise;
}).then(function (response) {
$analytics.eventTrack('Added Attachment');
toastr.success('The attachment has been added.');
closing = true;
$uibModalInstance.close(true);
}, function (e) {
var errors = validationService.parseErrors(e);
toastr.error(errors.length ? errors[0] : 'An error occurred.');
});
};
$scope.download = function (attachment) {
attachment.loading = true;
var key = cryptoService.getOrgKey($scope.cipher.organizationId);
cipherService.downloadAndDecryptAttachment(key, attachment, true).then(function (res) {
$timeout(function () {
attachment.loading = false;
});
}, function () {
$timeout(function () {
attachment.loading = false;
});
});
};
$scope.remove = function (attachment) {
if (!confirm('Are you sure you want to delete this attachment (' + attachment.fileName + ')?')) {
return;
}
attachment.loading = true;
apiService.ciphers.delAttachmentAdmin({ id: cipherId, attachmentId: attachment.id }).$promise.then(function () {
attachment.loading = false;
$analytics.eventTrack('Deleted Organization Attachment');
var index = $scope.cipher.attachments.indexOf(attachment);
if (index > -1) {
$scope.cipher.attachments.splice(index, 1);
}
}, function () {
toastr.error('Cannot delete attachment.');
attachment.loading = false;
});
};
$scope.close = function () {
$uibModalInstance.dismiss('cancel');
};
$scope.$on('modal.closing', function (e, reason, closed) {
if (closing) {
return;
}
e.preventDefault();
closing = true;
$uibModalInstance.close(!!$scope.cipher.attachments && $scope.cipher.attachments.length > 0);
});
}]);
angular
.module('bit.organization')
.controller('organizationVaultCipherCollectionsController', ["$scope", "apiService", "$uibModalInstance", "cipherService", "cipher", "$analytics", "collections", function ($scope, apiService, $uibModalInstance, cipherService,
cipher, $analytics, collections) {
$analytics.eventTrack('organizationVaultCipherCollectionsController', { category: 'Modal' });
$scope.cipher = {};
$scope.collections = [];
$scope.selectedCollections = {};
$uibModalInstance.opened.then(function () {
var collectionUsed = [];
for (var i = 0; i < collections.length; i++) {
if (collections[i].id) {
collectionUsed.push(collections[i]);
}
}
$scope.collections = collectionUsed;
$scope.cipher = cipher;
var selectedCollections = {};
if ($scope.cipher.collectionIds) {
for (i = 0; i < $scope.cipher.collectionIds.length; i++) {
selectedCollections[$scope.cipher.collectionIds[i]] = true;
}
}
$scope.selectedCollections = selectedCollections;
});
$scope.toggleCollectionSelectionAll = function ($event) {
var collections = {};
if ($event.target.checked) {
for (var i = 0; i < $scope.collections.length; i++) {
collections[$scope.collections[i].id] = true;
}
}
$scope.selectedCollections = collections;
};
$scope.toggleCollectionSelection = function (id) {
if (id in $scope.selectedCollections) {
delete $scope.selectedCollections[id];
}
else {
$scope.selectedCollections[id] = true;
}
};
$scope.collectionSelected = function (collection) {
return collection.id in $scope.selectedCollections;
};
$scope.allSelected = function () {
return Object.keys($scope.selectedCollections).length === $scope.collections.length;
};
$scope.submit = function () {
var request = {
collectionIds: []
};
for (var id in $scope.selectedCollections) {
if ($scope.selectedCollections.hasOwnProperty(id)) {
request.collectionIds.push(id);
}
}
$scope.submitPromise = apiService.ciphers.putCollectionsAdmin({ id: cipher.id }, request)
.$promise.then(function (response) {
$analytics.eventTrack('Edited Cipher Collections');
$uibModalInstance.close({
action: 'collectionsEdit',
collectionIds: request.collectionIds
});
});
};
$scope.close = function () {
$uibModalInstance.dismiss('cancel');
};
}]);
angular
.module('bit.organization')
.controller('organizationVaultCipherEventsController', ["$scope", "apiService", "$uibModalInstance", "cipher", "$analytics", "eventService", function ($scope, apiService, $uibModalInstance,
cipher, $analytics, eventService) {
$analytics.eventTrack('organizationVaultCipherEventsController', { category: 'Modal' });
$scope.cipher = cipher;
$scope.events = [];
$scope.loading = true;
$scope.continuationToken = null;
var defaultFilters = eventService.getDefaultDateFilters();
$scope.filterStart = defaultFilters.start;
$scope.filterEnd = defaultFilters.end;
$uibModalInstance.opened.then(function () {
load();
});
$scope.refresh = function () {
loadEvents(true);
};
$scope.next = function () {
loadEvents(false);
};
var i = 0,
orgUsersUserIdDict = {},
orgUsersIdDict = {};
function load() {
apiService.organizationUsers.list({ orgId: cipher.organizationId }).$promise.then(function (list) {
var users = [];
for (i = 0; i < list.Data.length; i++) {
var user = {
id: list.Data[i].Id,
userId: list.Data[i].UserId,
name: list.Data[i].Name,
email: list.Data[i].Email
};
users.push(user);
var displayName = user.name || user.email;
orgUsersUserIdDict[user.userId] = displayName;
orgUsersIdDict[user.id] = displayName;
}
$scope.orgUsers = users;
return loadEvents(true);
});
}
function loadEvents(clearExisting) {
var filterResult = eventService.formatDateFilters($scope.filterStart, $scope.filterEnd);
if (filterResult.error) {
alert(filterResult.error);
return;
}
if (clearExisting) {
$scope.continuationToken = null;
$scope.events = [];
}
$scope.loading = true;
return apiService.events.listCipher({
id: cipher.id,
start: filterResult.start,
end: filterResult.end,
continuationToken: $scope.continuationToken
}).$promise.then(function (list) {
$scope.continuationToken = list.ContinuationToken;
var events = [];
for (i = 0; i < list.Data.length; i++) {
var userId = list.Data[i].ActingUserId || list.Data[i].UserId;
var eventInfo = eventService.getEventInfo(list.Data[i], { cipherInfo: false });
events.push({
message: eventInfo.message,
appIcon: eventInfo.appIcon,
appName: eventInfo.appName,
userId: userId,
userName: userId ? (orgUsersUserIdDict[userId] || '-') : '-',
date: list.Data[i].Date,
ip: list.Data[i].IpAddress
});
}
if ($scope.events && $scope.events.length > 0) {
$scope.events = $scope.events.concat(events);
}
else {
$scope.events = events;
}
$scope.loading = false;
});
}
$scope.close = function () {
$uibModalInstance.dismiss('cancel');
};
}]);
angular
.module('bit.organization')
.controller('organizationVaultController', ["$scope", "apiService", "cipherService", "$analytics", "$q", "$state", "$localStorage", "$uibModal", "$filter", "authService", "$uibModalStack", "constants", "$timeout", function ($scope, apiService, cipherService, $analytics, $q, $state,
$localStorage, $uibModal, $filter, authService, $uibModalStack, constants, $timeout) {
$scope.ciphers = [];
$scope.collections = [];
$scope.loading = true;
$scope.useEvents = false;
$scope.constants = constants;
$scope.filter = undefined;
$scope.selectedType = undefined;
$scope.selectedCollection = undefined;
$scope.selectedAll = true;
$scope.selectedTitle = 'All';
$scope.selectedIcon = 'fa-th';
$scope.$on('$viewContentLoaded', function () {
authService.getUserProfile().then(function (profile) {
if (profile.organizations) {
var org = profile.organizations[$state.params.orgId];
$scope.useEvents = !!org.useEvents;
}
});
var collectionPromise = apiService.collections.listOrganization({ orgId: $state.params.orgId }, function (collections) {
var decCollections = [{
id: null,
name: 'Unassigned'
}];
for (var i = 0; i < collections.Data.length; i++) {
var decCollection = cipherService.decryptCollection(collections.Data[i], null, true);
decCollections.push(decCollection);
}
$scope.collections = decCollections;
}).$promise;
var cipherPromise = apiService.ciphers.listOrganizationDetails({ organizationId: $state.params.orgId },
function (ciphers) {
var decCiphers = [];
for (var i = 0; i < ciphers.Data.length; i++) {
var decCipher = cipherService.decryptCipherPreview(ciphers.Data[i]);
decCiphers.push(decCipher);
}
$scope.ciphers = decCiphers;
}).$promise;
$q.all([collectionPromise, cipherPromise]).then(function () {
$scope.loading = false;
$timeout(function () {
if ($('body').hasClass('control-sidebar-open')) {
$("#search").focus();
}
}, 500);
if ($state.params.search) {
$uibModalStack.dismissAll();
$scope.searchVaultText = $state.params.search;
}
if ($state.params.viewEvents) {
$uibModalStack.dismissAll();
var cipher = $filter('filter')($scope.ciphers, { id: $state.params.viewEvents });
if (cipher && cipher.length) {
$scope.viewEvents(cipher[0]);
}
}
});
});
$scope.collectionSort = function (item) {
if (!item.id) {
return '';
}
return item.name.toLowerCase();
};
$scope.editCipher = function (cipher) {
var editModel = $uibModal.open({
animation: true,
templateUrl: 'app/vault/views/vaultEditCipher.html',
controller: 'organizationVaultEditCipherController',
resolve: {
cipherId: function () { return cipher.id; },
orgId: function () { return $state.params.orgId; }
}
});
editModel.result.then(function (returnVal) {
var index;
if (returnVal.action === 'edit') {
index = $scope.ciphers.indexOf(cipher);
if (index > -1) {
returnVal.data.collectionIds = $scope.ciphers[index].collectionIds;
$scope.ciphers[index] = returnVal.data;
}
}
else if (returnVal.action === 'delete') {
index = $scope.ciphers.indexOf(cipher);
if (index > -1) {
$scope.ciphers.splice(index, 1);
}
}
});
};
$scope.$on('organizationVaultAddCipher', function (event, args) {
$scope.addCipher();
});
$scope.addCipher = function () {
var addModel = $uibModal.open({
animation: true,
templateUrl: 'app/vault/views/vaultAddCipher.html',
controller: 'organizationVaultAddCipherController',
resolve: {
orgId: function () { return $state.params.orgId; },
selectedType: function () { return $scope.selectedType; }
}
});
addModel.result.then(function (addedCipher) {
$scope.ciphers.push(addedCipher);
});
};
$scope.editCollections = function (cipher) {
var modal = $uibModal.open({
animation: true,
templateUrl: 'app/organization/views/organizationVaultCipherCollections.html',
controller: 'organizationVaultCipherCollectionsController',
resolve: {
cipher: function () { return cipher; },
collections: function () { return $scope.collections; }
}
});
modal.result.then(function (response) {
if (response.collectionIds) {
cipher.collectionIds = response.collectionIds;
}
});
};
$scope.viewEvents = function (cipher) {
$uibModal.open({
animation: true,
templateUrl: 'app/organization/views/organizationVaultCipherEvents.html',
controller: 'organizationVaultCipherEventsController',
resolve: {
cipher: function () { return cipher; }
}
});
};
$scope.attachments = function (cipher) {
authService.getUserProfile().then(function (profile) {
return !!profile.organizations[cipher.organizationId].maxStorageGb;
}).then(function (useStorage) {
if (!useStorage) {
$uibModal.open({
animation: true,
templateUrl: 'app/views/paidOrgRequired.html',
controller: 'paidOrgRequiredController',
resolve: {
orgId: function () { return cipher.organizationId; }
}
});
return;
}
var attachmentModel = $uibModal.open({
animation: true,
templateUrl: 'app/vault/views/vaultAttachments.html',
controller: 'organizationVaultAttachmentsController',
resolve: {
cipherId: function () { return cipher.id; }
}
});
attachmentModel.result.then(function (hasAttachments) {
cipher.hasAttachments = hasAttachments;
});
});
};
$scope.deleteCipher = function (cipher) {
if (!confirm('Are you sure you want to delete this item (' + cipher.name + ')?')) {
return;
}
apiService.ciphers.delAdmin({ id: cipher.id }, function () {
$analytics.eventTrack('Deleted Cipher');
var index = $scope.ciphers.indexOf(cipher);
if (index > -1) {
$scope.ciphers.splice(index, 1);
}
});
};
$scope.filterCollection = function (col) {
resetSelected();
$scope.selectedCollection = col;
$scope.selectedIcon = 'fa-cube';
if (col.id) {
$scope.filter = function (c) {
return c.collectionIds && c.collectionIds.indexOf(col.id) > -1;
};
}
else {
$scope.filter = function (c) {
return !c.collectionIds || c.collectionIds.length === 0;
};
}
fixLayout();
};
$scope.filterType = function (t) {
resetSelected();
$scope.selectedType = t;
switch (t) {
case constants.cipherType.login:
$scope.selectedTitle = 'Login';
$scope.selectedIcon = 'fa-globe';
break;
case constants.cipherType.card:
$scope.selectedTitle = 'Card';
$scope.selectedIcon = 'fa-credit-card';
break;
case constants.cipherType.identity:
$scope.selectedTitle = 'Identity';
$scope.selectedIcon = 'fa-id-card-o';
break;
case constants.cipherType.secureNote:
$scope.selectedTitle = 'Secure Note';
$scope.selectedIcon = 'fa-sticky-note-o';
break;
default:
break;
}
$scope.filter = function (c) {
return c.type === t;
};
fixLayout();
};
$scope.filterAll = function () {
resetSelected();
$scope.selectedAll = true;
$scope.selectedTitle = 'All';
$scope.selectedIcon = 'fa-th';
$scope.filter = null;
fixLayout();
};
function resetSelected() {
$scope.selectedCollection = undefined;
$scope.selectedType = undefined;
$scope.selectedAll = false;
}
function fixLayout() {
if ($.AdminLTE && $.AdminLTE.layout) {
$timeout(function () {
$.AdminLTE.layout.fix();
}, 0);
}
}
$scope.cipherFilter = function () {
return function (cipher) {
return !$scope.filter || $scope.filter(cipher);
};
};
}]);
angular
.module('bit.organization')
.controller('organizationVaultEditCipherController', ["$scope", "apiService", "$uibModalInstance", "cryptoService", "cipherService", "passwordService", "cipherId", "$analytics", "orgId", "$uibModal", "constants", function ($scope, apiService, $uibModalInstance, cryptoService,
cipherService, passwordService, cipherId, $analytics, orgId, $uibModal, constants) {
$analytics.eventTrack('organizationVaultEditCipherController', { category: 'Modal' });
$scope.cipher = {};
$scope.hideFolders = $scope.hideFavorite = $scope.fromOrg = true;
$scope.constants = constants;
apiService.ciphers.getAdmin({ id: cipherId }, function (cipher) {
$scope.cipher = cipherService.decryptCipher(cipher);
$scope.useTotp = $scope.cipher.organizationUseTotp;
setUriMatchValues();
});
$scope.save = function (model) {
var cipher = cipherService.encryptCipher(model, $scope.cipher.type);
$scope.savePromise = apiService.ciphers.putAdmin({ id: cipherId }, cipher, function (cipherResponse) {
$analytics.eventTrack('Edited Organization Cipher');
var decCipher = cipherService.decryptCipherPreview(cipherResponse);
$uibModalInstance.close({
action: 'edit',
data: decCipher
});
}).$promise;
};
$scope.generatePassword = function () {
if (!$scope.cipher.login.password || confirm('Are you sure you want to overwrite the current password?')) {
$analytics.eventTrack('Generated Password From Edit');
$scope.cipher.login.password = passwordService.generatePassword({ length: 14, special: true });
}
};
$scope.addUri = function () {
if (!$scope.cipher.login) {
return;
}
if (!$scope.cipher.login.uris) {
$scope.cipher.login.uris = [];
}
$scope.cipher.login.uris.push({
uri: null,
match: null,
matchValue: null
});
};
$scope.removeUri = function (uri) {
if (!$scope.cipher.login || !$scope.cipher.login.uris) {
return;
}
var index = $scope.cipher.login.uris.indexOf(uri);
if (index > -1) {
$scope.cipher.login.uris.splice(index, 1);
}
};
$scope.uriMatchChanged = function (uri) {
if ((!uri.matchValue && uri.matchValue !== 0) || uri.matchValue === '') {
uri.match = null;
}
else {
uri.match = parseInt(uri.matchValue);
}
};
$scope.addField = function () {
if (!$scope.cipher.login.fields) {
$scope.cipher.login.fields = [];
}
$scope.cipher.fields.push({
type: constants.fieldType.text.toString(),
name: null,
value: null
});
};
$scope.removeField = function (field) {
var index = $scope.cipher.fields.indexOf(field);
if (index > -1) {
$scope.cipher.fields.splice(index, 1);
}
};
$scope.clipboardSuccess = function (e) {
e.clearSelection();
selectPassword(e);
};
$scope.clipboardError = function (e, password) {
if (password) {
selectPassword(e);
}
alert('Your web browser does not support easy clipboard copying. Copy it manually instead.');
};
function selectPassword(e) {
var target = $(e.trigger).parent().prev();
if (target.attr('type') === 'text') {
target.select();
}
}
$scope.delete = function () {
if (!confirm('Are you sure you want to delete this item (' + $scope.cipher.name + ')?')) {
return;
}
apiService.ciphers.delAdmin({ id: $scope.cipher.id }, function () {
$analytics.eventTrack('Deleted Organization Cipher From Edit');
$uibModalInstance.close({
action: 'delete',
data: $scope.cipher.id
});
});
};
$scope.close = function () {
$uibModalInstance.dismiss('cancel');
};
$scope.showUpgrade = function () {
$uibModal.open({
animation: true,
templateUrl: 'app/views/paidOrgRequired.html',
controller: 'paidOrgRequiredController',
resolve: {
orgId: function () { return orgId; }
}
});
};
function setUriMatchValues() {
if ($scope.cipher.login && $scope.cipher.login.uris) {
for (var i = 0; i < $scope.cipher.login.uris.length; i++) {
$scope.cipher.login.uris[i].matchValue =
$scope.cipher.login.uris[i].match || $scope.cipher.login.uris[i].match === 0 ?
$scope.cipher.login.uris[i].match.toString() : '';
}
}
}
}]);
angular
.module('bit.services')
.factory('apiService', ["$resource", "tokenService", "appSettings", "$httpParamSerializer", "utilsService", function ($resource, tokenService, appSettings, $httpParamSerializer, utilsService) {
var _service = {},
_apiUri = appSettings.apiUri,
_identityUri = appSettings.identityUri;
_service.folders = $resource(_apiUri + '/folders/:id', {}, {
get: { method: 'GET', params: { id: '@id' } },
list: { method: 'GET', params: {} },
post: { method: 'POST', params: {} },
put: { method: 'POST', params: { id: '@id' } },
del: { url: _apiUri + '/folders/:id/delete', method: 'POST', params: { id: '@id' } }
});
_service.ciphers = $resource(_apiUri + '/ciphers/:id', {}, {
get: { method: 'GET', params: { id: '@id' } },
getAdmin: { url: _apiUri + '/ciphers/:id/admin', method: 'GET', params: { id: '@id' } },
getDetails: { url: _apiUri + '/ciphers/:id/details', method: 'GET', params: { id: '@id' } },
list: { method: 'GET', params: {} },
listOrganizationDetails: { url: _apiUri + '/ciphers/organization-details', method: 'GET', params: {} },
post: { method: 'POST', params: {} },
postAdmin: { url: _apiUri + '/ciphers/admin', method: 'POST', params: {} },
put: { method: 'POST', params: { id: '@id' } },
putAdmin: { url: _apiUri + '/ciphers/:id/admin', method: 'POST', params: { id: '@id' } },
'import': { url: _apiUri + '/ciphers/import', method: 'POST', params: {} },
importOrg: { url: _apiUri + '/ciphers/import-organization?organizationId=:orgId', method: 'POST', params: { orgId: '@orgId' } },
putPartial: { url: _apiUri + '/ciphers/:id/partial', method: 'POST', params: { id: '@id' } },
putShare: { url: _apiUri + '/ciphers/:id/share', method: 'POST', params: { id: '@id' } },
putCollections: { url: _apiUri + '/ciphers/:id/collections', method: 'POST', params: { id: '@id' } },
putCollectionsAdmin: { url: _apiUri + '/ciphers/:id/collections-admin', method: 'POST', params: { id: '@id' } },
del: { url: _apiUri + '/ciphers/:id/delete', method: 'POST', params: { id: '@id' } },
delAdmin: { url: _apiUri + '/ciphers/:id/delete-admin', method: 'POST', params: { id: '@id' } },
delMany: { url: _apiUri + '/ciphers/delete', method: 'POST' },
moveMany: { url: _apiUri + '/ciphers/move', method: 'POST' },
purge: { url: _apiUri + '/ciphers/purge', method: 'POST' },
postAttachment: {
url: _apiUri + '/ciphers/:id/attachment',
method: 'POST',
headers: { 'Content-Type': undefined },
params: { id: '@id' }
},
postAttachmentAdmin: {
url: _apiUri + '/ciphers/:id/attachment-admin',
method: 'POST',
headers: { 'Content-Type': undefined },
params: { id: '@id' }
},
postShareAttachment: {
url: _apiUri + '/ciphers/:id/attachment/:attachmentId/share?organizationId=:orgId',
method: 'POST',
headers: { 'Content-Type': undefined },
params: { id: '@id', attachmentId: '@attachmentId', orgId: '@orgId' }
},
delAttachment: { url: _apiUri + '/ciphers/:id/attachment/:attachmentId/delete', method: 'POST', params: { id: '@id', attachmentId: '@attachmentId' } },
delAttachmentAdmin: { url: _apiUri + '/ciphers/:id/attachment/:attachmentId/delete-admin', method: 'POST', params: { id: '@id', attachmentId: '@attachmentId' } }
});
_service.organizations = $resource(_apiUri + '/organizations/:id', {}, {
get: { method: 'GET', params: { id: '@id' } },
getBilling: { url: _apiUri + '/organizations/:id/billing', method: 'GET', params: { id: '@id' } },
getLicense: { url: _apiUri + '/organizations/:id/license', method: 'GET', params: { id: '@id' } },
list: { method: 'GET', params: {} },
post: { method: 'POST', params: {} },
put: { method: 'POST', params: { id: '@id' } },
putPayment: { url: _apiUri + '/organizations/:id/payment', method: 'POST', params: { id: '@id' } },
putSeat: { url: _apiUri + '/organizations/:id/seat', method: 'POST', params: { id: '@id' } },
putStorage: { url: _apiUri + '/organizations/:id/storage', method: 'POST', params: { id: '@id' } },
putUpgrade: { url: _apiUri + '/organizations/:id/upgrade', method: 'POST', params: { id: '@id' } },
putCancel: { url: _apiUri + '/organizations/:id/cancel', method: 'POST', params: { id: '@id' } },
putReinstate: { url: _apiUri + '/organizations/:id/reinstate', method: 'POST', params: { id: '@id' } },
postLeave: { url: _apiUri + '/organizations/:id/leave', method: 'POST', params: { id: '@id' } },
postVerifyBank: { url: _apiUri + '/organizations/:id/verify-bank', method: 'POST', params: { id: '@id' } },
del: { url: _apiUri + '/organizations/:id/delete', method: 'POST', params: { id: '@id' } },
postLicense: {
url: _apiUri + '/organizations/license',
method: 'POST',
headers: { 'Content-Type': undefined }
},
putLicense: {
url: _apiUri + '/organizations/:id/license',
method: 'POST',
headers: { 'Content-Type': undefined }
}
});
_service.organizationUsers = $resource(_apiUri + '/organizations/:orgId/users/:id', {}, {
get: { method: 'GET', params: { id: '@id', orgId: '@orgId' } },
list: { method: 'GET', params: { orgId: '@orgId' } },
listGroups: { url: _apiUri + '/organizations/:orgId/users/:id/groups', method: 'GET', params: { id: '@id', orgId: '@orgId' }, isArray: true },
invite: { url: _apiUri + '/organizations/:orgId/users/invite', method: 'POST', params: { orgId: '@orgId' } },
reinvite: { url: _apiUri + '/organizations/:orgId/users/:id/reinvite', method: 'POST', params: { id: '@id', orgId: '@orgId' } },
accept: { url: _apiUri + '/organizations/:orgId/users/:id/accept', method: 'POST', params: { id: '@id', orgId: '@orgId' } },
confirm: { url: _apiUri + '/organizations/:orgId/users/:id/confirm', method: 'POST', params: { id: '@id', orgId: '@orgId' } },
put: { method: 'POST', params: { id: '@id', orgId: '@orgId' } },
putGroups: { url: _apiUri + '/organizations/:orgId/users/:id/groups', method: 'POST', params: { id: '@id', orgId: '@orgId' } },
del: { url: _apiUri + '/organizations/:orgId/users/:id/delete', method: 'POST', params: { id: '@id', orgId: '@orgId' } }
});
_service.collections = $resource(_apiUri + '/organizations/:orgId/collections/:id', {}, {
get: { method: 'GET', params: { id: '@id', orgId: '@orgId' } },
getDetails: { url: _apiUri + '/organizations/:orgId/collections/:id/details', method: 'GET', params: { id: '@id', orgId: '@orgId' } },
listMe: { url: _apiUri + '/collections?writeOnly=:writeOnly', method: 'GET', params: { writeOnly: '@writeOnly' } },
listOrganization: { method: 'GET', params: { orgId: '@orgId' } },
listUsers: { url: _apiUri + '/organizations/:orgId/collections/:id/users', method: 'GET', params: { id: '@id', orgId: '@orgId' } },
post: { method: 'POST', params: { orgId: '@orgId' } },
put: { method: 'POST', params: { id: '@id', orgId: '@orgId' } },
del: { url: _apiUri + '/organizations/:orgId/collections/:id/delete', method: 'POST', params: { id: '@id', orgId: '@orgId' } },
delUser: { url: _apiUri + '/organizations/:orgId/collections/:id/delete-user/:orgUserId', method: 'POST', params: { id: '@id', orgId: '@orgId', orgUserId: '@orgUserId' } }
});
_service.groups = $resource(_apiUri + '/organizations/:orgId/groups/:id', {}, {
get: { method: 'GET', params: { id: '@id', orgId: '@orgId' } },
getDetails: { url: _apiUri + '/organizations/:orgId/groups/:id/details', method: 'GET', params: { id: '@id', orgId: '@orgId' } },
listOrganization: { method: 'GET', params: { orgId: '@orgId' } },
listUsers: { url: _apiUri + '/organizations/:orgId/groups/:id/users', method: 'GET', params: { id: '@id', orgId: '@orgId' } },
post: { method: 'POST', params: { orgId: '@orgId' } },
put: { method: 'POST', params: { id: '@id', orgId: '@orgId' } },
del: { url: _apiUri + '/organizations/:orgId/groups/:id/delete', method: 'POST', params: { id: '@id', orgId: '@orgId' } },
delUser: { url: _apiUri + '/organizations/:orgId/groups/:id/delete-user/:orgUserId', method: 'POST', params: { id: '@id', orgId: '@orgId', orgUserId: '@orgUserId' } }
});
_service.accounts = $resource(_apiUri + '/accounts', {}, {
register: { url: _apiUri + '/accounts/register', method: 'POST', params: {} },
emailToken: { url: _apiUri + '/accounts/email-token', method: 'POST', params: {} },
email: { url: _apiUri + '/accounts/email', method: 'POST', params: {} },
verifyEmailToken: { url: _apiUri + '/accounts/verify-email-token', method: 'POST', params: {} },
verifyEmail: { url: _apiUri + '/accounts/verify-email', method: 'POST', params: {} },
postDeleteRecoverToken: { url: _apiUri + '/accounts/delete-recover-token', method: 'POST', params: {} },
postDeleteRecover: { url: _apiUri + '/accounts/delete-recover', method: 'POST', params: {} },
putPassword: { url: _apiUri + '/accounts/password', method: 'POST', params: {} },
getProfile: { url: _apiUri + '/accounts/profile', method: 'GET', params: {} },
putProfile: { url: _apiUri + '/accounts/profile', method: 'POST', params: {} },
getDomains: { url: _apiUri + '/accounts/domains', method: 'GET', params: {} },
putDomains: { url: _apiUri + '/accounts/domains', method: 'POST', params: {} },
postPasswordHint: { url: _apiUri + '/accounts/password-hint', method: 'POST', params: {} },
putSecurityStamp: { url: _apiUri + '/accounts/security-stamp', method: 'POST', params: {} },
putKeys: { url: _apiUri + '/accounts/keys', method: 'POST', params: {} },
putKey: { url: _apiUri + '/accounts/key', method: 'POST', params: {} },
'import': { url: _apiUri + '/accounts/import', method: 'POST', params: {} },
postDelete: { url: _apiUri + '/accounts/delete', method: 'POST', params: {} },
putStorage: { url: _apiUri + '/accounts/storage', method: 'POST', params: {} },
putPayment: { url: _apiUri + '/accounts/payment', method: 'POST', params: {} },
putCancelPremium: { url: _apiUri + '/accounts/cancel-premium', method: 'POST', params: {} },
putReinstatePremium: { url: _apiUri + '/accounts/reinstate-premium', method: 'POST', params: {} },
getBilling: { url: _apiUri + '/accounts/billing', method: 'GET', params: {} },
postPremium: {
url: _apiUri + '/accounts/premium',
method: 'POST',
headers: { 'Content-Type': undefined }
},
putLicense: {
url: _apiUri + '/accounts/license',
method: 'POST',
headers: { 'Content-Type': undefined }
}
});
_service.twoFactor = $resource(_apiUri + '/two-factor', {}, {
list: { method: 'GET', params: {} },
listOrganization: { url: _apiUri + '/organizations/:orgId/two-factor', method: 'GET', params: { orgId: '@orgId' } },
getEmail: { url: _apiUri + '/two-factor/get-email', method: 'POST', params: {} },
getU2f: { url: _apiUri + '/two-factor/get-u2f', method: 'POST', params: {} },
getDuo: { url: _apiUri + '/two-factor/get-duo', method: 'POST', params: {} },
getOrganizationDuo: { url: _apiUri + '/organizations/:orgId/two-factor/get-duo', method: 'POST', params: { orgId: '@orgId' } },
getAuthenticator: { url: _apiUri + '/two-factor/get-authenticator', method: 'POST', params: {} },
getYubi: { url: _apiUri + '/two-factor/get-yubikey', method: 'POST', params: {} },
sendEmail: { url: _apiUri + '/two-factor/send-email', method: 'POST', params: {} },
sendEmailLogin: { url: _apiUri + '/two-factor/send-email-login', method: 'POST', params: {} },
putEmail: { url: _apiUri + '/two-factor/email', method: 'POST', params: {} },
putU2f: { url: _apiUri + '/two-factor/u2f', method: 'POST', params: {} },
putAuthenticator: { url: _apiUri + '/two-factor/authenticator', method: 'POST', params: {} },
putDuo: { url: _apiUri + '/two-factor/duo', method: 'POST', params: {} },
putOrganizationDuo: { url: _apiUri + '/organizations/:orgId/two-factor/duo', method: 'POST', params: { orgId: '@orgId' } },
putYubi: { url: _apiUri + '/two-factor/yubikey', method: 'POST', params: {} },
disable: { url: _apiUri + '/two-factor/disable', method: 'POST', params: {} },
disableOrganization: { url: _apiUri + '/organizations/:orgId/two-factor/disable', method: 'POST', params: { orgId: '@orgId' } },
recover: { url: _apiUri + '/two-factor/recover', method: 'POST', params: {} },
getRecover: { url: _apiUri + '/two-factor/get-recover', method: 'POST', params: {} }
});
_service.settings = $resource(_apiUri + '/settings', {}, {
getDomains: { url: _apiUri + '/settings/domains', method: 'GET', params: {} },
putDomains: { url: _apiUri + '/settings/domains', method: 'POST', params: {} },
});
_service.users = $resource(_apiUri + '/users/:id', {}, {
getPublicKey: { url: _apiUri + '/users/:id/public-key', method: 'GET', params: { id: '@id' } }
});
_service.events = $resource(_apiUri + '/events', {}, {
list: { method: 'GET', params: {} },
listOrganization: { url: _apiUri + '/organizations/:orgId/events', method: 'GET', params: { id: '@orgId' } },
listCipher: { url: _apiUri + '/ciphers/:id/events', method: 'GET', params: { id: '@id' } },
listOrganizationUser: { url: _apiUri + '/organizations/:orgId/users/:id/events', method: 'GET', params: { orgId: '@orgId', id: '@id' } }
});
_service.identity = $resource(_identityUri + '/connect', {}, {
token: {
url: _identityUri + '/connect/token',
method: 'POST',
headers: {
'Content-Type': 'application/x-www-form-urlencoded; charset=utf-8',
'Device-Type': utilsService.getDeviceType()
},
transformRequest: transformUrlEncoded,
skipAuthorization: true,
params: {}
}
});
_service.hibp = $resource('https://haveibeenpwned.com/api/v2/breachedaccount/:email', {}, {
get: { method: 'GET', params: { email: '@email' }, isArray: true },
});
function transformUrlEncoded(data) {
return $httpParamSerializer(data);
}
return _service;
}]);
angular
.module('bit.services')
.factory('authService', ["cryptoService", "apiService", "tokenService", "$q", "jwtHelper", "$rootScope", "constants", function (cryptoService, apiService, tokenService, $q, jwtHelper, $rootScope, constants) {
var _service = {},
_userProfile = null;
_service.logIn = function (email, masterPassword, token, provider, remember) {
email = email.toLowerCase();
var deferred = $q.defer();
var makeResult;
cryptoService.makeKeyAndHash(email, masterPassword).then(function (result) {
makeResult = result;
var request = {
username: email,
password: result.hash,
grant_type: 'password',
scope: 'api offline_access',
client_id: 'web'
};
// TODO: device information one day?
if (token && typeof (provider) !== 'undefined' && provider !== null) {
remember = remember || remember !== false;
request.twoFactorToken = token;
request.twoFactorProvider = provider;
request.twoFactorRemember = remember ? '1' : '0';
}
else if (tokenService.getTwoFactorToken(email)) {
request.twoFactorToken = tokenService.getTwoFactorToken(email);
request.twoFactorProvider = constants.twoFactorProvider.remember;
request.twoFactorRemember = '0';
}
return apiService.identity.token(request).$promise;
}).then(function (response) {
if (!response || !response.access_token) {
return;
}
tokenService.setToken(response.access_token);
tokenService.setRefreshToken(response.refresh_token);
cryptoService.setKey(makeResult.key);
if (response.TwoFactorToken) {
tokenService.setTwoFactorToken(response.TwoFactorToken, email);
}
if (response.Key) {
cryptoService.setEncKey(response.Key, makeResult.key);
}
if (response.PrivateKey) {
cryptoService.setPrivateKey(response.PrivateKey);
return true;
}
else {
return cryptoService.makeKeyPair();
}
}).then(function (keyResults) {
if (keyResults === true) {
return;
}
cryptoService.setPrivateKey(keyResults.privateKeyEnc);
return apiService.accounts.putKeys({
publicKey: keyResults.publicKey,
encryptedPrivateKey: keyResults.privateKeyEnc
}).$promise;
}).then(function () {
return _service.setUserProfile();
}).then(function () {
deferred.resolve();
}, function (error) {
_service.logOut();
if (error.status === 400 && error.data.TwoFactorProviders2 &&
Object.keys(error.data.TwoFactorProviders2).length) {
tokenService.clearTwoFactorToken(email);
deferred.resolve(error.data.TwoFactorProviders2);
}
else {
deferred.reject(error);
}
});
return deferred.promise;
};
_service.logOut = function () {
tokenService.clearTokens();
cryptoService.clearKeys();
$rootScope.vaultCiphers = $rootScope.vaultFolders = $rootScope.vaultCollections = null;
_userProfile = null;
};
_service.getUserProfile = function () {
if (!_userProfile) {
return _service.setUserProfile();
}
var deferred = $q.defer();
deferred.resolve(_userProfile);
return deferred.promise;
};
var _setDeferred = null;
_service.setUserProfile = function () {
if (_setDeferred && _setDeferred.promise.$$state.status === 0) {
return _setDeferred.promise;
}
_setDeferred = $q.defer();
var token = tokenService.getToken();
if (!token) {
_setDeferred.reject();
return _setDeferred.promise;
}
apiService.accounts.getProfile({}, function (profile) {
_userProfile = {
id: profile.Id,
email: profile.Email,
emailVerified: profile.EmailVerified,
premium: profile.Premium,
extended: {
name: profile.Name,
twoFactorEnabled: profile.TwoFactorEnabled,
culture: profile.Culture
}
};
if (profile.Organizations) {
var orgs = {};
for (var i = 0; i < profile.Organizations.length; i++) {
orgs[profile.Organizations[i].Id] = {
id: profile.Organizations[i].Id,
name: profile.Organizations[i].Name,
key: profile.Organizations[i].Key,
status: profile.Organizations[i].Status,
type: profile.Organizations[i].Type,
enabled: profile.Organizations[i].Enabled,
maxCollections: profile.Organizations[i].MaxCollections,
maxStorageGb: profile.Organizations[i].MaxStorageGb,
seats: profile.Organizations[i].Seats,
useGroups: profile.Organizations[i].UseGroups,
useDirectory: profile.Organizations[i].UseDirectory,
useEvents: profile.Organizations[i].UseEvents,
use2fa: profile.Organizations[i].Use2fa,
useTotp: profile.Organizations[i].UseTotp
};
}
_userProfile.organizations = orgs;
cryptoService.setOrgKeys(orgs);
_setDeferred.resolve(_userProfile);
}
}, function (error) {
_setDeferred.reject(error);
});
return _setDeferred.promise;
};
_service.addProfileOrganizationOwner = function (org, keyCt) {
return _service.getUserProfile().then(function (profile) {
if (profile) {
if (!profile.organizations) {
profile.organizations = {};
}
var o = {
id: org.Id,
name: org.Name,
key: keyCt,
status: 2, // 2 = Confirmed
type: 0, // 0 = Owner
enabled: true,
maxCollections: org.MaxCollections,
maxStorageGb: org.MaxStorageGb,
seats: org.Seats,
useGroups: org.UseGroups,
useDirectory: org.UseDirectory,
useEvents: org.UseEvents,
use2fa: org.Use2fa,
useTotp: org.UseTotp
};
profile.organizations[o.id] = o;
_userProfile = profile;
cryptoService.addOrgKey(o.id, o.key);
}
});
};
_service.removeProfileOrganization = function (orgId) {
return _service.getUserProfile().then(function (profile) {
if (profile) {
if (profile.organizations && profile.organizations.hasOwnProperty(orgId)) {
delete profile.organizations[orgId];
_userProfile = profile;
}
cryptoService.clearOrgKey(orgId);
}
});
};
_service.updateProfileOrganization = function (org) {
return _service.getUserProfile().then(function (profile) {
if (profile) {
if (profile.organizations && org.Id in profile.organizations) {
profile.organizations[org.Id].name = org.Name;
_userProfile = profile;
}
}
});
};
_service.updateProfilePremium = function (isPremium) {
return _service.getUserProfile().then(function (profile) {
if (profile) {
profile.premium = isPremium;
_userProfile = profile;
}
});
};
_service.isAuthenticated = function () {
return tokenService.getToken() !== null;
};
_service.refreshAccessToken = function () {
var refreshToken = tokenService.getRefreshToken();
if (!refreshToken) {
return $q(function (resolve, reject) {
resolve(null);
});
}
return apiService.identity.token({
grant_type: 'refresh_token',
client_id: 'web',
refresh_token: refreshToken
}).$promise.then(function (response) {
tokenService.setToken(response.access_token);
tokenService.setRefreshToken(response.refresh_token);
return response.access_token;
}, function (response) { });
};
return _service;
}]);
angular
.module('bit.services')
.factory('cipherService', ["cryptoService", "apiService", "$q", "$window", "constants", "appSettings", "$localStorage", function (cryptoService, apiService, $q, $window, constants, appSettings, $localStorage) {
var _service = {
disableWebsiteIcons: $localStorage.disableWebsiteIcons
};
_service.decryptCiphers = function (encryptedCiphers) {
if (!encryptedCiphers) throw "encryptedCiphers is undefined or null";
var unencryptedCiphers = [];
for (var i = 0; i < encryptedCiphers.length; i++) {
unencryptedCiphers.push(_service.decryptCipher(encryptedCiphers[i]));
}
return unencryptedCiphers;
};
_service.decryptCipher = function (encryptedCipher) {
if (!encryptedCipher) throw "encryptedCipher is undefined or null";
var key = null;
if (encryptedCipher.OrganizationId) {
key = cryptoService.getOrgKey(encryptedCipher.OrganizationId);
}
var cipher = {
id: encryptedCipher.Id,
organizationId: encryptedCipher.OrganizationId,
collectionIds: encryptedCipher.CollectionIds || [],
'type': encryptedCipher.Type,
name: cryptoService.decrypt(encryptedCipher.Name, key),
notes: _service.decryptProperty(encryptedCipher.Notes, key, true, false),
fields: _service.decryptFields(key, encryptedCipher.Fields),
folderId: encryptedCipher.FolderId,
favorite: encryptedCipher.Favorite,
edit: encryptedCipher.Edit,
organizationUseTotp: encryptedCipher.OrganizationUseTotp,
attachments: null,
icon: null
};
var i;
switch (cipher.type) {
case constants.cipherType.login:
cipher.login = {
username: _service.decryptProperty(encryptedCipher.Login.Username, key, true, false),
password: _service.decryptProperty(encryptedCipher.Login.Password, key, true, false),
totp: _service.decryptProperty(encryptedCipher.Login.Totp, key, true, false),
uris: null
};
if (encryptedCipher.Login.Uris) {
cipher.login.uris = [];
for (i = 0; i < encryptedCipher.Login.Uris.length; i++) {
cipher.login.uris.push({
uri: _service.decryptProperty(encryptedCipher.Login.Uris[i].Uri, key, true, false),
match: encryptedCipher.Login.Uris[i].Match
});
}
}
cipher.icon = 'fa-globe';
break;
case constants.cipherType.secureNote:
cipher.secureNote = {
type: encryptedCipher.SecureNote.Type
};
cipher.icon = 'fa-sticky-note-o';
break;
case constants.cipherType.card:
cipher.card = {
cardholderName: _service.decryptProperty(encryptedCipher.Card.CardholderName, key, true, false),
number: _service.decryptProperty(encryptedCipher.Card.Number, key, true, false),
brand: _service.decryptProperty(encryptedCipher.Card.Brand, key, true, false),
expMonth: _service.decryptProperty(encryptedCipher.Card.ExpMonth, key, true, false),
expYear: _service.decryptProperty(encryptedCipher.Card.ExpYear, key, true, false),
code: _service.decryptProperty(encryptedCipher.Card.Code, key, true, false)
};
cipher.icon = 'fa-credit-card';
break;
case constants.cipherType.identity:
cipher.identity = {
title: _service.decryptProperty(encryptedCipher.Identity.Title, key, true, false),
firstName: _service.decryptProperty(encryptedCipher.Identity.FirstName, key, true, false),
middleName: _service.decryptProperty(encryptedCipher.Identity.MiddleName, key, true, false),
lastName: _service.decryptProperty(encryptedCipher.Identity.LastName, key, true, false),
address1: _service.decryptProperty(encryptedCipher.Identity.Address1, key, true, false),
address2: _service.decryptProperty(encryptedCipher.Identity.Address2, key, true, false),
address3: _service.decryptProperty(encryptedCipher.Identity.Address3, key, true, false),
city: _service.decryptProperty(encryptedCipher.Identity.City, key, true, false),
state: _service.decryptProperty(encryptedCipher.Identity.State, key, true, false),
postalCode: _service.decryptProperty(encryptedCipher.Identity.PostalCode, key, true, false),
country: _service.decryptProperty(encryptedCipher.Identity.Country, key, true, false),
company: _service.decryptProperty(encryptedCipher.Identity.Company, key, true, false),
email: _service.decryptProperty(encryptedCipher.Identity.Email, key, true, false),
phone: _service.decryptProperty(encryptedCipher.Identity.Phone, key, true, false),
ssn: _service.decryptProperty(encryptedCipher.Identity.SSN, key, true, false),
username: _service.decryptProperty(encryptedCipher.Identity.Username, key, true, false),
passportNumber: _service.decryptProperty(encryptedCipher.Identity.PassportNumber, key, true, false),
licenseNumber: _service.decryptProperty(encryptedCipher.Identity.LicenseNumber, key, true, false)
};
cipher.icon = 'fa-id-card-o';
break;
default:
break;
}
if (!encryptedCipher.Attachments) {
return cipher;
}
cipher.attachments = [];
for (i = 0; i < encryptedCipher.Attachments.length; i++) {
cipher.attachments.push(_service.decryptAttachment(key, encryptedCipher.Attachments[i]));
}
return cipher;
};
_service.decryptCipherPreview = function (encryptedCipher) {
if (!encryptedCipher) throw "encryptedCipher is undefined or null";
var key = null;
if (encryptedCipher.OrganizationId) {
key = cryptoService.getOrgKey(encryptedCipher.OrganizationId);
}
var cipher = {
id: encryptedCipher.Id,
organizationId: encryptedCipher.OrganizationId,
collectionIds: encryptedCipher.CollectionIds || [],
'type': encryptedCipher.Type,
name: _service.decryptProperty(encryptedCipher.Name, key, false, true),
folderId: encryptedCipher.FolderId,
favorite: encryptedCipher.Favorite,
edit: encryptedCipher.Edit,
organizationUseTotp: encryptedCipher.OrganizationUseTotp,
hasAttachments: !!encryptedCipher.Attachments && encryptedCipher.Attachments.length > 0,
meta: {},
icon: null
};
switch (cipher.type) {
case constants.cipherType.login:
cipher.subTitle = _service.decryptProperty(encryptedCipher.Login.Username, key, true, true);
cipher.meta.password = _service.decryptProperty(encryptedCipher.Login.Password, key, true, true);
cipher.meta.uri = null;
if (encryptedCipher.Login.Uris && encryptedCipher.Login.Uris.length) {
cipher.meta.uri = _service.decryptProperty(encryptedCipher.Login.Uris[0].Uri, key, true, true);
}
setLoginIcon(cipher, cipher.meta.uri, true);
break;
case constants.cipherType.secureNote:
cipher.subTitle = null;
cipher.icon = 'fa-sticky-note-o';
break;
case constants.cipherType.card:
cipher.subTitle = '';
cipher.meta.number = _service.decryptProperty(encryptedCipher.Card.Number, key, true, true);
var brand = _service.decryptProperty(encryptedCipher.Card.Brand, key, true, true);
if (brand) {
cipher.subTitle = brand;
}
if (cipher.meta.number && cipher.meta.number.length >= 4) {
if (cipher.subTitle !== '') {
cipher.subTitle += ', ';
}
cipher.subTitle += ('*' + cipher.meta.number.substr(cipher.meta.number.length - 4));
}
cipher.icon = 'fa-credit-card';
break;
case constants.cipherType.identity:
var firstName = _service.decryptProperty(encryptedCipher.Identity.FirstName, key, true, true);
var lastName = _service.decryptProperty(encryptedCipher.Identity.LastName, key, true, true);
cipher.subTitle = '';
if (firstName) {
cipher.subTitle = firstName;
}
if (lastName) {
if (cipher.subTitle !== '') {
cipher.subTitle += ' ';
}
cipher.subTitle += lastName;
}
cipher.icon = 'fa-id-card-o';
break;
default:
break;
}
if (cipher.subTitle === '') {
cipher.subTitle = null;
}
return cipher;
};
function setLoginIcon(cipher, uri, setImage) {
if (!_service.disableWebsiteIcons && uri) {
var hostnameUri = uri,
isWebsite = false;
if (hostnameUri.indexOf('androidapp://') === 0) {
cipher.icon = 'fa-android';
}
else if (hostnameUri.indexOf('iosapp://') === 0) {
cipher.icon = 'fa-apple';
}
else if (hostnameUri.indexOf('://') === -1 && hostnameUri.indexOf('.') > -1) {
hostnameUri = "http://" + hostnameUri;
isWebsite = true;
}
else {
isWebsite = hostnameUri.indexOf('http') === 0 && hostnameUri.indexOf('.') > -1;
}
if (setImage && isWebsite) {
try {
var url = new URL(hostnameUri);
cipher.meta.image = appSettings.iconsUri + '/' + url.hostname + '/icon.png';
}
catch (e) { }
}
}
if (!cipher.icon) {
cipher.icon = 'fa-globe';
}
}
_service.decryptAttachment = function (key, encryptedAttachment) {
if (!encryptedAttachment) throw "encryptedAttachment is undefined or null";
return {
id: encryptedAttachment.Id,
url: encryptedAttachment.Url,
fileName: cryptoService.decrypt(encryptedAttachment.FileName, key),
size: encryptedAttachment.SizeName
};
};
_service.downloadAndDecryptAttachment = function (key, decryptedAttachment, openDownload) {
var deferred = $q.defer();
var req = new XMLHttpRequest();
req.open('GET', decryptedAttachment.url, true);
req.responseType = 'arraybuffer';
req.onload = function (evt) {
if (!req.response) {
deferred.reject('No response');
// error
return;
}
cryptoService.decryptFromBytes(req.response, key).then(function (decBuf) {
if (openDownload) {
var blob = new Blob([decBuf]);
// IE hack. ref http://msdn.microsoft.com/en-us/library/ie/hh779016.aspx
if ($window.navigator.msSaveOrOpenBlob) {
$window.navigator.msSaveBlob(blob, decryptedAttachment.fileName);
}
else {
var a = $window.document.createElement('a');
a.href = $window.URL.createObjectURL(blob);
a.download = decryptedAttachment.fileName;
$window.document.body.appendChild(a);
a.click();
$window.document.body.removeChild(a);
}
}
deferred.resolve(new Uint8Array(decBuf));
});
};
req.send(null);
return deferred.promise;
};
_service.decryptFields = function (key, encryptedFields) {
var unencryptedFields = [];
if (encryptedFields) {
for (var i = 0; i < encryptedFields.length; i++) {
unencryptedFields.push(_service.decryptField(key, encryptedFields[i]));
}
}
return unencryptedFields;
};
_service.decryptField = function (key, encryptedField) {
if (!encryptedField) throw "encryptedField is undefined or null";
return {
type: encryptedField.Type.toString(),
name: encryptedField.Name && encryptedField.Name !== '' ? cryptoService.decrypt(encryptedField.Name, key) : null,
value: encryptedField.Value && encryptedField.Value !== '' ? cryptoService.decrypt(encryptedField.Value, key) : null
};
};
_service.decryptFolders = function (encryptedFolders) {
if (!encryptedFolders) throw "encryptedFolders is undefined or null";
var unencryptedFolders = [];
for (var i = 0; i < encryptedFolders.length; i++) {
unencryptedFolders.push(_service.decryptFolder(encryptedFolders[i]));
}
return unencryptedFolders;
};
_service.decryptFolder = function (encryptedFolder) {
if (!encryptedFolder) throw "encryptedFolder is undefined or null";
return {
id: encryptedFolder.Id,
name: cryptoService.decrypt(encryptedFolder.Name)
};
};
_service.decryptFolderPreview = function (encryptedFolder) {
if (!encryptedFolder) throw "encryptedFolder is undefined or null";
return {
id: encryptedFolder.Id,
name: _service.decryptProperty(encryptedFolder.Name, null, false, true)
};
};
_service.decryptCollections = function (encryptedCollections, orgId, catchError) {
if (!encryptedCollections) throw "encryptedCollections is undefined or null";
var unencryptedCollections = [];
for (var i = 0; i < encryptedCollections.length; i++) {
unencryptedCollections.push(_service.decryptCollection(encryptedCollections[i], orgId, catchError));
}
return unencryptedCollections;
};
_service.decryptCollection = function (encryptedCollection, orgId, catchError) {
if (!encryptedCollection) throw "encryptedCollection is undefined or null";
catchError = catchError === true ? true : false;
orgId = orgId || encryptedCollection.OrganizationId;
var key = cryptoService.getOrgKey(orgId);
return {
id: encryptedCollection.Id,
name: catchError ? _service.decryptProperty(encryptedCollection.Name, key, false, true) :
cryptoService.decrypt(encryptedCollection.Name, key)
};
};
_service.decryptProperty = function (property, key, checkEmpty, showError) {
if (checkEmpty && (!property || property === '')) {
return null;
}
try {
property = cryptoService.decrypt(property, key);
}
catch (err) {
property = null;
}
return property || (showError ? '[error: cannot decrypt]' : null);
};
_service.encryptCiphers = function (unencryptedCiphers, key) {
if (!unencryptedCiphers) throw "unencryptedCiphers is undefined or null";
var encryptedCiphers = [];
for (var i = 0; i < unencryptedCiphers.length; i++) {
encryptedCiphers.push(_service.encryptCipher(unencryptedCiphers[i], null, key));
}
return encryptedCiphers;
};
_service.encryptCipher = function (unencryptedCipher, type, key, attachments) {
if (!unencryptedCipher) throw "unencryptedCipher is undefined or null";
if (unencryptedCipher.organizationId) {
key = key || cryptoService.getOrgKey(unencryptedCipher.organizationId);
}
var cipher = {
id: unencryptedCipher.id,
'type': type || unencryptedCipher.type,
organizationId: unencryptedCipher.organizationId || null,
folderId: unencryptedCipher.folderId === '' ? null : unencryptedCipher.folderId,
favorite: unencryptedCipher.favorite !== null ? unencryptedCipher.favorite : false,
name: cryptoService.encrypt(unencryptedCipher.name, key),
notes: encryptProperty(unencryptedCipher.notes, key),
fields: _service.encryptFields(unencryptedCipher.fields, key)
};
var i;
switch (cipher.type) {
case constants.cipherType.login:
var loginData = unencryptedCipher.login;
cipher.login = {
username: encryptProperty(loginData.username, key),
password: encryptProperty(loginData.password, key),
totp: encryptProperty(loginData.totp, key)
};
if (loginData.uris && loginData.uris.length) {
cipher.login.uris = [];
for (i = 0; i < loginData.uris.length; i++) {
cipher.login.uris.push({
uri: encryptProperty(loginData.uris[i].uri, key),
match: loginData.uris[i].match
});
}
}
break;
case constants.cipherType.secureNote:
cipher.secureNote = {
type: unencryptedCipher.secureNote.type
};
break;
case constants.cipherType.card:
var cardData = unencryptedCipher.card;
cipher.card = {
cardholderName: encryptProperty(cardData.cardholderName, key),
brand: encryptProperty(cardData.brand, key),
number: encryptProperty(cardData.number, key),
expMonth: encryptProperty(cardData.expMonth, key),
expYear: encryptProperty(cardData.expYear, key),
code: encryptProperty(cardData.code, key)
};
break;
case constants.cipherType.identity:
var identityData = unencryptedCipher.identity;
cipher.identity = {
title: encryptProperty(identityData.title, key),
firstName: encryptProperty(identityData.firstName, key),
middleName: encryptProperty(identityData.middleName, key),
lastName: encryptProperty(identityData.lastName, key),
address1: encryptProperty(identityData.address1, key),
address2: encryptProperty(identityData.address2, key),
address3: encryptProperty(identityData.address3, key),
city: encryptProperty(identityData.city, key),
state: encryptProperty(identityData.state, key),
postalCode: encryptProperty(identityData.postalCode, key),
country: encryptProperty(identityData.country, key),
company: encryptProperty(identityData.company, key),
email: encryptProperty(identityData.email, key),
phone: encryptProperty(identityData.phone, key),
ssn: encryptProperty(identityData.ssn, key),
username: encryptProperty(identityData.username, key),
passportNumber: encryptProperty(identityData.passportNumber, key),
licenseNumber: encryptProperty(identityData.licenseNumber, key)
};
break;
default:
break;
}
if (unencryptedCipher.attachments && attachments) {
cipher.attachments = {};
for (i = 0; i < unencryptedCipher.attachments.length; i++) {
cipher.attachments[unencryptedCipher.attachments[i].id] =
cryptoService.encrypt(unencryptedCipher.attachments[i].fileName, key);
}
}
return cipher;
};
_service.encryptAttachmentFile = function (key, unencryptedFile) {
var deferred = $q.defer();
if (unencryptedFile.size > 104857600) { // 100 MB
deferred.reject('Maximum file size is 100 MB.');
return;
}
var reader = new FileReader();
reader.readAsArrayBuffer(unencryptedFile);
reader.onload = function (evt) {
cryptoService.encryptToBytes(evt.target.result, key).then(function (encData) {
deferred.resolve({
fileName: cryptoService.encrypt(unencryptedFile.name, key),
data: new Uint8Array(encData),
size: unencryptedFile.size
});
});
};
reader.onerror = function (evt) {
deferred.reject('Error reading file.');
};
return deferred.promise;
};
_service.encryptFields = function (unencryptedFields, key) {
if (!unencryptedFields || !unencryptedFields.length) {
return null;
}
var encFields = [];
for (var i = 0; i < unencryptedFields.length; i++) {
if (!unencryptedFields[i]) {
continue;
}
encFields.push(_service.encryptField(unencryptedFields[i], key));
}
return encFields;
};
_service.encryptField = function (unencryptedField, key) {
if (!unencryptedField) throw "unencryptedField is undefined or null";
return {
type: parseInt(unencryptedField.type),
name: unencryptedField.name ? cryptoService.encrypt(unencryptedField.name, key) : null,
value: unencryptedField.value ? cryptoService.encrypt(unencryptedField.value.toString(), key) : null
};
};
_service.encryptFolders = function (unencryptedFolders, key) {
if (!unencryptedFolders) throw "unencryptedFolders is undefined or null";
var encryptedFolders = [];
for (var i = 0; i < unencryptedFolders.length; i++) {
encryptedFolders.push(_service.encryptFolder(unencryptedFolders[i], key));
}
return encryptedFolders;
};
_service.encryptFolder = function (unencryptedFolder, key) {
if (!unencryptedFolder) throw "unencryptedFolder is undefined or null";
return {
id: unencryptedFolder.id,
name: cryptoService.encrypt(unencryptedFolder.name, key)
};
};
_service.encryptCollections = function (unencryptedCollections, orgId) {
if (!unencryptedCollections) throw "unencryptedCollections is undefined or null";
var encryptedCollections = [];
for (var i = 0; i < unencryptedCollections.length; i++) {
encryptedCollections.push(_service.encryptCollection(unencryptedCollections[i], orgId));
}
return encryptedCollections;
};
_service.encryptCollection = function (unencryptedCollection, orgId) {
if (!unencryptedCollection) throw "unencryptedCollection is undefined or null";
return {
id: unencryptedCollection.id,
name: cryptoService.encrypt(unencryptedCollection.name, cryptoService.getOrgKey(orgId))
};
};
function encryptProperty(property, key) {
return !property || property === '' ? null : cryptoService.encrypt(property, key);
}
return _service;
}]);
angular
.module('bit.services')
.factory('cryptoService', ["$sessionStorage", "constants", "$q", "$window", function ($sessionStorage, constants, $q, $window) {
var _service = {},
_key,
_encKey,
_legacyEtmKey,
_orgKeys,
_privateKey,
_publicKey,
_crypto = typeof $window.crypto != 'undefined' ? $window.crypto : null,
_subtle = (!!_crypto && typeof $window.crypto.subtle != 'undefined') ? $window.crypto.subtle : null;
_service.setKey = function (key) {
_key = key;
$sessionStorage.key = _key.keyB64;
};
_service.setEncKey = function (encKey, key, alreadyDecrypted) {
if (alreadyDecrypted) {
_encKey = encKey;
$sessionStorage.encKey = _encKey.keyB64;
return;
}
try {
var encKeyBytes = _service.decrypt(encKey, key, 'raw');
$sessionStorage.encKey = forge.util.encode64(encKeyBytes);
_encKey = new SymmetricCryptoKey(encKeyBytes);
}
catch (e) {
console.log('Cannot set enc key. Decryption failed.');
}
};
_service.setPrivateKey = function (privateKeyCt, key) {
try {
var privateKeyBytes = _service.decrypt(privateKeyCt, key, 'raw');
$sessionStorage.privateKey = forge.util.encode64(privateKeyBytes);
_privateKey = forge.pki.privateKeyFromAsn1(forge.asn1.fromDer(privateKeyBytes));
}
catch (e) {
console.log('Cannot set private key. Decryption failed.');
}
};
_service.setOrgKeys = function (orgKeysCt, privateKey) {
if (!orgKeysCt || Object.keys(orgKeysCt).length === 0) {
return;
}
_service.clearOrgKeys();
var orgKeysb64 = {},
_orgKeys = {},
setKey = false;
for (var orgId in orgKeysCt) {
if (orgKeysCt.hasOwnProperty(orgId)) {
try {
var decBytes = _service.rsaDecrypt(orgKeysCt[orgId].key, privateKey);
var decKey = new SymmetricCryptoKey(decBytes);
_orgKeys[orgId] = decKey;
orgKeysb64[orgId] = decKey.keyB64;
setKey = true;
}
catch (e) {
console.log('Cannot set org key for ' + orgId + '. Decryption failed.');
}
}
}
if (setKey) {
$sessionStorage.orgKeys = orgKeysb64;
}
else {
_orgKeys = null;
}
};
_service.addOrgKey = function (orgId, encOrgKey, privateKey) {
_orgKeys = _service.getOrgKeys();
if (!_orgKeys) {
_orgKeys = {};
}
var orgKeysb64 = $sessionStorage.orgKeys;
if (!orgKeysb64) {
orgKeysb64 = {};
}
try {
var decBytes = _service.rsaDecrypt(encOrgKey, privateKey);
var decKey = new SymmetricCryptoKey(decBytes);
_orgKeys[orgId] = decKey;
orgKeysb64[orgId] = decKey.keyB64;
}
catch (e) {
_orgKeys = null;
console.log('Cannot set org key. Decryption failed.');
}
$sessionStorage.orgKeys = orgKeysb64;
};
_service.getKey = function () {
if (!_key && $sessionStorage.key) {
_key = new SymmetricCryptoKey($sessionStorage.key, true);
}
if (!_key) {
throw 'key unavailable';
}
return _key;
};
_service.getEncKey = function () {
if (!_encKey && $sessionStorage.encKey) {
_encKey = new SymmetricCryptoKey($sessionStorage.encKey, true);
}
return _encKey;
};
_service.getPrivateKey = function (outputEncoding) {
outputEncoding = outputEncoding || 'native';
if (_privateKey) {
if (outputEncoding === 'raw') {
var privateKeyAsn1 = forge.pki.privateKeyToAsn1(_privateKey);
var privateKeyPkcs8 = forge.pki.wrapRsaPrivateKey(privateKeyAsn1);
return forge.asn1.toDer(privateKeyPkcs8).getBytes();
}
return _privateKey;
}
if ($sessionStorage.privateKey) {
var privateKeyBytes = forge.util.decode64($sessionStorage.privateKey);
_privateKey = forge.pki.privateKeyFromAsn1(forge.asn1.fromDer(privateKeyBytes));
if (outputEncoding === 'raw') {
return privateKeyBytes;
}
}
return _privateKey;
};
_service.getPublicKey = function () {
if (_publicKey) {
return _publicKey;
}
var privateKey = _service.getPrivateKey();
if (!privateKey) {
return null;
}
_publicKey = forge.pki.setRsaPublicKey(privateKey.n, privateKey.e);
return _publicKey;
};
_service.getOrgKeys = function () {
if (_orgKeys) {
return _orgKeys;
}
if ($sessionStorage.orgKeys) {
var orgKeys = {},
setKey = false;
for (var orgId in $sessionStorage.orgKeys) {
if ($sessionStorage.orgKeys.hasOwnProperty(orgId)) {
orgKeys[orgId] = new SymmetricCryptoKey($sessionStorage.orgKeys[orgId], true);
setKey = true;
}
}
if (setKey) {
_orgKeys = orgKeys;
}
}
return _orgKeys;
};
_service.getOrgKey = function (orgId) {
var orgKeys = _service.getOrgKeys();
if (!orgKeys || !(orgId in orgKeys)) {
return null;
}
return orgKeys[orgId];
};
_service.clearKey = function () {
_key = null;
_legacyEtmKey = null;
delete $sessionStorage.key;
};
_service.clearEncKey = function () {
_encKey = null;
delete $sessionStorage.encKey;
};
_service.clearKeyPair = function () {
_privateKey = null;
_publicKey = null;
delete $sessionStorage.privateKey;
};
_service.clearOrgKeys = function () {
_orgKeys = null;
delete $sessionStorage.orgKeys;
};
_service.clearOrgKey = function (orgId) {
if (_orgKeys.hasOwnProperty(orgId)) {
delete _orgKeys[orgId];
}
if ($sessionStorage.orgKeys.hasOwnProperty(orgId)) {
delete $sessionStorage.orgKeys[orgId];
}
};
_service.clearKeys = function () {
_service.clearKey();
_service.clearEncKey();
_service.clearKeyPair();
_service.clearOrgKeys();
};
_service.makeKey = function (password, salt) {
if (_subtle != null && !$window.cryptoShimmed && $window.navigator.userAgent.indexOf('Edge') === -1) {
return pbkdf2WC(password, salt, 5000, 256).then(function (keyBuf) {
return new SymmetricCryptoKey(bufToB64(keyBuf), true);
});
}
else {
var deferred = $q.defer();
var keyBytes = forge.pbkdf2(forge.util.encodeUtf8(password), forge.util.encodeUtf8(salt),
5000, 256 / 8, 'sha256');
deferred.resolve(new SymmetricCryptoKey(keyBytes));
return deferred.promise;
}
};
_service.makeEncKey = function (key) {
var encKey = forge.random.getBytesSync(512 / 8);
var encKeyEnc = _service.encrypt(encKey, key, 'raw');
return {
encKey: new SymmetricCryptoKey(encKey),
encKeyEnc: encKeyEnc
};
};
_service.makeKeyPair = function (key) {
var deferred = $q.defer();
forge.pki.rsa.generateKeyPair({
bits: 2048,
workers: 2,
workerScript: '/lib/forge/prime.worker.min.js'
}, function (error, keypair) {
if (error) {
deferred.reject(error);
return;
}
var privateKeyAsn1 = forge.pki.privateKeyToAsn1(keypair.privateKey);
var privateKeyPkcs8 = forge.pki.wrapRsaPrivateKey(privateKeyAsn1);
var privateKeyBytes = forge.asn1.toDer(privateKeyPkcs8).getBytes();
var privateKeyEncCt = _service.encrypt(privateKeyBytes, key, 'raw');
var publicKeyAsn1 = forge.pki.publicKeyToAsn1(keypair.publicKey);
var publicKeyBytes = forge.asn1.toDer(publicKeyAsn1).getBytes();
deferred.resolve({
publicKey: forge.util.encode64(publicKeyBytes),
privateKeyEnc: privateKeyEncCt
});
});
return deferred.promise;
};
_service.makeShareKey = function () {
var key = forge.random.getBytesSync(512 / 8);
return {
key: new SymmetricCryptoKey(key),
ct: _service.rsaEncryptMe(key)
};
};
_service.hashPassword = function (password, key) {
if (!key) {
key = _service.getKey();
}
if (!password || !key) {
throw 'Invalid parameters.';
}
if (_subtle != null && !$window.cryptoShimmed && $window.navigator.userAgent.indexOf('Edge') === -1) {
var keyBuf = key.getBuffers();
return pbkdf2WC(new Uint8Array(keyBuf.key), password, 1, 256).then(function (hashBuf) {
return bufToB64(hashBuf);
});
}
else {
var deferred = $q.defer();
var hashBits = forge.pbkdf2(key.key, forge.util.encodeUtf8(password), 1, 256 / 8, 'sha256');
deferred.resolve(forge.util.encode64(hashBits));
return deferred.promise;
}
};
function pbkdf2WC(password, salt, iterations, size) {
password = typeof (password) === 'string' ? utf8ToArray(password) : password;
salt = typeof (salt) === 'string' ? utf8ToArray(salt) : salt;
return _subtle.importKey('raw', password.buffer, { name: 'PBKDF2' }, false, ['deriveKey', 'deriveBits'])
.then(function (importedKey) {
return _subtle.deriveKey(
{ name: 'PBKDF2', salt: salt.buffer, iterations: iterations, hash: { name: 'SHA-256' } },
importedKey, { name: 'AES-CBC', length: size }, true, ['encrypt', 'decrypt']);
}).then(function (derivedKey) {
return _subtle.exportKey('raw', derivedKey);
});
}
_service.makeKeyAndHash = function (email, password) {
email = email.toLowerCase();
var key;
return _service.makeKey(password, email).then(function (theKey) {
key = theKey;
return _service.hashPassword(password, theKey);
}).then(function (theHash) {
return {
key: key,
hash: theHash
};
});
};
_service.encrypt = function (plainValue, key, plainValueEncoding) {
var encValue = aesEncrypt(plainValue, key, plainValueEncoding);
var iv = forge.util.encode64(encValue.iv);
var ct = forge.util.encode64(encValue.ct);
var cipherString = iv + '|' + ct;
if (encValue.mac) {
var mac = forge.util.encode64(encValue.mac);
cipherString = cipherString + '|' + mac;
}
return encValue.key.encType + '.' + cipherString;
};
_service.encryptToBytes = function (plainValue, key) {
return aesEncryptWC(plainValue, key).then(function (encValue) {
var macLen = 0;
if (encValue.mac) {
macLen = encValue.mac.length;
}
var encBytes = new Uint8Array(1 + encValue.iv.length + macLen + encValue.ct.length);
encBytes.set([encValue.key.encType]);
encBytes.set(encValue.iv, 1);
if (encValue.mac) {
encBytes.set(encValue.mac, 1 + encValue.iv.length);
}
encBytes.set(encValue.ct, 1 + encValue.iv.length + macLen);
return encBytes.buffer;
});
};
function aesEncrypt(plainValue, key, plainValueEncoding) {
key = key || _service.getEncKey() || _service.getKey();
if (!key) {
throw 'Encryption key unavailable.';
}
plainValueEncoding = plainValueEncoding || 'utf8';
var buffer = forge.util.createBuffer(plainValue, plainValueEncoding);
var ivBytes = forge.random.getBytesSync(16);
var cipher = forge.cipher.createCipher('AES-CBC', key.encKey);
cipher.start({ iv: ivBytes });
cipher.update(buffer);
cipher.finish();
var ctBytes = cipher.output.getBytes();
var macBytes = null;
if (key.macKey) {
macBytes = computeMac(ivBytes + ctBytes, key.macKey, false);
}
return {
iv: ivBytes,
ct: ctBytes,
mac: macBytes,
key: key,
plainValueEncoding: plainValueEncoding
};
}
function aesEncryptWC(plainValue, key) {
key = key || _service.getEncKey() || _service.getKey();
if (!key) {
throw 'Encryption key unavailable.';
}
var obj = {
iv: new Uint8Array(16),
ct: null,
mac: null,
key: key
};
var keyBuf = key.getBuffers();
_crypto.getRandomValues(obj.iv);
return _subtle.importKey('raw', keyBuf.encKey, { name: 'AES-CBC' }, false, ['encrypt'])
.then(function (encKey) {
return _subtle.encrypt({ name: 'AES-CBC', iv: obj.iv }, encKey, plainValue);
}).then(function (encValue) {
obj.ct = new Uint8Array(encValue);
if (!keyBuf.macKey) {
return null;
}
var data = new Uint8Array(obj.iv.length + obj.ct.length);
data.set(obj.iv, 0);
data.set(obj.ct, obj.iv.length);
return computeMacWC(data.buffer, keyBuf.macKey);
}).then(function (mac) {
if (mac) {
obj.mac = new Uint8Array(mac);
}
return obj;
});
}
_service.rsaEncrypt = function (plainValue, publicKey, key) {
publicKey = publicKey || _service.getPublicKey();
if (!publicKey) {
throw 'Public key unavailable.';
}
if (typeof publicKey === 'string') {
var publicKeyBytes = forge.util.decode64(publicKey);
publicKey = forge.pki.publicKeyFromAsn1(forge.asn1.fromDer(publicKeyBytes));
}
var encryptedBytes = publicKey.encrypt(plainValue, 'RSA-OAEP', {
md: forge.md.sha1.create()
});
var cipherString = forge.util.encode64(encryptedBytes);
if (key && key.macKey) {
var mac = computeMac(encryptedBytes, key.macKey, true);
return constants.encType.Rsa2048_OaepSha1_HmacSha256_B64 + '.' + cipherString + '|' + mac;
}
else {
return constants.encType.Rsa2048_OaepSha1_B64 + '.' + cipherString;
}
};
_service.rsaEncryptMe = function (plainValue) {
return _service.rsaEncrypt(plainValue, _service.getPublicKey(), _service.getEncKey());
};
_service.decrypt = function (encValue, key, outputEncoding) {
try {
key = key || _service.getEncKey() || _service.getKey();
var headerPieces = encValue.split('.'),
encType,
encPieces;
if (headerPieces.length === 2) {
try {
encType = parseInt(headerPieces[0]);
encPieces = headerPieces[1].split('|');
}
catch (e) {
console.error('Cannot parse headerPieces.');
return null;
}
}
else {
encPieces = encValue.split('|');
encType = encPieces.length === 3 ? constants.encType.AesCbc128_HmacSha256_B64 :
constants.encType.AesCbc256_B64;
}
if (encType === constants.encType.AesCbc128_HmacSha256_B64 && key.encType === constants.encType.AesCbc256_B64) {
// Old encrypt-then-mac scheme, swap out the key
_legacyEtmKey = _legacyEtmKey ||
new SymmetricCryptoKey(key.key, false, constants.encType.AesCbc128_HmacSha256_B64);
key = _legacyEtmKey;
}
if (encType !== key.encType) {
throw 'encType unavailable.';
}
switch (encType) {
case constants.encType.AesCbc128_HmacSha256_B64:
case constants.encType.AesCbc256_HmacSha256_B64:
if (encPieces.length !== 3) {
console.error('Enc type (' + encType + ') not valid.');
return null;
}
break;
case constants.encType.AesCbc256_B64:
if (encPieces.length !== 2) {
console.error('Enc type (' + encType + ') not valid.');
return null;
}
break;
default:
console.error('Enc type (' + encType + ') not supported.');
return null;
}
var ivBytes = forge.util.decode64(encPieces[0]);
var ctBytes = forge.util.decode64(encPieces[1]);
if (key.macKey && encPieces.length > 2) {
var macBytes = forge.util.decode64(encPieces[2]);
var computedMacBytes = computeMac(ivBytes + ctBytes, key.macKey, false);
if (!macsEqual(macBytes, computedMacBytes)) {
console.error('MAC failed.');
return null;
}
}
var ctBuffer = forge.util.createBuffer(ctBytes);
var decipher = forge.cipher.createDecipher('AES-CBC', key.encKey);
decipher.start({ iv: ivBytes });
decipher.update(ctBuffer);
decipher.finish();
outputEncoding = outputEncoding || 'utf8';
if (outputEncoding === 'utf8') {
return decipher.output.toString('utf8');
}
else {
return decipher.output.getBytes();
}
}
catch (e) {
console.error('Caught unhandled error in decrypt: ' + e);
throw e;
}
};
_service.decryptFromBytes = function (encBuf, key) {
try {
if (!encBuf) {
throw 'no encBuf.';
}
var encBytes = new Uint8Array(encBuf),
encType = encBytes[0],
ctBytes = null,
ivBytes = null,
macBytes = null;
switch (encType) {
case constants.encType.AesCbc128_HmacSha256_B64:
case constants.encType.AesCbc256_HmacSha256_B64:
if (encBytes.length <= 49) { // 1 + 16 + 32 + ctLength
console.error('Enc type (' + encType + ') not valid.');
return null;
}
ivBytes = slice(encBytes, 1, 17);
macBytes = slice(encBytes, 17, 49);
ctBytes = slice(encBytes, 49);
break;
case constants.encType.AesCbc256_B64:
if (encBytes.length <= 17) { // 1 + 16 + ctLength
console.error('Enc type (' + encType + ') not valid.');
return null;
}
ivBytes = slice(encBytes, 1, 17);
ctBytes = slice(encBytes, 17);
break;
default:
console.error('Enc type (' + encType + ') not supported.');
return null;
}
return aesDecryptWC(
encType,
ctBytes.buffer,
ivBytes.buffer,
macBytes ? macBytes.buffer : null,
key);
}
catch (e) {
console.error('Caught unhandled error in decryptFromBytes: ' + e);
throw e;
}
};
function aesDecryptWC(encType, ctBuf, ivBuf, macBuf, key) {
key = key || _service.getEncKey() || _service.getKey();
if (!key) {
throw 'Encryption key unavailable.';
}
if (key.macKey && !macBuf) {
throw 'macBuf required for this type of key.';
}
if (encType !== key.encType) {
throw 'encType unavailable.';
}
var keyBuf = key.getBuffers(),
encKey = null;
return _subtle.importKey('raw', keyBuf.encKey, { name: 'AES-CBC' }, false, ['decrypt'])
.then(function (theEncKey) {
encKey = theEncKey;
if (!key.macKey || !macBuf) {
return null;
}
var data = new Uint8Array(ivBuf.byteLength + ctBuf.byteLength);
data.set(new Uint8Array(ivBuf), 0);
data.set(new Uint8Array(ctBuf), ivBuf.byteLength);
return computeMacWC(data.buffer, keyBuf.macKey);
}).then(function (computedMacBuf) {
if (computedMacBuf === null) {
return null;
}
return macsEqualWC(macBuf, computedMacBuf);
}).then(function (macsMatch) {
if (macsMatch === false) {
console.error('MAC failed.');
return null;
}
return _subtle.decrypt({ name: 'AES-CBC', iv: ivBuf }, encKey, ctBuf);
});
}
_service.rsaDecrypt = function (encValue, privateKey, key) {
privateKey = privateKey || _service.getPrivateKey();
key = key || _service.getEncKey();
if (!privateKey) {
throw 'Private key unavailable.';
}
var headerPieces = encValue.split('.'),
encType,
encPieces;
if (headerPieces.length === 1) {
encType = constants.encType.Rsa2048_OaepSha256_B64;
encPieces = [headerPieces[0]];
}
else if (headerPieces.length === 2) {
try {
encType = parseInt(headerPieces[0]);
encPieces = headerPieces[1].split('|');
}
catch (e) {
return null;
}
}
switch (encType) {
case constants.encType.Rsa2048_OaepSha256_B64:
case constants.encType.Rsa2048_OaepSha1_B64:
if (encPieces.length !== 1) {
return null;
}
break;
case constants.encType.Rsa2048_OaepSha256_HmacSha256_B64:
case constants.encType.Rsa2048_OaepSha1_HmacSha256_B64:
if (encPieces.length !== 2) {
return null;
}
break;
default:
return null;
}
var ctBytes = forge.util.decode64(encPieces[0]);
if (key && key.macKey && encPieces.length > 1) {
var macBytes = forge.util.decode64(encPieces[1]);
var computedMacBytes = computeMac(ctBytes, key.macKey, false);
if (!macsEqual(macBytes, computedMacBytes)) {
console.error('MAC failed.');
return null;
}
}
var md;
if (encType === constants.encType.Rsa2048_OaepSha256_B64 ||
encType === constants.encType.Rsa2048_OaepSha256_HmacSha256_B64) {
md = forge.md.sha256.create();
}
else if (encType === constants.encType.Rsa2048_OaepSha1_B64 ||
encType === constants.encType.Rsa2048_OaepSha1_HmacSha256_B64) {
md = forge.md.sha1.create();
}
else {
throw 'encType unavailable.';
}
var decBytes = privateKey.decrypt(ctBytes, 'RSA-OAEP', {
md: md
});
return decBytes;
};
function computeMac(dataBytes, macKey, b64Output) {
var hmac = forge.hmac.create();
hmac.start('sha256', macKey);
hmac.update(dataBytes);
var mac = hmac.digest();
return b64Output ? forge.util.encode64(mac.getBytes()) : mac.getBytes();
}
function computeMacWC(dataBuf, macKeyBuf) {
return _subtle.importKey('raw', macKeyBuf, { name: 'HMAC', hash: { name: 'SHA-256' } }, false, ['sign'])
.then(function (key) {
return _subtle.sign({ name: 'HMAC', hash: { name: 'SHA-256' } }, key, dataBuf);
});
}
// Safely compare two MACs in a way that protects against timing attacks (Double HMAC Verification).
// ref: https://www.nccgroup.trust/us/about-us/newsroom-and-events/blog/2011/february/double-hmac-verification/
// ref: https://paragonie.com/blog/2015/11/preventing-timing-attacks-on-string-comparison-with-double-hmac-strategy
function macsEqual(mac1, mac2) {
var hmac = forge.hmac.create();
hmac.start('sha256', getRandomBytes(32));
hmac.update(mac1);
mac1 = hmac.digest().getBytes();
hmac.start(null, null);
hmac.update(mac2);
mac2 = hmac.digest().getBytes();
return mac1 === mac2;
}
function macsEqualWC(mac1Buf, mac2Buf) {
var mac1,
macKey;
var compareKey = new Uint8Array(32);
_crypto.getRandomValues(compareKey);
return window.crypto.subtle.importKey('raw', compareKey.buffer, { name: 'HMAC', hash: { name: 'SHA-256' } }, false, ['sign'])
.then(function (key) {
macKey = key;
return window.crypto.subtle.sign({ name: 'HMAC', hash: { name: 'SHA-256' } }, macKey, mac1Buf);
}).then(function (mac) {
mac1 = mac;
return window.crypto.subtle.sign({ name: 'HMAC', hash: { name: 'SHA-256' } }, macKey, mac2Buf);
}).then(function (mac2) {
if (mac1.byteLength !== mac2.byteLength) {
return false;
}
var arr1 = new Uint8Array(mac1);
var arr2 = new Uint8Array(mac2);
for (var i = 0; i < arr2.length; i++) {
if (arr1[i] !== arr2[i]) {
return false;
}
}
return true;
});
}
function SymmetricCryptoKey(keyBytes, b64KeyBytes, encType) {
if (b64KeyBytes) {
keyBytes = forge.util.decode64(keyBytes);
}
if (!keyBytes) {
throw 'Must provide keyBytes';
}
var buffer = forge.util.createBuffer(keyBytes);
if (!buffer || buffer.length() === 0) {
throw 'Couldn\'t make buffer';
}
var bufferLength = buffer.length();
if (encType === null || encType === undefined) {
if (bufferLength === 32) {
encType = constants.encType.AesCbc256_B64;
}
else if (bufferLength === 64) {
encType = constants.encType.AesCbc256_HmacSha256_B64;
}
else {
throw 'Unable to determine encType.';
}
}
this.key = keyBytes;
this.keyB64 = forge.util.encode64(keyBytes);
this.encType = encType;
if (encType === constants.encType.AesCbc256_B64 && bufferLength === 32) {
this.encKey = keyBytes;
this.macKey = null;
}
else if (encType === constants.encType.AesCbc128_HmacSha256_B64 && bufferLength === 32) {
this.encKey = buffer.getBytes(16); // first half
this.macKey = buffer.getBytes(16); // second half
}
else if (encType === constants.encType.AesCbc256_HmacSha256_B64 && bufferLength === 64) {
this.encKey = buffer.getBytes(32); // first half
this.macKey = buffer.getBytes(32); // second half
}
else {
throw 'Unsupported encType/key length.';
}
}
SymmetricCryptoKey.prototype.getBuffers = function () {
if (this.keyBuf) {
return this.keyBuf;
}
var key = b64ToArray(this.keyB64);
var keys = {
key: key.buffer
};
if (this.macKey) {
keys.encKey = slice(key, 0, key.length / 2).buffer;
keys.macKey = slice(key, key.length / 2).buffer;
}
else {
keys.encKey = key.buffer;
keys.macKey = null;
}
this.keyBuf = keys;
return this.keyBuf;
};
function b64ToArray(b64Str) {
var binaryString = $window.atob(b64Str);
var arr = new Uint8Array(binaryString.length);
for (var i = 0; i < binaryString.length; i++) {
arr[i] = binaryString.charCodeAt(i);
}
return arr;
}
function bufToB64(buf) {
var binary = '';
var bytes = new Uint8Array(buf);
for (var i = 0; i < bytes.byteLength; i++) {
binary += String.fromCharCode(bytes[i]);
}
return $window.btoa(binary);
}
function utf8ToArray(str) {
var utf8Str = unescape(encodeURIComponent(str));
var arr = new Uint8Array(utf8Str.length);
for (var i = 0; i < utf8Str.length; i++) {
arr[i] = utf8Str.charCodeAt(i);
}
return arr;
}
function slice(arr, begin, end) {
if (arr.slice) {
return arr.slice(begin, end);
}
// shim for IE
// ref: https://stackoverflow.com/a/21440217
arr = arr.buffer;
if (begin === void 0) {
begin = 0;
}
if (end === void 0) {
end = arr.byteLength;
}
begin = Math.floor(begin);
end = Math.floor(end);
if (begin < 0) {
begin += arr.byteLength;
}
if (end < 0) {
end += arr.byteLength;
}
begin = Math.min(Math.max(0, begin), arr.byteLength);
end = Math.min(Math.max(0, end), arr.byteLength);
if (end - begin <= 0) {
return new ArrayBuffer(0);
}
var result = new ArrayBuffer(end - begin);
var resultBytes = new Uint8Array(result);
var sourceBytes = new Uint8Array(arr, begin, end - begin);
resultBytes.set(sourceBytes);
return new Uint8Array(result);
}
function getRandomBytes(byteLength) {
var bytes = new Uint32Array(byteLength / 4);
_crypto.getRandomValues(bytes);
var buffer = forge.util.createBuffer();
for (var i = 0; i < bytes.length; i++) {
buffer.putInt32(bytes[i]);
}
return buffer.getBytes();
}
return _service;
}]);
angular
.module('bit.services')
.factory('eventService', ["constants", "$filter", function (constants, $filter) {
var _service = {};
_service.getDefaultDateFilters = function () {
var d = new Date();
var filterEnd = new Date(d.getFullYear(), d.getMonth(), d.getDate(), 23, 59);
d.setDate(d.getDate() - 30);
var filterStart = new Date(d.getFullYear(), d.getMonth(), d.getDate(), 0, 0);
return {
start: filterStart,
end: filterEnd
};
};
_service.formatDateFilters = function (filterStart, filterEnd) {
var result = {
start: null,
end: null,
error: null
};
try {
var format = 'yyyy-MM-ddTHH:mm';
result.start = $filter('date')(filterStart, format + 'Z', 'UTC');
result.end = $filter('date')(filterEnd, format + ':59.999Z', 'UTC');
} catch (e) { }
if (!result.start || !result.end || result.end < result.start) {
result.error = 'Invalid date range.';
}
return result;
};
_service.getEventInfo = function (ev, options) {
options = options || {
cipherInfo: true
};
var appInfo = getAppInfo(ev);
return {
message: getEventMessage(ev, options),
appIcon: appInfo.icon,
appName: appInfo.name
};
};
function getEventMessage(ev, options) {
var msg = '';
switch (ev.Type) {
// User
case constants.eventType.User_LoggedIn:
msg = 'Logged in.';
break;
case constants.eventType.User_ChangedPassword:
msg = 'Changed account password.';
break;
case constants.eventType.User_Enabled2fa:
msg = 'Enabled two-step login.';
break;
case constants.eventType.User_Disabled2fa:
msg = 'Disabled two-step login.';
break;
case constants.eventType.User_Recovered2fa:
msg = 'Recovered account from two-step login.';
break;
case constants.eventType.User_FailedLogIn:
msg = 'Login attempt failed with incorrect password.';
break;
case constants.eventType.User_FailedLogIn2fa:
msg = 'Login attempt failed with incorrect two-step login.';
break;
// Cipher
case constants.eventType.Cipher_Created:
msg = options.cipherInfo ? 'Created item ' + formatCipherId(ev) + '.' : 'Created.';
break;
case constants.eventType.Cipher_Updated:
msg = options.cipherInfo ? 'Edited item ' + formatCipherId(ev) + '.' : 'Edited.';
break;
case constants.eventType.Cipher_Deleted:
msg = options.cipherInfo ? 'Deleted item ' + formatCipherId(ev) + '.' : 'Deleted';
break;
case constants.eventType.Cipher_AttachmentCreated:
msg = options.cipherInfo ? 'Created attachment for item ' + formatCipherId(ev) + '.' :
'Created attachment.';
break;
case constants.eventType.Cipher_AttachmentDeleted:
msg = options.cipherInfo ? 'Deleted attachment for item ' + formatCipherId(ev) + '.' :
'Deleted attachment.';
break;
case constants.eventType.Cipher_Shared:
msg = options.cipherInfo ? 'Shared item ' + formatCipherId(ev) + '.' : 'Shared.';
break;
case constants.eventType.Cipher_UpdatedCollections:
msg = options.cipherInfo ? 'Update collections for item ' + formatCipherId(ev) + '.' :
'Updated collections.';
break;
// Collection
case constants.eventType.Collection_Created:
msg = 'Created collection ' + formatCollectionId(ev) + '.';
break;
case constants.eventType.Collection_Updated:
msg = 'Edited collection ' + formatCollectionId(ev) + '.';
break;
case constants.eventType.Collection_Deleted:
msg = 'Deleted collection ' + formatCollectionId(ev) + '.';
break;
// Group
case constants.eventType.Group_Created:
msg = 'Created group ' + formatGroupId(ev) + '.';
break;
case constants.eventType.Group_Updated:
msg = 'Edited group ' + formatGroupId(ev) + '.';
break;
case constants.eventType.Group_Deleted:
msg = 'Deleted group ' + formatGroupId(ev) + '.';
break;
// Org user
case constants.eventType.OrganizationUser_Invited:
msg = 'Invited user ' + formatOrgUserId(ev) + '.';
break;
case constants.eventType.OrganizationUser_Confirmed:
msg = 'Confirmed user ' + formatOrgUserId(ev) + '.';
break;
case constants.eventType.OrganizationUser_Updated:
msg = 'Edited user ' + formatOrgUserId(ev) + '.';
break;
case constants.eventType.OrganizationUser_Removed:
msg = 'Removed user ' + formatOrgUserId(ev) + '.';
break;
case constants.eventType.OrganizationUser_UpdatedGroups:
msg = 'Edited groups for user ' + formatOrgUserId(ev) + '.';
break;
// Org
case constants.eventType.Organization_Updated:
msg = 'Edited organization settings.';
break;
default:
break;
}
return msg === '' ? null : msg;
}
function getAppInfo(ev) {
var appInfo = {
icon: 'fa-globe',
name: 'Unknown'
};
switch (ev.DeviceType) {
case constants.deviceType.android:
appInfo.icon = 'fa-android';
appInfo.name = 'Mobile App - Android';
break;
case constants.deviceType.ios:
appInfo.icon = 'fa-apple';
appInfo.name = 'Mobile App - iOS';
break;
case constants.deviceType.uwp:
appInfo.icon = 'fa-windows';
appInfo.name = 'Mobile App - Windows';
break;
case constants.deviceType.chromeExt:
appInfo.icon = 'fa-chrome';
appInfo.name = 'Extension - Chrome';
break;
case constants.deviceType.firefoxExt:
appInfo.icon = 'fa-firefox';
appInfo.name = 'Extension - Firefox';
break;
case constants.deviceType.operaExt:
appInfo.icon = 'fa-opera';
appInfo.name = 'Extension - Opera';
break;
case constants.deviceType.edgeExt:
appInfo.icon = 'fa-edge';
appInfo.name = 'Extension - Edge';
break;
case constants.deviceType.vivaldiExt:
appInfo.icon = 'fa-puzzle-piece';
appInfo.name = 'Extension - Vivaldi';
break;
case constants.deviceType.windowsDesktop:
appInfo.icon = 'fa-windows';
appInfo.name = 'Desktop - Windows';
break;
case constants.deviceType.macOsDesktop:
appInfo.icon = 'fa-apple';
appInfo.name = 'Desktop - macOS';
break;
case constants.deviceType.linuxDesktop:
appInfo.icon = 'fa-linux';
appInfo.name = 'Desktop - Linux';
break;
case constants.deviceType.chrome:
appInfo.icon = 'fa-globe';
appInfo.name = 'Web Vault - Chrome';
break;
case constants.deviceType.firefox:
appInfo.icon = 'fa-globe';
appInfo.name = 'Web Vault - Firefox';
break;
case constants.deviceType.opera:
appInfo.icon = 'fa-globe';
appInfo.name = 'Web Vault - Opera';
break;
case constants.deviceType.safari:
appInfo.icon = 'fa-globe';
appInfo.name = 'Web Vault - Safari';
break;
case constants.deviceType.vivaldi:
appInfo.icon = 'fa-globe';
appInfo.name = 'Web Vault - Vivaldi';
break;
case constants.deviceType.edge:
appInfo.icon = 'fa-globe';
appInfo.name = 'Web Vault - Edge';
break;
case constants.deviceType.ie:
appInfo.icon = 'fa-globe';
appInfo.name = 'Web Vault - IE';
break;
case constants.deviceType.unknown:
appInfo.icon = 'fa-globe';
appInfo.name = 'Web Vault - Unknown';
break;
default:
break;
}
return appInfo;
}
function formatCipherId(ev) {
var shortId = ev.CipherId.substring(0, 8);
if (!ev.OrganizationId) {
return '
' + shortId + '';
}
return '' +
'' + shortId + '';
}
function formatGroupId(ev) {
var shortId = ev.GroupId.substring(0, 8);
return '' +
'' + shortId + '';
}
function formatCollectionId(ev) {
var shortId = ev.CollectionId.substring(0, 8);
return '' +
'' + shortId + '';
}
function formatOrgUserId(ev) {
var shortId = ev.OrganizationUserId.substring(0, 8);
return '' +
'' + shortId + '';
}
return _service;
}]);
angular
.module('bit.services')
.factory('importService', ["constants", function (constants) {
var _service = {};
_service.import = function (source, file, success, error) {
if (!file) {
error();
return;
}
switch (source) {
case 'bitwardencsv':
importBitwardenCsv(file, success, error);
break;
case 'lastpass':
importLastPass(file, success, error, false);
break;
case 'safeincloudxml':
importSafeInCloudXml(file, success, error);
break;
case 'keepass2xml':
importKeePass2Xml(file, success, error);
break;
case 'keepassxcsv':
importKeePassXCsv(file, success, error);
break;
case 'padlockcsv':
importPadlockCsv(file, success, error);
break;
case '1password1pif':
import1Password1Pif(file, success, error);
break;
case '1password6wincsv':
import1Password6WinCsv(file, success, error);
break;
case 'chromecsv':
case 'vivaldicsv':
case 'operacsv':
importChromeCsv(file, success, error);
break;
case 'firefoxpasswordexportercsv':
importFirefoxPasswordExporterCsv(file, success, error);
break;
case 'upmcsv':
importUpmCsv(file, success, error);
break;
case 'keepercsv':
importKeeperCsv(file, success, error);
break;
case 'passworddragonxml':
importPasswordDragonXml(file, success, error);
break;
case 'enpasscsv':
importEnpassCsv(file, success, error);
break;
case 'pwsafexml':
importPasswordSafeXml(file, success, error);
break;
case 'dashlanecsv':
importDashlaneCsv(file, success, error);
break;
case 'stickypasswordxml':
importStickyPasswordXml(file, success, error);
break;
case 'msecurecsv':
importmSecureCsv(file, success, error);
break;
case 'truekeycsv':
importTrueKeyCsv(file, success, error);
break;
case 'clipperzhtml':
importClipperzHtml(file, success, error);
break;
case 'avirajson':
importAviraJson(file, success, error);
break;
case 'roboformhtml':
importRoboFormHtml(file, success, error);
break;
case 'saferpasscsv':
importSaferPassCsv(file, success, error);
break;
case 'ascendocsv':
importAscendoCsv(file, success, error);
break;
case 'passwordbossjson':
importPasswordBossJson(file, success, error);
break;
case 'zohovaultcsv':
importZohoVaultCsv(file, success, error);
break;
case 'splashidcsv':
importSplashIdCsv(file, success, error);
break;
case 'meldiumcsv':
importMeldiumCsv(file, success, error);
break;
case 'passkeepcsv':
importPassKeepCsv(file, success, error);
break;
case 'gnomejson':
importGnomeJson(file, success, error);
break;
default:
error();
break;
}
};
_service.importOrg = function (source, file, success, error) {
if (!file) {
error();
return;
}
switch (source) {
case 'bitwardencsv':
importBitwardenOrgCsv(file, success, error);
break;
case 'lastpass':
importLastPass(file, success, error, true);
break;
default:
error();
break;
}
};
// helpers
var _passwordFieldNames = [
'password', 'pass word', 'passphrase', 'pass phrase',
'pass', 'code', 'code word', 'codeword',
'secret', 'secret word', 'personpwd',
'key', 'keyword', 'key word', 'keyphrase', 'key phrase',
'form_pw', 'wppassword', 'pin', 'pwd', 'pw', 'pword', 'passwd',
'p', 'serial', 'serial#', 'license key', 'reg #',
// Non-English names
'passwort'
];
var _usernameFieldNames = [
'user', 'name', 'user name', 'username', 'login name',
'email', 'e-mail', 'id', 'userid', 'user id',
'login', 'form_loginname', 'wpname', 'mail',
'loginid', 'login id', 'log', 'personlogin',
'first name', 'last name', 'card#', 'account #',
'member', 'member #',
// Non-English names
'nom', 'benutzername'
];
var _notesFieldNames = [
"note", "notes", "comment", "comments", "memo",
"description", "free form", "freeform",
"free text", "freetext", "free",
// Non-English names
"kommentar"
];
var _uriFieldNames = [
'url', 'hyper link', 'hyperlink', 'link',
'host', 'hostname', 'host name', 'server', 'address',
'hyper ref', 'href', 'web', 'website', 'web site', 'site',
'web-site', 'uri',
// Non-English names
'ort', 'adresse'
];
function loginNameFromUrl(url) {
var a = document.createElement('a');
a.href = url;
return a.hostname.startsWith('www.') ? a.hostname.replace('www.', '') : a.hostname;
}
function isField(fieldText, refFieldValues) {
if (!fieldText || fieldText === '') {
return false;
}
fieldText = fieldText.trim().toLowerCase();
for (var i = 0; i < refFieldValues.length; i++) {
if (fieldText === refFieldValues[i]) {
return true;
}
}
return false;
}
function fixUri(uri) {
uri = uri.toLowerCase().trim();
if (uri.indexOf('://') === -1 && uri.indexOf('.') >= 0) {
uri = 'http://' + uri;
}
if (uri.length > 1000) {
return uri.substring(0, 1000);
}
return uri;
}
function makeUriArray(uri) {
if (!uri) {
return null;
}
if (typeof uri === 'string') {
return [{
uri: fixUri(uri),
match: null
}];
}
if (uri.length) {
var returnArr = [];
for (var i = 0; i < uri.length; i++) {
returnArr.push({
uri: fixUri(uri[i]),
match: null
});
}
return returnArr;
}
return null;
}
function parseSingleRowCsv(rowData) {
if (!rowData || rowData === '') {
return null;
}
var parsedRow = Papa.parse(rowData);
if (parsedRow && parsedRow.data && parsedRow.data.length && parsedRow.data[0].length) {
return parsedRow.data[0];
}
return null;
}
function parseCsvErrors(results) {
if (results.errors && results.errors.length) {
for (var i = 0; i < results.errors.length; i++) {
console.warn('Error parsing row ' + results.errors[i].row + ': ' + results.errors[i].message);
}
}
}
function getFileContents(file, contentsCallback, errorCallback) {
if (typeof file === 'string') {
contentsCallback(file);
}
else {
var reader = new FileReader();
reader.readAsText(file, 'utf-8');
reader.onload = function (evt) {
contentsCallback(evt.target.result);
};
reader.onerror = function (evt) {
errorCallback();
};
}
}
function getXmlFileContents(file, xmlCallback, errorCallback) {
getFileContents(file, function (fileContents) {
xmlCallback($.parseXML(fileContents));
}, errorCallback);
}
// ref https://stackoverflow.com/a/5911300
function getCardType(number) {
if (!number) {
return null;
}
// Visa
var re = new RegExp('^4');
if (number.match(re) != null) {
return 'Visa';
}
// Mastercard
// Updated for Mastercard 2017 BINs expansion
if (/^(5[1-5][0-9]{14}|2(22[1-9][0-9]{12}|2[3-9][0-9]{13}|[3-6][0-9]{14}|7[0-1][0-9]{13}|720[0-9]{12}))$/.test(number)) {
return 'Mastercard';
}
// AMEX
re = new RegExp('^3[47]');
if (number.match(re) != null) {
return 'Amex';
}
// Discover
re = new RegExp('^(6011|622(12[6-9]|1[3-9][0-9]|[2-8][0-9]{2}|9[0-1][0-9]|92[0-5]|64[4-9])|65)');
if (number.match(re) != null) {
return 'Discover';
}
// Diners
re = new RegExp('^36');
if (number.match(re) != null) {
return 'Diners Club';
}
// Diners - Carte Blanche
re = new RegExp('^30[0-5]');
if (number.match(re) != null) {
return 'Diners Club';
}
// JCB
re = new RegExp('^35(2[89]|[3-8][0-9])');
if (number.match(re) != null) {
return 'JCB';
}
// Visa Electron
re = new RegExp('^(4026|417500|4508|4844|491(3|7))');
if (number.match(re) != null) {
return 'Visa';
}
return null;
}
// importers
function importBitwardenCsv(file, success, error) {
Papa.parse(file, {
header: true,
encoding: 'UTF-8',
complete: function (results) {
parseCsvErrors(results);
var folders = [],
ciphers = [],
folderRelationships = [],
i = 0;
angular.forEach(results.data, function (value, key) {
var folderIndex = folders.length,
cipherIndex = ciphers.length,
hasFolder = value.folder && value.folder !== '',
addFolder = hasFolder;
if (hasFolder) {
for (i = 0; i < folders.length; i++) {
if (folders[i].name === value.folder) {
addFolder = false;
folderIndex = i;
break;
}
}
}
var cipher = {
favorite: value.favorite && value.favorite !== '' && value.favorite !== '0' ? true : false,
notes: value.notes && value.notes !== '' ? value.notes : null,
name: value.name && value.name !== '' ? value.name : '--',
type: constants.cipherType.login
};
if (value.fields && value.fields !== '') {
var fields = value.fields.split(/(?:\r\n|\r|\n)/);
for (i = 0; i < fields.length; i++) {
if (!fields[i] || fields[i] === '') {
continue;
}
var delimPosition = fields[i].lastIndexOf(': ');
if (delimPosition === -1) {
continue;
}
if (!cipher.fields) {
cipher.fields = [];
}
var field = {
name: fields[i].substr(0, delimPosition),
value: null,
type: constants.fieldType.text
};
if (fields[i].length > (delimPosition + 2)) {
field.value = fields[i].substr(delimPosition + 2);
}
cipher.fields.push(field);
}
}
var valueType = value.type ? value.type.toLowerCase() : null;
switch (valueType) {
case 'login':
case null:
case undefined:
cipher.type = constants.cipherType.login;
var totp = value.login_totp || value.totp;
var uris = parseSingleRowCsv(value.login_uri || value.uri);
var username = value.login_username || value.username;
var password = value.login_password || value.password;
cipher.login = {
totp: totp && totp !== '' ? totp : null,
uris: makeUriArray(uris),
username: username && username !== '' ? username : null,
password: password && password !== '' ? password : null
};
break;
case 'note':
cipher.type = constants.cipherType.secureNote;
cipher.secureNote = {
type: 0 // generic note
};
break;
default:
break;
}
ciphers.push(cipher);
if (addFolder) {
folders.push({
name: value.folder
});
}
if (hasFolder) {
var relationship = {
key: cipherIndex,
value: folderIndex
};
folderRelationships.push(relationship);
}
});
success(folders, ciphers, folderRelationships);
}
});
}
function importBitwardenOrgCsv(file, success, error) {
Papa.parse(file, {
header: true,
encoding: 'UTF-8',
complete: function (results) {
parseCsvErrors(results);
var collections = [],
ciphers = [],
collectionRelationships = [],
i;
angular.forEach(results.data, function (value, key) {
var cipherIndex = ciphers.length;
if (value.collections && value.collections !== '') {
var cipherCollections = value.collections.split(',');
for (i = 0; i < cipherCollections.length; i++) {
var addCollection = true;
var collectionIndex = collections.length;
for (var j = 0; j < collections.length; j++) {
if (collections[j].name === cipherCollections[i]) {
addCollection = false;
collectionIndex = j;
break;
}
}
if (addCollection) {
collections.push({
name: cipherCollections[i]
});
}
collectionRelationships.push({
key: cipherIndex,
value: collectionIndex
});
}
}
var cipher = {
favorite: false,
notes: value.notes && value.notes !== '' ? value.notes : null,
name: value.name && value.name !== '' ? value.name : '--',
type: constants.cipherType.login
};
if (value.fields && value.fields !== '') {
var fields = value.fields.split(/(?:\r\n|\r|\n)/);
for (i = 0; i < fields.length; i++) {
if (!fields[i] || fields[i] === '') {
continue;
}
var delimPosition = fields[i].lastIndexOf(': ');
if (delimPosition === -1) {
continue;
}
if (!cipher.fields) {
cipher.fields = [];
}
var field = {
name: fields[i].substr(0, delimPosition),
value: null,
type: constants.fieldType.text
};
if (fields[i].length > (delimPosition + 2)) {
field.value = fields[i].substr(delimPosition + 2);
}
cipher.fields.push(field);
}
}
var valueType = value.type ? value.type.toLowerCase() : null;
switch (valueType) {
case 'login':
case null:
case undefined:
cipher.type = constants.cipherType.login;
var totp = value.login_totp || value.totp;
var uris = parseSingleRowCsv(value.login_uri || value.uri);
var username = value.login_username || value.username;
var password = value.login_password || value.password;
cipher.login = {
totp: totp && totp !== '' ? totp : null,
uris: makeUriArray(uris),
username: username && username !== '' ? username : null,
password: password && password !== '' ? password : null
};
break;
case 'note':
cipher.type = constants.cipherType.secureNote;
cipher.secureNote = {
type: 0 // generic note
};
break;
default:
break;
}
ciphers.push(cipher);
});
success(collections, ciphers, collectionRelationships);
}
});
}
function importLastPass(file, success, error, org) {
if (typeof file !== 'string' && file.type && file.type === 'text/html') {
var reader = new FileReader();
reader.readAsText(file, 'utf-8');
reader.onload = function (evt) {
var doc = $(evt.target.result);
var pre = doc.find('pre');
var csv, results;
if (pre.length === 1) {
csv = pre.text().trim();
results = Papa.parse(csv, {
header: true,
encoding: 'UTF-8'
});
parseData(results.data);
}
else {
var foundPre = false;
for (var i = 0; i < doc.length; i++) {
if (doc[i].tagName.toLowerCase() === 'pre') {
foundPre = true;
csv = doc[i].outerText.trim();
results = Papa.parse(csv, {
header: true,
encoding: 'UTF-8'
});
parseData(results.data);
break;
}
}
if (!foundPre) {
error();
}
}
};
reader.onerror = function (evt) {
error();
};
}
else {
Papa.parse(file, {
header: true,
encoding: 'UTF-8',
complete: function (results) {
parseCsvErrors(results);
parseData(results.data);
},
beforeFirstChunk: function (chunk) {
return chunk.replace(/^\s+/, '');
}
});
}
function parseSecureNoteMapping(extraParts, map, skip) {
var obj = {
dataObj: {},
notes: null
};
for (var i = 0; i < extraParts.length; i++) {
var fieldParts = extraParts[i].split(':');
if (fieldParts.length < 1 || fieldParts[0] === 'NoteType' || skip.indexOf(fieldParts[0]) > -1 ||
!fieldParts[1] || fieldParts[1] === '') {
continue;
}
if (fieldParts[0] === 'Notes') {
if (obj.notes) {
obj.notes += ('\n' + fieldParts[1]);
}
else {
obj.notes = fieldParts[1];
}
}
else if (map.hasOwnProperty(fieldParts[0])) {
obj.dataObj[map[fieldParts[0]]] = fieldParts[1];
}
else {
if (obj.notes) {
obj.notes += '\n';
}
else {
obj.notes = '';
}
obj.notes += (fieldParts[0] + ': ' + fieldParts[1]);
}
}
return obj;
}
function parseCard(value) {
var cardData = {
cardholderName: value.ccname && value.ccname !== '' ? value.ccname : null,
number: value.ccnum && value.ccnum !== '' ? value.ccnum : null,
brand: value.ccnum && value.ccnum !== '' ? getCardType(value.ccnum) : null,
code: value.cccsc && value.cccsc !== '' ? value.cccsc : null
};
if (value.ccexp && value.ccexp !== '' && value.ccexp.indexOf('-') > -1) {
var ccexpParts = value.ccexp.split('-');
if (ccexpParts.length > 1) {
cardData.expYear = ccexpParts[0];
cardData.expMonth = ccexpParts[1];
if (cardData.expMonth.length === 2 && cardData.expMonth[0] === '0') {
cardData.expMonth = cardData.expMonth[1];
}
}
}
return cardData;
}
function parseData(data) {
var folders = [],
ciphers = [],
cipherRelationships = [],
i = 0;
angular.forEach(data, function (value, key) {
var folderIndex = folders.length,
cipherIndex = ciphers.length,
hasFolder = value.grouping && value.grouping !== '' && value.grouping !== '(none)',
addFolder = hasFolder;
if (hasFolder) {
for (i = 0; i < folders.length; i++) {
if (folders[i].name === value.grouping) {
addFolder = false;
folderIndex = i;
break;
}
}
}
var cipher;
if (value.hasOwnProperty('profilename') && value.hasOwnProperty('profilelanguage')) {
// form fill
cipher = {
favorite: false,
name: value.profilename && value.profilename !== '' ? value.profilename : '--',
type: constants.cipherType.card
};
if (value.title !== '' || value.firstname !== '' || value.lastname !== '' ||
value.address1 !== '' || value.phone !== '' || value.username !== '' ||
value.email !== '') {
cipher.type = constants.cipherType.identity;
}
}
else {
// site or secure note
cipher = {
favorite: org ? false : value.fav === '1',
name: value.name && value.name !== '' ? value.name : '--',
type: value.url === 'http://sn' ? constants.cipherType.secureNote : constants.cipherType.login
};
}
if (cipher.type === constants.cipherType.login) {
cipher.login = {
uris: makeUriArray(value.url),
username: value.username && value.username !== '' ? value.username : null,
password: value.password && value.password !== '' ? value.password : null
};
cipher.notes = value.extra && value.extra !== '' ? value.extra : null;
}
else if (cipher.type === constants.cipherType.secureNote) {
var extraParts = value.extra.split(/(?:\r\n|\r|\n)/),
processedNote = false;
if (extraParts.length) {
var typeParts = extraParts[0].split(':');
if (typeParts.length > 1 && typeParts[0] === 'NoteType' &&
(typeParts[1] === 'Credit Card' || typeParts[1] === 'Address')) {
var mappedData = null;
if (typeParts[1] === 'Credit Card') {
mappedData = parseSecureNoteMapping(extraParts, {
'Number': 'number',
'Name on Card': 'cardholderName',
'Security Code': 'code'
}, []);
cipher.type = constants.cipherType.card;
cipher.card = mappedData.dataObj;
}
else if (typeParts[1] === 'Address') {
mappedData = parseSecureNoteMapping(extraParts, {
'Title': 'title',
'First Name': 'firstName',
'Last Name': 'lastName',
'Middle Name': 'middleName',
'Company': 'company',
'Address 1': 'address1',
'Address 2': 'address2',
'Address 3': 'address3',
'City / Town': 'city',
'State': 'state',
'Zip / Postal Code': 'postalCode',
'Country': 'country',
'Email Address': 'email',
'Username': 'username'
}, []);
cipher.type = constants.cipherType.identity;
cipher.identity = mappedData.dataObj;
}
processedNote = true;
cipher.notes = mappedData.notes;
}
}
if (!processedNote) {
cipher.secureNote = {
type: 0
};
cipher.notes = value.extra && value.extra !== '' ? value.extra : null;
}
}
else if (cipher.type === constants.cipherType.card) {
cipher.card = parseCard(value);
cipher.notes = value.notes && value.notes !== '' ? value.notes : null;
}
else if (cipher.type === constants.cipherType.identity) {
cipher.identity = {
title: value.title && value.title !== '' ? value.title : null,
firstName: value.firstname && value.firstname !== '' ? value.firstname : null,
middleName: value.middlename && value.middlename !== '' ? value.middlename : null,
lastName: value.lastname && value.lastname !== '' ? value.lastname : null,
username: value.username && value.username !== '' ? value.username : null,
company: value.company && value.company !== '' ? value.company : null,
ssn: value.ssn && value.ssn !== '' ? value.ssn : null,
address1: value.address1 && value.address1 !== '' ? value.address1 : null,
address2: value.address2 && value.address2 !== '' ? value.address2 : null,
address3: value.address3 && value.address3 !== '' ? value.address3 : null,
city: value.city && value.city !== '' ? value.city : null,
state: value.state && value.state !== '' ? value.state : null,
postalCode: value.zip && value.zip !== '' ? value.zip : null,
country: value.country && value.country !== '' ? value.country : null,
email: value.email && value.email !== '' ? value.email : null,
phone: value.phone && value.phone !== '' ? value.phone : null
};
cipher.notes = value.notes && value.notes !== '' ? value.notes : null;
if (cipher.identity.title) {
cipher.identity.title = cipher.identity.title.charAt(0).toUpperCase() +
cipher.identity.title.slice(1);
}
if (value.ccnum && value.ccnum !== '') {
// there is a card on this identity too
var cardCipher = JSON.parse(JSON.stringify(cipher)); // cloned
cardCipher.identity = null;
cardCipher.type = constants.cipherType.card;
cardCipher.card = parseCard(value);
ciphers.push(cardCipher);
}
}
ciphers.push(cipher);
if (addFolder) {
folders.push({
name: value.grouping
});
}
if (hasFolder) {
var relationship = {
key: cipherIndex,
value: folderIndex
};
cipherRelationships.push(relationship);
}
});
success(folders, ciphers, cipherRelationships);
}
}
function importSafeInCloudXml(file, success, error) {
var folders = [],
ciphers = [],
cipherRelationships = [],
foldersIndex = [],
i = 0,
j = 0;
getXmlFileContents(file, parse, error);
function parse(xmlDoc) {
var xml = $(xmlDoc);
var db = xml.find('database');
if (db.length) {
var labels = db.find('> label');
if (labels.length) {
for (i = 0; i < labels.length; i++) {
var label = $(labels[i]);
foldersIndex[label.attr('id')] = folders.length;
folders.push({
name: label.attr('name')
});
}
}
var cards = db.find('> card');
if (cards.length) {
for (i = 0; i < cards.length; i++) {
var card = $(cards[i]);
if (card.attr('template') === 'true') {
continue;
}
var cipher = {
favorite: false,
notes: '',
name: card.attr('title'),
fields: null
};
if (!cipher.name || cipher.name === '') {
cipher.name = '--';
}
if (card.attr('type') === 'note') {
cipher.type = constants.cipherType.secureNote;
cipher.secureNote = {
type: 0 // generic note
};
}
else {
cipher.type = constants.cipherType.login;
cipher.login = {};
var fields = card.find('> field');
for (j = 0; j < fields.length; j++) {
var field = $(fields[j]);
var text = field.text();
var type = field.attr('type');
var name = field.attr('name');
if (text && text !== '') {
if (type === 'login') {
cipher.login.username = text;
}
else if (type === 'password') {
cipher.login.password = text;
}
else if (type === 'notes') {
cipher.notes += (text + '\n');
}
else if (type === 'weblogin' || type === 'website') {
cipher.login.uris = makeUriArray(text);
}
else if (text.length > 200) {
cipher.notes += (name + ': ' + text + '\n');
}
else {
if (!cipher.fields) {
cipher.fields = [];
}
cipher.fields.push({
name: name,
value: text,
type: constants.fieldType.text
});
}
}
}
}
var notes = card.find('> notes');
for (j = 0; j < notes.length; j++) {
cipher.notes += ($(notes[j]).text() + '\n');
}
if (cipher.notes === '') {
cipher.notes = null;
}
ciphers.push(cipher);
labels = card.find('> label_id');
if (labels.length) {
var labelId = $(labels[0]).text();
var folderIndex = foldersIndex[labelId];
if (labelId !== null && labelId !== '' && folderIndex !== null) {
cipherRelationships.push({
key: ciphers.length - 1,
value: folderIndex
});
}
}
}
}
success(folders, ciphers, cipherRelationships);
}
else {
error();
}
}
}
function importPadlockCsv(file, success, error) {
Papa.parse(file, {
encoding: 'UTF-8',
complete: function (results) {
parseCsvErrors(results);
var folders = [],
ciphers = [],
folderRelationships = [];
var customFieldHeaders = [];
// CSV index ref: 0 = name, 1 = category, 2 = username, 3 = password, 4+ = custom fields
var i = 0,
j = 0;
for (i = 0; i < results.data.length; i++) {
var value = results.data[i];
if (i === 0) {
// header row
for (j = 4; j < value.length; j++) {
customFieldHeaders.push(value[j]);
}
continue;
}
var folderIndex = folders.length,
cipherIndex = ciphers.length,
hasFolder = value[1] && value[1] !== '',
addFolder = hasFolder;
if (hasFolder) {
for (j = 0; j < folders.length; j++) {
if (folders[j].name === value[1]) {
addFolder = false;
folderIndex = j;
break;
}
}
}
var cipher = {
favorite: false,
type: constants.cipherType.login,
notes: null,
name: value[0] && value[0] !== '' ? value[0] : '--',
login: {
uris: null,
username: value[2] && value[2] !== '' ? value[2] : null,
password: value[3] && value[3] !== '' ? value[3] : null
},
fields: null
};
if (customFieldHeaders.length) {
for (j = 4; j < value.length; j++) {
var cf = value[j];
if (!cf || cf === '') {
continue;
}
var cfHeader = customFieldHeaders[j - 4];
if (cfHeader.toLowerCase() === 'url' || cfHeader.toLowerCase() === 'uri') {
cipher.login.uris = makeUriArray(cf);
}
else {
if (!cipher.fields) {
cipher.fields = [];
}
cipher.fields.push({
name: cfHeader,
value: cf,
type: constants.fieldType.text
});
}
}
}
ciphers.push(cipher);
if (addFolder) {
folders.push({
name: value[1]
});
}
if (hasFolder) {
folderRelationships.push({
key: cipherIndex,
value: folderIndex
});
}
}
success(folders, ciphers, folderRelationships);
}
});
}
function importKeePass2Xml(file, success, error) {
var folders = [],
ciphers = [],
folderRelationships = [];
getXmlFileContents(file, parse, error);
function parse(xmlDoc) {
var xml = $(xmlDoc);
var root = xml.find('Root');
if (root.length) {
var group = root.find('> Group');
if (group.length) {
traverse($(group[0]), true, '');
success(folders, ciphers, folderRelationships);
}
}
else {
error();
}
}
function traverse(node, isRootNode, groupNamePrefix) {
var nodeEntries = [];
var folderIndex = folders.length;
var groupName = groupNamePrefix;
if (!isRootNode) {
if (groupName !== '') {
groupName += ' > ';
}
groupName += node.find('> Name').text();
folders.push({
name: groupName
});
}
var entries = node.find('> Entry');
if (entries.length) {
for (var i = 0; i < entries.length; i++) {
var entry = $(entries[i]);
var cipherIndex = ciphers.length;
var cipher = {
favorite: false,
notes: null,
name: null,
type: constants.cipherType.login,
login: {
uris: null,
username: null,
password: null
},
fields: null
};
var entryStrings = entry.find('> String');
for (var j = 0; j < entryStrings.length; j++) {
var entryString = $(entryStrings[j]);
var key = entryString.find('> Key').text();
var value = entryString.find('> Value').text();
if (value === '') {
continue;
}
switch (key) {
case 'URL':
cipher.login.uris = makeUriArray(value);
break;
case 'UserName':
cipher.login.username = value;
break;
case 'Password':
cipher.login.password = value;
break;
case 'Title':
cipher.name = value;
break;
case 'Notes':
cipher.notes = cipher.notes === null ? value + '\n' : cipher.notes + value + '\n';
break;
default:
if (value.length > 200 || value.indexOf('\n') > -1) {
if (!cipher.notes) {
cipher.notes = '';
}
cipher.notes += (key + ': ' + value + '\n');
}
else {
if (!cipher.fields) {
cipher.fields = [];
}
// other custom fields
cipher.fields.push({
name: key,
value: value,
type: constants.fieldType.text
});
}
break;
}
}
if (cipher.name === null) {
cipher.name = '--';
}
ciphers.push(cipher);
if (!isRootNode) {
folderRelationships.push({
key: cipherIndex,
value: folderIndex
});
}
}
}
var groups = node.find('> Group');
if (groups.length) {
for (var k = 0; k < groups.length; k++) {
traverse($(groups[k]), false, groupName);
}
}
}
}
function importKeePassXCsv(file, success, error) {
Papa.parse(file, {
header: true,
encoding: 'UTF-8',
complete: function (results) {
parseCsvErrors(results);
var folders = [],
ciphers = [],
folderRelationships = [];
angular.forEach(results.data, function (value, key) {
value.Group = value.Group.startsWith('Root/') ?
value.Group.replace('Root/', '') : value.Group;
var groupName = value.Group && value.Group !== '' ?
value.Group.split('/').join(' > ') : null;
var folderIndex = folders.length,
cipherIndex = ciphers.length,
hasFolder = groupName !== null,
addFolder = hasFolder,
i = 0;
if (hasFolder) {
for (i = 0; i < folders.length; i++) {
if (folders[i].name === groupName) {
addFolder = false;
folderIndex = i;
break;
}
}
}
var cipher = {
type: constants.cipherType.login,
favorite: false,
notes: value.Notes && value.Notes !== '' ? value.Notes : null,
name: value.Title && value.Title !== '' ? value.Title : '--',
login: {
uris: makeUriArray(value.URL),
username: value.Username && value.Username !== '' ? value.Username : null,
password: value.Password && value.Password !== '' ? value.Password : null
}
};
if (value.Title) {
ciphers.push(cipher);
}
if (addFolder) {
folders.push({
name: groupName
});
}
if (hasFolder) {
var relationship = {
key: cipherIndex,
value: folderIndex
};
folderRelationships.push(relationship);
}
});
success(folders, ciphers, folderRelationships);
}
});
}
function import1Password1Pif(file, success, error) {
var folders = [],
ciphers = [],
i = 0;
function parseFields(fields, cipher, designationKey, valueKey, nameKey) {
for (var j = 0; j < fields.length; j++) {
var field = fields[j];
if (!field[valueKey] || field[valueKey] === '') {
continue;
}
var fieldValue = field[valueKey].toString();
if (cipher.type == constants.cipherType.login && !cipher.login.username &&
field[designationKey] && field[designationKey] === 'username') {
cipher.login.username = fieldValue;
}
else if (cipher.type == constants.cipherType.login && !cipher.login.password &&
field[designationKey] && field[designationKey] === 'password') {
cipher.login.password = fieldValue;
}
else if (cipher.type == constants.cipherType.login && !cipher.login.totp &&
field[designationKey] && field[designationKey].startsWith("TOTP_")) {
cipher.login.totp = fieldValue;
}
else if (fieldValue) {
var fieldName = (field[nameKey] || 'no_name');
if (fieldValue.indexOf('\\n') > -1 || fieldValue.length > 200) {
if (cipher.notes === null) {
cipher.notes = '';
}
else {
cipher.notes += '\n';
}
cipher.notes += (fieldName + ': ' +
fieldValue.split('\\r\\n').join('\n').split('\\n').join('\n'));
}
else {
if (!cipher.fields) {
cipher.fields = [];
}
cipher.fields.push({
name: fieldName,
value: fieldValue,
type: constants.fieldType.text
});
}
}
}
}
getFileContents(file, parse, error);
function parse(fileContent) {
var fileLines = fileContent.split(/(?:\r\n|\r|\n)/);
for (i = 0; i < fileLines.length; i++) {
var line = fileLines[i];
if (!line.length || line[0] !== '{') {
continue;
}
var item = JSON.parse(line);
var cipher = {
type: constants.cipherType.login,
favorite: item.openContents && item.openContents.faveIndex ? true : false,
notes: null,
name: item.title && item.title !== '' ? item.title : '--',
fields: null
};
if (item.typeName === 'securenotes.SecureNote') {
cipher.type = constants.cipherType.secureNote;
cipher.secureNote = {
type: 0 // generic note
};
}
else {
cipher.type = constants.cipherType.login;
cipher.login = {
uris: makeUriArray(item.location),
username: null,
password: null,
totp: null
};
}
if (item.secureContents) {
if (item.secureContents.notesPlain && item.secureContents.notesPlain !== '') {
cipher.notes = item.secureContents.notesPlain
.split('\\r\\n').join('\n').split('\\n').join('\n');
}
if (item.secureContents.fields) {
parseFields(item.secureContents.fields, cipher, 'designation', 'value', 'name');
}
if (item.secureContents.sections) {
for (var j = 0; j < item.secureContents.sections.length; j++) {
if (item.secureContents.sections[j].fields) {
parseFields(item.secureContents.sections[j].fields, cipher, 'n', 'v', 't');
}
}
}
}
ciphers.push(cipher);
}
success(folders, ciphers, []);
}
}
function import1Password6WinCsv(file, success, error) {
var folders = [],
ciphers = [];
Papa.parse(file, {
encoding: 'UTF-8',
header: true,
complete: function (results) {
parseCsvErrors(results);
for (var i = 0; i < results.data.length; i++) {
var value = results.data[i];
if (!value.title) {
continue;
}
var cipher = {
type: constants.cipherType.login,
favorite: false,
notes: value.notesPlain && value.notesPlain !== '' ? value.notesPlain : '',
name: value.title && value.title !== '' ? value.title : '--',
login: {
uris: null,
username: null,
password: null
}
};
for (var property in value) {
if (value.hasOwnProperty(property)) {
if (value[property] === null || value[property] === '') {
continue;
}
if (!cipher.login.password && property === 'password') {
cipher.login.password = value[property];
}
else if (!cipher.login.username && property === 'username') {
cipher.login.username = value[property];
}
else if (!cipher.login.uris && property === 'urls') {
var urls = value[property].split(/(?:\r\n|\r|\n)/);
cipher.login.uris = makeUriArray(urls);
}
else if (property !== 'ainfo' && property !== 'autosubmit' && property !== 'notesPlain' &&
property !== 'ps' && property !== 'scope' && property !== 'tags' && property !== 'title' &&
property !== 'uuid' && !property.startsWith('section:')) {
if (cipher.notes !== '') {
cipher.notes += '\n';
}
cipher.notes += (property + ': ' + value[property]);
}
}
}
if (cipher.notes === '') {
cipher.notes = null;
}
ciphers.push(cipher);
}
success(folders, ciphers, []);
}
});
}
function importChromeCsv(file, success, error) {
Papa.parse(file, {
header: true,
encoding: 'UTF-8',
complete: function (results) {
parseCsvErrors(results);
var folders = [],
ciphers = [];
angular.forEach(results.data, function (value, key) {
ciphers.push({
type: constants.cipherType.login,
favorite: false,
notes: null,
name: value.name && value.name !== '' ? value.name : '--',
login: {
uris: makeUriArray(value.url),
username: value.username && value.username !== '' ? value.username : null,
password: value.password && value.password !== '' ? value.password : null
}
});
});
success(folders, ciphers, []);
}
});
}
function importFirefoxPasswordExporterCsv(file, success, error) {
Papa.parse(file, {
header: true,
encoding: 'UTF-8',
complete: function (results) {
parseCsvErrors(results);
var folders = [],
ciphers = [];
angular.forEach(results.data, function (value, key) {
ciphers.push({
type: constants.cipherType.login,
favorite: false,
notes: null,
name: value.hostname && value.hostname !== '' ? loginNameFromUrl(value.hostname) : '--',
login: {
uris: makeUriArray(value.hostname),
username: value.username && value.username !== '' ? value.username : null,
password: value.password && value.password !== '' ? value.password : null
}
});
});
success(folders, ciphers, []);
}
});
}
function importUpmCsv(file, success, error) {
Papa.parse(file, {
encoding: 'UTF-8',
complete: function (results) {
parseCsvErrors(results);
var folders = [],
ciphers = [];
angular.forEach(results.data, function (value, key) {
if (value.length === 5) {
ciphers.push({
type: constants.cipherType.login,
favorite: false,
notes: value[4] && value[4] !== '' ? value[4] : null,
name: value[0] && value[0] !== '' ? value[0] : '--',
login: {
uris: makeUriArray(value[3]),
username: value[1] && value[1] !== '' ? value[1] : null,
password: value[2] && value[2] !== '' ? value[2] : null
}
});
}
});
success(folders, ciphers, []);
}
});
}
function importKeeperCsv(file, success, error) {
Papa.parse(file, {
encoding: 'UTF-8',
complete: function (results) {
parseCsvErrors(results);
var folders = [],
ciphers = [],
folderRelationships = [];
angular.forEach(results.data, function (value, key) {
if (value.length >= 6) {
var folderIndex = folders.length,
cipherIndex = ciphers.length,
hasFolder = value[0] && value[0] !== '',
addFolder = hasFolder,
i = 0;
if (hasFolder) {
for (i = 0; i < folders.length; i++) {
if (folders[i].name === value[0]) {
addFolder = false;
folderIndex = i;
break;
}
}
}
var cipher = {
type: constants.cipherType.login,
favorite: false,
notes: value[5] && value[5] !== '' ? value[5] : null,
name: value[1] && value[1] !== '' ? value[1] : '--',
login: {
uris: makeUriArray(value[4]),
username: value[2] && value[2] !== '' ? value[2] : null,
password: value[3] && value[3] !== '' ? value[3] : null
},
fields: null
};
if (value.length > 6) {
// we have some custom fields.
for (i = 6; i < value.length; i = i + 2) {
if (value[i + 1] && value[i + 1].length > 200) {
if (!cipher.notes) {
cipher.notes = '';
}
cipher.notes += (value[i] + ': ' + value[i + 1] + '\n');
}
else {
if (!cipher.fields) {
cipher.fields = [];
}
cipher.fields.push({
name: value[i],
value: value[i + 1],
type: constants.fieldType.text
});
}
}
}
ciphers.push(cipher);
if (addFolder) {
folders.push({
name: value[0]
});
}
if (hasFolder) {
var relationship = {
key: cipherIndex,
value: folderIndex
};
folderRelationships.push(relationship);
}
}
});
success(folders, ciphers, folderRelationships);
}
});
}
function importPasswordDragonXml(file, success, error) {
var folders = [],
ciphers = [],
folderRelationships = [],
foldersIndex = [],
j = 0;
getXmlFileContents(file, parseXml, error);
function parseXml(xmlDoc) {
var xml = $(xmlDoc);
var pwManager = xml.find('PasswordManager');
if (pwManager.length) {
var records = pwManager.find('> record');
if (records.length) {
for (var i = 0; i < records.length; i++) {
var record = $(records[i]);
var accountNameNode = record.find('> Account-Name'),
accountName = accountNameNode.length ? $(accountNameNode) : null,
userIdNode = record.find('> User-Id'),
userId = userIdNode.length ? $(userIdNode) : null,
passwordNode = record.find('> Password'),
password = passwordNode.length ? $(passwordNode) : null,
urlNode = record.find('> URL'),
url = urlNode.length ? $(urlNode) : null,
notesNode = record.find('> Notes'),
notes = notesNode.length ? $(notesNode) : null,
categoryNode = record.find('> Category'),
category = categoryNode.length ? $(categoryNode) : null,
categoryText = category ? category.text() : null;
var folderIndex = folders.length,
cipherIndex = ciphers.length,
hasFolder = categoryText && categoryText !== '' && categoryText !== 'Unfiled',
addFolder = hasFolder;
if (hasFolder) {
for (j = 0; j < folders.length; j++) {
if (folders[j].name === categoryText) {
addFolder = false;
folderIndex = j;
break;
}
}
}
var cipher = {
type: constants.cipherType.login,
favorite: false,
notes: notes && notes.text() !== '' ? notes.text() : null,
name: accountName && accountName.text() !== '' ? accountName.text() : '--',
login: {
uris: url ? makeUriArray(url.text()) : null,
username: userId && userId.text() !== '' ? userId.text() : null,
password: password && password.text() !== '' ? password.text() : null
},
fields: null
};
var attributesSelector = '';
for (j = 1; j <= 10; j++) {
attributesSelector += '> Attribute-' + j;
if (j < 10) {
attributesSelector += ', ';
}
}
var attributes = record.find(attributesSelector);
if (attributes.length) {
// we have some attributes. add them as fields
for (j = 0; j < attributes.length; j++) {
var attr = $(attributes[j]),
attrName = attr.prop('tagName'),
attrValue = attr.text();
if (!attrValue || attrValue === '' || attrValue === 'null') {
continue;
}
if (attrValue.length > 200) {
if (!cipher.notes) {
cipher.notes = '';
}
cipher.notes += (attrName + ': ' + attrValue + '\n');
}
else {
if (!cipher.fields) {
cipher.fields = [];
}
cipher.fields.push({
name: attrName,
value: attrValue,
type: constants.fieldType.text
});
}
}
}
ciphers.push(cipher);
if (addFolder) {
folders.push({
name: categoryText
});
}
if (hasFolder) {
var relationship = {
key: cipherIndex,
value: folderIndex
};
folderRelationships.push(relationship);
}
}
}
success(folders, ciphers, folderRelationships);
}
else {
error();
}
}
}
function importEnpassCsv(file, success, error) {
Papa.parse(file, {
encoding: 'UTF-8',
complete: function (results) {
parseCsvErrors(results);
var folders = [],
ciphers = [];
for (var j = 0; j < results.data.length; j++) {
var row = results.data[j];
if (row.length < 2) {
continue;
}
if (j === 0 && row[0] === 'Title') {
continue;
}
var note = row[row.length - 1];
var cipher = {
type: constants.cipherType.login,
name: row[0],
favorite: false,
notes: note && note !== '' ? note : null,
fields: null,
login: {
uris: null,
password: null,
username: null,
totp: null
}
};
if (row.length > 2 && (row.length % 2) === 0) {
for (var i = 0; i < row.length - 2; i += 2) {
var value = row[i + 2];
if (!value || value === '') {
continue;
}
var field = row[i + 1];
var fieldLower = field.toLowerCase();
if (fieldLower === 'url' && !cipher.login.uris) {
cipher.login.uris = makeUriArray(value);
}
else if ((fieldLower === 'username' || fieldLower === 'email') && !cipher.login.username) {
cipher.login.username = value;
}
else if (fieldLower === 'password' && !cipher.login.password) {
cipher.login.password = value;
}
else if (fieldLower === 'totp' && !cipher.login.totp) {
cipher.login.totp = value;
}
else if (value.length > 200) {
if (!cipher.notes) {
cipher.notes = '';
}
cipher.notes += (field + ': ' + value + '\n');
}
else {
// other fields
if (!cipher.fields) {
cipher.fields = [];
}
cipher.fields.push({
name: field,
value: value,
type: constants.fieldType.text
});
}
}
}
ciphers.push(cipher);
}
success(folders, ciphers, []);
}
});
}
function importPasswordSafeXml(file, success, error) {
var folders = [],
ciphers = [],
folderRelationships = [],
foldersIndex = [],
j = 0;
getXmlFileContents(file, parseXml, error);
function parseXml(xmlDoc) {
var xml = $(xmlDoc);
var pwsafe = xml.find('passwordsafe');
if (pwsafe.length) {
var notesDelimiter = pwsafe.attr('delimiter');
var entries = pwsafe.find('> entry');
if (entries.length) {
for (var i = 0; i < entries.length; i++) {
var entry = $(entries[i]);
var titleNode = entry.find('> title'),
title = titleNode.length ? $(titleNode) : null,
usernameNode = entry.find('> username'),
username = usernameNode.length ? $(usernameNode) : null,
emailNode = entry.find('> email'),
email = emailNode.length ? $(emailNode) : null,
emailText = email ? email.text() : null,
passwordNode = entry.find('> password'),
password = passwordNode.length ? $(passwordNode) : null,
urlNode = entry.find('> url'),
url = urlNode.length ? $(urlNode) : null,
notesNode = entry.find('> notes'),
notes = notesNode.length ? $(notesNode) : null,
notesText = notes ? notes.text().split(notesDelimiter).join('\n') : null,
groupNode = entry.find('> group'),
group = groupNode.length ? $(groupNode) : null,
groupText = group ? group.text().split('.').join(' > ') : null;
var folderIndex = folders.length,
cipherIndex = ciphers.length,
hasFolder = groupText && groupText !== '',
addFolder = hasFolder;
if (hasFolder) {
for (j = 0; j < folders.length; j++) {
if (folders[j].name === groupText) {
addFolder = false;
folderIndex = j;
break;
}
}
}
var cipher = {
type: constants.cipherType.login,
favorite: false,
notes: notes && notesText !== '' ? notesText : null,
name: title && title.text() !== '' ? title.text() : '--',
login: {
uris: url ? makeUriArray(url.text()) : null,
username: username && username.text() !== '' ? username.text() : null,
password: password && password.text() !== '' ? password.text() : null
}
};
if (!cipher.login.username && emailText && emailText !== '') {
cipher.login.username = emailText;
}
else if (emailText && emailText !== '') {
cipher.notes = cipher.notes === null ? 'Email: ' + emailText
: cipher.notes + '\n' + 'Email: ' + emailText;
}
ciphers.push(cipher);
if (addFolder) {
folders.push({
name: groupText
});
}
if (hasFolder) {
var relationship = {
key: cipherIndex,
value: folderIndex
};
folderRelationships.push(relationship);
}
}
}
success(folders, ciphers, folderRelationships);
}
else {
error();
}
}
}
function importDashlaneCsv(file, success, error) {
Papa.parse(file, {
encoding: 'UTF-8',
complete: function (results) {
parseCsvErrors(results);
var folders = [],
ciphers = [];
for (var j = 0; j < results.data.length; j++) {
var skip = false;
var row = results.data[j];
if (!row.length || row.length === 1) {
continue;
}
var cipher = {
type: constants.cipherType.login,
name: row[0] && row[0] !== '' ? row[0] : '--',
favorite: false,
notes: null,
login: {
uris: null,
password: null,
username: null
}
};
if (row.length === 2) {
cipher.login.uris = makeUriArray(row[1]);
}
else if (row.length === 3) {
cipher.login.uris = makeUriArray(row[1]);
cipher.login.username = row[2];
}
else if (row.length === 4) {
if (row[2] === '' && row[3] === '') {
cipher.login.username = row[1];
cipher.notes = row[2] + '\n' + row[3];
}
else {
cipher.login.username = row[2];
cipher.notes = row[1] + '\n' + row[3];
}
}
else if (row.length === 5) {
cipher.login.uris = makeUriArray(row[1]);
cipher.login.username = row[2];
cipher.login.password = row[3];
cipher.notes = row[4];
}
else if (row.length === 6) {
if (row[2] === '') {
cipher.login.username = row[3];
cipher.login.password = row[4];
cipher.notes = row[5];
}
else {
cipher.login.username = row[2];
cipher.login.password = row[3];
cipher.notes = row[4] + '\n' + row[5];
}
cipher.login.uris = makeUriArray(row[1]);
}
else if (row.length === 7) {
if (row[2] === '') {
cipher.login.username = row[3];
cipher.notes = row[4] + '\n' + row[6];
}
else {
cipher.login.username = row[2];
cipher.notes = row[3] + '\n' + row[4] + '\n' + row[6];
}
cipher.login.uris = makeUriArray(row[1]);
cipher.login.password = row[5];
}
else {
cipher.notes = '';
for (var i = 1; i < row.length; i++) {
cipher.notes = cipher.notes + row[i] + '\n';
if (row[i] === 'NO_TYPE') {
skip = true;
break;
}
}
}
if (skip) {
continue;
}
if (cipher.login.username === '') {
cipher.login.username = null;
}
if (cipher.login.password === '') {
cipher.login.password = null;
}
if (cipher.notes === '') {
cipher.notes = null;
}
ciphers.push(cipher);
}
success(folders, ciphers, []);
}
});
}
function importStickyPasswordXml(file, success, error) {
var folders = [],
ciphers = [],
folderRelationships = [],
foldersIndex = [],
j = 0;
function buildGroupText(database, groupId, groupText) {
var group = database.find('> Groups > Group[ID="' + groupId + '"]');
if (group.length) {
if (groupText && groupText !== '') {
groupText = ' > ' + groupText;
}
groupText = group.attr('Name') + groupText;
var parentGroupId = group.attr('ParentID');
return buildGroupText(database, parentGroupId, groupText);
}
return groupText;
}
getXmlFileContents(file, parseXml, error);
function parseXml(xmlDoc) {
var xml = $(xmlDoc);
var database = xml.find('root > Database');
if (database.length) {
var loginNodes = database.find('> Logins > Login');
if (loginNodes.length) {
for (var i = 0; i < loginNodes.length; i++) {
var loginNode = $(loginNodes[i]);
var usernameText = loginNode.attr('Name'),
passwordText = loginNode.attr('Password'),
accountId = loginNode.attr('ID'),
titleText = null,
linkText = null,
notesText = null,
groupId = null,
groupText = null;
if (accountId && accountId !== '') {
var accountLogin =
database.find('> Accounts > Account > LoginLinks > Login[SourceLoginID="' + accountId + '"]');
if (accountLogin.length) {
var account = accountLogin.parent().parent();
if (account.length) {
titleText = account.attr('Name');
linkText = account.attr('Link');
groupId = account.attr('ParentID');
notesText = account.attr('Comments');
if (notesText) {
notesText = notesText.split('/n').join('\n');
}
}
}
}
if (groupId && groupId !== '') {
groupText = buildGroupText(database, groupId, '');
}
var folderIndex = folders.length,
cipherIndex = ciphers.length,
hasFolder = groupText && groupText !== '',
addFolder = hasFolder;
if (hasFolder) {
for (j = 0; j < folders.length; j++) {
if (folders[j].name === groupText) {
addFolder = false;
folderIndex = j;
break;
}
}
}
var cipher = {
type: constants.cipherType.login,
favorite: false,
notes: notesText && notesText !== '' ? notesText : null,
name: titleText && titleText !== '' ? titleText : '--',
login: {
uris: makeUriArray(linkText),
username: usernameText && usernameText !== '' ? usernameText : null,
password: passwordText && passwordText !== '' ? passwordText : null
}
};
ciphers.push(cipher);
if (addFolder) {
folders.push({
name: groupText
});
}
if (hasFolder) {
var relationship = {
key: cipherIndex,
value: folderIndex
};
folderRelationships.push(relationship);
}
}
}
success(folders, ciphers, folderRelationships);
}
else {
error();
}
}
}
function importmSecureCsv(file, success, error) {
Papa.parse(file, {
encoding: 'UTF-8',
complete: function (results) {
parseCsvErrors(results);
var folders = [],
ciphers = [],
folderRelationships = [];
angular.forEach(results.data, function (value, key) {
if (value.length >= 3) {
var folderIndex = folders.length,
cipherIndex = ciphers.length,
hasFolder = value[0] && value[0] !== '' && value[0] !== 'Unassigned',
addFolder = hasFolder,
i = 0;
if (hasFolder) {
for (i = 0; i < folders.length; i++) {
if (folders[i].name === value[0]) {
addFolder = false;
folderIndex = i;
break;
}
}
}
var cipher = {
type: constants.cipherType.login,
favorite: false,
notes: '',
name: value[2] && value[2] !== '' ? value[2] : null,
login: {
uris: null,
username: null,
password: null
}
};
if (value[1] === 'Web Logins') {
cipher.login.uris = makeUriArray(value[4]);
cipher.login.username = value[5] && value[5] !== '' ? value[5] : null;
cipher.login.password = value[6] && value[6] !== '' ? value[6] : null;
cipher.notes = value[3] && value[3] !== '' ? value[3].split('\\n').join('\n') : null;
}
else if (value.length > 3) {
for (var j = 3; j < value.length; j++) {
if (value[j] && value[j] !== '') {
if (cipher.notes !== '') {
cipher.notes = cipher.notes + '\n';
}
cipher.notes = cipher.notes + value[j];
}
}
}
if (value[1] && value[1] !== '' && value[1] !== 'Web Logins') {
cipher.name = value[1] + ': ' + cipher.name;
}
if (cipher.notes === '') {
cipher.notes = null;
}
ciphers.push(cipher);
if (addFolder) {
folders.push({
name: value[0]
});
}
if (hasFolder) {
var relationship = {
key: cipherIndex,
value: folderIndex
};
folderRelationships.push(relationship);
}
}
});
success(folders, ciphers, folderRelationships);
}
});
}
function importTrueKeyCsv(file, success, error) {
var folders = [],
ciphers = [],
propsToIgnore = [
'kind',
'autologin',
'favorite',
'hexcolor',
'protectedwithpassword',
'subdomainonly',
'type',
'tk_export_version',
'note',
'title',
'document_content'
];
Papa.parse(file, {
header: true,
encoding: 'UTF-8',
complete: function (results) {
parseCsvErrors(results);
angular.forEach(results.data, function (value, key) {
var cipher = {
type: constants.cipherType.login,
favorite: value.favorite && value.favorite.toLowerCase() === 'true' ? true : false,
notes: value.memo && value.memo !== '' ? value.memo : null,
name: value.name && value.name !== '' ? value.name : '--',
login: {
uris: makeUriArray(value.url),
username: value.login && value.login !== '' ? value.login : null,
password: value.password && value.password !== '' ? value.password : null
},
fields: null
};
if (value.kind !== 'login') {
cipher.name = value.title && value.title !== '' ? value.title : '--';
cipher.notes = value.note && value.note !== '' ? value.note : null;
if (!cipher.notes) {
cipher.notes = value.document_content && value.document_content !== '' ?
value.document_content : null;
}
for (var property in value) {
if (value.hasOwnProperty(property) && propsToIgnore.indexOf(property.toLowerCase()) < 0 &&
value[property] && value[property] !== '') {
if (value[property].length > 200) {
if (!cipher.notes) {
cipher.notes = '';
}
cipher.notes += (property + ': ' + value[property] + '\n');
}
else {
if (!cipher.fields) {
cipher.fields = [];
}
// other custom fields
cipher.fields.push({
name: property,
value: value[property],
type: constants.fieldType.text
});
}
}
}
}
ciphers.push(cipher);
});
success(folders, ciphers, []);
}
});
}
function importClipperzHtml(file, success, error) {
var folders = [],
ciphers = [];
getFileContents(file, parse, error);
function parse(fileContents) {
var doc = $(fileContents);
var textarea = doc.find('textarea');
var json = textarea && textarea.length ? textarea.val() : null;
var entries = json ? JSON.parse(json) : null;
if (entries && entries.length) {
for (var i = 0; i < entries.length; i++) {
var entry = entries[i];
var cipher = {
type: constants.cipherType.login,
favorite: false,
notes: '',
name: entry.label && entry.label !== '' ? entry.label.split(' ')[0] : '--',
login: {
uris: null,
username: null,
password: null
},
fields: null
};
if (entry.data && entry.data.notes && entry.data.notes !== '') {
cipher.notes = entry.data.notes.split('\\n').join('\n');
}
if (entry.currentVersion && entry.currentVersion.fields) {
for (var property in entry.currentVersion.fields) {
if (entry.currentVersion.fields.hasOwnProperty(property)) {
var field = entry.currentVersion.fields[property];
var actionType = field.actionType.toLowerCase();
switch (actionType) {
case 'password':
cipher.login.password = field.value;
break;
case 'email':
case 'username':
case 'user':
case 'name':
cipher.login.username = field.value;
break;
case 'url':
cipher.login.uris = makeUriArray(field.value);
break;
default:
if (!cipher.login.username && isField(field.label, _usernameFieldNames)) {
cipher.login.username = field.value;
}
else if (!cipher.login.password && isField(field.label, _passwordFieldNames)) {
cipher.login.password = field.value;
}
else if (field.value.length > 200) {
if (!cipher.notes) {
cipher.notes = '';
}
cipher.notes += (field.label + ': ' + field.value + '\n');
}
else {
if (!cipher.fields) {
cipher.fields = [];
}
cipher.fields.push({
name: field.label,
value: field.value,
type: constants.fieldType.text
});
}
break;
}
}
}
}
if (cipher.notes === '') {
cipher.notes = null;
}
ciphers.push(cipher);
}
}
success(folders, ciphers, []);
}
}
function importAviraJson(file, success, error) {
var folders = [],
ciphers = [],
i = 0;
getFileContents(file, parseJson, error);
function parseJson(fileContent) {
var fileJson = JSON.parse(fileContent);
if (fileJson) {
if (fileJson.accounts) {
for (i = 0; i < fileJson.accounts.length; i++) {
var account = fileJson.accounts[i];
var cipher = {
type: constants.cipherType.login,
favorite: account.is_favorite && account.is_favorite === true,
notes: null,
name: account.label && account.label !== '' ? account.label : account.domain,
login: {
uris: makeUriArray(account.domain),
username: account.username && account.username !== '' ? account.username : null,
password: account.password && account.password !== '' ? account.password : null
}
};
if (account.email && account.email !== '') {
if (!cipher.login.username || cipher.login.username === '') {
cipher.login.username = account.email;
}
else {
cipher.notes = account.email;
}
}
if (!cipher.name || cipher.name === '') {
cipher.name = '--';
}
ciphers.push(cipher);
}
}
}
success(folders, ciphers, []);
}
}
function importRoboFormHtml(file, success, error) {
var folders = [],
ciphers = [];
getFileContents(file, parse, error);
function parse(fileContents) {
var doc = $(fileContents.split('').join('').split('Bitwarden two-step login recovery code:
' + '' + $scope.code + '' +
'' + new Date() + '
'); w.print(); w.close(); }; function formatString(s) { if (!s) { return null; } return s.replace(/(.{4})/g, '$1 ').trim().toUpperCase(); } $scope.close = function () { $uibModalInstance.close(); }; }]); angular .module('bit.settings') .controller('settingsTwoStepU2fController', ["$scope", "apiService", "$uibModalInstance", "cryptoService", "authService", "toastr", "$analytics", "constants", "$timeout", "$window", function ($scope, apiService, $uibModalInstance, cryptoService, authService, toastr, $analytics, constants, $timeout, $window) { $analytics.eventTrack('settingsTwoStepU2fController', { category: 'Modal' }); var _masterPasswordHash; var closed = false; $scope.deviceResponse = null; $scope.deviceListening = false; $scope.deviceError = false; $timeout(function () { $("#masterPassword").focus(); }); $scope.auth = function (model) { $scope.authPromise = cryptoService.hashPassword(model.masterPassword).then(function (hash) { _masterPasswordHash = hash; return apiService.twoFactor.getU2f({}, { masterPasswordHash: _masterPasswordHash }).$promise; }).then(function (response) { $scope.enabled = response.Enabled; $scope.challenge = response.Challenge; $scope.authed = true; return $scope.readDevice(); }); }; $scope.readDevice = function () { if (closed || $scope.enabled) { return; } console.log('listening for key...'); $scope.deviceResponse = null; $scope.deviceError = false; $scope.deviceListening = true; $window.u2f.register($scope.challenge.AppId, [{ version: $scope.challenge.Version, challenge: $scope.challenge.Challenge }], [], function (data) { $scope.deviceListening = false; if (data.errorCode === 5) { $scope.readDevice(); return; } else if (data.errorCode) { $timeout(function () { $scope.deviceError = true; }); console.log('error: ' + data.errorCode); return; } $timeout(function () { $scope.deviceResponse = JSON.stringify(data); }); }, 10); }; $scope.submit = function () { if ($scope.enabled) { disable(); return; } update(); }; function disable() { if (!confirm('Are you sure you want to disable the U2F provider?')) { return; } $scope.submitPromise = apiService.twoFactor.disable({}, { masterPasswordHash: _masterPasswordHash, type: constants.twoFactorProvider.u2f }, function (response) { $analytics.eventTrack('Disabled Two-step U2F'); toastr.success('U2F has been disabled.'); $scope.enabled = response.Enabled; $scope.close(); }).$promise; } function update() { $scope.submitPromise = apiService.twoFactor.putU2f({}, { deviceResponse: $scope.deviceResponse, masterPasswordHash: _masterPasswordHash }, function (response) { $analytics.eventTrack('Enabled Two-step U2F'); $scope.enabled = response.Enabled; $scope.challenge = null; $scope.deviceResponse = null; $scope.deviceError = false; }).$promise; } $scope.close = function () { closed = true; $uibModalInstance.close($scope.enabled); }; $scope.$on('modal.closing', function (e, reason, isClosed) { if (closed) { return; } e.preventDefault(); $scope.close(); }); }]); angular .module('bit.settings') .controller('settingsTwoStepYubiController', ["$scope", "apiService", "$uibModalInstance", "cryptoService", "authService", "toastr", "$analytics", "constants", "$timeout", function ($scope, apiService, $uibModalInstance, cryptoService, authService, toastr, $analytics, constants, $timeout) { $analytics.eventTrack('settingsTwoStepYubiController', { category: 'Modal' }); var _profile = null, _masterPasswordHash; $timeout(function () { $("#masterPassword").focus(); }); $scope.auth = function (model) { var response = null; $scope.authPromise = cryptoService.hashPassword(model.masterPassword).then(function (hash) { _masterPasswordHash = hash; return apiService.twoFactor.getYubi({}, { masterPasswordHash: _masterPasswordHash }).$promise; }).then(function (apiResponse) { response = apiResponse; return authService.getUserProfile(); }).then(function (profile) { _profile = profile; processResult(response); $scope.authed = true; }); }; $scope.remove = function (model) { model.key = null; model.existingKey = null; }; $scope.submit = function (model) { $scope.submitPromise = apiService.twoFactor.putYubi({}, { key1: model.key1.key, key2: model.key2.key, key3: model.key3.key, nfc: model.nfc, masterPasswordHash: _masterPasswordHash }, function (response) { $analytics.eventTrack('Saved Two-step YubiKey'); toastr.success('YubiKey saved.'); processResult(response); }).$promise; }; $scope.disable = function () { if (!confirm('Are you sure you want to disable the YubiKey provider?')) { return; } $scope.disableLoading = true; $scope.submitPromise = apiService.twoFactor.disable({}, { masterPasswordHash: _masterPasswordHash, type: constants.twoFactorProvider.yubikey }, function (response) { $scope.disableLoading = false; $analytics.eventTrack('Disabled Two-step YubiKey'); toastr.success('YubiKey has been disabled.'); $scope.enabled = response.Enabled; $scope.close(); }, function (response) { toastr.error('Failed to disable.'); $scope.disableLoading = false; }).$promise; }; function processResult(response) { $scope.enabled = response.Enabled; $scope.updateModel = { key1: { key: response.Key1, existingKey: padRight(response.Key1, '*', 44) }, key2: { key: response.Key2, existingKey: padRight(response.Key2, '*', 44) }, key3: { key: response.Key3, existingKey: padRight(response.Key3, '*', 44) }, nfc: response.Nfc === true || !response.Enabled }; } function padRight(str, character, size) { if (!str || !character || str.length >= size) { return str; } var max = (size - str.length) / character.length; for (var i = 0; i < max; i++) { str += character; } return str; } var closing = false; $scope.close = function () { closing = true; $uibModalInstance.close($scope.enabled); }; $scope.$on('modal.closing', function (e, reason, closed) { if (closing) { return; } e.preventDefault(); $scope.close(); }); }]); angular .module('bit.settings') .controller('settingsUpdateKeyController', ["$scope", "$state", "apiService", "$uibModalInstance", "cipherService", "cryptoService", "authService", "validationService", "toastr", "$analytics", "$q", function ($scope, $state, apiService, $uibModalInstance, cipherService, cryptoService, authService, validationService, toastr, $analytics, $q) { $analytics.eventTrack('settingsUpdateKeyController', { category: 'Modal' }); $scope.save = function (form) { var encKey = cryptoService.getEncKey(); if (encKey) { validationService.addError(form, 'MasterPasswordHash', 'You do not need to update. You are already using the new encryption key.', true); return; } $scope.savePromise = cryptoService.hashPassword($scope.masterPassword).then(function (hash) { return updateKey(hash); }).then(function () { $uibModalInstance.dismiss('cancel'); authService.logOut(); $analytics.eventTrack('Key Updated'); return $state.go('frontend.login.info'); }, function (e) { throw e ? e : 'Error occurred.'; }).then(function () { toastr.success('Please log back in. If you are using other Bitwarden applications, ' + 'log out and back in to those as well.', 'Key Updated', { timeOut: 10000 }); }); }; function updateKey(masterPasswordHash) { var madeEncKey = cryptoService.makeEncKey(null); var reencryptedCiphers = []; var ciphersPromise = apiService.ciphers.list({}, function (encryptedCiphers) { var filteredEncryptedCiphers = []; for (var i = 0; i < encryptedCiphers.Data.length; i++) { if (encryptedCiphers.Data[i].OrganizationId) { continue; } filteredEncryptedCiphers.push(encryptedCiphers.Data[i]); } var unencryptedCiphers = cipherService.decryptCiphers(filteredEncryptedCiphers); reencryptedCiphers = cipherService.encryptCiphers(unencryptedCiphers, madeEncKey.encKey); }).$promise; var reencryptedFolders = []; var foldersPromise = apiService.folders.list({}, function (encryptedFolders) { var unencryptedFolders = cipherService.decryptFolders(encryptedFolders.Data); reencryptedFolders = cipherService.encryptFolders(unencryptedFolders, madeEncKey.encKey); }).$promise; var privateKey = cryptoService.getPrivateKey('raw'), reencryptedPrivateKey = null; if (privateKey) { reencryptedPrivateKey = cryptoService.encrypt(privateKey, madeEncKey.encKey, 'raw'); } return $q.all([ciphersPromise, foldersPromise]).then(function () { var request = { masterPasswordHash: masterPasswordHash, ciphers: reencryptedCiphers, folders: reencryptedFolders, privateKey: reencryptedPrivateKey, key: madeEncKey.encKeyEnc }; return apiService.accounts.putKey(request).$promise; }, function () { throw 'Error while encrypting data.'; }).then(function () { cryptoService.setEncKey(madeEncKey.encKey, null, true); }); } $scope.close = function () { $uibModalInstance.dismiss('cancel'); }; }]); angular .module('bit.vault') .controller('vaultAddCipherController', ["$scope", "apiService", "$uibModalInstance", "cryptoService", "cipherService", "passwordService", "selectedFolder", "$analytics", "checkedFavorite", "$rootScope", "authService", "$uibModal", "constants", "$filter", "selectedType", function ($scope, apiService, $uibModalInstance, cryptoService, cipherService, passwordService, selectedFolder, $analytics, checkedFavorite, $rootScope, authService, $uibModal, constants, $filter, selectedType) { $analytics.eventTrack('vaultAddCipherController', { category: 'Modal' }); $scope.folders = $rootScope.vaultFolders; $scope.constants = constants; $scope.selectedType = selectedType ? selectedType.toString() : constants.cipherType.login.toString(); $scope.cipher = { folderId: selectedFolder ? selectedFolder.id : null, favorite: checkedFavorite === true, type: selectedType || constants.cipherType.login, login: { uris: [{ uri: null, match: null, matchValue: null }] }, identity: {}, card: {}, secureNote: { type: 0 } }; authService.getUserProfile().then(function (profile) { $scope.useTotp = profile.premium; }); $scope.typeChanged = function () { $scope.cipher.type = parseInt($scope.selectedType); }; $scope.savePromise = null; $scope.save = function () { if ($scope.cipher.type === constants.cipherType.login && $scope.cipher.login.uris.length === 1 && ($scope.cipher.login.uris[0].uri == null || $scope.cipher.login.uris[0].uri === '')) { $scope.cipher.login.uris = null; } var cipher = cipherService.encryptCipher($scope.cipher); $scope.savePromise = apiService.ciphers.post(cipher, function (cipherResponse) { $analytics.eventTrack('Created Cipher'); var decCipher = cipherService.decryptCipherPreview(cipherResponse); $uibModalInstance.close(decCipher); }).$promise; }; $scope.generatePassword = function () { if (!$scope.cipher.login.password || confirm('Are you sure you want to overwrite the current password?')) { $analytics.eventTrack('Generated Password From Add'); $scope.cipher.login.password = passwordService.generatePassword({ length: 14, special: true }); } }; $scope.addUri = function () { if (!$scope.cipher.login) { return; } if (!$scope.cipher.login.uris) { $scope.cipher.login.uris = []; } $scope.cipher.login.uris.push({ uri: null, match: null, matchValue: null }); }; $scope.removeUri = function (uri) { if (!$scope.cipher.login || !$scope.cipher.login.uris) { return; } var index = $scope.cipher.login.uris.indexOf(uri); if (index > -1) { $scope.cipher.login.uris.splice(index, 1); } }; $scope.uriMatchChanged = function (uri) { if ((!uri.matchValue && uri.matchValue !== 0) || uri.matchValue === '') { uri.match = null; } else { uri.match = parseInt(uri.matchValue); } }; $scope.addField = function () { if (!$scope.cipher.fields) { $scope.cipher.fields = []; } $scope.cipher.fields.push({ type: constants.fieldType.text.toString(), name: null, value: null }); }; $scope.removeField = function (field) { var index = $scope.cipher.fields.indexOf(field); if (index > -1) { $scope.cipher.fields.splice(index, 1); } }; $scope.toggleFavorite = function () { $scope.cipher.favorite = !$scope.cipher.favorite; }; $scope.clipboardSuccess = function (e) { e.clearSelection(); selectPassword(e); }; $scope.clipboardError = function (e, password) { if (password) { selectPassword(e); } alert('Your web browser does not support easy clipboard copying. Copy it manually instead.'); }; $scope.folderSort = function (item) { if (!item.id) { return ''; } return item.name.toLowerCase(); }; function selectPassword(e) { var target = $(e.trigger).parent().prev(); if (target.attr('type') === 'text') { target.select(); } } $scope.close = function () { $uibModalInstance.dismiss('close'); }; $scope.showUpgrade = function () { $uibModal.open({ animation: true, templateUrl: 'app/views/premiumRequired.html', controller: 'premiumRequiredController' }); }; }]); angular .module('bit.vault') .controller('vaultAddFolderController', ["$scope", "apiService", "$uibModalInstance", "cryptoService", "cipherService", "$analytics", function ($scope, apiService, $uibModalInstance, cryptoService, cipherService, $analytics) { $analytics.eventTrack('vaultAddFolderController', { category: 'Modal' }); $scope.savePromise = null; $scope.save = function (model) { var folder = cipherService.encryptFolder(model); $scope.savePromise = apiService.folders.post(folder, function (response) { $analytics.eventTrack('Created Folder'); var decFolder = cipherService.decryptFolder(response); $uibModalInstance.close(decFolder); }).$promise; }; $scope.close = function () { $uibModalInstance.dismiss('close'); }; }]); angular .module('bit.vault') .controller('vaultAttachmentsController', ["$scope", "apiService", "$uibModalInstance", "cryptoService", "cipherService", "cipherId", "$analytics", "validationService", "toastr", "$timeout", "authService", "$uibModal", function ($scope, apiService, $uibModalInstance, cryptoService, cipherService, cipherId, $analytics, validationService, toastr, $timeout, authService, $uibModal) { $analytics.eventTrack('vaultAttachmentsController', { category: 'Modal' }); $scope.cipher = {}; $scope.readOnly = true; $scope.loading = true; $scope.isPremium = true; $scope.canUseAttachments = true; var closing = false; authService.getUserProfile().then(function (profile) { $scope.isPremium = profile.premium; return apiService.ciphers.get({ id: cipherId }).$promise; }).then(function (cipher) { $scope.cipher = cipherService.decryptCipher(cipher); $scope.readOnly = !$scope.cipher.edit; $scope.canUseAttachments = $scope.isPremium || $scope.cipher.organizationId; $scope.loading = false; }, function () { $scope.loading = false; }); $scope.save = function (form) { var fileEl = document.getElementById('file'); var files = fileEl.files; if (!files || !files.length) { validationService.addError(form, 'file', 'Select a file.', true); return; } $scope.savePromise = cipherService.encryptAttachmentFile(getKeyForCipher(), files[0]).then(function (encValue) { var fd = new FormData(); var blob = new Blob([encValue.data], { type: 'application/octet-stream' }); fd.append('data', blob, encValue.fileName); return apiService.ciphers.postAttachment({ id: cipherId }, fd).$promise; }).then(function (response) { $analytics.eventTrack('Added Attachment'); $scope.cipher = cipherService.decryptCipher(response); // reset file input // ref: https://stackoverflow.com/a/20552042 fileEl.type = ''; fileEl.type = 'file'; fileEl.value = ''; }, function (e) { var errors = validationService.parseErrors(e); toastr.error(errors.length ? errors[0] : 'An error occurred.'); }); }; $scope.download = function (attachment) { attachment.loading = true; if (!$scope.canUseAttachments) { attachment.loading = false; alert('Premium membership is required to use this feature.'); return; } cipherService.downloadAndDecryptAttachment(getKeyForCipher(), attachment, true).then(function (res) { $timeout(function () { attachment.loading = false; }); }, function () { $timeout(function () { attachment.loading = false; }); }); }; function getKeyForCipher() { if ($scope.cipher.organizationId) { return cryptoService.getOrgKey($scope.cipher.organizationId); } return null; } $scope.remove = function (attachment) { if (!confirm('Are you sure you want to delete this attachment (' + attachment.fileName + ')?')) { return; } attachment.loading = true; apiService.ciphers.delAttachment({ id: cipherId, attachmentId: attachment.id }).$promise.then(function () { attachment.loading = false; $analytics.eventTrack('Deleted Attachment'); var index = $scope.cipher.attachments.indexOf(attachment); if (index > -1) { $scope.cipher.attachments.splice(index, 1); } }, function () { toastr.error('Cannot delete attachment.'); attachment.loading = false; }); }; $scope.close = function () { $uibModalInstance.dismiss('cancel'); }; $scope.$on('modal.closing', function (e, reason, closed) { if (closing) { return; } e.preventDefault(); closing = true; $uibModalInstance.close(!!$scope.cipher.attachments && $scope.cipher.attachments.length > 0); }); $scope.showUpgrade = function () { $uibModal.open({ animation: true, templateUrl: 'app/views/premiumRequired.html', controller: 'premiumRequiredController' }); }; }]); angular .module('bit.vault') .controller('vaultCipherCollectionsController', ["$scope", "apiService", "$uibModalInstance", "cipherService", "cipherId", "$analytics", function ($scope, apiService, $uibModalInstance, cipherService, cipherId, $analytics) { $analytics.eventTrack('vaultCipherCollectionsController', { category: 'Modal' }); $scope.cipher = {}; $scope.readOnly = false; $scope.loadingCipher = true; $scope.loadingCollections = true; $scope.selectedCollections = {}; $scope.collections = []; var cipherAndCols = null; $uibModalInstance.opened.then(function () { apiService.ciphers.getDetails({ id: cipherId }).$promise.then(function (cipher) { $scope.loadingCipher = false; $scope.readOnly = !cipher.Edit; if (cipher.Edit && cipher.OrganizationId) { if (cipher.Type === 1) { $scope.cipher = cipherService.decryptCipherPreview(cipher); } var collections = {}; if (cipher.CollectionIds) { for (var i = 0; i < cipher.CollectionIds.length; i++) { collections[cipher.CollectionIds[i]] = null; } } return { cipher: cipher, cipherCollections: collections }; } return null; }).then(function (result) { if (!result) { $scope.loadingCollections = false; return false; } cipherAndCols = result; return apiService.collections.listMe({ writeOnly: true }).$promise; }).then(function (response) { if (response === false) { return; } var collections = []; var selectedCollections = {}; var writeableCollections = response.Data; for (var i = 0; i < writeableCollections.length; i++) { // clean out selectCollections that aren't from this organization if (writeableCollections[i].OrganizationId !== cipherAndCols.cipher.OrganizationId) { continue; } if (writeableCollections[i].Id in cipherAndCols.cipherCollections) { selectedCollections[writeableCollections[i].Id] = true; } var decCollection = cipherService.decryptCollection(writeableCollections[i]); collections.push(decCollection); } $scope.loadingCollections = false; $scope.collections = collections; $scope.selectedCollections = selectedCollections; }); }); $scope.toggleCollectionSelectionAll = function ($event) { var collections = {}; if ($event.target.checked) { for (var i = 0; i < $scope.collections.length; i++) { collections[$scope.collections[i].id] = true; } } $scope.selectedCollections = collections; }; $scope.toggleCollectionSelection = function (id) { if (id in $scope.selectedCollections) { delete $scope.selectedCollections[id]; } else { $scope.selectedCollections[id] = true; } }; $scope.collectionSelected = function (collection) { return collection.id in $scope.selectedCollections; }; $scope.allSelected = function () { return Object.keys($scope.selectedCollections).length === $scope.collections.length; }; $scope.submit = function () { var request = { collectionIds: [] }; for (var id in $scope.selectedCollections) { if ($scope.selectedCollections.hasOwnProperty(id)) { request.collectionIds.push(id); } } $scope.submitPromise = apiService.ciphers.putCollections({ id: cipherId }, request) .$promise.then(function (response) { $analytics.eventTrack('Edited Cipher Collections'); $uibModalInstance.close({ action: 'collectionsEdit', collectionIds: request.collectionIds }); }); }; $scope.close = function () { $uibModalInstance.dismiss('cancel'); }; }]); angular .module('bit.vault') .controller('vaultController', ["$scope", "$uibModal", "apiService", "$filter", "cryptoService", "authService", "toastr", "cipherService", "$q", "$localStorage", "$timeout", "$rootScope", "$state", "$analytics", "constants", "validationService", function ($scope, $uibModal, apiService, $filter, cryptoService, authService, toastr, cipherService, $q, $localStorage, $timeout, $rootScope, $state, $analytics, constants, validationService) { $scope.loadingCiphers = true; $scope.loadingGroupings = true; $scope.ciphers = []; $scope.folders = []; $scope.collections = []; $scope.constants = constants; $scope.filter = undefined; $scope.selectedType = undefined; $scope.selectedFolder = undefined; $scope.selectedCollection = undefined; $scope.selectedFavorites = false; $scope.selectedAll = true; $scope.selectedTitle = 'All'; $scope.selectedIcon = 'fa-th'; if ($state.params.refreshFromServer) { $rootScope.vaultFolders = $rootScope.vaultCollections = $rootScope.vaultCiphers = null; } $scope.$on('$viewContentLoaded', function () { $timeout(function () { if ($('body').hasClass('control-sidebar-open')) { $("#search").focus(); } }, 500); if (($rootScope.vaultFolders || $rootScope.vaultCollections) && $rootScope.vaultCiphers) { $scope.loadingCiphers = $scope.loadingGroupings = false; loadCipherData($rootScope.vaultCiphers); return; } loadDataFromServer(); }); function loadDataFromServer() { var decFolders = [{ id: null, name: 'No Folder' }]; var decCollections = []; var collectionPromise = apiService.collections.listMe({ writeOnly: false }, function (collections) { for (var i = 0; i < collections.Data.length; i++) { var decCollection = cipherService.decryptCollection(collections.Data[i], null, true); decCollections.push(decCollection); } }).$promise; var folderPromise = apiService.folders.list({}, function (folders) { for (var i = 0; i < folders.Data.length; i++) { var decFolder = cipherService.decryptFolderPreview(folders.Data[i]); decFolders.push(decFolder); } }).$promise; var groupingPromise = $q.all([collectionPromise, folderPromise]).then(function () { $rootScope.vaultCollections = decCollections; $rootScope.vaultFolders = decFolders; $scope.loadingGroupings = false; }); apiService.ciphers.list({}, function (ciphers) { var decCiphers = []; for (var i = 0; i < ciphers.Data.length; i++) { var decCipher = cipherService.decryptCipherPreview(ciphers.Data[i]); decCiphers.push(decCipher); } groupingPromise.then(function () { loadCipherData(decCiphers); }); }); } function loadCipherData(decCiphers) { $rootScope.vaultCiphers = $scope.ciphers = $filter('orderBy')(decCiphers, ['sort', 'name', 'subTitle']); var chunks = chunk($rootScope.vaultCiphers, 200); if (chunks.length > 0) { $scope.ciphers = chunks[0]; var delay = 200; angular.forEach(chunks, function (value, index) { delay += 200; // skip the first chuck if (index > 0) { $timeout(function () { Array.prototype.push.apply($scope.ciphers, value); }, delay); } }); } $scope.loadingCiphers = false; } function sortScopedCipherData() { $rootScope.vaultCiphers = $scope.ciphers = $filter('orderBy')($rootScope.vaultCiphers, ['name', 'subTitle']); } function chunk(arr, len) { var chunks = [], i = 0, n = arr.length; while (i < n) { chunks.push(arr.slice(i, i += len)); } return chunks; } $scope.groupingSort = function (item) { if (!item.id) { return ''; } return item.name.toLowerCase(); }; $scope.clipboardError = function (e) { alert('Your web browser does not support easy clipboard copying. ' + 'Edit the item and copy it manually instead.'); }; $scope.editCipher = function (cipher) { var editModel = $uibModal.open({ animation: true, templateUrl: 'app/vault/views/vaultEditCipher.html', controller: 'vaultEditCipherController', resolve: { cipherId: function () { return cipher.id; } } }); editModel.result.then(function (returnVal) { if (returnVal.action === 'edit') { var index = $scope.ciphers.indexOf(cipher); if (index > -1) { // restore collection ids since those cannot change on edit here. returnVal.data.collectionIds = $rootScope.vaultCiphers[index].collectionIds; $rootScope.vaultCiphers[index] = returnVal.data; } sortScopedCipherData(); } else if (returnVal.action === 'partialEdit') { cipher.folderId = returnVal.data.folderId; cipher.favorite = returnVal.data.favorite; } else if (returnVal.action === 'delete') { removeCipherFromScopes(cipher); } }); }; $scope.$on('vaultAddCipher', function (event, args) { $scope.addCipher(); }); $scope.addCipher = function () { var addModel = $uibModal.open({ animation: true, templateUrl: 'app/vault/views/vaultAddCipher.html', controller: 'vaultAddCipherController', resolve: { selectedFolder: function () { return $scope.selectedFolder; }, selectedType: function () { return $scope.selectedType; }, checkedFavorite: function () { return $scope.selectedFavorites; } } }); addModel.result.then(function (addedCipher) { $rootScope.vaultCiphers.push(addedCipher); sortScopedCipherData(); }); }; $scope.deleteCipher = function (cipher) { if (!confirm('Are you sure you want to delete this item (' + cipher.name + ')?')) { return; } apiService.ciphers.del({ id: cipher.id }, function () { $analytics.eventTrack('Deleted Item'); removeCipherFromScopes(cipher); }); }; $scope.attachments = function (cipher) { authService.getUserProfile().then(function (profile) { return { isPremium: profile.premium, orgUseStorage: cipher.organizationId && !!profile.organizations[cipher.organizationId].maxStorageGb }; }).then(function (perms) { if (!cipher.hasAttachments) { if (cipher.organizationId && !perms.orgUseStorage) { $uibModal.open({ animation: true, templateUrl: 'app/views/paidOrgRequired.html', controller: 'paidOrgRequiredController', resolve: { orgId: function () { return cipher.organizationId; } } }); return; } if (!cipher.organizationId && !perms.isPremium) { $uibModal.open({ animation: true, templateUrl: 'app/views/premiumRequired.html', controller: 'premiumRequiredController' }); return; } } if (!cipher.organizationId && !cryptoService.getEncKey()) { toastr.error('You cannot use this feature until you update your encryption key.', 'Feature Unavailable'); return; } var attachmentModel = $uibModal.open({ animation: true, templateUrl: 'app/vault/views/vaultAttachments.html', controller: 'vaultAttachmentsController', resolve: { cipherId: function () { return cipher.id; } } }); attachmentModel.result.then(function (hasAttachments) { cipher.hasAttachments = hasAttachments; }); }); }; $scope.editFolder = function (folder) { if (!folder.id) { return; } var editModel = $uibModal.open({ animation: true, templateUrl: 'app/vault/views/vaultEditFolder.html', controller: 'vaultEditFolderController', size: 'sm', resolve: { folderId: function () { return folder.id; } } }); editModel.result.then(function (editedFolder) { folder.name = editedFolder.name; }); }; $scope.$on('vaultAddFolder', function (event, args) { $scope.addFolder(); }); $scope.addFolder = function () { var addModel = $uibModal.open({ animation: true, templateUrl: 'app/vault/views/vaultAddFolder.html', controller: 'vaultAddFolderController', size: 'sm' }); addModel.result.then(function (addedFolder) { $rootScope.vaultFolders.push(addedFolder); }); }; $scope.deleteFolder = function (folder) { if (!folder.id) { return; } if (!confirm('Are you sure you want to delete this folder (' + folder.name + ')? ' + 'Any items will be moved to "No Folder".')) { return; } apiService.folders.del({ id: folder.id }, function () { $analytics.eventTrack('Deleted Folder'); var index = $rootScope.vaultFolders.indexOf(folder); if (index > -1) { $rootScope.vaultFolders.splice(index, 1); $scope.filterAll(); } }); }; $scope.share = function (cipher) { var modal = $uibModal.open({ animation: true, templateUrl: 'app/vault/views/vaultShareCipher.html', controller: 'vaultShareCipherController', resolve: { cipherId: function () { return cipher.id; } } }); modal.result.then(function (returned) { cipher.organizationId = returned.orgId; cipher.collectionIds = returned.collectionIds || []; }); }; $scope.editCollections = function (cipher) { var modal = $uibModal.open({ animation: true, templateUrl: 'app/vault/views/vaultCipherCollections.html', controller: 'vaultCipherCollectionsController', resolve: { cipherId: function () { return cipher.id; } } }); modal.result.then(function (response) { if (response.collectionIds && !response.collectionIds.length) { removeCipherFromScopes(cipher); } else if (response.collectionIds) { cipher.collectionIds = response.collectionIds; } }); }; $scope.filterCollection = function (col) { resetSelected(); $scope.selectedCollection = col; $scope.selectedIcon = 'fa-cube'; $scope.filter = function (c) { return c.collectionIds && c.collectionIds.indexOf(col.id) > -1; }; fixLayout(); }; $scope.filterFolder = function (f) { resetSelected(); $scope.selectedFolder = f; $scope.selectedIcon = 'fa-folder-open' + (!f.id ? '-o' : ''); $scope.filter = function (c) { return c.folderId === f.id; }; fixLayout(); }; $scope.filterType = function (t) { resetSelected(); $scope.selectedType = t; switch (t) { case constants.cipherType.login: $scope.selectedTitle = 'Login'; $scope.selectedIcon = 'fa-globe'; break; case constants.cipherType.card: $scope.selectedTitle = 'Card'; $scope.selectedIcon = 'fa-credit-card'; break; case constants.cipherType.identity: $scope.selectedTitle = 'Identity'; $scope.selectedIcon = 'fa-id-card-o'; break; case constants.cipherType.secureNote: $scope.selectedTitle = 'Secure Note'; $scope.selectedIcon = 'fa-sticky-note-o'; break; default: break; } $scope.filter = function (c) { return c.type === t; }; fixLayout(); }; $scope.filterFavorites = function () { resetSelected(); $scope.selectedFavorites = true; $scope.selectedTitle = 'Favorites'; $scope.selectedIcon = 'fa-star'; $scope.filter = function (c) { return !!c.favorite; }; fixLayout(); }; $scope.filterAll = function () { resetSelected(); $scope.selectedAll = true; $scope.selectedTitle = 'All'; $scope.selectedIcon = 'fa-th'; $scope.filter = null; fixLayout(); }; function resetSelected() { $scope.selectedFolder = undefined; $scope.selectedCollection = undefined; $scope.selectedType = undefined; $scope.selectedFavorites = false; $scope.selectedAll = false; } function fixLayout() { if ($.AdminLTE && $.AdminLTE.layout) { $timeout(function () { $.AdminLTE.layout.fix(); }, 0); } } $scope.cipherFilter = function () { return function (cipher) { return !$scope.filter || $scope.filter(cipher); }; }; $scope.unselectAll = function () { selectAll(false); }; $scope.selectAll = function () { selectAll(true); }; $scope.select = function ($event) { var checkbox = $($event.currentTarget).closest('tr').find('input[name="cipherSelection"]'); checkbox.prop('checked', !checkbox.prop('checked')); }; function distinct(value, index, self) { return self.indexOf(value) === index; } function getSelectedCiphers() { return $('input[name="cipherSelection"]:checked').map(function () { return $(this).val(); }).get().filter(distinct); } function selectAll(select) { $('input[name="cipherSelection"]').prop('checked', select); } $scope.bulkMove = function () { var ids = getSelectedCiphers(); if (ids.length === 0) { alert('You have not selected anything.'); return; } var modal = $uibModal.open({ animation: true, templateUrl: 'app/vault/views/vaultMoveCiphers.html', controller: 'vaultMoveCiphersController', size: 'sm', resolve: { ids: function () { return ids; } } }); modal.result.then(function (folderId) { for (var i = 0; i < ids.length; i++) { var cipher = $filter('filter')($rootScope.vaultCiphers, { id: ids[i] }); if (cipher.length) { cipher[0].folderId = folderId; } } selectAll(false); sortScopedCipherData(); toastr.success('Items have been moved!'); }); }; $scope.bulkDelete = function () { var ids = getSelectedCiphers(); if (ids.length === 0) { alert('You have not selected anything.'); return; } if (!confirm('Are you sure you want to delete the selected items (total: ' + ids.length + ')?')) { return; } $scope.actionLoading = true; apiService.ciphers.delMany({ ids: ids }, function () { $analytics.eventTrack('Bulk Deleted Items'); for (var i = 0; i < ids.length; i++) { var cipher = $filter('filter')($rootScope.vaultCiphers, { id: ids[i] }); if (cipher.length && cipher[0].edit) { removeCipherFromScopes(cipher[0]); } } selectAll(false); $scope.actionLoading = false; toastr.success('Items have been deleted!'); }, function (e) { var errors = validationService.parseErrors(e); toastr.error(errors.length ? errors[0] : 'An error occurred.'); $scope.actionLoading = false; }); }; function removeCipherFromScopes(cipher) { var index = $rootScope.vaultCiphers.indexOf(cipher); if (index > -1) { $rootScope.vaultCiphers.splice(index, 1); } index = $scope.ciphers.indexOf(cipher); if (index > -1) { $scope.ciphers.splice(index, 1); } } }]); angular .module('bit.vault') .controller('vaultEditCipherController', ["$scope", "apiService", "$uibModalInstance", "cryptoService", "cipherService", "passwordService", "cipherId", "$analytics", "$rootScope", "authService", "$uibModal", "constants", "$filter", function ($scope, apiService, $uibModalInstance, cryptoService, cipherService, passwordService, cipherId, $analytics, $rootScope, authService, $uibModal, constants, $filter) { $analytics.eventTrack('vaultEditCipherController', { category: 'Modal' }); $scope.folders = $rootScope.vaultFolders; $scope.cipher = {}; $scope.readOnly = false; $scope.constants = constants; authService.getUserProfile().then(function (profile) { $scope.useTotp = profile.premium; return apiService.ciphers.get({ id: cipherId }).$promise; }).then(function (cipher) { $scope.cipher = cipherService.decryptCipher(cipher); $scope.readOnly = !$scope.cipher.edit; $scope.useTotp = $scope.useTotp || $scope.cipher.organizationUseTotp; setUriMatchValues(); }); $scope.save = function (model) { if ($scope.readOnly) { $scope.savePromise = apiService.ciphers.putPartial({ id: cipherId }, { folderId: model.folderId, favorite: model.favorite }, function (response) { $analytics.eventTrack('Partially Edited Cipher'); $uibModalInstance.close({ action: 'partialEdit', data: { id: cipherId, favorite: model.favorite, folderId: model.folderId && model.folderId !== '' ? model.folderId : null } }); }).$promise; } else { var cipher = cipherService.encryptCipher(model, $scope.cipher.type); $scope.savePromise = apiService.ciphers.put({ id: cipherId }, cipher, function (cipherResponse) { $analytics.eventTrack('Edited Cipher'); var decCipher = cipherService.decryptCipherPreview(cipherResponse); $uibModalInstance.close({ action: 'edit', data: decCipher }); }).$promise; } }; $scope.generatePassword = function () { if (!$scope.cipher.login.password || confirm('Are you sure you want to overwrite the current password?')) { $analytics.eventTrack('Generated Password From Edit'); $scope.cipher.login.password = passwordService.generatePassword({ length: 14, special: true }); } }; $scope.addUri = function () { if (!$scope.cipher.login) { return; } if (!$scope.cipher.login.uris) { $scope.cipher.login.uris = []; } $scope.cipher.login.uris.push({ uri: null, match: null, matchValue: null }); }; $scope.removeUri = function (uri) { if (!$scope.cipher.login || !$scope.cipher.login.uris) { return; } var index = $scope.cipher.login.uris.indexOf(uri); if (index > -1) { $scope.cipher.login.uris.splice(index, 1); } }; $scope.uriMatchChanged = function (uri) { if ((!uri.matchValue && uri.matchValue !== 0) || uri.matchValue === '') { uri.match = null; } else { uri.match = parseInt(uri.matchValue); } }; $scope.addField = function () { if (!$scope.cipher.fields) { $scope.cipher.fields = []; } $scope.cipher.fields.push({ type: constants.fieldType.text.toString(), name: null, value: null }); }; $scope.removeField = function (field) { var index = $scope.cipher.fields.indexOf(field); if (index > -1) { $scope.cipher.fields.splice(index, 1); } }; $scope.toggleFavorite = function () { $scope.cipher.favorite = !$scope.cipher.favorite; }; $scope.clipboardSuccess = function (e) { e.clearSelection(); selectPassword(e); }; $scope.clipboardError = function (e, password) { if (password) { selectPassword(e); } alert('Your web browser does not support easy clipboard copying. Copy it manually instead.'); }; $scope.folderSort = function (item) { if (!item.id) { return ''; } return item.name.toLowerCase(); }; function selectPassword(e) { var target = $(e.trigger).parent().prev(); if (target.attr('type') === 'text') { target.select(); } } $scope.delete = function () { if (!confirm('Are you sure you want to delete this item (' + $scope.cipher.name + ')?')) { return; } apiService.ciphers.del({ id: $scope.cipher.id }, function () { $analytics.eventTrack('Deleted Cipher From Edit'); $uibModalInstance.close({ action: 'delete', data: $scope.cipher.id }); }); }; $scope.close = function () { $uibModalInstance.dismiss('cancel'); }; $scope.showUpgrade = function () { $uibModal.open({ animation: true, templateUrl: 'app/views/premiumRequired.html', controller: 'premiumRequiredController' }); }; function setUriMatchValues() { if ($scope.cipher.login && $scope.cipher.login.uris) { for (var i = 0; i < $scope.cipher.login.uris.length; i++) { $scope.cipher.login.uris[i].matchValue = $scope.cipher.login.uris[i].match || $scope.cipher.login.uris[i].match === 0 ? $scope.cipher.login.uris[i].match.toString() : ''; } } } }]); angular .module('bit.vault') .controller('vaultEditFolderController', ["$scope", "apiService", "$uibModalInstance", "cryptoService", "cipherService", "folderId", "$analytics", function ($scope, apiService, $uibModalInstance, cryptoService, cipherService, folderId, $analytics) { $analytics.eventTrack('vaultEditFolderController', { category: 'Modal' }); $scope.folder = {}; apiService.folders.get({ id: folderId }, function (folder) { $scope.folder = cipherService.decryptFolder(folder); }); $scope.savePromise = null; $scope.save = function (model) { var folder = cipherService.encryptFolder(model); $scope.savePromise = apiService.folders.put({ id: folderId }, folder, function (response) { $analytics.eventTrack('Edited Folder'); var decFolder = cipherService.decryptFolder(response); $uibModalInstance.close(decFolder); }).$promise; }; $scope.close = function () { $uibModalInstance.dismiss('cancel'); }; }]); angular .module('bit.vault') .controller('vaultMoveCiphersController', ["$scope", "apiService", "$uibModalInstance", "ids", "$analytics", "$rootScope", "$filter", function ($scope, apiService, $uibModalInstance, ids, $analytics, $rootScope, $filter) { $analytics.eventTrack('vaultMoveCiphersController', { category: 'Modal' }); $scope.folders = $rootScope.vaultFolders; $scope.count = ids.length; $scope.save = function () { $scope.savePromise = apiService.ciphers.moveMany({ ids: ids, folderId: $scope.folderId }, function () { $analytics.eventTrack('Bulk Moved Ciphers'); $uibModalInstance.close($scope.folderId || null); }).$promise; }; $scope.folderSort = function (item) { if (!item.id) { return '!'; } return item.name.toLowerCase(); }; $scope.close = function () { $uibModalInstance.dismiss('cancel'); }; }]); angular .module('bit.vault') .controller('vaultShareCipherController', ["$scope", "apiService", "$uibModalInstance", "authService", "cipherService", "cipherId", "$analytics", "$state", "cryptoService", "$q", "toastr", function ($scope, apiService, $uibModalInstance, authService, cipherService, cipherId, $analytics, $state, cryptoService, $q, toastr) { $analytics.eventTrack('vaultShareCipherController', { category: 'Modal' }); $scope.model = {}; $scope.cipher = {}; $scope.collections = []; $scope.selectedCollections = {}; $scope.organizations = []; var organizationCollectionCounts = {}; $scope.loadingCollections = true; $scope.loading = true; $scope.readOnly = false; apiService.ciphers.get({ id: cipherId }).$promise.then(function (cipher) { $scope.readOnly = !cipher.Edit; if (cipher.Edit) { $scope.cipher = cipherService.decryptCipher(cipher); } return cipher.Edit; }).then(function (canEdit) { $scope.loading = false; if (!canEdit) { return; } return authService.getUserProfile(); }).then(function (profile) { if (profile && profile.organizations) { var orgs = [], setFirstOrg = false; for (var i in profile.organizations) { if (profile.organizations.hasOwnProperty(i) && profile.organizations[i].enabled) { orgs.push({ id: profile.organizations[i].id, name: profile.organizations[i].name }); organizationCollectionCounts[profile.organizations[i].id] = 0; if (!setFirstOrg) { setFirstOrg = true; $scope.model.organizationId = profile.organizations[i].id; } } } $scope.organizations = orgs; apiService.collections.listMe({ writeOnly: true }, function (response) { var collections = []; for (var i = 0; i < response.Data.length; i++) { var decCollection = cipherService.decryptCollection(response.Data[i]); decCollection.organizationId = response.Data[i].OrganizationId; collections.push(decCollection); organizationCollectionCounts[decCollection.organizationId]++; } $scope.collections = collections; $scope.loadingCollections = false; }); } }); $scope.toggleCollectionSelectionAll = function ($event) { var collections = {}; if ($event.target.checked) { for (var i = 0; i < $scope.collections.length; i++) { if ($scope.model.organizationId && $scope.collections[i].organizationId === $scope.model.organizationId) { collections[$scope.collections[i].id] = true; } } } $scope.selectedCollections = collections; }; $scope.toggleCollectionSelection = function (id) { if (id in $scope.selectedCollections) { delete $scope.selectedCollections[id]; } else { $scope.selectedCollections[id] = true; } }; $scope.collectionSelected = function (collection) { return collection.id in $scope.selectedCollections; }; $scope.allSelected = function () { if (!$scope.model.organizationId) { return false; } return Object.keys($scope.selectedCollections).length === organizationCollectionCounts[$scope.model.organizationId]; }; $scope.orgChanged = function () { $scope.selectedCollections = {}; }; $scope.submitPromise = null; $scope.submit = function (model) { var orgKey = cryptoService.getOrgKey(model.organizationId); var errorOnUpload = false; var attachmentSharePromises = []; if ($scope.cipher.attachments) { for (var i = 0; i < $scope.cipher.attachments.length; i++) { /* jshint ignore:start */ (function (attachment) { var promise = cipherService.downloadAndDecryptAttachment(null, attachment, false) .then(function (decData) { return cryptoService.encryptToBytes(decData.buffer, orgKey); }).then(function (encData) { if (errorOnUpload) { return; } var fd = new FormData(); var blob = new Blob([encData], { type: 'application/octet-stream' }); var encFilename = cryptoService.encrypt(attachment.fileName, orgKey); fd.append('data', blob, encFilename); return apiService.ciphers.postShareAttachment({ id: cipherId, attachmentId: attachment.id, orgId: model.organizationId }, fd).$promise; }, function (err) { errorOnUpload = true; }); attachmentSharePromises.push(promise); })($scope.cipher.attachments[i]); /* jshint ignore:end */ } } var returnedCollectionIds = null; $scope.submitPromise = $q.all(attachmentSharePromises).then(function () { if (errorOnUpload) { return; } $scope.cipher.organizationId = model.organizationId; var request = { collectionIds: [], cipher: cipherService.encryptCipher($scope.cipher, $scope.cipher.type, null, true) }; for (var id in $scope.selectedCollections) { if ($scope.selectedCollections.hasOwnProperty(id)) { request.collectionIds.push(id); } } returnedCollectionIds = request.collectionIds; return apiService.ciphers.putShare({ id: cipherId }, request).$promise; }).then(function (response) { $analytics.eventTrack('Shared Cipher'); toastr.success('Item has been shared.'); $uibModalInstance.close({ orgId: model.organizationId, collectionIds: returnedCollectionIds }); }); }; $scope.close = function () { $uibModalInstance.dismiss('cancel'); }; $scope.createOrg = function () { $state.go('backend.user.settingsCreateOrg').then(function () { $uibModalInstance.dismiss('cancel'); }); }; }]); angular .module('bit.tools') .controller('toolsController', ["$scope", "$uibModal", "apiService", "toastr", "authService", function ($scope, $uibModal, apiService, toastr, authService) { $scope.import = function () { $uibModal.open({ animation: true, templateUrl: 'app/tools/views/toolsImport.html', controller: 'toolsImportController' }); }; $scope.export = function () { $uibModal.open({ animation: true, templateUrl: 'app/tools/views/toolsExport.html', controller: 'toolsExportController' }); }; }]); angular .module('bit.tools') .controller('toolsExportController', ["$scope", "apiService", "$uibModalInstance", "cipherService", "$q", "toastr", "$analytics", "constants", function ($scope, apiService, $uibModalInstance, cipherService, $q, toastr, $analytics, constants) { $analytics.eventTrack('toolsExportController', { category: 'Modal' }); $scope.export = function (model) { $scope.startedExport = true; var decCiphers = [], decFolders = []; var folderPromise = apiService.folders.list({}, function (folders) { decFolders = cipherService.decryptFolders(folders.Data); }).$promise; var ciphersPromise = apiService.ciphers.list({}, function (ciphers) { decCiphers = cipherService.decryptCiphers(ciphers.Data); }).$promise; $q.all([folderPromise, ciphersPromise]).then(function () { if (!decCiphers.length) { toastr.error('Nothing to export.', 'Error!'); $scope.close(); return; } var foldersDict = {}; for (var i = 0; i < decFolders.length; i++) { foldersDict[decFolders[i].id] = decFolders[i]; } try { var exportCiphers = []; for (i = 0; i < decCiphers.length; i++) { // only export logins and secure notes if (decCiphers[i].type !== constants.cipherType.login && decCiphers[i].type !== constants.cipherType.secureNote) { continue; } var cipher = { folder: decCiphers[i].folderId && (decCiphers[i].folderId in foldersDict) ? foldersDict[decCiphers[i].folderId].name : null, favorite: decCiphers[i].favorite ? 1 : null, type: null, name: decCiphers[i].name, notes: decCiphers[i].notes, fields: null, // Login props login_uri: null, login_username: null, login_password: null, login_totp: null }; var j; if (decCiphers[i].fields) { for (j = 0; j < decCiphers[i].fields.length; j++) { if (!cipher.fields) { cipher.fields = ''; } else { cipher.fields += '\n'; } cipher.fields += ((decCiphers[i].fields[j].name || '') + ': ' + decCiphers[i].fields[j].value); } } switch (decCiphers[i].type) { case constants.cipherType.login: cipher.type = 'login'; cipher.login_username = decCiphers[i].login.username; cipher.login_password = decCiphers[i].login.password; cipher.login_totp = decCiphers[i].login.totp; if (decCiphers[i].login.uris && decCiphers[i].login.uris.length) { cipher.login_uri = []; for (j = 0; j < decCiphers[i].login.uris.length; j++) { cipher.login_uri.push(decCiphers[i].login.uris[j].uri); } } break; case constants.cipherType.secureNote: cipher.type = 'note'; break; default: continue; } exportCiphers.push(cipher); } var csvString = Papa.unparse(exportCiphers); var csvBlob = new Blob([csvString]); // IE hack. ref http://msdn.microsoft.com/en-us/library/ie/hh779016.aspx if (window.navigator.msSaveOrOpenBlob) { window.navigator.msSaveBlob(csvBlob, makeFileName()); } else { var a = window.document.createElement('a'); a.href = window.URL.createObjectURL(csvBlob, { type: 'text/plain' }); a.download = makeFileName(); document.body.appendChild(a); // IE: "Access is denied". // ref: https://connect.microsoft.com/IE/feedback/details/797361/ie-10-treats-blob-url-as-cross-origin-and-denies-access a.click(); document.body.removeChild(a); } $analytics.eventTrack('Exported Data'); toastr.success('Your data has been exported. Check your browser\'s downloads folder.', 'Success!'); $scope.close(); } catch (err) { toastr.error('Something went wrong. Please try again.', 'Error!'); $scope.close(); } }, function () { toastr.error('Something went wrong. Please try again.', 'Error!'); $scope.close(); }); }; $scope.close = function () { $uibModalInstance.dismiss('cancel'); }; function makeFileName() { var now = new Date(); var dateString = now.getFullYear() + '' + padNumber(now.getMonth() + 1, 2) + '' + padNumber(now.getDate(), 2) + padNumber(now.getHours(), 2) + '' + padNumber(now.getMinutes(), 2) + padNumber(now.getSeconds(), 2); return 'bitwarden_export_' + dateString + '.csv'; } function padNumber(number, width, paddingCharacter) { paddingCharacter = paddingCharacter || '0'; number = number + ''; return number.length >= width ? number : new Array(width - number.length + 1).join(paddingCharacter) + number; } }]); angular .module('bit.tools') .controller('toolsImportController', ["$scope", "$state", "apiService", "$uibModalInstance", "cryptoService", "cipherService", "toastr", "importService", "$analytics", "$sce", "validationService", function ($scope, $state, apiService, $uibModalInstance, cryptoService, cipherService, toastr, importService, $analytics, $sce, validationService) { $analytics.eventTrack('toolsImportController', { category: 'Modal' }); $scope.model = { source: '' }; $scope.source = {}; $scope.splitFeatured = true; $scope.options = [ { id: 'bitwardencsv', name: 'Bitwarden (csv)', featured: true, sort: 1, instructions: $sce.trustAsHtml('Export using the web vault (vault.bitwarden.com). ' + 'Log into the web vault and navigate to "Tools" > "Export".') }, { id: 'lastpass', name: 'LastPass (csv)', featured: true, sort: 2, instructions: $sce.trustAsHtml('See detailed instructions on our help site at ' + '' + 'https://help.bitwarden.com/article/import-from-lastpass/') }, { id: 'chromecsv', name: 'Chrome (csv)', featured: true, sort: 3, instructions: $sce.trustAsHtml('See detailed instructions on our help site at ' + '' + 'https://help.bitwarden.com/article/import-from-chrome/') }, { id: 'firefoxpasswordexportercsv', name: 'Firefox Password Exporter (csv)', featured: true, sort: 4, instructions: $sce.trustAsHtml('Use the ' + '' + 'FF Password Exporter application to export your passwords to a CSV file.') }, { id: 'keepass2xml', name: 'KeePass 2 (xml)', featured: true, sort: 5, instructions: $sce.trustAsHtml('Using the KeePass 2 desktop application, navigate to "File" > "Export" and ' + 'select the KeePass XML (2.x) option.') }, { id: 'keepassxcsv', name: 'KeePassX (csv)', instructions: $sce.trustAsHtml('Using the KeePassX desktop application, navigate to "Database" > ' + '"Export to CSV file" and save the CSV file.') }, { id: 'dashlanecsv', name: 'Dashlane (csv)', featured: true, sort: 7, instructions: $sce.trustAsHtml('Using the Dashlane desktop application, navigate to "File" > "Export" > ' + '"Unsecured archive (readable) in CSV format" and save the CSV file.') }, { id: '1password1pif', name: '1Password (1pif)', featured: true, sort: 6, instructions: $sce.trustAsHtml('See detailed instructions on our help site at ' + '' + 'https://help.bitwarden.com/article/import-from-1password/') }, { id: '1password6wincsv', name: '1Password 6 Windows (csv)', instructions: $sce.trustAsHtml('See detailed instructions on our help site at ' + '' + 'https://help.bitwarden.com/article/import-from-1password/') }, { id: 'roboformhtml', name: 'RoboForm (html)', instructions: $sce.trustAsHtml('Using the RoboForm Editor desktop application, navigate to "RoboForm" ' + '(top left) > "Print List" > "Logins". When the following print dialog pops up click on the "Save" button ' + 'and save the HTML file.') }, { id: 'keepercsv', name: 'Keeper (csv)', instructions: $sce.trustAsHtml('Log into the Keeper web vault (keepersecurity.com/vault). Navigate to "Backup" ' + '(top right) and find the "Export to Text File" option. Click "Export Now" to save the TXT/CSV file.') }, { id: 'enpasscsv', name: 'Enpass (csv)', instructions: $sce.trustAsHtml('Using the Enpass desktop application, navigate to "File" > "Export" > ' + '"As CSV". Select "Yes" to the warning alert and save the CSV file. Note that the importer only fully ' + 'supports files exported while Enpass is set to the English language, so adjust your settings accordingly.') }, { id: 'safeincloudxml', name: 'SafeInCloud (xml)', instructions: $sce.trustAsHtml('Using the SaveInCloud desktop application, navigate to "File" > "Export" > ' + '"As XML" and save the XML file.') }, { id: 'pwsafexml', name: 'Password Safe (xml)', instructions: $sce.trustAsHtml('Using the Password Safe desktop application, navigate to "File" > ' + '"Export To" > "XML format..." and save the XML file.') }, { id: 'stickypasswordxml', name: 'Sticky Password (xml)', instructions: $sce.trustAsHtml('Using the Sticky Password desktop application, navigate to "Menu" ' + '(top right) > "Export" > "Export all". Select the unencrypted format XML option and then the ' + '"Save to file" button. Save the XML file.') }, { id: 'msecurecsv', name: 'mSecure (csv)', instructions: $sce.trustAsHtml('Using the mSecure desktop application, navigate to "File" > ' + '"Export" > "CSV File..." and save the CSV file.') }, { id: 'truekeycsv', name: 'True Key (csv)', instructions: $sce.trustAsHtml('Using the True Key desktop application, click the gear icon (top right) and ' + 'then navigate to "App Settings". Click the "Export" button, enter your password and save the CSV file.') }, { id: 'passwordbossjson', name: 'Password Boss (json)', instructions: $sce.trustAsHtml('Using the Password Boss desktop application, navigate to "File" > ' + '"Export data" > "Password Boss JSON - not encrypted" and save the JSON file.') }, { id: 'zohovaultcsv', name: 'Zoho Vault (csv)', instructions: $sce.trustAsHtml('Log into the Zoho web vault (vault.zoho.com). Navigate to "Tools" > ' + '"Export Secrets". Select "All Secrets" and click the "Zoho Vault Format CSV" button. Highlight ' + 'and copy the data from the textarea. Open a text editor like Notepad and paste the data. Save the ' + 'data from the text editor aszoho_export.csv.')
},
{
id: 'splashidcsv',
name: 'SplashID (csv)',
instructions: $sce.trustAsHtml('Using the SplashID Safe desktop application, click on the SplashID ' +
'blue lock logo in the top right corner. Navigate to "Export" > "Export as CSV" and save the CSV file.')
},
{
id: 'passworddragonxml',
name: 'Password Dragon (xml)',
instructions: $sce.trustAsHtml('Using the Password Dragon desktop application, navigate to "File" > ' +
'"Export" > "To XML". In the dialog that pops up select "All Rows" and check all fields. Click ' +
'the "Export" button and save the XML file.')
},
{
id: 'padlockcsv',
name: 'Padlock (csv)',
instructions: $sce.trustAsHtml('Using the Padlock desktop application, click the hamburger icon ' +
'in the top left corner and navigate to "Settings". Click the "Export Data" option. Ensure that ' +
'the "CSV" option is selected from the dropdown. Highlight and copy the data from the textarea. ' +
'Open a text editor like Notepad and paste the data. Save the data from the text editor as ' +
'padlock_export.csv.')
},
{
id: 'clipperzhtml',
name: 'Clipperz (html)',
instructions: $sce.trustAsHtml('Log into the Clipperz web application (clipperz.is/app). Click the ' +
'hamburger menu icon in the top right to expand the navigation bar. Navigate to "Data" > ' +
'"Export". Click the "download HTML+JSON" button to save the HTML file.')
},
{
id: 'avirajson',
name: 'Avira (json)',
instructions: $sce.trustAsHtml('Using the Avira browser extension, click your username in the top ' +
'right corner and navigate to "Settings". Locate the "Export Data" section and click "Export". ' +
'In the dialog that pops up, click the "Export Password Manager Data" button to save the ' +
'TXT/JSON file.')
},
{
id: 'saferpasscsv',
name: 'SaferPass (csv)',
instructions: $sce.trustAsHtml('Using the SaferPass browser extension, click the hamburger icon ' +
'in the top left corner and navigate to "Settings". Click the "Export accounts" button to ' +
'save the CSV file.')
},
{
id: 'upmcsv',
name: 'Universal Password Manager (csv)',
instructions: $sce.trustAsHtml('Using the Universal Password Manager desktop application, navigate ' +
'to "Database" > "Export" and save the CSV file.')
},
{
id: 'ascendocsv',
name: 'Ascendo DataVault (csv)',
instructions: $sce.trustAsHtml('Using the Ascendo DataVault desktop application, navigate ' +
'to "Tools" > "Export". In the dialog that pops up, select the "All Items (DVX, CSV)" ' +
'option. Click the "Ok" button to save the CSV file.')
},
{
id: 'meldiumcsv',
name: 'Meldium (csv)',
instructions: $sce.trustAsHtml('Using the Meldium web vault, navigate to "Settings". ' +
'Locate the "Export data" function and click "Show me my data" to save the CSV file.')
},
{
id: 'passkeepcsv',
name: 'PassKeep (csv)',
instructions: $sce.trustAsHtml('Using the PassKeep mobile app, navigate to "Backup/Restore". ' +
'Locate the "CSV Backup/Restore" section and click "Backup to CSV" to save the CSV file.')
},
{
id: 'operacsv',
name: 'Opera (csv)',
instructions: $sce.trustAsHtml('The process for importing from Opera is exactly the same as ' +
'importing from Google Chrome. See detailed instructions on our help site at ' +
'' +
'https://help.bitwarden.com/article/import-from-chrome/')
},
{
id: 'vivaldicsv',
name: 'Vivaldi (csv)',
instructions: $sce.trustAsHtml('The process for importing from Vivaldi is exactly the same as ' +
'importing from Google Chrome. See detailed instructions on our help site at ' +
'' +
'https://help.bitwarden.com/article/import-from-chrome/')
},
{
id: 'gnomejson',
name: 'GNOME Passwords and Keys/Seahorse (json)',
instructions: $sce.trustAsHtml('Make sure you have python-keyring and python-gnomekeyring installed. ' +
'Save the GNOME Keyring Import/Export ' +
'python script by Luke Plant to your desktop as pw_helper.py. Open terminal and run ' +
'chmod +rx Desktop/pw_helper.py and then ' +
'python Desktop/pw_helper.py export Desktop/my_passwords.json. Then upload ' +
'the resulting my_passwords.json file here to Bitwarden.')
}
];
$scope.setSource = function () {
for (var i = 0; i < $scope.options.length; i++) {
if ($scope.options[i].id === $scope.model.source) {
$scope.source = $scope.options[i];
break;
}
}
};
$scope.setSource();
$scope.import = function (model, form) {
if (!model.source || model.source === '') {
validationService.addError(form, 'source', 'Select the format of the import file.', true);
return;
}
var file = document.getElementById('file').files[0];
if (!file && (!model.fileContents || model.fileContents === '')) {
validationService.addError(form, 'file', 'Select the import file or copy/paste the import file contents.', true);
return;
}
$scope.processing = true;
importService.import(model.source, file || model.fileContents, importSuccess, importError);
};
function importSuccess(folders, ciphers, folderRelationships) {
if (!folders.length && !ciphers.length) {
importError('Nothing was imported.');
return;
}
else if (ciphers.length) {
var halfway = Math.floor(ciphers.length / 2);
var last = ciphers.length - 1;
if (cipherIsBadData(ciphers[0]) && cipherIsBadData(ciphers[halfway]) && cipherIsBadData(ciphers[last])) {
importError('Data is not formatted correctly. Please check your import file and try again.');
return;
}
}
apiService.ciphers.import({
folders: cipherService.encryptFolders(folders),
ciphers: cipherService.encryptCiphers(ciphers),
folderRelationships: folderRelationships
}, function () {
$uibModalInstance.dismiss('cancel');
$state.go('backend.user.vault', { refreshFromServer: true }).then(function () {
$analytics.eventTrack('Imported Data', { label: $scope.model.source });
toastr.success('Data has been successfully imported into your vault.', 'Import Success');
});
}, importError);
}
function cipherIsBadData(cipher) {
return (cipher.name === null || cipher.name === '--') &&
(cipher.login && (cipher.login.password === null || cipher.login.password === ''));
}
function importError(error) {
$analytics.eventTrack('Import Data Failed', { label: $scope.model.source });
$uibModalInstance.dismiss('cancel');
if (error) {
var data = error.data;
if (data && data.ValidationErrors) {
var message = '';
for (var key in data.ValidationErrors) {
if (!data.ValidationErrors.hasOwnProperty(key)) {
continue;
}
for (var i = 0; i < data.ValidationErrors[key].length; i++) {
message += (key + ': ' + data.ValidationErrors[key][i] + ' ');
}
}
if (message !== '') {
toastr.error(message);
return;
}
}
else if (data && data.Message) {
toastr.error(data.Message);
return;
}
else {
toastr.error(error);
return;
}
}
toastr.error('Something went wrong. Try again.', 'Oh No!');
}
$scope.close = function () {
$uibModalInstance.dismiss('cancel');
};
}]);