LPSTR __cdecl _pgp_decrypt_key(LPCSTR szEncMsg, LPCSTR pgpKey) { #if defined(_WIN64) return 0; #else LPSTR szPlainMsg = 0; PGPSize dwPlainMsgLen; PGPUInt32 dwKeys; PGPKeyDBRef PrivateKeyDB; if (CheckPGPError(_pgp_import_key(&PrivateKeyDB,pgpKey))) return 0; PGPCountKeysInKeyDB(PrivateKeyDB, &dwKeys); if(dwKeys==0) { PGPFreeKeyDB(PrivateKeyDB); return 0; } int iTry = 0; do { if (!pszPassphrase && PGPPassphraseDialog(pgpContext, PGPOUIOutputPassphrase(pgpContext, &pszPassphrase), PGPOLastOption(pgpContext)) == kPGPError_UserAbort) { iTry = 3; break; } PGPError err = PGPDecode(pgpContext, PGPOInputBuffer(pgpContext, szEncMsg, lstrlen(szEncMsg)), PGPOAllocatedOutputBuffer(pgpContext, (LPVOID *)&szPlainMsg, 16384, &dwPlainMsgLen), PGPOKeyDBRef(pgpContext, PrivateKeyDB), PGPOPassphrase(pgpContext, pszPassphrase), PGPOLastOption(pgpContext)); if (CheckPGPError(err)) iTry = 3; else if (!dwPlainMsgLen) { PGPFreeData(pszPassphrase); pszPassphrase = 0; iTry++; } } while(!dwPlainMsgLen && iTry<3); PGPFreeKeyDB(PrivateKeyDB); if(iTry == 3) return 0; LPSTR szMsg = (LPSTR) LocalAlloc(LPTR,dwPlainMsgLen+1); _pgp_memcpy(szMsg, szPlainMsg, dwPlainMsgLen); szMsg[dwPlainMsgLen] = 0; PGPFreeData((LPVOID)szPlainMsg); return szMsg; #endif }
static PGPError sRevokeKeyNormal ( PGPContextRef context, PGPKeySetRef keyset, PGPKeyRef key, LPSTR pszPhrase) { UINT u; PGPKeyListRef keylist; PGPKeyIterRef keyiter; PGPSubKeyRef subkey; PGPError err; err = PGPRevokeKey (key, PGPOPassphrase (context, pszPhrase), PGPOLastOption (context)); if (IsPGPError (err)) return err; PGPGetKeyNumber (key, kPGPKeyPropAlgID, &u); switch (u) { case kPGPPublicKeyAlgorithm_RSA : break; case kPGPPublicKeyAlgorithm_DSA : PGPOrderKeySet (keyset, kPGPAnyOrdering, &keylist); PGPNewKeyIter (keylist, &keyiter); PGPKeyIterSeek (keyiter, key); PGPKeyIterNextSubKey (keyiter, &subkey); while (subkey) { err = PGPRevokeSubKey (subkey, PGPOPassphrase (context, pszPhrase), PGPOLastOption (context)); PGPKeyIterNextSubKey (keyiter, &subkey); } PGPFreeKeyIter (keyiter); PGPFreeKeyList (keylist); break; default : break; } return err; }
PGPError pgpKeyPassphraseCL( PGPContextRef context, CPGPKeyPassphraseDialogOptions *options) { PGPError err; GPP gpp; memset(&gpp,0x00,sizeof(GPP)); gpp.context=context; gpp.options=options; char szNameFinal[kPGPMaxUserIDSize]; GetKeyString(options->mDefaultKey, szNameFinal); fprintf(stdout, "\n%s\n", szNameFinal); while (1) { FreePassphrases(&gpp); gpp.pszPassPhrase = (char *)secAlloc (gpp.context, KEYSIZE); if (gpp.pszPassPhrase) { PGPInt32 len = pgpCLGetPass(stdout, gpp.pszPassPhrase, KEYSIZE); if (len < 0) { err = kPGPError_UserAbort; break; } *(options->mPassphrasePtr) = gpp.pszPassPhrase; if (PassphraseLengthAndQualityOK(options,gpp.pszPassPhrase)) { PGPBoolean PassValid; PassValid = PGPPassphraseIsValid(options->mDefaultKey, PGPOPassphrase(context, gpp.pszPassPhrase), PGPOLastOption(context)); if (PassValid) { err = kPGPError_NoErr; break; } else { fprintf(stdout, "Wrong passphrase, reenter\n"); } } else { ClearPassphrases(&gpp); FreePassphrases(&gpp); } } else { err = kPGPError_OutOfMemory; break; } } ClearPassphrases(&gpp); if (err != kPGPError_NoErr) FreePassphrases(&gpp); return(err); }
PGPError ValidateSigningPhrase (HWND hDlg, GPP *gpp, LPSTR pszPhrase, PGPKeyRef key) { CHAR szName[kPGPMaxUserIDSize]; CHAR sz[128]; CHAR sz2[kPGPMaxUserIDSize + 128]; PGPSize size; CPGPSigningPassphraseDialogOptions *options; options=(CPGPSigningPassphraseDialogOptions *)gpp->options; // does phrase match selected key ? if (PGPPassphraseIsValid (key, PGPOPassphrase (gpp->context, pszPhrase), PGPOLastOption (gpp->context))) { *(options->mPassphraseKeyPtr) = key; return kPGPError_NoErr; } if(options->mFindMatchingKey) { // does phrase match any private key ? key=GetKeyForPassphrase(options->mKeySet,pszPhrase,TRUE); if (key!=NULL) { // ask user to use other key LoadString (gPGPsdkUILibInst, IDS_FOUNDMATCHFORPHRASE, sz, sizeof(sz)); PGPGetPrimaryUserIDNameBuffer (key, sizeof(szName), szName, &size); wsprintf (sz2, sz, szName); LoadString (gPGPsdkUILibInst, IDS_PGP, sz, sizeof(sz)); if (MessageBox (hDlg, sz2, sz, MB_ICONQUESTION|MB_YESNO) == IDYES) { *(options->mPassphraseKeyPtr) = key; return kPGPError_NoErr; } return kPGPError_BadPassphrase; } } // phrase doesn't match any key PGPsdkUIMessageBox (hDlg, IDS_PGPERROR,IDS_BADPASSREENTER, MB_OK|MB_ICONSTOP); LoadString (gPGPsdkUILibInst, IDS_WRONGPHRASE, sz, sizeof (sz)); SetDlgItemText (hDlg, IDC_PROMPTSTRING, sz); return kPGPError_BadPassphrase; }
LPSTR __cdecl _pgp_decrypt_keydb(LPCSTR szEncMsg) { LPSTR szPlainMsg = 0; DWORD dwPlainMsgLen; ClearPGPError(); if(!pgpKeyDB) return 0; int iTry = 0; do { if (!pszPassphrase && PGPPassphraseDialog(pgpContext, PGPOUIOutputPassphrase(pgpContext, &pszPassphrase), PGPOLastOption(pgpContext)) == kPGPError_UserAbort) { iTry = 3; break; } PGPError err = PGPDecode(pgpContext, PGPOInputBuffer(pgpContext, szEncMsg, lstrlen(szEncMsg)), PGPOAllocatedOutputBuffer(pgpContext, (LPVOID *)&szPlainMsg, 16384, (PGPUInt32 *)&dwPlainMsgLen), #if (PGP_WIN32 < 0x700) PGPOKeySetRef(pgpContext, pgpKeyDB), #else PGPOKeyDBRef(pgpContext, pgpKeyDB), #endif PGPOPassphrase(pgpContext, pszPassphrase), PGPOLastOption(pgpContext)); if (CheckPGPError(err)) iTry = 3; else if (!dwPlainMsgLen) { PGPFreeData(pszPassphrase); pszPassphrase = 0; iTry++; } } while(!dwPlainMsgLen && iTry<3); if(iTry == 3) return 0; LPSTR szMsg = (LPSTR) LocalAlloc(LPTR,dwPlainMsgLen+1); _pgp_memcpy(szMsg, szPlainMsg, dwPlainMsgLen); szMsg[dwPlainMsgLen] = 0; PGPFreeData((LPVOID)szPlainMsg); return szMsg; }
PGPError ValidateSigningPhrase (GPP *gpp, char * pszPhrase, PGPKeyRef key) { char szName[kPGPMaxUserIDSize]; char sz[128]; char sz2[kPGPMaxUserIDSize + 128]; PGPSize size; CPGPSigningPassphraseDialogOptions *options; options = (CPGPSigningPassphraseDialogOptions *)gpp->options; // does phrase match selected key ? if (PGPPassphraseIsValid (key, PGPOPassphrase (gpp->context, pszPhrase), PGPOLastOption (gpp->context))) { *(options->mPassphraseKeyPtr) = key; return kPGPError_NoErr; } if (options->mFindMatchingKey) { // does phrase match any private key ? key=GetKeyForPassphrase(options->mKeySet,pszPhrase,TRUE); if (key != NULL) { // ask user to use other key PGPGetPrimaryUserIDNameBuffer (key, sizeof(szName), szName, &size); sprintf (sz2, sz, szName); return kPGPError_BadPassphrase; } } // phrase doesn't match any key printf("Bad Passphrase: Please re-enter\n"); return kPGPError_BadPassphrase; }
static PGPError sChangeKeyPhrase ( PGPContextRef context, PGPKeySetRef keyset, PGPKeyRef key, LPSTR szOld, PGPByte* pPasskeyOld, PGPSize sizePasskeyOld, PGPByte* pPasskey, PGPSize sizePasskey) { UINT u; PGPKeyListRef keylist; PGPKeyIterRef keyiter; PGPSubKeyRef subkey; PGPError err; if (szOld) { err = PGPChangePassphrase (key, PGPOPassphrase (context, szOld), PGPOPasskeyBuffer (context, pPasskey, sizePasskey), PGPOLastOption (context)); } else if (sizePasskeyOld > 0) { err = PGPChangePassphrase (key, PGPOPasskeyBuffer (context, pPasskeyOld, sizePasskeyOld), PGPOPasskeyBuffer (context, pPasskey, sizePasskey), PGPOLastOption (context)); } else { err = PGPChangePassphrase (key, PGPOPassphrase (context, ""), PGPOPasskeyBuffer (context, pPasskey, sizePasskey), PGPOLastOption (context)); } if (IsPGPError (err)) return err; PGPGetKeyNumber (key, kPGPKeyPropAlgID, &u); switch (u) { case kPGPPublicKeyAlgorithm_RSA : break; case kPGPPublicKeyAlgorithm_DSA : PGPOrderKeySet (keyset, kPGPAnyOrdering, &keylist); PGPNewKeyIter (keylist, &keyiter); PGPKeyIterSeek (keyiter, key); PGPKeyIterNextSubKey (keyiter, &subkey); while (subkey) { if (szOld) { err = PGPChangeSubKeyPassphrase (subkey, PGPOPassphrase (context, szOld), PGPOPasskeyBuffer (context, pPasskey, sizePasskey), PGPOLastOption (context)); } else if (sizePasskeyOld > 0) { err = PGPChangeSubKeyPassphrase (subkey, PGPOPasskeyBuffer (context, pPasskeyOld, sizePasskeyOld), PGPOPasskeyBuffer (context, pPasskey, sizePasskey), PGPOLastOption (context)); } else { err = PGPChangeSubKeyPassphrase (subkey, PGPOPassphrase (context, ""), PGPOPasskeyBuffer (context, pPasskey, sizePasskey), PGPOLastOption (context)); } PGPKeyIterNextSubKey (keyiter, &subkey); } PGPFreeKeyIter (keyiter); PGPFreeKeyList (keylist); break; default : break; } return err; }
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; }
LPSTR __cdecl _pgp_decrypt_key(LPCSTR szEncMsg, LPCSTR pgpKey) { LPSTR szPlainMsg = 0; DWORD dwPlainMsgLen; PGPUInt32 dwKeys; #if (PGP_WIN32 < 0x700) PGPKeySetRef PrivateKeyDB; if (CheckPGPError(_pgp_import_key(&PrivateKeyDB,pgpKey))) return 0; PGPCountKeys(PrivateKeyDB, &dwKeys); #else PGPKeyDBRef PrivateKeyDB; if (CheckPGPError(_pgp_import_key(&PrivateKeyDB,pgpKey))) return 0; PGPCountKeysInKeyDB(PrivateKeyDB, &dwKeys); #endif if(dwKeys==0) { #if (PGP_WIN32 < 0x700) PGPFreeKeySet(PrivateKeyDB); #else PGPFreeKeyDB(PrivateKeyDB); #endif return 0; } int iTry = 0; do { if (!pszPassphrase && PGPPassphraseDialog(pgpContext, PGPOUIOutputPassphrase(pgpContext, &pszPassphrase), PGPOLastOption(pgpContext)) == kPGPError_UserAbort) { iTry = 3; break; } /* #if (PGP_WIN32 < 0x700) PGPKeyListRef PrivateKeyList; PGPOrderKeySet(PrivateKeyDB, kPGPKeyIDOrdering, &PrivateKeyList); PGPKeyIterRef KeyIterRef; PGPNewKeyIter(PrivateKeyList, &KeyIterRef); PGPKeyRef PrivateKey; for(int i=0;i<dwKeys;i++) { PGPKeyIterNext(KeyIterRef, &PrivateKey); PGPOPassphraseIsValid(PrivateKey, PGPOPassphrase(pgpContext, pszPassphrase), PGPOLastOption(pgpContext)); } PGPFreeKeyList(PrivateKeyList); PGPFreeKeyIter(KeyIterRef); #else PGPKeyIterRef KeyIterRef; PGPNewKeyIterFromKeyDB(PrivateKeyDB, &KeyIterRef); PGPKeyDBObjRef KeyDBObjRef; for(int i=0;i<dwKeys;i++) { PGPKeyIterNextKeyDBObj(KeyIterRef, kPGPKeyDBObjType_Key, &KeyDBObjRef); PGPOPassphraseIsValid(PrivateKey, PGPOPassphrase(pgpContext, pszPassphrase), PGPOLastOption(pgpContext)); } PGPFreeKeyIter(KeyIterRef); #endif */ PGPError err = PGPDecode(pgpContext, PGPOInputBuffer(pgpContext, szEncMsg, lstrlen(szEncMsg)), PGPOAllocatedOutputBuffer(pgpContext, (LPVOID *)&szPlainMsg, 16384, (PGPUInt32 *)&dwPlainMsgLen), #if (PGP_WIN32 < 0x700) PGPOKeySetRef(pgpContext, PrivateKeyDB), #else PGPOKeyDBRef(pgpContext, PrivateKeyDB), #endif PGPOPassphrase(pgpContext, pszPassphrase), PGPOLastOption(pgpContext)); if (CheckPGPError(err)) iTry = 3; else if (!dwPlainMsgLen) { PGPFreeData(pszPassphrase); pszPassphrase = 0; iTry++; } } while(!dwPlainMsgLen && iTry<3); #if (PGP_WIN32 < 0x700) PGPFreeKeySet(PrivateKeyDB); #else PGPFreeKeyDB(PrivateKeyDB); #endif if(iTry == 3) return 0; LPSTR szMsg = (LPSTR) LocalAlloc(LPTR,dwPlainMsgLen+1); _pgp_memcpy(szMsg, szPlainMsg, dwPlainMsgLen); szMsg[dwPlainMsgLen] = 0; PGPFreeData((LPVOID)szPlainMsg); return szMsg; }
int revokeOrDisableKey(struct pgpmainBones *mainbPtr, char *keyguffin, PGPFileSpecRef keyfilespec) { PGPContextRef context = mainbPtr->pgpContext; struct pgpfileBones *filebPtr = mainbPtr->filebPtr; PGPEnv *env = mainbPtr->envbPtr->m_env; PGPBoolean compatible = mainbPtr->envbPtr->compatible; PGPKeySetRef ringset = NULL; PGPKeyListRef keylist = NULL; PGPKeyIterRef keyiter = NULL; PGPKeyRef key; PGPBoolean propData = FALSE; PGPError err, er2; PGPUInt32 pri; PGPBoolean needsfree = FALSE; char* passphrase = 0; int nkeysrevoked = 0; err = pgpOpenKeyringsFromPubringSpec( mainbPtr, keyfilespec, &ringset, kPGPKeyRingOpenFlags_Mutable ); if ( IsPGPError(err)) goto done; mainbPtr->workingRingSet=ringset; /*mainbPtr->workingGroupSet=NULL;*/ err = pgpGetMatchingKeyList( mainbPtr, keyguffin, kMatch_NotKeyServer, &keylist ); pgpAssertNoErr(err); err = PGPNewKeyIter( keylist, &keyiter ); pgpAssertNoErr(err); err = PGPKeyIterRewind( keyiter ); pgpAssertNoErr(err); err = PGPKeyIterNext( keyiter, &key ); while( key != NULL ) { pgpShowKeyBrief( filebPtr, key ); pgpShowKeyFingerprint( filebPtr, key ); /* XXX the old version used to ask for your password here... now is different a bit*/ err = PGPGetKeyBoolean( key, kPGPKeyPropIsSecret, &propData ); if( propData ) { PGPUserIDRef alias; PGPSize actual; char useridstr[ kPGPMaxUserIDSize ]; err = PGPGetPrimaryUserID( key, &alias ); pgpAssertNoErr(err); err = PGPGetUserIDStringBuffer( alias, kPGPUserIDPropName, kPGPMaxUserIDSize, useridstr, &actual ); pgpAssertNoErr(err); fprintf(filebPtr->pgpout, LANG("\nDo you want to permanently revoke your public key\n" "by issuing a secret key compromise certificate\n" "for \"%s\" (y/N)? "), useridstr ); if( getyesno( filebPtr, 'n', 0 ) ) { err = pgpGetValidPassphrase( mainbPtr, key, &passphrase, &needsfree); if( err == 0 ) { nkeysrevoked++; err = PGPRevokeKey( key, PGPOPassphrase( context, passphrase ), PGPOLastOption( context ) ); pgpAssertNoErr( err ); } goto tail; } } err = PGPGetKeyBoolean( key, kPGPKeyPropIsDisabled, &propData ); pgpAssertNoErr( err ); if( propData ) { fprintf( filebPtr->pgpout, LANG("\nKey is already disabled.\n" "Do you want to enable this key again (y/N)? ")); if( getyesno( filebPtr,'n',0) ) { err = PGPEnableKey( key ); pgpAssertNoErr( err ); } } else { fprintf( filebPtr->pgpout, LANG("\nDisable this key (y/N)? ")); if( getyesno( filebPtr,'n',0) ) { err = PGPDisableKey( key ); pgpAssertNoErr( err ); } } tail: err = PGPKeyIterNext( keyiter, &key ); } /*if( nkeysrevoked > 0 ) { err = PGPPropagateTrust( ringset ); pgpAssertNoErr( err ); }*/ if( PGPKeySetNeedsCommit( ringset ) ) { err = PGPCommitKeyRingChanges( ringset ); } done: if( needsfree ) { PGPFreeData( passphrase ); pgpRemoveFromPointerList( mainbPtr->leaks, passphrase ); } if (ringset) er2 = PGPFreeKeySet( ringset ); mainbPtr->workingRingSet = NULL; if (keyiter) er2 = PGPFreeKeyIter( keyiter ); if (keylist) er2 = PGPFreeKeyList( keylist ); if ( !compatible && IsPGPError(err) && pgpenvGetInt( env, PGPENV_VERBOSE, &pri, &er2) ) pgpShowError(filebPtr, err,__FILE__,__LINE__); return err; }
BOOL CALLBACK pgpKeyPassphraseDlgProc ( HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) { CPGPKeyPassphraseDialogOptions *options; GPP *gpp; INT i; DWORD Common; Common=DoCommonCalls (hDlg,uMsg,wParam,lParam); if(Common) return Common; switch (uMsg) { case WM_INITDIALOG: { RECT rc; int iTextWidth; HDC hdc; char szNameFinal[kPGPMaxUserIDSize]; gpp=(GPP *)GetWindowLong (hDlg, GWL_USERDATA); options = (CPGPKeyPassphraseDialogOptions *) gpp->options; gpp->iNextTabControl = IDOK; gpp->wpOrigPhrase1Proc = (WNDPROC) SetWindowLong( GetDlgItem(hDlg, IDC_PHRASE1), GWL_WNDPROC, (LONG) PhraseSubclassProc); GetClientRect(GetDlgItem(hDlg,IDC_KEYNAME), &rc); iTextWidth = rc.right-rc.left; hdc = GetDC (GetDlgItem(hDlg,IDC_KEYNAME)); GetKeyString(hdc,iTextWidth,options->mDefaultKey,szNameFinal); SetWindowText(GetDlgItem(hDlg,IDC_KEYNAME),szNameFinal); ReleaseDC (GetDlgItem (hDlg, IDC_KEYNAME), hdc); gpp->hwndOptionsControl=DisplayOptions(hDlg,options->mDialogOptions,130); return FALSE; } case WM_COMMAND: { gpp=(GPP *)GetWindowLong (hDlg, GWL_USERDATA); options = (CPGPKeyPassphraseDialogOptions *) gpp->options; switch (LOWORD (wParam)) { case IDOK: { PGPBoolean PassValid; FreePassphrases(gpp); i = SendDlgItemMessage (hDlg, IDC_PHRASE1, WM_GETTEXTLENGTH, 0, 0) +1; gpp->szDummy = (char *)secAlloc (gpp->context, i); if(gpp->szDummy) { gpp->pszPassPhrase = (char *)secAlloc (gpp->context, i); if (gpp->pszPassPhrase) { GetDlgItemText (hDlg, IDC_PHRASE1, gpp->szDummy, i); if(PassphraseLengthAndQualityOK(hDlg,options,gpp->pszPassPhrase)) { if(!options->mVerifyPassphrase) { ClearPassphrases(hDlg,gpp); SaveOptionSettings(gpp->hwndOptionsControl); EndDialog (hDlg, kPGPError_NoErr); break; } PassValid=PGPPassphraseIsValid (options->mDefaultKey, PGPOPassphrase (gpp->context, gpp->pszPassPhrase), PGPOLastOption (gpp->context)); if(PassValid) { ClearPassphrases(hDlg,gpp); SaveOptionSettings(gpp->hwndOptionsControl); EndDialog (hDlg, kPGPError_NoErr); break; } else { PGPsdkUIMessageBox (hDlg, IDS_PGPERROR,IDS_BADPASSREENTER, MB_OK|MB_ICONSTOP); } } // Bad passphrase/quality ClearPassphrases(hDlg,gpp); FreePassphrases(gpp); break; } } // Couldn't allocate passphrases ClearPassphrases(hDlg,gpp); FreePassphrases(gpp); EndDialog (hDlg, kPGPError_OutOfMemory); break; } } } break; } return FALSE; }
PGPError PGPskepSendShares(PGPskepRef skep, PGPKeyRef authKey, const char *passphrase, PGPShareRef shares, const char *destSocketAddress) { PGPSocketRef socket = NULL; PGPtlsSessionRef tlsSession = NULL; PGPEventHandlerProcPtr oldCallback = NULL; PGPUserValue oldUserValue; PGPSocketAddressInternet sockAddr; PGPHostEntry * hostEntry = NULL; PGPskepEvent skepEvent; PGPskepEventProgressData progressData = {0,0}; PGPInt32 result; PGPKeyRef remoteKey = NULL; PGPKeyID keyID; PGPShareID shareID; PGPUInt32 inetAddress; PGPUInt32 threshold; PGPUInt32 numShares; PGPUInt32 totalShares; PGPUInt32 closing; PGPSize shareDataSize; PGPByte * shareData = NULL; PGPByte version; PGPBoolean weConfirmed; PGPBoolean theyConfirmed; PGPError err = kPGPError_NoErr; PGPSocketsThreadStorageRef previousStorage; #if PGP_WIN32 char h_name[256]; #endif PGPValidateSKEP(skep); PGPValidateParam(PGPKeyRefIsValid(authKey)); PGPValidatePtr(passphrase); PGPValidateParam(PGPShareRefIsValid(shares)); PGPValidatePtr(destSocketAddress); pgpAssertMsg(skep->magic == kPGPskepMagic, "Invalid SKEP object"); skep->cancel = FALSE; PGPSocketsInit(); PGPSocketsCreateThreadStorage(&previousStorage); if (IsntNull(skep->eventHandler)) { PGPGetSocketsIdleEventHandler(&oldCallback, &oldUserValue); PGPSetSocketsIdleEventHandler(sSocketCallback, skep); } inetAddress = PGPDottedToInternetAddress(destSocketAddress); if (inetAddress != kPGPSockets_Error) { #if PGP_WIN32 err = PGPStartAsyncGetHostByAddress(inetAddress, &skep->asyncHostEntryRef); if (IsntPGPError(err)) { PGPWaitForGetHostByAddress(skep->asyncHostEntryRef, h_name, 256); skep->asyncHostEntryRef = kPGPInvalidAsyncHostEntryRef; } #else hostEntry = PGPGetHostByAddress((char *) &inetAddress, sizeof(PGPInternetAddress), kPGPProtocolFamilyInternet); #endif } else { #if PGP_WIN32 err = PGPStartAsyncGetHostByName(destSocketAddress, &skep->asyncHostEntryRef); if (IsntPGPError(err)) { PGPWaitForGetHostByName(skep->asyncHostEntryRef, &inetAddress); skep->asyncHostEntryRef = kPGPInvalidAsyncHostEntryRef; strcpy(h_name, destSocketAddress); } #else hostEntry = PGPGetHostByName(destSocketAddress); #endif } if (IsntPGPError(err) && IsNull(hostEntry)) if (inetAddress == kPGPSockets_Error) err = PGPGetLastSocketsError(); if (IsntPGPError(err)) { socket = PGPOpenSocket(kPGPAddressFamilyInternet, kPGPSocketTypeStream, kPGPTCPProtocol); if (IsNull(socket)) { err = PGPGetLastSocketsError(); pgpAssertNoErr(err); } } if (IsntPGPError(err)) { skep->socketOut = socket; sockAddr.sin_family = kPGPAddressFamilyInternet; sockAddr.sin_port = PGPHostToNetShort(kPGPskep_Port); /* If we were able to get the host entry, use the IP address list */ /* from that. If not, use the IP address passed in by the caller */ if (IsntNull(hostEntry)) sockAddr.sin_addr = *((PGPInternetAddress*) *hostEntry->h_addr_list); else sockAddr.sin_addr = *((PGPInternetAddress*) &inetAddress); result = PGPConnect(socket, (PGPSocketAddress *) &sockAddr, sizeof(sockAddr)); if (result == kPGPSockets_Error) err = PGPGetLastSocketsError(); else { skepEvent.type = kPGPskepEvent_ConnectEvent; if (skep->eventHandler != NULL) err = skep->eventHandler(skep, &skepEvent, skep->userValue); } } if (IsntPGPError(err)) { err = PGPNewTLSSession(skep->tlsContext, &tlsSession); pgpAssertNoErr(err); } if (IsntPGPError(err)) { err = PGPtlsSetProtocolOptions(tlsSession, kPGPtlsFlags_ClientSide); pgpAssertNoErr(err); } if (IsntPGPError(err)) { err = PGPtlsSetLocalPrivateKey(tlsSession, authKey, kInvalidPGPSigRef, kInvalidPGPKeySetRef, PGPOPassphrase( skep->context, passphrase ), PGPOLastOption( skep->context ) ); pgpAssertNoErr(err); } if (IsntPGPError(err)) { err = PGPSocketsEstablishTLSSession(socket, tlsSession); if (IsPGPError(err)) err = PGPGetLastSocketsError(); if (skep->cancel == TRUE) err = kPGPError_UserAbort; pgpAssertNoErr(err); } if (IsntPGPError(err)) { err = PGPtlsGetRemoteAuthenticatedKey(tlsSession, &remoteKey, NULL); if (skep->cancel == TRUE) err = kPGPError_UserAbort; pgpAssertNoErr(err); } if (IsntPGPError(err)) { /* If we don't have the host name, set it to the IP address */ if (IsntNull(hostEntry)) #if PGP_WIN32 skepEvent.data.ad.remoteHostname = h_name; #else skepEvent.data.ad.remoteHostname = hostEntry->h_name; #endif else skepEvent.data.ad.remoteHostname = PGPInternetAddressToDottedString(sockAddr.sin_addr); skepEvent.type = kPGPskepEvent_AuthenticateEvent; skepEvent.data.ad.remoteKey = remoteKey; skepEvent.data.ad.remoteIPAddress = PGPInternetAddressToDottedString(sockAddr.sin_addr); PGPtlsGetNegotiatedCipherSuite( tlsSession, &skepEvent.data.ad.tlsCipher ); if( ( skepEvent.data.ad.tlsCipher == kPGPtls_TLS_PGP_DHE_DSS_WITH_NULL_SHA ) || ( skepEvent.data.ad.tlsCipher == kPGPtls_TLS_DHE_DSS_WITH_NULL_SHA ) ) err = kPGPError_TLSNoCommonCipher; else { if (skep->eventHandler != NULL) err = skep->eventHandler(skep, &skepEvent, skep->userValue); if (IsntPGPError(err)) weConfirmed = TRUE; else weConfirmed = FALSE; err = kPGPError_NoErr; } }