• Stars
    star
    167
  • Rank 226,635 (Top 5 %)
  • Language
    Common Lisp
  • Created over 8 years ago
  • Updated over 5 years ago

Reviews

There are no reviews yet. Be the first to send feedback to the community and the maintainers!

Repository Details

Return Oriented Programme Evolution with ROPER
NOTE: Under development. Not yet ready for actual use. 
 ____   ___  ____  _____ ____  
|  _ \ / _ \|  _ \| ____|  _ \ 
| |_) | | | | |_) |  _| | |_) |
|  _ <| |_| |  __/| |___|  _ < 
|_| \_\\___/|_|   |_____|_| \_\
                               
A GENETIC ROP-CHAIN DEVELOPMENT TOOL

                                                                      
  /////////////////////////////////////////////////////////////////// 
  \\                                      `-. ``-`..`              // 
  \\                                     .+`...-o- .`.`            // 
  \\         ```              ``.-`      h:-`    ./h-`...`         // 
  \\   `..---:--+:-         .-:. `h-     +m`+.     `.+..`.-        // 
  \\  --.:://:-.-``:`      +-.,`: .--     :-.s+`.      ```         // 
  \\  .```      `/ `:     .Ns. ~_~ .o.      `---/..::`             // 
  \\            `s .-     //o` β­•  +y.        `.+o/.o.`           // 
  \\            h:`/     .://`_____+:.:+`         `.-` o`          // 
  \\          `y- -`    :.`-:./:+:`+```sm/`         `:`//          // 
  \\         `:.-+.    -h``../oyy:::`` `/.s.         +s-/          // 
  \\        ```:y-     om.`-``-+//. `.: .h++`       :++s           // 
  \\      `.  -o`     .;o:+-  ...-:/..o`/s.`/-..``---:y.     ``````// 
  \\    `-. `..     -.` -.y`'y\/\/\/y`o.:`s`.:....y//-``..``..``.-.// 
  \\   .+``..     `h+:`oy`:{          }-`-dysds+---..-..://-:--..--// 
  \\  .h-:-`     .yh:/dMh.` :/\/\/\/\-   `sdy-.--.-`.--:/:-``      // 
  \\  y/:s     `-+/-hy/hs..`:`/;;;/:.` .``/s+`.``/s//-`          `/// 
  \\  m:.:-` `:---s+.``/.:.`...::-+``` o..+:+o:/o-`            `-/.// 
  \\  /...``.-+++o/.`..`/: .``.`` `-```s+`/mN:...``.```.``...`.:oo-// 
  \\   ``....-//:...`.-+h+//``. . -s-./+/  :+-.--..----:-:/:--/o.  // 
  \\     ``..``+y..--s:ydyd:``    oy+::.- ``:/oo/o/:/:-.`.-..:---` // 
  \\   ``-` .s:o//+/.o+ss+s-   `` .`````/ .o+ds`::.--..``` ``-/.-:`// 
  \\  -.``/:ys/:--./hm/.`.`   `-::+:`  `ho..+s`               - -`:// 
  \\ .s .o+--/+./yo/hy..-` `-+--.://. ` -mydh`                ..``-// 
  \\ /: -.`/s/.sy-` oNy/+o/-..--.```````.+hhy.```             `- .`//
  \\ /y``-hs:-/-    sd:--.`.--`````` `-`.``..`````.``        `. .` // 
  \\ .N` .so/-``...`` `.--/::`--.  `...-. +md`  `..`.``.`.  .````  // 
  \\  +/-`  ``.-  `./oyy/ys-```-:  /..` . +dd       `.. ``````.`   // 
  \\   .+s++/++:```/mmmy+m-`    .  --`` .`o+o-          `  ``      // 
  \\    :o--.     .ddmdymo:     `  -- `  `:-.o:                    // 
  \\    .dh.:`   .dydNMNd`.    ``   . :`  `   +o                   // 
  \\     :d/--...ymdhhmd:`````  ``  ` ` `   o+mN+                  // 
  \\      `/+.``````````````....`     `    /dohmN-                 // 
  \\         `.odyo/oy+:--.-`....-  ` `       `:ss.                // 
  \\          -NMMy+Nhy...:`:-/moo` .h-      `` `:s:`              // 
  \\          hMMMNNhs+  `o:yodmd`- -Nh-``   yd+.  `s.             // 
  \\          yhmmNm/.   :hysmMMNs: `dNdd:   dNmd/..:`             // 
  \\             `/h``  .mmNmyoooyy:..`--/...-`  ``                // 
  \\             -N:    -Nho:                                      // 
  \\              -/-.:/s+.                                        // 
  \\                  `                                            // 
  '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
  

