pgppassphrasedialog.cpp

vc环境下的pgp源码

	}

	// phrase doesn't match any key
	printf("Bad Passphrase: Please re-enter\n");
	
	return kPGPError_BadPassphrase;

}

// ****************************************************************************
// ****************************************************************************

// Just a simple decryption
	PGPError
pgpPassphraseDialogPlatform(
	PGPContextRef					context,
	CPGPPassphraseDialogOptions 	*options)
{
	PGPError err = 0;
	GPP	gpp;

	memset(&gpp,0x00,sizeof(GPP));
	gpp.context=context;
	gpp.options=options;

//	InitRandomKeyHook(&hhookMouse,&hhookKeyboard);

//	err = DialogBoxParam (g_hInst, 
	//	MAKEPGPInt32 (IDD_PASSPHRASE), 
	//	options->mHwndParent,
	//	(DLGPROC)pgpPassphraseDlgProc, (LPARAM)&gpp);

//	*(options->mPassphrasePtr)=gpp.pszPassPhrase;

//	UninitRandomKeyHook(hhookMouse,hhookKeyboard);

	return(err);
}

// Show the recipients
	PGPError
pgpDecryptionPassphraseDialogPlatform(
	PGPContextRef							context,
	CPGPDecryptionPassphraseDialogOptions	*options)
{
	PGPError err = 0;
	GPP	gpp;

	memset(&gpp,0x00,sizeof(GPP));
	gpp.context=context;
	gpp.options=options;

//	InitRandomKeyHook(&hhookMouse,&hhookKeyboard);

	//err = DialogBoxParam (g_hInst, 
	//	MAKEINTRESOURCE (IDD_PASSPHRASEDECRYPTKEYS), 
	//	options->mHwndParent,
	//	(DLGPROC)pgpDecryptionPassphraseDlgProc, (LPARAM)&gpp);

	//*(options->mPassphrasePtr)=gpp.pszPassPhrase;

	//UninitRandomKeyHook(hhookMouse,hhookKeyboard);

	return(err);
}

// Signer combo box
PGPError
pgpSigningPassphraseDialogPlatform(
	PGPContextRef						context,
	CPGPSigningPassphraseDialogOptions 	*options)
{
	PGPError err = 0;
	GPP	gpp;

	memset(&gpp,0x00,sizeof(GPP));
	gpp.context=context;
	gpp.options=options;

	/*
	 * XXX
	 * Currently expects to display only *ONE* key.
	 * The caller must set the keyset in the options to consist
	 * of the signing key that the caller wants this routine
	 * to verify
	 */
	
	// Initialize stuff
	if (!InitSigningKeyComboBox (options)) {
		return kPGPError_UserAbort; // kPGPError_Win32_NoSecret_Key
	}
	
	if (options->mPrompt)
		puts(options->mPrompt);
	else
		printf("Need a pass phrase to use this key\n");
	
	// Need to ask and get Passphrase
	

	// Ask for passphrase
	// put into CBreak mode for no echo
	// Need to get the size of the passphrase
	// Get first key out of keyset. Keyset is supposed to
	// only have one key XXX
	
	PGPKeyListRef	KeyList;
	PGPKeyIterRef	KeyIter;
	PGPKeyRef		key;
	PGPOrderKeySet (options->mKeySet,kPGPValidityOrdering,&KeyList);
	PGPNewKeyIter (KeyList, &KeyIter);
	PGPKeyIterNext (KeyIter, &key);

	while (1) {
		FreePassphrases(&gpp);
		gpp.pszPassPhrase = (char *)secAlloc (gpp.context, 500); // XXX 500
		if (gpp.pszPassPhrase) {
			PGPBoolean  bShared;
			
			PGPInt32 len = pgpTtyGetPass(stdout, gpp.pszPassPhrase, 500);
			if (len < 0) {
				err = kPGPError_UserAbort;
				goto end;
			}
			
			*(options->mPassphrasePtr) = gpp.pszPassPhrase;
			
			// Check Shared status
			err = PGPGetKeyBoolean(key, kPGPKeyPropIsSecretShared, &bShared);
			
			if (IsntPGPError(err) && bShared) {
				// So, they want to do a shared key
				*(options->mPassphraseKeyPtr) = key;
				err = kPGPError_KeyUnusableForSignature;
				goto end;
			}
			
			if (PassphraseLengthAndQualityOK(options,gpp.pszPassPhrase)) {
				if (!options->mVerifyPassphrase) {
					err = kPGPError_NoErr;
					goto end;
				}
				
				err = ValidateSigningPhrase(&gpp,gpp.pszPassPhrase,key);
				
				if (IsntPGPError(err)) {
					err = kPGPError_NoErr;
					goto end;
				}
			}
			
			// Bad passphrase/quality
			err = kPGPError_BadPassphrase;
		}
	}
	
	// Couldn't allocate passphrases
	err = kPGPError_OutOfMemory;
	
	
 end:
	PGPFreeKeyIter(KeyIter);
	PGPFreeKeyList(KeyList);
	ClearPassphrases(&gpp);
	if (err != kPGPError_NoErr)
		FreePassphrases(&gpp);
	return(err);
}

