📄 csecret.cpp
字号:
PGPFreeKeyDB(keyDB) ;
return err ;
}
PGPError CSecret::EncrptingBuffer(const CString &strUserID , const CString &strFile)
{
PGPError err = kPGPError_NoErr;
PGPKeyDBRef keyDB = kInvalidPGPKeyDBRef;
PGPKeyIterRef iter = kInvalidPGPKeyIterRef;
PGPKeyID theKeyID;
PGPKeyDBObjRef BobsKey = kInvalidPGPKeyDBObjRef;
PGPKeyDBObjRef AlicesKey = kInvalidPGPKeyDBObjRef;
PGPKeyDBObjRef signKey = kInvalidPGPKeyDBObjRef;
PGPKeyDBObjRef encryptKey = kInvalidPGPKeyDBObjRef;
PGPOptionListRef encodeOptions = kInvalidPGPOptionListRef;
PGPOptionListRef savedOptions = kInvalidPGPOptionListRef;
PGPOptionListRef moreOptions = kInvalidPGPOptionListRef;
PGPKeySetRef encryptSet = kInvalidPGPKeySetRef;
PGPBoolean hideRecipents = TRUE;
/* Cipher Text */
void * cBuf = NULL;
PGPSize cBufSize;
/* Result Text */
void * dBuf = NULL;
PGPSize dBufSize;
PGPUInt32 numKeys;
DecodeInfo decodeInfo;
InitDecodeInfo(&decodeInfo);
err = importKeys(m_pContext ,strFile, kPGPInputFormat_PGP , &keyDB);
if (IsPGPError(err))
{
goto EXIT ;
}
err = PGPCountKeysInKeyDB(keyDB, &numKeys);
///*
char kKeyIdString[] = "0x526AB53F" ;//"0x1CB0044B" ;
// kPGPPublicKeyAlgorithm_RSASignOnly
//
err = PGPNewKeyIDFromString( kKeyIdString ,kPGPPublicKeyAlgorithm_RSA , &theKeyID);
if (IsPGPError(err))
{
goto EXIT ;
}
err = PGPFindKeyByKeyID( keyDB, &theKeyID, &BobsKey);
if (IsPGPError(err))
{
goto EXIT ;
}
// kPGPKeyPropertyFlags_UsageEncryptCommunications
// kPGPKeyPropertyFlags_UsageSignEncrypt
// kPGPKeyPropertyFlags_UsageSignMessages
err = PGPGetKeyForUsage( BobsKey ,kPGPKeyPropertyFlags_UsageSignMessages , &signKey);
if (IsPGPError(err))
{
goto EXIT ;
}
memcpy( &decodeInfo.key[0].keyID , &theKeyID , sizeof(PGPKeyID));
decodeInfo.key[0].passPhrase = "123";
char kBobsPassPhrase[] = "123" ;
///*kPGPKeyPropertyFlags_UsageSignMessages
// char kKeyIdString1[] = "0xBC01BDB3" ; // kPGPPublicKeyAlgorithm_RSASignOnly
char kKeyIdString1[] = "0xD6F74536";//"0xE71A9AF7" ;
err = PGPNewKeyIDFromString( kKeyIdString1 ,kPGPPublicKeyAlgorithm_RSA , &theKeyID);
if (IsPGPError(err))
{
goto EXIT ;
}
err = PGPFindKeyByKeyID( keyDB, &theKeyID, &AlicesKey);
if (IsPGPError(err))
{
goto EXIT ;
}
err = PGPGetKeyForUsage( AlicesKey, kPGPKeyPropertyFlags_UsageEncryptCommunications , &encryptKey);
if (IsPGPError(err))
{
goto EXIT ;
}
memcpy( &decodeInfo.key[1].keyID , &theKeyID , sizeof(PGPKeyID));
decodeInfo.key[1].passPhrase = "11";
decodeInfo.keyCount = 2 ;
//*/
////////////////////////////////////////////////////////////////////////////
/*kPGPPublicKeyAlgorithm_RSA "0xFA352277" "0x1A52E54E"
err = PGPNewKeyIDFromString( "0x8E10CFE6" ,
kPGPPublicKeyAlgorithm_DSA , &theKeyID); // kPGPPublicKeyAlgorithm_DSA
err = PGPFindKeyByKeyID( keyDB, &theKeyID, &BobsKey);
err = PGPGetKeyForUsage( BobsKey, kPGPKeyPropertyFlags_UsageSignMessages,
&signKey);
memcpy( &decodeInfo.key[0].keyID , &theKeyID , sizeof(PGPKeyID));
decodeInfo.key[0].passPhrase = "bobs passphrase" ;
char kBobsPassPhrase[] = "bobs passphrase";
//"0x5D2D1D66" "0x18629903"
err = PGPNewKeyIDFromString( "0xEE481634" ,
kPGPPublicKeyAlgorithm_DSA , &theKeyID); // kPGPPublicKeyAlgorithm_DSA
if (IsPGPError(err))
{
goto EXIT ;
}
err = PGPFindKeyByKeyID( keyDB, &theKeyID, &AlicesKey);
err = PGPGetKeyForUsage( AlicesKey, kPGPKeyPropertyFlags_UsageEncryptCommunications,
&encryptKey);
//COPY( &theKeyID, &decodeInfo.key[1].keyID, sizeof(PGPKeyID));
memcpy( &decodeInfo.key[1].keyID , &theKeyID , sizeof(PGPKeyID));
decodeInfo.key[1].passPhrase = "alices passphrase" ;
decodeInfo.keyCount = 2;
// err = PGPNewOneKeySet(encryptKey, &encryptSet);
//*/
//////////////////////////////////////////////////////////////////////////////////////////////////////////
// err = PGPNewOneKeySet(signKey, &encryptSet);
err = PGPNewOneKeySet(encryptKey, &encryptSet);
err = PGPCountKeys(encryptSet, &numKeys);
if (IsPGPError(err))
{
goto EXIT ;
}
err = PGPNewOptionList(m_pContext, &encodeOptions);
/*
err = PGPAppendOptionList(encodeOptions,
PGPOCommentString ( m_pContext, "FIPS 140-2 Test message"),
PGPOLastOption( m_pContext ) );
if (IsPGPError(err))
{
goto EXIT ;
}
err = PGPBuildOptionList(m_pContext, &moreOptions,
PGPOEventHandler( m_pContext, OptestEventHandler, &decodeInfo),
PGPOForYourEyesOnly(m_pContext,TRUE),
PGPODataIsASCII ( m_pContext, FALSE),
(hideRecipents?PGPOObfuscateRecipients(m_pContext, TRUE) : PGPONullOption(m_pContext)),
PGPOOutputLineEndType ( m_pContext,kPGPLineEnd_LF),
PGPOArmorOutput(m_pContext, TRUE),
PGPOLastOption( m_pContext ) );
if (IsPGPError(err))
{
goto EXIT ;
}
err = PGPAppendOptionList( encodeOptions, moreOptions, PGPOLastOption( m_pContext ) );
if (IsPGPError(err))
{
goto EXIT ;
}
err = PGPCopyOptionList(encodeOptions, &savedOptions);
if (IsPGPError(err))
{
goto EXIT ;
}
//*/
static const char MessageToBeSigned[] = "Our challen";
//"Our challenge is to synergistically utilize long-term "
//"high-impact cryptographic data to quickly pursue timely "
//"catalysts for change such that we may continue to interactively "
//"fashion long-term high-impact benefits to meet our customer's "
//"needs and stay competitive in tomorrow's world.";
//// /*
// TE03.14.02 - Encrypt data/
// TE03.14.02 - Sign data /
decodeInfo.option = kDecode_NoOption;
err = PGPEncode( m_pContext,
PGPOInputBuffer ( m_pContext, MessageToBeSigned, sizeof(MessageToBeSigned)-1 ),
PGPOAllocatedOutputBuffer( m_pContext, &cBuf, MAX_PGPSize, &cBufSize),
//PGPOSignWithKey ( m_pContext, signKey,
// PGPOPassphrase( m_pContext, kBobsPassPhrase),
// PGPOLastOption ( m_pContext ) ),
PGPOEncryptToKeySet(m_pContext, encryptSet),
PGPOOutputFormat(m_pContext, kPGPOutputFormat_PGP),
encodeOptions,
PGPOLastOption( m_pContext ) );
err = PGPDecode( m_pContext ,
PGPOInputBuffer ( m_pContext, cBuf, cBufSize ),
PGPOAllocatedOutputBuffer( m_pContext, &dBuf, MAX_PGPSize, &dBufSize),
PGPOEventHandler( m_pContext, OptestEventHandler, &decodeInfo),
PGPOKeyDBRef(m_pContext, keyDB),
PGPOLastOption ( m_pContext ) );
if (IsPGPError(err))
{
goto EXIT ;
}
//*/
/*
// TE03.14.02 - encrypt to a passphrase /
// OPTESTPrintF("\n\tEncoding Message Conventionally \n");
err = PGPEncode( m_pContext,
PGPOInputBuffer ( m_pContext, MessageToBeSigned, sizeof(MessageToBeSigned)-1 ),
PGPOAllocatedOutputBuffer( m_pContext, &cBuf, MAX_PGPSize, &cBufSize),
PGPOCipherAlgorithm(m_pContext, kPGPCipherAlgorithm_AES256),
PGPOConventionalEncrypt ( m_pContext,
PGPOPassphrase( m_pContext, kBobsPassPhrase),
PGPOLastOption ( m_pContext ) ),
PGPOLastOption( m_pContext ) );
if (IsPGPError(err))
{
goto EXIT ;
}
*/
EXIT:
/* Cleanup this mess */
CleanUpDecodeInfo(&decodeInfo);
if( dBuf != NULL)
PGPFreeData(dBuf);
if( cBuf != NULL)
PGPFreeData(cBuf);
// if( dumpBuf != NULL)
// PGPFreeData(dumpBuf);
if( PGPKeySetRefIsValid (encryptSet) )
PGPFreeKeySet(encryptSet);
if(PGPOptionListRefIsValid(encodeOptions))
PGPFreeOptionList(encodeOptions);
if(PGPOptionListRefIsValid(moreOptions))
PGPFreeOptionList(moreOptions);
if(PGPOptionListRefIsValid(savedOptions))
PGPFreeOptionList(savedOptions);
if( PGPKeyIterRefIsValid( iter ) )
PGPFreeKeyIter( iter );
if( PGPKeyDBRefIsValid( keyDB ) )
PGPFreeKeyDB( keyDB );
return err;
}
PGPChar* CSecret::hash_algor_table(int algor)
{
switch (algor )
{
case kPGPHashAlgorithm_MD5: return (PGPTXT_USER("MD5"));
case kPGPHashAlgorithm_SHA: return (PGPTXT_USER("SHA-1"));
case kPGPHashAlgorithm_RIPEMD160: return (PGPTXT_USER("RIPE-MD-160"));
case kPGPHashAlgorithm_SHA256: return (PGPTXT_USER("SHA-128"));
case kPGPHashAlgorithm_SHA384: return (PGPTXT_USER("SHA-384"));
case kPGPHashAlgorithm_SHA512: return (PGPTXT_USER("SHA-512"));
default: return (PGPTXT_USER("Invalid"));
}
}
PGPChar* CSecret::cipher_algor_table(int algor)
{
switch (algor )
{
case kPGPCipherAlgorithm_IDEA: return (PGPTXT_USER("IDEA"));
case kPGPCipherAlgorithm_3DES: return (PGPTXT_USER("3-DES"));
case kPGPCipherAlgorithm_CAST5: return (PGPTXT_USER("CAST-5"));
case kPGPCipherAlgorithm_AES128: return (PGPTXT_USER("AES-128"));
case kPGPCipherAlgorithm_AES192: return (PGPTXT_USER("AES-192"));
case kPGPCipherAlgorithm_AES256: return (PGPTXT_USER("AES-256"));
case kPGPCipherAlgorithm_Blowfish: return (PGPTXT_USER("BlowFish"));
case kPGPCipherAlgorithm_Twofish256: return (PGPTXT_USER("TwoFish"));
default: return (PGPTXT_USER("Invalid"));
}
}
PGPChar* CSecret::key_algor_table(int keytype)
{
switch(keytype)
{
case kPGPPublicKeyAlgorithm_RSA: return (PGPTXT_USER("RSA"));
case kPGPPublicKeyAlgorithm_RSAEncryptOnly: return (PGPTXT_USER("RSA Encrypt Only"));
case kPGPPublicKeyAlgorithm_RSASignOnly: return (PGPTXT_USER("RSA Sign Only"));
case kPGPPublicKeyAlgorithm_ElGamal: return (PGPTXT_USER("Elgamal"));
case kPGPPublicKeyAlgorithm_DSA: return (PGPTXT_USER("DSA"));
case kPGPPublicKeyAlgorithm_ECEncrypt: return (PGPTXT_USER("EC-Enc"));
case kPGPPublicKeyAlgorithm_ECSign: return (PGPTXT_USER("EC-Sign"));
default: return (PGPTXT_USER("Invalid"));
}
}
PGPChar* CSecret::compression_algor_table(int algor)
{
switch(algor)
{
case kPGPCompressionAlgorithm_None: return (PGPTXT_USER("None"));
case kPGPCompressionAlgorithm_ZLIB: return (PGPTXT_USER("ZLIB"));
case kPGPCompressionAlgorithm_ZIP: return (PGPTXT_USER("Zip"));
case kPGPCompressionAlgorithm_BZIP2: return (PGPTXT_USER("BZip2"));
default: return (PGPTXT_USER("Invalid"));
}
}
PGPChar* CSecret::email_encoding_table(int encoding)
{
switch(encoding)
{
case kPGPPreferredEmailEncoding_PGPMIME: return (PGPTXT_USER("PGPMIME"));
case kPGPPreferredEmailEncoding_Partitioned: return (PGPTXT_USER("Legacy"));
default: return (PGPTXT_USER("Invalid"));
}
}
char* CSecret::extname (const char *name)
{
const char *ext;
if(!name) return 0;
for (ext = name + strlen(name) ; ext != name && ( *ext != '.' && *ext != '/') ; ext--)
;
if(ext == name ) return 0;
else return (char*)(ext+1);
}
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -