LPSTR __cdecl _pgp_encrypt_keydb(LPCSTR szPlainMsg, PVOID pgpKeyID) { PGPKeyID *RemoteKeyID = (PGPKeyID *) pgpKeyID; LPSTR szEncMsg = 0; DWORD dwEncMsgLen; ClearPGPError(); if(!pgpKeyDB) return 0; #if (PGP_WIN32 < 0x700) PGPFilterRef IDFilter; PGPNewKeyIDFilter(pgpContext, RemoteKeyID, &IDFilter); PGPKeySetRef PublicKey; PGPFilterKeySet(pgpKeyDB, IDFilter, &PublicKey); #else PGPKeyDBObjRef PublicKey; PGPFindKeyByKeyID(pgpKeyDB, RemoteKeyID, &PublicKey); #endif PGPError err = PGPEncode(pgpContext, PGPOInputBuffer(pgpContext, szPlainMsg, lstrlen(szPlainMsg)), PGPOArmorOutput(pgpContext, TRUE), PGPOAllocatedOutputBuffer(pgpContext, (LPVOID *)&szEncMsg, 16384, (PGPUInt32 *)&dwEncMsgLen), #if (PGP_WIN32 < 0x700) PGPOEncryptToKeySet(pgpContext, PublicKey), #else PGPOEncryptToKeyDBObj(pgpContext, PublicKey), #endif PGPOVersionString(pgpContext, szVersionStr), PGPOLastOption(pgpContext)); #if (PGP_WIN32 < 0x700) PGPFreeKeySet(PublicKey); PGPFreeFilter(IDFilter); #endif if (CheckPGPError(err)) return 0; LPSTR szMsg = (LPSTR) LocalAlloc(LPTR,dwEncMsgLen+1); _pgp_memcpy(szMsg, szEncMsg, dwEncMsgLen); szMsg[dwEncMsgLen] = 0; PGPFreeData((LPVOID)szEncMsg); return szMsg; }
PGPError printSignatureChains(struct pgpmainBones *mainbPtr, PGPKeySetRef bothRingsSet, PGPFilterRef depthFilter) { struct pgpfileBones *filebPtr = mainbPtr->filebPtr; PGPKeyListRef depthList; PGPKeySetRef depthSet; PGPKeyRef key; PGPKeyIterRef keyiter; PGPKeyID keyID; PGPUserValue traceValue; PGPError err; char useridstr[ kPGPMaxUserIDSize ]; char nulluseridstr[kPGPMaxUserIDSize]; nulluseridstr[0] = '\0'; err = PGPFilterKeySet( bothRingsSet, depthFilter, &depthSet); pgpAssertNoErr(err); err = PGPOrderKeySet(depthSet, kPGPAnyOrdering, &depthList); pgpAssertNoErr(err); err = PGPNewKeyIter( depthList, &keyiter ); pgpAssertNoErr(err); err = PGPKeyIterRewind( keyiter ); pgpAssertNoErr(err); err = PGPKeyIterNext( keyiter, &key ); while (key != NULL) { err = pgpGetUserIDStringFromKey( key, useridstr ); pgpAssertNoErr(err); fprintf(filebPtr->pgpout, LANG("* %s\n"), useridstr); err = PGPGetKeyIDFromKey( key, &keyID); pgpAssertNoErr(err); traceValue = (PGPUserValue)( VISITED_MASK | 0 ); err = PGPSetKeyUserVal(key, traceValue); pgpAssertNoErr(err); err = printNextSignatureChainLink(mainbPtr, bothRingsSet, key, 0, 1); pgpAssertNoErr(err); err = PGPKeyIterNext( keyiter, &key ); } return 0; } /* printSignatureChains */
PGPError printNextSignatureChainLink(struct pgpmainBones *mainbPtr, PGPKeySetRef bothRingsSet, PGPKeyRef key, PGPBoolean visited, PGPUInt32 currentDepth) { PGPContextRef context = mainbPtr->pgpContext; struct pgpfileBones *filebPtr = mainbPtr->filebPtr; PGPUserValue traceValue; PGPUInt32 keyDepth; PGPKeyListRef kidsList; PGPKeySetRef kidsSet; PGPFilterRef kidsFilter; PGPFilterRef singletonFilter; PGPFilterRef notParentFilter; PGPKeyIterRef keyIter; char useridstr[kPGPMaxUserIDSize]; PGPError err = kPGPError_NoErr; PGPKeyID keyID; /* For first time at node? Create keyset containing its children. */ if (!visited) { err = PGPGetKeyIDFromKey( key, &keyID); pgpAssertNoErr(err); err = PGPNewSigKeyIDFilter(context, &keyID, &kidsFilter); pgpAssertNoErr(err); err = PGPNewKeyIDFilter( context, &keyID, &singletonFilter ); pgpAssertNoErr(err); err = PGPNegateFilter( singletonFilter, ¬ParentFilter); pgpAssertNoErr(err); err = PGPIntersectFilters( notParentFilter, kidsFilter, &kidsFilter ); pgpAssertNoErr(err); if (kidsFilter == NULL) return 0; /* childless node */ err = PGPFilterKeySet(bothRingsSet, kidsFilter, &kidsSet); pgpAssertNoErr(err); err = PGPOrderKeySet( kidsSet, kPGPAnyOrdering, &kidsList); pgpAssertNoErr(err); err = PGPNewKeyIter(kidsList, &keyIter); pgpAssertNoErr(err); err = PGPKeyIterRewind( keyIter); pgpAssertNoErr(err); err = PGPKeyIterNext( keyIter, &key); if (IsPGPError(err)) { /* childless */ PGPFreeKeyIter( keyIter); return 0; } } while (key != NULL) { err = PGPGetKeyUserVal(key, &traceValue); pgpAssertNoErr(err); visited = (PGPUInt32)traceValue & VISITED_MASK; keyDepth = (PGPUInt32)traceValue & DEPTH_MASK; err = pgpGetUserIDStringFromKey(key, useridstr); pgpAssertNoErr(err); fprintf(filebPtr->pgpout, LANG("%*s"), (2 * currentDepth), " "); fprintf(filebPtr->pgpout, LANG("> %s\n"), useridstr); if (visited || (keyDepth < currentDepth) ) return 0; traceValue = (PGPUserValue)( VISITED_MASK | keyDepth); err = PGPSetKeyUserVal(key, traceValue); pgpAssertNoErr(err); err = PGPGetKeyIDFromKey( key, &keyID); pgpAssertNoErr(err); err = printNextSignatureChainLink(mainbPtr, bothRingsSet, key, visited, currentDepth+1); err = PGPKeyIterNext( keyIter, &key ); if ( IsPGPError(err) ) { /* traversed all children of this node */ PGPFreeKeyIter( keyIter); return 0; } } return err; } /* printNextSignatureChainLink */
PGPError markSignatureChainDepths(struct pgpmainBones *mainbPtr, PGPKeySetRef bothRingsSet, PGPFilterRef depthFilter) { struct pgpfileBones *filebPtr = mainbPtr->filebPtr; PGPContextRef context = mainbPtr->pgpContext; PGPBoolean compatible = mainbPtr->envbPtr->compatible; PGPKeyIterRef keyiter; PGPKeyID kid; PGPKeySetRef depthSet; PGPKeyListRef depthList; PGPKeyRef key; PGPFilterRef signedByMeFilter = NULL; PGPFilterRef usedKeysFilter = NULL; PGPFilterRef unusedKeysFilter = NULL; char kstr[kPGPMaxKeyIDStringSize]; char useridstr[ kPGPMaxUserIDSize ]; PGPError err; PGPBoolean firstKeyAtThisDepth; PGPUInt32 depth = 0; PGPUInt32 count; PGPUserValue traceValue; /* Trace value contains highest depth in sig chain where this key appears. High bit ='visited' flag - indicates if chain has been followed from this point. */ fprintf(filebPtr->pgpout, LANG("\nPass 2: Tracing signature chains...\n")); usedKeysFilter = depthFilter; err = PGPNegateFilter( usedKeysFilter, &unusedKeysFilter ); pgpAssertNoErr(err); err = PGPFilterKeySet( bothRingsSet, depthFilter, &depthSet); pgpAssertNoErr(err); err = PGPCountKeys( depthSet, &count); pgpAssertNoErr(err); if (count == 0) { fprintf(filebPtr->pgpout, LANG("No ultimately-trusted keys.") ); return -1; } while ( TRUE ) { firstKeyAtThisDepth = TRUE; err = PGPOrderKeySet(depthSet, kPGPAnyOrdering, &depthList); pgpAssertNoErr(err); err = PGPNewKeyIter( depthList, &keyiter ); pgpAssertNoErr(err); err = PGPKeyIterRewind( keyiter ); pgpAssertNoErr(err); err = PGPKeyIterNext( keyiter, &key); while( key != NULL ) { err = pgpGetKeyIDStringCompatFromKey( key, TRUE, compatible, kstr ); pgpAssertNoErr(err); err = pgpGetUserIDStringFromKey( key, useridstr ); pgpAssertNoErr(err); /* Mark its highest depth level on each key. */ err = PGPGetKeyUserVal( key, &traceValue); pgpAssertNoErr(err); if ( (PGPUInt32)traceValue == 0) { (PGPUInt32)traceValue = depth; err = PGPSetKeyUserVal( key, traceValue); pgpAssertNoErr(err); } err = PGPGetKeyIDFromKey( key, &kid ); pgpAssertNoErr(err); if (firstKeyAtThisDepth) { err = PGPNewSigKeyIDFilter(context, &kid, &depthFilter); pgpAssertNoErr(err); firstKeyAtThisDepth = FALSE; } else { err = PGPNewSigKeyIDFilter(context, &kid, &signedByMeFilter); pgpAssertNoErr(err); err = PGPUnionFilters( signedByMeFilter, depthFilter, &depthFilter); pgpAssertNoErr(err); } err = PGPKeyIterNext( keyiter, &key); } err = PGPIntersectFilters(unusedKeysFilter, depthFilter, &depthFilter); pgpAssertNoErr(err); /* Create next depth level. */ err = PGPFreeKeySet( depthSet ); pgpAssertNoErr(err); err = PGPFilterKeySet( bothRingsSet, depthFilter, &depthSet); pgpAssertNoErr(err); err = PGPCountKeys( depthSet, &count); pgpAssertNoErr(err); err = PGPFreeKeyIter( keyiter ); pgpAssertNoErr(err); if (count == 0) return 0; err = PGPUnionFilters( depthFilter, usedKeysFilter, &usedKeysFilter); pgpAssertNoErr(err); err = PGPNegateFilter( usedKeysFilter, &unusedKeysFilter ); pgpAssertNoErr(err); depth ++; } } /* markSignatureChainDepths */
BOOL KMAddRevoker (PKEYMAN pKM) { PGPKeySetRef keysetToChoose = kInvalidPGPKeySetRef; PGPKeySetRef keysetToRemove = kInvalidPGPKeySetRef; PGPKeySetRef keysetThisKey = kInvalidPGPKeySetRef; PGPKeySetRef keysetSelected = kInvalidPGPKeySetRef; PGPFilterRef filterRSA = kInvalidPGPFilterRef; PGPError err = kPGPError_NoErr; PGPByte* pbyte = NULL; BOOL bRet = FALSE; PGPUInt32 uCount = 0; PGPBoolean bSyncWithServer = FALSE; PGPPrefRef prefref; PGPSize size; PGPKeyRef key; CHAR szPrompt[256]; key = (PGPKeyRef)KMFocusedObject (pKM); PGPclOpenClientPrefs (PGPGetContextMemoryMgr (pKM->Context), &prefref); PGPGetPrefBoolean (prefref, kPGPPrefKeyServerSyncOnAdd, &bSyncWithServer); PGPclCloseClientPrefs (prefref, FALSE); err = PGPNewKeySet (pKM->Context, &keysetToChoose); CKERR; err = PGPAddKeys (pKM->KeySetMain, keysetToChoose); CKERR; err = PGPCommitKeyRingChanges (keysetToChoose); CKERR; err = PGPNewKeyEncryptAlgorithmFilter (pKM->Context, kPGPPublicKeyAlgorithm_RSA, &filterRSA); CKERR; err = PGPFilterKeySet (pKM->KeySetMain, filterRSA, &keysetToRemove); CKERR; err = PGPCommitKeyRingChanges (keysetToRemove); CKERR; err = PGPRemoveKeys (keysetToRemove, keysetToChoose); CKERR; err = PGPCommitKeyRingChanges (keysetToChoose); CKERR; err = PGPCountKeys (keysetToChoose, &uCount); CKERR; if (uCount <= 1) { KMMessageBox (pKM->hWndParent, IDS_PGP, IDS_NOTENOUGHKEYSTOADDREVOKER, MB_OK|MB_ICONINFORMATION); goto done; } err = PGPFreeKeySet (keysetToRemove); CKERR; err = PGPNewSingletonKeySet (key, &keysetToRemove); CKERR; err = PGPRemoveKeys (keysetToRemove, keysetToChoose); CKERR; err = PGPCommitKeyRingChanges (keysetToChoose); CKERR; LoadString (g_hInst, IDS_ADDREVOKERPROMPT, szPrompt, sizeof(szPrompt)); err = PGPclSelectKeys (pKM->Context, pKM->tlsContext, pKM->hWndParent, szPrompt, keysetToChoose, pKM->KeySetMain, &keysetSelected); if (IsntPGPError (err) && PGPKeySetRefIsValid (keysetSelected)) { if (KMMessageBox (pKM->hWndParent, IDS_CAPTION, IDS_ADDREVOKERCONFIRM, MB_YESNO|MB_ICONEXCLAMATION) == IDYES) { err = KMGetKeyPhrase (pKM->Context, pKM->tlsContext, pKM->hWndParent, NULL, pKM->KeySetMain, key, NULL, &pbyte, &size); CKERR; // update from server if (IsntPGPError (err) && bSyncWithServer) { if (!KMGetFromServerInternal (pKM, FALSE, FALSE, FALSE)) { if (KMMessageBox (pKM->hWndParent, IDS_CAPTION, IDS_QUERYCONTINUEADDING, MB_YESNO|MB_ICONEXCLAMATION) == IDNO) { err = kPGPError_UserAbort; } } } if (IsntPGPError (err)) { err = PGPAddKeyOptions (key, PGPORevocationKeySet (pKM->Context, keysetSelected), pbyte ? PGPOPasskeyBuffer (pKM->Context, pbyte, size) : PGPONullOption (pKM->Context), PGPOLastOption (pKM->Context)); CKERR; } } else err = kPGPError_UserAbort; } // send to server if (IsntPGPError (err) && bSyncWithServer) { KMSendToServer (pKM, PGPCL_DEFAULTSERVER); } if (IsntPGPError (err)) { KMCommitKeyRingChanges (pKM); bRet = TRUE; if (bSyncWithServer) { KMMessageBox (pKM->hWndParent, IDS_PGP, IDS_ADDEDSENTREVOKERS, MB_OK|MB_ICONINFORMATION); } else { KMMessageBox (pKM->hWndParent, IDS_PGP, IDS_ADDEDREVOKERS, MB_OK|MB_ICONINFORMATION); } } done : if (NULL!=(int) (pbyte)) KMFreePasskey (pbyte, size); if (PGPKeySetRefIsValid (keysetToChoose)) PGPFreeKeySet (keysetToChoose); if (PGPKeySetRefIsValid (keysetToRemove)) PGPFreeKeySet (keysetToRemove); if (PGPKeySetRefIsValid (keysetThisKey)) PGPFreeKeySet (keysetThisKey); if (PGPKeySetRefIsValid (keysetSelected)) PGPFreeKeySet (keysetSelected); if (PGPFilterRefIsValid (filterRSA)) PGPFreeFilter (filterRSA); PGPclErrorBox (pKM->hWndParent, err); return bRet; }
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; }