// Double edit window
	PGPError
pgpConfirmationPassphraseDialogPlatform(
	PGPContextRef								context,
	CPGPConfirmationPassphraseDialogOptions 	*options)
{
	PGPError err = 0;
	GPP	gpp;

	memset(&gpp,0x00,sizeof(GPP));
	gpp.context=context;
	gpp.options=options;

//	InitRandomKeyHook(&hhookMouse,&hhookKeyboard);
	
	//err = DialogBoxParam (g_hInst, 
	//	MAKEINTRESOURCE (IDD_PASSPHRASEENCRYPT),
	//	options->mHwndParent,
	//	(DLGPROC)pgpConfirmationDlgProc, (LPARAM)&gpp);
//
//	*(options->mPassphrasePtr)=gpp.pszPassPhrase;
//
//	UninitRandomKeyHook(hhookMouse,hhookKeyboard);

	return(err);
}

	PGPError
pgpKeyPassphraseDialogPlatform(
	PGPContextRef					context,
	CPGPKeyPassphraseDialogOptions 	*options)
{
	PGPError err;
	PGPBoolean bShared,bNeedsPhrase;
	GPP	gpp;

	memset(&gpp,0x00,sizeof(GPP));
	gpp.context=context;
	gpp.options=options;

	err=PGPGetKeyBoolean( options->mDefaultKey, kPGPKeyPropIsSecretShared,
				&bShared);
	
	if(IsntPGPError(err) && bShared)
	{
		// So, they want to do a shared key....
		return(kPGPError_KeyUnusableForSignature);
	}

	err=PGPGetKeyBoolean (options->mDefaultKey, kPGPKeyPropNeedsPassphrase,
				&bNeedsPhrase);

	if(IsntPGPError(err) && !bNeedsPhrase)
	{
		*(options->mPassphrasePtr)=(char *)secAlloc (context, 1);
		if(*(options->mPassphrasePtr)==0)
			return(kPGPError_OutOfMemory);

		// Doesn't need a passphrase
		strcpy(*(options->mPassphrasePtr),"");
		return(kPGPError_NoErr);
	}

//	InitRandomKeyHook(&hhookMouse,&hhookKeyboard);

	//err = DialogBoxParam (g_hInst, 
	//	MAKEINTRESOURCE (IDD_KEYPASSPHRASE), 
	//	options->mHwndParent,
	//	(DLGPROC)pgpKeyPassphraseDlgProc, (LPARAM)&gpp);
//
//	*(options->mPassphrasePtr)=gpp.pszPassPhrase;
//
//	UninitRandomKeyHook(hhookMouse,hhookKeyboard);

	return(err);
}


