BOOL OpenRings(HWND hwnd,PGPContextRef context,PGPKeySetRef *pkeyset)
{
PGPError err;
PGPsdkLoadDefaultPrefs(context);
err=PGPOpenDefaultKeyRings( context,
OPENKEYRINGFLAGS,pkeyset);
if(IsPGPError(err))
{
PGPscMessageBox (hwnd,IDS_PGPERROR,IDS_CANTOPENRINGS,
MB_OK|MB_ICONSTOP);
return FALSE;
}
return TRUE;
}
int __cdecl _pgp_open_keyrings(LPSTR PubRingPath, LPSTR SecRingPath)
{
_pgp_close_keyrings();
#if (PGP_WIN32 < 0x700)
PGPError err = PGPOpenDefaultKeyRings(pgpContext, kPGPKeyRingOpenFlags_None, &pgpKeyDB);
#else
if ((!PubRingPath || !*PubRingPath) && !ShowSelectKeyringsDlg(0,PubRingPath,SecRingPath)) {
return 0;
}
PGPFileSpecRef PubKeyRing, SecKeyRing;
PGPNewFileSpecFromFullPath(pgpContext, PubRingPath, &PubKeyRing);
PGPNewFileSpecFromFullPath(pgpContext, SecRingPath, &SecKeyRing);
PGPError err = PGPOpenKeyDBFile(pgpContext, kPGPOpenKeyDBFileOptions_None, PubKeyRing, SecKeyRing, &pgpKeyDB);
PGPFreeFileSpec(SecKeyRing);
PGPFreeFileSpec(PubKeyRing);
#endif
if (CheckPGPError(err)) {
return 0;
}
return 1;
}
PGPError
TestGroupsUtil()
{
PGPContextRef context;
PGPError err = kPGPError_NoErr;
err = PGPNewContext( kPGPsdkAPIVersion, &context );
if ( IsntPGPError( err ) )
{
PGPKeySetRef keySet;
err = PGPOpenDefaultKeyRings( context, 0, &keySet );
if ( IsntPGPError( err ) )
{
err = sTestGroupValidity( keySet );
PGPFreeKeySet( keySet );
}
PGPFreeContext( context );
}
pgpAssertNoErr( err );
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;
}
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;
}
int disableKeyOnKeyServer(struct pgpmainBones *mainbPtr, char *keyguffin,
char *keyServerURL)
{
PGPContextRef context = mainbPtr->pgpContext;
struct pgpfileBones *filebPtr = mainbPtr->filebPtr;
struct pgpenvBones *envbPtr = filebPtr->envbPtr;
PGPtlsContextRef tlsContext = kInvalidPGPtlsContextRef;
PGPtlsSessionRef tlsSession = kInvalidPGPtlsSessionRef;
PGPKeyServerType type;
PGPEnv * env = envbPtr->m_env;
PGPInt32 pri;
PGPError err,er2;
PGPKeySetRef ringSet = NULL;
/*int status;*/
err = PGPOpenDefaultKeyRings( context, 0, &ringSet );
if( IsPGPError(err) ) {
fprintf(filebPtr->pgpout,
LANG("\nCan't open default key ring file\n"));
return -1;
}
mainbPtr->workingRingSet=ringSet;
err = PGPKeyServerInit();
pgpAssertNoErr(err);
err = PGPNewKeyServerFromURL( context, keyServerURL,
kPGPKeyServerAccessType_Administrator,
kPGPKeyServerKeySpace_Default,
&mainbPtr->workingKeyServer );
if( IsPGPError(err) )
pgpShowError(filebPtr, err,__FILE__,__LINE__);
err = PGPSetKeyServerEventHandler( mainbPtr->workingKeyServer,
srvhandler, (PGPUserValue)mainbPtr);
pgpAssertNoErr(err);
if(IsPGPError(err = PGPGetKeyServerType(mainbPtr->workingKeyServer, &type)))
{
err = 1;
goto done;
}
if (type == kPGPKeyServerType_LDAPS) {
if(IsPGPError(err = PGPNewTLSContext(context, &tlsContext)))
{
err = 1;
goto done;
}
if(IsPGPError(err = PGPNewTLSSession(tlsContext, &tlsSession)))
{
err = 1;
goto done;
}
}
err = PGPKeyServerOpen( mainbPtr->workingKeyServer, tlsSession );
if( IsPGPError(err) ) {
if (!envbPtr->compatible) {
if (pgpenvGetInt( env, PGPENV_VERBOSE, &pri, &er2 )) {
pgpShowError( filebPtr, err, __FILE__,__LINE__);
}
else {
pgpShowError( filebPtr, err, 0, 0);
}
}
goto done;
} else {
PGPKeySetRef keysToDisable=NULL;
err = pgpGetMatchingKeySet(mainbPtr, keyguffin, 0, &keysToDisable );
pgpAssertNoErr(err);
err = pgpUserChooseAndDisableKeys( mainbPtr, keysToDisable );
if( IsPGPError(err) ) {
if( err == kPGPError_EndOfIteration ) {
fprintf( filebPtr->pgpout,
LANG("\nKey not found in key ring '%s'.\n"),
keyServerURL );
} else if (!envbPtr->compatible)
pgpShowError(filebPtr, err, __FILE__,__LINE__);
}
if( PGPKeySetNeedsCommit( keysToDisable ) ) {
err = PGPCommitKeyRingChanges( keysToDisable );
if( IsPGPError(err))
pgpShowError(filebPtr,err,0,0);
}
if( keysToDisable )
PGPFreeKeySet( keysToDisable );
}
er2 = PGPKeyServerClose( mainbPtr->workingKeyServer );
pgpAssertNoErr(er2);
done:
if(tlsSession != kInvalidPGPtlsSessionRef)
PGPFreeTLSSession(tlsSession);
if(tlsContext != kInvalidPGPtlsContextRef)
PGPFreeTLSContext(tlsContext);
if(mainbPtr->workingKeyServer != kPGPInvalidRef)
PGPFreeKeyServer( mainbPtr->workingKeyServer );
mainbPtr->workingKeyServer = NULL;
er2 = PGPKeyServerCleanup();
pgpAssertNoErr(er2);
if( ringSet ) {
PGPFreeKeySet( ringSet );
mainbPtr->workingRingSet = NULL;
}
return IsPGPError(err) ? -1 : 0;
}
void AddSelectedKeys(HWND hWnd,
int nListCtrl,
PGPContextRef pgpContext,
PGPKeySetRef *pKeySet)
{
int nIndex;
LV_ITEM lviKey;
HWND hList;
PGPKeyRef newKey;
PGPKeySetRef userKeySet;
PGPKeySetRef newKeySet;
PGPKeyID newKeyID;
PGPError err;
PGPPublicKeyAlgorithm newKeyAlg;
if(IsPGPError(err = PGPOpenDefaultKeyRings(pgpContext,
(PGPKeyRingOpenFlags) 0, &userKeySet)))
{
MessageBox(NULL, "PGPOpenDefaultKeyRings error", "debug", MB_OK);
return;
}
hList = GetDlgItem(hWnd, nListCtrl);
if (*pKeySet != NULL)
PGPFreeKeySet(*pKeySet);
*pKeySet = NULL;
nIndex = ListView_GetNextItem(hList, -1, LVNI_SELECTED);
if (nIndex != -1)
PGPNewKeySet(pgpContext, pKeySet);
while (nIndex > -1)
{
lviKey.mask = LVIF_PARAM | LVIF_IMAGE;
lviKey.iItem = nIndex;
lviKey.iSubItem = 0;
ListView_GetItem(hList, &lviKey);
PGPGetKeyIDFromString((char *) lviKey.lParam, &newKeyID);
switch (lviKey.iImage)
{
case IDX_RSAPUBKEY:
newKeyAlg = kPGPPublicKeyAlgorithm_RSA;
break;
case IDX_DSAPUBKEY:
newKeyAlg = kPGPPublicKeyAlgorithm_DSA;
break;
default:
pgpDebugMsg("Image index isn't RSA or DSA!");
}
err = PGPGetKeyByKeyID(userKeySet, &newKeyID, newKeyAlg, &newKey);
if ((newKey != NULL) && (IsntPGPError(err)))
{
PGPNewSingletonKeySet(newKey, &newKeySet);
PGPAddKeys( newKeySet, *pKeySet);
PGPFreeKeySet(newKeySet);
}
nIndex = ListView_GetNextItem(hList,
nIndex, LVNI_SELECTED);
}
PGPFreeKeySet(userKeySet);
return;
}
void ShowKeyring(HWND hWnd,
int nListCtrl,
PGPContextRef pgpContext,
PGPKeySetRef onlyThisKeySet,
PGPBoolean bShowRSA,
PGPBoolean bShowDH,
PGPBoolean bMustEncrypt,
PGPBoolean bMustSign)
{
PGPKeyRef newKey = NULL;
PGPKeyID newKeyID;
PGPSubKeyRef newSubKey = NULL;
PGPError err;
PGPKeySetRef userKeySet = NULL;
PGPKeyListRef klist;
PGPKeyIterRef kiter;
unsigned char szUserID[kPGPMaxUserIDSize+1];
char szTempKeyID[kPGPMaxKeyIDStringSize+1];
char szSize[64];
char szCreation[64];
char szTitle[255];
UINT nLength;
HWND hList;
HDC hDC;
int iNumBits;
LV_ITEM lviKey;
LV_COLUMN lvcKey;
UINT nItem;
HIMAGELIST hImages;
HBITMAP hBmp;
PGPInt32 nSignSize;
PGPInt32 nEncryptSize;
PGPTime tCreation;
PGPUInt16 year, month, day;
PGPBoolean bIsRevoked;
PGPBoolean bIsDisabled;
PGPBoolean bIsExpired;
PGPBoolean bIsEncryptKey;
PGPBoolean bIsSigningKey;
PGPPublicKeyAlgorithm lAlg;
if(IsPGPError(err = PGPOpenDefaultKeyRings(pgpContext,
(PGPKeyRingOpenFlags) 0, &userKeySet)))
{
MessageBox(NULL, "PGPOpenDefaultKeyRings error", "debug", MB_OK);
return;
}
hList = GetDlgItem(hWnd, nListCtrl);
ListView_DeleteAllItems(hList);
ListView_DeleteColumn(hList, 2);
ListView_DeleteColumn(hList, 1);
ListView_DeleteColumn(hList, 0);
hDC = GetDC (NULL); // DC for desktop
iNumBits = GetDeviceCaps (hDC, BITSPIXEL) * GetDeviceCaps (hDC, PLANES);
ReleaseDC (NULL, hDC);
if (iNumBits <= 8)
{
hImages = ImageList_Create (16, 16, ILC_COLOR | ILC_MASK,
NUM_BITMAPS, 0);
hBmp = LoadBitmap (g_hInstance, MAKEINTRESOURCE (IDB_IMAGES4BIT));
ImageList_AddMasked (hImages, hBmp, RGB(255, 0, 255));
DeleteObject (hBmp);
}
else
{
hImages = ImageList_Create (16, 16, ILC_COLOR24 | ILC_MASK,
NUM_BITMAPS, 0);
hBmp = LoadBitmap (g_hInstance, MAKEINTRESOURCE (IDB_IMAGES24BIT));
ImageList_AddMasked (hImages, hBmp, RGB(255, 0, 255));
DeleteObject (hBmp);
}
ListView_SetImageList(hList, hImages, LVSIL_SMALL);
// Setup the list control columns
LoadString(g_hInstance, IDS_USERID, szTitle, 254);
lvcKey.mask = LVCF_FMT | LVCF_TEXT | LVCF_WIDTH | LVCF_SUBITEM;
lvcKey.fmt = LVCFMT_LEFT;
lvcKey.cx = 175;
lvcKey.pszText = szTitle;
lvcKey.iSubItem = -1;
ListView_InsertColumn(hList, 0, &lvcKey);
LoadString(g_hInstance, IDS_CREATION, szTitle, 254);
lvcKey.mask = LVCF_FMT | LVCF_TEXT | LVCF_WIDTH | LVCF_SUBITEM;
lvcKey.fmt = LVCFMT_CENTER;
lvcKey.cx = 75;
lvcKey.pszText = szTitle;
lvcKey.iSubItem = 1;
ListView_InsertColumn(hList, 1, &lvcKey);
LoadString(g_hInstance, IDS_KEYSIZE, szTitle, 254);
lvcKey.mask = LVCF_FMT | LVCF_TEXT | LVCF_WIDTH | LVCF_SUBITEM;
lvcKey.fmt = LVCFMT_CENTER;
lvcKey.cx = 75;
lvcKey.pszText = szTitle;
lvcKey.iSubItem = 2;
ListView_InsertColumn(hList, 2, &lvcKey);
/* Initialize keyrings */
PGPOrderKeySet(userKeySet, kPGPUserIDOrdering, &klist);
PGPNewKeyIter(klist, &kiter);
PGPKeyIterNext(kiter, &newKey);
nItem = 0;
while (newKey)
{
PGPGetKeyBoolean(newKey, kPGPKeyPropIsRevoked, &bIsRevoked);
PGPGetKeyBoolean(newKey, kPGPKeyPropIsDisabled, &bIsDisabled);
PGPGetKeyBoolean(newKey, kPGPKeyPropIsExpired, &bIsExpired);
PGPGetKeyBoolean(newKey, kPGPKeyPropIsEncryptionKey, &bIsEncryptKey);
PGPGetKeyBoolean(newKey, kPGPKeyPropIsSigningKey, &bIsSigningKey);
if ((bIsRevoked || bIsDisabled || bIsExpired) ||
(!bIsEncryptKey && bMustEncrypt) ||
(!bIsSigningKey && bMustSign))
{
PGPKeyIterNext(kiter, &newKey);
continue;
}
PGPGetKeyNumber(newKey, kPGPKeyPropAlgID, (PGPInt32 *) &lAlg);
if ((bShowRSA && (lAlg == kPGPPublicKeyAlgorithm_RSA)) ||
(bShowDH && (lAlg == kPGPPublicKeyAlgorithm_DSA)))
{
if (IsPGPError(PGPGetPrimaryUserIDNameBuffer(newKey,
kPGPMaxUserIDSize, (char*)szUserID, &nLength)))
{
PGPKeyIterNext(kiter, &newKey);
continue;
}
szUserID[nLength] = 0;
if (IsPGPError(PGPGetKeyNumber(newKey, kPGPKeyPropBits,
&nSignSize)))
{
PGPKeyIterNext(kiter, &newKey);
continue;
}
if (lAlg == kPGPPublicKeyAlgorithm_DSA)
{
PGPKeyIterNextSubKey(kiter, &newSubKey);
if (newSubKey) {
if (IsPGPError(PGPGetSubKeyNumber(newSubKey,
kPGPKeyPropBits, &nEncryptSize)))
{
PGPKeyIterNext(kiter, &newKey);
continue;
}
wsprintf(szSize, "%d/%d", nEncryptSize, nSignSize);
}
else
wsprintf(szSize, "%d", nSignSize);
}
else
wsprintf(szSize, "%d", nSignSize);
if (IsPGPError(PGPGetKeyTime(newKey, kPGPKeyPropCreation,
&tCreation)))
{
PGPKeyIterNext(kiter, &newKey);
continue;
}
PGPGetYMDFromPGPTime(tCreation, &year, &month, &day);
wsprintf(szCreation, "%d/%d/%d", month, day, year);
if (onlyThisKeySet != NULL)
{
if (!PGPKeySetIsMember(newKey, onlyThisKeySet))
{
PGPKeyIterNext(kiter, &newKey);
continue;
}
}
PGPGetKeyIDFromKey(newKey, &newKeyID);
PGPGetKeyIDString(&newKeyID, kPGPKeyIDString_Full, szTempKeyID);
lviKey.mask = LVIF_TEXT | LVIF_PARAM | LVIF_IMAGE;
lviKey.pszText = (char *) szUserID;
lviKey.iItem = nItem;
lviKey.iSubItem = 0;
if (lAlg == kPGPPublicKeyAlgorithm_RSA)
lviKey.iImage = IDX_RSAPUBKEY;
if (lAlg == kPGPPublicKeyAlgorithm_DSA)
lviKey.iImage = IDX_DSAPUBKEY;
lviKey.lParam = (long) pgpAlloc(strlen(szTempKeyID)+1);
strcpy((char *) lviKey.lParam, szTempKeyID);
ListView_InsertItem(hList, &lviKey);
lviKey.mask = LVIF_TEXT;
lviKey.pszText = szCreation;
lviKey.iItem = nItem;
lviKey.iSubItem = 1;
ListView_SetItem(hList, &lviKey);
lviKey.mask = LVIF_TEXT;
lviKey.pszText = szSize;
lviKey.iItem = nItem;
lviKey.iSubItem = 2;
ListView_SetItem(hList, &lviKey);
nItem++;
}
PGPKeyIterNext(kiter, &newKey);
}
PGPFreeKeyIter( kiter );
PGPFreeKeyList( klist );
/* Everything was OK */
err = kPGPError_NoErr;
PGPFreeKeySet(userKeySet);
return;
}
PGPError addToWorkingRingSet(struct pgpmainBones *mainbPtr, PGPKeySetRef
keySet, PGPBoolean bAddToDefault )
{
PGPContextRef context = mainbPtr->pgpContext;
PGPEnv *env = pgpContextGetEnvironment( context );
struct pgpfileBones *filebPtr = mainbPtr->filebPtr;
struct pgpenvBones *envbPtr = mainbPtr->envbPtr;
PGPKeyIterRef iter = NULL;
PGPError err;
PGPKeyRef key = 0;
PGPKeyRef origkey = 0;
PGPKeyID keyid;
int copying = 0;
int newkeys = 0, newsigs = 0, newuids = 0, newrvks = 0;
PGPKeyListRef keylist = 0;
char* ringfile = "";
PGPInt32 pri;
PGPInt32 verbose = pgpenvGetInt( env, PGPENV_VERBOSE, &pri, &err );
PGPInt32 interactive = envbPtr->interactiveAdd;
PGPBoolean batchmode = pgpenvGetInt( env, PGPENV_BATCHMODE, &pri, &err );
PGPKeySetRef keepset = NULL, origset = NULL;
PGPBoolean ans;
PGPKeySetRef defKeySet = kPGPInvalidRef;
err = PGPOpenDefaultKeyRings(context, kPGPKeyRingOpenFlags_Mutable, &defKeySet);
if(IsPGPError(err))
goto done;
if(bAddToDefault)
mainbPtr->workingRingSet = defKeySet;
pgpAssertAddrValid( mainbPtr, struct pgpmainBones );
pgpAssertAddrValid( mainbPtr->workingRingSet, PGPKeySetRef );
err = PGPNewEmptyKeySet( mainbPtr->workingRingSet, &origset );
pgpAssertNoErr(err);
err = PGPOrderKeySet( keySet, kPGPAnyOrdering, &keylist );
pgpAssertNoErr(err);
err = PGPNewKeyIter( keylist, &iter );
pgpAssertNoErr(err);
if(verbose)
fprintf(filebPtr->pgpout,
LANG("\nPASS 1.. find the existing keys\n"));
err = PGPKeyIterRewind( iter );
pgpAssertNoErr(err);
err = PGPKeyIterNext( iter, &key);
if( err ) {
fprintf( filebPtr->pgpout,LANG("Could not read key from keyfile."));
goto done;
}
while( key ) {
err = PGPGetKeyIDFromKey( key, &keyid );
pgpAssertNoErr(err);
err = PGPGetKeyByKeyID( defKeySet, &keyid,
kPGPPublicKeyAlgorithm_Invalid,
&origkey );
if(err == 0 )
err = pgpAddKeyToKeySet( origkey, origset );
err = PGPKeyIterNext( iter, &key );
}
if(verbose)
fprintf(filebPtr->pgpout,
LANG("\nPASS 2.. ask whether to add the new keys\n"));
err = PGPKeyIterRewind( iter );
pgpAssertNoErr(err);
err = PGPKeyIterNext( iter, &key);
if( err ) {
fprintf( filebPtr->pgpout,LANG("Could not read key from keyfile."));
goto done;
}
while( key ) {
PGPBoolean isnew;
err = PGPGetKeyIDFromKey( key, &keyid );
pgpAssertNoErr(err);
err = PGPGetKeyByKeyID( defKeySet, &keyid,
kPGPPublicKeyAlgorithm_Invalid,
&origkey );
/* Copy if all criteria are met */
copying = 0;
isnew = FALSE;
if(err == 0 ) {
copying = 1;
} else {
/* is a new key*/
err = pgpShowKeyListFormat( filebPtr,
mainbPtr->workingRingSet, iter, key, kShow_Sigs |
kShow_Checks );
if( interactive ) {
fprintf( filebPtr->pgpout, LANG(
"\nDo you want to add this key to keyring '%s' (y/N)? "), ringfile);
copying = getyesno(filebPtr,'n', batchmode ) ? 1 : 0;
} else
copying = 1;
if(copying) {
isnew=TRUE;
newkeys++;
}
}
if( copying ) {
if(keepset == NULL) {
err = PGPNewKeySet( context, &keepset );
pgpAssertNoErr(err);
}
err = pgpAddKeyToKeySet( key, keepset );
if(IsPGPError(err)) {
pgpShowError(filebPtr, err,__FILE__,__LINE__);
}
if( isnew && !batchmode ) {
/* This is not efficient, because it loops on
keepset, so avoid calling it in batchmode. */
err = pgpMarkKeyInSet( keepset, key );
}
}
err = PGPKeyIterNext( iter, &key );
if( err != 0 || key == 0 ) {
break;
}
}
if(err == kPGPError_EndOfIteration)
err = 0;
if( newkeys > 0 && !interactive ) {
fprintf( filebPtr->pgpout, LANG("\nkeyfile contains %d new keys. "),
newkeys);
fprintf( filebPtr->pgpout, LANG(
"Add these keys to keyring ? (Y/n) "));
fflush( filebPtr->pgpout );
ans = getyesno(filebPtr, 'y', batchmode);
/* add a newline to make it easier to read */
fprintf(filebPtr->pgpout, "\n");
fflush(filebPtr->pgpout);
if(!ans)
goto done;
}
if(verbose)
fprintf(filebPtr->pgpout, LANG(
"\nPASS 3.. show the new userids and new sigs\n"));
{
PGPSize keys,uids,sigs,rvks;
err = pgpMarkKeySet( origset );
pgpAssertNoErr(err);
err = PGPAddKeys( origset, keepset );
pgpAssertNoErr(err);
/*
* mark default key set to determine which keys are
* being added in, need to do this because mainbPtr->workingRingSet
* might be a in memory key set
*/
err = pgpMarkKeySet( defKeySet );
pgpAssertNoErr(err);
err = PGPAddKeys( keepset, defKeySet );
pgpAssertNoErr(err);
err = pgpShowKeySetUnmarked( filebPtr, defKeySet, &keys, &uids,
&sigs, &rvks );
pgpAssertNoErr(err);
/*newkeys += keys;*/
newuids += uids;
newsigs += sigs;
newrvks += rvks;
}
if(verbose)
fprintf(filebPtr->pgpout,
LANG("\nPASS 4... add them to the keyring\n"));
if(!bAddToDefault)
{
err = PGPAddKeys( keepset, mainbPtr->workingRingSet );
pgpAssertNoErr(err);
}
/* For now AddKeys should be more or less the same as mergekeys */
/* User feedback */
if( newsigs == 0 && newkeys == 0 && newuids == 0 && newrvks == 0 ) {
goto done;
}
/* Check signatures */
PGPCheckKeyRingSigs( keepset, mainbPtr->workingRingSet, 0, NULL, NULL );
if( err ) {
if( verbose ) {
fprintf(filebPtr->pgpout, LANG(
"addToWorkingRingSet: pgpDoCheckKeySet() returned %d\n"), err);
}
goto done;
}
/* More user feedback */
fprintf(filebPtr->pgpout, LANG("\nKeyfile contains:\n"));
if (newkeys)
fprintf(filebPtr->pgpout, LANG("%4d new key(s)\n"), newkeys);
if (newsigs)
fprintf(filebPtr->pgpout, LANG("%4d new signatures(s)\n"), newsigs);
if (newuids)
fprintf(filebPtr->pgpout, LANG("%4d new user ID(s)\n"), newuids);
if (newrvks)
fprintf(filebPtr->pgpout, LANG("%4d new revocation(s)\n"), newrvks);
err = PGPPropagateTrust( mainbPtr->workingRingSet );
pgpAssertNoErr(err);
/* mainbPtr->workingRingSet = ringSet;*/
/* mainbPtr->workingGroupSet = NULL;*/
err = pgpProcessUncertifiedKeys( mainbPtr, keepset );
if( IsPGPError(err)) {
if(err == kPGPError_UserAbort)
err = kPGPError_NoErr;
goto done;
}
err = pgpProcessUntrustedKeys( mainbPtr, keepset,
mainbPtr->workingRingSet );
done:
if(PGPKeySetNeedsCommit(mainbPtr->workingRingSet))
PGPCommitKeyRingChanges(mainbPtr->workingRingSet);
if(defKeySet != kPGPInvalidRef)
PGPFreeKeySet(defKeySet);
if(keepset != NULL)
PGPFreeKeySet( keepset );
if( iter )
PGPFreeKeyIter( iter );
if( keylist)
PGPFreeKeyList( keylist );
if( origset )
PGPFreeKeySet( origset );
/* The event handler will call addToRingSetFinish( ringSet ); before
this is done */
return err;
}
PGPError CreateFilter(HWND hwnd, PGPFilterRef* filter, int* action)
{
PGPError error = kPGPError_NoErr;
HWND hwndAttribute, hwndVerb;
HWND hwndEditSpecifier, hwndComboSpecifier, hwndComboListSpecifier;
HWND hwndTime;
int AttributeSelection = 0;
int VerbSelection = 0;
int SpecifierSelection = 0;
char* SpecifierBuffer = NULL;
DWORD SpecifierLength = 0;
int Month = 1;
int Day = 1;
int Year = 1970;
BOOL bNegate = FALSE;
SYSTEMTIME st;
assert(hwnd);
assert(filter);
assert(action);
// set default action
*action = ACTION_INTERSECT;
// find all our window handles
hwndAttribute = GetDlgItem(hwnd, IDC_ATTRIBUTE);
hwndVerb = GetDlgItem(hwnd, IDC_VERB);
hwndEditSpecifier = GetDlgItem(hwnd, IDC_SPECIFIER_EDIT);
hwndComboSpecifier = GetDlgItem(hwnd, IDC_SPECIFIER_COMBO);
hwndComboListSpecifier = GetDlgItem(hwnd, IDC_SPECIFIER_COMBO_LIST);
hwndTime = GetProp(hwnd, "hwndTime");
// find what the user has chosen to search on
AttributeSelection = ComboBox_GetCurSel(hwndAttribute);
VerbSelection = ComboBox_GetCurSel(hwndVerb);
SpecifierSelection = ComboBox_GetCurSel(hwndComboSpecifier);
if (SpecifierSelection < 0)
SpecifierSelection = ComboBox_GetCurSel(hwndComboListSpecifier);
// get date currently in time/date picker control
SendMessage (hwndTime, DTM_GETSYSTEMTIME, 0, (LPARAM)&st);
// struct tm represents months 0-11 so we have to subtract 1
Month = st.wMonth - 1;
// struct tm represents days 1-31 we have don't subtract 1
Day = st.wDay;
// struct tm represents years as offset from 1900
Year = st.wYear - 1900;
// combo is zero based and the string list is not... adjust Selection
switch( AttributeSelection + IDS_SEARCH_STRINGTABLE_BASE + 1 )
{
case IDS_ATTRIBUTE_1: // user id
{
SpecifierLength = Edit_GetTextLength(hwndEditSpecifier) + 1;
SpecifierBuffer = (char*) malloc(SpecifierLength);
if( SpecifierBuffer )
{
Edit_GetText( hwndEditSpecifier,
SpecifierBuffer,
SpecifierLength);
// MessageBox(NULL, SpecifierBuffer, "user id", MB_OK);
switch( VerbSelection )
{
case IS_NOT:
bNegate = TRUE;
case IS:
{
error = PGPNewUserIDStringFilter(
g_Context,
SpecifierBuffer,
kPGPMatchEqual,
filter );
if( bNegate && IsntPGPError(error) )
{
PGPFilterRef NegatedFilter = kPGPInvalidRef;
error = PGPNegateFilter(*filter,
&NegatedFilter);
if( IsntPGPError(error) )
{
*filter = NegatedFilter;
}
}
break;
}
case DOES_NOT_CONTAIN:
bNegate = TRUE;
case CONTAINS:
{
error = PGPNewUserIDStringFilter(
g_Context,
SpecifierBuffer,
kPGPMatchSubString,
filter );
if( bNegate && IsntPGPError(error) )
{
PGPFilterRef NegatedFilter = kPGPInvalidRef;
error = PGPNegateFilter(*filter,
&NegatedFilter);
if( IsntPGPError(error) )
{
*filter = NegatedFilter;
}
}
break;
}
case IS_NOT_SIGNED_BY:
bNegate = TRUE;
case IS_SIGNED_BY:
{
PGPKeySetRef ringSet = kPGPInvalidRef;
PGPKeySetRef filteredSet = kPGPInvalidRef;
error = PGPOpenDefaultKeyRings( g_Context,
0,
&ringSet);
if(ringSet && IsntPGPError(error))
{
PGPFilterRef userIdFilter = kPGPInvalidRef;
error = PGPNewUserIDStringFilter(
g_Context,
SpecifierBuffer,
kPGPMatchSubString,
&userIdFilter );
if( IsntPGPError(error) )
{
error = PGPFilterKeySet(ringSet,
userIdFilter,
&filteredSet);
PGPFreeFilter(userIdFilter);
}
if( IsntPGPError(error) )
{
error = KeyIdFilterFromKeySet( filteredSet,
filter);
PGPFreeKeySet(filteredSet);
}
if (!PGPRefIsValid (*filter))
{
error = kPGPError_Win32_NoSigningKey;
}
PGPFreeKeySet(ringSet);
}
if( bNegate && IsntPGPError(error) )
{
PGPFilterRef NegatedFilter = kPGPInvalidRef;
error = PGPNegateFilter(*filter,
&NegatedFilter);
if( IsntPGPError(error) )
{
*filter = NegatedFilter;
}
}
break;
}
}
free(SpecifierBuffer);
}
else
{
error = kPGPError_OutOfMemory;
}
break;
}
case IDS_ATTRIBUTE_2: // key id
{
SpecifierLength = Edit_GetTextLength(hwndEditSpecifier) + 1;
SpecifierBuffer = (char*) malloc(SpecifierLength);
if( SpecifierBuffer )
{
Edit_GetText( hwndEditSpecifier,
SpecifierBuffer,
SpecifierLength);
//MessageBox(NULL, SpecifierBuffer, "key id", MB_OK);
switch( VerbSelection )
{
case IS_NOT:
bNegate = TRUE;
case IS:
{
PGPKeyID keyId;
error = PGPGetKeyIDFromString( SpecifierBuffer,
&keyId );
if(IsntPGPError(error))
{
error = PGPNewKeyIDFilter( g_Context,
&keyId,
filter );
if( bNegate && IsntPGPError(error) )
{
PGPFilterRef NegatedFilter = kPGPInvalidRef;
error = PGPNegateFilter(*filter,
&NegatedFilter);
if( IsntPGPError(error) )
{
*filter = NegatedFilter;
}
}
}
break;
}
}
free(SpecifierBuffer);
}
else
{
error = kPGPError_OutOfMemory;
}
break;
}
case IDS_ATTRIBUTE_3: // key type
{
PGPByte encryptAlgorithm = 0;
if( SpecifierSelection == DH_KEY_TYPE )
{
encryptAlgorithm = kPGPPublicKeyAlgorithm_ElGamal;
}
else if( SpecifierSelection == RSA_KEY_TYPE )
{
encryptAlgorithm = kPGPPublicKeyAlgorithm_RSA;
}
error = PGPNewKeyEncryptAlgorithmFilter(g_Context,
encryptAlgorithm,
filter);
break;
}
case IDS_ATTRIBUTE_4: // creation date
{
struct tm time;
memset(&time, 0x00, sizeof(time));
time.tm_mday = Day; /* day of the month - [1,31] */
time.tm_mon = Month; /* months since January - [0,11] */
time.tm_year = Year; /* years since 1900 */
switch( VerbSelection )
{
// In order to simulate an "is date" without the
// user having to enter the exact hour, min, sec
// the key was created, we fake it by doing an
// intersection between the entire day.
case IS:
{
PGPFilterRef filterAM;
PGPFilterRef filterPM;
/* midnight AM */
time.tm_sec = 0;
time.tm_min = 0;
time.tm_hour = 0;
error = PGPNewKeyCreationTimeFilter(
g_Context,
PGPGetPGPTimeFromStdTime(mktime(&time)),
kPGPMatchGreaterOrEqual,
&filterAM );
if(IsPGPError(error))
{
break;
}
/* just before midnight PM */
time.tm_sec = 59;
time.tm_min = 59;
time.tm_hour = 23;
error = PGPNewKeyCreationTimeFilter(
g_Context,
PGPGetPGPTimeFromStdTime(mktime(&time)),
kPGPMatchLessOrEqual,
&filterPM );
if(IsntPGPError(error))
{
error = PGPIntersectFilters(filterAM,
filterPM,
filter);
}
break;
}
case IS_ON_OR_BEFORE:
{
/* just before midnight PM*/
time.tm_sec = 59;
time.tm_min = 59;
time.tm_hour = 23;
error = PGPNewKeyCreationTimeFilter(
g_Context,
PGPGetPGPTimeFromStdTime(mktime(&time)),
kPGPMatchLessOrEqual,
filter );
break;
}
case IS_ON_OR_AFTER:
{
/* midnight AM*/
time.tm_sec = 0;
time.tm_min = 0;
time.tm_hour = 0;
error = PGPNewKeyCreationTimeFilter(
g_Context,
PGPGetPGPTimeFromStdTime(mktime(&time)),
kPGPMatchGreaterOrEqual,
filter );
break;
}
}
break;
}
case IDS_ATTRIBUTE_5: // expiration date
{
struct tm time;
memset(&time, 0x00, sizeof(time));
time.tm_mday = Day; /* day of the month - [1,31] */
time.tm_mon = Month; /* months since January - [0,11] */
time.tm_year = Year; /* years since 1900 */
switch( VerbSelection )
{
// In order to simulate an "is date" without the
// user having to enter the exact hour, min, sec
// the key was created, we fake it by doing an
// intersection between the entire day.
case IS:
{
PGPFilterRef filterAM;
PGPFilterRef filterPM;
/* midnight AM */
time.tm_sec = 0;
time.tm_min = 0;
time.tm_hour = 0;
error = PGPNewKeyExpirationTimeFilter(
g_Context,
PGPGetPGPTimeFromStdTime(mktime(&time)),
kPGPMatchGreaterOrEqual,
&filterAM );
if(IsPGPError(error))
{
break;
}
/* just before midnight PM */
time.tm_sec = 59;
time.tm_min = 59;
time.tm_hour = 23;
error = PGPNewKeyExpirationTimeFilter(
g_Context,
PGPGetPGPTimeFromStdTime(mktime(&time)),
kPGPMatchLessOrEqual,
&filterPM );
if(IsntPGPError(error))
{
error = PGPIntersectFilters(filterAM,
filterPM,
filter);
}
break;
}
case IS_ON_OR_BEFORE:
{
/* just before midnight PM*/
time.tm_sec = 59;
time.tm_min = 59;
time.tm_hour = 23;
error = PGPNewKeyExpirationTimeFilter(
g_Context,
PGPGetPGPTimeFromStdTime(mktime(&time)),
kPGPMatchLessOrEqual,
filter );
break;
}
case IS_ON_OR_AFTER:
{
/* midnight AM*/
time.tm_sec = 0;
time.tm_min = 0;
time.tm_hour = 0;
error = PGPNewKeyExpirationTimeFilter(
g_Context,
PGPGetPGPTimeFromStdTime(mktime(&time)),
kPGPMatchGreaterOrEqual,
filter );
break;
}
}
break;
}
case IDS_ATTRIBUTE_6: // key
{
if( SpecifierSelection == REVOKED )
{
error = PGPNewKeyRevokedFilter(
g_Context,
(PGPBoolean)!VerbSelection,
filter );
}
else if( SpecifierSelection == DISABLED )
{
error = PGPNewKeyDisabledFilter(
g_Context,
(PGPBoolean)!VerbSelection,
filter );
}
break;
}
case IDS_ATTRIBUTE_7: // key size
{
SpecifierLength = ComboBox_GetTextLength(hwndComboSpecifier) + 1;
SpecifierBuffer = (char*) malloc(SpecifierLength);
if( SpecifierBuffer )
{
ComboBox_GetText( hwndComboSpecifier,
SpecifierBuffer,
SpecifierLength);
//MessageBox(NULL, SpecifierBuffer, "Key Size", MB_OK);
switch( VerbSelection )
{
case IS:
{
error = PGPNewKeyEncryptKeySizeFilter(
g_Context,
atol(SpecifierBuffer),
kPGPMatchEqual,
filter );
break;
}
case IS_AT_LEAST:
{
error = PGPNewKeyEncryptKeySizeFilter(
g_Context,
atol(SpecifierBuffer),
kPGPMatchGreaterOrEqual,
filter );
break;
}
case IS_AT_MOST:
{
error = PGPNewKeyEncryptKeySizeFilter(
g_Context,
atol(SpecifierBuffer),
kPGPMatchLessOrEqual,
filter );
break;
}
}
free(SpecifierBuffer);
}
else
{
error = kPGPError_OutOfMemory;
}
break;
}
default:
{
MessageBox(NULL, "DefaultFilter: Unknown Attribute", 0, MB_OK);
}
}
return error;
}
static
PGPError pgpInitSDKPrefsDir( PGPContextRef context )
{
char *pszTemp = NULL;
char rootPath[MAX_PATH] = {'\0'};
char filename[MAX_PATH] = {'\0'};
FILE *fp = NULL;
PGPUInt16 len = 0;
PGPError err = kPGPError_NoErr;
PGPKeySetRef keyset = kPGPInvalidRef;
#ifdef PGP_UNIX
PFLFileSpecRef dirspec = kPGPInvalidRef;
PGPMemoryMgrRef mmgr = kPGPInvalidRef;
PFLFileSpecRef sdkpflPrefs = kPGPInvalidRef;
PGPBoolean exists = FALSE;
err = PGPNewMemoryMgr(0, &mmgr);
if(IsPGPError(err))
return err;
err = pgpGetPrefsSpec( mmgr, &sdkpflPrefs );
if(IsPGPError(err))
{
PGPFreeMemoryMgr(mmgr);
return err;
}
err = PFLGetParentDirectory(sdkpflPrefs, &dirspec);
if(IsPGPError(err))
{
PFLFreeFileSpec(sdkpflPrefs);
PGPFreeMemoryMgr(mmgr);
return err;
}
err = PFLFileSpecExists(dirspec, &exists);
pgpAssertNoErr(err);
if(!exists) /* need to create directory */
{
char *dirname;
err = PFLGetFullPathFromFileSpec( dirspec, &dirname );
pgpAssertNoErr(err);
if(mkdir(dirname, 0700) == -1)
{
fprintf(stderr, LANG("mkdir (%s) failed..\n\n"), dirname);
err = kPGPError_CantOpenFile;
}
PGPFreeData(dirname);
}
if(dirspec != kPGPInvalidRef)
PGPFreeFileSpec(dirspec);
if(sdkpflPrefs != kPGPInvalidRef)
PFLFreeFileSpec(sdkpflPrefs);
if(mmgr != kPGPInvalidRef)
PGPFreeMemoryMgr(mmgr);
#endif /* PGP_UNIX */
err = PGPsdkLoadDefaultPrefs(context);
pgpAssertNoErr(err);
err = PGPOpenDefaultKeyRings(context,
kPGPKeyRingOpenFlags_Create |
kPGPKeyRingOpenFlags_Mutable, &keyset);
if(IsntPGPError(err))
{
PGPFreeKeySet(keyset);
}
else
return err;
/* now check to see if configuration file exists, if not, create it */
buildFileName(filename, "pgp.cfg");
if((fp = fopen(filename, "r")) != NULL)
fclose(fp);
else
{
/* file doesn't exist, create it */
touchFile(filename, 0600);
}
return err;
}
