clrecon.c

vc环境下的pgp源码

	prks = (PRECONKEYSTRUCT)userValue;

	uID = 0;

	switch (event->type) {
	case kPGPskepEvent_ConnectEvent :
		uID = IDS_STATUSCONNECTED;
		break;

	case kPGPskepEvent_AuthenticateEvent :
		if (event->data.ad.remoteHostname)
			psz = (LPSTR)event->data.ad.remoteHostname;
		else if (event->data.ad.remoteIPAddress)
			psz = (LPSTR)event->data.ad.remoteIPAddress;
		else {
			LoadString (g_hInst, IDS_UNIDENTIFIEDHOST, sz, sizeof(sz));
			psz = sz;
		}

		if (IsntPGPError (PGPclConfirmRemoteAuthentication (
								prks->context,
								prks->hwndDlg, 
								psz, 
								event->data.ad.remoteKey,
								event->data.ad.tlsCipher,
								prks->keyset,
								PGPCL_AUTHRECONSTITUTING))) 
		{
			uID = IDS_STATUSAUTHENTICATED;
			if (IsntPGPError (PGPGetPrimaryUserIDNameBuffer (
						event->data.ad.remoteKey, kPGPMaxUserIDSize, 
						prks->szAuthUserID, &u))) {
				SetDlgItemText (prks->hwndDlg, 
							IDC_AUTHENTICATION, prks->szAuthUserID);
			}
		}
		else
		{
			bCancel = TRUE;
			uID = IDS_STATUSLISTENING;
		}
		break;

	case kPGPskepEvent_ShareEvent:
		{
			PGPShareRef			shares;
			PGPShareRef			sharesTemp;
			UINT				uNumShares;
			UINT				uThreshold;
			PGPError			err = kPGPError_NoErr;
			PGPKeyID			keyid;
		
			shares = event->data.sd.shares;
			EnterCriticalSection (&prks->critsecAddShare);
			
			uNumShares = PGPGetNumberOfShares (shares);
			
			// check that shares belong to this key
			err = PGPGetKeyIDFromShares (shares, &keyid);
			if (IsPGPError (err)) goto NetContinue;
			
			if (PGPCompareKeyIDs (&keyid, &(prks->keyidToReconstitute))) {
				PGPclMessageBox (prks->hwndDlg, IDS_CAPTION, 
					IDS_SHAREKEYMISMATCH, MB_OK|MB_ICONEXCLAMATION);
				goto NetContinue;
			}
			
			// check that threshold corresponds to other share files
			uThreshold = PGPGetShareThreshold (shares);
			if (prks->uNeededShares != UNKNOWN_SHARES_NEEDED) {
				if (uThreshold != prks->uNeededShares) {
					PGPclMessageBox (prks->hwndDlg, IDS_CAPTION, 
						IDS_SHARENUMMISMATCH, MB_OK|MB_ICONEXCLAMATION);
					goto NetContinue;
				}
			}
			
			// add shares to collection
			if (prks->sharesCombined) {
				err = PGPCombineShares (shares, 
					prks->sharesCombined, &sharesTemp);
				if (IsPGPError (err)) goto NetContinue;
				PGPFreeShares (prks->sharesCombined);
				prks->sharesCombined = sharesTemp;
			}
			else {
				prks->sharesCombined = shares;
				shares = NULL;
			}
			
			// share is OK, add it to list
			prks->uNeededShares = uThreshold;
			SetDlgItemInt (prks->hwndDlg, IDC_SHARESNEEDED, 
				prks->uNeededShares, FALSE);
			
			prks->uCollectedShares += uNumShares;
			SetDlgItemInt (prks->hwndDlg, IDC_SHARESCOLLECTED, 
				prks->uCollectedShares, FALSE);
			sAddShareHolderToList (prks, prks->szAuthUserID, uNumShares);
			
			if (prks->uCollectedShares >= prks->uNeededShares)
				EnableWindow (GetDlgItem (prks->hwndDlg, IDOK), TRUE);

NetContinue:
			LeaveCriticalSection (&prks->critsecAddShare);
		
			if (shares)
				PGPFreeShares (shares);
			PGPclErrorBox (prks->hwndDlg, err);
			uID = IDS_STATUSLISTENING;
		}
		break;

	case kPGPskepEvent_ProgressEvent :
		uID = IDS_STATUSRECEIVING;
		break;

	case kPGPskepEvent_CloseEvent :
		uID = IDS_STATUSCLOSING;
		SetDlgItemText (prks->hwndDlg, IDC_AUTHENTICATION, "");
		break;

	}

	if (uID != 0) {
		LoadString (g_hInst, uID, sz, sizeof(sz));
		SetDlgItemText (prks->hwndDlg, IDC_STATUS, sz);
	}

	if (prks->bStop || bCancel)
		return kPGPError_UserAbort;
	else
		return kPGPError_NoErr;
}


