Rizin
unix-like reverse engineering framework and cli tools
Classes | Macros | Functions
pemixed.h File Reference
#include <rz_types.h>
#include "pe.h"

Go to the source code of this file.

Classes

struct  rz_bin_pemixed_obj_t
 

Macros

#define SUB_BIN_DOS   0
 
#define SUB_BIN_NATIVE   1
 
#define SUB_BIN_NET   2
 
#define _INCLUDE_RZ_BIN_PEMIXED_H_
 

Functions

RzBinPEObj * rz_bin_pemixed_init_dos (RzBinPEObj *pe_bin)
 
RzBinPEObj * rz_bin_pemixed_init_native (RzBinPEObj *pe_bin)
 
RzBinPEObj * rz_bin_pemixed_extract (struct rz_bin_pemixed_obj_t *bin, int sub_bin)
 
void * rz_bin_pemixed_free (struct rz_bin_pemixed_obj_t *bin)
 
struct rz_bin_pemixed_obj_t * rz_bin_pemixed_from_bytes_new (const ut8 *buf, ut64 size)
 

Macro Definition Documentation

◆ _INCLUDE_RZ_BIN_PEMIXED_H_

#define _INCLUDE_RZ_BIN_PEMIXED_H_

Definition at line 12 of file pemixed.h.

◆ SUB_BIN_DOS

#define SUB_BIN_DOS   0

Definition at line 7 of file pemixed.h.

◆ SUB_BIN_NATIVE

#define SUB_BIN_NATIVE   1

Definition at line 8 of file pemixed.h.

◆ SUB_BIN_NET

#define SUB_BIN_NET   2

Definition at line 9 of file pemixed.h.

Function Documentation

◆ rz_bin_pemixed_extract()

RzBinPEObj* rz_bin_pemixed_extract ( struct rz_bin_pemixed_obj_t *  bin,
int  sub_bin 
)

Definition at line 115 of file pemixed.c.

115  {
116  if (!bin) {
117  return NULL;
118  }
119 
120  switch (sub_bin) {
121  case SUB_BIN_DOS:
122  return bin->sub_bin_dos;
123  case SUB_BIN_NATIVE:
124  return bin->sub_bin_native;
125  case SUB_BIN_NET:
126  return bin->sub_bin_net;
127  }
128  return NULL;
129 }
NULL
#define NULL
Definition: cris-opc.c:27
SUB_BIN_NATIVE
#define SUB_BIN_NATIVE
Definition: pemixed.h:8
SUB_BIN_DOS
#define SUB_BIN_DOS
Definition: pemixed.h:7
SUB_BIN_NET
#define SUB_BIN_NET
Definition: pemixed.h:9
bin
Definition: malloc.c:26

References NULL, SUB_BIN_DOS, SUB_BIN_NATIVE, and SUB_BIN_NET.

Referenced by oneshot().

◆ rz_bin_pemixed_free()

void* rz_bin_pemixed_free ( struct rz_bin_pemixed_obj_t *  bin)

Definition at line 137 of file pemixed.c.

137  {
138  if (!bin) {
139  return NULL;
140  }
141  // only one free is nessescary since they all point
142  // to the same original pe struct
143  // possible memleak here
144  PE_(rz_bin_pe_free)
145  (bin->sub_bin_net);
146  if (bin->sub_bin_dos) {
147  rz_buf_free(bin->sub_bin_dos->b); // dos is the only one with its own buf
148  }
149  free(bin->sub_bin_dos);
150  free(bin->sub_bin_native);
151 
152  // PE_(rz_bin_pe_free)(bin->sub_bin_native);
153  // PE_(rz_bin_pe_free)(bin->sub_bin_net);
154  rz_buf_free(bin->b);
155  RZ_FREE(bin);
156  return NULL;
157 }
free
RZ_API void Ht_() free(HtName_(Ht) *ht)
Definition: ht_inc.c:130
rz_bin_pe_free
void *PE_() rz_bin_pe_free(RzBinPEObj *bin)
Definition: pe.c:88
PE_
#define PE_(name)
Definition: pe_specs.h:23
rz_buf_free
RZ_API void rz_buf_free(RzBuffer *b)
Free all internal data hold by the buffer and the buffer.
Definition: buf.c:1253
RZ_FREE
#define RZ_FREE(x)
Definition: rz_types.h:369

References free(), NULL, PE_, rz_bin_pe_free(), rz_buf_free(), and RZ_FREE.

