我在IDA注意到,我分析的PE文件不仅包括该.rdata部分,还包括.idata.有什么不同？
我想连接存储在向量中的字符串.例如,如果我["a" "b" "c"]在矢量中,我希望得到结果"abc".
在这个博客上,我发现了有趣的字符串拼图:
---引用---
String te = "te", st = "st";
//"test".length();
String username = te + st;
username.intern();
System.out.println("String object the same is: "
+ (username == "test"));
在Java 7更新7下打印.
String object the same is: true
但取消注释"test".length(); 行,或使用Java 6运行并打印
String object the same is: false
--- EoQ ---
说实话我不明白为什么输出不同.能否请您解释一下这种行为的原因是什么？
几乎所有人都知道Java中的字符串是不可变的.最近我发现了一些可能暗示它并不总是正确的东西.我们试试这段代码吧:
System.out.println("-------- BEFORE MODIFICATIONS --------");
String beforeTest = new String("Original");
System.out.println(beforeTest);
java.lang.reflect.Field valueField = String.class.getDeclaredField("value");
valueField.setAccessible(true);
valueField.set("Original", "Modified".toCharArray());
System.out.println("-------- AFTER MODIFICATIONS --------");
System.out.println(beforeTest);
System.out.println("Original");
String test = new String("Original");
System.out.println(test);
String test2 = new String("Original 2");
System.out.println(test2);
输出将是:
-------- BEFORE MODIFICATIONS --------
Original
-------- AFTER MODIFICATIONS --------
Original
Modified
Modified
Original 2
这个技巧如何运作？JVM如何知道应该更改哪些对象以及哪些对象不应该更改？这个伎俩的机制是什么？为什么已经创建的beforeTest字符串没有改变？这个技巧真的会贬低这个strings are immutable原则吗？
我正在分析流程加载的各种模块.不幸的是,我无法创建kernel32.dll内存快照,尽管该功能可以与其他模块正常工作(例如ntddl.dll).问题出在以下代码中:
/* Copy code from memory */
if (VirtualProtect((BYTE*)virtualAddress, sizeOfCode, PAGE_EXECUTE_READWRITE, &flags) == 0) {
std::cout << "VirtualProtect failed!" << std::endl;
std::cout << "Virtual address: " << virtualAddress << std::endl;
std::cout << "Size of code: " << sizeOfCode << std::endl;
std::cout << "Error code: " << GetLastError() << std::endl;
}
调用此代码的结果kernel32.dll是:
Virtual address: 747d0000
Size of code: 6a000
Error code: 0x1e7
错误描述说:
ERROR_INVALID_ADDRESS
487 (0x1E7)
Attempt to access invalid address.
我检查了进程'内存映射和kernel32.dll地址是否正确.原因是什么？
为什么当我输入bash时:if [ false ]; then echo 'ok'; fi;我得到ok字符串作为结果？使用变量时我也能得到类似的结果:ok=false; if [ $ok ]; then echo 'ok'; fi;
我有以下代码:
var A = function() {};
var a = new A();
var b = new A();
A.prototype.member1 = 10;
A.prototype = {}
var c = new A();
console.log(a.member1);
console.log(a.constructor === b.constructor);
console.log(a.constructor === c.constructor);
console.log('---------');
console.log(c.member1);
它的输出是:
10
true
false
---------
undefined
undefined
原型a并b没有改变,并c有一个新的.我是对的,这是因为a.constructor不相等c.constructor而且每个人都有自己的事实prototype？当两个物体的构造者可能不相等时,还有其他的东西吗？
额外的问题:为什么印有两个undefined字符串？(铬)
我有一个应用程序,它创建.textwin32进程的段转储.然后它将基本块上的代码分开.基本块是一组一个接一个地执行的指令(跳转始终是这些基本块的最后指令).这是一个例子:
Basic block 1
mov ecx, dword ptr [ecx]
test ecx, ecx
je 00401013h
Basic block 2
mov eax, dword ptr [ecx]
call dword ptr [eax+08h]
Basic block 3
test eax, eax
je 0040100Ah
Basic block 4
mov edx, dword ptr [eax]
push 00000001h
mov ecx, eax
call dword ptr [edx]
Basic block 5
ret 000008h
现在我想在函数中对这些基本块进行分组 - 比如哪些基本块构成一个函数.什么是算法？我必须记住,ret一个函数中可能有很多指令.如何检测fast_call功能？
我正在分析32位和64位DLL.我想找出导出函数的地址是什么.我已经处理过32位DLL,但相同的代码不适用于64位模块.
DWORD address = (*module)->getImageBaseAddress();
DWORD headerAddress = address + ((PIMAGE_DOS_HEADER)address)->e_lfanew;
PIMAGE_NT_HEADERS header = (PIMAGE_NT_HEADERS)headerAddress;
PIMAGE_EXPORT_DIRECTORY exports = (PIMAGE_EXPORT_DIRECTORY)(address + header->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress);
PVOID names = (BYTE *)address + exports->AddressOfNames;
PVOID moduleFunctions = (BYTE *)address + exports->AddressOfFunctions;
std::cout << "Characteristics: " << exports->Characteristics << endl;
std::cout << "TimeDateStamp: " << exports->TimeDateStamp << endl;
std::cout << "Major version: " << exports->MajorVersion << endl;
std::cout << "Minor version: " << exports->MinorVersion << endl;
std::cout << "Name: " << exports->Name << endl;
std::cout << "Base: …哈斯克尔很漂亮.这是事实.它简洁,快速等等.你们许多人都会承认写作是一件非常愉快的事情.另一方面,我认为当人们尝试编写过于复杂的代码时,它的简洁性可能是一个缺点.例如,我最近打开了我朋友的项目,发现了这样的事情:
stationDepartures id sc=map (\(s1,list)->(stationName $ (stationMap $ system sc) Map.! s1,list)) ( Map.toList (Map.fromListWith (++) (map (\((s1,s2),(d,start,dur))->(s2,[start])) (Map.toList (Map.filterWithKey (\(s1,s2) _ ->s1==id) (Map.unions (List.map times (Map.elems $ schedule sc))))))))
这个单线对我来说绝对不可读.这当然是一个非常极端的例子,但它帮助我意识到可能我的Haskell代码似乎对其他人来说是不可读的.我开始想知道在Haskell中创建漂亮代码的原则是什么.我发现例如lambda函数被某些人认为是多余的,因为它们使代码的可读性降低.你觉得怎么样？Haskell代码应满足哪些要求才能被视为"美丽"？