📄 pgprpcserver.c

📁 可以实现对邮件的加密解密以及签名
💻 C
📖 第 1 页 / 共 4 页
字号:
上一页 1 2 34
	rpkt->status = err;
	if (IsPGPError(err)) return;

	pack_uint32(rpkt, kdbid);
	pack_uint32(rpkt, numKeys);
	pack_opaque(rpkt, keyArray, keyArraySize);
	if( IsntNull( keyArray ) )
		PGPFreeData( keyArray );
}

static void
sRecv_NewKeyDB(PGPPackMsg *pkt, PGPPackMsg *rpkt)
{
	PGPError err;
	PGPUInt32 keydbid;

	(void) pkt;
	
	err = pgpNewKeyDB_back(gCtx, &keydbid);
	rpkt->status = err;
	if (IsPGPError(err)) return;

	pack_uint32(rpkt, keydbid);

	rpkt->status = err;
}

static void
sRecv_KeyDBArray(PGPPackMsg *pkt, PGPPackMsg *rpkt)
{
	PGPError err;
	PGPUInt32 kdbid;
	PGPUInt32 numKeys;
	PGPUInt32 *keyArray;
	PGPSize keyArraySize;

	kdbid = unpack_uint32(pkt);

	err = pgpKeyDBArray_back(gCtx, kdbid, &numKeys, &keyArray, &keyArraySize);
	rpkt->status = err;
	if (IsPGPError(err)) return;

	pack_uint32(rpkt, numKeys);
	pack_opaque(rpkt, keyArray, keyArraySize);
	if( IsntNull( keyArray ) )
		PGPFreeData( keyArray );
}

static void
sRecv_UpdateKeyDB(PGPPackMsg *pkt, PGPPackMsg *rpkt)
{
	PGPError err;
	PGPUInt32 kdbid;
	PGPUInt32 numKeys;
	PGPUInt32 *keyArray;
	PGPSize keyArraySize;
	PGPUInt32 *changedkeylist;
	PGPSize changedkeylistsize;

	kdbid = unpack_uint32(pkt);

	err = pgpUpdateKeyDB_back(gCtx, kdbid, &numKeys, &keyArray, &keyArraySize,
							  &changedkeylist, &changedkeylistsize);
	rpkt->status = err;
	if (IsPGPError(err)) return;

	pack_uint32(rpkt, numKeys);
	pack_opaque(rpkt, keyArray, keyArraySize);
	if( IsntNull( keyArray ) )
		PGPFreeData( keyArray );
	pack_opaque(rpkt, changedkeylist, changedkeylistsize);
	if( IsntNull( changedkeylist ) )
		PGPFreeData( changedkeylist );
}

static void
sRecv_SecProperties(PGPPackMsg *pkt, PGPPackMsg *rpkt)
{
	PGPError err;
	PGPUInt32 id;
	PGPBoolean needsPassphrase;
	PGPBoolean isSecretShared;
	PGPCipherAlgorithm lockAlg;
	PGPUInt32 lockBits;

	id = unpack_uint32(pkt);

	err = pgpSecProperties_back(gCtx, id,
		&needsPassphrase, &isSecretShared, &lockAlg, &lockBits);
	rpkt->status = err;
	if (IsPGPError(err)) return;

	pack_bool(rpkt, needsPassphrase);
	pack_bool(rpkt, isSecretShared);
	pack_uint32(rpkt, lockAlg);
	pack_uint32(rpkt, lockBits);
}

static void
sRecv_GlobalRandomPoolAddState(PGPPackMsg *pkt, PGPPackMsg *rpkt)
{
	PGPError err;
	PGPBoolean addKeyState;
	PGPInt32 keyEvent;
	PGPBoolean addMouseState, addSystemState;

	addKeyState = unpack_bool(pkt);
	keyEvent = unpack_int32(pkt);
	addMouseState = unpack_bool(pkt);
	addSystemState = unpack_bool(pkt);

	err = pgpGlobalRandomPoolAddState_back(addKeyState,
		keyEvent, addMouseState, addSystemState );
	rpkt->status = err;
	if (IsPGPError(err)) return;
}

