(Feb 17, 2022 02:53 PM)movss Wrote:  Implement a virtual machine that doesn't use the instruction cycle, and instead uses threaded coding to execute handlers pertaining to the machine's ISA.

An example would include:

mov eax, ecx
>
VM
>
tons of x86_64 opcodes that are responsible for handling your VMs opcodes.

This would be utterly confusing to the reader, and in doing so would have to reverse each "handler" and figure out what they are doing.
With dead code obfuscation, control flow obfuscation, opaque predicates this process becomes non trivial.

But easily defeated with LLVM + MCSEMA

(Feb 17, 2022 03:19 PM)yuumi Wrote:  It isn't meant to be an obfuscation challenge. It has nothing to do with manipulating the .text section at runtime and running the executable code through a separate handler which maps VM operations to actual instruction. It's a simple C based VM like a bytecode emulator.

I'm not asking a beginner in C to write an entire obfuscation virtual machine.

(Feb 17, 2022 03:23 PM)movss Wrote:  doesn't pertain to obfuscation
obfuscation is an additive obscurity measure for the aforementioned VM design

using handlers that are threaded is far more a better learning experience than a trivial instruction cycle

(Feb 17, 2022 10:04 PM)EmacsSucksButILikeIt Wrote:  I'm a bit out of touch with C and C++ but isn't the below C++ and this is a challenge for C.

Code

enum vm_op : uint8_t{
    kR0,
    kR1,
    kRax,
    kRdx,
    kHalt,
    kMovReg,
    kMovConst,
    kAddReg,
    kAddConst,
    kSubReg,
    kSubConst,
};

(Feb 17, 2022 10:22 PM)movss Wrote:  semantics retard
get the fuck out of this thread

(Feb 17, 2022 10:04 PM)EmacsSucksButILikeIt Wrote:  I'm a bit out of touch with C and C++ but isn't the below C++ and this is a challenge for C.

Code

enum vm_op : uint8_t{
    kR0,
    kR1,
    kRax,
    kRdx,
    kHalt,
    kMovReg,
    kMovConst,
    kAddReg,
    kAddConst,
    kSubReg,
    kSubConst,
};

(Feb 17, 2022 10:28 PM)EmacsSucksButILikeIt Wrote:  You understand this is for people that have a basic understanding of C and probably programming.... You shouldn't be posting confusing and conflicting information in your challenge.

Nice challenge BTW.

Quote:The return value register should be rax

(Feb 18, 2022 03:36 AM)EmacsSucksButILikeIt Wrote:  Might try this latter today.


Does this mean you expect to support function calls?

Also... Which direction are you moving your registers. Are you using AT&T or Intel style moves.

(Feb 18, 2022 07:14 AM)yuumi Wrote:  It’s intel syntax
Semantic:
Instruction destination source

No it doesn't have to support function calls the result in rax portion was just something I threw in the bytecode example. You can consider that irrelevant.

Quote:rax 9, rdx 0, r0 16, r1 0

(Feb 18, 2022 08:01 AM)EmacsSucksButILikeIt Wrote:  I'll use it(Rax) as an exit code for the byte code.

---

This is so easy to implement in a functional language(OCaml)... In C its a bit of a mess.

Code

type instr_reg = R0 | R1 | Rax | Rdx

type op_codes =
    MovConstReg of (int * instr_reg)
  | MovRegReg of (instr_reg * instr_reg)
  | AddConstReg of (int * instr_reg)
  | AddRegReg of (instr_reg * instr_reg)
  | SubConstReg of (int * instr_reg)
  | SubRegReg of (instr_reg * instr_reg)
  | Halt

let byte_code = [
  MovConstReg(10, R0);
  AddConstReg(5, R0);
  MovConstReg(3, Rax);
  SubRegReg(R0, Rax);
  MovConstReg(4, Rax);
  AddRegReg(R0, Rax);
  MovRegReg(Rax, R0);
  SubConstReg(7, Rax);
  Halt;
]

let process_byte_code bc =
  let rax = ref 0 in
  let rdx = ref 0 in
  let r0 = ref 0 in
  let r1 = ref 0 in
  let rec get_reg r =
    match r with
    | Rax -> rax
    | Rdx -> rdx
    | R0 -> r0
    | R1 -> r1 in
  let rec process_byte_code_aux bc =
    match bc with
    | [] -> failwith "Invalid byte code sequence"
    | hd::tl ->
      match hd with
      | Halt ->
        (
          Printf.printf "rax %d, rdx %d, r0 %d, r1 %d\n" !rax !rdx !r0 !r1;
          !rax
        )
      | MovConstReg (c, r) ->
        (
          (get_reg r) := c;
          process_byte_code_aux tl
        )
      | MovRegReg (r1, r2) ->
        (
          (get_reg r1) := !(get_reg r2);
          process_byte_code_aux tl
        )
      | AddConstReg (c, r) ->
          (
            (get_reg r) := !(get_reg r) + c;
            process_byte_code_aux tl
          )
      | SubRegReg (r1, r2) ->
        (
          (get_reg r1) := !(get_reg r1) - !(get_reg r2);
          process_byte_code_aux tl
        )
      | AddRegReg(r1, r2) ->
        (
          (get_reg r1) := !(get_reg r1)+ !(get_reg r2);
          process_byte_code_aux tl
        )
      | SubConstReg(c, r) ->
        (
          (get_reg r) := !(get_reg r) - c;
          process_byte_code_aux tl
        ) in
  process_byte_code_aux bc

let () =
  print_endline(string_of_int (process_byte_code byte_code))

The final register values. I think I got all the moves right.

I'll see if I can get a working C version soon.