From 7aff1e4cb053394db57c2814d5fe1e6493e0cc75 Mon Sep 17 00:00:00 2001 From: watcherhd Date: Sat, 26 Nov 2011 14:19:43 +0000 Subject: Project folders rename part 2 git-svn-id: http://miranda-plugins.googlecode.com/svn/trunk@214 e753b5eb-9565-29b2-b5c5-2cc6f99dfbcb --- CryptoPP/PGPw/main.cpp | 584 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 584 insertions(+) create mode 100644 CryptoPP/PGPw/main.cpp (limited to 'CryptoPP/PGPw/main.cpp') diff --git a/CryptoPP/PGPw/main.cpp b/CryptoPP/PGPw/main.cpp new file mode 100644 index 0000000..116615b --- /dev/null +++ b/CryptoPP/PGPw/main.cpp @@ -0,0 +1,584 @@ +#include "commonheaders.h" + +// pgpsdk.lib pgpsdknl.lib pgpsdkui.lib libcmt.lib +// /delayload:pgpsdk.dll,pgpsdknl.dll,pgpsdkui.dll + +PGPContextRef pgpContext; +#if (PGP_WIN32 < 0x700) +PGPKeySetRef pgpKeyDB = 0; +#else +PGPKeyDBRef pgpKeyDB = 0; +#endif +LPSTR pszPassphrase = 0; +LPSTR pgpErrMsg = 0; +#define pgpErrMsgLen 512 +UINT pgpVer; + + +void ClearPGPError() +{ + *pgpErrMsg = '\0'; +} + + +bool CheckPGPError(PGPError err) +{ + if (IsPGPError(err)) { + PGPSize ErrMsgLen = pgpErrMsgLen; + PGPGetErrorString(err, ErrMsgLen, pgpErrMsg); + return 1; + } + else { + *pgpErrMsg = '\0'; + return 0; + } +} + +#define _pgp_memcpy memmove +/* +void _pgp_memcpy(LPSTR dst, LPSTR src, UINT size) +{ + for(UINT i=0;i> 12; + switch(PGPMajorVersion(pgpVer)) { + case 2: + pgpVer = 1<<24 | ((minor+1)<<16) | (PGPRevVersion(pgpVer)<<8); + break; + case 3: + pgpVer = 1<<24 | ((minor+5)<<16) | (PGPRevVersion(pgpVer)<<8); + break; + default: + pgpVer = 1<<24 | (minor<<16) | (PGPRevVersion(pgpVer)<<8); + break; + } +#else + pgpVer = PGPGetPGPsdkVersion(); +#endif + + return 1; +} + + +int __cdecl _pgp_done() +{ + pgpVer = 0; + __try { + if(pgpErrMsg) LocalFree(pgpErrMsg); + if (pszPassphrase) PGPFreeData(pszPassphrase); +#if (PGP_WIN32 < 0x700) + if (pgpKeyDB) PGPFreeKeySet(pgpKeyDB); +#else + if (pgpKeyDB) PGPFreeKeyDB(pgpKeyDB); +#endif + PGPFreeContext(pgpContext); + PGPsdkUILibCleanup(); + PGPsdkCleanup(); + pszPassphrase = pgpErrMsg = 0; + pgpKeyDB = 0; + pgpContext = 0; + } + __except ( EXCEPTION_EXECUTE_HANDLER ) { + return 0; + } + return 1; +} + + +int __cdecl _pgp_open_keyrings(LPSTR PubRingPath, LPSTR SecRingPath) +{ + _pgp_close_keyrings(); + +#if (PGP_WIN32 < 0x700) + PGPError err = PGPOpenDefaultKeyRings(pgpContext, kPGPKeyRingOpenFlags_None, &pgpKeyDB); +#else + if ((!PubRingPath || !*PubRingPath) && !ShowSelectKeyringsDlg(0,PubRingPath,SecRingPath)) { + return 0; + } + + PGPFileSpecRef PubKeyRing, SecKeyRing; + PGPNewFileSpecFromFullPath(pgpContext, PubRingPath, &PubKeyRing); + PGPNewFileSpecFromFullPath(pgpContext, SecRingPath, &SecKeyRing); + + PGPError err = PGPOpenKeyDBFile(pgpContext, kPGPOpenKeyDBFileOptions_None, PubKeyRing, SecKeyRing, &pgpKeyDB); + PGPFreeFileSpec(SecKeyRing); + PGPFreeFileSpec(PubKeyRing); +#endif + if (CheckPGPError(err)) { + return 0; + } + return 1; +} + + +int __cdecl _pgp_close_keyrings() +{ +#if (PGP_WIN32 < 0x700) + if (pgpKeyDB) { + PGPFreeKeySet(pgpKeyDB); + pgpKeyDB = 0; + } +#else + if (pgpKeyDB) { + PGPFreeKeyDB(pgpKeyDB); + pgpKeyDB = 0; + } +#endif + return 1; +} + + +int __cdecl _pgp_get_version() +{ + return pgpVer; +} + + +LPSTR __cdecl _pgp_get_error() +{ + return pgpErrMsg; +} + + +LPSTR __cdecl _pgp_encrypt_keydb(LPCSTR szPlainMsg, PVOID pgpKeyID) +{ + PGPKeyID *RemoteKeyID = (PGPKeyID *) pgpKeyID; + LPSTR szEncMsg = 0; + DWORD dwEncMsgLen; + + ClearPGPError(); + if(!pgpKeyDB) + return 0; + +#if (PGP_WIN32 < 0x700) + PGPFilterRef IDFilter; + PGPNewKeyIDFilter(pgpContext, RemoteKeyID, &IDFilter); + + PGPKeySetRef PublicKey; + PGPFilterKeySet(pgpKeyDB, IDFilter, &PublicKey); +#else + PGPKeyDBObjRef PublicKey; + PGPFindKeyByKeyID(pgpKeyDB, RemoteKeyID, &PublicKey); +#endif + + PGPError err = PGPEncode(pgpContext, + PGPOInputBuffer(pgpContext, szPlainMsg, lstrlen(szPlainMsg)), + PGPOArmorOutput(pgpContext, TRUE), + PGPOAllocatedOutputBuffer(pgpContext, (LPVOID *)&szEncMsg, 16384, (PGPUInt32 *)&dwEncMsgLen), +#if (PGP_WIN32 < 0x700) + PGPOEncryptToKeySet(pgpContext, PublicKey), +#else + PGPOEncryptToKeyDBObj(pgpContext, PublicKey), +#endif + PGPOVersionString(pgpContext, szVersionStr), + PGPOLastOption(pgpContext)); + +#if (PGP_WIN32 < 0x700) + PGPFreeKeySet(PublicKey); + PGPFreeFilter(IDFilter); +#endif + + if (CheckPGPError(err)) + return 0; + + LPSTR szMsg = (LPSTR) LocalAlloc(LPTR,dwEncMsgLen+1); + _pgp_memcpy(szMsg, szEncMsg, dwEncMsgLen); + szMsg[dwEncMsgLen] = 0; + PGPFreeData((LPVOID)szEncMsg); + + return szMsg; +} + + +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; +} + + +#if (PGP_WIN32 < 0x700) +PGPError _pgp_import_key(PGPKeySetRef *keySet, LPCSTR pgpKey) +{ + return PGPImportKeySet( pgpContext, + keySet, + PGPOInputBuffer( pgpContext, + pgpKey, + lstrlen(pgpKey) ), + PGPOLastOption( pgpContext ) ); +} +#else +PGPError _pgp_import_key(PGPKeyDBRef *keyDB, LPCSTR pgpKey) +{ + return PGPImport( pgpContext, + keyDB, + PGPOInputBuffer( pgpContext, + pgpKey, + lstrlen(pgpKey) ), + PGPOLastOption( pgpContext ) ); +} +#endif + +/* +int __cdecl _pgp_check_key(LPCSTR pgpKey) +{ +#if (PGP_WIN32 < 0x700) + PGPKeySetRef PrivateKey; + if (CheckPGPError(_pgp_import_key(&PrivateKey,pgpKey))) + return 0; + PGPFreeKeySet(PrivateKey); +#else + PGPKeyDBRef PrivateKey; + if (CheckPGPError(_pgp_import_key(&PrivateKey,pgpKey))) + return 0; + PGPFreeKeyDB(PrivateKey); +#endif + return 1; +} +*/ + +LPSTR __cdecl _pgp_encrypt_key(LPCSTR szPlainMsg, LPCSTR pgpKey) +{ + LPSTR szEncMsg = 0; + DWORD dwEncMsgLen; + + PGPUInt32 dwKeys; +#if (PGP_WIN32 < 0x700) + PGPKeySetRef PublicKey; + if (CheckPGPError(_pgp_import_key(&PublicKey,pgpKey))) + return 0; + PGPCountKeys(PublicKey, &dwKeys); +#else + PGPKeyDBRef PublicKeyDB; + if (CheckPGPError(_pgp_import_key(&PublicKeyDB,pgpKey))) + return 0; + + PGPKeyIterRef KeyIterRef; + PGPNewKeyIterFromKeyDB(PublicKeyDB, &KeyIterRef); + + PGPKeyDBObjRef PublicKey; + PGPKeyIterNextKeyDBObj(KeyIterRef, kPGPKeyDBObjType_Key, &PublicKey); + + PGPCountKeysInKeyDB(PublicKeyDB, &dwKeys); +#endif + if(dwKeys==0) { +#if (PGP_WIN32 < 0x700) + PGPFreeKeySet(PublicKey); +#else + PGPFreeKeyIter(KeyIterRef); + PGPFreeKeyDB(PublicKeyDB); +#endif + return 0; + } + + PGPError err = PGPEncode(pgpContext, + PGPOInputBuffer(pgpContext, szPlainMsg, lstrlen(szPlainMsg)), + PGPOArmorOutput(pgpContext, TRUE), + PGPOAllocatedOutputBuffer(pgpContext, (LPVOID *)&szEncMsg, 16384, (PGPUInt32 *)&dwEncMsgLen), +#if (PGP_WIN32 < 0x700) + PGPOEncryptToKeySet(pgpContext, PublicKey), +#else + PGPOEncryptToKeyDBObj(pgpContext, PublicKey), +#endif + PGPOVersionString(pgpContext, szVersionStr), + PGPOLastOption(pgpContext)); + +#if (PGP_WIN32 < 0x700) + PGPFreeKeySet(PublicKey); +#else + PGPFreeKeyIter(KeyIterRef); + PGPFreeKeyDB(PublicKeyDB); +#endif + + if (CheckPGPError(err)) + return 0; + + LPSTR szMsg = (LPSTR) LocalAlloc(LPTR,dwEncMsgLen+1); + _pgp_memcpy(szMsg, szEncMsg, dwEncMsgLen); + szMsg[dwEncMsgLen] = 0; + PGPFreeData((LPVOID)szEncMsg); + + return szMsg; +} + + +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 1) + MessageBox(hDlg, "You selected more than one key. Only the first key will be used.", szModuleName, MB_ICONINFORMATION); + + static PGPKeyID KeyID; + +#if (PGP_WIN32 < 0x700) + PGPKeyListRef ContactKeyList; + PGPOrderKeySet(ContactKeyDB, kPGPKeyIDOrdering, &ContactKeyList); + + PGPKeyIterRef KeyIterRef; + PGPNewKeyIter(ContactKeyList, &KeyIterRef); + + PGPKeyRef ContactKey; + PGPKeyIterNext(KeyIterRef, &ContactKey); + + PGPGetKeyIDFromKey(ContactKey, &KeyID); + PGPGetKeyIDString(&KeyID, kPGPKeyIDString_Abbreviated, szKeyID); + + PGPFreeKeyList(ContactKeyList); + PGPFreeKeyIter(KeyIterRef); + PGPFreeKeySet(ContactKeyDB); +#else + PGPKeyIterRef KeyIterRef; + PGPNewKeyIterFromKeyDB(ContactKeyDB, &KeyIterRef); + + PGPKeyDBObjRef KeyDBObjRef; + PGPKeyIterNextKeyDBObj(KeyIterRef, kPGPKeyDBObjType_Key, &KeyDBObjRef); + + PGPSize dwFilled; + PGPGetKeyDBObjDataProperty(KeyDBObjRef, kPGPKeyProperty_KeyID, &KeyID, sizeof(PGPKeyID), &dwFilled); + PGPGetKeyIDString(&KeyID, kPGPKeyIDString_Abbreviated, szKeyID); + + PGPFreeKeyIter(KeyIterRef); + PGPFreeKeyDB(ContactKeyDB); +#endif + + return (PVOID)&KeyID; +} + + +#if (PGP_WIN32 >= 0x700) +BOOL ShowSelectKeyringsDlg(HWND hParent, LPSTR PubRingPath, LPSTR SecRingPath) +{ + // set keyring paths + OPENFILENAME ofn={0}; + ofn.lStructSize = sizeof(ofn); + ofn.hwndOwner = hParent; + ofn.nMaxFile = MAX_PATH; + ofn.Flags = OFN_EXPLORER | OFN_FILEMUSTEXIST | OFN_NONETWORKBUTTON; + + ofn.lpstrFile = PubRingPath; + ofn.lpstrFilter = "Public key rings (pubring.pkr)\0pubring.pkr\0All files (*.*)\0*.*\0"; + ofn.lpstrTitle = "Open Public Keyring"; + if (!GetOpenFileName(&ofn)) return FALSE; + + ofn.lpstrFile = SecRingPath; + ofn.lpstrFilter = "Secret key rings (secring.skr)\0secring.skr\0All files (*.*)\0*.*\0"; + ofn.lpstrTitle = "Open Secret Keyring"; + if (!GetOpenFileName(&ofn)) return FALSE; + + return TRUE; +} +#endif + + +// dllmain +BOOL WINAPI dllmain(HINSTANCE hInst, DWORD dwReason, LPVOID) { + g_hInst = hInst; + return TRUE; +} + -- cgit v1.2.3