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