mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-16 08:38:26 +00:00
add an entrails parser for the PDDB
This commit is contained in:
parent
93fd991dff
commit
94a86c542d
2 changed files with 579 additions and 0 deletions
318
tools/pddbdbg.py
Executable file
318
tools/pddbdbg.py
Executable file
|
|
@ -0,0 +1,318 @@
|
|||
#! /usr/bin/env python3
|
||||
import argparse
|
||||
import sys
|
||||
|
||||
from Crypto.Cipher import AES
|
||||
from rfc8452 import AES_GCM_SIV
|
||||
|
||||
import binascii
|
||||
import hashlib
|
||||
|
||||
SYSTEM_BASIS = '.System'
|
||||
|
||||
# from https://github.com/wc-duck/pymmh3/blob/master/pymmh3.py
|
||||
def xrange( a, b, c ):
|
||||
return range( a, b, c )
|
||||
def xencode(x):
|
||||
if isinstance(x, bytes) or isinstance(x, bytearray):
|
||||
return x
|
||||
else:
|
||||
return x.encode()
|
||||
|
||||
def mm3_hash( key, seed = 0x0 ):
|
||||
''' Implements 32bit murmur3 hash. '''
|
||||
|
||||
key = bytearray( xencode(key) )
|
||||
|
||||
def fmix( h ):
|
||||
h ^= h >> 16
|
||||
h = ( h * 0x85ebca6b ) & 0xFFFFFFFF
|
||||
h ^= h >> 13
|
||||
h = ( h * 0xc2b2ae35 ) & 0xFFFFFFFF
|
||||
h ^= h >> 16
|
||||
return h
|
||||
|
||||
length = len( key )
|
||||
nblocks = int( length / 4 )
|
||||
|
||||
h1 = seed
|
||||
|
||||
c1 = 0xcc9e2d51
|
||||
c2 = 0x1b873593
|
||||
|
||||
# body
|
||||
for block_start in xrange( 0, nblocks * 4, 4 ):
|
||||
# ??? big endian?
|
||||
k1 = key[ block_start + 3 ] << 24 | \
|
||||
key[ block_start + 2 ] << 16 | \
|
||||
key[ block_start + 1 ] << 8 | \
|
||||
key[ block_start + 0 ]
|
||||
|
||||
k1 = ( c1 * k1 ) & 0xFFFFFFFF
|
||||
k1 = ( k1 << 15 | k1 >> 17 ) & 0xFFFFFFFF # inlined ROTL32
|
||||
k1 = ( c2 * k1 ) & 0xFFFFFFFF
|
||||
|
||||
h1 ^= k1
|
||||
h1 = ( h1 << 13 | h1 >> 19 ) & 0xFFFFFFFF # inlined ROTL32
|
||||
h1 = ( h1 * 5 + 0xe6546b64 ) & 0xFFFFFFFF
|
||||
|
||||
# tail
|
||||
tail_index = nblocks * 4
|
||||
k1 = 0
|
||||
tail_size = length & 3
|
||||
|
||||
if tail_size >= 3:
|
||||
k1 ^= key[ tail_index + 2 ] << 16
|
||||
if tail_size >= 2:
|
||||
k1 ^= key[ tail_index + 1 ] << 8
|
||||
if tail_size >= 1:
|
||||
k1 ^= key[ tail_index + 0 ]
|
||||
|
||||
if tail_size > 0:
|
||||
k1 = ( k1 * c1 ) & 0xFFFFFFFF
|
||||
k1 = ( k1 << 15 | k1 >> 17 ) & 0xFFFFFFFF # inlined ROTL32
|
||||
k1 = ( k1 * c2 ) & 0xFFFFFFFF
|
||||
h1 ^= k1
|
||||
|
||||
#finalization
|
||||
return fmix( h1 ^ length )
|
||||
|
||||
# weird, this code breaks things compared to the reference Rust implementation
|
||||
unsigned_val = fmix( h1 ^ length )
|
||||
if unsigned_val & 0x80000000 == 0:
|
||||
return unsigned_val
|
||||
else:
|
||||
return -( (unsigned_val ^ 0xFFFFFFFF) + 1 )
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(description="Debug PDDB Images")
|
||||
parser.add_argument(
|
||||
"--pddb-image", required=False, help="pddb disk image", type=str, nargs='?', metavar=('pddb image'), const='./pddb.bin'
|
||||
)
|
||||
parser.add_argument(
|
||||
"--pddb-keys", required=False, help="known pddb keys", type=str, nargs='?', metavar=('pddb keys'), const='./pddb.key'
|
||||
)
|
||||
args = parser.parse_args()
|
||||
|
||||
if args.pddb_keys == None:
|
||||
keyfile = './tools/pddb.key'
|
||||
else:
|
||||
keyfile = args.pddb_keys
|
||||
|
||||
if args.pddb_image == None:
|
||||
imagefile = './tools/pddb.bin'
|
||||
else:
|
||||
imagefile = args.pddb_image
|
||||
|
||||
keys = {}
|
||||
with open(keyfile, 'rb') as key_f:
|
||||
raw_key = key_f.read()
|
||||
num_keys = int.from_bytes(raw_key[:4], 'little')
|
||||
for i in range(num_keys):
|
||||
name_all = raw_key[4 + i*96 : 4 + i*96 + 64]
|
||||
name_bytes = bytearray(b'')
|
||||
for b in name_all:
|
||||
if b != 0:
|
||||
name_bytes.append(b)
|
||||
else:
|
||||
break
|
||||
name = name_bytes.decode('utf8', errors='ignore')
|
||||
key = raw_key[4 + i*96 + 64 : 4 + i*96 + 96]
|
||||
keys[name] = key
|
||||
|
||||
print("Found basis keys:")
|
||||
print(keys)
|
||||
|
||||
MBBB_PAGES = 10
|
||||
FSCB_PAGES = 16
|
||||
KEY_PAGES = 1
|
||||
PAGE_SIZE = 4096
|
||||
|
||||
with open(imagefile, 'rb') as img_f:
|
||||
raw_img = img_f.read()
|
||||
pddb_len = len(raw_img)
|
||||
pddb_size_pages = pddb_len // PAGE_SIZE
|
||||
|
||||
img_index = 0
|
||||
tables = decode_pagetable(raw_img, pddb_size_pages, keys)
|
||||
img_index += pddb_size_pages * Pte.PTE_LEN
|
||||
rawkeys = raw_img[img_index : img_index + PAGE_SIZE * KEY_PAGES]
|
||||
img_index += PAGE_SIZE * KEY_PAGES
|
||||
mbbb = raw_img[img_index : img_index + PAGE_SIZE * MBBB_PAGES]
|
||||
img_index += PAGE_SIZE * MBBB_PAGES
|
||||
fscb = decode_fscb(raw_img[img_index: img_index + PAGE_SIZE * FSCB_PAGES], keys)
|
||||
|
||||
|
||||
class Pte:
|
||||
PTE_LEN = 16
|
||||
def __init__(self, bytes):
|
||||
assert(len(bytes) == self.PTE_LEN)
|
||||
self.bytes = bytes
|
||||
|
||||
def len_bytes(self):
|
||||
return(self.bytes.len())
|
||||
def as_bytes(self):
|
||||
return self.bytes
|
||||
|
||||
def addr(self):
|
||||
return int.from_bytes(self.bytes[:6], 'little')
|
||||
def flags(self):
|
||||
if self.bytes[6] == 1:
|
||||
return 'CLN'
|
||||
else:
|
||||
return 'INV'
|
||||
def nonce(self):
|
||||
return int.from_bytes(self.bytes[8:12], 'little')
|
||||
def checksum(self):
|
||||
return int.from_bytes(self.bytes[12:], 'little')
|
||||
|
||||
# checks the checksum
|
||||
def is_valid(self):
|
||||
return (self.checksum() == mm3_hash(self.bytes[:12], self.nonce()))
|
||||
|
||||
def print(self, ppage=None):
|
||||
#print('checksum: {:08x}, hash: {:08x}'.format(self.checksum(), mm3_hash(self.bytes[:12], self.nonce())))
|
||||
if ppage != None:
|
||||
print('{:08x}: a_{:012x} | f_{} | n_{:08x} | c_{:08x}'.format(ppage, self.addr(), self.flags(), self.nonce(), self.checksum()))
|
||||
else:
|
||||
print('a_{:012x} | f_{} | n_{:08x} | c_{:08x}'.format(self.addr(), self.flags(), self.nonce(), self.checksum()))
|
||||
|
||||
def decode_pagetable(img, entries, keys):
|
||||
key_table = {}
|
||||
for name, key in keys.items():
|
||||
print("Pages for basis {}".format(name))
|
||||
print("key: {}".format(key.hex()))
|
||||
cipher = AES.new(key, AES.MODE_ECB)
|
||||
encrypted_ptes = [img[i:i+Pte.PTE_LEN] for i in range(0, entries * Pte.PTE_LEN, Pte.PTE_LEN)]
|
||||
page = 0
|
||||
v2p_table = {}
|
||||
p2v_table = {}
|
||||
for pte in encrypted_ptes:
|
||||
maybe_pte = Pte(cipher.decrypt(pte))
|
||||
if maybe_pte.is_valid():
|
||||
maybe_pte.print(page)
|
||||
p_addr = page * (4096 / Pte.PTE_LEN)
|
||||
v2p_table[maybe_pte.addr()] = p_addr
|
||||
p2v_table[p_addr] = maybe_pte.addr()
|
||||
|
||||
page += Pte.PTE_LEN
|
||||
key_table[name] = [v2p_table, p2v_table]
|
||||
return key_table
|
||||
|
||||
class PhysPage:
|
||||
def __init__(self, bytes):
|
||||
self.pp = int.from_bytes(bytes[:4], 'little')
|
||||
|
||||
def page_number(self):
|
||||
return self.pp & 0xF_FFFF
|
||||
|
||||
def clean(self):
|
||||
if (self.pp & 0x10_0000) != 0:
|
||||
return True
|
||||
else:
|
||||
return False
|
||||
|
||||
def valid(self):
|
||||
if (self.pp & 0x20_0000) != 0:
|
||||
return True
|
||||
else:
|
||||
return False
|
||||
|
||||
def space_state(self):
|
||||
code = (self.pp >> 22) & 3
|
||||
if code == 0:
|
||||
return 'FREE'
|
||||
elif code == 1:
|
||||
return 'MUSE'
|
||||
elif code == 2:
|
||||
return 'USED'
|
||||
else:
|
||||
return 'DIRT'
|
||||
|
||||
def journal(self):
|
||||
return (self.pp >> 24) & 0xF
|
||||
|
||||
def print(self):
|
||||
print('a_{:05x} | c_{} | v_{} | ss_{} | j_{:02}'.format(self.page_number(), self.clean(), self.valid(), self.space_state(), self.journal()))
|
||||
|
||||
class Fscb:
|
||||
def __init__(self, bytes):
|
||||
FASTSPACE_PAGES = 2
|
||||
NONCE_LEN = 12
|
||||
TAG_LEN = 16
|
||||
PP_LEN = 4
|
||||
FREE_POOL_LEN = ((4096 * FASTSPACE_PAGES) - (NONCE_LEN + TAG_LEN)) // PP_LEN
|
||||
assert(len(bytes) == FREE_POOL_LEN * PP_LEN)
|
||||
raw_pps = [bytes[i:i+PP_LEN] for i in range(0, FREE_POOL_LEN * PP_LEN, PP_LEN)]
|
||||
self.free_space = {}
|
||||
for raw_pp in raw_pps:
|
||||
pp = PhysPage(raw_pp)
|
||||
if pp.valid():
|
||||
self.free_space[pp.page_number() * 4096] = pp
|
||||
|
||||
def at_phys_addr(self, addr):
|
||||
try:
|
||||
return self.free_pool[addr]
|
||||
except:
|
||||
None
|
||||
|
||||
def print(self):
|
||||
for pagenum, pp in self.free_space.items():
|
||||
pp.print()
|
||||
|
||||
# this is the "AAD" used to encrypt the FastSpace
|
||||
def aad(version=0, dna=0):
|
||||
return bytearray([46, 70, 97, 115, 116, 83, 112, 97, 99, 101]) + version.to_bytes(2, 'little') + dna.to_bytes(8, 'little')
|
||||
|
||||
# img is clipped to just the fscb region of the overall disk image
|
||||
def decode_fscb(img, keys, FSCB_LEN_PAGES=2):
|
||||
global SYSTEM_BASIS
|
||||
if SYSTEM_BASIS in keys:
|
||||
key = keys[SYSTEM_BASIS]
|
||||
pages = [img[i:i+4096] for i in range(0, len(img), 4096)]
|
||||
space_update = []
|
||||
fscb_start = None
|
||||
pg = 0
|
||||
for page in pages:
|
||||
if bytearray(page[:32]) == bytearray([0xff] * 32):
|
||||
# page is blank
|
||||
pass
|
||||
elif bytearray(page[:16] == bytearray([0xff] * 16)):
|
||||
space_update.append(page)
|
||||
else:
|
||||
if fscb_start == None:
|
||||
fscb_start = pg
|
||||
pg += 1
|
||||
|
||||
if fscb_start:
|
||||
print("found FSCB at {:x}".format(fscb_start))
|
||||
fscb_enc = img[fscb_start * 4096 : (fscb_start + FSCB_LEN_PAGES) * 4096]
|
||||
try:
|
||||
nonce = fscb_enc[:12]
|
||||
print("key: {}, nonce: {}".format(key.hex(), nonce.hex()))
|
||||
cipher = AES_GCM_SIV(key, nonce)
|
||||
print("aad: {}".format(Fscb.aad().hex()))
|
||||
print("mac: {}".format(fscb_enc[-16:].hex()))
|
||||
#print("data: {}".format(fscb_enc[12:-16].hex()))
|
||||
fscb_dec = cipher.decrypt(fscb_enc[12:], Fscb.aad())
|
||||
print("decrypted")
|
||||
fscb = Fscb(fscb_dec)
|
||||
except KeyError:
|
||||
print("couldn't decrypt")
|
||||
fscb = None
|
||||
|
||||
if fscb:
|
||||
fscb.print()
|
||||
|
||||
for update in space_update:
|
||||
pass
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
exit(0)
|
||||
|
||||
|
||||
# 00 00 00 00 00 00 00 00 00 00 00
|
||||
# 00 00 00 00 00 00 00 00 00 00
|
||||
# 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
|
||||
261
tools/rfc8452.py
Normal file
261
tools/rfc8452.py
Normal file
|
|
@ -0,0 +1,261 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
# Copyright (c) Bjorn Edstrom <be@bjrn.se> 2019
|
||||
|
||||
# Reference implementation of AES-GCM-SIV based on the IRTF draft.
|
||||
# Do not use.
|
||||
|
||||
# Vendored from https://github.com/bjornedstrom/aes-gcm-siv-py on Nov 14 2021.
|
||||
# Commit bc9c8f484405437720f7372850e8e8cadad08190
|
||||
# And slightly modified to be compatible with the Pycryptodome crate as used elsewhere by
|
||||
# the project.
|
||||
#
|
||||
# As of Nov 2021 Pycryptodome doesn't have an RFC8452 (aes-gcm-siv) implementation (the
|
||||
# thing called Galois mode (GCM) is a different RFC). This code is labelled "do not use"
|
||||
# by the author, but we use it only to diagnose/test a production
|
||||
# Rust crate, so, in the worst case, we just get some invalid diagnostic results.
|
||||
|
||||
import Crypto.Cipher.AES as AES
|
||||
import binascii
|
||||
import six
|
||||
import struct
|
||||
|
||||
|
||||
class Field(object):
|
||||
# The field is defined by the irreducible polynomial
|
||||
# x^128 + x^127 + x^126 + x^121 + 1
|
||||
_MOD = sum((1 << a) for a in [0, 121, 126, 127, 128])
|
||||
|
||||
# x^-128 is equal to x^127 + x^124 + x^121 + x^114 + 1
|
||||
_INV = sum((1 << a) for a in [0, 114, 121, 124, 127])
|
||||
|
||||
@staticmethod
|
||||
def add(x, y):
|
||||
assert x < (1 << 128)
|
||||
assert y < (1 << 128)
|
||||
return x ^ y
|
||||
|
||||
@staticmethod
|
||||
def mul(x, y):
|
||||
assert x < (1 << 128), x
|
||||
assert y < (1 << 128), y
|
||||
|
||||
res = 0
|
||||
for bit in range(128):
|
||||
if (y >> bit) & 1:
|
||||
res ^= (2 ** bit) * x
|
||||
|
||||
return Field.mod(res, Field._MOD)
|
||||
|
||||
@staticmethod
|
||||
def dot(a, b):
|
||||
return Field.mul(Field.mul(a, b), Field._INV)
|
||||
|
||||
@staticmethod
|
||||
def mod(a, m):
|
||||
m2 = m
|
||||
i = 0
|
||||
while m2 < a:
|
||||
m2 <<= 1
|
||||
i += 1
|
||||
while i >= 0:
|
||||
a2 = a ^ m2
|
||||
if a2 < a:
|
||||
a = a2
|
||||
m2 >>= 1
|
||||
i -= 1
|
||||
return a
|
||||
|
||||
|
||||
def polyval(h, xs):
|
||||
"""POLYVAL takes a field element, H, and a series of field elements X_1,
|
||||
..., X_s. Its result is S_s, where S is defined by the iteration S_0
|
||||
= 0; S_j = dot(S_{j-1} + X_j, H), for j = 1..s"""
|
||||
s = 0
|
||||
for x in xs:
|
||||
s = Field.dot(Field.add(s, x), h)
|
||||
return s
|
||||
|
||||
|
||||
class PolyvalIUF(object):
|
||||
"""Polyval implemented as an IUF construction, specifically in the context
|
||||
of AES-GCM_SIV."""
|
||||
|
||||
def __init__(self, h, nonce):
|
||||
self._s = 0
|
||||
self._h = b2i(h)
|
||||
self._nonce = bytearray(nonce)
|
||||
|
||||
# TODO: update() is a bit sensitive w.r.t zero-padding, make sure
|
||||
# it's called so there is no superfluous zero-padding added in the middle
|
||||
# of the input due to splitting etc.
|
||||
def update(self, inp):
|
||||
def update16(inp):
|
||||
assert len(inp) == 16
|
||||
self._s = Field.dot(Field.add(self._s, b2i(inp)), self._h)
|
||||
|
||||
def split16(s):
|
||||
return [s[i:i+16] for i in range(0, len(s), 16)]
|
||||
|
||||
def _right_pad_to_16(b):
|
||||
while len(b) % 16 != 0:
|
||||
b += b'\x00'
|
||||
return b
|
||||
|
||||
for block in split16(inp):
|
||||
update16(_right_pad_to_16(block))
|
||||
|
||||
def digest(self):
|
||||
S_s = bytearray(i2b(self._s))
|
||||
for i in range(12):
|
||||
S_s[i] ^= self._nonce[i]
|
||||
S_s[15] &= 0x7f
|
||||
return S_s
|
||||
|
||||
|
||||
def b2i(s):
|
||||
res = 0
|
||||
for c in reversed(s):
|
||||
res <<= 8
|
||||
res |= (ord(c) if six.PY2 else c)
|
||||
return res
|
||||
|
||||
|
||||
def i2b(i):
|
||||
if i == 0:
|
||||
return b'\x00'*16
|
||||
s = b''
|
||||
while i:
|
||||
s += chr(i & 0xff) if six.PY2 else bytes([i & 0xff])
|
||||
i >>= 8
|
||||
return bytes(s)
|
||||
|
||||
|
||||
def s2i(s):
|
||||
return b2i(binascii.unhexlify(s))
|
||||
|
||||
|
||||
def i2s(i):
|
||||
return binascii.hexlify(i2b(i))
|
||||
|
||||
|
||||
def le_uint32(i):
|
||||
return struct.pack(b'<L', i)
|
||||
|
||||
|
||||
def read_le_uint32(b):
|
||||
return struct.unpack(b'<L', b[0:4])[0]
|
||||
|
||||
|
||||
def le_uint64(i):
|
||||
return struct.pack(b'<Q', i)
|
||||
|
||||
|
||||
class AES_GCM_SIV(object):
|
||||
def __init__(self, key_gen_key, nonce):
|
||||
aes_obj = AES.new(key_gen_key, AES.MODE_ECB)
|
||||
msg_auth_key = aes_obj.encrypt(le_uint32(0) + nonce)[0:8] + \
|
||||
aes_obj.encrypt(le_uint32(1) + nonce)[0:8]
|
||||
msg_enc_key = aes_obj.encrypt(le_uint32(2) + nonce)[0:8] + \
|
||||
aes_obj.encrypt(le_uint32(3) + nonce)[0:8]
|
||||
if len(key_gen_key) == 32:
|
||||
msg_enc_key += aes_obj.encrypt(le_uint32(4) + nonce)[0:8] + \
|
||||
aes_obj.encrypt(le_uint32(5) + nonce)[0:8]
|
||||
self.msg_auth_key = msg_auth_key
|
||||
self.msg_enc_key = msg_enc_key
|
||||
self.nonce = nonce
|
||||
|
||||
def _right_pad_to_16(self, inp):
|
||||
while len(inp) % 16 != 0:
|
||||
inp += b'\x00'
|
||||
return inp
|
||||
|
||||
def _aes_ctr(self, key, initial_block, inp):
|
||||
block = initial_block
|
||||
output = b''
|
||||
while len(inp) > 0:
|
||||
keystream_block = AES.new(key, AES.MODE_ECB).encrypt(block)
|
||||
block = le_uint32((read_le_uint32(block[0:4]) + 1) & 0xffffffff) + block[4:]
|
||||
todo = min(len(inp), len(keystream_block))
|
||||
for j in range(todo):
|
||||
if six.PY2:
|
||||
output += chr(ord(keystream_block[j]) ^ ord(inp[j]))
|
||||
else:
|
||||
output += bytes([keystream_block[j] ^ inp[j]])
|
||||
inp = inp[todo:]
|
||||
return output
|
||||
|
||||
def _polyval_calc(self, plaintext, additional_data):
|
||||
# Instead of calculating S_s inline using the RFC polyval() function,
|
||||
# we redesign polyval as an IUF "hash". The old/RFC way would be as below:
|
||||
#
|
||||
# """
|
||||
# padded_plaintext = self._right_pad_to_16(plaintext)
|
||||
# padded_ad = self._right_pad_to_16(additional_data)
|
||||
# S_s = bytearray(
|
||||
# i2b(polyval(b2i(self.msg_auth_key),
|
||||
# map(b2i, split16(padded_ad) + split16(padded_plaintext) + [length_block]))))
|
||||
# nonce = bytearray(self.nonce)
|
||||
# for i in range(12):
|
||||
# S_s[i] ^= nonce[i]
|
||||
# S_s[15] &= 0x7f
|
||||
# assert S_s == S_s_new
|
||||
# """
|
||||
|
||||
pvh = PolyvalIUF(self.msg_auth_key, self.nonce)
|
||||
pvh.update(additional_data)
|
||||
pvh.update(plaintext)
|
||||
|
||||
length_block = le_uint64(len(additional_data) * 8) + \
|
||||
le_uint64(len(plaintext) * 8)
|
||||
pvh.update(length_block)
|
||||
|
||||
return pvh.digest()
|
||||
|
||||
def encrypt(self, plaintext, additional_data):
|
||||
"""Encrypt"""
|
||||
|
||||
if len(plaintext) > 2**36:
|
||||
raise ValueError('plaintext too large')
|
||||
|
||||
if len(additional_data) > 2**36:
|
||||
raise ValueError('additional_data too large')
|
||||
|
||||
# Polyval/tag calculation
|
||||
S_s = self._polyval_calc(plaintext, additional_data)
|
||||
tag = AES.new(self.msg_enc_key).encrypt(bytes(S_s))
|
||||
|
||||
# Encrypt
|
||||
counter_block = bytearray(tag)
|
||||
counter_block[15] |= 0x80
|
||||
return self._aes_ctr(self.msg_enc_key, bytes(counter_block), plaintext) + bytes(tag)
|
||||
|
||||
def decrypt(self, ciphertext, additional_data):
|
||||
"""Decrypt"""
|
||||
|
||||
if len(ciphertext) < 16 or len(ciphertext) > 2**36 + 16:
|
||||
raise ValueError('ciphertext too small or too large')
|
||||
|
||||
if len(additional_data) > 2**36:
|
||||
raise ValueError('additional_data too large')
|
||||
|
||||
ciphertext, tag = ciphertext[0:-16], ciphertext[-16:]
|
||||
|
||||
counter_block = bytearray(tag)
|
||||
counter_block[15] |= 0x80
|
||||
plaintext = self._aes_ctr(self.msg_enc_key, bytes(counter_block), ciphertext)
|
||||
|
||||
# Polyval/tag calculation
|
||||
S_s = self._polyval_calc(plaintext, additional_data)
|
||||
expected_tag = bytearray(AES.new(self.msg_enc_key, AES.MODE_ECB).encrypt(bytes(S_s)))
|
||||
|
||||
# Check tag
|
||||
actual_tag = bytearray(tag)
|
||||
|
||||
xor_sum = 0
|
||||
for i in range(len(expected_tag)):
|
||||
xor_sum |= expected_tag[i] ^ actual_tag[i]
|
||||
|
||||
if xor_sum != 0:
|
||||
raise ValueError('auth fail')
|
||||
|
||||
return plaintext
|
||||
Loading…
Reference in a new issue