#if 0
BOOL CALLBACK 
pgpSigningPassphraseDlgProc (
        HWND    hDlg, 
        UINT    uMsg, 
        WPARAM  wParam,
        LPARAM  lParam) 
{
    CPGPSigningPassphraseDialogOptions *options;
    GPP             *gpp;
    INT             i;
    DWORD           Common;
 
    Common=DoCommonCalls (hDlg,uMsg,wParam,lParam); 
 
    if(Common)
        return Common;
 
    switch (uMsg) 
    {
        case WM_INITDIALOG:
        {
            gpp=(GPP *)GetWindowLong (hDlg, GWL_USERDATA);
            options = (CPGPSigningPassphraseDialogOptions *)
                gpp->options;
 
            gpp->iNextTabControl = IDOK;
 
            gpp->wpOrigPhrase1Proc = (WNDPROC) SetWindowLong(
                GetDlgItem(hDlg, IDC_PHRASE1), 
                GWL_WNDPROC, 
                (LONG) PhraseSubclassProc); 
 
            if (InitSigningKeyComboBox (hDlg, options)) 
            {
                EnablePassPhraseControl (hDlg);
            }
            else 
            {
                EndDialog (hDlg, kPGPError_UserAbort);
            }
 
            DisplayOptions(hDlg,options->mDialogOptions,120);
 
            return TRUE;
        }
 
        case WM_COMMAND:
        {
            gpp=(GPP *)GetWindowLong (hDlg, GWL_USERDATA);
            options = (CPGPSigningPassphraseDialogOptions *)
                gpp->options;
 
            switch (LOWORD (wParam)) 
            {
                case IDOK:
                {
                    int ComboSelection;
 
                    FreePassphrases(gpp);
					
                    ComboSelection = SendDlgItemMessage (hDlg,
                    					IDC_SIGNKEYCOMBO, CB_GETCURSEL, 0, 0);
					
                    if (ComboSelection == CB_ERR) 
                    {
                        PGPclMessageBox (hDlg, 
                            IDS_ERRORMESSAGECAPTION, IDS_NOSIGNKEY, 
                            MB_OK | MB_ICONEXCLAMATION);
                        break;
                    }
 
                    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) 
                        {
                            PGPKeyRef   key;
                            PGPError    err;
                            PGPBoolean  bShared;
 
                            GetDlgItemText (hDlg, IDC_PHRASE1, gpp->szDummy, i);
 
                            key = (PGPKeyRef)SendDlgItemMessage (hDlg, 
                                IDC_SIGNKEYCOMBO, CB_GETITEMDATA,
                                ComboSelection , 0);
 
                            err=PGPGetKeyBoolean( key,
                            		kPGPKeyPropIsSecretShared , &bShared);
    
                            if(IsntPGPError(err) && bShared)
                            {
                                // So, they want to do a shared key....
                                ClearPassphrases(hDlg,gpp);
                                FreePassphrases(gpp);
                                *(options->mPassphraseKeyPtr) = key;
                                EndDialog (hDlg,
                                		kPGPError_KeyUnusableForSignatu
re);
                                break;
                            }
 
                            if(PassphraseLengthAndQualityOK(options,
                            		gpp->pszPass
Phrase))
                            {
                                if (!options->mVerifyPassphrase)
                                {
                                    ClearPassphrases(hDlg,gpp);
                                    EndDialog (hDlg, kPGPError_NoErr);
                                    break;
                                }
 
                                err=ValidateSigningPhrase(hDlg,gpp,
                                			gpp->pszPassPhrase,key);
 
                                if(IsntPGPError(err))
                                {
                                    ClearPassphrases(hDlg,gpp);
                                    EndDialog (hDlg, kPGPError_NoErr);
                                    break;
                                }
                            }
 
                            // Bad passphrase/quality
                            ClearPassphrases(hDlg,gpp);
                            FreePassphrases(gpp);
                            break;
                        }
                    }
 
                    // Couldn't allocate passphrases
                    ClearPassphrases(hDlg,gpp);
                    FreePassphrases(gpp);
                    EndDialog (hDlg, kPGPError_OutOfMemory);
                    break;
                }
 
                case IDC_SIGNKEYCOMBO :
                {
                    if(HIWORD(wParam)==CBN_SELCHANGE)
                        EnablePassPhraseControl (hDlg);
                    break;
                }
            }
        }
        break;
    }
    return FALSE;
}
#endif