Genetic programming platform for evolving ROP-chain payloads,
implemented in Rust. Under construction.

                          BRIEF EXPLANATION

ROPER is a genetic ROP-chain compiler that I have designed and developed. It
compiles ROP-chains, by creating a miniature ecosystem in which ROP-chains
evolve.  ROPER can be used to develop payloads -- including payloads that
exhibit learned or evolved behaviour -- unlikely to be developed by humans.

Definitions:

1. Return-Oriented Programming is an exploit technique that, instead of writing
malicious code ("shellcode") into a process' executable memory, collages
together a series of "gadgets" that already subside in executable memory. This
is useful when the process has no memory segments that are flagged as both
executable and writeable (W^X/DEP). 

2. Genetic programming is the implementation of natural selection in code.  A
population of random programmes (in this case, ROP-chains) is generated. A
fitness function is then defined, and used to rank the results of their
execution. Fitter programmes are made more likely to breed. Mutation operators
are applied to the offspring, and the next generation of the process begins.
This carries on until the desired outcome is obtained. 

[branch for adding channel based concurrency model, replacing crappy existing one]

More Repositories

1

plog

A bare-bones blogging system, written in Prolog
Prolog
25
star
2

monsoon

A binary rainfall visualizer for packet captures. Idea taken from Greg Conti's "Security Data Visualization".
Common Lisp
13
star
3

berbalang

WIP: evolutionary explorations of weird machines
Rust
9
star
4

cl-unicorn

Common Lisp bindings for the Unicorn emulation engine (www.unicorn-engine.org)
Common Lisp
7
star
5

angelusnovus

Scans browser history databases for sites known to be malicious by virustotal
Python
6
star
6

deprecated-refusr-repo

Reverse engineering functions using symbolic regression
StringTemplate
6
star
7

nasl-tracer

Reconstructs the call stack from nasl -T traces, and displays the trace in a more meaningful and readable way.
Python
4
star
8

tmux-enum

Local enumeration script for hosts, via tmux send-keys
Shell
3
star
9

genlin

An engine for linear genetic programming, written in Common Lisp.
Common Lisp
3
star
10

offsec-junkdrawer

odds and ends i like to keep handy for offsec purposes
C
3
star
11

tmux_ptyneas

Shell
3
star
12

NeuroWorm

NeuroWorm
Python
3
star
13

iprange

Small tool for generating lists of IP addresses from CIDR or min-max range.
C
2
star
14

wizbang

A parser and editor for character data in Wizardry 1's WIZ1.DSK file. Mostly just an exercise in Haskell.
Haskell
2
star
15

offline_site

HTML
2
star
16

roper-doc

Documentation, slide decks, papers, and a thesis on ROPER
TeX
2
star
17

omnitrace

a quick and dirty instruction tracer
C
2
star
18

slothrop

ROPER III (WIP)
Julia
2
star
19

emacs-sedition

Missing those sweet sed-style ex commands from your favourite ex-editor? Weep no more.
Emacs Lisp
2
star
20

snek

Rudimentary snake game in common lisp, optimized for parallelism and deterministic random-seeding. Intended for use in evolutionary computation.
Common Lisp
2
star
21

cmoskit

C
1
star
22

xsim

rudimentary CPU emulator, written in C
Groff
1
star
23

sym-evm

Symbolic Execution of Ethereum Virtual Machine
Haskell
1
star
24

terminal-chatbot

A chatbot for the terminal
Python
1
star
25

pat

pat the pattern generator! just a simplified, and much faster, version of metasploit's pattern_create.rb
Python
1
star
26

unicorn-fuzz

Rust
1
star
27

Cockatrice.jl

Tools and data structures for designing genetic programming systems
Julia
1
star
28

AntelopeEditions

A make file and utilities for generating beautiful ebooks
TeX
1
star
29

cl-mersenne

Quick and dirty implementation of Mersenne Twister PRNG in Common Lisp
Common Lisp
1
star
30

roguishly

a rough little roguelike, writen in common lisp. bit of a ways from playable, yet
Common Lisp
1
star
31

feral_machines

a blog, running on p'log
HTML
1
star
32

backdoor-locksmith

A lockpick for backdoors on Phicomm routers -- ported to Rust!
Rust
1
star
33

jira-dashboard

a very simple cli interface to replace the godawful jira dashboard gui
Python
1
star