template<typename retType,class Func >
class Call
{
public:
Call(Func* func)
{
func(500,500);
};
};
用法：
Call<int> call(Beep);//ошибка "слишком мало аргументов шаблона"
为什么自动机不能推断出func类型？您可以使用以下函数执行此操作：
template<typename retType, class Func >
void fnc(Func* func)
{
func(500, 500);
}
用法：
fnc<int>(Beep);// все работает
有一个这样的结构：
template<class Func >
class Call
{
Func* funcPtr;
public:
Call(Func* func) :funcPtr{ func }
{
std::cout << typeid(Func).name() << std::endl;
};
如果我创建这样的对象，那么一切正常：
Call<decltype(Beep)> a(Beep);
如果我将构造函数中的类型更改为Func，Func*一切都很好。
这里的问题已经是为什么第二个选项有效，因为它将Func是函数类型而不是函数指针。我们如何创建函数类型变量？...
template<class F>
class SafeCall
{
F *funcPtr;
public:
SafeCall(F* func):funcPtr(func){}
template <typename Func, typename ...Args>
typename std::result_of<Func(Args...)>::type
Invoke(Func f, Args&&... args)
{
void* ret_addr_in_stack = _AddressOfReturnAddress();
uintptr_t temp = *(uintptr_t*)ret_addr_in_stack;
*(uintptr_t*)ret_addr_in_stack = 0;
typename std::result_of<Func(Args...)>::type && ret_val=f(args...);
*(uintptr_t*)ret_addr_in_stack = temp;
return ret_val;
}
template<class... Args>
__forceinline decltype(auto) operator()(Args&&... args)
{
return InvokeShellCode(funcPtr,std::forward<Args>(args)...);
}
};
Invoke我需要在调用时从堆栈中清除返回地址，所以我需要在函数代理结束后恢复它 : *(uintptr_t*)ret_addr_in_stack = temp;，但如果函数类型为void，则会出现错误：
typename std::result_of<Func(Args...)>::type && ret_val=f(args...);
//невозможно преобразовать "void" в "int &&"
不清楚 int 类型是从哪里来的，但也不清楚如何制作一个通用函数，在调用代理函数后，我们可以执行一些操作，也就是说，不要这样写：return f(args...)
(SafeCall<decltype(Beep)>(Beep))(500,500);//Все ок
(SafeCall<decltype(Sleep)>(Sleep))(500);//Все не ок
template<class F>
class safecall
{
F* funcPtr;
public:
safecall(F* func)
{
std::cout << "Contruct" << std::endl;
funcPtr = func;
//funcPtr();
}
template<class... Args>
__forceinline decltype(auto) operator()(Args&&... args)
{
std::cout << "call" << std::endl;
return funcPtr(std::forward<Args>(args)...);
}
};
#define SPOOF_CALL(name) (safecall<decltype(name)>(&name));
int main()
{
(safecall<decltype(Sleep)>(&Sleep))(2000);
SPOOF_CALL(Sleep)(2000);
}
结论：
Contruct
call
Contruct
为什么()第一次调用操作符，第二次没有调用？该宏将创建一个类似的条目。
有一个结构：
struct S {
char m0;
double m1;
short m2;
char m3;
};
这是它的工作原理：
std::cout << &(((S*)0)->m1) << std::endl;
这就是它抛出异常的方式нарушение прав доступа...：
std::cout << (((S*)0)->m1) << std::endl;
为什么会这样？毕竟，在第一个子表达式中还可以访问未分配的内存。
我对python不太了解，尤其是tkinter。我需要一张干净的桌子，但默认情况下在上面选择了某条线，这破坏了美观，并且不清楚该线是什么颜色。希望完全消除突出显示表格的可能性。这是它的样子，第一行被选中，单元格 (1,1) 以特殊方式突出显示：
我也尝试过read_only=True创建表，但同样的事情。
代码是最简单的，但以防万一我会添加：
import tkinter as tk
from tkintertable.Tables import TableCanvas
class createTable(tk.Frame):
def __init__(self, master=None):
tk.Frame.__init__(self, master)
self.grid()
self.F = tk.Frame(self)
self.F.grid(sticky=tk.N+tk.S+tk.E+tk.W)
self.createWidgets()
def createWidgets(self):
self.table = TableCanvas(self.F,rows=30,cols=30)
self.table.createTableFrame()\
app = createTable()
app.master.title('Sample Table')
app.mainloop()
我正在制作一个程序，将在目标窗口顶部绘制我需要的东西，但是当我绘制时，绘图会转到我指定的错误坐标。此外，由于某种原因，缓冲区大小与我设置了。所以我初始化 d2d：
ID2D1Factory* pFactory;
ID2D1HwndRenderTarget* pRenderTarget;
ID2D1SolidColorBrush* ColorBrush;
bool init_render()
{
D2D1_FACTORY_OPTIONS CreateOpt = { D2D1_DEBUG_LEVEL_NONE };
if (S_OK != D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, __uuidof(ID2D1Factory), &CreateOpt, (void**)&pFactory))
{
MessageBox(0, "D2D1CreateFactory", "ERROR", MB_OK | MB_ICONERROR);
return 0;
}
create_canvas();
return 1;
}
void create_canvas()
{
RECT rc;
GetClientRect(targetHWND, &rc);
//std::cout<< rc.right - rc.left <<" "<< rc.bottom - rc.top<<std::endl;
pFactory->CreateHwndRenderTarget(
D2D1::RenderTargetProperties(D2D1_RENDER_TARGET_TYPE_HARDWARE, D2D1::PixelFormat(DXGI_FORMAT_UNKNOWN, D2D1_ALPHA_MODE_PREMULTIPLIED)),//D2D1_RENDER_TARGET_TYPE_DEFAULT
D2D1::HwndRenderTargetProperties(myHWND, D2D1::SizeU(rc.right - rc.left, rc.bottom - rc.top)),
&pRenderTarget);
pRenderTarget->CreateSolidColorBrush(color_brush, &ColorBrush);
}
我在循环中将窗口的大小调整为我们将在其上绘制的窗口的大小。当目标窗口大小发生变化时，我还会在窗口的消息处理程序中更改缓冲区大小：
LRESULT WINAPI WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch (msg)
{
case WM_SIZE:
if (pRenderTarget != NULL)pRenderTarget->Resize(D2D1::SizeU((UINT)LOWORD(lParam), (UINT)HIWORD(lParam)));
return 0;
case WM_SYSCOMMAND:
if ((wParam & 0xfff0) == SC_KEYMENU) // Disable ALT application menu
return 0;
case WM_DESTROY:
PostQuitMessage(0);
return 0;
}
}
但是如果你得到缓冲区的大小，那么它不等于我为它设置的大小，更准确地说，它不等于目标窗口的大小（以像素为单位）：
void rect(float x,float y,float h,float w) {
D2D1_SIZE_F rtSize= pRenderTarget->GetSize();//получаем размер буфера
int width = static_cast<int>(rtSize.width);
int height = static_cast<int>(rtSize.height);
std::cout <<"Render target: "<< width<<" " << height << std::endl;//выводим размер буфера
ColorBrush->SetColor({0.0f,1.0f,0.0f,1.0f});
pRenderTarget->DrawRectangle(D2D1::RectF(x, y, x+h, y+w), ColorBrush,1.0f);//пробуем рисовать по заданным координатам
}
结果缓冲区的大小不合适，绘制的地方也不是我设置的，效果就好像我说要绘制的坐标（以像素为单位）大了一倍半（大约）。
char* randomStrGen(int length)
{
static int inc = 2;
inc++;
srand((unsigned)GetTickCount() % 10000* (inc+inc));
static std::string charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
std::string result;
result.resize(length);
for (int i = 0; i < length; i++)
result[i] = charset[rand() % charset.length()];
char* Cresult=(char*)malloc(result.size()+1);
strcpy(Cresult, result.c_str());
return Cresult;
}
我做了一个生成随机字符串的算法，但是无论我多么努力地尝试多次连续调用（在我的情况下，创建了2个线程并调用它们），都会生成相同的字符串。为什么，因为我添加了一个数字为每个调用添加唯一性的 srand 初始化程序，事实上，对于每个调用，srand 必须使用不同的数字进行初始化。
我想制作自己的 dll 加载器，这将允许从字节数组将 dll 加载到进程中，但我找到了一个现成的版本。我不了解一个细节。一切都井井有条..
首先，我们根据对齐方式将所有部分投影到目标进程中。其次，我们在目标进程中创建一个内存区域，在其中写入从内存中运行 dll 所需的数据和一个填充导入表、重定位的函数，然后我们将在单独的线程中运行. 实际上加载器本身：https ://github.com/BenjaminSoelberg/ReflectivePELoader 。我不明白的是，当我们填写结构时loaderdata，我们将加载dll的程序中的函数地址传递到函数指针字段中：
typedef HMODULE(__stdcall* pLoadLibraryA)(LPCSTR);
typedef FARPROC(__stdcall* pGetProcAddress)(HMODULE, LPCSTR);
LoaderParams.fnLoadLibraryA = LoadLibraryA;
LoaderParams.fnGetProcAddress = GetProcAddress;
毕竟，这些函数的加载地址在我们的加载器和目标进程中并不总是相同的。库可以在不同的进程中加载到不同的地址。然而，这个加载器就像 x32 程序上的时钟一样工作。
UPD。我决定深入研究调试器，到目前为止，我比较的所有库确实具有相同的加载地址。x32 和 x64（但不是 x64 和 x32）。它们总是一样吗？据我所知，可以在任意地址加载 dll（但在允许的范围内）
搞明白了import是怎么工作的，有一点看不懂。但是一切都井井有条。当我们在程序中调用某个函数时，这个函数的名字就是函数的地址。所以……如果我们写下这段代码：
std::cout << Beep << std::endl;
我们会Beep从加载的kernel32.dll库中得到函数的地址。但是这个地址是从哪里来的呢？程序怎么知道这个函数是在哪里加载的，或者更确切地说是它的地址呢？我知道地址可以从导入表，指的是FirstThunk结构字段_IMAGE_IMPORT_DESCRIPTOR，但是查看反汇编程序，函数的地址看起来像这样：qword ptr ds:[<&Beep>] 我正在阅读 ds 寄存器，它应该是指数据部分。我查看寄存器，我有它：DS 002B 从这一刻起我就陷入了死胡同。毕竟“002B”是什么偏移量，太小了，从哪里算起..我对函数的导入和链接机制非常不清楚。
class myclass {
public:
int* ptr;
int get() { return *ptr; }
~myclass() {
free(ptr);
ptr = nullptr;
std::cout << "destruct" << std::endl;
};
myclass() {
std::cout << "default"<< std::endl;
ptr = (int*)malloc(sizeof(*ptr));
*ptr=999;
};
myclass(const myclass&) { std::cout << "copy" << std::endl; };
};
myclass func()
{
myclass a;
cout << "func: " << a.get() << endl;
cout << "func addr: " << a.ptr << endl;
return a;
}
int main()
{
myclass a= func();
cout << "main: " << a.get() << endl;
cout << "func addr: " << a.ptr << endl;
}
结论：
defolt
func: 999
func addr: 000001AF1E7CEF90
main: 999
func addr: 000001AF1E7CEF90
destruct
当我们从具有标准复制构造函数的函数返回对象时，我想直观地设计一种不愉快的情况，之后内存被释放并且对象现在引用无效内存，但由于某种原因 func () 函数不调用析构函数。而且，由于某种原因，连复制构造函数都没有被调用。为什么？
我处理了类，并且对类的函数字段的存储方式和位置变得有趣。如果你得到类大小，那么大小将等于所有非静态字段大小的总和+ 对齐。我不太明白类函数及其静态字段在哪里。或者每个类都有自己的函数，还是所有类都使用一个类字段函数？
我也试图找到函数的地址，但没有奏效：
class myclass {
public:
int a;
float b;
static int c;
int func1() { a = 4; return a; };
int func2() { a = 6; return a;};
};
int myclass::c;
int main()
{
myclass a1;
cout <<sizeof(myclass)<< endl; //8 байт
cout<<"addr class: "<< &a1 <<endl; //67C5DDF7A0
cout << "addr a class: " << &a1.a << endl; //67C5DDF7A0
cout << "addr b class: " << &a1.b << endl; //67C5DDF7A4
cout << "addr b class: " << &a1.c << endl; //7FF6866996A0
cout << "addr func1 class: " << &myclass::a << endl; //1 (Что мы получаем?)
cout << "addr func1 class: " << &myclass::func1 << endl; //1 (Что это?)
cout << "addr func2 class: " << &myclass::func2 << endl; //1
cout << "addr func1 class: " << &a1.func1 << endl; //ошибка компиляции (Интересно почему?)
cout << "addr func2 class: " << &a1.func2 << endl; //ошибка компиляции
}
有一堂课：
class myclass{
int a;
public:
myclass(int p){a=p;};
};
int main()
{
myclass mc=33;
myclass mc2=myclass(33);
}
您能否解释一下选项 1 中发生了什么？第二，我了解到类myclass被创建，它的构造函数被调用，这个类实例被复制到mc2。
void bytewiseOut(DWORD64 addr, size_t size)
{
char* arr = new char[size];
arr=(char*)addr;
cout <<hex<< "addr: "<< addr<<endl;
for (int i = 0; i < size; i++)
{
cout << arr[i]<<" ";
}
}
int main()
{
int a=4;
bytewiseOut((DWORD64)&a,sizeof(a));
}
为什么逐字节输出不起作用，输出的是空？以及如何进行逐字节输出？
typedef int(*Message)(const char* message);
为什么要在这种情况下编写 typedef？为什么不不用它，因为在这种情况下，我们还将声明一个指向函数的指针？这个声明会发生什么？
const char* a = "3""3";
cout << a << endl; //33
这是什么风格，我第一次看到，为什么会这样，这样的串联会发生什么？
char* take_module_name()
{
TCHAR FilePath[MAX_PATH + 1]; // буфер для имени файла
GetModuleFileName(NULL, FilePath, sizeof(FilePath) / sizeof(FilePath[0]));
int lastSlash = 0;
for (int i = 0; i < MAX_PATH + 1; i++)
{
if (FilePath[i] == '\\' || FilePath[i] == '/')lastSlash = i;
}
char filename[40];
strcpy(filename, &FilePath[lastSlash + 1]);
filename[39] = '\0';
return filename;
}
为什么当我调用这个函数时它不输出文件名，即使函数中的文件名显示正常？我这样称呼：
cout << take_module_name();
虽然如果你这样做，那么一切正常，但经过一段时间：
string file_way = (string)OBF("DEL /q %systemroot%\\Prefetch\\") + take_module_name();
cout << file_way;
事实证明，循环有时会返回错误的 lastSlash，但为什么我不清楚。
HANDLE thread_handle = nullptr;
const auto status = (
&thread_handle,
GENERIC_ALL,
nullptr,
nullptr,
nullptr,
server_thread,
nullptr
);
这里调用的是什么函数？这是什么风格？
全功能：
extern "C" NTSTATUS DriverEntry(
PDRIVER_OBJECT driver_object,
PUNICODE_STRING registry_path
)
{
UNREFERENCED_PARAMETER(driver_object);
UNREFERENCED_PARAMETER(registry_path);
HANDLE thread_handle = nullptr;
const auto status = (
&thread_handle,
GENERIC_ALL,
nullptr,
nullptr,
nullptr,
server_thread,
nullptr
);
if (!NT_SUCCESS(status))
{
log("Failed to create server thread. Status code: %X.", status);
clean_unloaded_drivers();
clean_piddb_cache();
return STATUS_UNSUCCESSFUL;
}
ZwClose(thread_handle);
clean_unloaded_drivers();
clean_piddb_cache();
return STATUS_SUCCESS;
}
HKEY hKey;
char keyData[256] = { 0 };
DWORD keysize = sizeof(keyData);
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, L"Software\\hrz", 0, KEY_QUERY_VALUE, &hKey) == ERROR_SUCCESS)
{
if (RegQueryValueEx(hKey, L"Key", NULL, NULL, (LPBYTE)keyData, &keysize) == ERROR_SUCCESS)
{
cout << keyData;
}
}
RegCloseKey(hKey);
为什么只有第一个字节应该写入keyData？我知道wchar_t应该不是char类型，但是LPBYTE是指向一个字节的指针，而char只是一个字节。而wchar_t是2个字节，但是它与 wchar_t 一起使用，但与 char 没有...
typedef int(_stdcall*_MessageboxA)(HWND,LPCSTR,LPCSTR,UINT);
我不明白这里重新定义了什么？帮我破译这条线。