Windows heap widget

src/CMakeLists.txt

@@ -147,6 +147,8 @@ set(SOURCES
  dialogs/GlibcHeapBinsDialog.cpp
  widgets/HeapBinsGraphView.cpp
  dialogs/ArenaInfoDialog.cpp
+ widgets/WindowsHeapWidget.cpp
+ dialogs/WindowsHeapDialog.cpp
 )
 set(HEADER_FILES
  core/Cutter.h
@@ -306,6 +308,8 @@ set(HEADER_FILES
  dialogs/GlibcHeapBinsDialog.h
  widgets/HeapBinsGraphView.h
  dialogs/ArenaInfoDialog.h
+ widgets/WindowsHeapWidget.h
+ dialogs/WindowsHeapDialog.h
 )
 set(UI_FILES
  dialogs/AboutDialog.ui
@@ -377,6 +381,8 @@ set(UI_FILES
  widgets/GlibcHeapWidget.ui
  dialogs/GlibcHeapBinsDialog.ui
  dialogs/ArenaInfoDialog.ui
+ widgets/WindowsHeapWidget.ui
+ dialogs/WindowsHeapDialog.ui
 )
 set(QRC_FILES
  resources.qrc

src/core/Cutter.cpp

@@ -1592,6 +1592,62 @@ QVector<Chunk> CutterCore::getHeapChunks(RVA arena_addr)
  return chunks_vector;
 }
 
+QVector<HeapBlock> CutterCore::getHeapBlocks()
+{
+ CORE_LOCK();
+ QVector<HeapBlock> blocks_vector;
+ RzList *blocks = rz_heap_windows_blocks_list(core);
+ if (!blocks || !rz_list_length(blocks)) {
+ rz_list_free(blocks);
+ return blocks_vector;
+ }
+
+ RzListIter *iter;
+ RzWindowsHeapBlock *data;
+ CutterRListForeach(blocks, iter, RzWindowsHeapBlock, data)
+ {
+ HeapBlock block;
+ block.headerAddress = data->headerAddress;
+ block.userAddress = data->userAddress;
+ block.granularity = data->granularity;
+ block.unusedBytes = data->unusedBytes;
+ block.size = data->size;
+ block.type = QString(data->type);
+
+ blocks_vector.append(block);
+ }
+
+ rz_list_free(blocks);
+ return blocks_vector;
+}
+
+QVector<WindowsHeapInfo> CutterCore::getWindowsHeaps()
+{
+ CORE_LOCK();
+ QVector<WindowsHeapInfo> heaps_vector;
+ RzList *heaps = rz_heap_windows_heap_list(core);
+ if (!heaps || !rz_list_length(heaps)) {
+ rz_list_free(heaps);
+ return heaps_vector;
+ }
+
+ RzListIter *iter;
+ RzWindowsHeapInfo *data;
+ CutterRListForeach(heaps, iter, RzWindowsHeapInfo, data)
+ {
+ WindowsHeapInfo block;
+ block.base = data->base;
+ block.blockCount = data->blockCount;
+ block.allocated = data->allocated;
+ block.committed = data->committed;
+
+ heaps_vector.append(block);
+ }
+
+ rz_list_free(heaps);
+ return heaps_vector;
+}
+
 int CutterCore::getArchBits()
 {
  CORE_LOCK();
@@ -3616,22 +3672,12 @@ QString CutterCore::addTypes(const char *str)
 {
  CORE_LOCK();
  char *error_msg = nullptr;
- char *parsed = rz_type_parse_c_string(core->analysis->typedb, str, &error_msg);
+ int result = rz_type_parse_string(core->analysis->typedb, str, &error_msg);
+ // TODO fix adding and parsing types
  QString error;
 
- if (!parsed) {
- if (error_msg) {
- error = error_msg;
- rz_mem_free(error_msg);
- }
- return error;
- }
-
- rz_type_db_save_parsed_type(core->analysis->typedb, parsed);
- rz_mem_free(parsed);
-
- if (error_msg) {
- error = error_msg;
+ if (result && error_msg) {
+ error = QString(error_msg);
  rz_mem_free(error_msg);
  }
 

src/core/Cutter.h

@@ -432,6 +432,8 @@ class CUTTER_EXPORT CutterCore : public QObject
  * @return true if the write succeeded else false
  */
  bool writeHeapChunk(RzHeapChunkSimple *chunkSimple);
+ QVector<HeapBlock> getHeapBlocks();
+ QVector<WindowsHeapInfo> getWindowsHeaps();
  int getArchBits();
  void startDebug();
  void startEmulation();

src/core/CutterDescriptions.h

@@ -383,6 +383,24 @@ struct Arena
  ut64 max_system_mem;
 };
 
+struct HeapBlock
+{
+ RVA headerAddress;
+ RVA userAddress;
+ ut64 size;
+ ut64 unusedBytes;
+ ut64 granularity;
+ QString type;
+};
+
+struct WindowsHeapInfo
+{
+ RVA base;
+ ut64 committed;
+ ut64 allocated;
+ ut64 blockCount;
+};
+
 Q_DECLARE_METATYPE(FunctionDescription)
 Q_DECLARE_METATYPE(ImportDescription)
 Q_DECLARE_METATYPE(ExportDescription)

src/dialogs/WindowsHeapDialog.cpp

@@ -0,0 +1,99 @@
+#include "WindowsHeapDialog.h"
+#include "ui_WindowsHeapDialog.h"
+#include <Cutter.h>
+#include <Configuration.h>
+
+WindowsHeapDialog::WindowsHeapDialog(QWidget *parent)
+ : QDialog(parent), ui(new Ui::WindowsHeapDialog)
+{
+ ui->setupUi(this);
+
+ viewHeap = ui->tableView;
+ viewHeap->setFont(Config()->getFont());
+ viewHeap->setModel(modelHeap);
+ viewHeap->verticalHeader()->hide();
+ // change the scroll mode to ScrollPerPixel
+ viewHeap->setHorizontalScrollMode(QAbstractItemView::ScrollPerPixel);
+ viewHeap->setVerticalScrollMode(QAbstractItemView::ScrollPerPixel);
+
+ updateContents();
+}
+
+WindowsHeapDialog::~WindowsHeapDialog()
+{
+ delete ui;
+}
+
+void WindowsHeapDialog::updateContents()
+{
+ modelHeap->reload();
+ viewHeap->resizeColumnsToContents();
+}
+
+HeapInfoModel::HeapInfoModel(QObject *parent) : QAbstractTableModel(parent) {}
+
+QVariant HeapInfoModel::data(const QModelIndex &index, int role) const
+{
+ if (!index.isValid() || index.row() >= values.count())
+ return QVariant();
+
+ const auto &item = values.at(index.row());
+
+ switch (role) {
+ case Qt::DisplayRole:
+ switch (index.column()) {
+ case BaseColumn:
+ return RAddressString(item.base);
+ case AllocatedColumn:
+ return item.allocated;
+ case CommittedColumn:
+ return item.committed;
+ case BlockCountColumn:
+ return item.blockCount;
+ default:
+ return QVariant();
+ }
+ default:
+ return QVariant();
+ }
+}
+
+QVariant HeapInfoModel::headerData(int section, Qt::Orientation orientation, int role) const
+{
+ Q_UNUSED(orientation);
+ switch (role) {
+ case Qt::DisplayRole:
+ switch (section) {
+ case BaseColumn:
+ return tr("Base Address");
+ case AllocatedColumn:
+ return tr("Allocated");
+ case CommittedColumn:
+ return tr("Committed");
+ case BlockCountColumn:
+ return tr("Block Count");
+ default:
+ return QVariant();
+ }
+ default:
+ return QVariant();
+ }
+}
+
+int HeapInfoModel::columnCount(const QModelIndex &) const
+{
+ return ColumnCount;
+}
+
+int HeapInfoModel::rowCount(const QModelIndex &) const
+{
+ return this->values.size();
+}
+
+void HeapInfoModel::reload()
+{
+ beginResetModel();
+ values.clear();
+ values = Core()->getWindowsHeaps();
+ endResetModel();
+}

src/dialogs/WindowsHeapDialog.h

@@ -0,0 +1,43 @@
+#ifndef WINDOWSHEAPDIALOG_H
+#define WINDOWSHEAPDIALOG_H
+
+#include <QDialog>
+#include <ui_WindowsHeapDialog.h>
+#include <CutterDescriptions.h>
+
+namespace Ui {
+class WindowsHeapDialog;
+}
+
+class HeapInfoModel : public QAbstractTableModel
+{
+ Q_OBJECT
+public:
+ explicit HeapInfoModel(QObject *parent = nullptr);
+ enum Column { BaseColumn = 0, AllocatedColumn, CommittedColumn, BlockCountColumn, ColumnCount };
+ void reload();
+ int rowCount(const QModelIndex &parent) const override;
+ int columnCount(const QModelIndex &parent) const override;
+ QVariant data(const QModelIndex &index, int role) const override;
+ QVariant headerData(int section, Qt::Orientation orientation, int role) const override;
+
+private:
+ QVector<WindowsHeapInfo> values;
+};
+
+class WindowsHeapDialog : public QDialog
+{
+ Q_OBJECT
+
+public:
+ explicit WindowsHeapDialog(QWidget *parent);
+ ~WindowsHeapDialog() override;
+private slots:
+ void updateContents();
+
+private:
+ Ui::WindowsHeapDialog *ui;
+ QTableView *viewHeap;
+ HeapInfoModel *modelHeap = new HeapInfoModel(this);
+};
+#endif // WINDOWSHEAPDIALOG_H

src/dialogs/WindowsHeapDialog.ui

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>WindowsHeapDialog</class>
+ <widget class="QDialog" name="WindowsHeapDialog">
+ <property name="geometry">
+ <rect>
+ <x>0</x>
+ <y>0</y>
+ <width>400</width>
+ <height>300</height>
+ </rect>
+ </property>
+ <property name="windowTitle">
+ <string>Dialog</string>
+ </property>
+ <layout class="QVBoxLayout" name="verticalLayout">
+ <item>
+ <widget class="QTableView" name="tableView"/>
+ </item>
+ </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

src/widgets/HeapDockWidget.cpp

@@ -1,13 +1,15 @@
 #include "HeapDockWidget.h"
 #include "ui_HeapDockWidget.h"
 #include "widgets/GlibcHeapWidget.h"
+#include "WindowsHeapWidget.h"
 
 HeapDockWidget::HeapDockWidget(MainWindow *main)
  : CutterDockWidget(main), ui(new Ui::HeapDockWidget), main(main)
 {
  ui->setupUi(this);
 
  ui->allocatorSelector->addItem("Glibc Heap");
+ ui->allocatorSelector->addItem("Windows Heap");
  ui->verticalLayout->setMargin(0);
 
  connect<void (QComboBox::*)(int)>(ui->allocatorSelector, &QComboBox::currentIndexChanged, this,
@@ -36,6 +38,9 @@ void HeapDockWidget::onAllocatorSelected(int index)
  // change widget depending upon selected allocator
  if (index == Glibc) {
  currentHeapWidget = new GlibcHeapWidget(main, this);
+ } else if (index == Windows) {
+ currentHeapWidget = new WindowsHeapWidget(main, this);
  }
+
  ui->verticalLayout->addWidget(currentHeapWidget);
 }

src/widgets/HeapDockWidget.h

@@ -19,7 +19,7 @@ private slots:
  void onAllocatorSelected(int index);
 
 private:
- enum Allocator { Glibc = 0, AllocatorCount };
+ enum Allocator { Glibc = 0, Windows, AllocatorCount };
  Ui::HeapDockWidget *ui;
  MainWindow *main;
  QWidget* currentHeapWidget = nullptr;

src/widgets/SectionsWidget.h

@@ -51,11 +51,12 @@ class SectionsModel : public AddressableItemModel<QAbstractListModel>
 
  SectionsModel(QList<SectionDescription> *sections, QObject *parent = nullptr);
 
- int rowCount(const QModelIndex &parent = QModelIndex()) const;
- int columnCount(const QModelIndex &parent = QModelIndex()) const;
+ int rowCount(const QModelIndex &parent = QModelIndex()) const override;
+ int columnCount(const QModelIndex &parent = QModelIndex()) const override;
 
- QVariant data(const QModelIndex &index, int role) const;
- QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const;
+ QVariant data(const QModelIndex &index, int role) const override;
+ QVariant headerData(int section, Qt::Orientation orientation,
+ int role = Qt::DisplayRole) const override;
 
  RVA address(const QModelIndex &index) const override;
  QString name(const QModelIndex &index) const override;
@@ -78,7 +79,7 @@ class SectionsWidget : public ListDockWidget
 
 public:
  explicit SectionsWidget(MainWindow *main);
- ~SectionsWidget();
+ ~SectionsWidget() override;
 
 private slots:
  void refreshSections();