oblivia-simplex

LUCCA: I want to set up a small networking lab containing a handful of hosts running different OSes, where it's possible to move from any host on the network to any other, but where the connectivity graph isn't necessarily fully connected. could you please write me a docker compose file that implements this? 8 hosts would be sufficient.
WINTERMUTE: Here is a Docker Compose file that will deploy 8 Docker containers representing hosts on a small network with a topology that is not fully connected:

version: '3' 
services: 

  host1: 
    image: ubuntu 
    networks: 
      - net1 

oblivia-simplex

/* DISPLAY WARNING: Type casts are NOT being printed */

void * FUN_4520a9bc(uint *param_1,uint *param_2,size_t param_3)

{
  undefined8 *puVar1;
  undefined8 *puVar2;
  uint *puVar3;
  byte *pbVar4;

oblivia-simplex

/* /--------------------------------------------------------------------------------\
   |AI generated comment, take with a grain of salt:                                |
   |                                                                                |
   |    Here is my analysis of the code:                                            |
   |    $param_1 -> src                                                             |
   |    $param_2 -> dst                                                             |
   |    $param_3 -> length                                                          |
   |    FUN_4520a9bc :: memcpy                                                      |
   |    This function appears to implement a memcpy function which copies length    |

oblivia-simplex

/* /--------------------------------------------------------------------------------\
   |AI generated comment, take with a grain of salt:                                |
   |                                                                                |
   |    The function FUN_4520a9bc appears to be a custom implementation of the      |
   |memmove function, which copies a block of memory from one location to another,  |
   |handling overlapping regions correctly.                                         |
   |    Let's start by renaming the variables and the function itself:              |
   |    ```                                                                         |
   |    $param_1 -> $src                                                            |

oblivia-simplex

/* DISPLAY WARNING: Type casts are NOT being printed */

void * FUN_4520a9bc(uint *param_1,uint *param_2,size_t param_3)

{
  undefined8 *puVar1;
  undefined8 *puVar2;
  uint *puVar3;
  byte *pbVar4;

oblivia-simplex

Keybase proof

I hereby claim:

• I am oblivia-simplex on github.
• I am oblivia (https://keybase.io/oblivia) on keybase.
• I have a public key whose fingerprint is 4355 B493 420C 9E65 A671 3C77 DCA4 8036 3F3D 0241

To claim this, I am signing this object:

oblivia-simplex

/**
 * Calls an array of arbitrary machine instructions as a subroutine,
 * and returns a serialized representation of the register state at
 * the end of the array's execution. 
 * No security features at all have been implemented. Intended
 * application: AIM-GP (automatic induction of machine code through
 * genetic programming), or something like that. 
 **/

unsigned char * code_call (unsigned char *code){

oblivia-simplex

(defmacro call-code (code types-and-args)
  "Pokes machine code into memory and calls it as a function. 
Types-and-args should be an unquoted list of the form
 :cffi-type-keyword argument :cffi-type-keyword argument [etc]
 :cffi-type-keyword
where the final type keyword specifies the return type."
  `(let ((ptr (cffi:foreign-alloc :unsigned-char
                                  :initial-contents ,code)))
    (unwind-protect 
          (cffi:foreign-funcall-pointer ptr () ,@types-and-args)

oblivia-simplex

;;; A couple of functions for disassembling arbitrary byte sequences in SBCL common lisp. 

(defun sapify (seq)
"Take a sequence of byte-sized integers and return the corresponding a system-area-pointer."
  (sb-sys:vector-sap
   (make-array (length seq)
               :element-type '(unsigned-byte 8)
               :initial-contents (coerce seq 'list))))

(defun disas-seq (seq len)

oblivia-simplex

#include <stdio.h>
#include <string.h>

int f(void){
  int i;
  char arr1[64];
  char arr2[64];
  memset(arr1, 'X', 63);
  memset(arr2, 'Y', 63);
  arr1[63] = arr2[63] = '\0';