# VMProtect 对象系统实现详解
## 1. 字符串格式化实现
### string_format 函数
“`cpp
std::string string_format(const char *format, …) {
va_list args;
va_start(args, format);
int size = 100; // 初始缓冲区大小
std::string res;
for (;;) {
res.resize(size);
va_start(args, format);
// 尝试格式化
int n = _vsnprintf_s(&res[0], size, _TRUNCATE, format, args);
if (n > -1 && n < size) {
// 成功，调整大小并返回
res.resize(n);
break;
}
// 缓冲区不够，扩大
if (n > -1)
size = n + 1; // 精确大小
else
size *= 2; // 翻倍
}
va_end(args);
return res;
}
“`
## 2. 可寻址对象实现
### AddressableObject 类
“`cpp
class AddressableObject : public IObject {
public:
AddressableObject() : address_(0) {}
AddressableObject(const AddressableObject &src)
: address_(src.address_) {}
AddressableObject &operator=(const AddressableObject &src) {
address_ = src.address_;
return *this;
}
// 比较实现
int CompareWith(const AddressableObject &other) const {
if (address_ > other.address_) return 1;
if (address_ < other.address_) return -1;
return 0;
}
// 访问器
uint64_t address() const { return address_; }
void set_address(uint64_t address) { address_ = address; }
protected:
uint64_t address_;
};
“`
## 3. 对象列表模板实现
### ObjectList 模板类
“`cpp
template <typename Object>
class ObjectList : public IObject {
// 禁止赋值
ObjectList &operator=(const ObjectList &);
public:
explicit ObjectList() : IObject() {}
explicit ObjectList(const ObjectList &src) : IObject(src) {}
virtual ~ObjectList() { clear(); }
// 清空列表
virtual void clear() {
while (!v_.empty()) {
delete v_.back();
}
}
// 删除指定索引的对象
void Delete(size_t index) {
if (index >= v_.size())
throw std::runtime_error(“subscript out of range”);
delete v_[index];
}
// 获取数量
size_t count() const { return v_.size(); }
// 获取指定索引的对象
Object *item(size_t index) const {
if (index >= v_.size())
throw std::runtime_error(“subscript out of range”);
return v_[index];
}
// 调整大小
void resize(size_t size) {
v_.resize(size);
}
// 获取最后一个对象
Object *last() const {
return v_.empty() ? NULL : *v_.rbegin();
}
// 对象比较函数
static bool CompareObjects(const Object *obj1, const Object *obj2) {
return obj1->CompareWith(*obj2) < 0;
}
// 排序
void Sort() {
std::sort(v_.begin(), v_.end(), CompareObjects);
}
// 查找对象索引
size_t IndexOf(const Object *obj) const {
const_iterator it = std::find(v_.begin(), v_.end(), obj);
return (it == v_.end()) ? -1 : it – v_.begin();
}
// 从指定位置查找
size_t IndexOf(const Object *obj, size_t index) const {
const_iterator it = std::find((v_.begin()+index), v_.end(), obj);
return (it == v_.end()) ? -1 : it – v_.begin();
}
// 交换对象
void SwapObjects(size_t i, size_t j) {
std::swap(v_[i], v_[j]);
}
// 添加对象
virtual void AddObject(Object *obj) {
v_.push_back(obj);
}
// 插入对象
virtual void InsertObject(size_t index, Object *obj) {
v_.insert(v_.begin() + index, obj);
}
// 移除对象（不删除）
virtual void RemoveObject(Object *obj) {
for (size_t i = count(); i > 0; i–) {
if (item(i – 1) == obj) {
erase(i – 1);
break;
}
}
}
// 删除指定索引（不销毁对象）
void erase(size_t index) {
v_.erase(v_.begin() + index);
}
// 从列表赋值
void assign(const std::list<Object*> &src) {
v_.clear();
for (typename std::list<Object*>::const_iterator it = src.begin();
it != src.end(); it++) {
v_.push_back(*it);
}
}
// 迭代器
const_iterator begin() const { return v_.begin(); }
const_iterator end() const { return v_.end(); }
iterator _begin() { return v_.begin(); }
iterator _end() { return v_.end(); }
protected:
void Reserve(size_t count) { v_.reserve(count); }
std::vector<Object*> v_;
};
“`
## 4. Data 类实现
### 数据缓冲区管理
“`cpp
class Data {
public:
Data() {}
Data(const std::vector<uint8_t> &src) { m_vData = src; }
// 添加字节
void PushByte(uint8_t value) {
m_vData.push_back(value);
}
// 添加 DWORD (32位)
void PushDWord(uint32_t value) {
PushBuff(&value, sizeof(value));
}
// 添加 QWORD (64位)
void PushQWord(uint64_t value) {
PushBuff(&value, sizeof(value));
}
// 添加 WORD (16位)
void PushWord(uint16_t value) {
PushBuff(&value, sizeof(value));
}
// 添加缓冲区
void PushBuff(const void *value, size_t nCount) {
m_vData.insert(m_vData.end(),
reinterpret_cast<const uint8_t *>(value),
reinterpret_cast<const uint8_t *>(value) + nCount);
}
// 插入字节
void InsertByte(size_t pos, uint8_t value) {
m_vData.insert(m_vData.begin() + pos, value);
}
// 插入缓冲区
void InsertBuff(size_t pos, const void *buff, size_t nCount) {
m_vData.insert(m_vData.begin() + pos,
reinterpret_cast<const uint8_t *>(buff),
reinterpret_cast<const uint8_t *>(buff) + nCount);
}
// 读取 DWORD
uint32_t ReadDWord(size_t nPosition) const {
return *reinterpret_cast<const uint32_t *>(&m_vData[nPosition]);
}
// 写入 DWORD
void WriteDWord(size_t nPosition, uint32_t dwValue) {
*reinterpret_cast<uint32_t *>(&m_vData[nPosition]) = dwValue;
}
// 访问数据
std::vector<uint8_t> &data() { return m_vData; }
const std::vector<uint8_t> &data() const { return m_vData; }
// 访问元素
uint8_t &operator[](size_t index) { return m_vData[index]; }
const uint8_t &operator[](size_t index) const { return m_vData[index]; }
// 获取大小
size_t size() const { return m_vData.size(); }
// 清空
void clear() { m_vData.clear(); }
// 是否为空
bool empty() const { return m_vData.empty(); }
private:
std::vector<uint8_t> m_vData;
};
“`
## 5. 智能指针实现
### 引用计数基类
“`cpp
class RefCounted {
public:
RefCounted() : ref_count_(0) {}
void AddRef() { ++ref_count_; }
void Release() {
if (–ref_count_ == 0)
delete this;
}
int ref_count() const { return ref_count_; }
protected:
virtual ~RefCounted() {}
private:
int ref_count_;
};
“`
### 智能指针模板
“`cpp
template <typename T>
class RefPtr {
public:
RefPtr() : ptr_(nullptr) {}
RefPtr(T *ptr) : ptr_(ptr) {
if (ptr_) ptr_->AddRef();
}
RefPtr(const RefPtr &other) : ptr_(other.ptr_) {
if (ptr_) ptr_->AddRef();
}
~RefPtr() {
if (ptr_) ptr_->Release();
}
RefPtr &operator=(T *ptr) {
if (ptr_) ptr_->Release();
ptr_ = ptr;
if (ptr_) ptr_->AddRef();
return *this;
}
RefPtr &operator=(const RefPtr &other) {
if (this != &other) {
if (ptr_) ptr_->Release();
ptr_ = other.ptr_;
if (ptr_) ptr_->AddRef();
}
return *this;
}
T *operator->() const { return ptr_; }
T &operator*() const { return *ptr_; }
T *get() const { return ptr_; }
bool operator!() const { return ptr_ == nullptr; }
operator bool() const { return ptr_ != nullptr; }
private:
T *ptr_;
};
“`
## 6. 通知系统实现
### 观察者模式
“`cpp
class INotifiable {
public:
virtual ~INotifiable() {}
virtual void Notify(MessageType type, IObject *sender,
const std::string &message) = 0;
};
class Notifier {
public:
void AddObserver(INotifiable *observer) {
observers_.push_back(observer);
}
void RemoveObserver(INotifiable *observer) {
observers_.erase(
std::remove(observers_.begin(), observers_.end(), observer),
observers_.end()
);
}
void Notify(MessageType type, IObject *sender,
const std::string &message) {
for (auto *observer : observers_) {
observer->Notify(type, sender, message);
}
}
private:
std::vector<INotifiable*> observers_;
};
“`
### 消息类型
“`cpp
enum MessageType {
mtInformation, // 信息
mtWarning, // 警告
mtError, // 错误
mtAdded, // 对象添加
mtChanged, // 对象改变
mtDeleted, // 对象删除
mtScript, // 脚本输出
};
“`
## 7. 命令模式实现
### 命令基类
“`cpp
class Command {
public:
virtual ~Command() {}
virtual void Execute() = 0;
virtual void Undo() = 0;
virtual const char *GetName() const = 0;
};
“`
### 命令管理器
“`cpp
class CommandManager {
public:
~CommandManager() {
Clear();
}
void Execute(Command *cmd) {
cmd->Execute();
// 清除重做栈
while (!redo_stack_.empty()) {
delete redo_stack_.top();
redo_stack_.pop();
}
undo_stack_.push(cmd);
}
void Undo() {
if (undo_stack_.empty()) return;
Command *cmd = undo_stack_.top();
undo_stack_.pop();
cmd->Undo();
redo_stack_.push(cmd);
}
void Redo() {
if (redo_stack_.empty()) return;
Command *cmd = redo_stack_.top();
redo_stack_.pop();
cmd->Execute();
undo_stack_.push(cmd);
}
bool CanUndo() const { return !undo_stack_.empty(); }
bool CanRedo() const { return !redo_stack_.empty(); }
void Clear() {
while (!undo_stack_.empty()) {
delete undo_stack_.top();
undo_stack_.pop();
}
while (!redo_stack_.empty()) {
delete redo_stack_.top();
redo_stack_.pop();
}
}
private:
std::stack<Command*> undo_stack_;
std::stack<Command*> redo_stack_;
};
“`
## 8. 工厂模式实现
### 对象工厂
“`cpp
template <typename Base, typename Key>
class Factory {
public:
typedef Base *(*CreateFunc)();
void Register(const Key &key, CreateFunc func) {
creators_[key] = func;
}
void Unregister(const Key &key) {
creators_.erase(key);
}
Base *Create(const Key &key) const {
auto it = creators_.find(key);
if (it != creators_.end())
return it->second();
return nullptr;
}
bool IsRegistered(const Key &key) const {
return creators_.find(key) != creators_.end();
}
private:
std::map<Key, CreateFunc> creators_;
};
“`
### 使用示例
“`cpp
// 定义工厂
Factory<ICommand, std::string> command_factory;
// 注册命令
command_factory.Register(“mov”, &CreateMovCommand);
command_factory.Register(“jmp”, &CreateJmpCommand);
// 创建命令
ICommand *cmd = command_factory.Create(“mov”);
“`
## 9. 单例模式实现
### 线程安全单例
“`cpp
template <typename T>
class Singleton {
public:
static T &Instance() {
static T instance;
return instance;
}
// 禁止拷贝
Singleton(const Singleton &) = delete;
Singleton &operator=(const Singleton &) = delete;
protected:
Singleton() {}
};
“`
### 使用示例
“`cpp
class Settings : public Singleton<Settings> {
friend class Singleton<Settings>;
public:
void Load(const char *filename);
void Save(const char *filename);
std::string GetString(const char *key);
int GetInt(const char *key);
private:
Settings() {}
std::map<std::string, std::string> values_;
};
// 使用
Settings::Instance().Load(“config.ini”);
std::string value = Settings::Instance().GetString(“key”);
“`
## 10. 序列化实现
### 序列化接口
“`cpp
class ISerializable {
public:
virtual ~ISerializable() {}
virtual void Serialize(Data &data) const = 0;
virtual void Deserialize(const Data &data) = 0;
};
“`
### 序列化辅助函数
“`cpp
// 序列化字符串
void SerializeString(Data &data, const std::string &str) {
data.PushDWord(str.size());
data.PushBuff(str.c_str(), str.size());
}
// 反序列化字符串
std::string DeserializeString(const Data &data, size_t &pos) {
uint32_t size = data.ReadDWord(pos);
pos += 4;
std::string str(reinterpret_cast<const char*>(&data[pos]), size);
pos += size;
return str;
}
// 序列化对象列表
template <typename T>
void SerializeList(Data &data, const ObjectList<T> &list) {
data.PushDWord(list.count());
for (size_t i = 0; i < list.count(); i++) {
Data item_data;
list.item(i)->Serialize(item_data);
SerializeString(data, std::string(
reinterpret_cast<const char*>(item_data.data().data()),
item_data.size()));
}
}
“`
暂无评论内容