/** Encrypts a packet and adds the common method header */
static bool method_encrypt(UNUSED fastd_peer_t *peer, fastd_method_session_state_t *session, fastd_buffer_t *out, fastd_buffer_t in) {
size_t tail_len = alignto(in.len, sizeof(fastd_block128_t))-in.len;
*out = fastd_buffer_alloc(in.len, alignto(COMMON_HEADBYTES, 16), sizeof(fastd_block128_t)+tail_len);
if (tail_len)
memset(in.data+in.len, 0, tail_len);
uint8_t nonce[session->method->cipher_info->iv_length ?: 1] __attribute__((aligned(8)));
fastd_method_expand_nonce(nonce, session->common.send_nonce, sizeof(nonce));
int n_blocks = block_count(in.len, sizeof(fastd_block128_t));
fastd_block128_t *inblocks = in.data;
fastd_block128_t *outblocks = out->data;
bool ok = session->cipher->crypt(session->cipher_state, outblocks, inblocks, n_blocks*sizeof(fastd_block128_t), nonce);
if (!ok) {
fastd_buffer_free(*out);
return false;
}
fastd_buffer_free(in);
fastd_method_put_common_header(out, session->common.send_nonce, 0);
fastd_method_increment_nonce(&session->common);
return true;
}
/** Verifies and decrypts a packet */
static bool method_decrypt(fastd_peer_t *peer, fastd_method_session_state_t *session, fastd_buffer_t *out, fastd_buffer_t in, bool *reordered) {
if (in.len < COMMON_HEADBYTES+sizeof(fastd_block128_t))
return false;
if (!method_session_is_valid(session))
return false;
uint8_t in_nonce[COMMON_NONCEBYTES];
uint8_t flags;
int64_t age;
if (!fastd_method_handle_common_header(&session->common, &in, in_nonce, &flags, &age))
return false;
if (flags)
return false;
uint8_t nonce[session->method->cipher_info->iv_length] __attribute__((aligned(8)));
fastd_method_expand_nonce(nonce, in_nonce, sizeof(nonce));
size_t tail_len = alignto(in.len, sizeof(fastd_block128_t))-in.len;
*out = fastd_buffer_alloc(in.len, 0, tail_len);
int n_blocks = block_count(in.len, sizeof(fastd_block128_t));
fastd_block128_t *inblocks = in.data;
fastd_block128_t *outblocks = out->data;
fastd_block128_t tag;
bool ok = session->cipher->crypt(session->cipher_state, outblocks, inblocks, n_blocks*sizeof(fastd_block128_t), nonce);
if (ok) {
if (tail_len)
memset(in.data+in.len, 0, tail_len);
put_size(&inblocks[n_blocks], in.len-sizeof(fastd_block128_t));
ok = session->ghash->digest(session->ghash_state, &tag, inblocks+1, n_blocks*sizeof(fastd_block128_t));
}
if (!ok || !block_equal(&tag, &outblocks[0])) {
fastd_buffer_free(*out);
return false;
}
fastd_buffer_free(in);
fastd_buffer_push_head(out, sizeof(fastd_block128_t));
fastd_tristate_t reorder_check = fastd_method_reorder_check(peer, &session->common, in_nonce, age);
if (reorder_check.set) {
*reordered = reorder_check.state;
}
else {
fastd_buffer_free(*out);
*out = fastd_buffer_alloc(0, 0, 0);
}
return true;
}
/// read super block and write to image head
extern void initial_image_hdr(char* device, image_head* image_hdr)
{
int fs_type = 0;
fs_type = test_extfs_type(device);
log_mesg(1, 0, 0, fs_opt.debug, "%s: extfs version is %i\n", __FILE__, fs_type);
strncpy(image_hdr->magic, IMAGE_MAGIC, IMAGE_MAGIC_SIZE);
strncpy(image_hdr->fs, extfs_MAGIC, FS_MAGIC_SIZE);
fs_open(device);
image_hdr->block_size = (int)block_size();
image_hdr->totalblock = (unsigned long long)block_count();
image_hdr->usedblocks = (unsigned long long)get_used_blocks();
image_hdr->device_size = (unsigned long long)(image_hdr->block_size * image_hdr->totalblock);
fs_close();
}
void generate_frequencies(unsigned int freq[][2][3], double *frequencies)
{
std::vector<unsigned int> block_count(72, 0);
double num_blocks = 80.0;
int i = 0;
while(i < 40){
block_count[(freq[i][0][0])]++;
i++;
}
i=0;
while(i < 40){
block_count[(freq[i][0][1]+12)]++;
i++;
}
i=0;
while(i < 40){
block_count[(freq[i][0][2]+24)]++;
i++;
}
i=0;
while(i < 40){
block_count[(freq[i][1][0]+36)]++;
i++;
}
i=0;
while(i < 40){
block_count[(freq[i][1][1]+48)]++;
i++;
}
i=0;
while(i < 40){
block_count[(freq[i][1][2]+60)]++;
i++;
}
for(unsigned int j = 0; j !=72; j++){
frequencies[j] = block_count[j]/num_blocks;
}
}
static Block
blocks_sort( /* Sort 'b1' on 'live_bytes'. */
Block b1)
{
int len = block_count(b1);
if (len < 2)
return b1;
{
Block b2 = blocks_split(b1, len / 2);
return blocks_merge(blocks_sort(b1), blocks_sort(b2)
);
}
}
void read_super_blocks(char* device, file_system_info* fs_info)
{
int fs_type = 0;
fs_type = test_extfs_type(device);
log_mesg(1, 0, 0, fs_opt.debug, "%s: extfs version is %i\n", __FILE__, fs_type);
strncpy(fs_info->fs, extfs_MAGIC, FS_MAGIC_SIZE);
fs_open(device);
fs_info->block_size = block_size();
fs_info->totalblock = block_count();
fs_info->usedblocks = get_used_blocks();
fs_info->device_size = fs_info->block_size * fs_info->totalblock;
log_mesg(1, 0, 0, fs_opt.debug, "%s: extfs block_size %i\n", __FILE__, fs_info->block_size);
log_mesg(1, 0, 0, fs_opt.debug, "%s: extfs total block %lli\n", __FILE__, fs_info->totalblock);
log_mesg(1, 0, 0, fs_opt.debug, "%s: extfs used blocks %lli\n", __FILE__, fs_info->usedblocks);
log_mesg(1, 0, 0, fs_opt.debug, "%s: extfs device size %lli\n", __FILE__, fs_info->device_size);
fs_close();
}
/** Encrypts and authenticates a packet */
static bool method_encrypt(UNUSED fastd_peer_t *peer, fastd_method_session_state_t *session, fastd_buffer_t *out, fastd_buffer_t in) {
size_t tail_len = in.len ? alignto(in.len, 2 * sizeof(fastd_block128_t))-in.len : (2 * sizeof(fastd_block128_t));
fastd_buffer_pull_head_zero(&in, sizeof(fastd_block128_t));
*out = fastd_buffer_alloc(in.len, alignto(COMMON_HEADBYTES, 16), tail_len);
uint8_t nonce[session->method->cipher_info->iv_length] __attribute__((aligned(8)));
fastd_method_expand_nonce(nonce, session->common.send_nonce, sizeof(nonce));
int n_blocks = block_count(in.len, sizeof(fastd_block128_t));
fastd_block128_t *inblocks = in.data;
fastd_block128_t *outblocks = out->data;
fastd_block128_t tag;
bool ok = session->cipher->crypt(session->cipher_state, outblocks, inblocks, n_blocks*sizeof(fastd_block128_t), nonce);
if (ok) {
if (tail_len)
memset(out->data+out->len, 0, tail_len);
ok = session->uhash->digest(session->uhash_state, &tag, outblocks+1, out->len - sizeof(fastd_block128_t));
}
if (!ok) {
fastd_buffer_free(*out);
return false;
}
xor_a(&outblocks[0], &tag);
fastd_buffer_free(in);
fastd_method_put_common_header(out, session->common.send_nonce, 0);
fastd_method_increment_nonce(&session->common);
return true;
}
int com_mac_validate(char* arg) {
char* a = strtok(arg, " ");
if (a && strtok(NULL, " ") != (char*)NULL) {
printf("Too many arguments\n");
return -1;
}
mf_size_t size = parse_size_default(a, MF_1K);
if (size == MF_INVALID_SIZE) {
printf("Unknown argument: %s\n", a);
return -1;
}
for(size_t i = 1; i < block_count(size); i++)
{
if(is_trailer_block(i))
{
continue;
}
unsigned char* mac = compute_block_mac(i, current_mac_key, 0);
printf("Block: %2x ", i);
printf("Tag: ");
print_hex_array_sep(¤t_tag.amb[i].mbd.abtData[14], 2, " ");
printf(" Computed: ");
print_hex_array_sep(mac, 2, " ");
printf(" Result: ");
if(memcmp(mac, ¤t_tag.amb[i].mbd.abtData[14], 2) == 0)
{
printf("VALID");
} else {
printf("IN-VALID");
}
printf("\n");
}
return 0;
}
static int
write_map (mapDef *mtab, int count,
unsigned char *codestr, int depth,
struct sbuf *wbuf, pdf_obj *stream)
{
int c, i, block_length;
mapDef *mtab1;
/* Must be greater than 1 */
#define BLOCK_LEN_MIN 2
struct {
int start, count;
} blocks[256/BLOCK_LEN_MIN+1];
int num_blocks = 0;
for (c = 0; c < 256; c++) {
codestr[depth] = (unsigned char) (c & 0xff);
if (LOOKUP_CONTINUE(mtab[c].flag)) {
mtab1 = mtab[c].next;
count = write_map(mtab1, count,
codestr, depth + 1, wbuf, stream);
} else {
if (MAP_DEFINED(mtab[c].flag)) {
switch (MAP_TYPE(mtab[c].flag)) {
case MAP_IS_CID: case MAP_IS_CODE:
block_length = block_count(mtab, c);
if (block_length >= BLOCK_LEN_MIN) {
blocks[num_blocks].start = c;
blocks[num_blocks].count = block_length;
num_blocks++;
c += block_length;
} else {
*(wbuf->curptr)++ = '<';
for (i = 0; i <= depth; i++)
sputx(codestr[i], &(wbuf->curptr), wbuf->limptr);
*(wbuf->curptr)++ = '>';
*(wbuf->curptr)++ = ' ';
*(wbuf->curptr)++ = '<';
for (i = 0; i < mtab[c].len; i++)
sputx(mtab[c].code[i], &(wbuf->curptr), wbuf->limptr);
*(wbuf->curptr)++ = '>';
*(wbuf->curptr)++ = '\n';
count++;
}
break;
case MAP_IS_NAME:
ERROR("%s: Unexpected error...", CMAP_DEBUG_STR);
break;
case MAP_IS_NOTDEF:
break;
default:
ERROR("%s: Unknown mapping type: %d",
CMAP_DEBUG_STR, MAP_TYPE(mtab[c].flag));
}
}
}
/* Flush if necessary */
if (count >= 100 ||
wbuf->curptr >= wbuf->limptr ) {
char fmt_buf[32];
if (count > 100)
ERROR("Unexpected error....: %d", count);
sprintf(fmt_buf, "%d beginbfchar\n", count);
pdf_add_stream(stream, fmt_buf, strlen(fmt_buf));
pdf_add_stream(stream,
wbuf->buf, (int) (wbuf->curptr - wbuf->buf));
wbuf->curptr = wbuf->buf;
pdf_add_stream(stream,
"endbfchar\n", strlen("endbfchar\n"));
count = 0;
}
}
if (num_blocks > 0) {
char fmt_buf[32];
if (count > 0) {
sprintf(fmt_buf, "%d beginbfchar\n", count);
pdf_add_stream(stream, fmt_buf, strlen(fmt_buf));
pdf_add_stream(stream,
wbuf->buf, (int) (wbuf->curptr - wbuf->buf));
wbuf->curptr = wbuf->buf;
pdf_add_stream(stream,
"endbfchar\n", strlen("endbfchar\n"));
count = 0;
}
sprintf(fmt_buf, "%d beginbfrange\n", num_blocks);
pdf_add_stream(stream, fmt_buf, strlen(fmt_buf));
for (i = 0; i < num_blocks; i++) {
int j;
c = blocks[i].start;
*(wbuf->curptr)++ = '<';
for (j = 0; j < depth; j++)
sputx(codestr[j], &(wbuf->curptr), wbuf->limptr);
sputx((unsigned char)c, &(wbuf->curptr), wbuf->limptr);
*(wbuf->curptr)++ = '>';
*(wbuf->curptr)++ = ' ';
*(wbuf->curptr)++ = '<';
for (j = 0; j < depth; j++)
sputx(codestr[j], &(wbuf->curptr), wbuf->limptr);
sputx((unsigned char)(c + blocks[i].count), &(wbuf->curptr), wbuf->limptr);
*(wbuf->curptr)++ = '>';
*(wbuf->curptr)++ = ' ';
*(wbuf->curptr)++ = '<';
for (j = 0; j < mtab[c].len; j++)
sputx(mtab[c].code[j], &(wbuf->curptr), wbuf->limptr);
*(wbuf->curptr)++ = '>';
*(wbuf->curptr)++ = '\n';
}
pdf_add_stream(stream,
wbuf->buf, (int) (wbuf->curptr - wbuf->buf));
wbuf->curptr = wbuf->buf;
pdf_add_stream(stream,
"endbfrange\n", strlen("endbfrange\n"));
}
return count;
}
static ssize_t block_read_count(struct kobj_t * kobj, void * buf, size_t size)
{
struct block_t * blk = (struct block_t *)kobj->priv;
return sprintf(buf, "%lld", block_count(blk));
}
u64_t block_write(struct block_t * blk, u8_t * buf, u64_t offset, u64_t count)
{
u64_t blkno, blksz, blkcnt, capacity;
u64_t len, tmp;
u64_t ret = 0;
u8_t * p;
if(!blk || !buf || !count)
return 0;
blksz = block_size(blk);
blkcnt = block_count(blk);
if(!blksz || !blkcnt)
return 0;
capacity = block_capacity(blk);
if(offset >= capacity)
return 0;
tmp = capacity - offset;
if(count > tmp)
count = tmp;
p = malloc(blksz);
if(!p)
return 0;
blkno = offset / blksz;
tmp = offset % blksz;
if(tmp > 0)
{
len = blksz - tmp;
if(count < len)
len = count;
if(blk->read(blk, p, blkno, 1) != 1)
{
free(p);
return ret;
}
memcpy((void *)(&p[tmp]), (const void *)buf, len);
if(blk->write(blk, p, blkno, 1) != 1)
{
free(p);
return ret;
}
buf += len;
count -= len;
ret += len;
blkno += 1;
}
tmp = count / blksz;
if(tmp > 0)
{
len = tmp * blksz;
if(blk->write(blk, buf, blkno, tmp) != tmp)
{
free(p);
return ret;
}
buf += len;
count -= len;
ret += len;
blkno += tmp;
}
if(count > 0)
{
len = count;
if(blk->read(blk, p, blkno, 1) != 1)
{
free(p);
return ret;
}
memcpy((void *)(&p[0]), (const void *)buf, len);
if(blk->write(blk, p, blkno, 1) != 1)
{
free(p);
return ret;
}
ret += len;
}
free(p);
return ret;
}
void LinearScan::allocate_fpu_stack() {
// First compute which FPU registers are live at the start of each basic block
// (To minimize the amount of work we have to do if we have to merge FPU stacks)
if (ComputeExactFPURegisterUsage) {
Interval* intervals_in_register, *intervals_in_memory;
create_unhandled_lists(&intervals_in_register, &intervals_in_memory, is_in_fpu_register, NULL);
// ignore memory intervals by overwriting intervals_in_memory
// the dummy interval is needed to enforce the walker to walk until the given id:
// without it, the walker stops when the unhandled-list is empty -> live information
// beyond this point would be incorrect.
Interval* dummy_interval = new Interval(any_reg);
dummy_interval->add_range(max_jint - 2, max_jint - 1);
dummy_interval->set_next(Interval::end());
intervals_in_memory = dummy_interval;
IntervalWalker iw(this, intervals_in_register, intervals_in_memory);
const int num_blocks = block_count();
for (int i = 0; i < num_blocks; i++) {
BlockBegin* b = block_at(i);
// register usage is only needed for merging stacks -> compute only
// when more than one predecessor.
// the block must not have any spill moves at the beginning (checked by assertions)
// spill moves would use intervals that are marked as handled and so the usage bit
// would been set incorrectly
// NOTE: the check for number_of_preds > 1 is necessary. A block with only one
// predecessor may have spill moves at the begin of the block.
// If an interval ends at the current instruction id, it is not possible
// to decide if the register is live or not at the block begin -> the
// register information would be incorrect.
if (b->number_of_preds() > 1) {
int id = b->first_lir_instruction_id();
ResourceBitMap regs(FrameMap::nof_fpu_regs);
iw.walk_to(id); // walk after the first instruction (always a label) of the block
assert(iw.current_position() == id, "did not walk completely to id");
// Only consider FPU values in registers
Interval* interval = iw.active_first(fixedKind);
while (interval != Interval::end()) {
int reg = interval->assigned_reg();
assert(reg >= pd_first_fpu_reg && reg <= pd_last_fpu_reg, "no fpu register");
assert(interval->assigned_regHi() == -1, "must not have hi register (doubles stored in one register)");
assert(interval->from() <= id && id < interval->to(), "interval out of range");
#ifndef PRODUCT
if (TraceFPURegisterUsage) {
tty->print("fpu reg %d is live because of ", reg - pd_first_fpu_reg); interval->print();
}
#endif
regs.set_bit(reg - pd_first_fpu_reg);
interval = interval->next();
}
b->set_fpu_register_usage(regs);
#ifndef PRODUCT
if (TraceFPURegisterUsage) {
tty->print("FPU regs for block %d, LIR instr %d): ", b->block_id(), id); regs.print_on(tty); tty->cr();
}
#endif
}
}
}
FpuStackAllocator alloc(ir()->compilation(), this);
_fpu_stack_allocator = &alloc;
alloc.allocate();
_fpu_stack_allocator = NULL;
}
bool mf_read_tag_internal(mf_tag_t* tag,
const mf_tag_t* keys, mf_key_type_t key_type) {
mifare_param mp;
static mf_tag_t buffer_tag;
clear_tag(&buffer_tag);
int error = 0;
printf("Reading: ["); fflush(stdout);
// Read the card from end to begin
for (int block_it = (int)block_count(size) - 1; block_it >= 0; --block_it) {
size_t block = (size_t)block_it;
// Authenticate everytime we reach a trailer block
if (is_trailer_block(block)) {
// Try to authenticate for the current sector
uint8_t* key = key_from_tag(keys, key_type, block);
if (!mf_authenticate(block, key, key_type)) {
// Progress indication and error report
printf("0x%02zx", block_to_sector(block));
if (block != 3) printf(".");
fflush(stdout);
block_it -= (int)sector_size(block) - 1; // Skip the rest of the sector blocks
error = 1;
}
else {
// Try to read the trailer (only to *read* the access bits)
if (nfc_initiator_mifare_cmd(device, MC_READ, (uint8_t)block, &mp)) {
// Copy the keys over to our tag buffer
key_to_tag(&buffer_tag, keys->amb[block].mbt.abtKeyA, MF_KEY_A, block);
key_to_tag(&buffer_tag, keys->amb[block].mbt.abtKeyB, MF_KEY_B, block);
// Store the retrieved access bits in the tag buffer
memcpy(buffer_tag.amb[block].mbt.abtAccessBits,
mp.mpd.abtData + 6, 4);
} else {
printf ("\nUnable to read trailer block: 0x%02zx.\n", block);
return false;
}
printf("."); fflush(stdout); // Progress indicator
}
}
else { // I.e. not a sector trailer
// Try to read out the block
if (!nfc_initiator_mifare_cmd(device, MC_READ, (uint8_t)block, &mp)) {
printf("\nUnable to read block: 0x%02zx.\n", block);
return false;
}
memcpy(buffer_tag.amb[block].mbd.abtData, mp.mpd.abtData, 0x10);
}
}
// Terminate progress indicator
if (error)
printf("] Auth errors in indicated sectors.\n");
else
printf("] Success!\n");
// Success! Copy the data
// todo: Or return static ptr?
memcpy(tag, &buffer_tag, MF_4K);
return true;
}