//	______________________________________________
//
// thread for actually receiving the shares

static DWORD WINAPI 
sNetworkThreadRoutine (LPVOID lpvoid)
{
	PRECONKEYSTRUCT		prks		= (PRECONKEYSTRUCT)lpvoid;
	PGPError			err;
	CHAR				sz[64];

	err = PGPskepSetEventHandler (prks->skep,
					(PGPskepEventHandler)sHandlerSKEP, (PGPUserValue)prks);

	do
	{
		LoadString (g_hInst, IDS_STATUSLISTENING, sz, sizeof(sz));
		SetDlgItemText (prks->hwndDlg, IDC_STATUS, sz);

		err = PGPskepReceiveShares (prks->skep,
									prks->keyAuthenticating,
									prks->pszPhraseAuth);

		if (err != kPGPError_UserAbort)
			PGPclErrorBox (prks->hwndDlg, err);

		SetDlgItemText (prks->hwndDlg, IDC_AUTHENTICATION, "");
	}
	while (err == kPGPClientError_RejectedSKEPAuthentication);

	LoadString (g_hInst, IDS_STATUSNOTCONNECTED, sz, sizeof(sz));
	SetDlgItemText (prks->hwndDlg, IDC_STATUS, sz);

	PostMessage (prks->hwndDlg, WM_APP, 0, 0);

	return 0;
}


//	______________________________________________
//
//	Reconstitute key dialog message procedure

