enigma.js
No OneTemporary
Actions

Authored By

Unknown

Size

23 KB

Referenced Files

None

Subscribers

None

enigma.js
View Options

	/**
	* Enigma plugin script
	*
	* @licstart The following is the entire license notice for the
	* JavaScript code in this file.
	*
	* Copyright (c) The Roundcube Dev Team
	*
	* The JavaScript code in this page is free software: you can redistribute it
	* and/or modify it under the terms of the GNU General Public License
	* as published by the Free Software Foundation, either version 3 of
	* the License, or (at your option) any later version.
	*
	* @licend The above is the entire license notice
	* for the JavaScript code in this file.
	*/

	window.rcmail && rcmail.addEventListener('init', function(evt) {
	if (rcmail.env.task == 'settings') {
	if (rcmail.gui_objects.keyslist) {
	rcmail.keys_list = new rcube_list_widget(rcmail.gui_objects.keyslist,
	{multiselect:true, draggable:false, keyboard:true});
	rcmail.keys_list
	.addEventListener('select', function(o) { rcmail.enigma_keylist_select(o); })
	.addEventListener('keypress', function(o) { rcmail.list_keypress(o, {del: 'plugin.enigma-key-delete'}); })
	.init()
	.focus();

	rcmail.enigma_list();

	rcmail.register_command('firstpage', function(props) { return rcmail.enigma_list_page('first'); });
	rcmail.register_command('previouspage', function(props) { return rcmail.enigma_list_page('previous'); });
	rcmail.register_command('nextpage', function(props) { return rcmail.enigma_list_page('next'); });
	rcmail.register_command('lastpage', function(props) { return rcmail.enigma_list_page('last'); });
	}

	if (rcmail.env.action == 'plugin.enigmakeys') {
	rcmail.register_command('search', function(props) {return rcmail.enigma_search(props); }, true);
	rcmail.register_command('reset-search', function(props) {return rcmail.enigma_search_reset(props); }, true);
	rcmail.register_command('plugin.enigma-import', function() { rcmail.enigma_import(); }, true);
	rcmail.register_command('plugin.enigma-import-search', function() { rcmail.enigma_import_search(); }, true);
	rcmail.register_command('plugin.enigma-key-export', function() { rcmail.enigma_export(); });
	rcmail.register_command('plugin.enigma-key-export-selected', function() { rcmail.enigma_export(true); });
	rcmail.register_command('plugin.enigma-key-import', function() { rcmail.enigma_key_import(); }, true);
	rcmail.register_command('plugin.enigma-key-import-search', function() { rcmail.enigma_key_import_search(); }, true);
	rcmail.register_command('plugin.enigma-key-delete', function(props) { return rcmail.enigma_delete(); });
	rcmail.register_command('plugin.enigma-key-create', function(props) { return rcmail.enigma_key_create(); }, true);
	rcmail.register_command('plugin.enigma-key-save', function(props) { return rcmail.enigma_key_create_save(); }, true);

	rcmail.addEventListener('responseafterplugin.enigmakeys', function() {
	rcmail.enable_command('plugin.enigma-key-export', rcmail.env.rowcount > 0);
	rcmail.triggerEvent('listupdate', {list: rcmail.keys_list, rowcount: rcmail.env.rowcount});
	});

	if (rcmail.gui_objects.importform) {
	// make sure Enter key in search input starts searching
	// instead of submitting the form
	$('#rcmimportsearch').keydown(function(e) {
	if (e.which == 13) {
	rcmail.enigma_import_search();
	return false;
	}
	});
	}
	}
	}
	else if (rcmail.env.task == 'mail') {
	if (rcmail.env.action == 'compose') {
	rcmail.addEventListener('beforesend', function(props) { rcmail.enigma_beforesend_handler(props); })
	.addEventListener('beforesavedraft', function(props) { rcmail.enigma_beforesavedraft_handler(props); });

	$('#enigmamenu').find('input,label').mouseup(function(e) {
	// don't close the menu on mouse click inside
	e.stopPropagation();
	});

	$('a.button.enigma').prop('tabindex', $('#messagetoolbar > a').first().prop('tabindex'));

	$.each(['encrypt', 'sign'], function() {
	var opt = this, input = $('#enigma' + opt + 'opt');

	if (rcmail.env['enigma_force_' + opt]) {
	input.prop('checked', true);
	}

	// Compose status bar in Elastic
	if (window.UI && UI.compose_status) {
	input.on('change', function() { UI.compose_status(opt, this.checked); });
	}

	// As the options might have been initially enabled we have to
	// trigger onchange event, so all handlers can update the state
	input.trigger('change');
	});
	}

	if (rcmail.env.enigma_password_request) {
	rcmail.enigma_password_request(rcmail.env.enigma_password_request);
	}
	}
	});


	/*********************************************************/
	/******* Enigma Settings/Keys/Certs UI *******/
	/*********************************************************/

	// Display key(s) import form
	rcube_webmail.prototype.enigma_key_import = function()
	{
	var dialog = $('<iframe>').attr('src', this.url('plugin.enigmakeys', {_a: 'import', _framed: 1})),
	import_func = function(e) {
	var win = dialog[0].contentWindow;
	win.rcmail.enigma_import();
	};

	this.enigma_import_dialog = this.simple_dialog(dialog, this.gettext('enigma.importkeys'), import_func, {
	button: 'import',
	width: 500,
	height: 180
	});
	};

	// Display key(s) search/import form
	rcube_webmail.prototype.enigma_key_import_search = function()
	{
	var dialog = $('<iframe>').attr('src', this.url('plugin.enigmakeys', {_a: 'import-search', _framed: 1})),
	search_func = function() {
	var win = dialog[0].contentWindow;
	win.rcmail.enigma_import_search();
	};

	this.enigma_import_dialog = this.simple_dialog(dialog, this.gettext('enigma.keyimportsearchlabel'), search_func, {
	button: 'search',
	width: 500,
	height: 150
	});
	};

	rcube_webmail.prototype.enigma_import_success = function()
	{
	var dialog = this.enigma_import_dialog \|\| parent.rcmail.enigma_import_dialog;
	dialog.dialog('destroy');
	};

	// Display key(s) generation form
	rcube_webmail.prototype.enigma_key_create = function()
	{
	this.keys_list.clear_selection();
	this.enigma_loadframe('&_action=plugin.enigmakeys&_a=create&_nav=hide');
	};

	// Generate key(s) and submit them
	rcube_webmail.prototype.enigma_key_create_save = function()
	{
	var options, lock, users = [],
	password = $('#key-pass').val(),
	confirm = $('#key-pass-confirm').val(),
	type = $('#key-type').val();

	$('[name="identity[]"]:checked').each(function() {
	users.push({name: $(this).data('name') \|\| '', email: $(this).data('email')});
	});

	// validate the form
	if (!password \|\| !confirm) {
	this.alert_dialog(this.get_label('enigma.formerror'));
	return;
	}

	if (password != confirm) {
	this.alert_dialog(this.get_label('enigma.passwordsdiffer'));
	return;
	}

	if (!users.length) {
	this.alert_dialog(this.get_label('enigma.noidentselected'));
	return;
	}

	// generate keys
	// use OpenPGP.js if browser supports required features
	if (window.openpgp && window.crypto && window.crypto.getRandomValues) {
	lock = this.set_busy(true, 'enigma.keygenerating');
	options = {
	userIDs: users,
	passphrase: password,
	type: type.substring(0, 3)
	};

	if (type == 'ecc')
	options.curve = 'ed25519';
	else if (type == 'rsa4096')
	options.rsaBits = 4096;
	else
	options.rsaBits = 2048;

	openpgp.generateKey(options).then(function(keypair) {
	// success
	var post = {
	_a: 'import',
	_keys: keypair.privateKey,
	_generated: 1,
	_passwd: password
	};

	// send request to server
	rcmail.http_post('plugin.enigmakeys', post, lock);
	}, function(error) {
	// failure
	console.error(error);
	rcmail.set_busy(false, null, lock);
	rcmail.display_message(rcmail.get_label('enigma.keygenerateerror'), 'error');
	});
	}
	else {
	rcmail.display_message(rcmail.get_label('enigma.keygennosupport'), 'error');
	}
	};

	// Action executed after successful key generation and import
	rcube_webmail.prototype.enigma_key_create_success = function()
	{
	parent.rcmail.enigma_list(1);
	};

	// Delete key(s)
	rcube_webmail.prototype.enigma_delete = function()
	{
	var keys = this.keys_list.get_selection();

	if (!keys.length)
	return;

	this.confirm_dialog(this.get_label('enigma.keyremoveconfirm'), 'delete', function(e, ref) {
	var lock = ref.display_message(ref.get_label('enigma.keyremoving'), 'loading'),
	post = {_a: 'delete', _keys: keys};

	// send request to server
	ref.http_post('plugin.enigmakeys', post, lock);
	});
	};

	// Export key(s)
	rcube_webmail.prototype.enigma_export = function(selected)
	{
	var priv = false,
	list = this.keys_list,
	keys = selected ? list.get_selection().join(',') : '*',
	args = {_keys: keys};

	if (!keys.length)
	return;

	// find out whether selected keys are private
	if (keys == '*')
	priv = true;
	else
	$.each(list.get_selection(), function() {
	flags = $(list.rows[this].obj).data('flags');
	if (flags && flags.indexOf('p') >= 0) {
	priv = true;
	return false;
	}
	});

	// ask the user about including private key in the export
	if (priv)
	return this.show_popup_dialog(
	this.get_label('enigma.keyexportprompt'),
	this.get_label('enigma.exportkeys'),
	[{
	'class': 'export mainaction',
	text: this.get_label('enigma.onlypubkeys'),
	click: function(e) {
	rcmail.enigma_export_submit(args);
	$(this).remove();
	}
	},
	{
	'class': 'export',
	text: this.get_label('enigma.withprivkeys'),
	click: function(e) {
	args._priv = 1;
	rcmail.enigma_export_submit(args);
	$(this).remove();
	}
	},
	{
	'class': 'cancel',
	text: this.get_label('close'),
	click: function(e) {
	$(this).remove();
	}
	}],
	{width: 500}
	);

	this.enigma_export_submit(args);
	};

	// Submitting request for key(s) export
	// Done this way to handle password input
	rcube_webmail.prototype.enigma_export_submit = function(data)
	{
	var id = 'keyexport-' + new Date().getTime(),
	form = $('<form>').attr({target: id, method: 'post', style: 'display:none',
	action: '?_action=plugin.enigmakeys&_task=settings&_a=export'}),
	iframe = $('<iframe>').attr({name: id, style: 'display:none'})

	form.append($('<input>').attr({name: '_token', value: this.env.request_token}));
	$.each(data, function(i, v) {
	form.append($('<input>').attr({name: i, value: v}));
	});

	iframe.appendTo(document.body);
	form.appendTo(document.body).submit();
	};

	// Submit key(s) import form
	rcube_webmail.prototype.enigma_import = function()
	{
	var form, file, lock,
	id = 'keyimport-' + new Date().getTime();

	if (form = this.gui_objects.importform) {
	file = document.getElementById('rcmimportfile');
	if (file && !file.value) {
	this.alert_dialog(this.get_label('selectimportfile'));
	return;
	}

	lock = this.set_busy(true, 'importwait');
	$('<iframe>').attr({name: id, style: 'display:none'}).appendTo(document.body);
	$(form).attr({target: id, action: this.add_url(form.action, '_unlock', lock)}).submit();

	return true;
	}
	};

	// Search for key(s) for import
	rcube_webmail.prototype.enigma_import_search = function()
	{
	var form, search;

	if (form = this.gui_objects.importform) {
	search = $('#rcmimportsearch').val();
	if (!search) {
	return;
	}

	this.enigma_find_publickey(search);
	}
	};

	// list row selection handler
	rcube_webmail.prototype.enigma_keylist_select = function(list)
	{
	var id = list.get_single_selection(), url;

	if (id && !list.multi_selecting)
	url = '&_action=plugin.enigmakeys&_a=info&_id=' + id;

	this.enigma_loadframe(url);
	this.enable_command('plugin.enigma-key-delete', 'plugin.enigma-key-export-selected', list.get_selection().length > 0);
	};

	// load key frame
	rcube_webmail.prototype.enigma_loadframe = function(url)
	{
	var win;

	if (win = this.get_frame_window(this.env.contentframe)) {
	if (!url) {
	if (win.location && win.location.href.indexOf(this.env.blankpage) < 0)
	win.location.href = this.env.blankpage;
	if (this.env.frame_lock)
	this.set_busy(false, null, this.env.frame_lock);
	return;
	}

	this.env.frame_lock = this.set_busy(true, 'loading');
	win.location.href = this.env.comm_path + '&_framed=1' + url;
	}
	};

	// Search keys/certs
	rcube_webmail.prototype.enigma_search = function(props)
	{
	if (!props && this.gui_objects.qsearchbox)
	props = this.gui_objects.qsearchbox.value;

	if (props \|\| this.env.search_request) {
	var params = {'_a': 'search', '_q': props},
	lock = this.set_busy(true, 'searching');
	// if (this.gui_objects.search_filter)
	// addurl += '&_filter=' + this.gui_objects.search_filter.value;
	this.env.current_page = 1;
	this.enigma_loadframe();
	this.enigma_clear_list();
	this.http_post('plugin.enigmakeys', params, lock);
	}

	return false;
	};

	// Reset search filter and the list
	rcube_webmail.prototype.enigma_search_reset = function(props)
	{
	var s = this.env.search_request;
	this.reset_qsearch();

	if (s) {
	this.enigma_loadframe();
	this.enigma_clear_list();

	// refresh the list
	this.enigma_list();
	}

	return false;
	};

	// Keys/certs listing
	rcube_webmail.prototype.enigma_list = function(page, reset_frame)
	{
	if (this.is_framed())
	return parent.rcmail.enigma_list(page, reset_frame);

	var params = {'_a': 'list'},
	lock = this.set_busy(true, 'loading');

	this.env.current_page = page ? page : 1;

	if (this.env.search_request)
	params._q = this.env.search_request;
	if (page)
	params._p = page;

	this.enigma_clear_list(reset_frame);
	this.http_post('plugin.enigmakeys', params, lock);
	};

	// Change list page
	rcube_webmail.prototype.enigma_list_page = function(page)
	{
	if (page == 'next')
	page = this.env.current_page + 1;
	else if (page == 'last')
	page = this.env.pagecount;
	else if (page == 'prev' && this.env.current_page > 1)
	page = this.env.current_page - 1;
	else if (page == 'first' && this.env.current_page > 1)
	page = 1;

	this.enigma_list(page);
	};

	// Remove list rows
	rcube_webmail.prototype.enigma_clear_list = function(reset_frame)
	{
	if (reset_frame !== false)
	this.enigma_loadframe();

	if (this.keys_list)
	this.keys_list.clear(true);

	this.enable_command('plugin.enigma-key-delete', 'plugin.enigma-key-delete-selected', false);
	this.triggerEvent('listupdate', {list: this.keys_list, rowcount: this.keys_list.rowcount});
	};

	// Adds a row to the list
	rcube_webmail.prototype.enigma_add_list_row = function(r)
	{
	if (!this.gui_objects.keyslist \|\| !this.keys_list)
	return false;

	var list = this.keys_list,
	tbody = this.gui_objects.keyslist.tBodies[0],
	rowcount = tbody.rows.length,
	even = rowcount%2,
	// for performance use DOM instead of jQuery here
	row = document.createElement('tr'),
	col = document.createElement('td');

	row.id = 'rcmrow' + r.id;
	row.className = 'message';
	if (r.flags) $(row).data('flags', r.flags);

	col.className = 'name';
	col.innerHTML = r.name;
	row.appendChild(col);
	list.insert_row(row);
	};


	/*********************************************************/
	/******* Enigma Message methods *******/
	/*********************************************************/

	// handle message send/save action
	rcube_webmail.prototype.enigma_beforesend_handler = function(props)
	{
	this.env.last_action = 'send';
	this.enigma_compose_handler(props);
	};

	rcube_webmail.prototype.enigma_beforesavedraft_handler = function(props)
	{
	this.env.last_action = 'savedraft';
	this.enigma_compose_handler(props);
	};

	rcube_webmail.prototype.enigma_compose_handler = function(props)
	{
	var form = this.gui_objects.messageform;

	// copy inputs from enigma menu to the form (not used in Elastic)
	$('#enigmamenu input').each(function() {
	var id = this.id + '_cpy', input = $('#' + id);

	if (!input.length) {
	input = $(this).clone();
	input.prop({id: id, type: 'hidden'}).appendTo(form);
	}

	input.val(this.checked ? '1' : '');
	});
	};

	// Import attached keys/certs file
	rcube_webmail.prototype.enigma_import_attachment = function(mime_id)
	{
	var lock = this.set_busy(true, 'loading'),
	post = {_uid: this.env.uid, _mbox: this.env.mailbox, _part: mime_id};

	this.http_post('plugin.enigmaimport', post, lock);

	return false;
	};

	// password request popup
	rcube_webmail.prototype.enigma_password_request = function(data)
	{
	if (!data \|\| !data.keyid) {
	return;
	}

	var ref = this,
	msg = this.get_label('enigma.enterkeypass'),
	myprompt = $('<div class="prompt">'),
	myprompt_content = $('<p class="message">')
	.appendTo(myprompt),
	myprompt_input = $('<input>').attr({type: 'password', size: 30, 'data-submit': 'true'})
	.appendTo(myprompt);

	data.key = data.keyid;
	if (data.keyid.length > 8)
	data.keyid = data.keyid.substr(data.keyid.length - 8);

	$.each(['keyid', 'user'], function() {
	msg = msg.replace('$' + this, data[this]);
	});

	myprompt_content.text(msg);

	this.show_popup_dialog(myprompt, this.get_label('enigma.enterkeypasstitle'),
	[{
	text: this.get_label('ok'),
	'class': 'mainaction save unlock',
	click: function(e) {
	e.stopPropagation();

	var jq = ref.is_framed() ? window.parent.$ : $;

	data.password = myprompt_input.val();

	if (!data.password) {
	myprompt_input.focus();
	return;
	}

	ref.enigma_password_submit(data);
	jq(this).remove();
	}
	},
	{
	text: this.get_label('cancel'),
	'class': 'cancel',
	click: function(e) {
	var jq = ref.is_framed() ? window.parent.$ : $;
	e.stopPropagation();
	jq(this).remove();
	}
	}], {width: 400});

	if (this.is_framed() && parent.rcmail.message_list) {
	// this fixes bug when pressing Enter on "Save" button in the dialog
	parent.rcmail.message_list.blur();
	}
	};

	// submit entered password
	rcube_webmail.prototype.enigma_password_submit = function(data)
	{
	var lock, form;

	if (this.env.action == 'compose' && !data['compose-init']) {
	return this.enigma_password_compose_submit(data);
	}
	else if (this.env.action == 'plugin.enigmakeys' && (form = this.gui_objects.importform)) {
	if (!$('input[name="_keyid"]', form).length) {
	$(form).append($('<input>').attr({type: 'hidden', name: '_keyid', value: data.key}))
	.append($('<input>').attr({type: 'hidden', name: '_passwd', value: data.password}))
	}

	return this.enigma_import();
	}

	lock = data.nolock ? null : this.set_busy(true, 'loading');
	form = $('<form>')
	.attr({method: 'post', action: data.action \|\| location.href, style: 'display:none'})
	.append($('<input>').attr({type: 'hidden', name: '_keyid', value: data.key}))
	.append($('<input>').attr({type: 'hidden', name: '_passwd', value: data.password}))
	.append($('<input>').attr({type: 'hidden', name: '_token', value: this.env.request_token}))
	.append($('<input>').attr({type: 'hidden', name: '_unlock', value: lock}));

	// Additional form fields for request parameters
	$.each(data, function(i, v) {
	if (i.indexOf('input') == 0)
	form.append($('<input>').attr({type: 'hidden', name: i.substring(5), value: v}))
	});

	if (data.iframe) {
	var name = 'enigma_frame_' + (new Date()).getTime(),
	frame = $('<iframe>').attr({style: 'display:none', name: name}).appendTo(document.body);
	form.attr('target', name);
	}

	form.appendTo(document.body).submit();
	};

	// submit entered password - in mail compose page
	rcube_webmail.prototype.enigma_password_compose_submit = function(data)
	{
	var form = this.gui_objects.messageform;

	if (!$('input[name="_keyid"]', form).length) {
	$(form).append($('<input>').attr({type: 'hidden', name: '_keyid', value: data.key}))
	.append($('<input>').attr({type: 'hidden', name: '_passwd', value: data.password}));
	}
	else {
	$('input[name="_keyid"]', form).val(data.key);
	$('input[name="_passwd"]', form).val(data.password);
	}

	this.submit_messageform(this.env.last_action == 'savedraft');
	};

	// Display no-key error with key search button
	rcube_webmail.prototype.enigma_key_not_found = function(data)
	{
	var params = {width: 500, dialogClass: 'error'},
	buttons = [{
	'class': 'mainaction search',
	text: data.button,
	click: function() {
	$(this).remove();
	rcmail.enigma_find_publickey(data.email);
	}
	}];

	if (data.mode == 'encrypt') {
	buttons.push({
	'class': 'send',
	text: rcmail.get_label('enigma.sendunencrypted'),
	click: function(e) {
	$(this).remove();
	$('#enigmaencryptopt').prop('checked', false).change();
	rcmail.command('send', {nocheck: true}, e.target, e.originalEvent);
	}
	});
	}

	buttons.push({
	'class': 'cancel',
	text: this.get_label('cancel'),
	click: function() {
	$(this).remove();
	}
	});

	return this.show_popup_dialog(data.text, data.title, buttons, params);
	};

	// Search for a public key on the key server
	rcube_webmail.prototype.enigma_find_publickey = function(email)
	{
	this.mailvelope_search_pubkeys([email],
	function(status) {},
	function(key) {
	var lock = rcmail.set_busy(true, 'enigma.importwait'),
	post = {_a: 'import', _keys: key};

	if (rcmail.env.action == 'plugin.enigmakeys')
	post._refresh = 1;

	// send request to server
	rcmail.http_post('plugin.enigmakeys', post, lock);
	}
	);
	};

File Metadata

Mime Type: text/plain
Expires: Sat, Apr 4, 4:06 AM (2 h, 56 m ago)
Storage Engine: local-disk
Storage Format: Raw Data
Storage Handle: d2/f3/e64f371ed2b51cec69d554279e68
Default Alt Text: enigma.js (23 KB)

enigma.jsNo OneTemporaryActions

enigma.jsView Options

File Metadata

Event Timeline

enigma.js
No OneTemporary
Actions

enigma.js
View Options