static int print_cube(cube_t *cube){
int i;
int j;
int k;
for(i = 0; i < CUBE_ORDER; ++i){
for(j = 0; j < CUBE_ORDER; ++j){
print_block(&cube->face[UUU].block[i][j]);
}
printf("%x", i);
printf("\n");
}
printf("0 1 2 3 4 5 6 7 8 9 a a 9 8 7 6 5 4 3 2 1 0 a 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 a\n");
for(i = 0; i < CUBE_ORDER; ++i){
for(k = FFF; k <= LLL; ++k){
for(j = 0; j < CUBE_ORDER; ++j){
print_block(&cube->face[k].block[i][j]);
}
printf("%x", CUBE_ORDER - 1 - i);
}
printf("\n");
}
printf("0 1 2 3 4 5 6 7 8 9 a a 9 8 7 6 5 4 3 2 1 0 a 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 a\n");
for(i = 0; i < CUBE_ORDER; ++i){
for(j = 0; j < CUBE_ORDER; ++j){
print_block(&cube->face[DDD].block[i][j]);
}
printf("%x", CUBE_ORDER - 1 - i);
printf("\n");
}
printf("0 1 2 3 4 5 6 7 8 9 a\n");
return 0;
}
/*(Key (128): E8E9EAEBEDEEEFF0F2F3F4F5F7F8F9FA
Plaintext: 014BAF2278A69D331D5180103643E99A
Ciphertext: 6743C3D1519AB4F2CD9A78AB09A511BD */
void test_encryption(){
unsigned char
/* TODO: old values taht seem to be invalid:
key[] = {0xE8, 0xE9, 0xEA, 0xEB, 0xED, 0xEE, 0xEF, 0xF0, 0xF2, 0xF3, 0xF4, 0xF5, 0xF7, 0xF8, 0xF9, 0xFA},
plain[] = {0x01, 0x4B, 0xAF, 0x22, 0x78, 0xA6, 0x9D, 0x33, 0x1D, 0x51, 0x80, 0x10, 0x36, 0x43, 0xE9, 0x9A},
cipher[] = {0x67, 0x43, 0xC3, 0xD1, 0x51, 0x9A, 0xB4, 0xF2, 0xCD, 0x9A, 0x78, 0xAB, 0x09, 0xA5, 0x11, 0xBD};
*/
/* TODO: test w/these values instead. if they work, investigate why the other ones don't:
data = [0x68, 0x65, 0x6c, 0x6c,
0x6f, 0x2c, 0x20, 0x77,
0x6f, 0x72, 0x6c, 0x64,
0x21, 0x21, 0x21, 0x21]
key = [0x0f, 0x15, 0x71, 0xc9,
0x47, 0xd9, 0xe8, 0x59,
0x0c, 0xb7, 0xad, 0xd6,
0xaf, 0x7f, 0x67, 0x98]
result = @aes.encrypt(data, key)
assert_equal([0x56, 0xdd, 0x68, 0x15, 0x44, 0x65, 0x7b, 0x76, 0xe5, 0x93, 0x51, 0xf5, 0x7d, 0x95, 0xa4, 0xb3],
result)
*/
unsigned char *c = encrypt(plain, key, 16);
print_block(c, 16);
print_block(cipher, 16);
assert( bytencmp(c, cipher, 16) == 0 );
//unsigned char *p = decrypt(c, key, 16);
//assert( bytencmp(p, plain, 16) == 0 );
free(c);
// free(p);
}
void print_disk_tree (int block_nr)
{
struct buffer_head * bh;
bh = bread (g_sb.s_dev, block_nr, g_sb.s_blocksize);
if (B_IS_KEYS_LEVEL (bh)) {
int i;
struct disk_child * dc;
g_stat_info.nr_internals ++;
print_block (bh, print_mode (), -1, -1);
dc = B_N_CHILD (bh, 0);
for (i = 0; i <= B_NR_ITEMS (bh); i ++, dc ++)
print_disk_tree (dc->dc_block_number);
} else if (B_IS_ITEMS_LEVEL (bh)) {
g_stat_info.nr_leaves ++;
print_block (bh, print_mode (), -1, -1);
} else {
print_block (bh, print_mode (), -1, -1);
die ("print_disk_tree: bad block type");
}
brelse (bh);
}
void print_block(value v, int m)
{
int size, i;
margin(m);
if (Is_long(v))
{
printf("immediate value (%ld)\n", Long_val(v));
return;
}
printf("memory block: size=%d - ", size=Wosize_val(v));
switch(Tag_val(v))
{
case Closure_tag:
printf("closure with %d free variables\n", size-1);
margin(m+4);
printf("code pointer: %p\n", Code_val(v));
for (i=1; i<size; i++)
print_block(Field(v,i),m+4);
break;
case String_tag:
printf("string: %s (%s)\n", String_val(v), (char *) v);
break;
case Double_tag:
printf("float: %g\n", Double_val(v));
break;
case Double_array_tag:
printf("float array: ");
for (i=0; i<size/Double_wosize; i++)
printf(" %g", Double_field(v,i));
printf("\n");
break;
case Abstract_tag:
printf("abstract type\n");
break;
case Custom_tag:
printf("abstract finalized type\n");
break;
default:
if (Tag_val(v) >= No_scan_tag)
{
printf("unknown tag");
break;
};
printf("structured block (tag=%d):\n", Tag_val(v));
for (i=0; i<size; i++)
print_block(Field(v,i), m+4);
}
return;
}
/*
* Set up the indentation for a list item; used from pre_it().
*/
static void
print_width(const struct mdoc_bl *bl, const struct roff_node *child)
{
char buf[24];
struct roffsu su;
const char *end;
int numeric, remain, sz, chsz;
numeric = 1;
remain = 0;
/* Convert the width into a number (of characters). */
if (bl->width == NULL)
sz = (bl->type == LIST_hang) ? 6 : 0;
else {
end = a2roffsu(bl->width, &su, SCALE_MAX);
if (end == NULL || *end != '\0')
sz = man_strlen(bl->width);
else if (SCALE_EN == su.unit)
sz = su.scale;
else {
sz = 0;
numeric = 0;
}
}
/* XXX Rough estimation, might have multiple parts. */
if (bl->type == LIST_enum)
chsz = (bl->count > 8) + 1;
else if (child != NULL && child->type == ROFFT_TEXT)
chsz = man_strlen(child->string);
else
chsz = 0;
/* Maybe we are inside an enclosing list? */
mid_it();
/*
* Save our own indentation,
* such that child lists can use it.
*/
Bl_stack[Bl_stack_len++] = sz + 2;
/* Set up the current list. */
if (chsz > sz && bl->type != LIST_tag)
print_block(".HP", 0);
else {
print_block(".TP", 0);
remain = sz + 2;
}
if (numeric) {
(void)snprintf(buf, sizeof(buf), "%dn", sz + 2);
print_word(buf);
} else
print_word(bl->width);
TPremain = remain;
}
/*
* Set up the indentation for a list item; used from pre_it().
*/
static void
print_width(const char *v, const struct mdoc_node *child, size_t defsz)
{
char buf[24];
struct roffsu su;
size_t sz, chsz;
int numeric, remain;
numeric = 1;
remain = 0;
/* Convert v into a number (of characters). */
if (NULL == v)
sz = defsz;
else if (a2roffsu(v, &su, SCALE_MAX)) {
if (SCALE_EN == su.unit)
sz = su.scale;
else {
sz = 0;
numeric = 0;
}
} else
sz = strlen(v);
/* XXX Rough estimation, might have multiple parts. */
chsz = (NULL != child && MDOC_TEXT == child->type) ?
strlen(child->string) : 0;
/* Maybe we are inside an enclosing list? */
mid_it();
/*
* Save our own indentation,
* such that child lists can use it.
*/
Bl_stack[Bl_stack_len++] = sz + 2;
/* Set up the current list. */
if (defsz && chsz > sz)
print_block(".HP", 0);
else {
print_block(".TP", 0);
remain = sz + 2;
}
if (numeric) {
(void)snprintf(buf, sizeof(buf), "%zun", sz + 2);
print_word(buf);
} else
print_word(v);
TPremain = remain;
}
void test_chacha(const uint8_t *key, const uint8_t *iv, uint8_t *expected,
uint8_t keylength, uint8_t rounds) {
uint8_t cipher_data[64] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
uint8_t cipher_result[64] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
struct chacha_ctx cipher_ctx;
uint8_t errors;
chacha_set_key(&cipher_ctx, keylength, key);
chacha_set_iv(&cipher_ctx, iv);
chacha_crypt(&cipher_ctx, 64, rounds, &cipher_result[0], &cipher_data[0]);
if (DEBUG) {
printf("Result after encryption:\n");
print_block(cipher_result);
}
errors = 0;
for (uint8_t i = 0 ; i < 64 ; i++) {
if (cipher_result[i] != expected[i]) {
errors++;
}
}
if (errors > 0) {
printf("Error, expected:\n");
print_block(&expected[0]);
printf("Got:\n");
print_block(cipher_result);
}
else {
printf("Success, result matched expected.\n");
}
}
/* first calls search_by_key, then, if item is not found looks for the entry inside directory item indicated by
search_by_key. (We assign a key to each directory item, and place multiple entries in a single directory item.)
Fills the path to the entry, and to the entry position in the item */
int search_by_entry_key (struct super_block * sb, struct key * key, struct path * path, int * pos_in_item, int * repeat)
{
/* search for a directory item using key of entry */
if (search_by_key (sb, key, path, repeat, DISK_LEAF_NODE_LEVEL, READ_BLOCKS) == ITEM_FOUND) {
*pos_in_item = 0;
return POSITION_FOUND;
}
#ifdef REISERFS_CHECK
if (!PATH_LAST_POSITION (path))
reiserfs_panic (sb, "vs-7000: search_by_entry_key: search_by_key returned item position == 0");
#endif /* REISERFS_CHECK */
PATH_LAST_POSITION (path) --;
#ifdef REISERFS_CHECK
{
struct item_head * ih = B_N_PITEM_HEAD (PATH_PLAST_BUFFER (path), PATH_LAST_POSITION (path));
if (!I_IS_DIRECTORY_ITEM (ih) || COMP_SHORT_KEYS (&(ih->ih_key), key)) {
print_block (PATH_PLAST_BUFFER (path), 0, -1, -1);
reiserfs_panic (sb, "vs-7005: search_by_entry_key: found item %h is not directory item or "
"does not belong to the same directory as key %k", ih, key);
}
}
#endif /* REISERFS_CHECK */
/* binary search in directory item by third component of the key */
return bin_search_in_dir_item (PATH_PITEM_HEAD (path), B_I_DEH (PATH_PLAST_BUFFER (path), PATH_PITEM_HEAD (path)), key, pos_in_item);
}
void decrypt_key(unsigned char* decryptedSap, unsigned char* keyIn, unsigned char* iv, unsigned char* keyOut)
{
unsigned char blockIn[16];
uint32_t key_schedule[11][4];
uint32_t mode_key_schedule[11][4];
generate_key_schedule(&decryptedSap[8], key_schedule);
printf("Generating mode key:\n");
generate_key_schedule(initial_session_key, mode_key_schedule);
z_xor(keyIn, blockIn, 1);
print_block("Input to cycle is: ", blockIn);
cycle(blockIn, key_schedule);
for (int j = 0; j < 16; j++)
keyOut[j] = blockIn[j] ^ iv[j];
print_block("Output from cycle is: ", keyOut);
x_xor(keyOut, keyOut, 1);
}
void test_shift_rows(){
char msg[] = "0123456789ABCDE";
print_block(msg, 16);
printf("\n");
shift_rows(msg, 16);
print_block(msg, 16);
printf("\n");
inv_shift_rows(msg, 16);
print_block(msg, 16);
// TODO: cannot use strcmp because it stops on 0!
// TODO: assert inv is equal to original
assert( strcmp(msg, "0123456789ABCDE") == 0 );
}
void permute_block_1(unsigned char* block)
{
block[0] = table_s3[block[0]];
block[4] = table_s3[0x400+block[4]];
block[8] = table_s3[0x800+block[8]];
block[12] = table_s3[0xc00+block[12]];
unsigned char tmp = block[13];
block[13] = table_s3[0x100+block[9]];
block[9] = table_s3[0xd00+block[5]];
block[5] = table_s3[0x900+block[1]];
block[1] = table_s3[0x500+tmp];
tmp = block[2];
block[2] = table_s3[0xa00+block[10]];
block[10] = table_s3[0x200+tmp];
tmp = block[6];
block[6] = table_s3[0xe00+block[14]];
block[14] = table_s3[0x600+tmp];
tmp = block[3];
block[3] = table_s3[0xf00+block[7]];
block[7] = table_s3[0x300+block[11]];
block[11] = table_s3[0x700+block[15]];
block[15] = table_s3[0xb00+tmp];
print_block("Permutation complete. Final value of block: ", block); // This looks right to me, at least for decrypt_kernel
}
bool block_check_invariants_print_result(Block* block, Value* out)
{
circa::Value result;
block_check_invariants(&result, block);
if (list_length(&result) == 0)
return true;
string_append(out, list_length(&result));
string_append(out, " errors found in block ");
string_append_ptr(out, block);
string_append(out, "\n");
for (int i=0; i < list_length(&result); i++) {
Value* error = list_get(&result,i);
string_append(out, "[");
string_append(out, as_int(list_get(error, 1)));
string_append(out, "]");
string_append(out, as_cstring(list_get(error, 2)));
string_append(out, "\n");
}
string_append(out, "contents:\n");
print_block(block, out);
return false;
}
void permute_block_2(unsigned char* block, int round)
{
// round is 0..8?
printf("Permuting via table2, round %d... (block[0] = %02X)\n", round, block[0]);
block[0] = permute_table_2(round*16+0)[block[0]];
block[4] = permute_table_2(round*16+4)[block[4]];
block[8] = permute_table_2(round*16+8)[block[8]];
block[12] = permute_table_2(round*16+12)[block[12]];
unsigned char tmp = block[13];
block[13] = permute_table_2(round*16+13)[block[9]];
block[9] = permute_table_2(round*16+9)[block[5]];
block[5] = permute_table_2(round*16+5)[block[1]];
block[1] = permute_table_2(round*16+1)[tmp];
tmp = block[2];
block[2] = permute_table_2(round*16+2)[block[10]];
block[10] = permute_table_2(round*16+10)[tmp];
tmp = block[6];
block[6] = permute_table_2(round*16+6)[block[14]];
block[14] = permute_table_2(round*16+14)[tmp];
tmp = block[3];
block[3] = permute_table_2(round*16+3)[block[7]];
block[7] = permute_table_2(round*16+7)[block[11]];
block[11] = permute_table_2(round*16+11)[block[15]];
block[15] = permute_table_2(round*16+15)[tmp];
print_block("Permutation (2) complete. Final value of block: ", block); // This looks right to me, at least for decrypt_kernel
}
static int
pre_nm(DECL_ARGS)
{
char *name;
if (MDOC_BLOCK == n->type) {
outflags |= MMAN_Bk;
pre_syn(n);
}
if (MDOC_ELEM != n->type && MDOC_HEAD != n->type)
return(1);
name = n->child ? n->child->string : meta->name;
if (NULL == name)
return(0);
if (MDOC_HEAD == n->type) {
if (NULL == n->parent->prev)
outflags |= MMAN_sp;
print_block(".HP", 0);
printf(" %zun", strlen(name) + 1);
outflags |= MMAN_nl;
}
font_push('B');
if (NULL == n->child)
print_word(meta->name);
return(1);
}
static int
pre_fn(DECL_ARGS)
{
pre_syn(n);
n = n->child;
if (NULL == n)
return 0;
if (NODE_SYNPRETTY & n->flags)
print_block(".HP 4n", MMAN_nl);
font_push('B');
print_node(meta, n);
font_pop();
outflags &= ~MMAN_spc;
print_word("(");
outflags &= ~MMAN_spc;
n = n->next;
if (NULL != n)
pre_fa(meta, n);
return 0;
}
static int
pre_nm(DECL_ARGS)
{
char *name;
if (n->type == ROFFT_BLOCK) {
outflags |= MMAN_Bk;
pre_syn(n);
}
if (n->type != ROFFT_ELEM && n->type != ROFFT_HEAD)
return 1;
name = n->child ? n->child->string : meta->name;
if (NULL == name)
return 0;
if (n->type == ROFFT_HEAD) {
if (NULL == n->parent->prev)
outflags |= MMAN_sp;
print_block(".HP", 0);
printf(" %zun", strlen(name) + 1);
outflags |= MMAN_nl;
}
font_push('B');
if (NULL == n->child)
print_word(meta->name);
return 1;
}
static void
print_line(OBJ *obj)
{
struct stat *st;
FTSENT *p;
p = obj->obj_list;
while (p != NULL) {
if (p->fts_number == FTS_NO_PRINT) {
p = p->fts_link;
continue;
}
st = p->fts_statp;
/* print inode */
if (f_ino)
printf("%*"PRIuMAX" ", obj->obj_ino_max,
(uintmax_t)st->st_ino);
/* print number of blocks */
if (f_block) {
print_block(st->st_blocks * 512, obj->obj_block_max);
}
print_name(p, NO_LINK);
putchar('\n');
p = p->fts_link;
}
}
static int
pre_fo(DECL_ARGS)
{
switch (n->type) {
case ROFFT_BLOCK:
pre_syn(n);
break;
case ROFFT_HEAD:
if (n->child == NULL)
return 0;
if (NODE_SYNPRETTY & n->flags)
print_block(".HP 4n", MMAN_nl);
font_push('B');
break;
case ROFFT_BODY:
outflags &= ~(MMAN_spc | MMAN_nl);
print_word("(");
outflags &= ~MMAN_spc;
break;
default:
break;
}
return 1;
}
/**********************************************************
* print_heap
* Prints all the blocks in the heap till epilogue
**********************************************************/
void print_heap()
{
void *bp;
for (bp = heap_listp; GET_SIZE(HDRP(bp)) > 0; bp = NEXT_BLKP(bp))
{
print_block(bp);
}
}
void
print_long(OBJ *obj)
{
struct stat *st;
FTSENT *p;
char mode[MODE_BUFF_SIZE];
p = obj->obj_list;
if(!obj->obj_isroot)
print_total(obj->obj_size_total);
while (p != NULL) {
if (p->fts_number == FTS_NO_PRINT) {
p = p->fts_link;
continue;
}
st = p->fts_statp;
/* print inode */
if (f_ino)
printf("%*"PRIuMAX" ", obj->obj_ino_max,
(uintmax_t)st->st_ino);
/* print number of blocks */
if (f_block) {
print_block((int64_t)st->st_blocks * DEFAULT_BSIZE,
obj->obj_block_max);
}
/* print mode */
strmode(st->st_mode, mode);
printf("%11s ", mode);
/* print number of links */
printf("%*"PRIuMAX" ", obj->obj_link_max,
(uintmax_t)st->st_nlink);
/* print owner and group */
print_user_and_group(st->st_uid, st->st_gid,
obj->obj_user_max, obj->obj_group_max);
/* print size */
if (S_ISCHR(st->st_mode) || S_ISBLK(st->st_mode))
print_device(st->st_rdev, obj->obj_major_max,
obj->obj_minor_max);
else
print_size(st->st_size, obj->obj_size_max);
print_date(st);
print_name(p, WITH_LINK);
putchar('\n');
p = p->fts_link;
}
}
int main (int argc, char **argv)
{
int res = 1;
if (argc != 3) {
printf("Usage: %s <desugar=0/1> <string>\n", (argc > 0 ? argv[0] : ""));
goto fail0;
}
int desugar = atoi(argv[1]);
char *text = argv[2];
BLog_InitStdout();
// parse
NCDProgram prog;
if (!NCDConfigParser_Parse(text, strlen(text), &prog)) {
DEBUG("NCDConfigParser_Parse failed");
goto fail1;
}
// desugar
if (desugar) {
if (!NCDSugar_Desugar(&prog)) {
DEBUG("NCDSugar_Desugar failed");
goto fail2;
}
}
// print
for (NCDProgramElem *elem = NCDProgram_FirstElem(&prog); elem; elem = NCDProgram_NextElem(&prog, elem)) {
switch (NCDProgramElem_Type(elem)) {
case NCDPROGRAMELEM_PROCESS: {
NCDProcess *p = NCDProgramElem_Process(elem);
printf("process name=%s is_template=%d\n", NCDProcess_Name(p), NCDProcess_IsTemplate(p));
print_block(NCDProcess_Block(p), 2);
} break;
case NCDPROGRAMELEM_INCLUDE: {
printf("include path=%s\n", NCDProgramElem_IncludePathData(elem));
} break;
case NCDPROGRAMELEM_INCLUDE_GUARD: {
printf("include_guard id=%s\n", NCDProgramElem_IncludeGuardIdData(elem));
} break;
default: ASSERT(0);
}
}
res = 0;
fail2:
NCDProgram_Free(&prog);
fail1:
BLog_Free();
fail0:
return res;
}
/**********************************************************
* print_list
* Determines which bin to print from the segregated list
* based on the index
**********************************************************/
void print_list(int index)
{
dlist *current = sep_list_head[index];
while (current != NULL) {
print_block((void*)current);
current = current->next;
}
}
/* The function is NOT SCHEDULE-SAFE! */
int search_by_entry_key(struct super_block *sb, const struct cpu_key *key,
struct treepath *path, struct reiserfs_dir_entry *de)
{
int retval;
retval = search_item(sb, key, path);
switch (retval) {
case ITEM_NOT_FOUND:
if (!PATH_LAST_POSITION(path)) {
reiserfs_error(sb, "vs-7000", "search_by_key "
"returned item position == 0");
pathrelse(path);
return IO_ERROR;
}
PATH_LAST_POSITION(path)--;
case ITEM_FOUND:
break;
case IO_ERROR:
return retval;
default:
pathrelse(path);
reiserfs_error(sb, "vs-7002", "no path to here");
return IO_ERROR;
}
set_de_item_location(de, path);
#ifdef CONFIG_REISERFS_CHECK
if (!is_direntry_le_ih(de->de_ih) ||
COMP_SHORT_KEYS(&de->de_ih->ih_key, key)) {
print_block(de->de_bh, 0, -1, -1);
reiserfs_panic(sb, "vs-7005", "found item %h is not directory "
"item or does not belong to the same directory "
"as key %K", de->de_ih, key);
}
#endif /* CONFIG_REISERFS_CHECK */
/*
* binary search in directory item by third component of the
* key. sets de->de_entry_num of de
*/
retval = bin_search_in_dir_item(de, cpu_key_k_offset(key));
path->pos_in_item = de->de_entry_num;
if (retval != NAME_NOT_FOUND) {
/*
* ugly, but rename needs de_bh, de_deh, de_name,
* de_namelen, de_objectid set
*/
set_de_name_and_namelen(de);
set_de_object_key(de);
}
return retval;
}
static void print_all_blocks(tmp_block_t *block_list, unsigned r, unsigned c)
{
tmp_block_t *current_block = block_list;
while(current_block) {
print_block(current_block, r, c);
current_block = current_block->next;
};
}
void main()
{ struct block data,key,temp;
//unsigned char c1[16]={0x32,0x88,0x31,0xe0,0x43,0x5a,0x31,0x37,0xf6,0x30,0x98,0x07,0xa8,0x8d,0xa2,0x34};
//unsigned char c2[16]={0x2b,0x28,0xab,0x09,0x7e,0xae,0xf7,0xcf,0x15,0xd2,0x15,0x4f,0x16,0xa6,0x88,0x3c};
unsigned char c1[16]="Hello World. 123";
unsigned char c2[16]="My New Password.";
int i,j,c=0;
struct block round_key[11];
// Initializing Data and Key
for(i=0;i<4;i++)
{ for(j=0;j<4;j++)
{ data.b[i][j]=c1[c];
key.b[i][j]=c2[c];
c++;
}
}
printf("Data and key before encryption:");
printf("\n Data:\n");
print_block(data);
printf("\n Key:\n");
print_block(key);
printf("Generating All the round Keys:");
round_key[0]=key;
temp=key;
for(i=0;i<10;i++)
{ temp=next_key(temp,i);
round_key[i+1]=temp;
}
printf("All the keys generated.");
data=encrypt(data,round_key);
printf("Data after encryption:");
printf("\n Data:\n");
print_block(data);
printf("\nData After Decryption\n");
data=decrypt(data,round_key);
print_block(data);
}
void DisassemblerContext::print_function(const ValuePtr<Function>& term) {
print_function_type_term(term->function_type(), term);
if (!term->blocks().empty()) {
*m_output << " {\n";
for (Function::BlockList::const_iterator ii = term->blocks().begin(), ie = term->blocks().end(); ii != ie; ++ii)
print_block(*ii, m_local_definitions[*ii]);
*m_output << "}";
}
*m_output << ";\n";
}
int main()
{
unsigned char key[8] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef};
unsigned char block[8] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xe7};
unsigned char tmp_block[8] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
unsigned char zero_block[8] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
uint64_t k_arr[16]={
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0};
des_ctx ctx={
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
};
uint64_t tmp;
int i;
des_key(&ctx, key);
des_gen_ks(des_byte2key(key), k_arr);
// print_block("k[0] my", k_arr);
// print_block("k[0] work", ctx.ek);
/* tmp = des_f(0,k_arr[0]);
print_block32("des_f(0,k[1])", &tmp);
tmp = des_ssl_f(0,ctx.ek);
print_block32("ssl_f(0,k[1])", &tmp);
tmp = des_work_f(0,ctx.ek);
print_block32("work_f(0,k[1])", &tmp);
*/
des_enc(&ctx, block, 1);
print_block("Encrypted", block);
des_dec(&ctx, block, 1);
print_block("Decrypted", block);
puts("===============================================");
print_block("Plain", block);
//*(uint64_t*)block = des_byte2key(block);
des_block_crypt((uint64_t*)block, k_arr, DES_ENCRYPT_ACT);
print_block("Encrypted", block);
reverse_bit_buff(tmp_block, block, 8);
print_block("Mirrored", tmp_block);
for(i=0; i<8; i++) tmp_block[i]=reverse_bit_byte(block[i]);
print_block("ByBitMirrored", tmp_block);
des_block_crypt((uint64_t*)block, k_arr, DES_DECRYPT_ACT);
print_block("Decrypted", block);
return 0;
}
/*
* Print before a section header.
*/
static int
pre_sect(DECL_ARGS)
{
if (n->type == ROFFT_HEAD) {
outflags |= MMAN_sp;
print_block(manacts[n->tok].prefix, 0);
print_word("");
putchar('\"');
outflags &= ~MMAN_spc;
}
return 1;
}
/*
* Print before a section header.
*/
static int
pre_sect(DECL_ARGS)
{
if (MDOC_HEAD == n->type) {
outflags |= MMAN_sp;
print_block(manacts[n->tok].prefix, 0);
print_word("");
putchar('\"');
outflags &= ~MMAN_spc;
}
return(1);
}
void decrypt_sap(unsigned char* sapIn, unsigned char* sapOut)
{
uint32_t key_schedule[11][4];
unsigned char* iv;
print_block("Base sap: ", &sapIn[0xf0]);
z_xor(sapIn, sapOut, 16);
generate_key_schedule(sap_key_material, key_schedule);
print_block("lastSap before cycle: ", &sapOut[0xf0]);
for (int i = 0xf0; i >= 0x00; i-=0x10)
{
printf("Ready to cycle %02X\n", i);
cycle(&sapOut[i], key_schedule);
print_block("After cycling, block is: ", &sapOut[i]);
if (i > 0)
{ // xor with previous block
iv = &sapOut[i-0x10];
}
else
{ // xor with sap IV
iv = sap_iv;
}
for (int j = 0; j < 16; j++)
{
printf("%02X ^ %02X -> %02X\n", sapOut[i+j], iv[j], sapOut[i+j] ^ iv[j]);
sapOut[i+j] = sapOut[i+j] ^ iv[j];
}
printf("Decrypted SAP %02X-%02X:\n", i, i+0xf);
print_block("", &sapOut[i]);
}
// Lastly grind the whole thing through x_key. This is the last time we modify sap
x_xor(sapOut, sapOut, 16);
printf("Sap is decrypted to\n");
for (int i = 0xf0; i >= 0x00; i-=0x10)
{
printf("Final SAP %02X-%02X: ", i, i+0xf);
print_block("", &sapOut[i]);
}
}