Referenced by free_xtr(), and rz_bin_pemixed_from_bytes_new().

◆ rz_bin_pemixed_from_bytes_new()

struct rz_bin_pemixed_obj_t* rz_bin_pemixed_from_bytes_new ( const ut8 *  buf,
ut64  size 
)

Definition at line 159 of file pemixed.c.

159  {
160  struct rz_bin_pemixed_obj_t *bin = RZ_NEW0(struct rz_bin_pemixed_obj_t);
161  RzBinPEObj *pe_bin;
162  if (!bin || !buf) {
163  return rz_bin_pemixed_free(bin);
164  }
165  bin->b = rz_buf_new_with_bytes(buf, size);
166  if (!bin->b) {
167  return rz_bin_pemixed_free(bin);
168  }
169  bin->size = size;
170  pe_bin = PE_(rz_bin_pe_new_buf)(bin->b, true);
171  if (!pe_bin) {
172  PE_(rz_bin_pe_free)
173  (pe_bin);
174  return rz_bin_pemixed_free(bin);
175  }
176  if (!pe_bin->clr || !pe_bin->clr->header) {
177  PE_(rz_bin_pe_free)
178  (pe_bin);
179  return rz_bin_pemixed_free(bin);
180  }
181  // check if binary only contains managed code
182  // check implemented here cuz we need to intialize
183  // the pe header to access the clr hdr
184  if (check_il_only(pe_bin->clr->header->Flags)) {
185  PE_(rz_bin_pe_free)
186  (pe_bin);
187  return rz_bin_pemixed_free(bin);
188  }
189  if (!rz_bin_pemixed_init(bin, pe_bin)) {
190  PE_(rz_bin_pe_free)
191  (pe_bin);
192  return rz_bin_pemixed_free(bin);
193  }
194  return bin;
195 }
size
voidpf void uLong size
Definition: ioapi.h:138
buf
voidpf void * buf
Definition: ioapi.h:138
rz_bin_pe_new_buf
RzBinPEObj *PE_() rz_bin_pe_new_buf(RzBuffer *buf, bool verbose)
Definition: pe.c:116
RzBinPEObj
#define RzBinPEObj
Definition: pe.h:126
check_il_only
static bool check_il_only(ut32 flags)
Definition: pemixed.c:132
rz_bin_pemixed_free
void * rz_bin_pemixed_free(struct rz_bin_pemixed_obj_t *bin)
Definition: pemixed.c:137
rz_bin_pemixed_init
static int rz_bin_pemixed_init(struct rz_bin_pemixed_obj_t *bin, RzBinPEObj *pe_bin)
Definition: pemixed.c:9
rz_buf_new_with_bytes
RZ_API RZ_OWN RzBuffer * rz_buf_new_with_bytes(RZ_NULLABLE RZ_BORROW const ut8 *bytes, ut64 len)
Creates a new buffer with a bytes array.
Definition: buf.c:465
RZ_NEW0
#define RZ_NEW0(x)
Definition: rz_types.h:284
rz_bin_pemixed_obj_t
Definition: pemixed.h:14

References check_il_only(), PE_, rz_bin_pe_free(), rz_bin_pe_new_buf(), rz_bin_pemixed_free(), rz_bin_pemixed_init(), rz_buf_new_with_bytes(), RZ_NEW0, and RzBinPEObj.

Referenced by oneshot().

◆ rz_bin_pemixed_init_dos()

RzBinPEObj* rz_bin_pemixed_init_dos ( RzBinPEObj *  pe_bin)

Definition at line 30 of file pemixed.c.

