bool Module::import(StringRef name, DefnList & defs, bool absPath) {
Module * mod = PackageMgr::get().loadModule(name);
if (mod == NULL && !absPath) {
// Try our own package
llvm::SmallString<128> importName(packageName_);
importName.push_back('.');
importName += name;
mod = PackageMgr::get().loadModule(importName);
if (mod == NULL && packageName_ != "tart.core") {
// Try tart.core
importName = "tart.core.";
importName += name;
mod = PackageMgr::get().loadModule(importName);
}
}
if (mod != NULL) {
importModules_.insert(mod);
if (!mod->primaryDefs_.empty()) {
defs.append(mod->primaryDefs_.begin(), mod->primaryDefs_.end());
return true;
}
diag.warn(SourceLocation()) << "Module '" << name << "' has no primary defs?";
}
return false;
}
OM_uint32
gssEapImportContext(OM_uint32 *minor,
gss_buffer_t token,
gss_ctx_id_t ctx)
{
OM_uint32 major;
unsigned char *p = (unsigned char *)token->value;
size_t remain = token->length;
if (remain < 16) {
*minor = GSSEAP_TOK_TRUNC;
return GSS_S_DEFECTIVE_TOKEN;
}
if (load_uint32_be(&p[0]) != EAP_EXPORT_CONTEXT_V1) {
*minor = GSSEAP_BAD_CONTEXT_TOKEN;
return GSS_S_DEFECTIVE_TOKEN;
}
ctx->state = load_uint32_be(&p[4]);
ctx->flags = load_uint32_be(&p[8]);
ctx->gssFlags = load_uint32_be(&p[12]);
p += 16;
remain -= 16;
/* Validate state */
if (GSSEAP_SM_STATE(ctx) < GSSEAP_STATE_INITIAL ||
GSSEAP_SM_STATE(ctx) > GSSEAP_STATE_ESTABLISHED)
return GSS_S_DEFECTIVE_TOKEN;
/* Only acceptor can export partial context tokens */
if (CTX_IS_INITIATOR(ctx) && !CTX_IS_ESTABLISHED(ctx))
return GSS_S_DEFECTIVE_TOKEN;
major = importMechanismOid(minor, &p, &remain, &ctx->mechanismUsed);
if (GSS_ERROR(major))
return major;
major = importKerberosKey(minor, &p, &remain,
&ctx->checksumType,
&ctx->encryptionType,
&ctx->rfc3961Key);
if (GSS_ERROR(major))
return major;
/* Initiator name OID matches the context mechanism, so it's not encoded */
major = importName(minor, ctx->mechanismUsed, &p, &remain, &ctx->initiatorName);
if (GSS_ERROR(major))
return major;
major = importName(minor, GSS_C_NO_OID, &p, &remain, &ctx->acceptorName);
if (GSS_ERROR(major))
return major;
/* Check that, if context is established, names are valid */
if (CTX_IS_ESTABLISHED(ctx) &&
(CTX_IS_INITIATOR(ctx) ? ctx->acceptorName == GSS_C_NO_NAME
: ctx->initiatorName == GSS_C_NO_NAME)) {
return GSS_S_DEFECTIVE_TOKEN;
}
if (remain < 24 + sequenceSize(ctx->seqState)) {
*minor = GSSEAP_TOK_TRUNC;
return GSS_S_DEFECTIVE_TOKEN;
}
ctx->expiryTime = (time_t)load_uint64_be(&p[0]);
ctx->sendSeq = load_uint64_be(&p[8]);
ctx->recvSeq = load_uint64_be(&p[16]);
p += 24;
remain -= 24;
major = sequenceInternalize(minor, &ctx->seqState, &p, &remain);
if (GSS_ERROR(major))
return major;
#ifdef GSSEAP_ENABLE_ACCEPTOR
/*
* The partial context should only be expected for unestablished
* acceptor contexts.
*/
if (!CTX_IS_INITIATOR(ctx) && !CTX_IS_ESTABLISHED(ctx) &&
(ctx->flags & CTX_FLAG_KRB_REAUTH) == 0) {
major = gssEapImportPartialContext(minor, &p, &remain, ctx);
if (GSS_ERROR(major))
return major;
}
#ifdef GSSEAP_DEBUG
GSSEAP_ASSERT(remain == 0);
#endif
#endif /* GSSEAP_ENABLE_ACCEPTOR */
major = GSS_S_COMPLETE;
*minor = 0;
return major;
}
bool apienumimports(duint base, const IMPORTENUMCALLBACK & cbEnum)
{
// Variables
bool readSuccess;
Memory<char*> importName(MAX_IMPORT_SIZE + 1, "apienumimports:buffer");
char importModuleName[MAX_MODULE_SIZE] = "";
duint regionSize;
ULONG_PTR importTableRva, importTableSize;
MEMORY_BASIC_INFORMATION mbi;
PIMAGE_IMPORT_DESCRIPTOR importTableVa;
IMAGE_IMPORT_DESCRIPTOR importDescriptor;
PIMAGE_THUNK_DATA imageIATVa, imageINTVa;
IMAGE_THUNK_DATA imageOftThunkData, imageFtThunkData;
PIMAGE_IMPORT_BY_NAME pImageImportByNameVa;
// Get page size
VirtualQueryEx(fdProcessInfo->hProcess, (const void*)base, &mbi, sizeof(mbi));
regionSize = mbi.RegionSize;
Memory<void*> buffer(regionSize, "apienumimports:buffer");
// Read first page into buffer
if(!MemRead(base, buffer(), regionSize))
return false;
// Import Table address and size
importTableRva = GetPE32DataFromMappedFile((duint)buffer(), 0, UE_IMPORTTABLEADDRESS);
importTableSize = GetPE32DataFromMappedFile((duint)buffer(), 0, UE_IMPORTTABLESIZE);
// Return if no imports
if(!importTableSize)
return false;
importTableVa = (PIMAGE_IMPORT_DESCRIPTOR)(base + importTableRva);
readSuccess = MemRead((duint)importTableVa, &importDescriptor, sizeof(importDescriptor));
// Loop through all dlls
while(readSuccess && importDescriptor.FirstThunk)
{
// Copy module name into importModuleName
MemRead((duint)(base + importDescriptor.Name), &importModuleName, MAX_MODULE_SIZE);
imageIATVa = (PIMAGE_THUNK_DATA)(base + importDescriptor.FirstThunk);
imageINTVa = (PIMAGE_THUNK_DATA)(base + importDescriptor.OriginalFirstThunk);
if(!MemRead((duint)imageIATVa, &imageFtThunkData, sizeof(imageFtThunkData)))
return false;
if(!MemRead((duint)imageINTVa, &imageOftThunkData, sizeof(imageOftThunkData)))
return false;
// Loop through all imported function in this dll
while(imageFtThunkData.u1.AddressOfData)
{
pImageImportByNameVa = (PIMAGE_IMPORT_BY_NAME)(base + imageOftThunkData.u1.AddressOfData);
// Read every IMPORT_BY_NAME.name
if(!MemRead((duint)pImageImportByNameVa + sizeof(WORD), importName(), MAX_IMPORT_SIZE))
return false;
// Callback
cbEnum(base, imageFtThunkData.u1.Function, importName(), importModuleName);
// Move to next address in the INT
imageINTVa++;
if(!MemRead((duint)imageINTVa, &imageOftThunkData, sizeof(imageOftThunkData)))
return false;
// Move to next address in the IAT and read it into imageFtThunkData
imageIATVa++;
if(!MemRead((duint)imageIATVa, &imageFtThunkData, sizeof(imageFtThunkData)))
return false;
}
importTableVa++;
readSuccess = MemRead((duint)importTableVa, &importDescriptor, sizeof(importDescriptor));
}
return true;
}
