PGPError
KMGetConventionalPhrase (
PGPContextRef context,
HWND hwnd,
LPSTR pszPrompt,
LPSTR* ppszPhrase)
{
PGPError err = kPGPError_BadParams;
PGPOptionListRef optionList = kInvalidPGPOptionListRef;
if (!ppszPhrase) return err;
err = PGPBuildOptionList (context, &optionList,
PGPOUIOutputPassphrase (context, ppszPhrase),
PGPOUIParentWindowHandle (context, hwnd),
PGPOLastOption (context));
if (IsntPGPError (err))
{
// If we have a prompt, use it
if (NULL!=(int) (pszPrompt))
{
err = PGPAppendOptionList (optionList,
PGPOUIDialogPrompt (context, pszPrompt),
PGPOLastOption (context));
}
if (IsntPGPError (err))
{
err = PGPConventionalDecryptionPassphraseDialog (context,
optionList,
PGPOLastOption (context));
}
}
if (IsPGPError (err))
{
if (*ppszPhrase)
{
PGPFreeData (*ppszPhrase);
*ppszPhrase = NULL;
}
}
if (PGPOptionListRefIsValid (optionList))
PGPFreeOptionList (optionList);
return err;
}
PGPError AddKeyFileListStub (MYSTATE *ms)
{
PGPContextRef context;
PGPFileSpecRef inref;
PGPOptionListRef opts;
FILELIST *FileCurrent;
PGPError err;
err=kPGPError_NoErr;
context=ms->context;
FileCurrent=ms->ListHead;
while(!(SCGetProgressCancel(ms->hPrgDlg))&&(FileCurrent!=0)&&(IsntPGPError(err)))
{
if(FileCurrent->IsDirectory)
{
FileCurrent=FileCurrent->next;
continue;
}
PGPNewFileSpecFromFullPath (context,
FileCurrent->name, &inref);
PGPBuildOptionList(context,&opts,
PGPOInputFile(context,inref),
PGPOLastOption(context));
err=GenericAddKey(ms,opts,FileCurrent->name);
PGPFreeOptionList(opts);
PGPFreeFileSpec( inref );
FileCurrent=FileCurrent->next;
}
return err;
}
PGPError AddKeyClipboardStub (MYSTATE *ms)
{
PGPOptionListRef opts;
PGPContextRef context;
char StrRes[100];
PGPError err;
err=kPGPError_NoErr;
context=ms->context;
PGPBuildOptionList(context,&opts,
PGPOInputBuffer(context,ms->pInput,ms->dwInputSize),
PGPOLastOption(context));
LoadString (g_hinst, IDS_CLIPBOARD, StrRes, sizeof(StrRes));
err=GenericAddKey(ms,opts,StrRes);
PGPFreeOptionList(opts);
return err;
}
static PGPError
pgpEncode(
PGPContextRef context,
PGPOptionListRef firstOption,
va_list args)
{
PGPError err;
PGPOptionListRef optionList;
pgpAssert( pgpContextIsValid( context ) );
optionList = pgpBuildOptionListArgs( context, FALSE, firstOption, args );
err = pgpGetOptionListError( optionList );
if( IsntPGPError( err ) )
{
err = pgpEncodeInternal( context, optionList );
}
PGPFreeOptionList( optionList );
return( err );
}
STDMETHODIMP CExtImpl::OnWriteComplete(IExchExtCallback* pecb, ULONG ulFlags)
{
if (_context != EECONTEXT_SENDNOTEMESSAGE)
return S_FALSE;
if (ulFlags == EEME_COMPLETE_FAILED) // Nothing to unwind
return S_FALSE;
if (!_fInSubmitState) // This is not a submission.
return S_FALSE;
if (_bEncrypt || _bSign)
{
IMessage *pmsg = 0;
RECIPIENTDIALOGSTRUCT *prds;
PGPOptionListRef signOptions = NULL;
HWND hwnd;
PGPError nError = kPGPError_NoErr;
pecb->GetWindow(&hwnd);
if (!hwnd)
hwnd = GetTopWindow(NULL);
CWaitCursor wait; // Mark busy
HRESULT hr = pecb->GetObject(NULL, (IMAPIProp**)&pmsg);
if (FAILED(hr))
{
UIDisplayStringID(hwnd, IDS_E_NOMESSAGE);
return E_ABORT;
}
prds = (RECIPIENTDIALOGSTRUCT *)
calloc(sizeof(RECIPIENTDIALOGSTRUCT), 1);
nError = PGPsdkLoadDefaultPrefs(_pgpContext);
if (IsPGPError(nError))
{
UIDisplayErrorCode(__FILE__, __LINE__, NULL, nError);
return E_ABORT;
}
nError = PGPOpenDefaultKeyRings(_pgpContext, (PGPKeyRingOpenFlags)0,
&(prds->OriginalKeySetRef));
if (IsPGPError(nError))
{
UIDisplayErrorCode(__FILE__, __LINE__, NULL, nError);
return E_ABORT;
}
if (_bEncrypt)
nError = GetRecipients(pecb, _pgpContext, _tlsContext, prds);
if (IsPGPError(nError))
{
if (nError != kPGPError_UserAbort)
UIDisplayErrorCode(__FILE__, __LINE__, NULL,
nError);
return E_ABORT;
}
nError = EncryptSignMessage(hwnd, pmsg, prds, &signOptions);
if (signOptions != NULL)
{
PGPFreeOptionList(signOptions);
signOptions = NULL;
}
FreeRecipients(prds);
if (NULL!=(int)(prds->OriginalKeySetRef))
{
PGPFreeKeySet(prds->OriginalKeySetRef);
prds->OriginalKeySetRef = NULL;
}
free(prds);
pmsg->Release();
if (IsPGPError(nError))
return E_ABORT;
}
return S_FALSE;
}
static PGPError
sSaveSharesToFile (
PSHAREHOLDERSTRUCT pshs,
PGPContextRef context,
PGPShareRef sharesTotal,
PGPKeySetRef keyset,
LPSTR pszFolder)
{
PFLFileSpecRef filespec = NULL;
PGPShareFileRef sharefile = NULL;
PGPShareRef sharesHolder = NULL;
PGPOptionListRef encodeOptions = NULL;
PGPError err = kPGPError_NoErr;
INT iModifier = 0;
CHAR szPath[MAX_PATH];
CHAR szModifier[MAX_SHARES_LEN+1];
CHAR sz1[32];
CHAR sz2[kPGPMaxUserIDSize + 32];
PGPKeyRef key;
// create file name and filespec
err = sCreateFilePathFromUserName (pszFolder, pshs->szUserID,
pshs->uShares, NULL, szPath, sizeof(szPath));
if (IsPGPError (err)) goto SaveFileCleanup;
// check for pre-existence of file
while (GetFileAttributes (szPath) != 0xFFFFFFFF) {
iModifier++;
if (iModifier > MAX_SHARES) {
err = kPGPError_CantOpenFile;
goto SaveFileCleanup;
}
wsprintf (szModifier, " %i", iModifier);
err = sCreateFilePathFromUserName (pszFolder, pshs->szUserID,
pshs->uShares, szModifier, szPath, sizeof(szPath));
if (IsPGPError (err)) goto SaveFileCleanup;
}
err = PFLNewFileSpecFromFullPath (PGPGetContextMemoryMgr (context),
szPath, &filespec);
if (IsPGPError (err)) goto SaveFileCleanup;
err = PFLFileSpecCreate (filespec);
if (IsPGPError (err)) goto SaveFileCleanup;
err = PGPNewShareFile (filespec, &sharefile);
if (IsPGPError (err)) goto SaveFileCleanup;
err = PGPSetShareFileUserID (sharefile, pshs->szUserID);
if (IsPGPError (err)) goto SaveFileCleanup;
err = PGPSplitShares (sharesTotal, pshs->uShares, &sharesHolder);
if (IsPGPError (err)) goto SaveFileCleanup;
// if this shareholder has public key, use it
if (pshs->bPublicKey) {
err = PGPSetShareFileOwnerKeyID (sharefile, pshs->keyid);
if (IsPGPError (err)) goto SaveFileCleanup;
err = PGPGetKeyByKeyID (keyset, &(pshs->keyid), pshs->keyalg, &key);
if (IsPGPError (err)) {
LoadString (g_hInst, IDS_CAPTIONERROR, sz1, sizeof(sz1));
LoadString (g_hInst, IDS_SHAREKEYGONE, sz2, sizeof(sz2));
lstrcat (sz2, pshs->szUserID);
MessageBox (NULL, sz2, sz1, MB_OK|MB_ICONERROR);
err = kPGPError_UserAbort;
goto SaveFileCleanup;
}
err = PGPBuildOptionList (context, &encodeOptions,
PGPOEncryptToKey (context, key),
PGPOLastOption (context));
if (IsPGPError (err)) goto SaveFileCleanup;
}
// there is no public key for this shareholder
else {
err = PGPBuildOptionList (context, &encodeOptions,
PGPOConventionalEncrypt (context,
PGPOPassphrase (context, pshs->pszPassphrase),
PGPOLastOption (context)),
PGPOLastOption (context));
if (IsPGPError (err)) goto SaveFileCleanup;
}
err = PGPCopySharesToFile (context, sharefile,
encodeOptions, sharesHolder);
if (IsPGPError (err)) goto SaveFileCleanup;
err = PGPSaveShareFile (sharefile);
SaveFileCleanup:
if (encodeOptions != NULL)
PGPFreeOptionList (encodeOptions);
if (sharesHolder != NULL)
PGPFreeShares (sharesHolder);
if (sharefile != NULL)
PGPFreeShareFile (sharefile);
if (filespec != NULL)
PFLFreeFileSpec (filespec);
return err;
}
PluginError PerformTranslation(
short trans_id,
char* in_file,
char* out_file,
char** addresses,
emsMIMEtypeP in_mime,
emsMIMEtypeP* out_mime
)
{
PluginError pluginReturn = EMSR_UNKNOWN_FAIL;
BOOL bSign = FALSE;
PGPError error = 0;
PGPSize mimeBodyOffset = 0;
char szExe[256];
char szDll[256];
assert(in_file);
assert(out_file);
LoadString(g_hinst, IDS_EXE, szExe, sizeof(szExe));
LoadString(g_hinst, IDS_DLL, szDll, sizeof(szDll));
switch( trans_id )
{
case kEncryptTranslatorID:
case kSignTranslatorID:
case kEncryptAndSignTranslatorID:
{
char** RecipientList = NULL;
unsigned long numRecipients = 0;
PGPOptionListRef pgpOptions = NULL;
PGPOptionListRef signOptions = NULL;
char mimeSeparator[kPGPMimeSeparatorSize];
PRECIPIENTDIALOGSTRUCT prds = NULL;
// allocate a recipient dialog structure
prds = (PRECIPIENTDIALOGSTRUCT)
calloc(sizeof(RECIPIENTDIALOGSTRUCT), 1);
if(prds)
{
char szTitle[256] = {0x00}; // title for recipient dialog
UINT recipientReturn = FALSE; // recipient dialog result
error = PGPsdkLoadDefaultPrefs(g_pgpContext);
if (IsPGPError(error))
{
PGPclEncDecErrorBox(g_hwndEudoraMainWindow, error);
return EMSR_UNKNOWN_FAIL;
}
error = PGPOpenDefaultKeyRings(g_pgpContext,
(PGPKeyRingOpenFlags)0,
&(prds->OriginalKeySetRef));
if (IsPGPError(error))
{
PGPclEncDecErrorBox(g_hwndEudoraMainWindow, error);
return EMSR_UNKNOWN_FAIL;
}
if ((trans_id == kEncryptTranslatorID) ||
(trans_id == kEncryptAndSignTranslatorID))
{
if(addresses) // do we have addresses to pass along
{
numRecipients = CreateRecipientList(addresses,
&RecipientList);
}
LoadString(GetModuleHandle("PGPplugin.dll"),
IDS_TITLE_RECIPIENTDIALOG, szTitle, sizeof(szTitle));
prds->Context = g_pgpContext;
prds->tlsContext = g_tlsContext;
prds->Version = CurrentPGPrecipVersion;
prds->hwndParent = g_hwndEudoraMainWindow;
prds->szTitle = szTitle;
prds->dwOptions = PGPCL_ASCIIARMOR;
prds->dwDisableFlags = PGPCL_DISABLE_WIPEORIG |
PGPCL_DISABLE_ASCIIARMOR |
PGPCL_DISABLE_SDA;
prds->dwNumRecipients = numRecipients;
prds->szRecipientArray = RecipientList;
/* Disable FYEO if there's an attachment or HTML */
if (in_mime && !match_mime_type(in_mime, "text", "plain"))
prds->dwDisableFlags |= PGPCL_DISABLE_FYEO;
// If shift is pressed, force the dialog to pop.
if (GetAsyncKeyState( VK_CONTROL) & 0x8000)
prds->dwDisableFlags|=PGPCL_DISABLE_AUTOMODE;
// See who we wish to encrypt this to
recipientReturn = PGPclRecipientDialog( prds );
if (prds->AddedKeys != NULL)
{
PGPUInt32 numKeys;
PGPCountKeys(prds->AddedKeys, &numKeys);
if (numKeys > 0)
PGPclQueryAddKeys(g_pgpContext, g_tlsContext,
g_hwndEudoraMainWindow, prds->AddedKeys,
NULL);
PGPFreeKeySet(prds->AddedKeys);
prds->AddedKeys = NULL;
}
if (!recipientReturn)
{
if (RecipientList)
FreeRecipientList(RecipientList, numRecipients);
if (prds->SelectedKeySetRef != NULL)
PGPFreeKeySet(prds->SelectedKeySetRef);
PGPFreeKeySet(prds->OriginalKeySetRef);
free(prds);
return EMSR_UNKNOWN_FAIL;
}
}
if( IsntPGPError(error) )
{
error = PGPBuildOptionList(g_pgpContext, &pgpOptions,
PGPOOutputLineEndType(g_pgpContext,
kPGPLineEnd_CRLF),
PGPOPGPMIMEEncoding(g_pgpContext,
TRUE,
&mimeBodyOffset,
mimeSeparator),
PGPOLastOption(g_pgpContext) );
}
if(IsntPGPError( error))
{
error = EncryptSignFile(g_hinst, g_hwndEudoraMainWindow,
g_pgpContext, g_tlsContext, szExe,
szDll, in_file, prds, pgpOptions,
&signOptions, out_file,
((trans_id ==
kSignTranslatorID) ? FALSE : TRUE ),
((trans_id ==
kEncryptTranslatorID) ? FALSE : TRUE ),
FALSE);
PGPFreeOptionList(pgpOptions);
PGPFreeOptionList(signOptions);
}
else
{
PGPclEncDecErrorBox (NULL, error);
}
if (RecipientList)
FreeRecipientList(RecipientList, numRecipients);
if (prds->SelectedKeySetRef != NULL)
PGPFreeKeySet(prds->SelectedKeySetRef);
PGPFreeKeySet(prds->OriginalKeySetRef);
free(prds);
if( IsntPGPError(error) )
{
if( out_mime )
{
pluginReturn = BuildEncryptedPGPMIMEType(
out_mime,
mimeSeparator );
if(EMSR_OK == pluginReturn)
{
pluginReturn = AddMIMEParam(*out_mime,
"PGPFormat",
"PGPMIME-encrypted" );
}
}
}
}
break;
}
case kDecryptTranslatorID:
case kVerifyTranslatorID:
{
char *szTempFile = NULL;
BOOL bFYEO = FALSE;
void *pOutput = NULL;
PGPSize outSize = 0;
error = DecryptVerifyFile(g_hinst, g_hwndEudoraMainWindow,
g_pgpContext, g_tlsContext, szExe, szDll, in_file,
TRUE, FALSE, &szTempFile, &pOutput, &outSize, &bFYEO);
if( IsntPGPError(error) )
{
if ((bFYEO)||(GetSecureViewerPref((void *)g_pgpContext)))
TempestViewer((void *)g_pgpContext,NULL,pOutput,outSize,
bFYEO);
CopyFile(szTempFile, out_file, FALSE);
DeleteFile(szTempFile);
if( out_mime )
{
ParseFileForMIMEType( out_file, out_mime );
}
if ((bFYEO)||(GetSecureViewerPref((void *)g_pgpContext)))
pluginReturn = EMSR_UNKNOWN_FAIL;
else
pluginReturn = EMSR_OK;
}
if (szTempFile != NULL)
PGPFreeData(szTempFile);
if (pOutput != NULL)
PGPFreeData(pOutput);
break;
}
}
return pluginReturn;
}
BOOL
EncryptSignRichEditText(char** ppBuffer,
long* pLength,
BOOL bEncrypt,
BOOL bSign,
char** pAddresses,
long NumAddresses,
char* pAttachments,
char** ppOutAttachments)
{
BOOL ReturnValue = FALSE;
void* pOutput = NULL;
long outSize = 0;
PGPError error = kPGPError_NoErr;
PGPOptionListRef userOptions = NULL;
PGPclRecipientDialogStruct *prds = NULL;
char szExe[256];
char szDll[256];
LoadString(g_hinst, IDS_EXE, szExe, sizeof(szExe));
LoadString(g_hinst, IDS_DLL, szDll, sizeof(szDll));
// allocate a recipient dialog structure
prds = (PGPclRecipientDialogStruct *)
calloc(sizeof(PGPclRecipientDialogStruct), 1);
if (!prds)
{
PGPclErrorBox(g_hwndEudoraMainWindow, kPGPError_OutOfMemory);
return FALSE;
}
error = PGPclOpenDefaultKeyrings(g_pgpContext,
kPGPOpenKeyDBFileOptions_Mutable, &(prds->keydbOriginal));
if (IsPGPError(error))
error = PGPclOpenDefaultKeyrings(g_pgpContext,
kPGPOpenKeyDBFileOptions_None, &(prds->keydbOriginal));
if (IsPGPError(error))
{
char szTitle[255];
char szBuffer[1024];
LoadString(g_hinst, IDS_DLL, szTitle, 254);
LoadString(g_hinst, IDS_Q_NOKEYRINGS, szBuffer, 1023);
if (MessageBox(g_hwndEudoraMainWindow, szBuffer, szTitle, MB_YESNO))
{
char szPath[MAX_PATH];
PGPclGetPath(kPGPclPGPkeysExeFile, szPath, MAX_PATH-1);
PGPclExecute(szPath, SW_SHOW);
}
return S_FALSE;
}
if(prds && bEncrypt)
{
char szTitle[256] = {0x00}; // title for recipient dialog
UINT recipientReturn = FALSE; // recipient dialog result
LoadString(GetModuleHandle("PGPplugin.dll"),
IDS_TITLE_RECIPIENTDIALOG, szTitle, sizeof(szTitle));
if( IsntPGPError(error) )
{
prds->context = g_pgpContext;
prds->tlsContext = g_tlsContext;
prds->Version = kPGPCurrentRecipVersion;
prds->hwndParent = g_hwndEudoraMainWindow;
prds->szTitle = szTitle;
prds->dwOptions = kPGPclASCIIArmor;
prds->dwDisableFlags = kPGPclDisableWipeOriginal |
kPGPclDisableASCIIArmor |
kPGPclDisableSelfDecryptingArchive |
kPGPclDisableInputIsText;
prds->dwNumRecipients = NumAddresses;
prds->szRecipientArray = pAddresses;
// If shift is pressed, force the dialog to pop.
if (GetAsyncKeyState( VK_CONTROL) & 0x8000)
prds->dwDisableFlags |= kPGPclDisableAutoMode;
// See who we wish to encrypt this to
recipientReturn = PGPclRecipientDialog( prds );
}
if (prds->keydbAdded != NULL)
{
PGPUInt32 numKeys;
PGPKeySetRef keySet;
PGPNewKeySet(prds->keydbAdded, &keySet);
PGPCountKeys(keySet, &numKeys);
if (numKeys > 0)
PGPclImportKeys(g_pgpContext, g_tlsContext, prds->hwndParent,
keySet, prds->keydbOriginal,
kPGPclNoDialogForValidSingletons);
PGPFreeKeySet(keySet);
PGPFreeKeyDB(prds->keydbAdded);
prds->keydbAdded = NULL;
}
if (!recipientReturn)
{
if (prds->keydbSelected != NULL)
PGPFreeKeyDB(prds->keydbSelected);
PGPFreeKeyDB(prds->keydbOriginal);
free(prds);
return FALSE;
}
}
if( IsntPGPError(error) )
{
error = EncryptSignBuffer(g_hinst, g_hwndEudoraMainWindow,
g_pgpContext, g_tlsContext, szExe, szDll,
*ppBuffer, *pLength, prds, NULL, &userOptions, &pOutput,
&outSize, bEncrypt, bSign, FALSE, FALSE);
}
else
{
PGPclEncDecErrorBox(g_hwndEudoraMainWindow, error);
}
*pLength = outSize;
if( IsntPGPError(error) )
{
if( pOutput )
{
*ppBuffer = (char*)HeapReAlloc( GetProcessHeap(),
HEAP_ZERO_MEMORY,
*ppBuffer,
*pLength + 1);
if(*ppBuffer)
{
ReturnValue = TRUE;
memcpy(*ppBuffer, (char*)pOutput, *pLength);
*(*ppBuffer + *pLength) = 0x00; // NULL terminate the string
memset(pOutput, 0x00, *pLength);
}
else
{
error = kPGPError_OutOfMemory;
}
PGPFreeData(pOutput);
}
}
// are there attachments?
if(IsntPGPError(error) && pAttachments && *pAttachments)
{
error = EncryptAttachments( pAttachments,
ppOutAttachments,
prds,
userOptions,
bEncrypt,
bSign);
}
if(userOptions != NULL)
{
PGPFreeOptionList(userOptions);
}
if (prds)
{
if (prds->keydbSelected != NULL)
PGPFreeKeyDB(prds->keydbSelected);
PGPFreeKeyDB(prds->keydbOriginal);
free(prds);
}
return ReturnValue;
}