30  {
31  ut8 *tmp_buf;
32 
33  ut64 pe_hdr_off = pe_bin->dos_header->e_lfanew;
34 
35  // idk if this is the most efficient way but could not find a function to read
36  // RzBuffer into another RzBuffer
37  if (!(tmp_buf = malloc(pe_hdr_off))) {
38  return NULL;
39  }
40 
41  if ((rz_buf_read_at(pe_bin->b, 0, tmp_buf, pe_hdr_off)) == -1) {
42  RZ_LOG_ERROR("Cannot read buffer\n");
43  return NULL;
44  }
45 
46  RzBinPEObj *sub_bin_dos = RZ_NEW0(RzBinPEObj);
47  if (!(sub_bin_dos->b = rz_buf_new_with_bytes(tmp_buf, pe_hdr_off))) {
48  PE_(rz_bin_pe_free)
49  (sub_bin_dos);
50  return NULL;
51  }
52 
53  sub_bin_dos->size = pe_hdr_off;
54  sub_bin_dos->dos_header = pe_bin->dos_header;
55 
56  free(tmp_buf);
57  return sub_bin_dos;
58 }
ut8
uint8_t ut8
Definition: lh5801.h:11
malloc
void * malloc(size_t size)
Definition: malloc.c:123
rz_buf_read_at
RZ_API st64 rz_buf_read_at(RZ_NONNULL RzBuffer *b, ut64 addr, RZ_NONNULL RZ_OUT ut8 *buf, ut64 len)
Read len bytes of the buffer at the specified address.
Definition: buf.c:1136
RZ_LOG_ERROR
#define RZ_LOG_ERROR(fmtstr,...)
Definition: rz_log.h:58
ut64
ut64(WINAPI *w32_GetEnabledXStateFeatures)()

References free(), malloc(), NULL, PE_, rz_bin_pe_free(), rz_buf_new_with_bytes(), rz_buf_read_at(), RZ_LOG_ERROR, RZ_NEW0, RzBinPEObj, and ut64().

Referenced by rz_bin_pemixed_init().

◆ rz_bin_pemixed_init_native()

RzBinPEObj* rz_bin_pemixed_init_native ( RzBinPEObj *  pe_bin)

Definition at line 60 of file pemixed.c.

60  {
61  ut8 *zero_out;
62 
63  RzBinPEObj *sub_bin_native = RZ_NEW0(RzBinPEObj);
64  memcpy(sub_bin_native, pe_bin, sizeof(RzBinPEObj));
65 
66  // copy pe_bin->b and assign to sub_bin_native
67 
68  // if (!(tmp_buf = malloc (b_size))) {
69  // RZ_LOG_ERROR("bad malloc\n");
70  // };
71 
72  // if (!(rz_buf_read_at (pe_bin->b, 0, tmp_buf, b_size))) {
73  // free (sub_bin_native);
74  // return NULL;
75  // }
76 
77  if (!(sub_bin_native->b = rz_buf_new_with_buf(pe_bin->b))) {
78  free(sub_bin_native);
79  RZ_LOG_ERROR("failed to create new buffer\n");
80  return NULL;
81  }
82 
83  // calculate the dotnet data directory offset
84  int dotnet_offset = pe_bin->dos_header->e_lfanew;
85  dotnet_offset += sizeof(PE_(image_nt_headers));
86  dotnet_offset -= sizeof(PE_(image_data_directory)) * 2;
87 
88  if (!(zero_out = (ut8 *)calloc(2, 4 * sizeof(ut8)))) {
89  // can't call PE_(rz_bin_pe_free) since this will free the underlying pe_bin
90  // object which we may need for later
91  // PE_(rz_bin_pe_free) (sub_bin_native);
92  rz_buf_free(sub_bin_native->b);
93  free(sub_bin_native);
94  return NULL;
95  }
96 
97  if (rz_buf_write_at(sub_bin_native->b, dotnet_offset, zero_out, sizeof(PE_(image_data_directory))) < -1) {
98  RZ_LOG_ERROR("Zeroing out dotnet offset failed\n");
99  rz_buf_free(sub_bin_native->b);
100  free(sub_bin_native);
101  free(zero_out);
102  return NULL;
103  }
104 
105  free(zero_out);
106  return sub_bin_native;
107 }
memcpy
memcpy(mem, inblock.get(), min(CONTAINING_RECORD(inblock.get(), MEMBLOCK, data) ->size, size))
calloc
void * calloc(size_t number, size_t size)
Definition: malloc.c:102
rz_buf_write_at
RZ_API st64 rz_buf_write_at(RZ_NONNULL RzBuffer *b, ut64 addr, RZ_NONNULL const ut8 *buf, ut64 len)
Write len bytes of the buffer at the specified address.
Definition: buf.c:1197
rz_buf_new_with_buf
RZ_API RZ_OWN RzBuffer * rz_buf_new_with_buf(RzBuffer *b)
Creates a new buffer from a source buffer.
Definition: buf.c:448

References calloc(), free(), memcpy(), NULL, PE_, rz_buf_free(), rz_buf_new_with_buf(), rz_buf_write_at(), RZ_LOG_ERROR, RZ_NEW0, and RzBinPEObj.

Referenced by rz_bin_pemixed_init().