static void
sRecv_GlobalRandomPoolGetInfo(PGPPackMsg *pkt, PGPPackMsg *rpkt)
{
	PGPError err;
	PGPUInt32 entropy, size, minEntropy;
	PGPBoolean hasMinEntropy, hasIntelRNG;

	(void) pkt;
	err = pgpGlobalRandomPoolGetInfo_back(&entropy, &size,
		&minEntropy, &hasMinEntropy, &hasIntelRNG );
	rpkt->status = err;
	if (IsPGPError(err)) return;

	pack_uint32(rpkt, entropy);
	pack_uint32(rpkt, size);
	pack_uint32(rpkt, minEntropy);
	pack_bool(rpkt, hasMinEntropy);
	pack_bool(rpkt, hasIntelRNG);
}

static void
sRecv_RandomGetBytesEntropy(PGPPackMsg *pkt, PGPPackMsg *rpkt)
{
	PGPError err;
	PGPUInt32 requestBytes, entropyBits;
	PGPByte *randBuf;
	PGPSize randBufLen;

	requestBytes = unpack_uint32(pkt);
	entropyBits = unpack_uint32(pkt);

	err = pgpRandomGetBytesEntropy_back(gCtx,
		requestBytes, entropyBits,
		&randBuf, &randBufLen);
	rpkt->status = err;
	if (IsPGPError(err)) return;

	pack_opaque(rpkt, randBuf, randBufLen);
	if( IsntNull( randBuf ) )
		PGPFreeData(randBuf);
}

static void
sRecv_RandomAddBytes(PGPPackMsg *pkt, PGPPackMsg *rpkt)
{
	PGPError err;
	PGPByte *buf;
	PGPSize buflen;

	unpack_opaque(pkt, (void **) &buf, &buflen);

	err = pgpRandomAddBytes_back(gCtx, buf, buflen);
	rpkt->status = err;
}

static void
sRecv_RandomStir(PGPPackMsg *pkt, PGPPackMsg *rpkt)
{
	PGPError err;

	err = pgpRandomStir_back(gCtx);
	rpkt->status = err;
}

static void
sRecv_SetRandSeedFile(PGPPackMsg *pkt, PGPPackMsg *rpkt)
{
	PGPError err;
	PFLFileSpecRef randFile;
	
	randFile = unpack_filespec(pkt, PGPPeekContextMemoryMgr(gCtx) );

	err = pgpSetRandSeedFile_back( randFile );
	rpkt->status = err;

	if(PFLFileSpecRefIsValid(randFile))
		PFLFreeFileSpec(randFile);
}

PGPUInt32 pgpRPCAllocConnection()
{
	PGPMemoryMgrRef memref;
	struct connection *cp;

	memref = PGPGetDefaultMemoryMgr();
	if (memref == kInvalidPGPMemoryMgrRef)
		return kPGPError_UnknownError;

	cp = PGPNewData(memref, sizeof(pgpRPCconnection), kPGPMemoryMgrFlags_Clear);
	return (PGPUInt32)cp;
}


/* Handle user-initiated server shutdown */
void pgpRPCServerShuttingDown()  {
	DbgPrintf("cleaning up SDK...\n");

	PGPsdkCleanup();

	DbgPrintf("SDK cleanup done\n");
}

