def get_header_not_lsb(image, chans, header_start, header_length, bits):
img = imageio.imread(image)
height, width, _ = img.shape
chars = []
count = 0
for r in range(height):
for c in range(width):
if count < header_start + header_length:
previous_length = len(chars)
if 0 in chans:
chars.extend(
list(
str((int2ba((img[r, c, 0] & bits) >>
(bits / 2)).item())).split('\'')[1]))
if 1 in chans:
chars.extend(
list(
str((int2ba((img[r, c, 1] & bits) >>
(bits / 2)).item())).split('\'')[1]))
if 2 in chans:
chars.extend(
list(
str((int2ba((img[r, c, 2] & bits) >>
(bits / 2)).item())).split('\'')[1]))
if 3 in chans:
chars.extend(
list(
str((int2ba((img[r, c, 3] & bits) >>
(bits / 2)).item())).split('\'')[1]))
count += len(chars) - previous_length
output = "".join(chars)[header_start:header_start + header_length]
return ba2int(bitarray(output))
def codebook_compression(image_shape, window_size, codes, codebook):
height, width = image_shape
res = bitarray()
height_code = f"{int(height):032b}"
width_code = f"{int(width):032b}"
res += bitarray(height_code)
res += bitarray(width_code)
window_size_code = f"{int(window_size):032b}"
res += bitarray(window_size_code)
codebook_size = len(codebook)
codebook_size_code = f"{int(codebook_size):032b}"
res += bitarray(codebook_size_code)
for codebook_code in codebook:
for element in codebook_code:
element_code = int2ba(int(element), length=9, signed=True)
res += element_code
bits_per_code = int(np.ceil(np.log2(codebook_size)))
for vector_code in codes:
vector_code_code = int2ba(int(vector_code),
length=bits_per_code,
signed=False)
res += vector_code_code
return res
def count(self):
a = btutil.int2ba(self.wstate)
b = btutil.int2ba(self.bstate)
c = Counter()
c[Color.WHITE] = a.count(True)
c[Color.BLACK] = b.count(True)
return c
def makeEp(data, streamIndex, isFrameEnd, frameType):
assert (0 <= streamIndex < 2**64)
assert (0 <= frameType < 2**64)
assert (0 <= len(data) <= 2**13)
if (len(data) == 0):
return b"\x00"
bits = bitarray(endian='big')
#put as many zeros as the number of bits needed for the stream index, minus one
streamIndexNbBits = streamIndex.bit_length()
bits += bitarray((streamIndexNbBits - 1) * "0" + "1")
#then put the index
bits += int2ba(streamIndex, length=None,
endian='big') #stream index associtated to the data
bits.append(isFrameEnd) #are those data the end of the current frame
if (isFrameEnd):
#put as many zeros as the number of bits needed for the frame type, minus one
frameTypeNbBits = frameType.bit_length() + 1
bits += bitarray((frameTypeNbBits - 1) * "0" + "1")
#then put the frame type
bits += int2ba(frameType, length=None, endian='big')
bits.append(0) #unknown
bits.append(
1
) #need to write a value of size nb_zero*2+28 bits afterwards, so just nullify nb_zero
bits += bitarray("0" * 28) #unknown
#put data len minus one on 13 bits
bits += int2ba(len(data) - 1, length=13, endian='big')
return bits.tobytes() + data
def read_n_bits(image, chans, bits, n):
img = imageio.imread(image)
height, width, _ = img.shape
print("Height:", height, "Width:", width)
chars = []
count = 0
for r in range(height):
for c in range(width):
if count < n:
previous_length = len(chars)
if 0 in chans:
chars.extend(
list(
str(int2ba(
(img[r, c, 0] & bits).item())).split('\'')[1]))
if 1 in chans:
chars.extend(
list(
str(int2ba(
(img[r, c, 1] & bits).item())).split('\'')[1]))
if 2 in chans:
chars.extend(
list(
str(int2ba(
(img[r, c, 2] & bits).item())).split('\'')[1]))
if 3 in chans:
chars.extend(
list(
str(int2ba(
(img[r, c, 3] & bits).item())).split('\'')[1]))
count += len(chars) - previous_length
output = bitarray("".join(chars))
print(output.tobytes())
def int_to_bitarray(n):
if (n < 0):
n = abs(n)
a = util.int2ba(n)
a.invert()
else:
a = util.int2ba(n)
return a
def __init__(self, client_id: int, service_server_id: int,
current_timestamp: int, valid_period_seconds: int,
encryption_key: bitarray) -> None:
self.client_id = int2ba(client_id)
self.service_server_id = int2ba(service_server_id)
self.current_timestamp = int2ba(current_timestamp)
self.valid_period_seconds = int2ba(valid_period_seconds)
self.encryption_key = encryption_key
def get_random_cond(self, batch_size): cond = [] for i in range(batch_size): labels = list(int2ba(np.random.randint(0, 17)).to01().zfill(5)) labels += list(int2ba(np.random.randint(0, 17)).to01().zfill(5)) labels = list(map(int, labels)) labels += list(np.clip((np.random.randn(8)+1)*0.5, 0, 1)) cond.append(labels) return torch.FloatTensor(cond).view(batch_size, -1, 1, 1)
def encode(b):
counts = collections.Counter(b)
sorted_counts = sorted(
counts.items(),
key=lambda item: item[1],
reverse=True,
)
if len(sorted_counts) == 0:
encodings = []
elif len(sorted_counts) == 1:
encodings = [(sorted_counts[0][0], bitarray("0"))]
else:
while len(sorted_counts) > 1:
right, right_count = sorted_counts.pop()
left, left_count = sorted_counts.pop()
sorted_counts.append(((left, right), left_count + right_count))
sorted_counts = sorted(
sorted_counts,
key=lambda item: item[1],
reverse=True,
)
tree = sorted_counts[0][0]
encodings = []
def f(current_encoding, tree):
if isinstance(tree, tuple):
left, right = tree
left_encoding = current_encoding + bitarray("0")
f(left_encoding, left)
right_encoding = current_encoding + bitarray("1")
f(right_encoding, right)
else:
encodings.append((tree, current_encoding))
f(bitarray(), tree)
encode_dict = dict(encodings)
z = bitarray()
if b:
z.encode(encode_dict, b)
decode_dict = {
symbol.to_bytes(1, byteorder='big'): bits
for symbol, bits in encode_dict.items()
}
serialized_dict = serialize_dict(decode_dict)
dict_length = int2ba(len(serialized_dict), length=16)
z_length = int2ba(len(z), length=64)
return dict_length + serialized_dict + z_length + z
def test_int2ba(self):
self.assertEqual(int2ba(0), bitarray('0'))
self.assertEqual(int2ba(1), bitarray('1'))
self.assertEqual(int2ba(5), bitarray('101'))
self.assertEQUAL(int2ba(6, endian='big'), bitarray('110', 'big'))
self.assertEQUAL(int2ba(6, endian='little'), bitarray('011', 'little'))
self.assertRaises(TypeError, int2ba, 1.0)
self.assertRaises(TypeError, int2ba, 1, 3.0)
self.assertRaises(ValueError, int2ba, 1, 0)
self.assertRaises(TypeError, int2ba, 1, 10, 123)
self.assertRaises(ValueError, int2ba, 1, 10, 'asd')
# signed integer requires length
self.assertRaises(TypeError, int2ba, 100, signed=True)
def test_int2ba_length(self):
self.assertRaises(TypeError, int2ba, 0, 1.0)
self.assertRaises(ValueError, int2ba, 0, 0)
self.assertEqual(int2ba(5, length=6, endian='big'), bitarray('000101'))
for n in range(1, 100):
ab = int2ba(1, n, 'big')
al = int2ba(1, n, 'little')
self.assertEqual(ab.endian(), 'big')
self.assertEqual(al.endian(), 'little')
self.assertEqual(len(ab), n),
self.assertEqual(len(al), n)
self.assertEqual(ab, bitarray((n - 1) * '0') + bitarray('1'))
self.assertEqual(al, bitarray('1') + bitarray((n - 1) * '0'))
ab = int2ba(0, n, 'big')
al = int2ba(0, n, 'little')
self.assertEqual(len(ab), n)
self.assertEqual(len(al), n)
self.assertEqual(ab, bitarray(n * '0', 'big'))
self.assertEqual(al, bitarray(n * '0', 'little'))
self.assertEqual(int2ba(2**n - 1), bitarray(n * '1'))
self.assertEqual(int2ba(2**n - 1, endian='little'),
bitarray(n * '1'))
for endian in 'big', 'little':
self.assertEqual(int2ba(-1, n, endian, signed=True),
bitarray(n * '1'))
def uint_to_bitarray(number, size):
a = util.int2ba(number, signed=False)
add = size - len(a)
z = util.zeros(add)
for x in a:
z.append(x)
return z
def is_mnemonic_valid(self, mnemonic):
words = normalize_string(mnemonic).split(" ")
num_words = len(words)
if num_words not in VALID_WORD_COUNTS:
return False
try:
indices = tuple(self.wordlist.index(w) for w in words)
except ValueError:
return False
encoded_seed = bitarray()
for idx in indices:
# Build bitarray from tightly packing indices (which are 11-bits integers)
encoded_seed.extend(int2ba(idx, length=11))
entropy_size = 4 * num_words // 3
# Checksum the raw entropy bits
checksum = bitarray()
checksum.frombytes(sha256(encoded_seed[:entropy_size * 8].tobytes()))
computed_checksum = checksum[:len(encoded_seed) -
entropy_size * 8].tobytes()
# Extract the stored checksum bits
stored_checksum = encoded_seed[entropy_size * 8:].tobytes()
# Check that the stored matches the relevant slice of the actual checksum
# NOTE: Use secrets.compare_digest for protection again timing attacks
return secrets.compare_digest(stored_checksum, computed_checksum)
def trans(value):
global mask
a = util.int2ba(value, length=36)
for i, v in enumerate(mask):
if v != "X":
a[i] = (v == "1")
return a
def flipped_text_with_header(image, bit_start, chans, bits, testing_multiple):
bit_lengths = {1: 1, 3: 2, 7: 3}
img = imageio.imread(image)
height, width, _ = img.shape
print("Height:", height, "Width:", width)
length = get_flipped_header(image, chans, bit_start, 32, bits)
print(length)
hidden_width = get_flipped_header(image, chans, bit_start + 32, 32, bits)
print(hidden_width)
if testing_multiple:
if input("Continue?") in ["n", "N"]:
return
chars = []
for c in range(width):
for r in range(height):
if len(chars) < (length * 8) + 32 + bit_start:
for chan in chans:
x = list(
str(int2ba(
(img[r, c, chan] & bits).item())).split('\'')[1])
if (len(x) < bit_lengths[bits]):
for i in range(bit_lengths[bits] - len(x)):
x.insert(0, '0')
chars.extend(x)
output = bitarray("".join(chars))[bit_start:bit_start + (length * 8 + 32)]
print(output.tobytes()[4:length + 4])
def mangling_function(self, right_side, key):
expanded_bitstring = self.permute(right_side, EXPANSION_FUNCTION)
xor = expanded_bitstring ^ key
b_list = []
begin = 0
for end in range(6, len(xor) + 1, 6):
b_list.append(xor[begin:end])
begin = end
c_of_j_list = []
for i, b in enumerate(b_list):
row = bitarray(2)
row[0] = b[0]
row[1] = b[-1]
row_num = ba2int(row)
column = bitarray(4)
for j in range(1, 5):
column[j - 1] = b[j]
col_num = ba2int(column)
c_of_j_list.append(int2ba(S_BOXES[i][row_num * 16 + col_num], 4))
big_c = bitarray()
for i in c_of_j_list:
big_c += i
# print(f'S-BOX outputs = {big_c}')
return self.permute(big_c, PERMUTATION)
def apply(self, val):
bt = bt_util.int2ba(val, length=36, endian="big")
debug(f"Input: {bt}")
bt &= self.and_mask
bt |= self.or_mask
debug(f"Masked: {bt}")
return bt_util.ba2int(bt)
def XORKeyGenerator(seed):
generatedKey = seed
generatedKey ^= generatedKey >> 3
generatedKey ^= generatedKey << 2
generatedKey ^= generatedKey >> 7
# print(int2ba(generatedKey))
return int2ba(generatedKey)
def calculate_graye_code():
result = []
for item in range(0, 32):
bits = bitarray(int2ba(item))
gray_code = bitarray(bits >> 1)
gray_code ^= bits
result.append(Number(bits, gray_code, ba2int(bits)))
return result
def even_bits_text(image, chans, bits, testing_multiple):
# Don't use 'bits'
img = imageio.imread(image)
height, width, _ = img.shape
print("Height:", height, "Width:", width)
length = get_header(image, chans, 0, 32, bits)
print(length)
if testing_multiple:
if input("Continue?") in ["n", "N"]:
return
chars = []
count = 0
for r in range(height):
for c in range(width):
# change once we figure out headers
if count < 30:
previous_length = len(chars)
for color in range(3):
print('color_before: ', (int2ba(
(img[r, c, color]).item())))
color_even = (list(
str(int2ba((img[r, c, color]).item())).split('\'')[1]))
# to preserve leading 0's
if (len(color_even) < 8):
for i in range(8 - len(color_even)):
color_even.insert(0, '0')
print('color_even: ', color_even)
for i in range(len(color_even)):
if (i % 2 != 0):
print('added: ', color_even[i])
chars.extend(color_even[i])
count += len(chars) - previous_length
output = bitarray("".join(chars))
print(output.tobytes()[4:length + 4])
def generate_delta(index: int):
# v_k_s = u_[log2(k+1)] + (k+1)_2
m_k = int(log2(index + 1))
delta_array = generate_gamma(m_k)
k_part = int2ba(index + 1)
delta_array.extend(k_part)
delta_array.pop(len(delta_array) - m_k - 1)
return delta_array
def generate_mem_content(code, initial: bitarray, delta: bitarray, N=100):
initial = bit_util.ba2int(initial)
delta = bit_util.ba2int(delta)
overlap = 2**(code.k)
data = [x % overlap for x in range(initial, initial + N * delta, delta)]
ba_data = [bit_util.int2ba(d, length=code.k) for d in data]
codewords = [code.encode_word(word) for word in ba_data]
return codewords
def s_block(b: bitarray, i: int) -> bitarray:
assert len(b) == 6
row_bits = bitarray(2)
row_bits[0] = b[0]
row_bits[1] = b[5]
row = ba2int(row_bits)
assert 0 <= row < 4
col = ba2int(b[1:4])
assert 0 <= col < 16
return int2ba(S[i][row][col], length=4)
def set_time_lag(self, conv=0b100, avg=0b01):
with SMBus(self.i2c_ch) as bus:
#read the configure register
#print(self.hadd, self.sensor_configure_register)
conf = bus.read_i2c_block_data(self.hadd, sc.TMP117_CONF_REGISTER,
2)
#print("Old CONFIG:", conf)
#high8 = util.int2ba(conf[0], 8)[:6] + util.int2ba(conv, 3)[:2]
#low8 = util.int2ba(conv, 3)[2:] + util.int2ba(avg, 2) + util.int2ba(conf[1], 8)[3:]
#print(high8, low8)
conf[0] = util.ba2int(
util.int2ba(conf[0], 8)[:6] + util.int2ba(conv, 3)[:2])
conf[1] = util.ba2int(
util.int2ba(conv, 3)[2:] + util.int2ba(avg, 2) +
util.int2ba(conf[1], 8)[3:])
#print(conf)
bus.write_i2c_block_data(self.hadd, sc.TMP117_CONF_REGISTER, conf)
conf = bus.read_i2c_block_data(self.hadd, sc.TMP117_CONF_REGISTER,
2)
def test_explicit(self):
for i, sa in [(0, '0'), (1, '1'), (2, '10'), (3, '11'), (25, '11001'),
(265, '100001001'), (3691038, '1110000101001000011110')]:
ab = bitarray(sa, 'big')
al = bitarray(sa[::-1], 'little')
self.assertEQUAL(int2ba(i), ab)
self.assertEQUAL(int2ba(i, endian='little'), al)
self.assertEqual(ba2int(ab), ba2int(al), i)
if i == 0 or i >= 512:
continue
for n in range(9, 32):
for endian in 'big', 'little':
a = int2ba(i, length=n, endian=endian)
self.assertEqual(a.endian(), endian)
self.assertEqual(len(a), n)
if endian == 'big':
f = a.index(1)
self.assertEqual(a[:f], bitarray(f * '0'))
self.assertEqual(a[f:], ab)
def additiveScramble(data):
current_index = 0
# scramble_key = int2ba(len(data))
scramble_key = int2ba(50)
while current_index < len(data) - 1:
data[current_index:(
current_index + len(scramble_key))] = data[current_index:(
current_index + len(scramble_key))] ^ scramble_key
current_index += len(scramble_key)
def translate_line(assembly_line: str) -> bitarray:
'''Translate a line of assembly code to bit instructions.'''
symbols = assembly_line.split(' ')
a_code = symbols[0]
exp_args = corium.get_arg_types(a_code)
act_args = symbols[1:]
bits = bitarray(0)
bit_count = 0
if len(exp_args) < len(act_args):
raise SyntaxError(f'Too many args for command {a_code}!')
elif len(exp_args) > len(act_args):
raise SyntaxError(f'Not enough args for command {a_code}!')
else:
bits = corium.get_m_code(a_code)
bit_count += 8
for i in range(len(act_args)):
arg = int(act_args[i])
arg_type = exp_args[i]
if arg_type == 'imm' and arg < MIN_IMM:
raise ValueError(f'Min value for an immediate is {MIN_IMM}!')
elif arg_type == 'imm' and arg > MAX_IMM:
raise ValueError(f'Max value for an immediate is {MAX_IMM}!')
elif arg_type == 'imm':
imm = int2ba(arg, 16, signed=True)
bits += imm
bit_count += 16
elif arg < MIN_REG:
raise ValueError(f'Min value for a register is {MIN_REG}!')
elif arg > MAX_REG:
raise ValueError(f'Max value for a register is {MAX_REG}!')
else:
reg = int2ba(arg, 4, signed=False)
bits += reg
bit_count += 4
zeros = '0' * (32 - bit_count)
zero_bits = bitarray(zeros)
bits += zero_bits
return bits
