static
RBOOL
findDoc
(
rSequence doc,
DocSearchContext* ctx
)
{
RBOOL isMatch = FALSE;
RPCHAR filePathA = NULL;
RPWCHAR filePathW = NULL;
CryptoLib_Hash* pHash = NULL;
RU32 hashSize = 0;
if( rpal_memory_isValid( doc ) &&
NULL != ctx )
{
rSequence_getSTRINGA( doc, RP_TAGS_FILE_PATH, &filePathA );
rSequence_getSTRINGW( doc, RP_TAGS_FILE_PATH, &filePathW );
rSequence_getBUFFER( doc, RP_TAGS_HASH, (RPU8*)&pHash, &hashSize );
if( ( NULL == filePathA || NULL == ctx->exprA || rpal_string_match( ctx->exprA, filePathA, FALSE ) ) &&
( NULL == filePathW || NULL == ctx->exprW || rpal_string_matchw( ctx->exprW, filePathW, FALSE ) ) &&
( NULL == pHash || NULL == ctx->pHash || 0 == rpal_memory_memcmp( pHash, ctx->pHash, hashSize ) ) )
{
isMatch = TRUE;
}
}
return isMatch;
}
//=============================================================================
// Utilities
//=============================================================================
static
rSequence
getStaticConfig
(
)
{
RU8 magic[] = _HCP_DEFAULT_STATIC_STORE_MAGIC;
rSequence config = NULL;
RU32 unused = 0;
RU8 key[] = _HCP_DEFAULT_STATIC_STORE_KEY;
if( 0 != rpal_memory_memcmp( g_patchedConfig, magic, sizeof( magic ) ) )
{
obfuscationLib_toggle( g_patchedConfig, sizeof( g_patchedConfig ), key, sizeof( key ) );
if( rSequence_deserialise( &config, g_patchedConfig, sizeof( g_patchedConfig ), &unused ) )
{
rpal_debug_info( "static store patched, using it as config" );
}
obfuscationLib_toggle( g_patchedConfig, sizeof( g_patchedConfig ), key, sizeof( key ) );
}
else
{
rpal_debug_info( "static store not patched, using defaults" );
}
return config;
}
// Provides a lexicographic ordering of atoms.
RPRIVATE
RS32
cmpAtoms
(
RPU8 atomId1,
RPU8 atomId2
)
{
return (RS32)rpal_memory_memcmp( atomId1, atomId2, HBS_ATOM_ID_SIZE );
}
static RS32
_cmpHashes
(
CryptoLib_Hash* pHash1,
CryptoLib_Hash* pHash2
)
{
RS32 ret = (RU32)(-1);
if( NULL != pHash1 &&
NULL != pHash2 )
{
ret = (RS32)rpal_memory_memcmp( pHash1, pHash2, sizeof( *pHash1 ) );
}
return ret;
}
static
RS32
_cmpModule
(
_moduleHistEntry* m1,
_moduleHistEntry* m2
)
{
RS32 ret = 0;
if( NULL != m1 &&
NULL != m2 )
{
ret = (RS32)rpal_memory_memcmp( m1, m2, sizeof( *m1 ) );
}
return ret;
}
static
RS32
_findHandle
(
rHandle* hToFind,
rHandle* hCurr
)
{
RS32 ret = 0;
if( NULL != hToFind &&
NULL != hCurr )
{
ret = (RS32)rpal_memory_memcmp( hToFind, hCurr, sizeof( *hToFind ) );
}
return ret;
}
static
RS32
_cmpContext
(
ProcExtInfo** ctx1,
ProcExtInfo** ctx2
)
{
RS32 ret = 0;
if( NULL != ctx1 &&
NULL != ctx2 &&
NULL != *ctx1 &&
NULL != *ctx2 )
{
ret = rpal_memory_memcmp( (*ctx1)->atomId, (*ctx2)->atomId, sizeof( (*ctx1)->atomId ) );
}
return ret;
}
RPRIVATE
RS32
_cmpDns
(
_dnsRecord* rec1,
_dnsRecord* rec2
)
{
RS32 ret = 0;
if( NULL != rec1 &&
NULL != rec2 )
{
if( 0 == ( ret = rpal_memory_memcmp( rec1,
rec2,
sizeof( *rec1 ) - sizeof( RPWCHAR ) ) ) )
{
ret = rpal_string_strcmp( rec1->name, rec2->name );
}
}
return ret;
}
RBOOL
processMessage
(
rSequence seq
)
{
RBOOL isSuccess = FALSE;
RU8 command = 0;
rSequence idSeq = NULL;
rpHCPId tmpId = { 0 };
rpHCPId emptyId = { 0 };
RU64 tmpTime = 0;
rThread hQuitThread = 0;
rpHCPIdentStore identStore = {0};
RPU8 token = NULL;
RU32 tokenSize = 0;
OBFUSCATIONLIB_DECLARE( store, RP_HCP_CONFIG_IDENT_STORE );
if( NULL != seq )
{
if( rSequence_getRU8( seq, RP_TAGS_OPERATION, &command ) )
{
rpal_debug_info( "Received command 0x%0X.", command );
switch( command )
{
case RP_HCP_COMMAND_LOAD_MODULE:
isSuccess = loadModule( &g_hcpContext, seq );
break;
case RP_HCP_COMMAND_UNLOAD_MODULE:
isSuccess = unloadModule( &g_hcpContext, seq );
break;
case RP_HCP_COMMAND_SET_HCP_ID:
if( rSequence_getSEQUENCE( seq, RP_TAGS_HCP_IDENT, &idSeq ) )
{
tmpId = seqToHcpId( idSeq );
if( 0 != rpal_memory_memcmp( &emptyId, &tmpId, sizeof( emptyId ) ) )
{
g_hcpContext.currentId = tmpId;
OBFUSCATIONLIB_TOGGLE( store );
if( rSequence_getBUFFER( seq, RP_TAGS_HCP_ENROLLMENT_TOKEN, &token, &tokenSize ) )
{
identStore.agentId = tmpId;
if( saveHcpId( (RPNCHAR)store, &identStore, token, tokenSize ) )
{
isSuccess = TRUE;
}
if( NULL != g_hcpContext.enrollmentToken )
{
rpal_memory_free( g_hcpContext.enrollmentToken );
g_hcpContext.enrollmentToken = NULL;
}
if( NULL != ( g_hcpContext.enrollmentToken = rpal_memory_alloc( tokenSize ) ) )
{
rpal_memory_memcpy( g_hcpContext.enrollmentToken, token, tokenSize );
g_hcpContext.enrollmentTokenSize = tokenSize;
isSuccess = TRUE;
}
}
else
{
rpal_debug_warning( "hcp id is missing token" );
}
OBFUSCATIONLIB_TOGGLE( store );
}
}
break;
case RP_HCP_COMMAND_SET_GLOBAL_TIME:
if( rSequence_getTIMESTAMP( seq, RP_TAGS_TIMESTAMP, &tmpTime ) )
{
rpal_time_setGlobalOffset( tmpTime - rpal_time_getLocal() );
isSuccess = TRUE;
}
break;
case RP_HCP_COMMAND_QUIT:
if( 0 != ( hQuitThread = rpal_thread_new( thread_quitAndCleanup, NULL ) ) )
{
rpal_thread_free( hQuitThread );
isSuccess = TRUE;
}
break;
case RP_HCP_COMMAND_UPGRADE:
isSuccess = upgradeHcp( seq );
break;
default:
break;
}
if( isSuccess )
{
rpal_debug_info( "Command was successful." );
}
else
{
rpal_debug_warning( "Command was not successful." );
}
}
}
return isSuccess;
}
