1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
|
package main
import (
"fmt"
"math/rand"
"strings"
"time"
r2pipe "github.com/radare/r2pipe-go"
"github.com/sirupsen/logrus"
)
func buildBots(config *Config) {
logrus.Info("Building all bots")
// build all the bots
for i := 0; i < config.AmountOfBots; i++ {
buildBot(i, config)
}
}
// buildBot builds the bot located at the given path.
func buildBot(i int, config *Config) {
logrus.Debugf("Building bot %d", i)
// open radare without input for building the bot
r2p1, err := r2pipe.NewPipe("--")
if err != nil {
panic(err)
}
defer r2p1.Close()
// Compile a warrior using rasm2
//
// This uses the given architecture, the given bitness and the given path in
// rasm2 to compile the bot
botPath := config.Bots[i].Path
radareCommand := fmt.Sprintf("rasm2 -a %s -b %d -f %s", config.Arch, config.Bits, botPath)
botSource := r2cmd(r2p1, radareCommand)
config.Bots[i].Source = botSource
}
// init initializes the arena
func initArena(config *Config) *r2pipe.Pipe {
logrus.Info("Initializing the arena")
logrus.Debugf("Allocating %d bytes of memory...", config.Memsize)
// allocate memory
r2p, err := r2pipe.NewPipe(fmt.Sprintf("malloc://%d", config.Memsize))
if err != nil {
panic(err)
}
logrus.Info("Memoy successfully allocated")
// define the architecture and the bitness
_ = r2cmd(r2p, fmt.Sprintf("e asm.arch = %s", config.Arch))
_ = r2cmd(r2p, fmt.Sprintf("e asm.bits = %d", config.Bits))
// enable colors
// _ = r2cmd(r2p, "e scr.color = 0")
_ = r2cmd(r2p, "e scr.color = 3")
_ = r2cmd(r2p, "e scr.color.args = true")
_ = r2cmd(r2p, "e scr.color.bytes = true")
_ = r2cmd(r2p, "e scr.color.grep = true")
_ = r2cmd(r2p, "e scr.color.ops = true")
_ = r2cmd(r2p, "e scr.bgfill = true")
_ = r2cmd(r2p, "e scr.color.pipe = true")
_ = r2cmd(r2p, "e scr.utf8 = true")
// hex column width
_ = r2cmd(r2p, "e hex.cols = 32")
// initialize ESIL VM state
logrus.Debug("Initializing the ESIL VM")
_ = r2cmd(r2p, "aei")
// initialize ESIL VM stack
logrus.Debug("Initializing the ESIL Stack")
_ = r2cmd(r2p, "aeim")
// return the pipe
return r2p
}
// getRandomOffsets returns random offsets for all bots
// This is used to get the offset the bots are initially placed in
func getRandomOffsets(config Config) []int {
var amountOfBots int = len(config.Bots)
var offsets []int
var roundCounter int = 0
// seed the random number generator
rand.Seed(time.Now().UTC().UnixNano())
for {
// define an integer array to store the random offsets in
//var offsets []int = []int{}
// define a random address
address := rand.Intn(config.Memsize - config.MaxProgSize)
// for all bots, try to generate another random address after the intially
// generated address and test if it fits in memory
for i := 0; i < amountOfBots; i++ {
offsets = append(offsets, address)
// generate a random value in range [maxProgSize, maxProgSize + 300)
address += rand.Intn(config.MaxProgSize+300) + config.MaxProgSize
// if there is not enough memory remaining after the last generated
// address, start from be beginning
if address+config.MaxProgSize > config.Memsize {
roundCounter++
continue
}
}
// if enough addresses have been generated, break out of the for loop
break
}
log.Printf("[+] Initial bot positions found after %d trues", roundCounter)
return offsets
}
// place the bot in the arena at the given address
func placeBot(r2p *r2pipe.Pipe, bot Bot, address int) {
_ = r2cmd(r2p, fmt.Sprintf("wx %s @ %d", bot, address))
}
|
