def encode_reed_salomon(arr):
arr_shape = arr.shape
arr.resize(arr.size)
rs = reedsolo.RSCodec(4)
reedsolo.RSCodec()
size_mod = arr.size % 4
rs_code = numpy.empty(arr.size * 2 - size_mod, numpy.uint8)
for x in range(0, arr.size - size_mod, 4):
rs_code[2 * x:2 * x + 8] = numpy.frombuffer(
rs.encode(arr[x:x + 4].tobytes()), numpy.uint8)
for x in range(size_mod):
rs_code.itemset((arr.size - size_mod) * 2 + x,
arr.item(arr.size - size_mod + x))
arr.resize(arr_shape)
return rs_code
def test_reed_solomon_encoding(self):
# fmt: off
pairs = [("a0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebf", "0404992ae0b12cb0ef0d4fd3"),
("11a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbd11bf", "e001803c2130884c190d57d5"),
("22a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbd22bf", "6c32056dd3fcc33fa6193773"),
("0a1a2a3a4a5a6a7a8a9aaabacadaeafa0b1b2b3b4b5b6b7b8b9babbbcbdbebfb", "08149eef461af628943c2661"),
("b3f455fb0b275123dec0e73c4becca19246bf2b103df401844a3bdcd3fd01a95", "500409183fa1b8e680568da7"),
("435777773fb1e36f7d6b5f1e99afaa7a57f16be0ed36bc057c7dae6a266d1504", "815d3007153d797bd6630d0e"),
("20a126c10f50ee871f43cfcfe4e62a492e3f729a6c48348a58863f3a482a69fe", "36150928f41dcacf396c0893"),
("a8d5fbda18d75605c422d2b10ac7f73283a5c9609d6b8c90ffaa96b84f133582", "a4f21330282242c9e20b6acf"),
("4296abb9a44432c8656d5605feffc25d71941fd0abf0ff0d61a01a19315a264c", "1bb4c3afd14b9023b33a2f15"),
("206e4f83f8173635d7d554d96b84586fbc3a4280b4403cba5834d3dc8e99a682", "1b7edac989c569cb08f9efd9"),
("57e8dc1b37c6b53a428fc6d7242114eaf3d80b0447bb642703120a257cf7ec52", "5ee82f785f3d5e19df92635b"),
("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "13a36292597404257375e0aa"),
("f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0", "f66cb1ba3ee5d164a19668a0"),
("abad1deaabad1deaabad1deaabad1deaabad1deaabad1deaabad1deaabad1dea", "1171924a9b34c16878e182a5"),
("abad1deadeadbeefabadbabecafebabe11223344556677889900aabbccddeeff", "7601266085196663727c6522"),
("0000000000000000000000000000000000000000000000000000000000000000", "000000000000000000000000"),
("1000000000000000000000000000000000000000000000000000000000000000", "b6f06eae2266cc0bfca685ca"),
("0001000100010001000a000b000c000d000e000f000100010001000100010001", "6dc2afb4820bb002d9263544"),
("0000000000000000000000000000000000000000000000000000000000000001", "44774376dc1f07545c7fd561"),
] # Pregenerated pairs consisting of 32 bytes of data + 12 bytes of RS ECC (FPGA verified)
# fmt: on
rs = reedsolo.RSCodec(12) # 12 ECC symbols
for pair in pairs:
bin_base = bytearray.fromhex(pair[0])
# Encode the original 32 bytes of data
encoded_data = rs.encode([x for x in bin_base])
self.assertEqual(encoded_data, bytearray.fromhex(pair[0] + pair[1]))
def extract(storage_path: str, output_path: str):
"""
Used to extract data from the specified directory at the storage
path, and will write the extracted data to a file at the specified
output path.
"""
encoded_int_strings = CovertChannel.get_encoded_int_string(
storage_path)
found_start = False
next_index = 0
encoded_data = bytearray()
files_remaining = 0
files_captured = 0
for string in sorted(encoded_int_strings):
index = int(string[0:DIGITS_FOR_INDEX])
if index != 0:
if not found_start:
continue
elif files_remaining > 0:
files_remaining -= 1
files_captured += 1
byte = bytearray(int_to_bytes(
int(string[DIGITS_FOR_INDEX:])))
newbyte = bytes(byte)
while len(newbyte) < STORABLE_BYTES_PER_FILE:
newbyte = b'\x00' + bytes(newbyte)
encoded_data += bytearray(newbyte)
next_index += 1
else:
break
else:
found_start = True
files_remaining = int(string[DIGITS_FOR_INDEX:])
next_index = 1
files_captured += 1
print('Found data for {} files'.format(files_captured))
# Trim leading zero bytes
while bytes(encoded_data)[0] == 0:
encoded_data = encoded_data[1:]
# Decode the message from ECC message
decoded_message = reedsolo.RSCodec(
ERROR_CORRECTING_BYTES).decode(encoded_data)
# Retrieve original file extension
message_and_data = decoded_message.rsplit(b'.', 1)
message = message_and_data[0]
ext = message_and_data[1]
to_save = open(output_path + '.' + ext.decode("utf-8"), 'wb')
to_save.write(message)
def datagram_received(self, data, addr):
global time_data_recieved_start
global time_data_recieved_and_loaded
time_data_recieved_start = time.time()
time_fec_starts = 0
if (fec > 0):
rs = reedsolo.RSCodec(fec)
time_fec_starts = time.time()
data = rs.decode(data)
time_json_start = time.time()
original_message = json.loads(data.decode())
time_for_fec_and_dejson_end = time.time()
if addr not in self.qs.keys():
self.qs[addr] = queue.PriorityQueue(maxsize=2000)
pqs.append(self.qs[addr])
# print("recieved data")
add_packets_to_queue(self.qs[addr], original_message)
time_data_recieved_and_loaded = time.time()
time_packet_sync_start = time.time()
tuples = time_sync()
end_time = time.time()
analyze_tuples(tuples, end_time, time_data_recieved_start, \
time_data_recieved_and_loaded, time_packet_sync_start, \
time_for_fec_and_dejson_end, time_fec_starts, time_json_start)
# print("Close the socket")
self.transport.close()
def fix_data_errors(self):
for data_row, error_correction_row in self.error_correction_sequence.rows():
values = [cw.value for cw in data_row + error_correction_row]
rs = reedsolo.RSCodec(len(error_correction_row))
corrected = rs.decode(values)
for cw, value in zip(data_row, corrected):
cw.value = value
def __init__(self):
self.map = self.get_map()
self.chars = sorted(self.map.keys())
self.dsp = Signal(self.RATE)
self.rs = reedsolo.RSCodec(nsym=8,
nsize=20,
prim=0x25,
generator=2,
c_exp=5)
def rs_encode(self, payload):
""" Reed Solomon Error Correction Encoding """
rsl = self.get_rs_length(len(payload))
padded = [0] * (255 - rsl)
for i in range(0, len(payload)):
padded[i] = payload[i]
rs = reedsolo.RSCodec(nsym=rsl, fcr=1)
encoded = payload[:]
encoded.extend(list(rs.encode(padded))[-rsl:])
return encoded
def main(argv):
inputfile = ''
original_file = ''
indices_file = ''
try:
opts, args = getopt.getopt(argv, "h:d:i:o:",
["dfile=", "itype=", "ofile="])
except getopt.GetoptError:
print 'file.py -d <file_to_decode> -o <original_file> -i <indices_file>'
sys.exit(2)
for opt, arg in opts:
print opt, arg,
if opt == '-h':
print 'file.py -d <file_to_decode> -o <original_file> -i <indices_file> '
sys.exit()
elif opt in ("-d", "--dfile"):
inputfile = arg
elif opt in ("-i", "--itype"):
indices_file = arg
elif opt in ("-o", "--ofile"):
original_file = arg
else:
print "check help for usage"
sys.exit()
print inputfile
print inputfile.split('_')
to_decode_file = scipy.fromfile(open(inputfile), dtype=scipy.float32)
original_string = scipy.fromfile(open(original_file), dtype=scipy.float32)
oracle_indices = np.load(indices_file)
print "\n lengths for measured data:", len(
to_decode_file), "length of orig transmission: ", len(original_string)
get_index = start_index(to_decode_file)
start_data_index = get_index + 1 # get_index+1 #(m-get_index) #m - (len(preamble) - get_index) +1
print "starting of data is ", start_data_index
plt.plot(to_decode_file[:start_data_index], '*-')
plt.savefig('abhinav.pdf')
plt.clf()
original_message = original_string[len(preamble):]
to_decode_data1 = to_decode_file[start_data_index:]
to_decode_data = to_decode_data1.astype(np.int64)
#print "lengths of data going in:", len(original_message), len(to_decode_data)
#bin_rep_to_decode=decoding_maj3(oracle_indices,to_decode_data)
bin_rep_to_decode = single_demod(oracle_indices, to_decode_data)
ber_single(oracle_indices, to_decode_data, original_message)
print "\nGoing to decode"
rs = reedsolo.RSCodec(32)
message_decoded = ''
try:
message_decoded = rs.decode(bin_rep_to_decode)
except:
print "Cannot decode using RS decoder "
print "decoded message is ", message_decoded
print "\n"
def __init__(self, sym_bits=5, block_len=20, code_ratio=0.8):
self.sym_bits = sym_bits
self.block_len = block_len
self.code_ratio = code_ratio
self.msg_len = int(block_len * code_ratio)
self.ecc_len = self.block_len - self.msg_len
self.prim = reedsolo.find_prime_polys(c_exp=self.sym_bits)
self.codec = reedsolo.RSCodec(nsym=self.ecc_len,
prim=self.prim[0],
nsize=self.block_len,
c_exp=self.sym_bits)
def removeErrorCorrection(data):
completeData = bytes(b'')
for element in data:
completeData += bytes(element)
rs = reedsolo.RSCodec(40)
dataDecoded = rs.decode(completeData)
#dataDecoded = completeData
return dataDecoded
def burn_key(esp, args, data=None):
block_num = args.key_block + BLOCK_BY_NAME["BLOCK_KEY0"][1]
block = BLOCKS[block_num]
purpose_num = KEY_PURPOSES.index(args.purpose)
if data is None:
data = args.file.read()
if len(data) != 32:
raise esptool.FatalError(
"File must be exactly 32 bytes (this file was %d)" % (len(data)))
if args.purpose in [
"XTS_AES_256_KEY_1", "XTS_AES_256_KEY_2", "XTS_AES_128_KEY"
]:
print("Reversing byte order for AES-XTS hardware peripheral...")
data = data[::-1]
# apply RS encoding
rs = reedsolo.RSCodec(12)
encoded_data = rs.encode([x
for x in data]) # 32 byte of data + 12 bytes RS
words = struct.unpack("<" + "I" * 11, encoded_data)
# write key data
_clear_pgm_registers(esp)
for i in range(8):
esp.write_reg(EFUSE_PGM_DATA0_REG + 4 * i, words[i])
for i in range(3):
esp.write_reg(EFUSE_CHECK_VALUE0_REG + 4 * i, words[i + 8])
_efuse_program(esp, block_num)
# write purpose register for the key block
_clear_pgm_registers(esp)
_, purpose_word, purpose_mask, purpose_wr_dis_bit = BLK0_BY_NAME[
"KEY_PURPOSE_%d" % args.key_block]
esp.write_reg(EFUSE_PGM_DATA0_REG + 4 * purpose_word,
purpose_num << _shift(purpose_mask))
_efuse_program(esp, 0)
print("Write protecting purpose efuse and key block...")
_, _, _, blk_rd_dis_bit, blk_wr_dis_bit = block
_clear_pgm_registers(esp)
new_wr_dir = (1 << blk_wr_dis_bit) | (1 << purpose_wr_dis_bit)
esp.write_reg(EFUSE_PGM_DATA0_REG, new_wr_dir)
_efuse_program(esp, 0)
errs, fail = _get_block_errors(esp, block_num)
if errs == 0 and not fail:
print("(No encoding errors in block)")
else:
print("WARNING: Block has %d errors (failed=%s)" % (errs, fail))
print("Done")
def _decodeData(data):
decoder = reedsolo.RSCodec(7)
data=decoder.decode(data)[:19]
heximal = ""
for i in data:
heximal+="{:02X}".format(i)
heximal=heximal[3:]
while heximal[-1:]!="0":
heximal = heximal[:-2]
heximal=heximal[:-1]
bytesarr=bytearray.fromhex(heximal)
return bytesarr
def img2data(image, width, height, bucket, q, metaDataSize, metaDataOffset,
enSize, modulation_type):
"""
insert in blocks
"""
from . import video_helper_functions as vhf
import reedsolo
if modulation_type == "square_RGB":
dataOut = functions.demodulate_Square_RGB_Fast(image, width, height,
bucket, q)
elif modulation_type == "square_YUV":
dataOut = functions.demodulate_Square_YUV_Fast(image, width, height,
bucket, q)
elif modulation_type == "square_YUV2":
dataOut = functions.demodulate_Square_YUV_Fast2(
image, width, height, bucket, q)
else:
raise Exception("modulation type not supported")
# Get metadata
totMetaDataSize = metaDataSize + 8 * enSize
metaData = dataOut[:totMetaDataSize]
# Handle Reed-Solomon if needed
# THIS MIGHT NOT WORK
if enSize != 0:
metaData = bytearray(vhf.bit_array_2_bytes(metaData))
rs = reedsolo.RSCodec(enSize)
metaData = vhf.bytes_2_bit_list(rs.decode(metaData))
new_frame, index, offset, bitoffset = vhf.extract_metadata(
metaData, metaDataOffset)
if (0):
print("\n%%%%")
print("index", index)
print("offset", offset)
print("bitoffset", bitoffset)
print("length", len(dataOut))
print("metadata len", totMetaDataSize)
print("%%%%\n")
# cut up data
message = dataOut[totMetaDataSize:totMetaDataSize + offset]
size = totMetaDataSize + offset - bitoffset
if 0:
print(vhf.bit_array_2_bytes(dataOut[:totMetaDataSize + offset]))
return message[:len(message) -
bitoffset], new_frame, index, offset, bitoffset, size
def rs_decode(self, payload, length):
""" Reed Solomon Error Correction Decoding """
padded = [0] * 255
for i in range(0, length):
padded[i] = payload[i]
parity = payload[length:]
for i in range(0, len(parity)):
padded[255 - len(parity) + i] = parity[i]
try:
rs = reedsolo.RSCodec(nsym=len(parity), fcr=1)
return list(rs.decode(padded))[:length]
except reedsolo.ReedSolomonError:
print('Decode failed')
def __init__(self,
bits_per_symbol,
preamble=None,
log_ber_interval=10,
spy_length=64,
spy_threshold=0.1):
ModulatorClassic.__init__(self, bits_per_symbol, max_amplitude=0.09)
gr.basic_block.__init__(self,
name="modulator_classic",
in_sig=None,
out_sig=None)
# Echo protocol variables
assert preamble is not None, "Preamble must be provided"
if preamble is not np.ndarray:
preamble = np.array(preamble)
self.preamble = preamble
self.preamble_si = util_data.bits_to_integers(self.preamble,
self.bits_per_symbol)
self.log_ber_interval = log_ber_interval
# Message port setup and variables
self.port_id_in = pmt.intern("bits")
self.port_id_update = pmt.intern("update")
self.port_id_out = pmt.intern("symbols")
self.message_port_register_in(self.port_id_in)
self.message_port_register_in(self.port_id_update)
self.message_port_register_out(self.port_id_out)
self.set_msg_handler(self.port_id_in, self.handle_packet)
self.set_msg_handler(self.port_id_update, self.handle_update)
self.packet_cnt = 0
self.ber_cnt = 0
# Packet header and spy variables
self.spy_length = spy_length
assert self.spy_length % self.bits_per_symbol == 0
self.spy_threshold = spy_threshold
self.reedsolomon = reedsolo.RSCodec(4)
self.rs_length = 4 * 2 * 8 # 4 bytes data, 4 bytes parity, 8 bits per byte
# Logging stuff
self.uuid = uuid.uuid4()
self.uuid_str = str(self.uuid)[-6:]
self.logger = gr.logger("log_debug")
self.logger.set_level("DEBUG")
self.logger.info("classic mod {}: {} bits per symbol".format(
self.uuid_str, self.bits_per_symbol))
with open("ber_echo_{}.csv".format(self.uuid_str), "w") as f:
f.write("train_iter,BER\n")
def decode_reed_salomon(arr, shape):
rs = reedsolo.RSCodec(4)
size_mod = arr.size % 4
arr_out = numpy.empty(shape, numpy.uint8)
arr_out.resize(arr_out.size)
for i in range(0, arr_out.size - size_mod, 4):
try:
arr_out[i:i + 4] = numpy.frombuffer(
rs.decode(arr[2 * i:2 * i + 8].tobytes()), numpy.uint8)
except reedsolo.ReedSolomonError:
arr_out[i:i + 4] = arr[2 * i:2 * i + 4]
for i in range(size_mod):
arr_out.iteset(arr_out.size - size_mod + i,
arr.item((arr_out.size - size_mod) * 2 + i))
arr_out.resize(shape)
return arr_out
def encodeRS(arr):
arrShape = arr.shape # storing shape
arr.resize(arr.size)
rs = reedsolo.RSCodec(4)
sizeMod = arr.size % 4
arr_out = numpy.empty(arr.size * 2 - sizeMod, numpy.uint8)
for i in range(0, arr.size - sizeMod,
4): # looping through 4byte chunks in arr
arr_out[2 * i:2 * i + 8] = numpy.frombuffer(
rs.encode(arr[i:i + 4].tobytes()),
numpy.uint8) #inserting the encoded bytes into the output array
for i in range(sizeMod):
arr_out.itemset((arr.size - sizeMod) * 2 + i,
arr.item(arr.size - sizeMod + i))
arr.resize(arrShape)
return arr_out
def datagram_received(self, data, addr):
message = data.decode()
# print('Received %r from %s' % (message, addr))
# print("sending json_data", json_data)
data = data_generator(original_time, fps)
json_data = json.dumps(data).encode()
if (fec > 0):
rs = reedsolo.RSCodec(fec)
reed_data = rs.encode(json_data)
if network_delay_transmitter_to_client_over_udp > 0:
time.sleep(network_delay_transmitter_to_client_over_udp)
self.transport.sendto(reed_data, addr)
else:
if network_delay_transmitter_to_client_over_udp > 0:
time.sleep(network_delay_transmitter_to_client_over_udp)
self.transport.sendto(json_data, addr)
def __init__(self,
bits_per_symbol,
block_length=10000,
preamble=None,
log_ber_interval=10,
spy_length=64,
spy_threshold=0.1,
alias="demod_classic"):
DemodulatorClassic.__init__(self,
bits_per_symbol=bits_per_symbol,
block_length=block_length,
max_amplitude=0.09)
gr.basic_block.__init__(self,
name="demod_classic",
in_sig=None,
out_sig=None)
self.alias = alias
self.port_id_in = pmt.intern("symbols")
self.port_id_out = pmt.intern("bits")
self.port_id_corrupt = pmt.intern("corrupt")
self.message_port_register_in(self.port_id_in)
self.message_port_register_out(self.port_id_out)
self.message_port_register_out(self.port_id_corrupt)
self.set_msg_handler(self.port_id_in, self.handle_packet)
if preamble is not np.ndarray:
preamble = np.array(preamble)
self.preamble = preamble
self.packet_cnt = 0
self.update_cnt = 0
self.ber = None
self.log_ber_interval = log_ber_interval
self.spy_length = spy_length
assert self.spy_length % self.bits_per_symbol == 0
self.spy_threshold = spy_threshold
self.reedsolomon = reedsolo.RSCodec(4)
self.rs_length = 4 * 2 * 8 # 4 bytes data, 4 bytes parity, 8 bits per byte
self.uuid = uuid.uuid4()
self.uuid_str = str(self.uuid)[-6:]
self.logger = gr.logger("log_debug")
self.logger.set_level("DEBUG")
self.logger.info("classic demod {}: {} bits per symbol".format(
self.uuid_str, self.bits_per_symbol))
with open("ber_{}.csv".format(self.uuid_str), "w") as f:
f.write("iter,BER\n")
def handle_coding_scheme(self, blk, data):
if blk.id != 0:
# CODING_SCHEME RS applied only for all blocks except BLK0.
coded_bytes = 12
data.pos = coded_bytes * 8
plain_data = data.readlist('32*uint:8')[::-1]
# takes 32 bytes
# apply RS encoding
rs = reedsolo.RSCodec(coded_bytes)
# 32 byte of data + 12 bytes RS
calc_encoded_data = list(rs.encode([x for x in plain_data]))
data.pos = 0
if calc_encoded_data != data.readlist('44*uint:8')[::-1]:
raise FatalError("Error in coding scheme data")
data = data[coded_bytes * 8:]
if blk.len < 8:
data = data[(8 - blk.len) * 32:]
return data
def apply_coding_scheme(self):
data = self.get_raw(from_read=False)[::-1]
if len(data) < self.len_of_burn_unit():
add_empty_bytes = self.len_of_burn_unit() - len(data)
data = data + (b"\x00" * add_empty_bytes)
if self.get_coding_scheme() == self.parent.REGS.CODING_SCHEME_RS:
# takes 32 bytes
# apply RS encoding
rs = reedsolo.RSCodec(12)
# 32 byte of data + 12 bytes RS
encoded_data = rs.encode([x for x in data])
words = struct.unpack("<" + "I" * 11, encoded_data)
# returns 11 words (8 words of data + 3 words of RS coding)
else:
# takes 32 bytes
words = struct.unpack("<" + ("I" * (len(data) // 4)), data)
# returns 8 words
return words
def decodeRS(arr, shape):
rs = reedsolo.RSCodec(4)
sizeMod = arr.size % 4
arr_out = numpy.empty(shape, numpy.uint8)
arr_out.resize(arr_out.size)
for i in range(0, arr_out.size - sizeMod,
4): # looping through 8byte chunks in arr
try:
arr_out[i:i + 4] = numpy.frombuffer(
rs.decode(arr[2 * i:2 * i + 8].tobytes()), numpy.uint8
) #inserting the decoded bytes into the output array
except reedsolo.ReedSolomonError:
arr_out[i:i + 4] = arr[2 * i:2 * i + 4]
for i in range(sizeMod):
arr_out.iteset(arr_out.size - sizeMod + i,
arr.item((arr_out.size - sizeMod) * 2 + i))
arr_out.resize(shape)
return arr_out
class Share:
rs = reedsolo.RSCodec(10)
def __init__(self, raw_value, batch):
raw_value = "".join(raw_value.split())
self.raw_value = raw_value.replace("-", "")
self.batch = batch
self.code = ""
try:
decoded = self.rs.decode(bytes.fromhex(self.raw_value))
except Exception:
return
if len(decoded) == 33:
as_string = decoded.hex()
self.code = as_string[0:2] + "-" + as_string[2:]
def __eq__(self, other):
return self.raw_value == other.raw_value and \
self.batch == other.batch
def get_values(m):
rs_bytes = 20
codec = reedsolo.RSCodec(rs_bytes)
try:
with open("lpn.key", "r") as f:
key = json.loads(f.read())
key['pk'][0] = deserialize_mat(key['pk'][0])
key['pk'][1] = deserialize_mat(key['pk'][1])
key['sk'] = deserialize_mat(key['sk'])
except IOError as e:
assert e.strerror == 'No such file or directory'
key = MultiBitKeyGen(800)
with open("lpn.key", "w") as f:
f.write(serialize_key(key))
ctxt = MultiBitEnc(key['pk'], bytes(codec.encode(m)))
ptxt = codec.decode(bytearray(MultiBitDec(key['sk'], ctxt)))
return (key, ctxt, ptxt)
def insertErrorCorrection(inputFile):
if os.path.isfile(inputFile):
f = open(inputFile, "rb")
data = f.read()
f.close()
# add redundancy: each 215 bytes we add 40 ecc bytes and get a new chunk size of 255 bytes (~15% redundancy)
# with this behaviour we share the redundancy over the entire input message and thus over different timestamps
rs = reedsolo.RSCodec(40)
#print(data)
print(len(data))
dataEncoded = rs.encode(data)
#print(dataEncoded)
print(len(dataEncoded))
return dataEncoded
else:
print("No regular file.")
return 0
def brute_force(blocks, limit_error_correction, unknown_code_nums,
unknown_indexes, verbose):
brute_range = unknown_code_nums - limit_error_correction_num
assert (brute_range <= BF_LIMIT)
assert (len(unknown_indexes) >= brute_range)
target_indexes = unknown_indexes[0:brute_range]
if verbose:
print '[*] start bruteforce(%d bytes)' % brute_range
print '[*] target indexes' + repr(target_indexes)
# reverse for using reedsolomon module
blocks.reverse()
target_indexes = map(lambda x: len(blocks) - 1 - x, target_indexes)
brute_bytes_range = 1 << 8 * brute_range
for i in xrange(brute_bytes_range):
candidates = i
for j in xrange(brute_range):
blocks[target_indexes[j]] = candidates % 0x100
candidates >>= 8
try:
# is it always true?
rs = reedsolo.RSCodec(limit_error_correction_num * 2)
#print repr(bytearray(blocks))
corrected = rs.encode(rs.decode(bytearray(blocks)))
assert (len(corrected) == len(blocks))
# only one solution is possible?
for i in xrange(len(blocks)):
blocks[i] = corrected[i]
blocks.reverse()
return
except Exception, e:
#raise
pass
#print bytearray(blocks)
if i % 0x1000 == 0 and verbose:
print "[*] processing 0x%x/0x%x" % (i, brute_bytes_range)
def img2meta(image, width, height, bucket, q, metaDataSize, metaDataOffset,
enSize, modulation_type):
from . import video_helper_functions as vhf
import reedsolo
import sys
import traceback
try:
totMetaDataSize = metaDataSize + 8 * enSize
if modulation_type == "square_RGB":
dataOut = functions.demodulate_Square_RGB_Fast_Meta(
image, width, height, bucket, q, totMetaDataSize)
elif modulation_type == "square_YUV":
dataOut = functions.demodulate_Square_YUV_Fast_Meta(
image, width, height, bucket, q, totMetaDataSize)
else:
print("Unsupported img2meta modulation_type")
# Get metadata
metaData = dataOut[:totMetaDataSize]
metaData = bytearray(vhf.bit_array_2_bytes(metaData))
if enSize != 0:
# Set up Reed-Solomon
rs = reedsolo.RSCodec(enSize)
metaData = vhf.bytes_2_bit_list(rs.decode(metaData))
else:
metaData = vhf.bytes_2_bit_list(metaData)
new_frame, index, offset, bitoffset = vhf.extract_metadata(
metaData, metaDataOffset)
return new_frame, index, offset, bitoffset
except Exception as e:
import sys, traceback
print("Exception in img2meta")
print(e)
print(traceback.print_tb(sys.exc_info()[2]))
def encode_barcode(data):
crc = caurus._crc24(data)
data += crc.to_bytes(3, 'big')
if len(data) != _BLOCK_SIZE - _ECC_SYMBOLS:
raise Exception('Unsupported size')
rs = reedsolo.RSCodec(nsym=_ECC_SYMBOLS, nsize=_BLOCK_SIZE, fcr=1)
data = rs.encode(data)
modules = []
for i in range(_BLOCK_SIZE):
for block in range(len(data) // _BLOCK_SIZE):
for j in range(0, 8, 2)[::-1]:
modules.append((data[block * _BLOCK_SIZE + i] >> j) & 0b11)
modules[-3] = 0
result = []
offset = 0
for alignment, take in caurus._ALIGNMENT:
result += alignment
result += modules[offset:offset + take]
offset += take
return result
def read_audio_packets(f):
nop = 32
audio_packets = []
for i in range(nop):
header = bytearray(f.read(7))
if len(header) < 7 or header[0] != 0xff or header[1] & 0xf0 != 0xf0:
return audio_packets
length = (header[3] & 0x03) << 11 | (header[4] << 3) | (header[5] >> 5)
packet = bytearray(f.read(length - 7))
audio_packets.append(packet)
return audio_packets
rs = reedsolo.RSCodec(8)
NUM_FRAMES = 32
fpsd = [open('psd{0}.raw'.format(channel + 1), 'rb') for channel in range(8)]
faudio = open('sample.hdc', 'rb')
with open('p1.raw', 'wb') as fout:
start_seq_no = 0
for frame in range(NUM_FRAMES):
pdu_seq_no = frame % 2
p1_bytes = bytearray()
for channel in range(3):
if channel == 0:
audio_packets = read_audio_packets(faudio)
else:
def __init__(self, nsym):
Ecc.__init__(self, nsym)
self.coder = reedsolo.RSCodec(self.nsym)
