Page MenuHome GnuPG
Files F36624205

enigmail.js
No OneTemporary
Actions

enigmail.js
View Options

/*
* The contents of this file are subject to the Mozilla Public
* License Version 1.1 (the "MPL"); you may not use this file
* except in compliance with the MPL. You may obtain a copy of
* the MPL at http://www.mozilla.org/MPL/
*
* Software distributed under the MPL is distributed on an "AS
* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
* implied. See the MPL for the specific language governing
* rights and limitations under the MPL.
*
* The Original Code is Enigmail.
*
* The Initial Developer of the Original Code is Ramalingam Saravanan.
* Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
* Copyright (C) 2001 Ramalingam Saravanan. All Rights Reserved.
*
* Contributor(s):
* Patrick Brunschwig <patrick.brunschwig@gmx.net>
*
* Alternatively, the contents of this file may be used under the
* terms of the GNU General Public License (the "GPL"), in which case
* the provisions of the GPL are applicable instead of
* those above. If you wish to allow use of your version of this
* file only under the terms of the GPL and not to allow
* others to use your version of this file under the MPL, indicate
* your decision by deleting the provisions above and replace them
* with the notice and other provisions required by the GPL.
* If you do not delete the provisions above, a recipient
* may use your version of this file under either the MPL or the
* GPL.
*/
// Maximum size of message directly processed by Enigmail
const MSG_BUFFER_SIZE = 98304; // 96 kB
const MAX_MSG_BUFFER_SIZE = 512000 // slightly less than 512 kB
const ERROR_BUFFER_SIZE = 16384; // 16 kB
const PGP_BATCH_OPTS = " +batchmode +force";
const GPG_BATCH_OPTS = " --batch --no-tty --status-fd 2";
const gDummyPKCS7 = 'Content-Type: multipart/mixed;\r\n boundary="------------060503030402050102040303\r\n\r\nThis is a multi-part message in MIME format.\r\n--------------060503030402050102040303\r\nContent-Type: application/x-pkcs7-mime\r\nContent-Transfer-Encoding: 8bit\r\n\r\n\r\n--------------060503030402050102040303\r\nContent-Type: application/x-enigmail-dummy\r\nContent-Transfer-Encoding: 8bit\r\n\r\n\r\n--------------060503030402050102040303--\r\n';
/* Implementations supplied by this module */
const NS_ENIGMAIL_CONTRACTID = "@mozdev.org/enigmail/enigmail;1";
const NS_PGP_MODULE_CONTRACTID = "@mozilla.org/mimecth/pgp;1";
const NS_ENIGMAILPROTOCOLHANDLER_CONTRACTID =
"@mozilla.org/network/protocol;1?name=enigmail";
const NS_ENIGMAIL_CID =
Components.ID("{847b3a01-7ab1-11d4-8f02-006008948af5}");
const NS_ENIGMAILPROTOCOLHANDLER_CID =
Components.ID("{847b3a11-7ab1-11d4-8f02-006008948af5}");
const NS_PGP_MODULE_CID =
Components.ID("{847b3af1-7ab1-11d4-8f02-006008948af5}");
const NS_ENIGMSGCOMPOSE_CID =
Components.ID("{847b3a21-7ab1-11d4-8f02-006008948af5}");
const NS_ENIGMSGCOMPOSEFACTORY_CID =
Components.ID("{847b3a22-7ab1-11d4-8f02-006008948af5}");
const NS_ENIGCLINE_SERVICE_CID =
Components.ID("{847b3ab1-7ab1-11d4-8f02-006008948af5}");
// Contract IDs and CIDs used by this module
const NS_IPCSERVICE_CONTRACTID = "@mozilla.org/process/ipc-service;1";
const NS_IPCBUFFER_CONTRACTID = "@mozilla.org/process/ipc-buffer;1";
const NS_PIPECONSOLE_CONTRACTID = "@mozilla.org/process/pipe-console;1";
const NS_PIPETRANSPORT_CONTRACTID="@mozilla.org/process/pipe-transport;1";
const NS_PROCESSINFO_CONTRACTID = "@mozilla.org/xpcom/process-info;1";
const NS_MSGCOMPOSESECURE_CONTRACTID = "@mozilla.org/messengercompose/composesecure;1";
const NS_ENIGMSGCOMPOSE_CONTRACTID = "@mozilla.org/enigmail/composesecure;1";
const NS_ENIGMSGCOMPOSEFACTORY_CONTRACTID = "@mozilla.org/enigmail/composesecure-factory;1";
const NS_ENIGMIMESERVICE_CONTRACTID = "@mozdev.org/enigmail/enigmimeservice;1";
const NS_SIMPLEURI_CONTRACTID = "@mozilla.org/network/simple-uri;1";
const NS_TIMER_CONTRACTID = "@mozilla.org/timer;1";
const NS_OBSERVERSERVICE_CONTRACTID = "@mozilla.org/observer-service;1";
const NS_PROMPTSERVICE_CONTRACTID = "@mozilla.org/embedcomp/prompt-service;1";
const ASS_CONTRACTID = "@mozilla.org/appshell/appShellService;1";
const WMEDIATOR_CONTRACTID = "@mozilla.org/rdf/datasource;1?name=window-mediator";
const NS_IOSERVICE_CONTRACTID = "@mozilla.org/network/io-service;1";
const NS_ISCRIPTABLEUNICODECONVERTER_CONTRACTID = "@mozilla.org/intl/scriptableunicodeconverter";
const NS_SCRIPTABLEINPUTSTREAM_CONTRACTID = "@mozilla.org/scriptableinputstream;1"
const ENIG_STRINGBUNDLE_CONTRACTID = "@mozilla.org/intl/stringbundle;1";
const NS_PREFS_SERVICE_CID = "@mozilla.org/preferences-service;1";
const NS_DOMPARSER_CONTRACTID = "@mozilla.org/xmlextras/domparser;1";
const NS_DOMSERIALIZER_CONTRACTID = "@mozilla.org/xmlextras/xmlserializer;1";
const NS_CATMAN_CONTRACTID = "@mozilla.org/categorymanager;1";
const NS_CLINE_SERVICE_CONTRACTID = "@mozilla.org/commandlinehandler/general-startup;1?type=pgpkeyman";
// Interfaces
const nsISupports = Components.interfaces.nsISupports;
const nsIObserver = Components.interfaces.nsIObserver;
const nsILocalFile = Components.interfaces.nsILocalFile;
const nsIProtocolHandler = Components.interfaces.nsIProtocolHandler;
const nsIIPCService = Components.interfaces.nsIIPCService;
const nsIPipeConsole = Components.interfaces.nsIPipeConsole;
const nsIProcessInfo = Components.interfaces.nsIProcessInfo;
const nsIEnigmail = Components.interfaces.nsIEnigmail;
//const nsIPGPModule = Components.interfaces.nsIPGPModule;
//const nsIPGPMsgBody = Components.interfaces.nsIPGPMsgBody;
//const nsIPGPMsgHeader = Components.interfaces.nsIPGPMsgHeader;
const nsIEnigStrBundle = Components.interfaces.nsIStringBundleService;
const nsICmdLineHandler = Components.interfaces.nsICmdLineHandler;
const nsICategoryManager = Components.interfaces.nsICategoryManager;
const nsIWindowWatcher = Components.interfaces.nsIWindowWatcher;
const NS_XPCOM_SHUTDOWN_OBSERVER_ID = "xpcom-shutdown";
///////////////////////////////////////////////////////////////////////////////
// Global variables
const GPG_COMMENT_OPT = "Using GnuPG with %s - http://enigmail.mozdev.org";
var gLogLevel = 3; // Output only errors/warnings by default
var gEnigmailSvc = null; // Global Enigmail Service
var gCachedPassphrase = null; // Cached passphrase
var gCacheTimer = null; // Cache timer
var gXULOwner = null; // Global XUL owner
var gEnvList = []; // Global environment list
var gEnigStrBundle; // Global string bundle
// GPG status flags mapping (see doc/DETAILS file in the GnuPG distribution)
var gStatusFlags = {GOODSIG: nsIEnigmail.GOOD_SIGNATURE,
BADSIG: nsIEnigmail.BAD_SIGNATURE,
ERRSIG: nsIEnigmail.UNVERIFIED_SIGNATURE,
EXPSIG: nsIEnigmail.EXPIRED_SIGNATURE,
REVKEYSIG: nsIEnigmail.GOOD_SIGNATURE,
EXPKEYSIG: nsIEnigmail.EXPIRED_KEY_SIGNATURE,
KEYEXPIRED: nsIEnigmail.EXPIRED_KEY,
KEYREVOKED: nsIEnigmail.REVOKED_KEY,
NO_PUBKEY: nsIEnigmail.NO_PUBKEY,
NO_SECKEY: nsIEnigmail.NO_SECKEY,
IMPORTED: nsIEnigmail.IMPORTED_KEY,
INV_RECP: nsIEnigmail.INVALID_RECIPIENT,
MISSING_PASSPHRASE: nsIEnigmail.MISSING_PASSPHRASE,
BAD_PASSPHRASE: nsIEnigmail.BAD_PASSPHRASE,
BADARMOR: nsIEnigmail.BAD_ARMOR,
NODATA: nsIEnigmail.NODATA,
DECRYPTION_FAILED: nsIEnigmail.DECRYPTION_FAILED,
DECRYPTION_OKAY: nsIEnigmail.DECRYPTION_OKAY,
TRUST_UNDEFINED: nsIEnigmail.UNTRUSTED_IDENTITY,
TRUST_NEVER: nsIEnigmail.UNTRUSTED_IDENTITY,
TRUST_MARGINAL: nsIEnigmail.UNTRUSTED_IDENTITY,
TRUST_FULLY: nsIEnigmail.TRUSTED_IDENTITY,
TRUST_ULTIMATE: nsIEnigmail.TRUSTED_IDENTITY
};
///////////////////////////////////////////////////////////////////////////////
// File read/write operations
const NS_LOCAL_FILE_CONTRACTID = "@mozilla.org/file/local;1";
const NS_LOCALFILEOUTPUTSTREAM_CONTRACTID =
"@mozilla.org/network/file-output-stream;1";
const NS_RDONLY = 0x01;
const NS_WRONLY = 0x02;
const NS_CREATE_FILE = 0x08;
const NS_TRUNCATE = 0x20;
const DEFAULT_FILE_PERMS = 0600;
const GET_BOOL = "GET_BOOL";
const GET_LINE = "GET_LINE";
const GET_HIDDEN = "GET_HIDDEN";
const BUTTON_POS_0 = 1;
const BUTTON_POS_1 = 1 << 8;
const BUTTON_POS_2 = 1 << 16;
function CreateFileStream(filePath, permissions) {
//DEBUG_LOG("enigmail.js: CreateFileStream: file="+filePath+"\n");
try {
var localFile = Components.classes[NS_LOCAL_FILE_CONTRACTID].createInstance(Components.interfaces.nsILocalFile);
localFile.initWithPath(filePath);
if (localFile.exists()) {
if (localFile.isDirectory() || !localFile.isWritable())
throw Components.results.NS_ERROR_FAILURE;
if (!permissions)
permissions = localFile.permissions;
}
if (!permissions)
permissions = DEFAULT_FILE_PERMS;
var flags = NS_WRONLY | NS_CREATE_FILE | NS_TRUNCATE;
var fileStream = Components.classes[NS_LOCALFILEOUTPUTSTREAM_CONTRACTID].createInstance(Components.interfaces.nsIFileOutputStream);
fileStream.init(localFile, flags, permissions, 0);
return fileStream;
} catch (ex) {
ERROR_LOG("enigmail.js: CreateFileStream: Failed to create "+filePath+"\n");
return null;
}
}
function WriteFileContents(filePath, data, permissions) {
DEBUG_LOG("enigmail.js: WriteFileContents: file="+filePath+"\n");
try {
var fileOutStream = CreateFileStream(filePath, permissions);
if (data.length) {
if (fileOutStream.write(data, data.length) != data.length)
throw Components.results.NS_ERROR_FAILURE;
fileOutStream.flush();
}
fileOutStream.close();
} catch (ex) {
ERROR_LOG("enigmail.js: WriteFileContents: Failed to write to "+filePath+"\n");
return false;
}
return true;
}
// Pack/unpack: Network (big-endian) byte order
function pack(value, bytes) {
var str = '';
var mask = 0xff;
for (var j=0; j < bytes; j++) {
str = String.fromCharCode( (value & mask) >> j*8 ) + str;
mask <<= 8;
}
return str;
}
function unpack(str) {
var len = str.length;
var value = 0;
for (var j=0; j < len; j++) {
value <<= 8;
value |= str.charCodeAt(j);
}
return value;
}
const hexTable = "0123456789abcdef";
function bytesToHex(str) {
var len = str.length;
var hex = '';
for (var j=0; j < len; j++) {
var charCode = str.charCodeAt(j);
hex += hexTable.charAt((charCode & 0xf0) >> 4) +
hexTable.charAt((charCode & 0x0f));
}
return hex;
}
function hexToBytes(hex) {
hex = hex.toLowerCase();
var bytes = (1+hex.length)/2;
var str = '';
for (var j=0; j < bytes; j++) {
var loc1 = hexTable.indexOf(hex.charAt(2*j));
var loc2 = 0;
if ((2*j+1) < hex.length)
loc2 = hexTable.indexOf(hex.charAt(2*j+1));
if (loc1 < 0) loc1 = 0;
if (loc2 < 0) loc2 = 0;
str += String.fromCharCode((loc1 << 4) + loc2);
}
return str;
}
///////////////////////////////////////////////////////////////////////////////
function WRITE_LOG(str) {
if (gLogLevel >= 4)
dump(str);
if (gEnigmailSvc && gEnigmailSvc.logFileStream) {
gEnigmailSvc.logFileStream.write(str, str.length);
//gEnigmailSvc.logFileStream.flush();
}
}
function DEBUG_LOG(str) {
if ((gLogLevel >= 4) || (gEnigmailSvc && gEnigmailSvc.logFileStream))
WRITE_LOG(str);
}
function WARNING_LOG(str) {
if (gLogLevel >= 3)
WRITE_LOG(str);
if (gEnigmailSvc && gEnigmailSvc.console)
gEnigmailSvc.console.write(str);
}
function ERROR_LOG(str) {
if (gLogLevel >= 2)
WRITE_LOG(str);
if (gEnigmailSvc && gEnigmailSvc.console)
gEnigmailSvc.console.write(str);
}
function CONSOLE_LOG(str) {
if (gLogLevel >= 3)
WRITE_LOG(str);
if (gEnigmailSvc && gEnigmailSvc.console)
gEnigmailSvc.console.write(str);
}
///////////////////////////////////////////////////////////////////////////////
var EnigModuleObj = {
registerSelf: function (compRegistrar, moduleFile,
registryLocation, componentType)
{
WRITE_LOG("enigmail.js: Registering components\n");
compRegistrar = compRegistrar.QueryInterface(Components.interfaces.nsIComponentRegistrar);
compRegistrar.registerFactoryLocation(NS_ENIGMAIL_CID,
"Enigmail",
NS_ENIGMAIL_CONTRACTID,
moduleFile, registryLocation,
componentType);
compRegistrar.registerFactoryLocation(NS_ENIGMAILPROTOCOLHANDLER_CID,
"Enigmail Protocol Handler",
NS_ENIGMAILPROTOCOLHANDLER_CONTRACTID,
moduleFile, registryLocation,
componentType);
compRegistrar.registerFactoryLocation(NS_PGP_MODULE_CID,
"PGP Module",
NS_PGP_MODULE_CONTRACTID,
moduleFile, registryLocation,
componentType);
compRegistrar.registerFactoryLocation(NS_ENIGCLINE_SERVICE_CID,
"Enigmail Key Management CommandLine Service",
NS_CLINE_SERVICE_CONTRACTID,
moduleFile,
registryLocation,
componentType);
var catman = Components.classes[NS_CATMAN_CONTRACTID].getService(nsICategoryManager);
catman.addCategoryEntry("command-line-argument-handlers",
"Enigmail Key Management command line handler",
NS_CLINE_SERVICE_CONTRACTID, true, true);
WRITE_LOG("enigmail.js: Registered components\n");
},
unregisterSelf: function(compRegistrar, moduleFile, registryLocation)
{
DEBUG_LOG("enigmail.js: unregisterSelf\n");
compRegistrar = compRegistrar.QueryInterface(Components.interfaces.nsIComponentRegistrar);
compRegistrar.unregisterFactoryLocation(NS_ENIGCLINE_SERVICE_CID,
moduleFile);
var catman = Components.classes[NS_CATMAN_CONTRACTID]
.getService(nsICategoryManager);
catman.deleteCategoryEntry("command-line-argument-handlers",
NS_CLINE_SERVICE_CONTRACTID, true);
},
getClassObject: function (compRegistrar, cid, iid) {
DEBUG_LOG("enigmail.js: getClassObject: cid="+cid+"\n");
if (!iid.equals(Components.interfaces.nsIFactory))
throw Components.results.NS_ERROR_NOT_IMPLEMENTED;
if (gEnigmailSvc == null) {
// Create Enigmail Service (delay initialization)
gEnigmailSvc = new Enigmail(false);
}
if (cid.equals(NS_ENIGCLINE_SERVICE_CID))
return EnigCLineFactory;
if (cid.equals(NS_ENIGMAIL_CID)) {
return new EnigmailFactory();
}
if (cid.equals(NS_ENIGMAILPROTOCOLHANDLER_CID)) {
return new EnigmailProtocolHandlerFactory();
}
if (cid.equals(NS_PGP_MODULE_CID)) {
return new PGPModuleFactory();
}
return null;
},
canUnload: function(compRegistrar)
{
DEBUG_LOG("enigmail.js: canUnload:\n");
return true;
}
};
/* Module entry point */
function NSGetModule(compRegistrar, moduleFile) {
DEBUG_LOG("enigmail.js: NSGetModule:\n");
return EnigModuleObj;
}
///////////////////////////////////////////////////////////////////////////////
function EnigmailFactory()
{
}
EnigmailFactory.prototype = {
QueryInterface: function (iid) {
//DEBUG_LOG("EnigmailFactory.QueryInterface:"+iid+"\n");
if (!iid.equals(Components.interfaces.nsIFactory) &&
!iid.equals(nsISupports))
throw Components.results.NS_ERROR_NO_INTERFACE;
return this;
},
createInstance: function (outer, iid) {
//DEBUG_LOG("EnigmailFactory.createInstance:\n");
if (!gEnigmailSvc)
throw Components.results.NS_ERROR_NOT_D;
return gEnigmailSvc;
}
}
function PGPModuleFactory()
{
}
PGPModuleFactory.prototype = {
QueryInterface: function (iid) {
//DEBUG_LOG("PGPModuleFactory.QueryInterface:"+iid+"\n");
if (!iid.equals(Components.interfaces.nsIFactory) &&
!iid.equals(nsISupports))
throw Components.results.NS_ERROR_NO_INTERFACE;
return this;
},
createInstance: function (outer, iid) {
DEBUG_LOG("PGPModuleFactory.createInstance:\n");
return new PGPModule();
}
}
function PGPMsgHeader(aTo, aCc, aBcc)
{
this.to = aTo;
this.cc = aCc;
this.bcc = aBcc;
}
PGPMsgHeader.prototype = {
to: "",
cc: "",
bcc: "",
QueryInterface: function (iid) {
DEBUG_LOG("PGPMsgHeader.QueryInterface:\n");
if (!iid.equals(nsIPGPMsgHeader) && !iid.equals(nsISupports))
throw Components.results.NS_ERROR_NO_INTERFACE;
return this;
}
}
/*
function PGPMsgBody(aBody)
{
this.body = aBody;
}
PGPMsgBody.prototype = {
body: "",
QueryInterface: function (iid) {
DEBUG_LOG("PGPMsgBody.QueryInterface:\n");
if (!iid.equals(nsIPGPMsgBody) && !iid.equals(nsISupports))
throw Components.results.NS_ERROR_NO_INTERFACE;
return this;
}
}
function PGPModule()
{
}
PGPModule.prototype = {
QueryInterface: function (iid) {
DEBUG_LOG("PGPModule.QueryInterface:\n");
if (!iid.equals(nsIPGPModule) && !iid.equals(nsISupports))
throw Components.results.NS_ERROR_NO_INTERFACE;
return this;
},
// void SetEncrypt(in boolean aEncrypt, in long aFlags,
// [retval] out long aNewFlags);
SetEncrypt: function (aEncrypt, aFlags, aNewFlags) {
DEBUG_LOG("PGPModule.SetEncrypt:\n");
return 0;
},
// void SetSign(in boolean aSign, in long aFlags,
// [retval] out long aNewFlags);
SetSign: function (aSign, aFlags, aNewFlags) {
DEBUG_LOG("PGPModule.SetSign:\n");
return 0;
},
// void SetPGPMIME(in boolean aMime, in long aFlags,
// [retval] out long aNewFlags);
SetPGPMIME: function (aMime, Flags, aNewFlags) {
DEBUG_LOG("PGPModule.SetPGPMIME:\n");
return 0;
},
// nsISupports CreateMsgHeader(in string aTo, in string aCc, in string aBcc);
CreateMsgHeader: function (aTo, aCc, aBcc) {
DEBUG_LOG("PGPModuleCreateMsgHeader.:\n");
return new PGPMsgHeader(aTo, aCc, aBcc);
},
//nsISupports CreateMsgBody(in string aBody);
CreateMsgBody: function (aBody) {
DEBUG_LOG("PGPModule.CreateMsgBody: "+aBody+"\n");
return new PGPMsgBody(aBody);
},
// string GetStringFromMsgBody(in nsISupports aMsgBody);
GetStringFromMsgBody: function (aMsgBody) {
DEBUG_LOG("PGPModule.GetStringFromMsgBody:\n");
aMsgBody = aMsgBody.QueryInterface(nsIPGPMsgBody);
return aMsgBody.body;
},
// void EncryptSign(in long aFlags, in nsISupports aMsgHeader,
// in nsISupports aOrigBody,
// [retval] out nsISupports aNewBody);
EncryptSign: function (aFlags, aMsgHeader, aOrigBody, aNewBody) {
DEBUG_LOG("PGPModule.EncryptSign:\n");
aMsgHeader = aMsgHeader.QueryInterface(nsIPGPMsgHeader);
aOrigBody = aOrigBody.QueryInterface(nsIPGPMsgBody);
DEBUG_LOG("PGPModule.EncryptSign: aMsgHeader.to="+aMsgHeader.to+"\n");
DEBUG_LOG("PGPModule.EncryptSign: aOrigBody.body="+aOrigBody.body+"\n");
DEBUG_LOG("PGPModule.EncryptSign: aNewBody="+aNewBody+"\n");
var exitCodeObj = new Object();
var statusFlagsObj = new Object();
var errorMsgObj = new Object();
var encryptFlags = nsIEnigmail.SEND_SIGNED | nsIEnigmail.SEND_ENCRYPTED;
var cipherText = gEnigmailSvc.encryptMessage(null, 0,
aOrigBody.body,
"",
aMsgHeader.to,
encryptFlags,
exitCodeObj,
statusFlagsObj,
errorMsgObj);
return new PGPMsgBody(cipherText);
},
// void DecryptVerify(in nsISupports aOrigBody,
// [retval] out nsISupports aNewBody)
DecryptVerify: function (aOrigBody, aNewBody) {
DEBUG_LOG("PGPModule.DecryptVerify:\n");
aOrigBody = aOrigBody.QueryInterface(nsIPGPMsgBody);
DEBUG_LOG("PGPModule.DecryptVerify: aOrigBody.body="+aOrigBody.body+"\n");
var exitCodeObj = new Object();
var errorMsgObj = new Object();
var signatureObj = new Object();
var statusFlagsObj = new Object();
var keyIdObj = new Object();
var userIdObj = new Object();
var plainText = gEnigmailSvc.decryptMessage(null, 0,
aOrigBody.body,
signatureObj,
exitCodeObj,
statusFlagsObj,
keyIdObj,
userIdObj,
errorMsgObj);
return new PGPMsgBody(plainText);
},
// void FreeMsgHeader(in nsISupports aMsgHeader);
FreeMsgHeader: function (aMsgHeader) {
DEBUG_LOG("PGPModule.FreeMsgHeader:\n");
},
// void FreeMsgBody(in nsISupports aMsgBody);
FreeMsgBody: function (aMsgBody) {
DEBUG_LOG("PGPModule.FreeMsgBody:\n");
},
// void FindHeader(in string aHeaderBuffer, in string aHeaderStr,
// out long aHeaderStartOffset, out long aHeaderLength,
// [retval] out long aBufferEndOffset);
FindHeader: function (aHeaderBuffer, aHeaderStr,
aHeaderStartOffset, aHeaderLength, aBufferEndOffset) {
DEBUG_LOG("PGPModule.FindHeader:\n");
DEBUG_LOG("PGPModule.EncryptSign: aHeaderBuffer="+aHeaderBuffer+"\n");
for (var k in aHeaderStartOffset)
DEBUG_LOG("PGPModule.EncryptSign: k="+k+"\n");
DEBUG_LOG("PGPModule.EncryptSign: aHeaderStartOffset="+aHeaderStartOffset+"\n");
DEBUG_LOG("PGPModule.EncryptSign: aHeaderLength="+aHeaderLength+"\n");
DEBUG_LOG("PGPModule.EncryptSign: aBufferEndOffset="+aBufferEndOffset+"\n");
aHeaderStartOffset.value = 0;
aHeaderLength.value = 0;
aBufferEndOffset.value = 0;
},
// boolean ContainsPGPContent(in string aBuffer);
ContainsPGPContent: function (aBuffer) {
DEBUG_LOG("PGPModule.ContainsPGPContent:\n");
return false;
}
}
*/
///////////////////////////////////////////////////////////////////////////////
// Utility functions
///////////////////////////////////////////////////////////////////////////////
function isAbsolutePath(filePath, isDosLike) {
// Check if absolute path
if (isDosLike) {
return (filePath.search(/^\w+:\\/) == 0);
} else {
return (filePath.search(/^\//) == 0)
}
}
function ResolvePath(filePath, envPath, isDosLike) {
DEBUG_LOG("enigmail.js: ResolvePath: filePath="+filePath+"\n");
if (isAbsolutePath(filePath, isDosLike))
return filePath;
if (!envPath)
return null;
var pathDirs = envPath.split(isDosLike ? ";" : ":");
for (var j=0; j<pathDirs.length; j++) {
try {
var pathDir = Components.classes[NS_LOCAL_FILE_CONTRACTID].createInstance(nsILocalFile);
pathDir.initWithPath(pathDirs[j]);
if (pathDir.exists() && pathDir.isDirectory()) {
pathDir.appendRelativePath(filePath);
if (pathDir.exists()) {
return pathDir.path;
}
}
} catch (ex) {
}
}
return null;
}
function EnigConvertToUnicode(text, charset) {
DEBUG_LOG("enigmail.js: EnigConvertToUnicode: "+charset+"\n");
if (!text || !charset || (charset.toLowerCase() == "iso-8859-1"))
return text;
// Encode plaintext
try {
var unicodeConv = Components.classes[NS_ISCRIPTABLEUNICODECONVERTER_CONTRACTID].getService(Components.interfaces.nsIScriptableUnicodeConverter);
unicodeConv.charset = charset;
return unicodeConv.ConvertToUnicode(text);
} catch (ex) {
return text;
}
}
function EnigConvertGpgToUnicode(text) {
if (typeof(text)=="string") {
var a=text.search(/[\x80-\xFF]{2}/);
var b=0;
while (a>=0) {
var ch=text.substr(a,2).toSource().substr(13,8).replace(/\\x/g, "\\u00");
var newCh=EnigConvertToUnicode(EnigConvertToUnicode(ch, "x-u-escaped"), "utf-8");
if (newCh != ch) {
//dump(ch+"\n");
var r=new RegExp(text.substr(a, 2), "g");
text=text.replace(r, newCh);
}
b=a+2;
a=text.substr(b+2).search(/[\x80-\xFF]{2}/);
if (a>=0) {
a += b+2;
}
}
a=text.search(/\\x3a/i);
if (a>0) {
text = text.replace(/\\x3a/ig, "\\e3A");
}
a=text.search(/\\x/);
while (a>=0) {
ch=text.substr(a,4).replace(/\\x/g, "\\u00");
newCh=EnigConvertToUnicode(ch, "x-u-escaped");
if (newCh != ch) {
r=new RegExp("\\"+text.substr(a, 4), "g");
text=text.replace(r, newCh);
}
a=text.search(/\\x/);
}
}
return text;
}
///////////////////////////////////////////////////////////////////////////////
// Enigmail protocol handler
///////////////////////////////////////////////////////////////////////////////
function EnigmailProtocolHandler()
{
}
EnigmailProtocolHandler.prototype.scheme = "enigmail";
EnigmailProtocolHandler.prototype.defaultPort = -1;
EnigmailProtocolHandler.prototype.QueryInterface =
function (iid)
{
DEBUG_LOG("enigmail.js: EnigmailProtocolHandler.QueryInterface\n");
if (!iid.equals(nsIProtocolHandler) && !iid.equals(nsISupports))
throw Components.results.NS_ERROR_NO_INTERFACE;
return this;
}
EnigmailProtocolHandler.prototype.newURI =
function (aSpec, originCharset, aBaseURI)
{
DEBUG_LOG("enigmail.js: EnigmailProtocolHandler.newURI: aSpec='"+aSpec+"'\n");
var uri = Components.classes[NS_SIMPLEURI_CONTRACTID].createInstance(Components.interfaces.nsIURI);
uri.spec = aSpec;
return uri;
}
EnigmailProtocolHandler.prototype.newChannel =
function (aURI)
{
DEBUG_LOG("enigmail.js: EnigmailProtocolHandler.newChannel: URI='"+aURI.spec+"'\n");
var messageId = ExtractMessageId(aURI.spec);
if (messageId) {
// Handle enigmail:message?id=...
if (!gEnigmailSvc)
throw Components.results.NS_ERROR_FAILURE;
var contentType, contentCharset, contentData;
if (gEnigmailSvc._messageIdList[messageId]) {
var messageUriObj = gEnigmailSvc._messageIdList[messageId];
contentType = messageUriObj.contentType;
contentCharset = messageUriObj.contentCharset;
contentData = messageUriObj.contentData;
DEBUG_LOG("enigmail.js: EnigmailProtocolHandler.newChannel: messageURL="+messageUriObj.originalUrl+", "+contentType+", "+contentCharset+"\n");
if (!messageUriObj.persist)
delete gEnigmailSvc._messageIdList[messageId];
} else {
contentType = "text/plain";
contentCharset = "";
contentData = "Enigmail error: invalid URI "+aURI.spec;
}
var channel = gEnigmailSvc.ipcService.newStringChannel(aURI,
contentType,
"UTF-8",
contentData);
return channel;
}
if (aURI.spec == aURI.scheme+":dummy") {
// Dummy PKCS7 content (to access mimeEncryptedClass)
channel = gEnigmailSvc.ipcService.newStringChannel(aURI,
"message/rfc822",
"",
gDummyPKCS7);
return channel;
}
var winName, spec;
if (aURI.spec == "about:"+aURI.scheme) {
// About Enigmail
winName = "about:"+enigmail;
spec = "chrome://enigmail/content/enigmailAbout.xul";
} else if (aURI.spec == aURI.scheme+":console") {
// Display enigmail console messages
winName = "enigmail:console";
spec = "chrome://enigmail/content/enigmailConsole.xul";
} else if (aURI.spec == aURI.scheme+":keygen") {
// Display enigmail key generation console
winName = "enigmail:keygen";
spec = "chrome://enigmail/content/enigmailKeygen.xul";
} else {
// Display Enigmail about page
winName = "about:enigmail";
spec = "chrome://enigmail/content/enigmailAbout.xul";
}
var windowManager = Components.classes[WMEDIATOR_CONTRACTID].getService(Components.interfaces.nsIWindowMediator);
var recentWin = windowManager.getMostRecentWindow(winName);
dump("recentWin="+recentWin+"\n");
if (recentWin) {
recentWin.focus();
} else {
var appShellSvc = Components.classes[ASS_CONTRACTID].getService(Components.interfaces.nsIAppShellService);
var domWin = appShellSvc.hiddenDOMWindow;
domWin.open(spec, "_blank", "chrome,menubar,toolbar,resizable");
}
throw Components.results.NS_ERROR_FAILURE;
}
function EnigmailProtocolHandlerFactory() {
}
EnigmailProtocolHandlerFactory.prototype = {
QueryInterface: function (iid) {
//DEBUG_LOG("EnigmailProtocolHandlerFactory.QueryInterface:"+iid+"\n");
if (!iid.equals(Components.interfaces.nsIFactory) &&
!iid.equals(nsISupports))
throw Components.results.NS_ERROR_NO_INTERFACE;
return this;
},
createInstance: function (outer, iid) {
DEBUG_LOG("enigmail.js: EnigmailProtocolHandlerFactory.createInstance\n");
if (outer != null)
throw Components.results.NS_ERROR_NO_AGGREGATION;
if (!iid.equals(nsIProtocolHandler) && !iid.equals(nsISupports))
throw Components.results.NS_ERROR_INVALID_ARG;
return new EnigmailProtocolHandler();
}
}
///////////////////////////////////////////////////////////////////////////////
// Enigmail encryption/decryption service
///////////////////////////////////////////////////////////////////////////////
function GetXULOwner () {
if (gXULOwner)
return gXULOwner;
// Open temporary XUL channel
var ioServ = Components.classes[NS_IOSERVICE_CONTRACTID].getService(Components.interfaces.nsIIOService);
var temChannel = ioServ.newChannel("chrome://enigmail/content/dummy.xul",
"",
null);
// Get owner of XUL channel
gXULOwner = temChannel.owner;
// Release channel
temChannel = null;
DEBUG_LOG("enigmail.js: GetXULOwner: gXULOwner="+gXULOwner+"\n");
return gXULOwner;
}
function GetPassphrase(domWindow, passwdObj, useAgentObj, agentVersion) {
DEBUG_LOG("enigmail.js: GetPassphrase:\n");
useAgentObj.value = false;
try {
var noPassphrase = gEnigmailSvc.prefBranch.getBoolPref("noPassphrase");
var useAgent = gEnigmailSvc.prefBranch.getBoolPref("useGpgAgent");
useAgentObj.value = useAgent;
if (noPassphrase || useAgent) {
passwdObj.value = "";
return true;
}
}
catch(ex) {}
if (gEnigmailSvc.haveCachedPassphrase()) {
passwdObj.value = gCachedPassphrase;
return true;
}
// Obtain password interactively
var checkObj = new Object();
if (agentVersion>="1.4") {
var promptMsg = EnigGetString("enterPassOrPin");
}
else {
promptMsg = EnigGetString("enterPass",gEnigmailSvc.agentType.toUpperCase());
}
passwdObj.value = "";
checkObj.value = true;
var maxIdleMinutes = gEnigmailSvc.getMaxIdleMinutes();
var checkMsg = (maxIdleMinutes>0) ? EnigGetString("rememberPass",maxIdleMinutes) : "";
var success;
var promptService = Components.classes[NS_PROMPTSERVICE_CONTRACTID].getService(Components.interfaces.nsIPromptService);
success = promptService.promptPassword(domWindow,
EnigGetString("Enigmail"),
promptMsg,
passwdObj,
checkMsg,
checkObj);
if (!success)
return false;
DEBUG_LOG("enigmail.js: GetPassphrase: got passphrase\n");
// Remember passphrase only if necessary
if (checkObj.value && (maxIdleMinutes > 0))
gEnigmailSvc.setCachedPassphrase(passwdObj.value);
return true;
}
function Enigmail(registeringModule)
{
DEBUG_LOG("enigmail.js: Enigmail: START "+registeringModule+"\n");
this.registeringModule = registeringModule;
DEBUG_LOG("enigmail.js: Enigmail: END\n");
}
Enigmail.prototype.registeringModule = false;
Enigmail.prototype.initialized = false;
Enigmail.prototype.initializationAttempted = false;
Enigmail.prototype.initializationError = "";
Enigmail.prototype.composeSecure = false;
Enigmail.prototype.logFileStream = null;
Enigmail.prototype.isUnix = false;
Enigmail.prototype.isWin32 = false;
Enigmail.prototype.isOs2 = false;
Enigmail.prototype.isDosLike = false;
Enigmail.prototype.ipcService = null;
Enigmail.prototype.prefBranch = null;
Enigmail.prototype.console = null;
Enigmail.prototype.keygenProcess = null;
Enigmail.prototype.keygenConsole = null;
Enigmail.prototype.quoteSign = "";
Enigmail.prototype.agentType = "";
Enigmail.prototype.agentPath = "";
Enigmail.prototype.agentVersion = "";
Enigmail.prototype.userIdList = null;
Enigmail.prototype.rulesList = null;
Enigmail.prototype._lastActiveTime = 0;
Enigmail.prototype._messageIdList = {};
Enigmail.prototype.QueryInterface =
function (iid) {
//DEBUG_LOG("Enigmail.QueryInterface:\n");
if (!iid.equals(nsIEnigmail) &&
!iid.equals(nsIObserver) &&
!iid.equals(nsISupports))
throw Components.results.NS_ERROR_NO_INTERFACE;
return this;
}
Enigmail.prototype.observe =
function (aSubject, aTopic, aData) {
DEBUG_LOG("enigmail.js: Enigmail.observe: topic='"+aTopic+"' \n");
if (aTopic == "timer-callback") {
// Cause cached password to expire, if need be
if (!this.haveCachedPassphrase()) {
// No cached password; cancel repeating timer
if (gCacheTimer)
gCacheTimer.cancel();
}
} else if (aTopic == NS_XPCOM_SHUTDOWN_OBSERVER_ID) {
// XPCOM shutdown
this.finalize();
// Reset mail.show_headers pref
try {
var prefSvc = Components.classes[NS_PREFS_SERVICE_CID]
.getService(Components.interfaces.nsIPrefService);
var prefRoot = prefSvc.getBranch(null);
var prefValue = 1;
try {
prefValue = this.prefBranch.getIntPref("show_headers");
} catch (ex) {}
prefRoot.setIntPref("mail.show_headers", prefValue);
prefSvc.savePrefFile(null);
} catch (ex) {}
}
}
Enigmail.prototype.alertMsg =
function (domWindow, mesg) {
var promptService = Components.classes[NS_PROMPTSERVICE_CONTRACTID].getService(Components.interfaces.nsIPromptService);
return promptService.alert(domWindow, EnigGetString("enigAlert"), mesg);
}
Enigmail.prototype.confirmMsg =
function (domWindow, mesg) {
var dummy={};
var promptService = Components.classes[NS_PROMPTSERVICE_CONTRACTID].getService(Components.interfaces.nsIPromptService);
var buttonPressed = promptService.confirmEx(domWindow,
EnigGetString("enigConfirm"),
mesg,
(promptService.BUTTON_TITLE_YES * BUTTON_POS_0) +
(promptService.BUTTON_TITLE_NO * BUTTON_POS_1),
null, null, null,
null, dummy);
return (buttonPressed==0); // promptService.confirm(domWindow, EnigGetString("enigConfirm"), mesg);
}
Enigmail.prototype.promptValue =
function (domWindow, mesg, valueObj) {
var promptService = Components.classes[NS_PROMPTSERVICE_CONTRACTID].getService(Components.interfaces.nsIPromptService);
var checkObj = new Object();
return promptService.prompt(domWindow, EnigGetString("enigPrompt"),
mesg, valueObj, "", checkObj);
}
Enigmail.prototype.errorMsg =
function (domWindow, mesg) {
var promptService = Components.classes[NS_PROMPTSERVICE_CONTRACTID].getService(Components.interfaces.nsIPromptService);
return promptService.alert(domWindow, EnigGetString("enigError"), mesg);
}
Enigmail.prototype.getMaxIdleMinutes =
function () {
var maxIdleMinutes = 5;
try {
maxIdleMinutes = this.prefBranch.getIntPref("maxIdleMinutes");
} catch (ex) {
}
return maxIdleMinutes;
}
Enigmail.prototype.getLogDirectoryPrefix =
function () {
var logDirectory = "";
try {
logDirectory = this.prefBranch.getCharPref("logDirectory");
} catch (ex) {
}
if (!logDirectory)
return "";
var dirPrefix = logDirectory + (this.isDosLike ? "\\" : "/");
return dirPrefix;
}
Enigmail.prototype.stillActive =
function () {
DEBUG_LOG("enigmail.js: Enigmail.stillActive: \n");
// Update last active time
var curDate = new Date();
this._lastActiveTime = curDate.getTime();
// DEBUG_LOG("enigmail.js: Enigmail.stillActive: _lastActiveTime="+this._lastActiveTime+"\n");
}
Enigmail.prototype.clearCachedPassphrase =
function () {
DEBUG_LOG("enigmail.js: Enigmail.clearCachedPassphrase: \n");
gCachedPassphrase = null;
}
Enigmail.prototype.setCachedPassphrase =
function (passphrase) {
DEBUG_LOG("enigmail.js: Enigmail.setCachedPassphrase: \n");
gCachedPassphrase = passphrase;
this.stillActive();
var maxIdleMinutes = this.getMaxIdleMinutes();
if (this.haveCachedPassphrase() && (maxIdleMinutes > 0)) {
// Start timer
if (gCacheTimer)
gCacheTimer.cancel();
var delayMillisec = maxIdleMinutes*60*1000;
if (Components.interfaces.nsITimer) {
// Use nsITimer: Post 1.2a mozilla trunk
const nsITimer = Components.interfaces.nsITimer;
gCacheTimer = Components.classes[NS_TIMER_CONTRACTID].createInstance(nsITimer);
if (!gCacheTimer) {
ERROR_LOG("enigmail.js: Enigmail.setCachedPassphrase: Error - failed to create timer\n");
throw Components.results.NS_ERROR_FAILURE;
}
gCacheTimer.init(this, delayMillisec,
nsITimer.TYPE_REPEATING_SLACK);
} else {
// Use nsIScriptableTimer: Stable Mozilla 1.0 branch
const nsIScriptableTimer = Components.interfaces.nsIScriptableTimer;
gCacheTimer = Components.classes[NS_TIMER_CONTRACTID].createInstance(nsIScriptableTimer);
if (!gCacheTimer) {
ERROR_LOG("enigmail.js: Enigmail.setCachedPassphrase: Error - failed to create scriptable timer\n");
throw Components.results.NS_ERROR_FAILURE;
}
gCacheTimer.init(this, delayMillisec,
nsIScriptableTimer.PRIORITY_NORMAL,
nsIScriptableTimer.TYPE_REPEATING_SLACK);
}
DEBUG_LOG("enigmail.js: Enigmail.setCachedPassphrase: gCacheTimer="+gCacheTimer+"\n");
}
}
Enigmail.prototype.haveCachedPassphrase =
function () {
DEBUG_LOG("enigmail.js: Enigmail.haveCachedPassphrase: \n");
var havePassphrase = ((typeof gCachedPassphrase) == "string");
if (!havePassphrase)
return false;
var curDate = new Date();
var currentTime = curDate.getTime();
var maxIdleMinutes = this.getMaxIdleMinutes();
var delayMillisec = maxIdleMinutes*60*1000;
var expired = ((currentTime - this._lastActiveTime) >= delayMillisec);
// DEBUG_LOG("enigmail.js: Enigmail.haveCachedPassphrase: ")
// DEBUG_LOG("currentTime="+currentTime+", _lastActiveTime="+this._lastActiveTime+", expired="+expired+"\n");
if (expired) {
// Too much idle time; forget cached password
gCachedPassphrase = null;
havePassphrase = false;
WRITE_LOG("enigmail.js: Enigmail.haveCachedPassphrase: CACHE IDLED OUT\n");
}
return havePassphrase;
}
Enigmail.prototype.finalize =
function () {
DEBUG_LOG("enigmail.js: Enigmail.finalize:\n");
if (!this.initialized) return;
if (this.logFileStream) {
this.logFileStream.close();
this.logFileStream = null;
}
if (this.console) {
this.console.close();
this.console = null;
}
gLogLevel = 3;
this.initializationError = "";
this.initializationAttempted = false;
this.initialized = false;
}
Enigmail.prototype.mimeInitialized =
function () {
var enigMimeService = Components.classes[NS_ENIGMIMESERVICE_CONTRACTID].getService(Components.interfaces.nsIEnigMimeService);
var value = enigMimeService.initialized;
DEBUG_LOG("enigmail.js: Enigmail.mimeInitialized: "+value+"\n");
return value;
}
Enigmail.prototype.initialize =
function (domWindow, version, prefBranch) {
this.initializationAttempted = true;
this.prefBranch = prefBranch;
DEBUG_LOG("enigmail.js: Enigmail.initialize: START\n");
if (this.initialized) return;
try {
var enigMsgComposeFactory = Components.classes[NS_ENIGMSGCOMPOSEFACTORY_CONTRACTID].createInstance(Components.interfaces.nsIFactory);
var compMgr = Components.manager.QueryInterface(Components.interfaces.nsIComponentRegistrar);
compMgr.registerFactory(NS_ENIGMSGCOMPOSE_CID,
"Enig Msg Compose",
NS_MSGCOMPOSESECURE_CONTRACTID,
enigMsgComposeFactory);
var msgComposeSecureCID = compMgr.contractIDToCID(NS_MSGCOMPOSESECURE_CONTRACTID);
this.composeSecure = (msgComposeSecureCID.toString() ==
NS_ENIGMSGCOMPOSE_CID);
} catch (ex) {}
var ioServ = Components.classes[NS_IOSERVICE_CONTRACTID].getService(Components.interfaces.nsIIOService);
try {
var httpHandler = ioServ.getProtocolHandler("http");
httpHandler = httpHandler.QueryInterface(Components.interfaces.nsIHttpProtocolHandler);
}
catch (ex) {
httpHandler = domWindow.navigator;
}
this.oscpu = httpHandler.oscpu;
this.platform = httpHandler.platform;
if (httpHandler.vendor) {
this.vendor = httpHandler.vendor;
} else {
this.vendor = "Mozilla";
}
this.isUnix = (this.platform.search(/X11/i) == 0);
this.isWin32 = (this.platform.search(/Win/i) == 0);
this.isOs2 = (this.platform.search(/OS\/2/i) == 0);
if (this.isOs2) {
this.quoteSign="\\\"";
}
else {
this.quoteSign="'";
}
this.isDosLike = (this.isWin32 || this.isOs2);
var prefix = this.getLogDirectoryPrefix();
if (prefix) {
gLogLevel = 5;
this.logFileStream = CreateFileStream(prefix+"enigdbug.txt");
DEBUG_LOG("enigmail.js: Logging debug output to "+prefix+"enigdbug.txt\n");
}
this.version = version;
DEBUG_LOG("enigmail.js: Enigmail version "+this.version+"\n");
DEBUG_LOG("enigmail.js: OS/CPU="+this.oscpu+"\n");
DEBUG_LOG("enigmail.js: Platform="+this.platform+"\n");
DEBUG_LOG("enigmail.js: composeSecure="+this.composeSecure+"\n");
var processInfo;
try {
processInfo = Components.classes[NS_PROCESSINFO_CONTRACTID].getService(nsIProcessInfo);
} catch (ex) {
this.initializationError = EnigGetString("enigmimeNotAvail");
ERROR_LOG("enigmail.js: Enigmail.initialize: Error - "+this.initializationError+"\n");
throw Components.results.NS_ERROR_FAILURE;
}
this.processInfo = processInfo;
var nspr_log_modules = processInfo.getEnv("NSPR_LOG_MODULES");
var matches = nspr_log_modules.match(/enigmail:(\d+)/);
if (matches && (matches.length > 1)) {
gLogLevel = matches[1];
WARNING_LOG("enigmail.js: Enigmail: gLogLevel="+gLogLevel+"\n");
}
// Initialize global environment variables list
var passEnv = [ "PGPPATH", "GNUPGHOME",
"ALLUSERSPROFILE", "APPDATA", "BEGINLIBPATH",
"COMMONPROGRAMFILES", "COMSPEC", "DISPLAY",
"ENIGMAIL_PASS_ENV", "ENDLIBPATH",
"HOME", "HOMEDRIVE", "HOMEPATH",
"LANG", "LANGUAGE", "LC_ALL", "LC_COLLATE", "LC_CTYPE",
"LC_MESSAGES", "LC_MONETARY", "LC_NUMERIC", "LC_TIME",
"LOCPATH", "LOGNAME", "LD_LIBRARY_PATH", "MOZILLA_FIVE_HOME",
"NLSPATH", "PATH", "PATHEXT", "PROGRAMFILES", "PWD",
"SHELL", "SYSTEMDRIVE", "SYSTEMROOT",
"TEMP", "TMP", "TMPDIR", "TZ", "TZDIR", "UNIXROOT",
"USER", "USERPROFILE", "WINDIR" ];
try {
var useAgent=this.prefBranch.getBoolPref("useGpgAgent");
if (useAgent) {
passEnv.push("GPG_AGENT_INFO");
}
} catch (ex) {}
var passList = this.processInfo.getEnv("ENIGMAIL_PASS_ENV");
if (passList) {
var passNames = passList.split(":");
for (var k=0; k<passNames.length; k++)
passEnv.push(passNames[k]);
}
gEnvList = [];
for (var j=0; j<passEnv.length; j++) {
var envName = passEnv[j];
var envValue = this.processInfo.getEnv(envName);
if (envValue)
gEnvList.push(envName+"="+envValue);
}
DEBUG_LOG("enigmail.js: Enigmail.initialize: gEnvList = "+gEnvList+"\n");
try {
// Access IPC Service
var ipcService = Components.classes[NS_IPCSERVICE_CONTRACTID].getService();
ipcService = ipcService.QueryInterface(nsIIPCService);
this.ipcService = ipcService;
// Create a non-joinable console
var pipeConsole = Components.classes[NS_PIPECONSOLE_CONTRACTID].createInstance(nsIPipeConsole);
pipeConsole.open(500, 80, false);
this.console = pipeConsole;
pipeConsole.write("Initializing Enigmail service ...\n");
} catch (ex) {
this.initializationError = EnigGetString("enigmimeNotAvail");
ERROR_LOG("enigmail.js: Enigmail.initialize: Error - "+this.initializationError+"\n");
throw Components.results.NS_ERROR_FAILURE;
}
this.setAgentPath();
// Register to observe XPCOM shutdown
var obsServ = Components.classes[NS_OBSERVERSERVICE_CONTRACTID].getService();
obsServ = obsServ.QueryInterface(Components.interfaces.nsIObserverService);
obsServ.addObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, false);
this.stillActive();
this.initialized = true;
DEBUG_LOG("enigmail.js: Enigmail.initialize: END\n");
}
Enigmail.prototype.reinitialize =
function () {
this.initialized = false;
this.initializationAttempted = true;
this.console.write("Reinitializing Enigmail service ...\n");
this.setAgentPath();
this.initialized = true;
}
Enigmail.prototype.setAgentPath =
function () {
var agentPath = "";
try {
agentPath = this.prefBranch.getCharPref("agentPath");
} catch (ex) {}
var agentList = ["gpg"];
var agentType = "";
if (agentPath) {
// Locate GPG/PGP executable
// Append default .exe extension for DOS-Like systems, if needed
if (this.isDosLike && (agentPath.search(/\.\w+$/) < 0))
agentPath += ".exe";
try {
var pathDir = Components.classes[NS_LOCAL_FILE_CONTRACTID].createInstance(nsILocalFile);
if (! isAbsolutePath(agentPath, this.isDosLike)) {
// path relative to Mozilla installation dir
var ds = Components.classes[DIR_SERV_CONTRACTID].getService();
var dsprops = ds.QueryInterface(Components.interfaces.nsIProperties);
pathDir = dsprops.get("CurProcD", Components.interfaces.nsILocalFile);
var dirs=agentPath.split(RegExp(this.isDosLike ? "\\\\" : "/"));
for (var i=0; i< dirs.length; i++) {
if (dirs[i]!=".") {
pathDir.append(dirs[i]);
}
}
pathDir.normalize();
agentPath = pathDir.target;
}
else {
// absolute path
pathDir.initWithPath(agentPath);
}
if (!pathDir.exists())
throw Components.results.NS_ERROR_FAILURE;
} catch (ex) {
this.initializationError = EnigGetString("gpgNotFound", agentPath);
ERROR_LOG("enigmail.js: Enigmail.initialize: Error - "+this.initializationError+"\n");
throw Components.results.NS_ERROR_FAILURE;
}
if (agentPath.search(/gpg[^\/\\]*$/i) > -1) {
agentType = "gpg";
} else if (agentPath.search(/pgp[^\/\\]*$/i) > -1) {
agentType = "pgp";
} else {
this.initializationError = "Cannot determine agent type (GPG/PGP) from executable filename "+agentPath;
ERROR_LOG("enigmail.js: Enigmail.initialize: Error - "+this.initializationError+"\n");
throw Components.results.NS_ERROR_FAILURE;
}
} else {
// Resolve relative path using PATH environment variable
var envPath = this.processInfo.getEnv("PATH");
for (var index=0; index<agentList.length; index++) {
agentType = agentList[index];
var agentName = this.isDosLike ? agentType+".exe" : agentType;
agentPath = ResolvePath(agentName, envPath, this.isDosLike);
if (agentPath) {
// Discard path info for DOS-like systems
/* if (this.isDosLike)
agentPath = agentType; */
break;
}
}
if (!agentPath && this.isDosLike) {
// DOS-like systems: search for GPG in c:\gnupg, c:\gnupg\bin, d:\gnupg, d:\gnupg\bin
var gpgPath = "c:\\gnupg;c:\\gnupg\\bin;d:\\gnupg;d:\\gnupg\\bin";
agentType = "gpg";
agentPath = ResolvePath("gpg.exe", gpgPath, this.isDosLike);
}
if (!agentPath) {
this.initializationError = EnigGetString("gpgNotInPath");
ERROR_LOG("enigmail.js: Enigmail: Error - "+this.initializationError+"\n");
throw Components.results.NS_ERROR_FAILURE;
}
}
CONSOLE_LOG("EnigmailAgentPath="+agentPath+"\n\n");
// Escape any backslashes in agent path
agentPath = agentPath.replace(/\\/g, "\\\\");
this.agentType = agentType;
this.agentPath = agentPath;
var command = this.getAgentPath();
if (agentType == "gpg") {
command += " --batch --no-tty --version";
} else {
command += " +batchmode -h";
}
// This particular command execution seems to be essential on win32
// (In particular, this should be the first command executed and
// *should* use the shell, i.e., command.com)
var outStrObj = new Object();
var outLenObj = new Object();
var errStrObj = new Object();
var errLenObj = new Object();
var exitCode = this.ipcService.execPipe(command, false, "", "", 0, [], 0,
outStrObj, outLenObj, errStrObj, errLenObj);
CONSOLE_LOG("enigmail> "+command.replace(/\\\\/g, "\\")+"\n");
var outStr = outStrObj.value;
if (errStrObj.value)
outStr += errStrObj.value;
CONSOLE_LOG(outStr+"\n");
var versionParts = outStr.replace(/[\r\n].*/g,"").split(/ /);
var gpgVersion = versionParts[versionParts.length-1]
this.agentVersion = gpgVersion;
// check GnuPG version number
var evalVersion = this.agentVersion.match(/^\d+\.\d+/)
if (evalVersion && evalVersion[0]<"1.2") {
this.alertMsg(domWindow, EnigGetString("oldGpgVersion", gpgVersion));
throw Components.results.NS_ERROR_FAILURE;
}
}
Enigmail.prototype.getAgentPath =
function () {
var p = "";
try {
p=" "+this.prefBranch.getCharPref("agentAdditionalParam").replace(/([\\\`])/g, "\\$1");
}
catch (ex) {}
return this.agentPath+p;
}
Enigmail.prototype.passwdCommand =
function () {
var command;
try {
var gpgVersion = this.agentVersion.match(/^\d+\.\d+/);
if (this.prefBranch.getBoolPref("useGpgAgent")) {
command = " --use-agent "
}
else {
command = " --passphrase-fd 0";
if (gpgVersion && gpgVersion[0] >= "1.1") {
command += " --no-use-agent ";
}
}
} catch (ex) {}
return command;
}
Enigmail.prototype.fixExitCode =
function (exitCode, statusFlags) {
if ((this.agentType == "gpg") && (exitCode == 256)) {
WARNING_LOG("enigmail.js: Enigmail.fixExitCode: Using gpg and exit code is 256. You seem to use cygwin-gpg, activating countermeasures.\n");
if (statusFlags & (nsIEnigmail.BAD_PASSPHRASE | nsIEnigmail.UNVERIFIED_SIGNATURE)) {
WARNING_LOG("enigmail.js: Enigmail.fixExitCode: Changing exitCode 256->2\n");
exitCode = 2;
} else {
WARNING_LOG("enigmail.js: Enigmail.fixExitCode: Changing exitCode 256->0\n");
exitCode = 0;
}
}
if (((this.agentVersion >= "1.3") && (this.agentVersion < "1.4.1" )) && (this.isDosLike)) {
if ((exitCode == 2) && (!(statusFlags & (nsIEnigmail.BAD_PASSPHRASE |
nsIEnigmail.UNVERIFIED_SIGNATURE |
nsIEnigmail.MISSING_PASSPHRASE |
nsIEnigmail.BAD_ARMOR |
nsIEnigmail.DECRYPTION_INCOMPLETE |
nsIEnigmail.DECRYPTION_FAILED |
nsIEnigmail.NO_PUBKEY |
nsIEnigmail.NO_SECKEY)))) {
WARNING_LOG("enigmail.js: Enigmail.fixExitCode: Using gpg version "+this.agentVersion+", activating countermeasures for file renaming bug.\n");
exitCode = 0;
}
}
return exitCode;
}
Enigmail.prototype.execCmd =
function (command, passphrase, input, exitCodeObj, statusFlagsObj,
statusMsgObj, errorMsgObj) {
WRITE_LOG("enigmail.js: Enigmail.execCmd: command = "+command+"\n");
if ((typeof input) != "string") input = "";
var prependPassphrase = ((typeof passphrase) == "string");
var envList = [];
envList = envList.concat(gEnvList);
var preInput;
if (prependPassphrase) {
envList.push("PGPPASSFD=0");
preInput = passphrase;
input = "\n" + input;
} else {
preInput = "";
}
var prefix = this.getLogDirectoryPrefix();
if (prefix && (gLogLevel >= 4)) {
if (prependPassphrase) {
// Obscure passphrase
WriteFileContents(prefix+"eniginp.txt", "<passphrase>"+input);
} else {
WriteFileContents(prefix+"eniginp.txt", input);
}
WriteFileContents(prefix+"enigcmd.txt", command.replace(/\\\\/g, "\\")+"\n");
WriteFileContents(prefix+"enigenv.txt", envList.join(",")+"\n");
DEBUG_LOG("enigmail.js: Enigmail.execCmd: copied command line/env/input to files "+prefix+"enigcmd.txt/enigenv.txt/eniginp.txt\n");
}
var outObj = new Object();
var errObj = new Object();
var outLenObj = new Object();
var errLenObj = new Object();
CONSOLE_LOG("\nenigmail> "+command.replace(/\\\\/g, "\\")+"\n");
try {
var useShell = false;
exitCodeObj.value = gEnigmailSvc.ipcService.execPipe(command,
useShell,
preInput,
input, input.length,
envList, envList.length,
outObj, outLenObj,
errObj, errLenObj);
} catch (ex) {
exitCodeObj.value = -1;
}
var outputData = "";
var errOutput = "";
if (outObj.value)
outputData = outObj.value;
if (errObj.value)
errOutput = errObj.value;
if (prefix && (gLogLevel >= 4)) {
WriteFileContents(prefix+"enigout.txt", outputData);
WriteFileContents(prefix+"enigerr.txt", errOutput);
DEBUG_LOG("enigmail.js: Enigmail.execCmd: copied command out/err data to files "+prefix+"enigout.txt/enigerr.txt\n");
}
DEBUG_LOG("enigmail.js: Enigmail.execCmd: exitCode = "+exitCodeObj.value+"\n");
DEBUG_LOG("enigmail.js: Enigmail.execCmd: errOutput = "+errOutput+"\n");
var errLines = errOutput.split(/\r?\n/);
// Discard last null string, if any
if ((errLines.length > 1) && !errLines[errLines.length-1])
errLines.pop();
var errArray = new Array();
var statusArray = new Array();
var statusPat = /^\[GNUPG:\] /;
var statusFlags = 0;
for (var j=0; j<errLines.length; j++) {
if (errLines[j].search(statusPat) == 0) {
var statusLine = errLines[j].replace(statusPat,"");
statusArray.push(statusLine);
var matches = statusLine.match(/^(\w+)\b/);
if (matches && (matches.length > 1)) {
var flag = gStatusFlags[matches[1]];
if (flag == nsIEnigmail.NODATA) {
// Recognize only "NODATA 1"
if (statusLine.search(/NODATA 1\b/) < 0)
flag = 0;
}
if (flag)
statusFlags |= flag;
//DEBUG_LOG("enigmail.js: Enigmail.execCmd: status match "+matches[1]+"\n");
}
} else {
errArray.push(errLines[j]);
}
}
exitCodeObj.value = this.fixExitCode(exitCodeObj.value, statusFlags);
statusFlagsObj.value = statusFlags;
statusMsgObj.value = statusArray.join("\n");
errorMsgObj.value = errArray.join("\n");
CONSOLE_LOG(errorMsgObj.value+"\n");
DEBUG_LOG("enigmail.js: Enigmail.execCmd: statusFlags = "+bytesToHex(pack(statusFlags,4))+"\n");
//DEBUG_LOG("enigmail.js: Enigmail.execCmd: statusMsg = "+statusMsgObj.value+"\n");
this.stillActive();
return outputData;
}
Enigmail.prototype.execStart =
function (command, needPassphrase, domWindow, prompter, listener,
noProxy, statusFlagsObj) {
WRITE_LOG("enigmail.js: Enigmail.execStart: command = "+command+", needPassphrase="+needPassphrase+", domWindow="+domWindow+", prompter="+prompter+", listener="+listener+", noProxy="+noProxy+"\n");
statusFlagsObj.value = 0;
var envList = [];
envList = envList.concat(gEnvList);
var passphrase = null;
var useAgentObj = {value: false};
if (needPassphrase) {
command += this.passwdCommand();
var passwdObj = new Object();
if (!GetPassphrase(domWindow, passwdObj, useAgentObj, this.agentVersion)) {
ERROR_LOG("enigmail.js: Enigmail.execStart: Error - no passphrase supplied\n");
statusFlagsObj.value |= nsIEnigmail.MISSING_PASSPHRASE;
return null;
}
passphrase = passwdObj.value;
}
var prefix = this.getLogDirectoryPrefix();
if (prefix && (gLogLevel >= 4)) {
WriteFileContents(prefix+"enigcmd.txt", command.replace(/\\\\/g, "\\")+"\n");
WriteFileContents(prefix+"enigenv.txt", envList.join(",")+"\n");
DEBUG_LOG("enigmail.js: Enigmail.execStart: copied command line/env to files "+prefix+"enigcmd.txt/enigenv.txt\n");
}
CONSOLE_LOG("\nenigmail> "+command.replace(/\\\\/g, "\\")+"\n");
var pipetrans = Components.classes[NS_PIPETRANSPORT_CONTRACTID].createInstance();
pipetrans = pipetrans.QueryInterface(Components.interfaces.nsIPipeTransport);
DEBUG_LOG("enigmail.js: Enigmail.execStart: pipetrans = " + pipetrans + "\n");
try {
var ipcBuffer = Components.classes[NS_IPCBUFFER_CONTRACTID].createInstance(Components.interfaces.nsIIPCBuffer);
ipcBuffer.open(ERROR_BUFFER_SIZE, false);
var mergeStderr = false;
pipetrans.initCommand(command, envList, envList.length,
0, "", noProxy, mergeStderr,
ipcBuffer);
if (listener) {
pipetrans.asyncRead(listener, null, 0, -1, 0);
}
if (needPassphrase && ! useAgentObj.value) {
// Write to child STDIN
// (ignore errors, because child may have exited already, closing STDIN)
try {
if (passphrase) {
pipetrans.writeSync(passphrase, passphrase.length);
}
pipetrans.writeSync("\n", 1);
} catch (ex) {}
}
return pipetrans;
} catch (ex) {
CONSOLE_LOG("enigmail.js: Enigmail.execStart: Error - Failed to start PipeTransport\n");
return null;
}
}
Enigmail.prototype.parseErrorOutput =
function (errOutput, statusFlagsObj, statusMsgObj) {
WRITE_LOG("enigmail.js: Enigmail.parseErrorOutput: \n");
var errLines = errOutput.split(/\r?\n/);
// Discard last null string, if any
if ((errLines.length > 1) && !errLines[errLines.length-1])
errLines.pop();
var errArray = new Array();
var statusArray = new Array();
var statusPat = /^\[GNUPG:\] /;
var statusFlags = 0;
for (var j=0; j<errLines.length; j++) {
if (errLines[j].search(statusPat) == 0) {
var statusLine = errLines[j].replace(statusPat,"");
statusArray.push(statusLine);
var matches = statusLine.match(/^(\w+)\b/);
if (matches && (matches.length > 1)) {
var flag = gStatusFlags[matches[1]];
if (flag == nsIEnigmail.NODATA) {
// Recognize only "NODATA 1"
if (statusLine.search(/NODATA 1\b/) < 0)
flag = 0;
}
if (flag)
statusFlags |= flag;
//DEBUG_LOG("enigmail.js: Enigmail.parseErrorOutput: status match '+matches[1]+"\n");
}
} else {
errArray.push(errLines[j]);
}
}
statusFlagsObj.value = statusFlags;
statusMsgObj.value = statusArray.join("\n");
var errorMsg = errArray.join("\n");
DEBUG_LOG("enigmail.js: Enigmail.parseErrorOutput: statusFlags = "+bytesToHex(pack(statusFlags,4))+"\n");
//DEBUG_LOG("enigmail.js: Enigmail.parseErrorOutput: statusMsg = "+statusMsgObj.value+"\n");
return errorMsg;
}
Enigmail.prototype.execEnd =
function (pipeTransport, statusFlagsObj, statusMsgObj, cmdLineObj, errorMsgObj) {
WRITE_LOG("enigmail.js: Enigmail.execEnd: \n");
// Extract command line
try {
var request = pipeTransport.QueryInterface(Components.interfaces.nsIRequest);
cmdLineObj.value = request.name;
} catch (ex) {
cmdLineObj.value = "unknown-command";
}
// Extract exit code and error output from pipeTransport
var exitCode = pipeTransport.exitCode();
var errListener = pipeTransport.console;
var errOutput = errListener.getData();
// Terminate pipeTransport
errListener.shutdown();
pipeTransport.terminate();
var prefix = this.getLogDirectoryPrefix();
if (prefix && (gLogLevel >= 4)) {
WriteFileContents(prefix+"enigerr.txt", errOutput);
DEBUG_LOG("enigmail.js: Enigmail.execEnd: copied command err output to file "+prefix+"enigerr.txt\n");
}
DEBUG_LOG("enigmail.js: Enigmail.execEnd: exitCode = "+exitCode+"\n");
DEBUG_LOG("enigmail.js: Enigmail.execEnd: errOutput = "+errOutput+"\n");
var errLines = errOutput.split(/\r?\n/);
// Discard last null string, if any
if ((errLines.length > 1) && !errLines[errLines.length-1])
errLines.pop();
var errArray = new Array();
var statusArray = new Array();
var statusPat = /^\[GNUPG:\] /;
var statusFlags = 0;
for (var j=0; j<errLines.length; j++) {
if (errLines[j].search(statusPat) == 0) {
var statusLine = errLines[j].replace(statusPat,"");
statusArray.push(statusLine);
var matches = statusLine.match(/^(\w+)\b/);
if (matches && (matches.length > 1)) {
var flag = gStatusFlags[matches[1]];
if (flag == nsIEnigmail.NODATA) {
// Recognize only "NODATA 1"
if (statusLine.search(/NODATA 1\b/) < 0)
flag = 0;
}
if (flag)
statusFlags |= flag;
//DEBUG_LOG("enigmail.js: Enigmail.execEnd: status match '+matches[1]+"\n");
}
} else {
errArray.push(errLines[j]);
}
}
if (errOutput.search(/jpeg image of size \d+/)>-1) {
statusFlags |= nsIEnigmail.PHOTO_AVAILABLE;
}
statusFlagsObj.value = statusFlags;
statusMsgObj.value = statusArray.join("\n");
errorMsgObj.value = errArray.join("\n");
CONSOLE_LOG(errorMsgObj.value+"\n");
DEBUG_LOG("enigmail.js: Enigmail.execEnd: statusFlags = "+bytesToHex(pack(statusFlags,4))+"\n");
//DEBUG_LOG("enigmail.js: Enigmail.execEnd: statusMsg = "+statusMsgObj.value+"\n");
this.stillActive();
return exitCode;
}
// Remove all quoted strings (and angle brackets) from a list of email
// addresses, returning a list of pure email address
function EnigStripEmail(mailAddrs) {
var qStart, qEnd;
while ((qStart = mailAddrs.indexOf('"')) != -1) {
qEnd = mailAddrs.indexOf('"', qStart+1);
if (qEnd == -1) {
ERROR_LOG("enigmail.js: EnigStripEmail: Unmatched quote in mail address: "+mailAddrs+"\n");
mailAddrs=mailAddrs.replace(/\"/g, "");
break;
}
mailAddrs = mailAddrs.substring(0,qStart) + mailAddrs.substring(qEnd+1);
}
// Eliminate all whitespace, just to be safe
mailAddrs = mailAddrs.replace(/\s+/g,"");
// Extract pure e-mail address list (stripping out angle brackets)
mailAddrs = mailAddrs.replace(/(^|,)[^,]*<([^>]+)>[^,]*/g,"$1$2");
return mailAddrs;
}
Enigmail.prototype.stripWhitespace = function(sendFlags) {
var stripThem=false;
if ((sendFlags & nsIEnigmail.SEND_SIGNED) &&
(!(sendFlags & nsIEnigmail.SEND_ENCRYPTED))) {
if (this.agentVersion >= "1.4.0" && this.agentVersion < "1.4.1") {
stripThem = true;
}
}
return stripThem;
}
Enigmail.prototype.encryptMessage =
function (parent, uiFlags, plainText, fromMailAddr, toMailAddr,
sendFlags, exitCodeObj, statusFlagsObj, errorMsgObj) {
DEBUG_LOG("enigmail.js: Enigmail.encryptMessage: "+plainText.length+" bytes from "+fromMailAddr+" to "+toMailAddr+" ("+sendFlags+")\n");
exitCodeObj.value = -1;
statusFlagsObj.value = 0;
errorMsgObj.value = "";
if (!plainText) {
DEBUG_LOG("enigmail.js: Enigmail.encryptMessage: NO ENCRYPTION!\n");
exitCodeObj.value = 0;
return plainText;
}
if (!this.initialized) {
errorMsgObj.value = EnigGetString("notInit");
return "";
}
var defaultSend = sendFlags & nsIEnigmail.SEND_DEFAULT;
var signMsg = sendFlags & nsIEnigmail.SEND_SIGNED;
var encryptMsg = sendFlags & nsIEnigmail.SEND_ENCRYPTED;
if (encryptMsg) {
// First convert all linebreaks to newlines
plainText = plainText.replace(/\r\n/g, "\n");
plainText = plainText.replace(/\r/g, "\n");
// Using platform-specific linebreaks confuses some windows mail clients,
// so we convert everything to windows like good old PGP worked anyway.
plainText = plainText.replace(/\n/g, "\r\n");
}
var noProxy = true;
var startErrorMsgObj = new Object();
var ipcBuffer = Components.classes[NS_IPCBUFFER_CONTRACTID].createInstance(Components.interfaces.nsIIPCBuffer);
var bufferSize = ((plainText.length + 20000)/1024).toFixed(0)*1024;
if (MSG_BUFFER_SIZE > bufferSize)
bufferSize=MSG_BUFFER_SIZE;
ipcBuffer.open(bufferSize, false);
var pipeTrans = this.encryptMessageStart(parent, null, uiFlags,
fromMailAddr, toMailAddr,
"", sendFlags, ipcBuffer,
noProxy, startErrorMsgObj);
if (!pipeTrans) {
errorMsgObj.value = startErrorMsgObj.value;
return "";
}
// Write to child STDIN
// (ignore errors, because child may have exited already, closing STDIN)
try {
pipeTrans.writeSync(plainText, plainText.length);
} catch (ex) {}
// Wait for child STDOUT to close
pipeTrans.join();
var cipherText = ipcBuffer.getData();
ipcBuffer.shutdown();
var exitCode = this.encryptMessageEnd(parent, null, uiFlags, sendFlags,
plainText.length, pipeTrans,
statusFlagsObj, errorMsgObj);
exitCodeObj.value = exitCode;
if ((exitCodeObj.value == 0) && !cipherText)
exitCodeObj.value = -1;
if (exitCodeObj.value == 0) {
// Normal return
return cipherText;
}
// Error processing
ERROR_LOG("enigmail.js: Enigmail.encryptMessage: Error in command execution\n");
return "";
}
Enigmail.prototype.encryptMessageEnd =
function (parent, prompter, uiFlags, sendFlags, outputLen, pipeTransport,
statusFlagsObj, errorMsgObj)
{
DEBUG_LOG("enigmail.js: Enigmail.encryptMessageEnd: uiFlags="+uiFlags+", sendFlags="+bytesToHex(pack(sendFlags,4))+", outputLen="+outputLen+", pipeTransport="+pipeTransport+"\n");
var pgpMime = uiFlags & nsIEnigmail.UI_PGP_MIME;
statusFlagsObj.value = 0;
errorMsgObj.value = "";
if (!this.initialized) {
errorMsgObj.value = EnigGetString("notInit");
return -1;
}
// Terminate job and parse error output
var statusMsgObj = new Object();
var cmdLineObj = new Object();
var cmdErrorMsgObj = new Object();
var exitCode = this.execEnd(pipeTransport, statusFlagsObj, statusMsgObj, cmdLineObj, cmdErrorMsgObj);
var statusMsg = statusMsgObj.value;
exitCode = this.fixExitCode(exitCode, statusFlagsObj.value);
if ((exitCode == 0) && !outputLen) {
exitCode = -1;
}
if (exitCode == 0) {
// Normal return
errorMsgObj.value = cmdErrorMsgObj.value;
return 0;
}
// Error processing
ERROR_LOG("enigmail.js: Enigmail.encryptMessageEnd: Error in command execution\n");
var defaultSend = sendFlags & nsIEnigmail.SEND_DEFAULT;
var signMsg = sendFlags & nsIEnigmail.SEND_SIGNED;
var encryptMsg = sendFlags & nsIEnigmail.SEND_ENCRYPTED;
if ( (statusFlagsObj.value & nsIEnigmail.BAD_PASSPHRASE) ||
((this.agentType == "pgp") && signMsg && (exitCode != 21)) ) {
// "Unremember" passphrase on error return
this.clearCachedPassphrase();
}
if (statusFlagsObj.value & nsIEnigmail.BAD_PASSPHRASE) {
errorMsgObj.value = EnigGetString("badPhrase");
}
else if (statusFlagsObj.value & nsIEnigmail.INVALID_RECIPIENT) {
errorMsgObj.value = statusMsg;
}
else {
errorMsgObj.value = EnigGetString("badCommand");
}
if (cmdErrorMsgObj.value) {
errorMsgObj.value += "\n\n" + this.agentType + " "+EnigGetString("cmdLine");
errorMsgObj.value += "\n" + cmdLineObj.value;
errorMsgObj.value += "\n" + cmdErrorMsgObj.value;
}
if (pgpMime && errorMsgObj.value) {
if (prompter)
prompter.alert(EnigGetString("enigAlert"), errorMsgObj.value);
else
this.alertMsg(parent, errorMsgObj.value);
}
return exitCode;
}
var gPGPHashNum = {md5:1, sha1:2, ripemd160:3, sha256:4, sha384:5, sha512:6};
Enigmail.prototype.getEncryptCommand =
function (fromMailAddr, toMailAddr, hashAlgorithm, sendFlags, isAscii, errorMsgObj) {
try {
fromMailAddr = EnigStripEmail(fromMailAddr);
toMailAddr = EnigStripEmail(toMailAddr);
} catch (ex) {
errorMsgObj.value = EnigGetString("invalidEmail");
return null;
}
var defaultSend = sendFlags & nsIEnigmail.SEND_DEFAULT;
var signMsg = sendFlags & nsIEnigmail.SEND_SIGNED;
var encryptMsg = sendFlags & nsIEnigmail.SEND_ENCRYPTED;
var usePgpMime = sendFlags & nsIEnigmail.SEND_PGP_MIME;
var useDefaultComment = false;
try {
useDefaultComment = this.prefBranch.getBoolPref("useDefaultComment")
} catch(ex) { }
var hushMailSupport = false;
try {
hushMailSupport = this.prefBranch.getBoolPref("hushMailSupport")
} catch(ex) { }
var detachedSig = usePgpMime && signMsg && !encryptMsg;
var toAddrList = toMailAddr.split(/\s*,\s*/);
var k;
var encryptCommand = this.getAgentPath();
if (this.agentType == "pgp") {
encryptCommand += PGP_BATCH_OPTS + " -fta "
if (encryptMsg) {
encryptCommand += " -e";
if (signMsg)
encryptCommand += " -s";
if ((sendFlags & nsIEnigmail.SEND_ENCRYPT_TO_SELF) && fromMailAddr)
encryptCommand += " +encrypttoself=on";
for (k=0; k<toAddrList.length; k++)
encryptCommand += " "+toAddrList[k];
} else if (detachedSig) {
encryptCommand += " -sb";
if (hashAlgorithm && gPGPHashNum[hashAlgorithm.toLowerCase()])
encryptCommand += " +hashnum=" + gPGPHashNum[hashAlgorithm];
} else if (signMsg) {
encryptCommand += " -s";
}
if (fromMailAddr) {
encryptCommand += " +myname=" + fromMailAddr;
}
} else {
encryptCommand += GPG_BATCH_OPTS;
if (!useDefaultComment)
encryptCommand += " --comment "+this.quoteSign+GPG_COMMENT_OPT.replace(/\%s/, this.vendor)+this.quoteSign;
/*
if (usePgpMime && (! encryptMsg)) {
if (this.agentVersion >= "1.4.1") {
//encryptCommand += " --rfc2440-dshaw"
}
}
*/
var angledFromMailAddr = ((fromMailAddr.search(/^0x/) == 0) || hushMailSupport)
? fromMailAddr : "<" + fromMailAddr + ">";
angledFromMailAddr = angledFromMailAddr.replace(/([\"\'\`])/g, "\\$1");
if (encryptMsg) {
if (isAscii)
encryptCommand += " -a";
encryptCommand += " -e";
if (signMsg)
encryptCommand += " -s";
if (sendFlags & nsIEnigmail.SEND_ALWAYS_TRUST) {
if (this.agentVersion >= "1.4") {
encryptCommand += " --trust-model always"
}
else {
encryptCommand += " --always-trust";
}
}
if ((sendFlags & nsIEnigmail.SEND_ENCRYPT_TO_SELF) && fromMailAddr)
encryptCommand += " --encrypt-to " + angledFromMailAddr;
for (k=0; k<toAddrList.length; k++) {
toAddrList[k] = toAddrList[k].replace(/\'/g, "\\'");
encryptCommand += (hushMailSupport || (toAddrList[k].search(/^0x/) == 0)) ? " -r "+ toAddrList[k]
:" -r <" + toAddrList[k] + ">";
}
} else if (detachedSig) {
encryptCommand += " -s -b -t";
if (isAscii)
encryptCommand += " -a";
if (hashAlgorithm) {
encryptCommand += " --digest-algo "+hashAlgorithm;
}
} else if (signMsg) {
encryptCommand += " --clearsign";
if (hashAlgorithm) {
encryptCommand += " --digest-algo "+hashAlgorithm;
}
}
if (fromMailAddr) {
encryptCommand += " -u " + angledFromMailAddr;
}
}
return encryptCommand;
}
Enigmail.prototype.encryptMessageStart =
function (parent, prompter, uiFlags, fromMailAddr, toMailAddr,
hashAlgorithm, sendFlags, listener, noProxy, errorMsgObj) {
DEBUG_LOG("enigmail.js: Enigmail.encryptMessageStart: prompter="+prompter+", uiFlags="+uiFlags+", from "+fromMailAddr+" to "+toMailAddr+", hashAlgorithm="+hashAlgorithm+" ("+bytesToHex(pack(sendFlags,4))+")\n");
var pgpMime = uiFlags & nsIEnigmail.UI_PGP_MIME;
if (uiFlags & nsIEnigmail.UI_RESTORE_STRICTLY_MIME) {
try {
var prefSvc = Components.classes[NS_PREFS_SERVICE_CID]
.getService(Components.interfaces.nsIPrefService);
var prefRoot = prefSvc.getBranch(null);
prefRoot.setBoolPref("mail.strictly_mime", false);
DEBUG_LOG("enigmail.js: Enigmail.encryptMessageStart: disabled quoted-printable\n");
}
catch (ex) {}
}
errorMsgObj.value = "";
if (!sendFlags) {
DEBUG_LOG("enigmail.js: Enigmail.encryptMessageStart: NO ENCRYPTION!\n");
errorMsgObj.value = EnigGetString("notRequired");
return null;
}
if (!this.initialized) {
errorMsgObj.value = EnigGetString("notInit");
return null;
}
if (this.keygenProcess) {
errorMsgObj.value = EnigGetString("notComplete");
return null;
}
var encryptCommand = this.getEncryptCommand(fromMailAddr, toMailAddr, hashAlgorithm, sendFlags, true, errorMsgObj);
if (! encryptCommand)
return null;
var signMsg = sendFlags & nsIEnigmail.SEND_SIGNED;
var statusFlagsObj = new Object();
var pipetrans = this.execStart(encryptCommand, signMsg, parent, prompter,
listener, noProxy, statusFlagsObj);
if (statusFlagsObj.value & nsIEnigmail.MISSING_PASSPHRASE) {
ERROR_LOG("enigmail.js: Enigmail.encryptMessageStart: Error - no passphrase supplied\n");
errorMsgObj.value = EnigGetString("noPassphrase");
}
if (pgpMime && errorMsgObj.value) {
if (prompter)
prompter.alert(EnigGetString("enigAlert"), errorMsgObj.value);
else
this.alertMsg(parent, errorMsgObj.value);
}
return pipetrans;
}
// Locates STRing in TEXT occurring only at the beginning of a line
function IndexOfArmorDelimiter(text, str, offset) {
//DEBUG_LOG("enigmail.js: IndexOfArmorDelimiter: "+str+", "+offset+"\n");
while (offset < text.length) {
var loc = text.indexOf(str, offset);
if ((loc < 1) || (text.charAt(loc-1) == "\n"))
return loc;
offset = loc + str.length;
}
return -1;
}
// Locates offsets bracketing PGP armored block in text,
// starting from given offset, and returns block type string.
// beginIndex = offset of first character of block
// endIndex = offset of last character of block (newline)
// If block is not found, the null string is returned;
Enigmail.prototype.locateArmoredBlock =
function (text, offset, indentStr, beginIndexObj, endIndexObj,
indentStrObj) {
DEBUG_LOG("enigmail.js: Enigmail.locateArmoredBlock: "+offset+", '"+indentStr+"'\n");
beginIndexObj.value = -1;
endIndexObj.value = -1;
var beginIndex = IndexOfArmorDelimiter(text, indentStr+"-----BEGIN PGP ", offset);
if (beginIndex == -1) {
var blockStart=text.indexOf("-----BEGIN PGP ")
if (blockStart>=0) {
var indentStart=text.search(/\n.*\-\-\-\-\-BEGIN PGP /)+1;
indentStrObj.value=text.substring(indentStart, blockStart);
indentStr=indentStrObj.value;
beginIndex = IndexOfArmorDelimiter(text, indentStr+"-----BEGIN PGP ", offset);
}
}
if (beginIndex == -1)
return "";
// Locate newline at end of armor header
offset = text.indexOf("\n", beginIndex);
if (offset == -1)
return "";
var endIndex = IndexOfArmorDelimiter(text, indentStr+"-----END PGP ", offset);
if (endIndex == -1)
return "";
// Locate newline at end of PGP block
endIndex = text.indexOf("\n", endIndex);
if (endIndex == -1) {
// No terminating newline
endIndex = text.length - 1;
}
var blockHeader = text.substr(beginIndex, offset-beginIndex+1);
var blockRegex = new RegExp("^" + indentStr +
"-----BEGIN PGP (.*)-----\\s*\\r?\\n");
var matches = blockHeader.match(blockRegex);
var blockType = "";
if (matches && (matches.length > 1)) {
blockType = matches[1];
DEBUG_LOG("enigmail.js: Enigmail.locateArmoredBlock: blockType="+blockType+"\n");
}
if (blockType == "UNVERIFIED MESSAGE") {
// Skip any unverified message block
return this.locateArmoredBlock(text, endIndex+1, indentStr,
beginIndexObj, endIndexObj, indentStrObj);
}
beginIndexObj.value = beginIndex;
endIndexObj.value = endIndex;
return blockType;
}
Enigmail.prototype.extractSignaturePart =
function (signatureBlock, part) {
DEBUG_LOG("enigmail.js: Enigmail.extractSignaturePart: part="+part+"\n");
// Search for blank line
var offset = signatureBlock.search(/\n\s*\r?\n/);
if (offset == -1)
return "";
offset = signatureBlock.indexOf("\n", offset+1);
if (offset == -1)
return "";
var beginIndex = signatureBlock.indexOf("-----BEGIN PGP SIGNATURE-----",
offset+1);
if (beginIndex == -1)
return "";
if (part == nsIEnigmail.SIGNATURE_TEXT) {
var signedText = signatureBlock.substr(offset+1, beginIndex-offset-1);
// Unescape leading dashes
signedText = signedText.replace(/^- -/, "-");
signedText = signedText.replace(/\n- -/g, "\n-");
signedText = signedText.replace(/\r- -/g, "\r-");
return signedText;
}
// Locate newline at end of armor header
offset = signatureBlock.indexOf("\n", beginIndex);
if (offset == -1)
return "";
var endIndex = signatureBlock.indexOf("-----END PGP SIGNATURE-----", offset);
if (endIndex == -1)
return "";
var signBlock = signatureBlock.substr(offset, endIndex-offset);
// Search for blank line
var armorIndex = signBlock.search(/\n\s*\r?\n/);
if (armorIndex == -1)
return "";
if (part == nsIEnigmail.SIGNATURE_HEADERS) {
return signBlock.substr(1, armorIndex);
}
armorIndex = signBlock.indexOf("\n", armorIndex+1);
if (armorIndex == -1)
return "";
if (part == nsIEnigmail.SIGNATURE_ARMOR) {
var armorData = signBlock.substr(armorIndex, endIndex-armorIndex);
armorData = armorData.replace(/\s*/g, "");
return armorData;
}
return "";
}
Enigmail.prototype.decryptMessage =
function (parent, uiFlags, cipherText, signatureObj, exitCodeObj,
statusFlagsObj, keyIdObj, userIdObj, sigDetailsObj, errorMsgObj) {
DEBUG_LOG("enigmail.js: Enigmail.decryptMessage: "+cipherText.length+" bytes, "+uiFlags+"\n");
if (! cipherText)
return "";
var interactive = uiFlags & nsIEnigmail.UI_INTERACTIVE;
var allowImport = uiFlags & nsIEnigmail.UI_ALLOW_KEY_IMPORT;
var unverifiedEncryptedOK = uiFlags & nsIEnigmail.UI_UNVERIFIED_ENC_OK;
var oldSignature = signatureObj.value;
DEBUG_LOG("enigmail.js: Enigmail.decryptMessage: oldSignature="+oldSignature+"\n");
signatureObj.value = "";
exitCodeObj.value = -1;
statusFlagsObj.value = 0;
keyIdObj.value = "";
userIdObj.value = "";
errorMsgObj.value = "";
var beginIndexObj = new Object();
var endIndexObj = new Object();
var indentStrObj = new Object();
var blockType = this.locateArmoredBlock(cipherText, 0, "",
beginIndexObj, endIndexObj, indentStrObj);
if (!blockType || blockType == "SIGNATURE") {
errorMsgObj.value = EnigGetString("noPGPblock");
statusFlagsObj.value |= nsIEnigmail.DISPLAY_MESSAGE;
return "";
}
var publicKey = (blockType == "PUBLIC KEY BLOCK");
var verifyOnly = (blockType == "SIGNED MESSAGE");
var pgpBlock = cipherText.substr(beginIndexObj.value,
endIndexObj.value - beginIndexObj.value + 1);
if (indentStrObj.value) {
RegExp.multiline = true;
var indentRegexp = new RegExp("^"+indentStrObj.value, "g");
pgpBlock = pgpBlock.replace(indentRegexp, "");
RegExp.multiline = false;
}
var head = cipherText.substr(0, beginIndexObj.value);
var tail = cipherText.substr(endIndexObj.value+1,
cipherText.length - endIndexObj.value - 1);
if (publicKey) {
if (!allowImport) {
// errorMsgObj.value = EnigGetString("decryptToImport");
statusFlagsObj.value |= nsIEnigmail.DISPLAY_MESSAGE;
// statusFlagsObj.value |= nsIEnigmail.INLINE_KEY;
return "";
}
// Import public key
var importFlags = nsIEnigmail.UI_INTERACTIVE;
exitCodeObj.value = this.importKey(parent, importFlags, pgpBlock, "",
errorMsgObj);
if (exitCodeObj.value == 0) {
statusFlagsObj.value |= nsIEnigmail.IMPORTED_KEY;
}
return "";
}
var newSignature = "";
if (verifyOnly) {
newSignature = this.extractSignaturePart(pgpBlock,
nsIEnigmail.SIGNATURE_ARMOR);
if (oldSignature && (newSignature != oldSignature)) {
ERROR_LOG("enigmail.js: Enigmail.decryptMessage: Error - signature mismatch "+newSignature+"\n");
errorMsgObj.value = EnigGetString("sigMismatch");
statusFlagsObj.value |= nsIEnigmail.DISPLAY_MESSAGE;
return "";
}
}
var noOutput = false;
var noProxy = true;
var startErrorMsgObj = new Object();
var readBytes = MSG_BUFFER_SIZE;
if (verifyOnly && pgpBlock.length > MSG_BUFFER_SIZE) {
readBytes = ((pgpBlock.length+1500)/1024).toFixed(0)*1024;
}
if (readBytes > MAX_MSG_BUFFER_SIZE) {
errorMsgObj.value = EnigGetString("messageSizeError");
statusFlagsObj.value |= nsIEnigmail.OVERFLOWED;
exitCodeObj.value = 1;
return "";
}
const maxTries = 2;
var tryCount = 0;
while (tryCount < maxTries) {
tryCount++;
var ipcBuffer = Components.classes[NS_IPCBUFFER_CONTRACTID].createInstance(Components.interfaces.nsIIPCBuffer);
ipcBuffer.open(readBytes, false);
var pipeTrans = this.decryptMessageStart(parent, null, verifyOnly, noOutput,
ipcBuffer, noProxy, startErrorMsgObj);
if (!pipeTrans) {
errorMsgObj.value = startErrorMsgObj.value;
statusFlagsObj.value |= nsIEnigmail.DISPLAY_MESSAGE;
return "";
}
// Write to child STDIN
// (ignore errors, because child may have exited already, closing STDIN)
try {
pipeTrans.writeSync(pgpBlock, pgpBlock.length);
} catch (ex) {}
// Wait for child STDOUT to close
pipeTrans.join();
var overflowed = ipcBuffer.overflowed;
var plainText = ipcBuffer.getData();
if (ipcBuffer.overflowed && plainText.length < ipcBuffer.totalBytes) {
readBytes = ((ipcBuffer.totalBytes+1500)/1024).toFixed(0)*1024;
WRITE_LOG("enigmail.js: Enigmail.decryptMessage: decrypted text too big for standard buffer, retrying with buffer size="+readBytes+"\n");
}
else {
tryCount = maxTries;
}
ipcBuffer.shutdown();
ipcBuffer = null; // make sure the object gets freed
var exitCode = this.decryptMessageEnd(uiFlags, plainText.length, pipeTrans,
verifyOnly, noOutput,
statusFlagsObj, keyIdObj, userIdObj, sigDetailsObj,
errorMsgObj);
exitCodeObj.value = exitCode;
}
if ((head.search(/\S/) >= 0) ||
(tail.search(/\S/) >= 0)) {
statusFlagsObj.value |= nsIEnigmail.PARTIALLY_PGP;
}
if (exitCodeObj.value == 0) {
// Normal return
var doubleDashSeparator = false;
try {
doubleDashSeparator = this.prefBranch.getBoolPref("doubleDashSeparator")
} catch(ex) { }
if (doubleDashSeparator && (plainText.search(/(\r|\n)-- +(\r|\n)/) < 0) ) {
// Workaround for MsgCompose stripping trailing spaces from sig separator
plainText = plainText.replace(/(\r|\n)--(\r|\n)/, "$1-- $2");
}
statusFlagsObj.value |= nsIEnigmail.DISPLAY_MESSAGE;
if (verifyOnly && indentStrObj.value) {
RegExp.multiline = true;
plainText = plainText.replace(/^/g, indentStrObj.value)
RegExp.multiline = false;
}
return plainText;
}
var pubKeyId = keyIdObj.value;
if (statusFlagsObj.value & nsIEnigmail.BAD_SIGNATURE) {
if (verifyOnly && indentStrObj.value) {
// Probably replied message that could not be verified
errorMsgObj.value = EnigGetString("unverifiedReply")+"\n\n"+errorMsgObj.value;
return "";
}
// Return bad signature (for checking later)
signatureObj.value = newSignature;
} else if (pubKeyId &&
(statusFlagsObj.value & nsIEnigmail.UNVERIFIED_SIGNATURE)) {
var innerKeyBlock;
if (verifyOnly) {
// Search for indented public key block in signed message
var innerBlockType = this.locateArmoredBlock(pgpBlock, 0, "- ",
beginIndexObj, endIndexObj,
indentStrObj);
if (innerBlockType == "PUBLIC KEY BLOCK") {
innerKeyBlock = pgpBlock.substr(beginIndexObj.value,
endIndexObj.value - beginIndexObj.value + 1);
innerKeyBlock = innerKeyBlock.replace(/- -----/g, "-----");
statusFlagsObj.value |= nsIEnigmail.INLINE_KEY;
DEBUG_LOG("enigmail.js: Enigmail.decryptMessage: innerKeyBlock found\n");
}
}
if (allowImport) {
var importedKey = false;
if (innerKeyBlock) {
var importErrorMsgObj = new Object();
var importFlags2 = nsIEnigmail.UI_INTERACTIVE;
var exitStatus = this.importKey(parent, importFlags2, innerKeyBlock,
pubKeyId, importErrorMsgObj);
importedKey = (exitStatus == 0);
if (exitStatus > 0) {
this.alertMsg(parent, EnigGetString("cantImport")+importErrorMsgObj.value);
}
}
if (importedKey) {
// Recursive call; note that nsIEnigmail.UI_ALLOW_KEY_IMPORT is unset
// to break the recursion
var uiFlagsDeep = interactive ? nsIEnigmail.UI_INTERACTIVE : 0;
signatureObj.value = "";
return this.decryptMessage(parent, uiFlagsDeep, pgpBlock,
signatureObj, exitCodeObj, statusFlagsObj,
keyIdObj, userIdObj, sigDetailsObj, errorMsgObj);
}
}
if (plainText && !unverifiedEncryptedOK) {
// Append original PGP block to unverified message
plainText = "-----BEGIN PGP UNVERIFIED MESSAGE-----\r\n" + plainText +
"-----END PGP UNVERIFIED MESSAGE-----\r\n\r\n" + pgpBlock;
}
}
return verifyOnly ? "" : plainText;
}
Enigmail.prototype.decryptMessageStart =
function (parent, prompter, verifyOnly, noOutput,
listener, noProxy, errorMsgObj) {
DEBUG_LOG("enigmail.js: Enigmail.decryptMessageStart: prompter="+prompter+", verifyOnly="+verifyOnly+", noOutput="+noOutput+"\n");
if (!this.initialized) {
errorMsgObj.value = EnigGetString("notInit");
return null;
}
if (this.keygenProcess) {
errorMsgObj.value = EnigGetString("notComplete");
return null;
}
var decryptCommand = this.getAgentPath();
if (this.agentType == "pgp") {
decryptCommand += PGP_BATCH_OPTS + " -ft";
} else if (noOutput) {
decryptCommand += GPG_BATCH_OPTS + " --verify";
} else {
decryptCommand += GPG_BATCH_OPTS + " -d";
}
var statusFlagsObj = new Object();
var pipetrans = this.execStart(decryptCommand, !verifyOnly, parent, prompter,
listener, noProxy, statusFlagsObj);
if (statusFlagsObj.value & nsIEnigmail.MISSING_PASSPHRASE) {
ERROR_LOG("enigmail.js: Enigmail.decryptMessageStart: Error - no passphrase supplied\n");
errorMsgObj.value = EnigGetString("noPassphrase");
return null;
}
return pipetrans;
}
Enigmail.prototype.decryptMessageEnd =
function (uiFlags, outputLen, pipeTransport, verifyOnly, noOutput,
statusFlagsObj, keyIdObj, userIdObj, sigDetailsObj, errorMsgObj) {
DEBUG_LOG("enigmail.js: Enigmail.decryptMessageEnd: uiFlags="+uiFlags+", outputLen="+outputLen+", pipeTransport="+pipeTransport+", verifyOnly="+verifyOnly+", noOutput="+noOutput+"\n");
var interactive = uiFlags & nsIEnigmail.UI_INTERACTIVE;
var pgpMime = uiFlags & nsIEnigmail.UI_PGP_MIME;
var allowImport = uiFlags & nsIEnigmail.UI_ALLOW_KEY_IMPORT;
var unverifiedEncryptedOK = uiFlags & nsIEnigmail.UI_UNVERIFIED_ENC_OK;
statusFlagsObj.value = 0;
errorMsgObj.value = "";
if (!this.initialized) {
errorMsgObj.value = EnigGetString("notInit");
return -1;
}
// Terminate job and parse error output
var statusMsgObj = new Object();
var cmdLineObj = new Object();
var cmdErrorMsgObj = new Object();
var exitCode = this.execEnd(pipeTransport, statusFlagsObj, statusMsgObj, cmdLineObj, cmdErrorMsgObj);
if (pgpMime) {
statusFlagsObj.value |= verifyOnly ? nsIEnigmail.PGP_MIME_SIGNED
: nsIEnigmail.PGP_MIME_ENCRYPTED;
}
var statusMsg = statusMsgObj.value;
exitCode = this.fixExitCode(exitCode, statusFlagsObj.value);
if ((exitCode == 0) && !noOutput && !outputLen) {
exitCode = -1;
}
if (exitCode == 0) {
// Normal return
var errLines, goodSignPat, badSignPat, keyExpPat;
if (statusMsg) {
errLines = statusMsg.split(/\r?\n/);
goodSignPat = /GOODSIG (\w{16}) (.*)$/i;
badSignPat = /BADSIG (\w{16}) (.*)$/i;
keyExpPat = /EXPKEYSIG (\w{16}) (.*)$/i
revKeyPat = /REVKEYSIG (\w{16}) (.*)$/i;
validSigPat = /VALIDSIG (\w+) (.*) (\d+) (.*)/i;
} else {
errLines = cmdErrorMsgObj.value.split(/\r?\n/);
goodSignPat = /Good signature from (user )?"(.*)"\.?/i;
badSignPat = /BAD signature from (user )?"(.*)"\.?/i;
keyExpPat = /This key has expired/i;
revKeyPat = /This key has been revoked/i;
validSigPat = /dummy-not-used/i;
}
errorMsgObj.value = "";
var matches;
var signed = false;
var goodSignature;
var userId = "";
var keyId = "";
var sigDetails = "";
for (j=0; j<errLines.length; j++) {
matches = errLines[j].match(badSignPat);
if (matches && (matches.length > 2)) {
signed = true;
goodSignature = false;
userId = matches[2];
keyId = matches[1];
break;
}
matches = errLines[j].match(revKeyPat);
if (matches && (matches.length > 2)) {
signed = true;
goodSignature = true;
userId = matches[2];
keyId = matches[1];
break;
}
matches = errLines[j].match(goodSignPat);
if (matches && (matches.length > 2)) {
signed = true;
goodSignature = true;
userId = matches[2];
keyId = matches[1];
break;
}
matches = errLines[j].match(keyExpPat);
if (matches && (matches.length > 2)) {
signed = true;
goodSignature = true;
userId = matches[2];
keyId = matches[1];
break;
}
}
if (goodSignature) {
for (var j=0; j<errLines.length; j++) {
matches = errLines[j].match(validSigPat);
if (matches && (matches.length > 2)) {
sigDetails = errLines[j].substr(9);
break;
}
}
}
try {
if (userId && keyId && this.prefBranch.getBoolPref("displaySecondaryUid")) {
uids = this.getKeyDetails(keyId, true);
if (uids) {
userId = uids;
}
}
}
catch (ex) {}
if (userId) {
userId = EnigConvertToUnicode(userId, "UTF-8");
}
userIdObj.value = userId;
keyIdObj.value = keyId;
sigDetailsObj.value = sigDetails;
if (signed) {
var trustPrefix = "";
if (statusFlagsObj.value & nsIEnigmail.UNTRUSTED_IDENTITY) {
trustPrefix += EnigGetString("prefUntrusted")+" ";
}
if (statusFlagsObj.value & nsIEnigmail.REVOKED_KEY) {
trustPrefix += EnigGetString("prefRevoked")+" ";
}
if (statusFlagsObj.value & nsIEnigmail.EXPIRED_KEY_SIGNATURE) {
trustPrefix += EnigGetString("prefExpiredKey")+" ";
} else if (statusFlagsObj.value & nsIEnigmail.EXPIRED_SIGNATURE) {
trustPrefix += EnigGetString("prefExpired")+" ";
}
if (goodSignature) {
errorMsgObj.value = trustPrefix + EnigGetString("prefGood",userId) /* + ", " +
EnigGetString("keyId") + " 0x" + keyId.substring(8,16); */
if (this.agentType != "gpg") {
// Trust all good signatures, if not GPG
statusFlagsObj.value |= nsIEnigmail.GOOD_SIGNATURE | nsIEnigmail.TRUSTED_IDENTITY;
}
} else {
errorMsgObj.value = trustPrefix + EnigGetString("prefBad",userId) /*+ ", " +
EnigGetString("keyId") + " 0x" + keyId.substring(8,16); */
if (!exitCode)
exitCode = 1;
if (this.agentType != "gpg")
statusFlagsObj.value |= nsIEnigmail.BAD_SIGNATURE;
}
}
if (!verifyOnly && (this.agentType != "gpg")) {
statusFlagsObj.value |= nsIEnigmail.DECRYPTION_OKAY;
}
return exitCode;
}
if ( (statusFlagsObj.value & nsIEnigmail.BAD_PASSPHRASE) ||
((this.agentType == "pgp") && !verifyOnly && (exitCode != 30)) ) {
// "Unremember" passphrase on decryption failure
this.clearCachedPassphrase();
}
var pubKeyId;
if (statusFlagsObj.value & nsIEnigmail.UNVERIFIED_SIGNATURE) {
// Unverified signature
var matchb = statusMsg.match(/(^|\n)NO_PUBKEY (\w{8})(\w{8})/);
if (matchb && (matchb.length > 3)) {
pubKeyId = "0x" + matchb[3];
DEBUG_LOG("enigmail.js: Enigmail.decryptMessageEnd: NO_PUBKEY "+pubKeyId+"\n");
keyIdObj.value = matchb[2]+matchb[3];
}
if (statusFlagsObj.value & nsIEnigmail.DECRYPTION_OKAY) {
exitCode=0;
}
}
if (this.agentType != "gpg") {
// Not GPG
if (verifyOnly) {
// Assume bad signature is reason for failure
statusFlagsObj.value |= nsIEnigmail.BAD_SIGNATURE;
} else {
statusFlagsObj.value |= outputLen ? nsIEnigmail.DECRYPTION_OKAY
: nsIEnigmail.DECRYPTION_FAILED;
}
}
if (exitCode != 0) {
// Error processing
ERROR_LOG("enigmail.js: Enigmail.decryptMessageEnd: Error in command execution\n");
}
if (cmdErrorMsgObj.value) {
errorMsgObj.value = this.agentType + " " + EnigGetString("cmdLine");
errorMsgObj.value += "\n" + cmdLineObj.value;
errorMsgObj.value += "\n" + cmdErrorMsgObj.value;
}
return exitCode;
}
// ExitCode == 0 => success
// ExitCode > 0 => error
// ExitCode == -1 => Cancelled by user
Enigmail.prototype.receiveKey =
function (recvFlags, keyserver, keyId, requestObserver, errorMsgObj) {
DEBUG_LOG("enigmail.js: Enigmail.receiveKey: "+keyId+"\n");
if (!this.initialized) {
errorMsgObj.value = EnigGetString("notInit");
return null;
}
if (this.agentType != "gpg") {
errorMsgObj.value = EnigGetString("failOnlyGPG");
return null;
}
if (!keyserver) {
errorMsgObj.value = EnigGetString("failNoServer");
return null;
}
if (!keyId && ! (recvFlags & nsIEnigmail.REFRESH_KEY)) {
errorMsgObj.value = EnigGetString("failNoID");
return null;
}
var envList = [];
envList = envList.concat(gEnvList);
var proxyHost = null;
try {
if (this.prefBranch.getBoolPref("respectHttpProxy")) {
// determine proxy host
var prefsSvc = Components.classes[NS_PREFS_SERVICE_CID].getService(Components.interfaces.nsIPrefService);
var prefRoot = prefsSvc.getBranch(null);
var useProxy = prefRoot.getIntPref("network.proxy.type");
if (useProxy==1) {
var proxyHostName = prefRoot.getCharPref("network.proxy.http");
var proxyHostPort = prefRoot.getIntPref("network.proxy.http_port");
var noProxy = prefRoot.getCharPref("network.proxy.no_proxies_on").split(/[ ,]/);
for (var i=0; i<noProxy.length; i++) {
var proxySearch=new RegExp(noProxy[i].replace(/\./, "\\.")+"$", "i");
if (noProxy[i] && keyserver.search(proxySearch)>=0) {
i=noProxy.length+1;
proxyHostName=null;
}
}
if (proxyHostName && proxyHostPort) {
proxyHost="http://"+proxyHostName+":"+proxyHostPort
}
}
}
}
catch (ex) {}
var command = this.getAgentPath();
if (! (recvFlags & nsIEnigmail.SEARCH_KEY)) command += GPG_BATCH_OPTS;
if (proxyHost) {
command += " --keyserver-options honor-http-proxy";
envList.push("http_proxy="+proxyHost);
}
command += " --keyserver " + keyserver;
if (recvFlags & nsIEnigmail.DOWNLOAD_KEY) {
command += " --recv-keys " + keyId;
}
else if (recvFlags & nsIEnigmail.SEARCH_KEY) {
command += " --search-keys " + keyId;
}
else if (recvFlags & nsIEnigmail.UPLOAD_KEY) {
command += " --send-keys " + keyId;
}
else if (recvFlags & nsIEnigmail.REFRESH_KEY) {
command += " --refresh-keys";
}
var exitCodeObj = new Object();
var statusFlagsObj = new Object();
var statusMsgObj = new Object();
var cmdLineObj = new Object();
CONSOLE_LOG("enigmail> "+command.replace(/\\\\/g, "\\")+"\n");
var pipeConsole = Components.classes[NS_PIPECONSOLE_CONTRACTID].createInstance(Components.interfaces.nsIPipeConsole);
// Create joinable console
pipeConsole.open(20, 80, true);
var ipcRequest = null;
try {
ipcRequest = gEnigmailSvc.ipcService.execAsync(command,
false,
"",
"",
0,
envList, envList.length,
pipeConsole,
pipeConsole,
requestObserver);
} catch (ex) {
ERROR_LOG("enigmail.js: Enigmail.receiveKey: execAsync failed\n");
}
if (!ipcRequest) {
ERROR_LOG("enigmail.js: Enigmail.receiveKey: execAsync failed somehow\n");
return null;
}
return ipcRequest;
}
Enigmail.prototype.searchKey =
function (recvFlags, protocol, keyserver, port, keyValue, requestObserver, errorMsgObj) {
DEBUG_LOG("enigmail.js: Enigmail.searchKey: "+keyValue+"\n");
if (!this.initialized) {
errorMsgObj.value = EnigGetString("notInit");
return null;
}
if (this.agentType != "gpg") {
errorMsgObj.value = EnigGetString("failOnlyGPG");
return null;
}
if (!keyserver) {
errorMsgObj.value = EnigGetString("failNoServer");
return null;
}
if (!keyValue) {
errorMsgObj.value = EnigGetString("failNoID");
return null;
}
var envList = [];
envList = envList.concat(gEnvList);
var proxyHost = null;
if (protocol=="hkp") {
try {
if (this.prefBranch.getBoolPref("respectHttpProxy")) {
// determine proxy host
var prefsSvc = Components.classes[NS_PREFS_SERVICE_CID].getService(Components.interfaces.nsIPrefService);
var prefRoot = prefsSvc.getBranch(null);
var useProxy = prefRoot.getIntPref("network.proxy.type");
if (useProxy==1) {
var proxyHostName = prefRoot.getCharPref("network.proxy.http");
var proxyHostPort = prefRoot.getIntPref("network.proxy.http_port");
var noProxy = prefRoot.getCharPref("network.proxy.no_proxies_on").split(/[ ,]/);
for (var i=0; i<noProxy.length; i++) {
var proxySearch=new RegExp(noProxy[i].replace(/\./, "\\.")+"$", "i");
if (noProxy[i] && keyserver.search(proxySearch)>=0) {
i=noProxy.length+1;
proxyHostName=null;
}
}
if (proxyHostName && proxyHostPort) {
proxyHost="http://"+proxyHostName+":"+proxyHostPort
}
}
}
}
catch (ex) {}
}
var baseCommand = "gpgkeys_" + protocol;
if (this.isDosLike) {
baseCommand+=".exe";
}
var baseDir = Components.classes[NS_LOCAL_FILE_CONTRACTID].createInstance(nsILocalFile);
baseDir.initWithPath(this.agentPath);
var command = null;
// try to locate gpgkeys_*
if (baseDir)
baseDir = baseDir.parent;
if (baseDir) {
var theCommand=baseDir.clone();
// first the same dir as gpg executable
theCommand.append(baseCommand);
if (theCommand.exists() && theCommand.isExecutable())
command = theCommand.path;
if (! command) {
// then lib
theCommand.append("lib");
theCommand.append(baseCommand);
if (theCommand.exists() && theCommand.isExecutable())
command = theCommand.path;
}
if (!command) {
if (baseDir.parent) {
baseDir=baseDir.parent;
theCommand=baseDir.clone();
// then ..\lib\gnupg or ../lib/gnupg
theCommand.append("lib");
theCommand.append("gnupg");
theCommand.append(baseCommand);
if (theCommand.exists() && theCommand.isExecutable()) {
command = theCommand.path;
}
else {
theCommand=baseDir.clone();
// then ..\libexec\gnupg or ../libexec/gnupg
theCommand.append("libexec");
theCommand.append("gnupg");
theCommand.append(baseCommand);
if (theCommand.exists() && theCommand.isExecutable())
command = theCommand.path;
}
}
}
}
if (! command) {
// no gpgkeys_* found
return null;
}
command=command.replace(/\\\\/g, "\\").replace(/\\/g, "\\\\");
// call gpgkeys to check the version number
var outObj = new Object();
var outLenObj = new Object();
var errObj = new Object();
var errLenObj = new Object();
var testCmd = command + " -V"
CONSOLE_LOG("\nenigmail> "+testCmd.replace(/\\\\/g, "\\")+"\n");
try {
var exitCode = this.ipcService.execPipe(testCmd,
false,
"",
"", 0,
envList, envList.length,
outObj, outLenObj,
errObj, errLenObj);
}
catch (ex) {
CONSOLE_LOG(testCmd.replace(/\\\\/g, "\\")+" failed\n");
return null;
}
if (exitCode !=0) {
CONSOLE_LOG(testCmd.replace(/\\\\/g, "\\")+" not found\n");
return null;
}
CONSOLE_LOG(outObj.value+"\n");
var ver = outObj.value.split(/[\n\r]+/);
if (Number(ver[0])==0 || Number(ver[0])==1) {
var inputData="VERSION "+ver[0]+"\nHOST "+keyserver+"\nPORT "+port+"\n";
}
else {
return null;
}
if (proxyHost) {
inputData+="OPTION honor-http-proxy\n";
envList.push("http_proxy="+proxyHost);
}
if (recvFlags & nsIEnigmail.SEARCH_KEY) {
inputData+="COMMAND search\n\n"+keyValue+"\n\n";
}
else if (recvFlags & nsIEnigmail.DOWNLOAD_KEY) {
inputData+="COMMAND get\n\n+"+keyValue+"\n\n";
}
var pipeConsole = Components.classes[NS_PIPECONSOLE_CONTRACTID].createInstance(Components.interfaces.nsIPipeConsole);
// Create joinable console
pipeConsole.open(5000, 0, true);
var errorConsole = Components.classes[NS_PIPECONSOLE_CONTRACTID].createInstance(Components.interfaces.nsIPipeConsole);
errorConsole.open(20, 0, true);
CONSOLE_LOG("enigmail> "+command.replace(/\\\\/g, "\\")+"\n");
var ipcRequest = null;
try {
ipcRequest = gEnigmailSvc.ipcService.execAsync(command,
false,
"",
inputData,
inputData.length,
envList, envList.length,
pipeConsole,
errorConsole,
requestObserver);
} catch (ex) {
ERROR_LOG("enigmail.js: Enigmail.searchKey: execAsync failed\n");
}
if (!ipcRequest) {
ERROR_LOG("enigmail.js: Enigmail.searchKey: execAsync failed somehow\n");
return null;
}
return ipcRequest;
}
Enigmail.prototype.extractKey =
function (parent, exportFlags, userId, outputFile, exitCodeObj, errorMsgObj) {
DEBUG_LOG("enigmail.js: Enigmail.extractKey: "+userId+"\n");
if (!this.initialized) {
errorMsgObj.value = EnigGetString("notInit");
return "";
}
var command = this.getAgentPath();
command += GPG_BATCH_OPTS + " -a --export ";
command += userId;
var statusFlagsObj = new Object();
var statusMsgObj = new Object();
var cmdErrorMsgObj = new Object();
var keyBlock = this.execCmd(command, null, "",
exitCodeObj, statusFlagsObj, statusMsgObj, cmdErrorMsgObj);
if ((exitCodeObj.value == 0) && !keyBlock)
exitCodeObj.value = -1;
if (exitCodeObj.value != 0) {
errorMsgObj.value = EnigGetString("failKeyExtract");
if (cmdErrorMsgObj.value) {
errorMsgObj.value += "\n" + command;
errorMsgObj.value += "\n" + cmdErrorMsgObj.value;
}
return "";
}
if (exportFlags & nsIEnigmail.EXTRACT_SECRET_KEY) {
command = this.getAgentPath();
command += GPG_BATCH_OPTS + " -a --export-secret-keys ";
command += userId;
var secKeyBlock = this.execCmd(command, null, "",
exitCodeObj, statusFlagsObj, statusMsgObj, cmdErrorMsgObj);
if ((exitCodeObj.value == 0) && !secKeyBlock)
exitCodeObj.value = -1;
if (exitCodeObj.value != 0) {
errorMsgObj.value = EnigGetString("failKeyExtract");
if (cmdErrorMsgObj.value) {
errorMsgObj.value += "\n" + command;
errorMsgObj.value += "\n" + cmdErrorMsgObj.value;
}
return "";
}
if (keyBlock.substr(-1,1).search(/[\r\n]/)<0) keyBlock += "\n"
keyBlock+=secKeyBlock;
}
if (outputFile) {
if (! WriteFileContents(outputFile, keyBlock, DEFAULT_FILE_PERMS)) {
exitCodeObj.value = -1;
errorMsgObj.value = EnigGetString("fileWriteFailed", outputFile);
}
return "";
}
return keyBlock;
}
// ExitCode == 0 => success
// ExitCode > 0 => error
// ExitCode == -1 => Cancelled by user
Enigmail.prototype.importKey =
function (parent, uiFlags, msgText, keyId, errorMsgObj) {
DEBUG_LOG("enigmail.js: Enigmail.importKey: id="+keyId+", "+uiFlags+"\n");
if (!this.initialized) {
errorMsgObj.value = EnigGetString("notInit");
return 1;
}
var beginIndexObj = new Object();
var endIndexObj = new Object();
var indentStrObj = new Object();
var blockType = this.locateArmoredBlock(msgText, 0, "",
beginIndexObj, endIndexObj,
indentStrObj);
if (!blockType) {
errorMsgObj.value = EnigGetString("noPGPblock");
return 1;
}
if (blockType != "PUBLIC KEY BLOCK") {
errorMsgObj.value = EnigGetString("notFirstBlock");
return 1;
}
var pgpBlock = msgText.substr(beginIndexObj.value,
endIndexObj.value - beginIndexObj.value + 1);
var interactive = uiFlags & nsIEnigmail.UI_INTERACTIVE;
if (interactive) {
var confirmMsg = EnigGetString("importKeyConfirm");
if (!this.confirmMsg(parent, confirmMsg)) {
errorMsgObj.value = EnigGetString("failCancel");
return -1;
}
}
var command = this.getAgentPath();
if (this.agentType == "pgp") {
command += PGP_BATCH_OPTS + " -ft -ka";
} else {
command += GPG_BATCH_OPTS + " --import";
}
var exitCodeObj = new Object();
var statusFlagsObj = new Object();
var statusMsgObj = new Object();
var output = this.execCmd(command, null, pgpBlock,
exitCodeObj, statusFlagsObj, statusMsgObj, errorMsgObj);
var statusMsg = statusMsgObj.value;
var pubKeyId;
if (exitCodeObj.value == 0) {
// Normal return
this.invalidateUserIdList();
if (statusMsg && (statusMsg.search("IMPORTED ") > -1)) {
var matches = statusMsg.match(/(^|\n)IMPORTED (\w{8})(\w{8})/);
if (matches && (matches.length > 3)) {
pubKeyId = "0x" + matches[3];
DEBUG_LOG("enigmail.js: Enigmail.importKey: IMPORTED "+pubKeyId+"\n");
}
}
}
return exitCodeObj.value;
}
Enigmail.prototype.importKeyFromFile =
function (parent, fileName, errorMsgObj) {
DEBUG_LOG("enigmail.js: Enigmail.importKeyFromFile: fileName="+fileName+"\n");
if (!this.initialized) {
errorMsgObj.value = EnigGetString("notInit");
return 1;
}
fileName=fileName.replace(/\\/g, "\\\\");
var command = this.getAgentPath();
command += GPG_BATCH_OPTS + " --import '"+fileName+"'";
var statusFlagsObj = new Object();
var statusMsgObj = new Object();
var exitCodeObj = new Object();
var output = this.execCmd(command, null, "",
exitCodeObj, statusFlagsObj, statusMsgObj, errorMsgObj);
var statusMsg = statusMsgObj.value;
var pubKeyId;
if (exitCodeObj.value == 0) {
// Normal return
this.invalidateUserIdList();
if (statusMsg && (statusMsg.search("IMPORTED ") > -1)) {
var matches = statusMsg.match(/(^|\n)IMPORTED (\w{8})(\w{8})/);
if (matches && (matches.length > 3)) {
pubKeyId = "0x" + matches[3];
DEBUG_LOG("enigmail.js: Enigmail.importKey: IMPORTED "+pubKeyId+"\n");
}
}
errorMsgObj.value = EnigConvertGpgToUnicode(errorMsgObj.value);
}
return exitCodeObj.value;
}
Enigmail.prototype.generateKey =
function (parent, name, comment, email, expiryDate, keyLength, passphrase,
requestObserver) {
WRITE_LOG("enigmail.js: Enigmail.generateKey: \n");
if (this.keygenProcess || (this.agentType != "gpg"))
throw Components.results.NS_ERROR_FAILURE;
var pipeConsole = Components.classes[NS_PIPECONSOLE_CONTRACTID].createInstance(Components.interfaces.nsIPipeConsole);
// Create joinable console
pipeConsole.open(100, 80, true);
var command = this.getAgentPath() + GPG_BATCH_OPTS + " --gen-key";
pipeConsole.write(command.replace(/\\\\/g, "\\")+"\n");
CONSOLE_LOG(command.replace(/\\\\/g, "\\")+"\n");
var inputData = "%echo Generating a standard key\nKey-Type: DSA\nKey-Length: 1024\nSubkey-Type: ELG-E\n";
inputData += "Subkey-Length: "+keyLength+"\n";
inputData += "Name-Real: "+name+"\n";
if (comment)
inputData += "Name-Comment: "+comment+"\n";
inputData += "Name-Email: "+email+"\n";
inputData += "Expire-Date: "+String(expiryDate)+"\n";
pipeConsole.write(inputData+"\n");
CONSOLE_LOG(inputData+" \n");
if (passphrase.length)
inputData += "Passphrase: "+passphrase+"\n";
inputData += "%commit\n%echo done\n";
var ipcRequest = null;
try {
var useShell = false;
ipcRequest = gEnigmailSvc.ipcService.execAsync(command,
useShell,
"",
inputData,
inputData.length,
[], 0,
pipeConsole,
pipeConsole,
requestObserver);
} catch (ex) {
}
if (!ipcRequest) {
ERROR_LOG("enigmail.js: Enigmail.generateKey: execAsync failed\n");
return null;
}
this.keygenRequest = ipcRequest;
DEBUG_LOG("enigmail.js: Enigmail.generateKey: ipcRequest = "+ipcRequest+"\n");
return ipcRequest;
}
Enigmail.prototype.createMessageURI =
function (originalUrl, contentType, contentCharset, contentData, persist) {
DEBUG_LOG("enigmail.js: Enigmail.createMessageURI: "+originalUrl+
", "+contentType+", "+contentCharset+"\n");
var messageId = "msg" + Math.floor(Math.random()*1.0e9);
this._messageIdList[messageId] = {originalUrl:originalUrl,
contentType:contentType,
contentCharset:contentCharset,
contentData:contentData,
persist:persist};
return "enigmail:message?id="+messageId;
}
function ExtractMessageId(uri) {
var messageId = "";
var matches = uri.match(/^enigmail:message\?id=(.+)/);
if (matches && (matches.length > 1)) {
messageId = matches[1];
}
return messageId;
}
Enigmail.prototype.deleteMessageURI =
function (uri) {
DEBUG_LOG("enigmail.js: Enigmail.deleteMessageURI: "+uri+"\n");
var messageId = ExtractMessageId(uri);
if (!messageId)
return false;
return (delete this._messageIdList[messageId]);
}
function IPCContext()
{
}
IPCContext.prototype = {
command: "",
pipeTransport: null,
stdoutConsole: null,
stderrConsole: null,
QueryInterface: function (iid) {
if (!iid.equals(Components.interfaces.nsIIPCContext) &&
!iid.equals(Components.interfaces.nsISupports))
throw Components.results.NS_ERROR_NO_INTERFACE;
return this;
}
}
const ENIGMAIL_PANEL_URL = "chrome://enigmail/content/enigmailPanel.xul";
Enigmail.prototype.selectPanel =
function (url) {
WRITE_LOG("enigmail.js: Enigmail.selectPanel: "+url+"\n");
var wm = Components.classes[WMEDIATOR_CONTRACTID].getService(Components.interfaces.nsIWindowMediator);
var navWindowList = wm.getEnumerator("navigator:browser");
var retval = false;
while (navWindowList.hasMoreElements()) {
var navWindow =navWindowList.getNext();
DEBUG_LOG("enigmail.js: navWindow="+navWindow+"\n");
var href = navWindow._content.location.href;
DEBUG_LOG("enigmail.js: href="+href+"\n");
if (href.toLowerCase().indexOf(url.toLowerCase()) != 0)
continue;
var enigmailPanel = navWindow.document.getElementById("urn:sidebar:3rdparty-panel:"+ENIGMAIL_PANEL_URL);
DEBUG_LOG("enigmail.js: panel="+enigmailPanel+"\n");
if (!enigmailPanel) {
// Add panel
enigmailAddPanel();
enigmailPanel = navWindow.document.getElementById("urn:sidebar:3rdparty-panel:"+ENIGMAIL_PANEL_URL);
DEBUG_LOG("enigmail.js: panel="+enigmailPanel+"\n");
if (!enigmailPanel) {
DEBUG_LOG("enigmail.js: Added panel not found in document!\n");
return false;
}
}
navWindow.SidebarSelectPanel(enigmailPanel, true, true);
retval = true;
}
return retval;
}
// Chrome sidebar panel adding code
function enigmailAddPanel() {
DEBUG_LOG("enigmail.js: Adding Enigmail panel\n");
var sidebarObj = new chromeSidebar();
sidebarObj.addPanel("Enigmail", ENIGMAIL_PANEL_URL, "");
}
const PANELS_RDF_FILE = "UPnls"; /* directory services property to find panels.rdf */
const CONTAINER_CONTRACTID = "@mozilla.org/rdf/container;1";
const DIR_SERV_CONTRACTID = "@mozilla.org/file/directory_service;1"
const NETSEARCH_CONTRACTID = "@mozilla.org/rdf/datasource;1?name=internetsearch"
const RDF_CONTRACTID = "@mozilla.org/rdf/rdf-service;1";
const nsIRDFService = Components.interfaces.nsIRDFService;
const nsIRDFContainer = Components.interfaces.nsIRDFContainer;
const nsIRDFRemoteDataSource = Components.interfaces.nsIRDFRemoteDataSource;
function chromeSidebar()
{
this.rdf = Components.classes[RDF_CONTRACTID].getService(nsIRDFService);
this.datasource_uri = getSidebarDatasourceURI(PANELS_RDF_FILE);
DEBUG_LOG("enigmail.js: datasource_uri is" + this.datasource_uri + "\n");
this.resource = 'urn:sidebar:current-panel-list';
this.datasource = this.rdf.GetDataSource(this.datasource_uri);
}
chromeSidebar.prototype.nc = "http://home.netscape.com/NC-rdf#";
function sidebarURLSecurityCheck(url)
{
if (url.search(/(^chrome:|^http:|^ftp:|^https:)/) == -1)
throw "Script attempted to add sidebar panel from illegal source";
}
chromeSidebar.prototype.isPanel =
function (aContentURL)
{
var container =
Components.classes[CONTAINER_CONTRACTID].createInstance(nsIRDFContainer);
/* Create a resource for the new panel and add it to the list */
var panel_resource =
this.rdf.GetResource("urn:sidebar:3rdparty-panel:" + aContentURL);
return (container.IndexOf(panel_resource) != -1);
}
/* decorate prototype to provide ``class'' methods and property accessors */
chromeSidebar.prototype.addPanel =
function (aTitle, aContentURL, aCustomizeURL)
{
DEBUG_LOG("enigmail.js: addPanel(" + aTitle + ", " + aContentURL + ", " +
aCustomizeURL + ")" + "\n");
sidebarURLSecurityCheck(aContentURL);
// Create a "container" wrapper around the current panels to
// manipulate the RDF:Seq more easily.
var panel_list = this.datasource.GetTarget(this.rdf.GetResource(this.resource), this.rdf.GetResource(chromeSidebar.prototype.nc+"panel-list"), true);
if (panel_list) {
panel_list.QueryInterface(Components.interfaces.nsIRDFResource);
} else {
// Datasource is busted. Start over.
DEBUG_LOG("enigmail.js: Sidebar datasource is busted\n");
}
var container = Components.classes[CONTAINER_CONTRACTID].createInstance(nsIRDFContainer);
container.Init(this.datasource, panel_list);
/* Create a resource for the new panel and add it to the list */
var panel_resource =
this.rdf.GetResource("urn:sidebar:3rdparty-panel:" + aContentURL);
var panel_index = container.IndexOf(panel_resource);
if (panel_index != -1)
{
DEBUG_LOG("enigmail.js: addPanel(): panel already in list"+"\n");
return;
}
/* Now make some sidebar-ish assertions about it... */
this.datasource.Assert(panel_resource,
this.rdf.GetResource(this.nc + "title"),
this.rdf.GetLiteral(aTitle),
true);
this.datasource.Assert(panel_resource,
this.rdf.GetResource(this.nc + "content"),
this.rdf.GetLiteral(aContentURL),
true);
if (aCustomizeURL)
this.datasource.Assert(panel_resource,
this.rdf.GetResource(this.nc + "customize"),
this.rdf.GetLiteral(aCustomizeURL),
true);
container.AppendElement(panel_resource);
// Use an assertion to pass a "refresh" event to all the sidebars.
// They use observers to watch for this assertion (in sidebarOverlay.js).
this.datasource.Assert(this.rdf.GetResource(this.resource),
this.rdf.GetResource(this.nc + "refresh"),
this.rdf.GetLiteral("true"),
true);
this.datasource.Unassert(this.rdf.GetResource(this.resource),
this.rdf.GetResource(this.nc + "refresh"),
this.rdf.GetLiteral("true"));
/* Write the modified panels out. */
this.datasource.QueryInterface(nsIRDFRemoteDataSource).Flush();
DEBUG_LOG("enigmail.js: Panel successfully added to sidebar\n");
}
function getSidebarDatasourceURI(panels_file_id)
{
try
{
/* use the fileLocator to look in the profile directory
* to find 'panels.rdf', which is the
* database of the user's currently selected panels. */
var directory_service = Components.classes[DIR_SERV_CONTRACTID].getService();
if (directory_service)
directory_service = directory_service.QueryInterface(Components.interfaces.nsIProperties);
/* if <profile>/panels.rdf doesn't exist, get will copy
*bin/defaults/profile/panels.rdf to <profile>/panels.rdf */
var sidebar_file = directory_service.get(panels_file_id, Components.interfaces.nsIFile);
if (!sidebar_file.exists())
{
/* this should not happen, as GetFileLocation() should copy
* defaults/panels.rdf to the users profile directory */
DEBUG_LOG("enigmail.js: sidebar file does not exist" + "\n");
return null;
}
DEBUG_LOG("enigmail.js: sidebar uri is " + sidebar_file.URL + "\n");
return sidebar_file.URL;
}
catch (ex)
{
/* this should not happen */
DEBUG_LOG("enigmail.js: caught " + ex + " getting sidebar datasource uri" + "\n");
return null;
}
}
// retrieves a localized string from the enigmail.properties stringbundle
function EnigGetString(aStr) {
var restCount = arguments.length - 1;
if(!gEnigStrBundle) {
try {
var strBundleService = Components.classes[ENIG_STRINGBUNDLE_CONTRACTID].getService();
strBundleService = strBundleService.QueryInterface(nsIEnigStrBundle);
gEnigStrBundle = strBundleService.createBundle("chrome://enigmail/locale/enigmail.properties");
} catch (ex) {
ERROR_LOG("enigmailCommon.js: Error in instantiating stringBundleService\n");
}
}
if(gEnigStrBundle) {
try {
if(restCount > 0) {
var subPhrases = new Array();
for (var i = 1; i < arguments.length; i++) {
subPhrases.push(arguments[i]);
}
return gEnigStrBundle.formatStringFromName(aStr, subPhrases, subPhrases.length);
}
else {
return gEnigStrBundle.GetStringFromName(aStr);
}
} catch (ex) {
ERROR_LOG("enigmailCommon.js: Error in querying stringBundleService for string '"+aStr+"'\n");
}
}
return null;
}
Enigmail.prototype.invalidateUserIdList =
function () {
// clean the userIdList to force reloading the list at next usage
this.userIdList= null;
}
// returns the output of -with-colons --list[-secret]-keys
Enigmail.prototype.getUserIdList =
function (secretOnly, refresh, exitCodeObj, statusFlagsObj, errorMsgObj) {
if (secretOnly || refresh || this.userIdList == null) {
var gpgCommand = this.getAgentPath() + GPG_BATCH_OPTS;
if (secretOnly) {
gpgCommand += " --with-fingerprint --fixed-list-mode --with-colons --list-secret-keys"; }
else {
gpgCommand += " --with-fingerprint --fixed-list-mode --with-colons --list-keys";
}
if (!this.initialized) {
errorMsgObj.value = EnigGetString("notInit");
return "";
}
statusFlagsObj.value = 0;
var statusMsgObj = new Object();
var cmdErrorMsgObj = new Object();
var listText = this.execCmd(gpgCommand, null, "",
exitCodeObj, statusFlagsObj, statusMsgObj, cmdErrorMsgObj);
if (exitCodeObj.value != 0) {
errorMsgObj.value = EnigGetString("badCommand");
if (cmdErrorMsgObj.value) {
errorMsgObj.value += "\n" + gpgCommand;
errorMsgObj.value += "\n" + cmdErrorMsgObj.value;
}
return "";
}
listText=EnigConvertGpgToUnicode(listText).replace(/(\r\n|\r)/g, "\n");
if (secretOnly) {
return listText;
}
this.userIdList = listText;
}
else {
exitCodeObj.value=0;
statusFlagsObj.value=0;
errorMsgObj.value="";
}
return this.userIdList;
}
// returns the output of -with-colons --list-sig
Enigmail.prototype.getKeySig =
function (keyId, exitCodeObj, errorMsgObj) {
var gpgCommand = this.getAgentPath() + GPG_BATCH_OPTS + " --fixed-list-mode --with-colons --with-fingerprint --list-sig "+keyId;
if (!this.initialized) {
errorMsgObj.value = EnigGetString("notInit");
return "";
}
var statusFlagsObj = new Object();
var statusMsgObj = new Object();
var cmdErrorMsgObj = new Object();
var listText = this.execCmd(gpgCommand, null, "",
exitCodeObj, statusFlagsObj, statusMsgObj, cmdErrorMsgObj);
if (exitCodeObj.value != 0) {
errorMsgObj.value = EnigGetString("badCommand");
if (cmdErrorMsgObj.value) {
errorMsgObj.value += "\n" + gpgCommand;
errorMsgObj.value += "\n" + cmdErrorMsgObj.value;
}
return "";
}
return listText;
}
// get key details.
// if uidOnly is true, returns just a list of uid's
Enigmail.prototype.getKeyDetails = function (keyId, uidOnly) {
var gpgCommand = this.getAgentPath() + GPG_BATCH_OPTS
gpgCommand += " --fixed-list-mode --with-colons --list-keys " + keyId;
var statusMsgObj = new Object();
var cmdErrorMsgObj = new Object();
var statusFlagsObj = new Object();
var exitCodeObj = new Object();
var listText = this.execCmd(gpgCommand, null, "",
exitCodeObj, statusFlagsObj, statusMsgObj, cmdErrorMsgObj);
if (exitCodeObj.value != 0) {
return "";
}
listText=EnigConvertGpgToUnicode(listText).replace(/(\r\n|\r)/g, "\n");
if (uidOnly) {
var userList="";
var keyArr=listText.split(/\n/);
for (var i=0; i<keyArr.length; i++) {
switch (keyArr[i].substr(0,4)) {
case "uid:" :
userList += keyArr[i].split(/:/)[9] + "\n";
}
}
return userList;
}
return listText;
}
Enigmail.prototype.encryptAttachment =
function (parent, fromMailAddr, toMailAddr, sendFlags, inFile, outFile,
exitCodeObj, statusFlagsObj, errorMsgObj) {
DEBUG_LOG("enigmail.js: Enigmail.encryptAttachment\n");
if (!this.initialized) {
errorMsgObj.value = EnigGetString("notInit");
return "";
}
statusFlagsObj.value = 0;
var asciiArmor = false;
try {
asciiArmor = this.prefBranch.getBoolPref("inlineAttachAsciiArmor");
} catch (ex) {}
var gpgCommand = this.getEncryptCommand(fromMailAddr, toMailAddr, "", sendFlags, asciiArmor, errorMsgObj);
if (! gpgCommand)
return null;
var passphrase = null;
var signMessage = (sendFlags & nsIEnigmail.SEND_SIGNED);
if (signMessage ) {
gpgCommand += this.passwdCommand();
var passwdObj = new Object();
var useAgentObj = new Object();
if (!GetPassphrase(parent, passwdObj, useAgentObj, this.agentVersion)) {
ERROR_LOG("enigmail.js: Enigmail.encryptAttachment: Error - no passphrase supplied\n");
statusFlagsObj.value |= nsIEnigmail.MISSING_PASSPHRASE;
return null;
}
passphrase = passwdObj.value;
}
// escape the backslashes (mainly for Windows) and the ' character
inFile = inFile.replace(/([\\\"\'\`])/g, "\\$1");
//replace(/\\/g, "\\\\").replace(/\'/g, "\\'");
outFile = outFile.replace(/([\\\"\'\`])/g, "\\$1");
gpgCommand += " --yes -o " + this.quoteSign + outFile + this.quoteSign;
gpgCommand += " "+this.quoteSign + inFile + this.quoteSign;
var statusMsgObj = new Object();
var cmdErrorMsgObj = new Object();
var msg = this.execCmd(gpgCommand, passphrase, "",
exitCodeObj, statusFlagsObj, statusMsgObj, cmdErrorMsgObj);
if (exitCodeObj.value != 0) {
if (cmdErrorMsgObj.value) {
errorMsgObj.value = gpgCommand;
errorMsgObj.value += "\n" + cmdErrorMsgObj.value;
}
else {
errorMsgObj.value = "An unknown error has occurred";
}
return "";
}
return msg;
}
Enigmail.prototype.decryptAttachment =
function (parent, outFileName, displayName, inputBuffer,
exitCodeObj, statusFlagsObj, errorMsgObj) {
WRITE_LOG("enigmail.js: Enigmail.decryptAttachment: parent="+parent+", outFileName="+outFileName+"\n");
var dataLength = new Object();
var byteData = inputBuffer.getByteData(dataLength);
var attachmentHead = byteData.substr(0,200);
if (attachmentHead.match(/\-\-\-\-\-BEGIN PGP \w+ KEY BLOCK\-\-\-\-\-/)) {
// attachment appears to be a PGP key file
if (this.confirmMsg(parent, EnigGetString("attachmentPgpKey", displayName))) {
exitCodeObj.value = this.importKey(parent, 0, byteData, "", errorMsgObj);
statusFlagsObj.value = gStatusFlags.IMPORTED;
}
else {
exitCodeObj.value = 0;
statusFlagsObj.value = nsIEnigmail.DISPLAY_MESSAGE;
}
return true;
}
var command = this.getAgentPath();
outFileName = outFileName.replace(/([\\\"\'\`])/g, "\\$1");
//replace(/\\/g, "\\\\").replace(/'/g, "\\'");;
command += GPG_BATCH_OPTS + " -o " + this.quoteSign + outFileName + this.quoteSign;
command+= " --yes " + this.passwdCommand() + " -d ";
statusFlagsObj.value = 0;
var passphrase = null;
var passwdObj = new Object();
var useAgentObj = new Object();
if (!GetPassphrase(parent, passwdObj, useAgentObj, this.agentVersion)) {
ERROR_LOG("enigmail.js: Enigmail.decryptAttachment: Error - no passphrase supplied\n");
statusFlagsObj.value |= nsIEnigmail.MISSING_PASSPHRASE;
return null;
}
passphrase = passwdObj.value;
var noProxy = true;
var ipcBuffer = Components.classes[NS_IPCBUFFER_CONTRACTID].createInstance(Components.interfaces.nsIIPCBuffer);
ipcBuffer.open(MSG_BUFFER_SIZE, false);
var pipeTrans = this.execStart(command, false, parent, 0,
ipcBuffer, noProxy, statusFlagsObj);
if (!pipeTrans) {
return false;
}
var inStream;
try {
if (! useAgentObj.value) {
if (passphrase.length > 0) {
pipeTrans.writeSync(passphrase, passphrase.length);
}
pipeTrans.writeSync("\n", 1);
}
pipeTrans.writeSync(byteData, dataLength.value);
}
catch (ex) {
return false;
}
// Wait for child STDOUT to close
pipeTrans.join();
exitCodeObj.value = pipeTrans.exitCode();
var statusMsgObj = new Object();
var cmdLineObj = new Object();
try {
this.execEnd(pipeTrans, statusFlagsObj, statusMsgObj, cmdLineObj, errorMsgObj);
}
catch (ex) {};
return true;
}
Enigmail.prototype.getCardStatus =
function(exitCodeObj, errorMsgObj) {
var command = this.getAgentPath();
command += " --status-fd 2 --with-colons --card-status";
var statusMsgObj = new Object();
var statusFlagsObj = new Object();
var outputTxt = this.execCmd(command, null, "",
exitCodeObj, statusFlagsObj, statusMsgObj, errorMsgObj);
if ((exitCodeObj.value == 0) && !outputTxt) {
exitCodeObj.value = -1;
return "";
}
return outputTxt;
}
Enigmail.prototype.showKeyPhoto =
function(keyId, exitCodeObj, errorMsgObj) {
var command = this.getAgentPath();
command += " --batch --no-tty --status-fd 1 --attribute-fd 1";
command += " --fixed-list-mode --list-keys "+keyId;
var statusMsgObj = new Object();
var statusFlagsObj = new Object();
var outputTxt = this.execCmd(command, null, "",
exitCodeObj, statusFlagsObj, statusMsgObj, errorMsgObj);
if ((exitCodeObj.value == 0) && !outputTxt) {
exitCodeObj.value = -1;
return "";
}
if (this.agentVersion<"1.5" && this.isDosLike) {
// workaround for error in gpg
outputTxt=outputTxt.replace(/\r\n/g, "\n");
}
var startIndex=0;
var nextIndex=outputTxt.indexOf("[GNUPG:]",startIndex);
var imgSize=-1;
while (nextIndex>=0 && startIndex < outputTxt.length && startIndex>=0) {
var matches = outputTxt.substring(startIndex).match(/ATTRIBUTE ([A-F\d]+) (\d+) (\d+) (\d+) (\d+) (\d+) (\d+) (\d+)/);
if (matches && matches[3]=="1") {
// attribute is an image
imgSize=Number(matches[2])
break;
}
startIndex=nextIndex+1;
nextIndex=outputTxt.indexOf("[GNUPG:]",startIndex);
}
if (imgSize>=0) {
startIndex = outputTxt.substring(nextIndex).search(/[\n\r]\[GNUPG:\] ATTRIBUTE /)+nextIndex+5;
var cr = outputTxt.substring(startIndex).search(/[\r\n]/);
// increase cr by 1 if CRLF
if (outputTxt.charAt(startIndex+cr)=="\r" &&
outputTxt.charAt(startIndex+cr+1)=="\n")
cr++;
var pictureData = outputTxt.substring(startIndex+cr+1+16, startIndex+cr+1+imgSize);
if (! pictureData.length)
return "";
try {
var flags = NS_WRONLY | NS_CREATE_FILE | NS_TRUNCATE;
var ds = Components.classes[DIR_SERV_CONTRACTID].getService();
var dsprops = ds.QueryInterface(Components.interfaces.nsIProperties);
var picFile = dsprops.get("TmpD", Components.interfaces.nsIFile);
picFile.append(keyId+".jpg");
picFile.createUnique(picFile.NORMAL_FILE_TYPE, DEFAULT_FILE_PERMS);
var fileStream = Components.classes[NS_LOCALFILEOUTPUTSTREAM_CONTRACTID].createInstance(Components.interfaces.nsIFileOutputStream);
fileStream.init(picFile, flags, DEFAULT_FILE_PERMS, 0);
if (fileStream.write(pictureData, pictureData.length) != pictureData.length)
throw Components.results.NS_ERROR_FAILURE;
fileStream.flush();
fileStream.close();
}
catch (ex) {
exitCodeObj.value = -1;
return "";
}
}
return picFile.path;
}
// Methods for handling Per-Recipient Rules
Enigmail.prototype.getRulesFile = function () {
DEBUG_LOG("enigmail.js: getRulesFile\n");
var ds = Components.classes[DIR_SERV_CONTRACTID].getService();
var dsprops = ds.QueryInterface(Components.interfaces.nsIProperties);
var rulesFile = dsprops.get("ProfD", Components.interfaces.nsILocalFile);
rulesFile.append("pgprules.xml");
return rulesFile;
}
Enigmail.prototype.loadRulesFile = function () {
DEBUG_LOG("enigmail.js: loadRulesFile\n");
var flags = NS_RDONLY;
var rulesFile = this.getRulesFile();
if (rulesFile.exists()) {
var ioServ = Components.classes[NS_IOSERVICE_CONTRACTID].getService(Components.interfaces.nsIIOService);
if (!ioServ)
throw Components.results.NS_ERROR_FAILURE;
var fileURI = ioServ.newFileURI(rulesFile);
var fileChannel = ioServ.newChannel(fileURI.asciiSpec, null, null);
var rawInStream = fileChannel.open();
var scriptableInStream = Components.classes[NS_SCRIPTABLEINPUTSTREAM_CONTRACTID].createInstance(Components.interfaces.nsIScriptableInputStream);
scriptableInStream.init(rawInStream);
var available = scriptableInStream.available()
var fileContents = scriptableInStream.read(available);
scriptableInStream.close();
if (fileContents.length==0 || fileContents.search(/^\s*$/)==0) {
return false;
}
var domParser=Components.classes[NS_DOMPARSER_CONTRACTID].createInstance(Components.interfaces.nsIDOMParser);
this.rulesList = domParser.parseFromString(fileContents, "text/xml");
return true;
}
return false;
}
Enigmail.prototype.saveRulesFile = function () {
DEBUG_LOG("enigmail.js: saveRulesFile\n");
var flags = NS_WRONLY | NS_CREATE_FILE | NS_TRUNCATE;
var domSerializer=Components.classes[NS_DOMSERIALIZER_CONTRACTID].createInstance(Components.interfaces.nsIDOMSerializer);
var rulesFile = this.getRulesFile();
if (rulesFile) {
if (this.rulesList) {
// the rule list is not empty -> write into file
return WriteFileContents(rulesFile.path,
domSerializer.serializeToString(this.rulesList.firstChild),
DEFAULT_FILE_PERMS);
}
else {
// empty rule list -> delete rules file
try {
rulesFile.remove(false);
}
catch (ex) {}
return true;
}
}
else
return false;
}
Enigmail.prototype.getRulesData = function (rulesListObj) {
DEBUG_LOG("enigmail.js: getRulesData\n");
var ret=true;
if (! this.rulesList) {
ret=this.loadRulesFile();
}
if (this.rulesList) {
rulesListObj.value = this.rulesList;
return ret;
}
rulesListObj.value = null;
return false;
}
Enigmail.prototype.addRule = function (appendToEnd, toAddress, keyList, sign, encrypt, pgpMime, flags) {
DEBUG_LOG("enigmail.js: addRule\n");
if (! this.rulesList) {
var domParser=Components.classes[NS_DOMPARSER_CONTRACTID].createInstance(Components.interfaces.nsIDOMParser);
this.rulesList = domParser.parseFromString("<pgpRuleList/>", "text/xml");
}
var negate = (flags & 1);
var rule=this.rulesList.createElement("pgpRule");
rule.setAttribute("email", toAddress);
rule.setAttribute("keyId", keyList);
rule.setAttribute("sign", sign);
rule.setAttribute("encrypt", encrypt);
rule.setAttribute("pgpMime", pgpMime);
rule.setAttribute("negateRule", flags);
var origFirstChild = this.rulesList.firstChild.firstChild;
if (origFirstChild && (! appendToEnd)) {
this.rulesList.firstChild.insertBefore(rule, origFirstChild);
this.rulesList.firstChild.insertBefore(this.rulesList.createTextNode(this.isDosLike ? "\r\n" : "\n"), origFirstChild);
}
else {
this.rulesList.firstChild.appendChild(rule);
this.rulesList.firstChild.appendChild(this.rulesList.createTextNode(this.isDosLike ? "\r\n" : "\n"));
}
}
Enigmail.prototype.clearRules = function () {
this.rulesList = null;
}
function KeyEditor(pipeTrans, reqObserver) {
this._pipeTrans = pipeTrans;
this._reqObserver = reqObserver;
}
KeyEditor.prototype = {
_pipeTrans: null,
_txt: null,
_req: null,
nextLine: function() {
return this._txt;
},
writeLine: function (inputData) {
this._pipeTrans.writeSync(inputData+"\n", inputData.length+1);
},
nextLine: function() {
var txt="";
while (txt.indexOf("[GNUPG:]") < 0) {
txt = this._pipeTrans.readLine(-1);
if (this._reqObserver) {
var newTxt = this._reqObserver.onDataAvailable(txt);
if (newTxt) {
txt = newTxt;
}
}
}
this._txt = txt;
return this._txt;
},
doCheck: function(inputType, promptVal) {
var a=this._txt.split(/ /);
return ((a[1] == inputType) && (a[2] == promptVal))
},
getText: function() {
return this._txt;
},
keyEditorMainLoop: function (callbackFunc, inputData, errorMsgObj) {
// main method that loops over the requests & responses of the
// GnuPG key editor
var txt="";
var r = { quitNow: false,
exitCode: -1 };
errorMsgObj.value=EnigGetString("undefinedError");
while (! r.quitNow) {
while ((txt.indexOf("[GNUPG:] GET_") < 0) && (! r.quitNow)) {
try {
txt = this.nextLine();
DEBUG_LOG(txt+"\n");
if (txt.indexOf("KEYEXPIRED") > 0) {
errorMsgObj.value=EnigGetString("noSignKeyExpired");
r.exitCode=-1;
}
if (txt.indexOf("[GNUPG:] BAD_PASSPHRASE")>=0) {
r.exitCode=-2;
}
if (txt.indexOf("[GNUPG:] ENIGMAIL_FAILURE")==0) {
r.exitCode = -3;
r.quitNow = true;
errorMsgObj.value = txt.substr(26);
}
if (txt.indexOf("[GNUPG:] ALREADY_SIGNED")>=0) {
errorMsgObj.value=EnigGetString("keyAlreadySigned");
r.exitCode=-1;
}
}
catch (ex) {
txt="";
r.quitNow=true;
}
}
if (! r.quitNow) {
if (callbackFunc) {
callbackFunc(inputData, this, r);
if (r.exitCode == 0) {
this.writeLine(r.writeTxt);
}
else {
errorMsgObj.value = r.errorMsg;
}
}
else {
r.quitNow=true;
r.exitCode = 0;
}
}
if (! r.quitNow) {
try{
txt = this.nextLine();
DEBUG_LOG(txt+"\n");
}
catch(ex) {
r.quitNow=true;
}
}
}
try {
this.writeLine("save");
txt = this.nextLine();
DEBUG_LOG(txt+"\n");
}
catch (ex) {
DEBUG_LOG("no more data\n");
}
return r.exitCode;
},
QueryInterface: function (iid) {
if (!iid.equals(Components.interfaces.nsISupports))
throw Components.results.NS_ERROR_NO_INTERFACE;
return this;
}
}
Enigmail.prototype.signKey =
function (parent, userId, keyId, signLocally, trustLevel, errorMsgObj) {
DEBUG_LOG("enigmail.js: Enigmail.signKey: trustLevel="+trustLevel+", userId="+userId+", keyId="+keyId+"\n");
var r = this.editKey(parent, true, userId, keyId,
(signLocally ? "lsign" : "sign"),
{ trustLevel: trustLevel},
signKeyCallback,
null,
errorMsgObj);
this.stillActive();
return r;
}
Enigmail.prototype.setKeyTrust =
function (parent, keyId, trustLevel, errorMsgObj) {
DEBUG_LOG("enigmail.js: Enigmail.setKeyTrust: trustLevel="+trustLevel+", keyId="+keyId+"\n");
return this.editKey(parent, false, null, keyId, "trust",
{ trustLevel: trustLevel},
keyTrustCallback,
null,
errorMsgObj);
}
Enigmail.prototype.genRevokeCert =
function (parent, keyId, outFile, reasonCode, reasonText, errorMsgObj) {
DEBUG_LOG("enigmail.js: Enigmail.genRevokeCert: keyId="+keyId+"\n");
var r= this.editKey(parent, true, null, keyId, "revoke",
{ outFile: outFile,
reasonCode: reasonCode,
reasonText: reasonText },
revokeCertCallback,
null,
errorMsgObj);
this.stillActive();
return r;
}
Enigmail.prototype.addUid =
function (parent, keyId, name, email, comment, errorMsgObj) {
DEBUG_LOG("enigmail.js: Enigmail.addUid: keyId="+keyId+", name="+name+", email="+email+"\n");
var r= this.editKey(parent, true, null, keyId, "adduid",
{ email: email,
name: name,
comment: comment,
nameAsked: 0,
emailAsked: 0 },
addUidCallback,
null,
errorMsgObj);
this.stillActive();
return r;
}
Enigmail.prototype.deleteKey =
function (parent, keyId, deleteSecretKey, errorMsgObj) {
DEBUG_LOG("enigmail.js: Enigmail.addUid: keyId="+keyId+", deleteSecretKey="+deleteSecretKey+"\n");
var cmd = (deleteSecretKey ? "--delete-secret-and-public-key" : "--delete-key");
var r= this.editKey(parent, false, null, keyId, cmd,
{},
deleteKeyCallback,
null,
errorMsgObj);
this.stillActive();
return r;
}
Enigmail.prototype.revokeSubkey =
function (parent, keyId, subkeys, reasonCode, reasonText, errorMsgObj) {
DEBUG_LOG("enigmail.js: Enigmail.revokeSubkey: keyId="+keyId+"\n");
var r= this.editKey(parent, true, null, keyId, "",
{ step: 0,
subkeys: subkeys.split(/,/),
reasonCode: reasonCode,
reasonText: reasonText },
revokeSubkeyCallback,
null,
errorMsgObj);
this.stillActive();
return r;
}
Enigmail.prototype.enableDisableKey =
function (parent, keyId, disableKey, errorMsgObj) {
DEBUG_LOG("enigmail.js: Enigmail.addUid: keyId="+keyId+", disableKey="+disableKey+"\n");
var cmd = (disableKey ? "disable" : "enable");
var r= this.editKey(parent, false, null, keyId, cmd,
{},
null,
null,
errorMsgObj);
this.stillActive();
return r;
}
Enigmail.prototype.setPrimaryUid =
function (parent, keyId, idNumber, errorMsgObj) {
DEBUG_LOG("enigmail.js: Enigmail.setPrimaryUid: keyId="+keyId+", idNumber="+idNumber+"\n");
var r = this.editKey(parent, true, null, keyId, "",
{ idNumber: idNumber,
step: 0 },
setPrimaryUidCallback,
null,
errorMsgObj);
this.stillActive();
return r;
}
Enigmail.prototype.deleteUid =
function (parent, keyId, idNumber, errorMsgObj) {
DEBUG_LOG("enigmail.js: Enigmail.deleteUid: keyId="+keyId+", idNumber="+idNumber+"\n");
var r = this.editKey(parent, true, null, keyId, "",
{ idNumber: idNumber,
step: 0 },
deleteUidCallback,
null,
errorMsgObj);
this.stillActive();
return r;
}
Enigmail.prototype.revokeUid =
function (parent, keyId, idNumber, errorMsgObj) {
DEBUG_LOG("enigmail.js: Enigmail.revokeUid: keyId="+keyId+", idNumber="+idNumber+"\n");
var r = this.editKey(parent, true, null, keyId, "",
{ idNumber: idNumber,
step: 0 },
revokeUidCallback,
null,
errorMsgObj);
this.stillActive();
return r;
}
function enigCardAdminObserver(guiObserver, isDosLike) {
this._guiObserver = guiObserver;
this.isDosLike = isDosLike;
}
enigCardAdminObserver.prototype =
{
_guiObserver: null,
_failureCode: 0,
QueryInterface : function(iid)
{
if (iid.equals(Components.interfaces.nsIEnigMimeReadCallback) ||
iid.equals(Components.interfaces.nsISupports) )
return this;
throw Components.results.NS_NOINTERFACE;
},
onDataAvailable: function (data) {
var ret="";
DEBUG_LOG("enigmail.js: enigCardAdminObserver.onDataAvailable: data="+data+"\n");
if (this.isDosLike && data.indexOf("[GNUPG:] BACKUP_KEY_CREATED") == 0) {
data=data.replace(/\//g, "\\");
}
if (this._failureCode) {
ret = "[GNUPG:] ENIGMAIL_FAILURE "+data;
}
if (data.indexOf("[GNUPG:] SC_OP_FAILURE")>=0) {
this._failureCode = 1;
}
if (this._guiObserver) {
this._guiObserver.onDataAvailable(data);
}
return ret;
}
}
Enigmail.prototype.genCardKey =
function (parent, name, email, comment, expiry, backupPasswd, requestObserver, errorMsgObj) {
DEBUG_LOG("enigmail.js: Enigmail.genCardKey: \n");
var generateObserver = new enigCardAdminObserver(requestObserver, this.isDosLike);
var r = this.editKey(parent, false, null, "", "--with-colons --card-edit",
{ step: 0,
name: name,
email: email,
comment: comment,
expiry: expiry,
backupPasswd: backupPasswd,
backupKey: (backupPasswd.length > 0 ? "Y" : "N"),
parent: parent },
genCardKeyCallback,
generateObserver,
errorMsgObj);
return r;
}
Enigmail.prototype.cardAdminData =
function (parent, name, firstname, lang, sex, url, login, forcepin, errorMsgObj) {
DEBUG_LOG("enigmail.js: Enigmail.cardAdminData: parent="+parent+", name="+name+", firstname="+firstname+", lang="+lang+", sex="+sex+", url="+url+", login="+login+", forcepin="+forcepin+"\n");
var adminObserver = new enigCardAdminObserver(null, this.isDosLike);
var r = this.editKey(parent, false, null, "", "--with-colons --card-edit",
{ step: 0,
name: name,
firstname: firstname,
lang: lang,
sex: sex,
url: url,
login: login,
forcepin: forcepin },
cardAdminDataCallback,
adminObserver,
errorMsgObj);
return r;
}
Enigmail.prototype.cardChangePin =
function (parent, action, oldPin, newPin, adminPin, pinObserver, errorMsgObj) {
DEBUG_LOG("enigmail.js: Enigmail.cardChangePin: parent="+parent+", action="+action+"\n");
var adminObserver = new enigCardAdminObserver(pinObserver, this.isDosLike);
var r = this.editKey(parent, false, null, "", "--with-colons --card-edit",
{ step: 0,
pinStep: 0,
action: action,
oldPin: oldPin,
newPin: newPin,
adminPin: adminPin },
cardChangePinCallback,
adminObserver,
errorMsgObj);
return r;
}
Enigmail.prototype.editKey =
function (parent, needPassphrase, userId, keyId, editCmd, inputData, callbackFunc, requestObserver, errorMsgObj) {
DEBUG_LOG("enigmail.js: Enigmail.editKey: parent="+parent+", editCmd="+editCmd+"\n");
if (!this.initialized) {
errorMsgObj.value = EnigGetString("notInit");
return -1;
}
if (this.agentType != "gpg") {
errorMsgObj.value = EnigGetString("failOnlyGPG");
return -1;
}
errorMsgObj.value = "";
var command = this.getAgentPath();
var statusFlags = new Object();
var passphrase = "";
var useAgentObj = new Object();
if (needPassphrase) {
command += this.passwdCommand();
var passwdObj = new Object();
if (!GetPassphrase(parent, passwdObj, useAgentObj, this.agentVersion)) {
ERROR_LOG("enigmail.js: Enigmail.execStart: Error - no passphrase supplied\n");
errorMsgObj.value = EnigGetString("noPassphrase");
return -1;
}
passphrase = passwdObj.value;
}
else
{
useAgentObj.value = true;
}
command += " --no-tty --status-fd 1 --logger-fd 1 --command-fd 0"
if (userId) command += " -u " + userId;
if (editCmd == "revoke") {
// escape backslashes and ' characters
command += " -a -o "+this.quoteSign;
command += inputData.outFile.replace(/([\\\"\'\`])/g, "\\$1");
//replace(/\\/g, "\\\\").replace(/'/g, "\\'");
command += this.quoteSign+" --gen-revoke " + keyId;
}
else if (editCmd.indexOf("--")==0) {
command += " "+editCmd + " " + keyId;
}
else {
command += " --ask-cert-level --edit-key " + keyId + " " + editCmd;
}
command = command.replace(/ *$/, "");
var pipeTrans = this.execStart(command, false, parent, null, null,
true, statusFlags);
if (! pipeTrans) return -1;
if (! useAgentObj.value) {
try {
if (passphrase) {
pipeTrans.writeSync(passphrase, passphrase.length);
}
pipeTrans.writeSync("\n", 1);
} catch (ex) {}
}
var returnCode=-1;
try {
var keyEdit = new KeyEditor(pipeTrans, requestObserver);
returnCode = keyEdit.keyEditorMainLoop(callbackFunc, inputData, errorMsgObj);
} catch (ex) {
DEBUG_LOG("enigmail.js: Enigmail.editKey: caught exception from writing to pipeTrans\n");
}
var exitCode = -1;
switch(returnCode) {
case 0:
for (var retryCount = 50; retryCount > 0; retryCount--) {
if (pipeTrans.isAttached()) {
DEBUG_LOG("enigmail.js: Enigmail.editKey: sleeping 50 ms\n");
this.ipcService.sleep(50); // sleep 50 ms before retrying
}
else {
retryCount = -1;
}
}
try{
exitCode = pipeTrans.exitCode();
} catch (ex) {
DEBUG_LOG("enigmail.js: Enigmail.editKey: caught exception from pipeTrans\n");
}
break;
case -2:
errorMsgObj.value=EnigGetString("badPhrase");
this.clearCachedPassphrase();
default:
exitCode = returnCode;
}
DEBUG_LOG("enigmail.js: Enigmail.editKey: GnuPG terminated with code="+exitCode+"\n");
return exitCode;
}
function signKeyCallback(inputData, keyEdit, ret) {
ret.writeTxt = "";
ret.errorMsg = "";
if (keyEdit.doCheck(GET_BOOL, "sign_uid.okay" )) {
ret.exitCode = 0;
ret.writeTxt = "Y";
}
else if (keyEdit.doCheck(GET_BOOL, "keyedit.sign_all.okay" )) {
ret.exitCode = 0;
ret.writeTxt = "Y";
}
else if (keyEdit.doCheck(GET_LINE, "sign_uid.expire" )) {
ret.exitCode = 0;
ret.writeTxt = "0";
}
else if (keyEdit.doCheck(GET_LINE, "trustsig_prompt.trust_value" )) {
ret.exitCode = 0;
ret.writeTxt = "0";
}
else if (keyEdit.doCheck(GET_LINE, "trustsig_prompt.trust_depth" )) {
ret.exitCode = 0;
ret.writeTxt = "";}
else if (keyEdit.doCheck(GET_LINE, "trustsig_prompt.trust_regexp" )) {
ret.exitCode = 0;
ret.writeTxt = "0";}
else if (keyEdit.doCheck(GET_LINE, "siggen.valid" )) {
ret.exitCode = 0;
ret.writeTxt = "0";
}
else if (keyEdit.doCheck(GET_BOOL, "sign_uid.local_promote_okay" )) {
ret.exitCode = 0;
ret.writeTxt = "Y";
}
else if (keyEdit.doCheck(GET_LINE, "sign_uid.class" )) {
ret.exitCode = 0;
ret.writeTxt = inputData.trustLevel;
}
else if (keyEdit.doCheck(GET_HIDDEN, "passphrase.adminpin.ask")) {
GetPin(inputData.parent, EnigGetString("enterAdminPin"), ret);
}
else if (keyEdit.doCheck(GET_HIDDEN, "passphrase.pin.ask")) {
GetPin(inputData.parent, EnigGetString("enterCardPin"), ret);
}
else if (keyEdit.doCheck(GET_LINE, "keyedit.prompt")) {
ret.quitNow = true;
}
else {
ret.quitNow=true;
ERROR_LOG("Unknown command prompt: "+keyEdit.getText()+"\n");
ret.exitCode=-1;
}
}
function keyTrustCallback(inputData, keyEdit, ret) {
ret.writeTxt = "";
ret.errorMsg = "";
if (keyEdit.doCheck(GET_LINE, "edit_ownertrust.value" )) {
ret.exitCode = 0;
ret.writeTxt = inputData.trustLevel;
}
else if (keyEdit.doCheck(GET_BOOL, "edit_ownertrust.set_ultimate.okay")) {
ret.exitCode = 0;
ret.writeTxt = "Y";
}
else if (keyEdit.doCheck(GET_LINE, "keyedit.prompt")) {
ret.quitNow = true;
}
else if (keyEdit.doCheck(GET_HIDDEN, "passphrase.adminpin.ask")) {
GetPin(inputData.parent, EnigGetString("enterAdminPin"), ret);
}
else if (keyEdit.doCheck(GET_HIDDEN, "passphrase.pin.ask")) {
GetPin(inputData.parent, EnigGetString("enterCardPin"), ret);
}
else {
ret.quitNow=true;
ERROR_LOG("Unknown command prompt: "+keyEdit.getText()+"\n");
ret.exitCode=-1;
}
}
function addUidCallback(inputData, keyEdit, ret) {
ret.writeTxt = "";
ret.errorMsg = "";
if (keyEdit.doCheck(GET_LINE, "keygen.name" )) {
++inputData.nameAsked;
if (inputData.nameAsked==1) {
ret.exitCode = 0;
ret.writeTxt = inputData.name;
}
else {
ret.exitCode=-1;
ret.quitNow=true;
ret.errorMsg="Invalid name (too short)";
}
}
else if (keyEdit.doCheck(GET_LINE, "keygen.email")) {
++inputData.emailAsked;
if (inputData.emailAsked==1) {
ret.exitCode = 0;
ret.writeTxt = inputData.email;
}
else {
ret.exitCode=-1;
ret.quitNow=true;
ret.errorMsg="Invalid email";
}
}
else if (keyEdit.doCheck(GET_LINE, "keygen.comment")) {
ret.exitCode = 0;
if (inputData.comment) {
ret.writeTxt = inputData.comment;
}
else {
ret.writeTxt="";
}
}
else if (keyEdit.doCheck(GET_LINE, "keyedit.prompt")) {
ret.quitNow = true;
}
else if (keyEdit.doCheck(GET_HIDDEN, "passphrase.adminpin.ask")) {
GetPin(inputData.parent, EnigGetString("enterAdminPin"), ret);
}
else if (keyEdit.doCheck(GET_HIDDEN, "passphrase.pin.ask")) {
GetPin(inputData.parent, EnigGetString("enterCardPin"), ret);
}
else {
ret.quitNow=true;
ERROR_LOG("Unknown command prompt: "+keyEdit.getText()+"\n");
ret.exitCode=-1;
}
}
function revokeCertCallback(inputData, keyEdit, ret) {
ret.writeTxt = "";
ret.errorMsg = "";
if (keyEdit.doCheck(GET_LINE, "ask_revocation_reason.code" )) {
ret.exitCode = 0;
ret.writeTxt = inputData.reasonCode;
}
else if (keyEdit.doCheck(GET_LINE, "ask_revocation_reason.text" )) {
ret.exitCode = 0;
ret.writeTxt = "";
}
else if (keyEdit.doCheck(GET_BOOL, "gen_revoke.okay")) {
ret.exitCode = 0;
ret.writeTxt = "Y";
}
else if (keyEdit.doCheck(GET_BOOL, "ask_revocation_reason.okay" )) {
ret.exitCode = 0;
ret.writeTxt = "Y";
}
else if (keyEdit.doCheck(GET_BOOL, "openfile.overwrite.okay" )) {
ret.exitCode = 0;
ret.writeTxt = "Y";
}
else if (keyEdit.doCheck(GET_HIDDEN, "passphrase.adminpin.ask")) {
GetPin(inputData.parent, EnigGetString("enterAdminPin"), ret);
}
else if (keyEdit.doCheck(GET_HIDDEN, "passphrase.pin.ask")) {
GetPin(inputData.parent, EnigGetString("enterCardPin"), ret);
}
else if (keyEdit.doCheck(GET_LINE, "keyedit.prompt")) {
ret.quitNow = true;
}
else {
ret.quitNow=true;
ERROR_LOG("Unknown command prompt: "+keyEdit.getText()+"\n");
ret.exitCode=-1;
}
}
function revokeSubkeyCallback(inputData, keyEdit, ret) {
ret.writeTxt = "";
ret.errorMsg = "";
if (keyEdit.doCheck(GET_LINE, "keyedit.prompt")) {
if (inputData.step < inputData.subkeys.length) {
ret.exitCode = 0;
ret.writeTxt = "key "+inputData.subkeys[inputData.step];
++inputData.step;
}
else if (inputData.step == inputData.subkeys.length) {
ret.exitCode = 0;
ret.writeTxt = "revkey";
++inputData.step;
}
else {
if (inputData.step == (inputData.subkeys.length+1)) {
ret.exitCode = 0;
}
else {
ret.exitCode = -1;
}
ret.quitNow = true;
}
}
else if (keyEdit.doCheck(GET_BOOL, "keyedit.revoke.subkey.okay")) {
ret.exitCode = 0;
ret.writeTxt = "Y";
}
else if (keyEdit.doCheck(GET_LINE, "ask_revocation_reason.code" )) {
ret.exitCode = 0;
ret.writeTxt = inputData.reasonCode;
}
else if (keyEdit.doCheck(GET_LINE, "ask_revocation_reason.text" )) {
ret.exitCode = 0;
ret.writeTxt = "";
}
else if (keyEdit.doCheck(GET_BOOL, "ask_revocation_reason.okay" )) {
++inputData.step;
ret.exitCode = 0;
ret.writeTxt = "Y";
}
else if (keyEdit.doCheck(GET_HIDDEN, "passphrase.adminpin.ask")) {
GetPin(inputData.parent, EnigGetString("enterAdminPin"), ret);
}
else if (keyEdit.doCheck(GET_HIDDEN, "passphrase.pin.ask")) {
GetPin(inputData.parent, EnigGetString("enterCardPin"), ret);
}
else {
ret.quitNow=true;
ERROR_LOG("Unknown command prompt: "+keyEdit.getText()+"\n");
ret.exitCode=-1;
}
}
function setPrimaryUidCallback(inputData, keyEdit, ret) {
ret.writeTxt = "";
ret.errorMsg = "";
if (keyEdit.doCheck(GET_LINE, "keyedit.prompt" )) {
++inputData.step;
switch (inputData.step) {
case 1:
ret.exitCode = 0;
ret.writeTxt = "uid "+inputData.idNumber;
break;
case 2:
ret.exitCode = 0;
ret.writeTxt = "primary";
break;
case 3:
ret.exitCode = 0;
ret.quitNow=true;
break;
default:
ret.exitCode = -1;
ret.quitNow=true;
}
}
else {
ret.quitNow=true;
ERROR_LOG("Unknown command prompt: "+keyEdit.getText()+"\n");
ret.exitCode=-1;
}
}
function deleteUidCallback(inputData, keyEdit, ret) {
ret.writeTxt = "";
ret.errorMsg = "";
if (keyEdit.doCheck(GET_LINE, "keyedit.prompt" )) {
++inputData.step;
switch (inputData.step) {
case 1:
ret.exitCode = 0;
ret.writeTxt = "uid "+inputData.idNumber;
break;
case 2:
ret.exitCode = 0;
ret.writeTxt = "deluid";
break;
case 4:
ret.exitCode = 0;
ret.quitNow=true;
break;
default:
ret.exitCode = -1;
ret.quitNow=true;
}
}
else if (keyEdit.doCheck(GET_BOOL, "keyedit.remove.uid.okay" )) {
++inputData.step;
ret.exitCode = 0;
ret.writeTxt = "Y";
}
else if (keyEdit.doCheck(GET_HIDDEN, "passphrase.adminpin.ask")) {
GetPin(inputData.parent, EnigGetString("enterAdminPin"), ret);
}
else if (keyEdit.doCheck(GET_HIDDEN, "passphrase.pin.ask")) {
GetPin(inputData.parent, EnigGetString("enterCardPin"), ret);
}
else {
ret.quitNow=true;
ERROR_LOG("Unknown command prompt: "+keyEdit.getText()+"\n");
ret.exitCode=-1;
}
}
function revokeUidCallback(inputData, keyEdit, ret) {
ret.writeTxt = "";
ret.errorMsg = "";
if (keyEdit.doCheck(GET_LINE, "keyedit.prompt" )) {
++inputData.step;
switch (inputData.step) {
case 1:
ret.exitCode = 0;
ret.writeTxt = "uid "+inputData.idNumber;
break;
case 2:
ret.exitCode = 0;
ret.writeTxt = "revuid";
break;
case 7:
ret.exitCode = 0;
ret.quitNow=true;
break;
default:
ret.exitCode = -1;
ret.quitNow=true;
}
}
else if (keyEdit.doCheck(GET_BOOL, "keyedit.revoke.uid.okay" )) {
++inputData.step;
ret.exitCode = 0;
ret.writeTxt = "Y";
}
else if (keyEdit.doCheck(GET_LINE, "ask_revocation_reason.code")) {
++inputData.step;
ret.exitCode = 0;
ret.writeTxt = "0"; // no reason specified
}
else if (keyEdit.doCheck(GET_LINE, "ask_revocation_reason.text")) {
++inputData.step;
ret.exitCode = 0;
ret.writeTxt = "";
}
else if (keyEdit.doCheck(GET_BOOL, "ask_revocation_reason.okay")) {
++inputData.step;
ret.exitCode = 0;
ret.writeTxt = "Y";
}
else if (keyEdit.doCheck(GET_HIDDEN, "passphrase.adminpin.ask")) {
GetPin(inputData.parent, EnigGetString("enterAdminPin"), ret);
}
else if (keyEdit.doCheck(GET_HIDDEN, "passphrase.pin.ask")) {
GetPin(inputData.parent, EnigGetString("enterCardPin"), ret);
}
else {
ret.quitNow=true;
ERROR_LOG("Unknown command prompt: "+keyEdit.getText()+"\n");
ret.exitCode=-1;
}
}
function deleteKeyCallback(inputData, keyEdit, ret) {
ret.writeTxt = "";
ret.errorMsg = "";
if (keyEdit.doCheck(GET_BOOL, "delete_key.secret.okay")) {
ret.exitCode = 0;
ret.writeTxt = "Y";
}
else if (keyEdit.doCheck(GET_BOOL, "keyedit.remove.subkey.okay")) {
ret.exitCode = 0;
ret.writeTxt = "Y";
}
else if (keyEdit.doCheck(GET_BOOL, "delete_key.okay" )) {
ret.exitCode = 0;
ret.writeTxt = "Y";
}
else if (keyEdit.doCheck(GET_HIDDEN, "passphrase.adminpin.ask")) {
GetPin(inputData.parent, EnigGetString("enterAdminPin"), ret);
}
else if (keyEdit.doCheck(GET_HIDDEN, "passphrase.pin.ask")) {
GetPin(inputData.parent, EnigGetString("enterCardPin"), ret);
}
else {
ret.quitNow=true;
ERROR_LOG("Unknown command prompt: "+keyEdit.getText()+"\n");
ret.exitCode=-1;
}
}
function GetPin(domWindow, promptMsg, ret) {
DEBUG_LOG("enigmail.js: GetPin: \n");
var passwdObj = {value: ""};
var dummyObj = {};
var success = false;
var promptService = Components.classes[NS_PROMPTSERVICE_CONTRACTID].getService(Components.interfaces.nsIPromptService);
success = promptService.promptPassword(domWindow,
EnigGetString("Enigmail"),
promptMsg,
passwdObj,
null,
dummyObj);
if (!success) {
ret.errorMsg = EnigGetString("noPassphrase");
ret.quitNow=true;
return false;
}
DEBUG_LOG("enigmail.js: GetPin: got pin\n");
ret.writeTxt = passwdObj.value;
return true;
}
function genCardKeyCallback(inputData, keyEdit, ret) {
ret.writeTxt = "";
ret.errorMsg = "";
var pinObj={};
if (keyEdit.doCheck(GET_LINE, "cardedit.prompt")) {
if (inputData.step == 0) {
ret.exitCode = 0;
ret.writeTxt = "admin";
}
else if (inputData.step == 1) {
ret.exitCode = 0;
ret.writeTxt = "generate";
}
else {
ret.exitCode = 0;
ret.quitNow=true;
ret.writeTxt = "quit";
}
++inputData.step;
}
else if (keyEdit.doCheck(GET_LINE, "cardedit.genkeys.backup_enc") ||
keyEdit.doCheck(GET_BOOL, "cardedit.genkeys.backup_enc")) {
ret.exitCode = 0;
ret.writeTxt = inputData.backupKey;
}
else if (keyEdit.doCheck(GET_BOOL, "cardedit.genkeys.replace_keys")) {
ret.exitCode = 0;
ret.writeTxt = "Y";
}
else if (keyEdit.doCheck(GET_HIDDEN, "passphrase.adminpin.ask")) {
GetPin(inputData.parent, EnigGetString("enterAdminPin"), ret);
}
else if (keyEdit.doCheck(GET_HIDDEN, "passphrase.pin.ask")) {
GetPin(inputData.parent, EnigGetString("enterCardPin"), ret);
}
else if (keyEdit.doCheck(GET_HIDDEN, "passphrase.enter")) {
ret.exitCode = 0;
ret.writeTxt = inputData.backupPasswd;
}
else if (keyEdit.doCheck(GET_LINE, "keygen.valid")) {
ret.exitCode = 0;
ret.writeTxt = inputData.expiry;
}
else if (keyEdit.doCheck(GET_LINE, "keygen.name")) {
ret.exitCode = 0;
ret.writeTxt = inputData.name;
}
else if (keyEdit.doCheck(GET_LINE, "keygen.email")) {
ret.exitCode = 0;
ret.writeTxt = inputData.email;
}
else if (keyEdit.doCheck(GET_LINE, "keygen.comment")) {
ret.exitCode = 0;
if (inputData.comment) {
ret.writeTxt = inputData.comment;
}
else {
ret.writeTxt="";
}
}
else {
ret.quitNow=true;
ERROR_LOG("Unknown command prompt: "+keyEdit.getText()+"\n");
ret.exitCode=-1;
}
}
function cardAdminDataCallback(inputData, keyEdit, ret) {
ret.writeTxt = "";
ret.errorMsg = "";
var pinObj={};
if (keyEdit.doCheck(GET_LINE, "cardedit.prompt")) {
++inputData.step;
ret.exitCode = 0;
switch(inputData.step) {
case 1:
ret.writeTxt = "admin";
break;
case 2:
ret.writeTxt = "name";
break;
case 3:
ret.writeTxt = "lang";
break;
case 4:
ret.writeTxt = "sex";
break;
case 5:
ret.writeTxt = "url";
break;
case 6:
ret.writeTxt = "login";
break;
case 7:
if (inputData.forcepin != 0) {
ret.writeTxt = "forcesig";
break;
}
default:
ret.writeTxt = "quit";
ret.quitNow=true;
break;
}
}
else if (keyEdit.doCheck(GET_HIDDEN, "passphrase.adminpin.ask")) {
GetPin(inputData.parent, EnigGetString("enterAdminPin"), ret);
}
else if (keyEdit.doCheck(GET_HIDDEN, "passphrase.pin.ask")) {
GetPin(inputData.parent, EnigGetString("enterCardPin"), ret);
}
else if (keyEdit.doCheck(GET_LINE, "keygen.smartcard.surname")) {
ret.exitCode = 0;
ret.writeTxt = inputData.firstname;
}
else if (keyEdit.doCheck(GET_LINE, "keygen.smartcard.givenname")) {
ret.exitCode = 0;
ret.writeTxt = inputData.name;
}
else if (keyEdit.doCheck(GET_LINE, "cardedit.change_sex")) {
ret.exitCode = 0;
ret.writeTxt = inputData.sex;
}
else if (keyEdit.doCheck(GET_LINE, "cardedit.change_lang")) {
ret.exitCode = 0;
ret.writeTxt = inputData.lang;
}
else if (keyEdit.doCheck(GET_LINE, "cardedit.change_url")) {
ret.exitCode = 0;
ret.writeTxt = inputData.url;
}
else if (keyEdit.doCheck(GET_LINE, "cardedit.change_login")) {
ret.exitCode = 0;
ret.writeTxt = inputData.login;
}
else {
ret.quitNow=true;
ERROR_LOG("Unknown command prompt: "+keyEdit.getText()+"\n");
ret.exitCode=-1;
}
}
function cardChangePinCallback(inputData, keyEdit, ret) {
ret.writeTxt = "";
ret.errorMsg = "";
if (keyEdit.doCheck(GET_LINE, "cardedit.prompt")) {
++inputData.step;
ret.exitCode=0;
switch (inputData.step) {
case 1:
ret.writeTxt = "admin";
break;
case 2:
ret.writeTxt = "passwd";
break;
default:
ret.writeTxt = "quit";
ret.exitCode = 0;
ret.quitNow=true;
break;
}
}
else if (keyEdit.doCheck(GET_HIDDEN, "passphrase.adminpin.ask")) {
ret.exitCode=0;
ret.writeTxt = inputData.adminPin;
}
else if (keyEdit.doCheck(GET_HIDDEN, "passphrase.pin.ask")) {
ret.exitCode=0;
ret.writeTxt = inputData.oldPin;
}
else if (keyEdit.doCheck(GET_HIDDEN, "passphrase.pin.new.ask") ||
keyEdit.doCheck(GET_HIDDEN, "passphrase.pin.repeat") ||
keyEdit.doCheck(GET_HIDDEN, "passphrase.adminpin.new.ask")) {
ret.exitCode = 0;
ret.writeTxt = inputData.newPin;
}
else if (keyEdit.doCheck(GET_LINE, "cardutil.change_pin.menu")) {
ret.exitCode=0;
++inputData.pinStep;
if (inputData.pinStep == 1) {
ret.writeTxt = inputData.action.toString();
}
else {
ret.writeTxt = "Q";
}
}
else {
ret.exitCode=-1;
ret.quitNow=true;
ERROR_LOG("Unknown command prompt: "+keyEdit.getText()+"\n");
}
}
/* Command Line handler service */
function EnigCLineService()
{}
EnigCLineService.prototype = {
/* nsISupports */
QueryInterface : function handler_QI(iid) {
if (iid.equals(nsISupports))
return this;
if (nsICmdLineHandler && iid.equals(nsICmdLineHandler))
return this;
if (nsICommandLineHandler && iid.equals(nsICommandLineHandler))
return this;
throw Components.results.NS_ERROR_NO_INTERFACE;
},
commandLineArgument: "-pgpkeyman",
prefNameForStartup: "general.startup.pgpkeyman",
chromeUrlForTask: "chrome://enigmail/content/enigmailKeyManager.xul",
helpText: "Start with OpenPGP key manager",
helpInfo : " -pgpkeyman Open the OpenPGP key manager",
handlesArgs: false,
defaultArgs: "",
openWindowWithArgs: false
}
/* factory for command line handler service (EnigCLineService) */
var EnigCLineFactory = {
createInstance : function (outer, iid) {
if (outer != null)
throw Components.results.NS_ERROR_NO_AGGREGATION;
if (!iid.equals(nsICmdLineHandler) && !iid.equals(nsISupports))
throw Components.results.NS_ERROR_INVALID_ARG;
return new EnigCLineService().QueryInterface(iid);
}
}

File Metadata

Mime Type
text/plain
Expires
Thu, Feb 26, 7:15 PM (16 h, 31 m)
Storage Engine
local-disk
Storage Format
Raw Data
Storage Handle
73/bb/a7b9f21524c89ed468738580ea88

Event Timeline