LPSTR __cdecl _gpg_decrypt(LPCSTR message)
{
char buffer[ciphertextsize];
char plaintext[plaintextsize];
char keyuserid[keyuseridsize];
int dlgresult;
BOOL useridvalid;
char *storedpassphrase;
char passphrase[passphrasesize];
char *decmessage = 0;
int decmessagelen;
gpgResult gpgresult;
const char *begin = strstr(message, txtbeginpgpmessage);
const char *end = strstr(message, txtendpgpmessage);
if ((begin!=NULL)&&(end!=NULL))
{
strcpy(buffer, "");
strncat(buffer, begin, end-begin+strlen(txtendpgpmessage));
replace(buffer, "\r", "");
replace(buffer, "\n", txtcrlf);
ZeroMemory(keyuserid, sizeof(keyuserid));
gpgresult=gpgDetectUserID(keyuserid, buffer);
storedpassphrase=NULL;
if(gpgresult!=gpgSuccess)
{
// ErrorMessage(txtwarning, txtdetectuseridfailed, txtverifyoptions);
strcpy(keyuserid, txtunknownuserid);
useridvalid=FALSE;
}
else
{
storedpassphrase=getPassphrase(keyuserid);
useridvalid=TRUE;
}
if(storedpassphrase!=NULL)
{
strcpy(passphrase, storedpassphrase);
ZeroMemory(plaintext, sizeof(plaintext));
gpgresult=gpgDecrypt(plaintext, buffer, passphrase);
}
else gpgresult=gpgUnknownError;
dlgresult=IDOK;
while((gpgresult!=gpgSuccess)&&(dlgresult!=IDCANCEL))
{
dlgresult=DialogBoxParam(g_hInst, MAKEINTRESOURCE(IDD_PASSPHRASE), NULL, PassphraseDialogProcedure, (LPARAM)keyuserid);
if(dlgresult==IDOK)
{
strcpy(passphrase, dlgpassphrase);
ZeroMemory(dlgpassphrase, passphrasesize);
strcat(passphrase, txtcrlf);
ZeroMemory(plaintext, sizeof(plaintext));
gpgresult=gpgDecrypt(plaintext, buffer, passphrase);
}
}
if(gpgresult==gpgSuccess)
{
strcpy(buffer, plaintext);
}
if ( gpgresult==gpgSuccess && useridvalid==TRUE)
addPassphrase(keyuserid, passphrase);
ZeroMemory(passphrase, sizeof(passphrase));
decmessagelen = strlen(buffer)+1;
decmessage = (char *) LocalAlloc(LPTR,decmessagelen);
MoveMemory(decmessage, buffer, decmessagelen);
}
return decmessage;
}
/* #############################################################################
*
* Description read, decrypt and parse the given filename
* Author Harry Brueckner
* Date 2005-03-18
* Arguments char* filename - filename to read
* char** errormsg - pointer to the GpgMe error message, if any
* PASSPHRASE_FN - passphrase callback function
* SHOWERROR_FN - callback function for error messages
* Return 1 on error, otherwise 0
*/
int xmlDataFileRead(char* filename, char** errormsg,
PASSPHRASE_FN passphrase_cb, SHOWERROR_FN showerror_cb)
{
xmlNode* node;
struct stat filestat;
off_t size;
int error = 0,
fd,
gpgsize = 0,
validate;
char* buffer = NULL;
char* gpgbuffer = NULL;
char* tmpbuffer = NULL;
TRACE(99, "xmlDataFileRead()", NULL);
/* we initialize the error message */
*errormsg = NULL;
fd = fileLockOpen(filename, O_RDONLY, -1, &tmpbuffer);
if (fd == -1)
{ /* unable to read the file, we start a new one */
showerror_cb(_("file error"), tmpbuffer);
memFree(__FILE__, __LINE__, tmpbuffer, STDBUFFERLENGTH);
if (fileExists(filename))
{ /* if the file exists and we can't read it it's a hard error and
* we must not continue; we don't need another error message since
* we already had one displayed.
*/
return 1;
}
/* we create a new, empty document */
xmldoc = xmlNewDoc(BAD_CAST "1.0");
node = xmlNewDocNode(xmldoc, NULL, BAD_CAST "root", NULL);
xmlDocSetRootElement(xmldoc, node);
createEditorsNode();
createTemplateNode();
/* we insert the current version and also create the created and
* modified entries.
*/
xmlVersionUpdate(1);
checkDtd(showerror_cb);
keyDefaults();
/* we created a new document, so it's changed */
runtime -> datachanged = 1;
}
else if (!fstat(fd, &filestat) &&
filestat.st_size)
{ /* we found a file and have to read it */
size = filestat.st_size;
buffer = memAlloc(__FILE__, __LINE__, size);
/* Flawfinder: ignore */
if (read(fd, buffer, size) != size)
{
memFree(__FILE__, __LINE__, buffer, size);
return 1;
}
close(fd);
if (config -> encryptdata)
{
error = gpgDecrypt(buffer, size, &gpgbuffer, &gpgsize,
passphrase_cb, showerror_cb);
if (error)
{ *errormsg = _("could not decrypt database file."); }
/* since we decrypted the file, we swap buffers */
memFree(__FILE__, __LINE__, buffer, size);
buffer = gpgbuffer;
size = gpgsize;
#ifdef TEST_OPTION
if (config -> testrun &&
!strcmp("decrypt", config -> testrun) &&
buffer)
{ printf("%s", buffer); }
#endif
/* TODO: add the same keys as used in the encrypted file;
* For now we just always add the default keys
*/
if (runtime -> realmhint)
{ /* if we have a realm, we add it to the default keys since we
* probably want to encrypt data for ourselves as well
*/
config -> defaultkeys = listAdd(config -> defaultkeys,
runtime -> realmhint);
}
keyDefaults();
}
else
{
/* if we run in unencrypted mode, we must add all default keys */
keyDefaults();
showerror_cb(_("warning"), _("the database file is read in unecrypted mode."));
}
if (!error &&
buffer[0] == '\x1f' && buffer[1] == '\x8b')
{ /* we have a gzipped buffer and must compress it */
error = zlibDecompress(buffer, size, &gpgbuffer, &gpgsize,
errormsg);
if (error)
{
tmpbuffer = memAlloc(__FILE__, __LINE__, STDBUFFERLENGTH);
snprintf(tmpbuffer, STDBUFFERLENGTH,
_("error (%s) compressing file '%s'."),
*errormsg,
filename);
showerror_cb(_("compression error"), tmpbuffer);
memFree(__FILE__, __LINE__, tmpbuffer, STDBUFFERLENGTH);
memFree(__FILE__, __LINE__, buffer, size);
return 1;
}
memFree(__FILE__, __LINE__, buffer, size);
buffer = gpgbuffer;
size = gpgsize;
}
else
{
if (!error && config -> compression > 0)
{
tmpbuffer = memAlloc(__FILE__, __LINE__, STDBUFFERLENGTH);
snprintf(tmpbuffer, STDBUFFERLENGTH,
_("database '%s' was not compressed."),
filename);
showerror_cb(_("warning"), tmpbuffer);
memFree(__FILE__, __LINE__, tmpbuffer, STDBUFFERLENGTH);
}
}
if (!error)
{
xmldoc = xmlReadMemory(buffer, size, filename, config -> encoding,
XML_PARSE_PEDANTIC | XML_PARSE_NONET | XML_PARSE_NOCDATA);
if (!xmldoc)
{
memFree(__FILE__, __LINE__, buffer, size);
tmpbuffer = memAlloc(__FILE__, __LINE__, STDBUFFERLENGTH);
snprintf(tmpbuffer, STDBUFFERLENGTH,
_("failed to parse xml document '%s'."),
filename);
showerror_cb(_("file error"), tmpbuffer);
memFree(__FILE__, __LINE__, tmpbuffer, STDBUFFERLENGTH);
return 1;
}
}
if (buffer)
{ memFree(__FILE__, __LINE__, buffer, size); }
/* we update our document version */
if (!error)
{ xmlVersionUpdate(0); }
if (!error)
{
validate = checkDtd(showerror_cb);
if (validate != 1)
{
tmpbuffer = memAlloc(__FILE__, __LINE__, STDBUFFERLENGTH);
snprintf(tmpbuffer, STDBUFFERLENGTH,
_("failed to validate xml document '%s'."),
filename);
showerror_cb(_("file error"), tmpbuffer);
memFree(__FILE__, __LINE__, tmpbuffer, STDBUFFERLENGTH);
return 1;
}
}
}
else
{ /* the given file has size 0 */
error = 1;
}
return error;
}