static BOOL CALLBACK 
sReconKeyDlgProc (
		HWND	hDlg, 
		UINT	uMsg, 
		WPARAM	wParam, 
		LPARAM	lParam) 
{
	PRECONKEYSTRUCT		prks;
	CHAR				sz[kPGPMaxUserIDSize];
	DWORD				dw;
	PGPError			err;

	switch (uMsg) {

	case WM_INITDIALOG :
	{
		CHAR		szTitle[kPGPMaxUserIDSize + 32];
		PGPUInt32	size;

		// save address of struct
		SetWindowLong (hDlg, GWL_USERDATA, lParam);
		prks = (PRECONKEYSTRUCT)lParam;
		prks->hwndDlg = hDlg;

		// initialize shareholder list
		prks->hwndList = GetDlgItem (hDlg, IDC_SHAREHOLDERS);
		sInitKeyList (prks);

		// initialize name of key to reconstitute
		LoadString (g_hInst, IDS_RECONKEYTITLE, szTitle, sizeof(szTitle));
		PGPGetPrimaryUserIDNameBuffer (prks->keyToReconstitute, 
										sizeof(sz), sz, &size);
		SetDlgItemText (hDlg, IDC_KEYTORECON, sz);
		lstrcat (szTitle, sz);
		SetWindowText (hDlg, szTitle);

		// initialize numbers of shares
		SetDlgItemText (hDlg, IDC_SHARESNEEDED, "?");
		SetDlgItemInt (hDlg, IDC_SHARESCOLLECTED, 
											prks->uCollectedShares, FALSE);

		// initialize Network controls
		LoadString (g_hInst, IDS_STARTNETWORK, sz, sizeof(sz));
		SetDlgItemText (hDlg, IDC_NETWORK, sz);
		ShowWindow (GetDlgItem (hDlg, IDC_STATUS), SW_HIDE);
		ShowWindow (GetDlgItem (hDlg, IDC_STATUSTEXT), SW_HIDE);
		ShowWindow (GetDlgItem (hDlg, IDC_AUTHENTICATION), SW_HIDE);
		ShowWindow (GetDlgItem (hDlg, IDC_AUTHENTICATIONTEXT), SW_HIDE);
		ShowWindow (GetDlgItem (hDlg, IDC_NETWORKINSTRUCTIONS), SW_SHOW);

		// OK button is initially disabled
		EnableWindow (GetDlgItem (hDlg, IDOK), FALSE);

		return TRUE;
	}

	case WM_HELP: 
	    WinHelp (((LPHELPINFO) lParam)->hItemHandle, g_szHelpFile, 
	        HELP_WM_HELP, (DWORD) (LPSTR) aIds); 
	    break; 

	case WM_CONTEXTMENU: 
		WinHelp ((HWND) wParam, g_szHelpFile, HELP_CONTEXTMENU, 
		    (DWORD) (LPVOID) aIds); 
		break; 

	case WM_DESTROY :
		prks = (PRECONKEYSTRUCT)GetWindowLong (hDlg, GWL_USERDATA);
		ImageList_Destroy (prks->hIml);
		break;

	case WM_APP :
		prks = (PRECONKEYSTRUCT)GetWindowLong (hDlg, GWL_USERDATA);

		// event signaling end of thread
		if (prks->skep != NULL)
		{
			PGPFreeSKEP (prks->skep);
			prks->skep = NULL;
		}

		// reset controls
		prks->bServerMode = FALSE;
		LoadString (g_hInst, IDS_STARTNETWORK, sz, sizeof(sz));
		SetDlgItemText (hDlg, IDC_NETWORK, sz);
		ShowWindow (GetDlgItem (hDlg, IDC_STATUS), SW_HIDE);
		ShowWindow (GetDlgItem (hDlg, IDC_STATUSTEXT), SW_HIDE);
		ShowWindow (GetDlgItem (hDlg, IDC_AUTHENTICATION), SW_HIDE);
		ShowWindow (GetDlgItem (hDlg, IDC_AUTHENTICATIONTEXT), SW_HIDE);
		ShowWindow (
					GetDlgItem (hDlg, IDC_NETWORKINSTRUCTIONS), SW_SHOW);

		if (prks->uCollectedShares >= prks->uNeededShares)
			EnableWindow (GetDlgItem (hDlg, IDOK), TRUE);

		if (prks->bUserCancel)
			EndDialog (hDlg, 0);
		if (prks->bUserOK)
			EndDialog (hDlg, 1);
		break;

	case WM_COMMAND:

		switch (LOWORD(wParam)) {
		case IDCANCEL :
			prks = (PRECONKEYSTRUCT)GetWindowLong (hDlg, GWL_USERDATA);
			if (prks->bServerMode) {
				prks->bStop = TRUE;
				prks->bUserCancel = TRUE;
				if (prks->skep != NULL)
					PGPskepCancel (prks->skep);
			}
			else {
				EndDialog (hDlg, 0);
			}
			break;

		case IDOK :
			prks = (PRECONKEYSTRUCT)GetWindowLong (hDlg, GWL_USERDATA);
			if (prks->bServerMode) {
				prks->bStop = TRUE;
				prks->bUserOK = TRUE;
				if (prks->skep != NULL)
					PGPskepCancel (prks->skep);
			}
			else {
				EndDialog (hDlg, 1);
			}
			break;

		case IDC_NETWORK :
			prks = (PRECONKEYSTRUCT)GetWindowLong (hDlg, GWL_USERDATA);
			prks->bServerMode = !prks->bServerMode;

			if (prks->bServerMode) {
				// if this is a retry, free phrase and passkey
				if (prks->pszPhraseAuth) {
					KMFreePhrase (prks->pszPhraseAuth);
					prks->pszPhraseAuth = NULL;
				}
				if (prks->pPasskeyAuth) {
					KMFreePasskey (prks->pPasskeyAuth,prks->sizePasskeyAuth);
					prks->pPasskeyAuth = NULL;
				}

				// get authentication key and phrase
				LoadString (g_hInst, IDS_RECONAUTHPROMPT, sz, sizeof(sz));
				err = KMGetSigningKeyPhrase (prks->context, 
						prks->tlsContext, hDlg, sz, 
						prks->keyset, TRUE, &(prks->keyAuthenticating),
						&(prks->pszPhraseAuth), &(prks->pPasskeyAuth),
						&(prks->sizePasskeyAuth));
				if (IsPGPError (err))
				{
					prks->bServerMode = FALSE;
					break;
				}

				// setup controls
				LoadString (g_hInst, IDS_STOPNETWORK, sz, sizeof(sz));
				SetDlgItemText (hDlg, IDC_NETWORK, sz);
				ShowWindow (GetDlgItem (hDlg, IDC_STATUS), SW_SHOW);
				ShowWindow (GetDlgItem (hDlg, IDC_STATUSTEXT), SW_SHOW);
				ShowWindow (GetDlgItem (hDlg, IDC_AUTHENTICATION), SW_SHOW);
				ShowWindow (
					GetDlgItem (hDlg, IDC_AUTHENTICATIONTEXT), SW_SHOW);
				ShowWindow (
					GetDlgItem (hDlg, IDC_NETWORKINSTRUCTIONS), SW_HIDE);

				SetDlgItemText (hDlg, IDC_STATUS, "");
				SetDlgItemText (hDlg, IDC_AUTHENTICATION, "");

				EnableWindow (GetDlgItem (hDlg, IDOK), FALSE);

				// start the thread
				prks->bStop = FALSE;
				PGPNewSKEP (prks->context, prks->tlsContext, &prks->skep);
				CreateThread (NULL, 0, sNetworkThreadRoutine, prks, 0, &dw);
			}
			else {
				// set flag which will stop thread
				prks->bStop = TRUE;
				if (prks->skep != NULL)
					PGPskepCancel (prks->skep);
			}

			// change the help ID based on if the button says start or stop
			if (prks->bServerMode) {
				aIds[1] = IDH_PGPCLRECON_STOPNETWORK;
			}
			else {
				aIds[1] = IDH_PGPCLRECON_STARTNETWORK;
			}

			break;

		case IDC_SHAREFILE :
			prks = (PRECONKEYSTRUCT)GetWindowLong (hDlg, GWL_USERDATA);
			sAddShareFile (hDlg, prks);
			if (prks->uCollectedShares >= prks->uNeededShares)
				EnableWindow (GetDlgItem (hDlg, IDOK), TRUE);
			break;

		}
		return TRUE;
	}
	return FALSE;
}