void
rcv_generic(PGPByte buf[], PGPSize inlen, PGPByte *outbuf[], PGPSize *outlen)
{
	PGPPackMsg pkt, rmsg;
	(void)inlen;
	
	pkt.ptr = 0;
	pkt.length = 0;
	pkt.base = buf;

	pkt.type = unpack_int32(&pkt);
	pkt.connect_ref = unpack_int32(&pkt);
	pkt.length = unpack_int32(&pkt);

	PGPGetRPCInitBuf((void **) &rmsg.base, &rmsg.length);
	rmsg.ptr = 8;
	rmsg.status = 0;

	/* Save connection ref into backend context */
	if( IsntNull( gCtx ) )
		pgpContextSetConnectRef( gCtx, (PGPConnectRef) pkt.connect_ref );

#if PGP_DEBUG && PGP_WIN32
	{
		extern char *pgpRPC_cmds[];
		DbgPrintf("%-35s %08x %5d",
			pgpRPC_cmds[pkt.type],
			pkt.connect_ref,
			pkt.length );
	}
#endif
#if PGP_DEBUG && PGP_UNIX
	{
		extern char *pgpRPC_cmds[];
		extern int debug;
		if (debug) {
			printf("%-35s %08x %5d",
				pgpRPC_cmds[pkt.type],
				pkt.connect_ref,
				pkt.length );
			fflush(stdout);
		}
	}
#endif

	switch(pkt.type) {
	case kPGP_Connect_MSG:
		sRecv_Connect(&pkt, &rmsg);
		break;
	case kPGP_Disconnect_MSG:
		sRecv_Disconnect(&pkt, &rmsg);
		break;
	case kPGP_Reconnect_MSG:
		sRecv_Reconnect(&pkt, &rmsg);
		break;
	case kPGP_FetchObjectData_MSG:
		sRecv_FetchObjectData(&pkt, &rmsg);
		break;
	case kPGP_GetKeyByKeyID_MSG:
		sRecv_GetKeyByKeyID(&pkt, &rmsg);
		break;
	case kPGP_KeyEncrypt_MSG:
		sRecv_KeyEncrypt(&pkt, &rmsg);
		break;
	case kPGP_KeyDecrypt_MSG:
		sRecv_KeyDecrypt(&pkt, &rmsg);
		break;
	case kPGP_KeyVerify_MSG:
		sRecv_KeyVerify(&pkt, &rmsg);
		break;
	case kPGP_KeySign_MSG:
		sRecv_KeySign(&pkt, &rmsg);
		break;
	case kPGP_SecPassphraseOK_MSG:
		sRecv_SecPassphraseOK(&pkt, &rmsg);
		break;
	case kPGP_PurgePassphraseCache_MSG:
		sRecv_PurgePassphraseCache(&pkt, &rmsg);
		break;
	case kPGP_CountCachedPassphrases_MSG:
		sRecv_CountCachedPassphrases(&pkt, &rmsg);
		break;
	case kPGP_KeyMaxSizes_MSG:
		sRecv_KeyMaxSizes(&pkt, &rmsg);
		break;
	case kPGP_FetchKeyInfo_MSG:
		sRecv_FetchKeyInfo(&pkt, &rmsg);
		break;
	case kPGP_OpenKeyDBFile_MSG:
		sRecv_OpenKeyDBFile(&pkt, &rmsg);
		break;
	case kPGP_KeyDBFlush_MSG:
		sRecv_KeyDBFlush(&pkt, &rmsg);
		break;
	case kPGP_FreeKeyDB_MSG:
		sRecv_FreeKeyDB(&pkt, &rmsg);
		break;
	case kPGP_SetKeyEnabled_MSG:
		sRecv_SetKeyEnabled(&pkt, &rmsg);
		break;
	case kPGP_SetKeyAxiomatic_MSG:
		sRecv_SetKeyAxiomatic(&pkt, &rmsg);
		break;
	case kPGP_PropagateTrust_MSG:
		sRecv_PropagateTrust(&pkt, &rmsg);
		break;
	case kPGP_CheckKeyRingSigs_MSG:
		sRecv_CheckKeyRingSigs(&pkt, &rmsg);
		break;
	case kPGP_PrepareToCheckKeyRingSigs_MSG:
		sRecv_PrepareToCheckKeyRingSigs(&pkt, &rmsg);
		break;
	case kPGP_CheckSig_MSG:
		sRecv_CheckSig(&pkt, &rmsg);
		break;
	case kPGP_DoGenerateKey_MSG:
		sRecv_DoGenerateKey(&pkt, &rmsg);
		break;
	case kPGP_CreateKeypair_MSG:
		sRecv_CreateKeypair(&pkt, &rmsg);
		break;
	case kPGP_CreateSubkeypair_MSG:
		sRecv_CreateSubkeypair(&pkt, &rmsg);
		break;
	case kPGP_CountTokens_MSG:
		sRecv_CountTokens(&pkt, &rmsg);
		break;
    case kPGP_GetTokenInfo_MSG:
		sRecv_GetTokenInfo(&pkt, &rmsg);
		break;
	case kPGP_DeleteKeyOnToken_MSG:
		sRecv_DeleteKeyOnToken(&pkt, &rmsg);
		break;
	case kPGP_WipeToken_MSG:
		sRecv_WipeToken(&pkt, &rmsg);
		break;
	case kPGP_FormatToken_MSG:
		sRecv_FormatToken(&pkt, &rmsg);
		break;
	case kPGP_TokenPassphraseIsValid_MSG:
		sRecv_TokenPassphraseIsValid(&pkt, &rmsg);
		break;
	case kPGP_CopyKeyToToken_MSG:
		sRecv_CopyKeyToToken(&pkt, &rmsg);
		break;
    case kPGP_TokenImportX509_MSG:
        sRecv_TokenImportX509(&pkt, &rmsg);
        break;
    case kPGP_TokenPutKeyContainer_MSG:
        sRecv_TokenPutKeyContainer(&pkt, &rmsg);
        break;
    case kPGP_TokenGetKeyContainer_MSG:
        sRecv_TokenGetKeyContainer(&pkt, &rmsg);
        break;
    case kPGP_SetPKCS11DrvFile_MSG:
		sRecv_SetPKCS11DrvFile(&pkt, &rmsg);
		break;
	case kPGP_AddUserID_MSG:
		sRecv_AddUserID(&pkt, &rmsg);
		break;
	case kPGP_CertifyUserID_MSG:
		sRecv_CertifyUserID(&pkt, &rmsg);
		break;
	case kPGP_CertifyPrimaryUserID_MSG:
		sRecv_CertifyPrimaryUserID(&pkt, &rmsg);
		break;
	case kPGP_RevokeSig_MSG:
		sRecv_RevokeSig(&pkt, &rmsg);
		break;
	case kPGP_RevokeKey_MSG:
		sRecv_RevokeKey(&pkt, &rmsg);
		break;
	case kPGP_DoChangePassphrase_MSG:
		sRecv_DoChangePassphrase(&pkt, &rmsg);
		break;
	case kPGP_PassphraseIsValid_MSG:
		sRecv_PassphraseIsValid(&pkt, &rmsg);
		break;
	case kPGP_SetKeyTrust_MSG:
		sRecv_SetKeyTrust(&pkt, &rmsg);
		break;
	case kPGP_GetPasskeyBuffer_MSG:
		sRecv_GetPasskeyBuffer(&pkt, &rmsg);
		break;
	case kPGP_AddKeyOptions_MSG:
		sRecv_AddKeyOptions(&pkt, &rmsg);
		break;
	case kPGP_UpdateKeyOptions_MSG:
		sRecv_UpdateKeyOptions(&pkt, &rmsg);
		break;
	case kPGP_KeyDBAddObject_MSG:
		sRecv_KeyDBAddObject(&pkt, &rmsg);
		break;
	case kPGP_KeyDBRemoveObject_MSG:
		sRecv_KeyDBRemoveObject(&pkt, &rmsg);
		break;
	case kPGP_CopyKeys_MSG:
		sRecv_CopyKeys(&pkt, &rmsg);
		break;
	case kPGP_ImportKeyBinary_MSG:
		sRecv_ImportKeyBinary(&pkt, &rmsg);
		break;
	case kPGP_NewKeyDB_MSG:
		sRecv_NewKeyDB(&pkt, &rmsg);
		break;
	case kPGP_KeyDBArray_MSG:
		sRecv_KeyDBArray(&pkt, &rmsg);
		break;
	case kPGP_UpdateKeyDB_MSG:
		sRecv_UpdateKeyDB(&pkt, &rmsg);
		break;
	case kPGP_SecProperties_MSG:
		sRecv_SecProperties(&pkt, &rmsg);
		break;
	case kPGP_GlobalRandomPoolAddState_MSG:
		sRecv_GlobalRandomPoolAddState(&pkt, &rmsg);
		break;
	case kPGP_GlobalRandomPoolGetInfo_MSG:
		sRecv_GlobalRandomPoolGetInfo(&pkt, &rmsg);
		break;
	case kPGP_RandomGetBytesEntropy_MSG:
		sRecv_RandomGetBytesEntropy(&pkt, &rmsg);
		break;
	case kPGP_RandomAddBytes_MSG:
		sRecv_RandomAddBytes(&pkt, &rmsg);
		break;
	case kPGP_RandomStir_MSG:
		sRecv_RandomStir(&pkt, &rmsg);
		break;
	case kPGP_SetRandSeedFile_MSG:
		sRecv_SetRandSeedFile(&pkt, &rmsg);
		break;
	case kPGP_PurgeKeyDBCache_MSG:
		sRecv_PurgeKeyDBCache(&pkt, &rmsg);
		break;
	case kPGP_CacheKeyDB_MSG:
		sRecv_CacheKeyDB(&pkt, &rmsg);
		break;
	default:
		rmsg.status = kPGPError_RPCGarbledMsg;
	}

#if PGP_DEBUG && PGP_UNIX
	{
		extern int debug;
		if (debug) printf("  status=%d\n", rmsg.status);
	}
#endif

	*(PGPInt32 *)(&rmsg.base[0]) = rmsg.status;
	*(PGPInt32 *)(&rmsg.base[4]) = rmsg.ptr;
	*outlen = rmsg.ptr;
	*outbuf = rmsg.base;
}

