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; }