//	______________________________________________
//
//  Reconstitute specified key

PGPError PGPclExport
PGPclReconstituteKey (
		PGPContextRef		context,
		PGPtlsContextRef	tlsContext,
		HWND				hwnd,
		PGPKeySetRef		keyset,
		PGPKeyRef			key,
		PGPByte**			ppPasskey,
		PGPUInt32*			piPasskeyLength) 
{
	RECONKEYSTRUCT		rks;
	PGPError			err;

	// initialize struct
	rks.context				= context;
	rks.tlsContext			= tlsContext;
	rks.keyset				= keyset;
	rks.keyToReconstitute	= key;
	PGPGetKeyIDFromKey (key, &(rks.keyidToReconstitute));
	rks.uCollectedShares	= 0;
	rks.uNeededShares		= UNKNOWN_SHARES_NEEDED;
	rks.sharesCombined		= NULL;
	rks.bServerMode			= FALSE;
	rks.bUserCancel			= FALSE;
	rks.bUserOK				= FALSE;
	rks.bBadPassphrase		= FALSE;
	rks.pszPhraseAuth		= NULL;
	rks.pPasskeyAuth		= NULL;
	rks.skep				= NULL;
	rks.iIconIndex			= -1;

	InitializeCriticalSection (&rks.critsecAddShare);

	do {
		if (DialogBoxParam (g_hInst, MAKEINTRESOURCE (IDD_RECONSTITUTEKEY), 
			hwnd, sReconKeyDlgProc, (LPARAM)&rks)) {
			err = PGPGetPasskeyFromShares (rks.sharesCombined, 
							ppPasskey, piPasskeyLength);
			PGPclErrorBox (hwnd, err);

			if (!PGPPassphraseIsValid (key, 
					PGPOPasskeyBuffer (context, 
								*ppPasskey, *piPasskeyLength),
					PGPOLastOption (context))) {
				PGPclMessageBox (hwnd, IDS_CAPTION, IDS_BADPASSKEY, 
									MB_OK|MB_ICONSTOP);
				err = kPGPError_BadPassphrase;
			}
		}
		else {
			*ppPasskey = NULL;
			*piPasskeyLength = 0;
			err = kPGPError_UserAbort;
		}
	} while (err == kPGPError_BadPassphrase);

	DeleteCriticalSection (&rks.critsecAddShare);

	if (rks.sharesCombined)
		PGPFreeShares (rks.sharesCombined);

	if (rks.pszPhraseAuth)
		KMFreePhrase (rks.pszPhraseAuth);

	if (rks.pPasskeyAuth)
		KMFreePasskey (rks.pPasskeyAuth, rks.sizePasskeyAuth);

	return err;
}