#if PGP_DEBUG
char *pgpRPC_cmds[] = {
	"kPGP_Connect_MSG",
	"kPGP_FetchObjectData_MSG",
	"kPGP_GetKeyByKeyID_MSG",
	"kPGP_KeyEncrypt_MSG",
	"kPGP_KeyDecrypt_MSG",
	"kPGP_KeyVerify_MSG",
	"kPGP_KeySign_MSG",
	"kPGP_SecPassphraseOK_MSG",
	"kPGP_KeyMaxSizes_MSG",
	"kPGP_SecProperties_MSG",
	"kPGP_FetchKeyInfo_MSG",
	"kPGP_OpenKeyDBFile_MSG",
	"kPGP_ImportKeyBinary_MSG",
	"kPGP_KeyDBFlush_MSG",
	"kPGP_FreeKeyDB_MSG",
	"kPGP_SetKeyEnabled_MSG",
	"kPGP_SetKeyAxiomatic_MSG",
	"kPGP_PropagateTrust_MSG",
	"kPGP_CheckKeyRingSigs_MSG",
	"kPGP_PrepareToCheckKeyRingSigs_MSG",
	"kPGP_CheckSig_MSG",
	"kPGP_DoGenerateKey_MSG",
	"kPGP_AddUserID_MSG",
	"kPGP_CertifyUserID_MSG",
	"kPGP_CertifyPrimaryUserID_MSG",
	"kPGP_RevokeSig_MSG",
	"kPGP_RevokeKey_MSG",
	"kPGP_DoChangePassphrase_MSG",
	"kPGP_PassphraseIsValid_MSG",
	"kPGP_SetKeyTrust_MSG",
	"kPGP_GetPasskeyBuffer_MSG",
	"kPGP_AddKeyOptions_MSG",
	"kPGP_UpdateKeyOptions_MSG",
	"kPGP_KeyDBAddObject_MSG",
	"kPGP_KeyDBRemoveObject_MSG",
	"kPGP_NewKeyDB_MSG",
	"kPGP_KeyDBArray_MSG",
	"kPGP_GlobalRandomPoolAddState_MSG",
	"kPGP_GlobalRandomPoolGetInfo_MSG",
	"kPGP_RandomGetBytesEntropy_MSG",
	"kPGP_UpdateKeyDB_MSG",
	"kPGP_RandomAddBytes_MSG",
	"kPGP_PurgePassphraseCache_MSG",
	"kPGP_CopyKeys_MSG",
	"kPGP_SetRandSeedFile_MSG",
	"kPGP_Disconnect_MSG",
	"kPGP_Reconnect_MSG",
	"kPGP_RandomStir_MSG",
	"kPGP_CreateKeypair_MSG",
	"kPGP_CreateSubkeypair_MSG",
	"kPGP_CountTokens_MSG",
	"kPGP_GetTokenInfo_MSG",
	"kPGP_CopyKeyToToken_MSG",
	"kPGP_DeleteKeyOnToken_MSG",
	"kPGP_WipeToken_MSG",
	"kPGP_TokenPassphraseIsValid_MSG",
    "kPGP_TokenImportX509_MSG", 
    "kPGP_TokenPutKeyContainer_MSG", 
    "kPGP_TokenGetKeyContainer_MSG", 
    "kPGP_SetPKCS11DrvFile_MSG", 
	"kPGP_FormatToken_MSG",
	"kPGP_PurgeKeyDBCache_MSG",
	"kPGP_CacheKeyDB_MSG",
	"kPGP_CountCachedPassphrases_MSG",
};
#endif

/*__Editor_settings____

	Local Variables:
	tab-width: 4
	End:
	vi: ts=4 sw=4
	vim: si
_____________________*/
上一页 1 2 34
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -