* Re: Qemu API documentation
2020-03-18 19:49 ` John Snow
@ 2020-03-19 14:16 ` Priyamvad Acharya
2020-03-19 14:39 ` Alex Bennée
0 siblings, 1 reply; 12+ messages in thread
From: Priyamvad Acharya @ 2020-03-19 14:16 UTC (permalink / raw)
To: John Snow; +Cc: Peter Maydell, qemu-devel
[-- Attachment #1.1: Type: text/plain, Size: 3319 bytes --]
Thanks John and Peter for guiding me, but still it will be hard to
understand from source code for a newbie.
I basically want to implement a trivial device for arm architecture which
basically contains register for read/write operation with a program.So what
are the references?
I am providing pointers about my device which I am trying to implement:
- I am implementing a device which will be attached to *versatilepb*
board, that board has* ARM926 CPU*.
- My device name is "*soc*" , whose description is in *qemu/hw/misc/soc.c*
file attached below.
- I have written below line to make my device available to qemu in
*qemu/hw/misc/Makefile.objs*.
> *$ common-obj-$(CONFIG_SOC) += soc.o *
>
- I added following lines in *qemu/hw/arm/versatilepb.c* to attach my
device to board.
>
> *#define DES_BASEADDR 0x101f5000*
>
>
>
> * soc=qdev_create(NULL, "soc");// + qdev_init_nofail(soc);// +
> sysbus_mmio_map(SYS_BUS_DEVICE(soc), 0, DES_BASEADDR);// +*
>
- Run below commands to build my device
> *$ make distclean*
> *$ make -j8 -C build *
>
- Run below command to run a bare metal program on device.
> *$ ./qemu-system-arm -M versatilepb -nographic -kernel
> /lhome/priyamvad/debian_qemu_arm32/c_application/DES/des_demo.elf*
>
-I get following output in terminal shown below
>
>
> *[priyamvad@predator arm-softmmu]$ ./qemu-system-arm -M versatilepb
> -nographic -kernel
> /lhome/priyamvad/debian_qemu_arm32/c_application/DES/des_demo.elf
> qemu-system-arm: Unknown device 'soc' for default sysbusAborted (core
> dumped)*
>
-Here des_demo.elf is our *bare metal program* executable for *arm(926ej-s)*
processor.
So how to resolve below issue to run executable
>
>
> *[priyamvad@predator arm-softmmu]$ ./qemu-system-arm -M versatilepb
> -nographic -kernel
> /lhome/priyamvad/debian_qemu_arm32/c_application/DES/des_demo.elf
> qemu-system-arm: Unknown device 'soc' for default sysbusAborted (core
> dumped)*
>
test.s,test.ld,startup.S,Makefile,des_demo.c are files required for bare
> metal program
>
References:
https://devkail.wordpress.com/2014/12/16/emulation-of-des-encryption-device-in-qemu/
Thanks,
Priyamvad
On Thu, 19 Mar 2020 at 01:19, John Snow <jsnow@redhat.com> wrote:
>
>
> On 3/18/20 7:09 AM, Peter Maydell wrote:
> > On Wed, 18 Mar 2020 at 09:55, Priyamvad Acharya
> > <priyamvad.agnisys@gmail.com> wrote:
> >>
> >> Hello developer community,
> >>
> >> I am working on implementing a custom device in Qemu, so to implement
> it I need documentation of functions which are used to emulate a hardware
> model in Qemu.
> >>
> >> What are the references to get it ?
> >
> > QEMU has very little documentation of its internals;
> > the usual practice is to figure things out by
> > reading the source code. What we do have is in
> > docs/devel. There are also often documentation comments
> > for specific functions in the include files where
> > those functions are declared, which form the API
> > documentation for them.
> >
>
> ^ Unfortunately true. One thing you can do is try to pick an existing
> device that's close to yours -- some donor PCI, USB etc device and start
> using that as a reference.
>
> If you can share (broad) details of what device you are trying to
> implement, we might be able to point you to relevant examples to use as
> a reference.
>
> --js
>
>
[-- Attachment #1.2: Type: text/html, Size: 5497 bytes --]
[-- Attachment #2: soc.c --]
[-- Type: text/x-csrc, Size: 23517 bytes --]
/*
* Data Encryption Standard (DES) device
* for virtex-ml507
* Written by Liang Kaiyuan <kaiyuanl@tju.edu.cn>
* for testing and research
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU GPLv2 as published by
* Free Software Foundation, or any later version. See the COPING
* file in the top-level directory.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "hw/hw.h"
#include "hw/sysbus.h"
#include "qemu/main-loop.h"
#include "qemu/osdep.h"
#include "qemu/units.h"
#include "hw/pci/msi.h"
#include "qemu/timer.h"
#include "qemu/module.h"
#include "qapi/visitor.h"
typedef struct {
unsigned char k[8];
unsigned char c[4];
unsigned char d[4];
} key_set;
void generate_key(unsigned char* key);
void generate_sub_keys(unsigned char* main_key, key_set* key_sets);
void process_message(unsigned char* message_piece, unsigned char* processed_piece, key_set* key_sets, int mode);
void print_char_as_binary(char input);
void print_key_set(key_set key_set);
int bread(unsigned char* block, int size, unsigned char* str, int *index);
int bwrite(unsigned char* block, int size, unsigned char* str, int *index);
int bstrlen(unsigned char* str);
#define ENCRYPTION_MODE 1
#define DECRYPTION_MODE 0
#define GENERATEKEY_MODE 2
#define DONE_MODE 3
#define REGS_OFFSET 0x1000
#define REG_KEY_ADDR_OFFSET 0x0000
#define REG_IN_ADDR_OFFSET 0x0004
#define REG_OUT_ADDR_OFFSET 0x0008
#define REG_MODE_OFFSET 0x000C
/*#define DES_DEBUG*/
typedef struct SoCDESState{
SysBusDevice parent_obj;
MemoryRegion mmio;
QEMUBH *bh;
qemu_irq irq;
uint32_t reg_key_addr;
uint32_t reg_in_addr;
uint32_t reg_out_addr;
uint32_t reg_mode;
}SoCDESState;
#define TYPE_SOC_DES "soc"
#define SOC_DES(obj) \
OBJECT_CHECK(SoCDESState, (obj), TYPE_SOC_DES)
static uint64_t soc_des_read(void *opaque, hwaddr offset, unsigned size)
{
#ifdef DES_DEBUG
printf("begin soc_des_read\n");
printf("offset 0x%x\t size 0x%x\n", (unsigned int)offset, size);
#endif
SoCDESState *s = opaque;
uint32_t ret = 0;
switch(offset)
{
case REG_KEY_ADDR_OFFSET:
ret = s->reg_key_addr;
break;
case REG_OUT_ADDR_OFFSET:
ret = s->reg_out_addr;
break;
case REG_MODE_OFFSET:
ret = s->reg_mode;
break;
default:
printf("bad offset 0x%x\n", (int)offset);
}
#ifdef DES_DEBUG
printf("offset 0x%x, value 0x%x\n", (int)offset, ret);
printf("finish soc_des_read\n");
#endif
return ret;
}
static void soc_des_write(void *opaque, hwaddr offset, uint64_t value, unsigned size)
{
#ifdef DES_DEBUG
printf("begin soc_des_write\n");
printf("offset 0x%x\t size 0x%x\n", (unsigned)offset, size);
printf("value x0%x\n", (unsigned)value);
#endif
SoCDESState *s = opaque;
switch(offset)
{
case REG_KEY_ADDR_OFFSET:
s->reg_key_addr = value;
break;
case REG_IN_ADDR_OFFSET:
s->reg_in_addr = value;
break;
case REG_OUT_ADDR_OFFSET:
s->reg_out_addr = value;
break;
case REG_MODE_OFFSET:
s->reg_mode = value;
unsigned char* des_key = (unsigned char*)malloc(8*sizeof(char));
unsigned char* data_block = NULL;
unsigned char* processed_block = NULL;
key_set* key_sets;
int index_key = 0;
int index_in = 0;
int index_out = 0;
char tz = '\0';
switch(s->reg_mode)
{
case GENERATEKEY_MODE:
generate_key(des_key);
bwrite(des_key, 8, (unsigned char*)s->reg_key_addr, &index_key);
bwrite(&tz, 1, (unsigned char*)s->reg_key_addr, &index_key);
s->reg_mode = DONE_MODE;
break;
case ENCRYPTION_MODE:
case DECRYPTION_MODE:
bread(des_key, 8, (unsigned char*)s->reg_key_addr, &index_key);
key_sets = (key_set*)malloc(17*sizeof(key_set));
generate_sub_keys(des_key, key_sets);
data_block = (unsigned char*)malloc(8*sizeof(char));
processed_block = (unsigned char*)malloc(8*sizeof(char));
int data_size = bstrlen((unsigned char*)s->reg_in_addr);
int number_of_blocks = data_size/8 + ((data_size%8)?1:0);
int block_count = 0;
unsigned short int padding;
while(bread(data_block, 8, (unsigned char*)s->reg_in_addr, &index_in))
{
block_count++;
if(block_count == number_of_blocks)
{
if(s->reg_mode == ENCRYPTION_MODE)
{
padding = 8 - data_size%8;
if(padding < 8)
{
memset((data_block + 8 - padding), (unsigned char)padding, padding);
}
process_message(data_block, processed_block, key_sets, s->reg_mode);
bwrite(processed_block, 8, (unsigned char*)s->reg_out_addr, &index_out);
if(padding == 8)
{
memset(data_block, (unsigned char)padding, 8);
process_message(data_block, processed_block, key_sets, s->reg_mode);
bwrite(processed_block, 8, (unsigned char*)s->reg_out_addr, &index_out);
}
}
else
{
process_message(data_block, processed_block, key_sets, s->reg_mode);
padding = processed_block[7];
if(padding < 8)
{
bwrite(processed_block, 8, (unsigned char*)s->reg_out_addr, &index_out);
}
}
}
else
{
process_message(data_block, processed_block, key_sets, s->reg_mode);
bwrite(processed_block, 8, (unsigned char*)s->reg_out_addr, &index_out);
}
memset(data_block, 0, 8);
}
free(key_sets);
free(data_block);
free(processed_block);
s->reg_mode = DONE_MODE;
break;
}
free(des_key);
break;
default:
printf("bad offset 0x%x\n", (int)offset);
}
#ifdef DES_DEBUG
printf("finish soc_des_write\n");
#endif
}
static const MemoryRegionOps soc_des_ops = {
.read = soc_des_read,
.write = soc_des_write,
.endianness = DEVICE_NATIVE_ENDIAN,
.valid = {
.min_access_size = 4,
.max_access_size = 4
}
};
static const VMStateDescription vmstate_soc_des = {
.name = "soc",
.version_id = 0,
.minimum_version_id = 0,
.fields = (VMStateField[]) {
VMSTATE_UINT32(reg_key_addr, SoCDESState),
VMSTATE_UINT32(reg_in_addr, SoCDESState),
VMSTATE_UINT32(reg_out_addr, SoCDESState),
VMSTATE_UINT32(reg_mode, SoCDESState),
VMSTATE_END_OF_LIST()
}
};
static int soc_des_init(SysBusDevice *dev)
{
#ifdef DES_DEBUG
printf("begin soc_des_init\n");
#endif
SoCDESState *d = SOC_DES(dev);
d->reg_key_addr = 0x0000;
d->reg_in_addr= 0x0000;
d->reg_out_addr = 0x0000;
d->reg_mode = 0x0000;
sysbus_init_irq(dev, &d->irq);
memory_region_init_io(&d->mmio, OBJECT(d), &soc_des_ops, d, TYPE_SOC_DES, REGS_OFFSET);
sysbus_init_mmio(dev, &d->mmio);
#ifdef DES_DEBUG
printf("finish soc_des_init\n");
#endif
return 0;
}
static void soc_des_class_init(ObjectClass *klass, void *data)
{
#ifdef DES_DEBUG
printf("begin soc_des_class_init\n");
#endif
DeviceClass *d = DEVICE_CLASS(klass);
SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass);
k->init = soc_des_init;
d->vmsd = &vmstate_soc_des;
#ifdef DES_DEBUG
printf("finish soc_des_class_init\n");
#endif
}
static const TypeInfo soc_des_info = {
.name = TYPE_SOC_DES,
.parent = TYPE_SYS_BUS_DEVICE,
.instance_size = sizeof(SoCDESState),
.class_init = soc_des_class_init,
};
static void soc_des_register_types(void)
{
#ifdef DES_DEBUG
printf("begin soc_des_register_types\n");
#endif
type_register_static(&soc_des_info);
#ifdef DES_DEBUG
printf("finish soc_des_register_types\n");
#endif
}
type_init(soc_des_register_types)
/*
* Functions related to DES algorithm
* Implemented by tarequeh
* https://github.com/tarequeh/DES
*/
int initial_key_permutaion[] = {57, 49, 41, 33, 25, 17, 9,
1, 58, 50, 42, 34, 26, 18,
10, 2, 59, 51, 43, 35, 27,
19, 11, 3, 60, 52, 44, 36,
63, 55, 47, 39, 31, 23, 15,
7, 62, 54, 46, 38, 30, 22,
14, 6, 61, 53, 45, 37, 29,
21, 13, 5, 28, 20, 12, 4};
int initial_message_permutation[] = {58, 50, 42, 34, 26, 18, 10, 2,
60, 52, 44, 36, 28, 20, 12, 4,
62, 54, 46, 38, 30, 22, 14, 6,
64, 56, 48, 40, 32, 24, 16, 8,
57, 49, 41, 33, 25, 17, 9, 1,
59, 51, 43, 35, 27, 19, 11, 3,
61, 53, 45, 37, 29, 21, 13, 5,
63, 55, 47, 39, 31, 23, 15, 7};
int key_shift_sizes[] = {-1, 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1};
int sub_key_permutation[] = {14, 17, 11, 24, 1, 5,
3, 28, 15, 6, 21, 10,
23, 19, 12, 4, 26, 8,
16, 7, 27, 20, 13, 2,
41, 52, 31, 37, 47, 55,
30, 40, 51, 45, 33, 48,
44, 49, 39, 56, 34, 53,
46, 42, 50, 36, 29, 32};
int message_expansion[] = {32, 1, 2, 3, 4, 5,
4, 5, 6, 7, 8, 9,
8, 9, 10, 11, 12, 13,
12, 13, 14, 15, 16, 17,
16, 17, 18, 19, 20, 21,
20, 21, 22, 23, 24, 25,
24, 25, 26, 27, 28, 29,
28, 29, 30, 31, 32, 1};
int S1[] = {14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7,
0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8,
4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0,
15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13};
int S2[] = {15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10,
3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5,
0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15,
13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9};
int S3[] = {10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8,
13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1,
13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7,
1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12};
int S4[] = { 7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15,
13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9,
10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4,
3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14};
int S5[] = { 2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9,
14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6,
4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14,
11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3};
int S6[] = {12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11,
10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8,
9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6,
4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13};
int S7[] = { 4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1,
13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6,
1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2,
6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12};
int S8[] = {13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7,
1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2,
7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8,
2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11};
int right_sub_message_permutation[] = {16, 7, 20, 21,
29, 12, 28, 17,
1, 15, 23, 26,
5, 18, 31, 10,
2, 8, 24, 14,
32, 27, 3, 9,
19, 13, 30, 6,
22, 11, 4, 25};
int final_message_permutation[] = {40, 8, 48, 16, 56, 24, 64, 32,
39, 7, 47, 15, 55, 23, 63, 31,
38, 6, 46, 14, 54, 22, 62, 30,
37, 5, 45, 13, 53, 21, 61, 29,
36, 4, 44, 12, 52, 20, 60, 28,
35, 3, 43, 11, 51, 19, 59, 27,
34, 2, 42, 10, 50, 18, 58, 26,
33, 1, 41, 9, 49, 17, 57, 25};
void print_char_as_binary(char input) {
int i;
for (i=0; i<8; i++) {
char shift_byte = 0x01 << (7-i);
if (shift_byte & input) {
printf("1");
} else {
printf("0");
}
}
}
int bread(unsigned char* block, int size, unsigned char* str, int* index)
{
int i;
char c;
for(i = 0; i < size; i++)
{
cpu_physical_memory_read(str + *index + i, &c, 1);
if(!c)
break;
block[i] = c;
}
*index += i;
return i;
}
int bwrite(unsigned char* block, int size, unsigned char* str, int* index)
{
int i;
char c;
for(i = 0; i < size; i++)
{
c = block[i];
cpu_physical_memory_write(str + *index + i, &c, 1);
}
*index += i;
return i;
}
int bstrlen(unsigned char* str)
{
int i;
char c;
for(i = 0; ; i++)
{
cpu_physical_memory_read(str + i, &c, 1);
if(!c)
break;
}
return i;
}
void generate_key(unsigned char* key) {
int i;
for (i=0; i<8; i++) {
key[i] = rand()%255;
}
}
void print_key_set(key_set key_set){
int i;
printf("K: \n");
for (i=0; i<8; i++) {
printf("%02X : ", key_set.k[i]);
print_char_as_binary(key_set.k[i]);
printf("\n");
}
printf("\nC: \n");
for (i=0; i<4; i++) {
printf("%02X : ", key_set.c[i]);
print_char_as_binary(key_set.c[i]);
printf("\n");
}
printf("\nD: \n");
for (i=0; i<4; i++) {
printf("%02X : ", key_set.d[i]);
print_char_as_binary(key_set.d[i]);
printf("\n");
}
printf("\n");
}
void generate_sub_keys(unsigned char* main_key, key_set* key_sets) {
int i, j;
int shift_size;
unsigned char shift_byte, first_shift_bits, second_shift_bits, third_shift_bits, fourth_shift_bits;
for (i=0; i<8; i++) {
key_sets[0].k[i] = 0;
}
for (i=0; i<56; i++) {
shift_size = initial_key_permutaion[i];
shift_byte = 0x80 >> ((shift_size - 1)%8);
shift_byte &= main_key[(shift_size - 1)/8];
shift_byte <<= ((shift_size - 1)%8);
key_sets[0].k[i/8] |= (shift_byte >> i%8);
}
for (i=0; i<3; i++) {
key_sets[0].c[i] = key_sets[0].k[i];
}
key_sets[0].c[3] = key_sets[0].k[3] & 0xF0;
for (i=0; i<3; i++) {
key_sets[0].d[i] = (key_sets[0].k[i+3] & 0x0F) << 4;
key_sets[0].d[i] |= (key_sets[0].k[i+4] & 0xF0) >> 4;
}
key_sets[0].d[3] = (key_sets[0].k[6] & 0x0F) << 4;
for (i=1; i<17; i++) {
for (j=0; j<4; j++) {
key_sets[i].c[j] = key_sets[i-1].c[j];
key_sets[i].d[j] = key_sets[i-1].d[j];
}
shift_size = key_shift_sizes[i];
if (shift_size == 1){
shift_byte = 0x80;
} else {
shift_byte = 0xC0;
}
// Process C
first_shift_bits = shift_byte & key_sets[i].c[0];
second_shift_bits = shift_byte & key_sets[i].c[1];
third_shift_bits = shift_byte & key_sets[i].c[2];
fourth_shift_bits = shift_byte & key_sets[i].c[3];
key_sets[i].c[0] <<= shift_size;
key_sets[i].c[0] |= (second_shift_bits >> (8 - shift_size));
key_sets[i].c[1] <<= shift_size;
key_sets[i].c[1] |= (third_shift_bits >> (8 - shift_size));
key_sets[i].c[2] <<= shift_size;
key_sets[i].c[2] |= (fourth_shift_bits >> (8 - shift_size));
key_sets[i].c[3] <<= shift_size;
key_sets[i].c[3] |= (first_shift_bits >> (4 - shift_size));
// Process D
first_shift_bits = shift_byte & key_sets[i].d[0];
second_shift_bits = shift_byte & key_sets[i].d[1];
third_shift_bits = shift_byte & key_sets[i].d[2];
fourth_shift_bits = shift_byte & key_sets[i].d[3];
key_sets[i].d[0] <<= shift_size;
key_sets[i].d[0] |= (second_shift_bits >> (8 - shift_size));
key_sets[i].d[1] <<= shift_size;
key_sets[i].d[1] |= (third_shift_bits >> (8 - shift_size));
key_sets[i].d[2] <<= shift_size;
key_sets[i].d[2] |= (fourth_shift_bits >> (8 - shift_size));
key_sets[i].d[3] <<= shift_size;
key_sets[i].d[3] |= (first_shift_bits >> (4 - shift_size));
for (j=0; j<48; j++) {
shift_size = sub_key_permutation[j];
if (shift_size <= 28) {
shift_byte = 0x80 >> ((shift_size - 1)%8);
shift_byte &= key_sets[i].c[(shift_size - 1)/8];
shift_byte <<= ((shift_size - 1)%8);
} else {
shift_byte = 0x80 >> ((shift_size - 29)%8);
shift_byte &= key_sets[i].d[(shift_size - 29)/8];
shift_byte <<= ((shift_size - 29)%8);
}
key_sets[i].k[j/8] |= (shift_byte >> j%8);
}
}
}
void process_message(unsigned char* message_piece, unsigned char* processed_piece, key_set* key_sets, int mode) {
int i, k;
int shift_size;
unsigned char shift_byte;
unsigned char initial_permutation[8];
memset(initial_permutation, 0, 8);
memset(processed_piece, 0, 8);
for (i=0; i<64; i++) {
shift_size = initial_message_permutation[i];
shift_byte = 0x80 >> ((shift_size - 1)%8);
shift_byte &= message_piece[(shift_size - 1)/8];
shift_byte <<= ((shift_size - 1)%8);
initial_permutation[i/8] |= (shift_byte >> i%8);
}
unsigned char l[4], r[4];
for (i=0; i<4; i++) {
l[i] = initial_permutation[i];
r[i] = initial_permutation[i+4];
}
unsigned char ln[4], rn[4], er[6], ser[4];
int key_index;
for (k=1; k<=16; k++) {
memcpy(ln, r, 4);
memset(er, 0, 6);
for (i=0; i<48; i++) {
shift_size = message_expansion[i];
shift_byte = 0x80 >> ((shift_size - 1)%8);
shift_byte &= r[(shift_size - 1)/8];
shift_byte <<= ((shift_size - 1)%8);
er[i/8] |= (shift_byte >> i%8);
}
if (mode == DECRYPTION_MODE) {
key_index = 17 - k;
} else {
key_index = k;
}
for (i=0; i<6; i++) {
er[i] ^= key_sets[key_index].k[i];
}
unsigned char row, column;
for (i=0; i<4; i++) {
ser[i] = 0;
}
// 0000 0000 0000 0000 0000 0000
// rccc crrc cccr rccc crrc cccr
// Byte 1
row = 0;
row |= ((er[0] & 0x80) >> 6);
row |= ((er[0] & 0x04) >> 2);
column = 0;
column |= ((er[0] & 0x78) >> 3);
ser[0] |= ((unsigned char)S1[row*16+column] << 4);
row = 0;
row |= (er[0] & 0x02);
row |= ((er[1] & 0x10) >> 4);
column = 0;
column |= ((er[0] & 0x01) << 3);
column |= ((er[1] & 0xE0) >> 5);
ser[0] |= (unsigned char)S2[row*16+column];
// Byte 2
row = 0;
row |= ((er[1] & 0x08) >> 2);
row |= ((er[2] & 0x40) >> 6);
column = 0;
column |= ((er[1] & 0x07) << 1);
column |= ((er[2] & 0x80) >> 7);
ser[1] |= ((unsigned char)S3[row*16+column] << 4);
row = 0;
row |= ((er[2] & 0x20) >> 4);
row |= (er[2] & 0x01);
column = 0;
column |= ((er[2] & 0x1E) >> 1);
ser[1] |= (unsigned char)S4[row*16+column];
// Byte 3
row = 0;
row |= ((er[3] & 0x80) >> 6);
row |= ((er[3] & 0x04) >> 2);
column = 0;
column |= ((er[3] & 0x78) >> 3);
ser[2] |= ((unsigned char)S5[row*16+column] << 4);
row = 0;
row |= (er[3] & 0x02);
row |= ((er[4] & 0x10) >> 4);
column = 0;
column |= ((er[3] & 0x01) << 3);
column |= ((er[4] & 0xE0) >> 5);
ser[2] |= (unsigned char)S6[row*16+column];
// Byte 4
row = 0;
row |= ((er[4] & 0x08) >> 2);
row |= ((er[5] & 0x40) >> 6);
column = 0;
column |= ((er[4] & 0x07) << 1);
column |= ((er[5] & 0x80) >> 7);
ser[3] |= ((unsigned char)S7[row*16+column] << 4);
row = 0;
row |= ((er[5] & 0x20) >> 4);
row |= (er[5] & 0x01);
column = 0;
column |= ((er[5] & 0x1E) >> 1);
ser[3] |= (unsigned char)S8[row*16+column];
for (i=0; i<4; i++) {
rn[i] = 0;
}
for (i=0; i<32; i++) {
shift_size = right_sub_message_permutation[i];
shift_byte = 0x80 >> ((shift_size - 1)%8);
shift_byte &= ser[(shift_size - 1)/8];
shift_byte <<= ((shift_size - 1)%8);
rn[i/8] |= (shift_byte >> i%8);
}
for (i=0; i<4; i++) {
rn[i] ^= l[i];
}
for (i=0; i<4; i++) {
l[i] = ln[i];
r[i] = rn[i];
}
}
unsigned char pre_end_permutation[8];
for (i=0; i<4; i++) {
pre_end_permutation[i] = r[i];
pre_end_permutation[4+i] = l[i];
}
for (i=0; i<64; i++) {
shift_size = final_message_permutation[i];
shift_byte = 0x80 >> ((shift_size - 1)%8);
shift_byte &= pre_end_permutation[(shift_size - 1)/8];
shift_byte <<= ((shift_size - 1)%8);
processed_piece[i/8] |= (shift_byte >> i%8);
}
}
[-- Attachment #3: test.s --]
[-- Type: application/octet-stream, Size: 11047 bytes --]
.cpu arm7tdmi
.eabi_attribute 20, 1
.eabi_attribute 21, 1
.eabi_attribute 23, 3
.eabi_attribute 24, 1
.eabi_attribute 25, 1
.eabi_attribute 26, 1
.eabi_attribute 30, 6
.eabi_attribute 34, 0
.eabi_attribute 18, 4
.file "des_demo.c"
.text
.Ltext0:
.cfi_sections .debug_frame
.global UART0DR
.section .rodata
.align 2
.type UART0DR, %object
.size UART0DR, 4
UART0DR:
.word 270471168
.text
.align 2
.global print_uart0
.arch armv4t
.syntax unified
.arm
.fpu softvfp
.type print_uart0, %function
print_uart0:
.LFB0:
.file 1 "des_demo.c"
.loc 1 20 1
.cfi_startproc
@ Function supports interworking.
@ args = 0, pretend = 0, frame = 8
@ frame_needed = 1, uses_anonymous_args = 0
@ link register save eliminated.
str fp, [sp, #-4]!
.cfi_def_cfa_offset 4
.cfi_offset 11, -4
add fp, sp, #0
.cfi_def_cfa_register 11
sub sp, sp, #12
str r0, [fp, #-8]
.loc 1 21 10
b .L2
.L3:
.loc 1 23 35
ldr r3, [fp, #-8]
ldrb r3, [r3]
and r2, r3, #255
.loc 1 23 9
ldr r3, .L4
.loc 1 23 18
str r2, [r3]
.loc 1 24 10
ldr r3, [fp, #-8]
add r3, r3, #1
str r3, [fp, #-8]
.L2:
.loc 1 21 11
ldr r3, [fp, #-8]
ldrb r3, [r3]
and r3, r3, #255
.loc 1 21 10
cmp r3, #0
bne .L3
.loc 1 26 1
nop
nop
add sp, fp, #0
.cfi_def_cfa_register 13
@ sp needed
ldr fp, [sp], #4
.cfi_restore 11
.cfi_def_cfa_offset 0
bx lr
.L5:
.align 2
.L4:
.word 270471168
.cfi_endproc
.LFE0:
.size print_uart0, .-print_uart0
.section .rodata
.align 2
.LC0:
.ascii "hello, world\000"
.align 2
.LC1:
.ascii "hello, des\012\000"
.align 2
.LC2:
.ascii "plain text is \000"
.align 2
.LC3:
.ascii "\012\000"
.align 2
.LC4:
.ascii "start generating key\012\000"
.align 2
.LC5:
.ascii "key is \000"
.align 2
.LC6:
.ascii "start encrypting\012\000"
.align 2
.LC7:
.ascii "cipher text is \000"
.align 2
.LC8:
.ascii "start decryption\012\000"
.align 2
.LC9:
.ascii "decrypted text is \000"
.text
.align 2
.global main
.syntax unified
.arm
.fpu softvfp
.type main, %function
main:
.LFB1:
.loc 1 29 1
.cfi_startproc
@ Function supports interworking.
@ args = 0, pretend = 0, frame = 240
@ frame_needed = 1, uses_anonymous_args = 0
push {fp, lr}
.cfi_def_cfa_offset 8
.cfi_offset 11, -8
.cfi_offset 14, -4
add fp, sp, #4
.cfi_def_cfa 11, 4
sub sp, sp, #240
.loc 1 30 28
ldr r3, .L10
str r3, [fp, #-8]
.loc 1 31 28
ldr r3, .L10+4
str r3, [fp, #-12]
.loc 1 32 28
ldr r3, .L10+8
str r3, [fp, #-16]
.loc 1 33 28
ldr r3, .L10+12
str r3, [fp, #-20]
.loc 1 36 20
ldr r3, .L10+16
str r3, [fp, #-24]
.loc 1 41 5
ldr r0, .L10+20
bl print_uart0
.loc 1 42 5
ldr r0, .L10+24
bl print_uart0
.loc 1 43 5
ldr r0, [fp, #-24]
bl print_uart0
.loc 1 44 5
ldr r0, .L10+28
bl print_uart0
.loc 1 48 5
ldr r0, .L10+32
bl print_uart0
.loc 1 49 19
sub r2, fp, #40
ldr r3, [fp, #-8]
str r2, [r3]
.loc 1 50 15
ldr r3, [fp, #-20]
mov r2, #2
str r2, [r3]
.loc 1 51 10
nop
.L7:
.loc 1 51 11 discriminator 1
ldr r3, [fp, #-20]
ldr r3, [r3]
.loc 1 51 10 discriminator 1
cmp r3, #3
bne .L7
.loc 1 52 29
ldr r3, [fp, #-8]
ldr r3, [r3]
.loc 1 52 10
str r3, [fp, #-28]
.loc 1 53 5
ldr r0, .L10+36
bl print_uart0
.loc 1 54 5
ldr r0, [fp, #-28]
bl print_uart0
.loc 1 55 5
ldr r0, .L10+28
bl print_uart0
.loc 1 58 5
ldr r0, .L10+40
bl print_uart0
.loc 1 59 18
ldr r2, [fp, #-24]
ldr r3, [fp, #-12]
str r2, [r3]
.loc 1 60 19
sub r2, fp, #140
ldr r3, [fp, #-16]
str r2, [r3]
.loc 1 61 15
ldr r3, [fp, #-20]
mov r2, #1
str r2, [r3]
.loc 1 62 10
nop
.L8:
.loc 1 62 11 discriminator 1
ldr r3, [fp, #-20]
ldr r3, [r3]
.loc 1 62 10 discriminator 1
cmp r3, #3
bne .L8
.loc 1 63 29
ldr r3, [fp, #-16]
ldr r3, [r3]
.loc 1 63 10
str r3, [fp, #-28]
.loc 1 64 5
ldr r0, .L10+44
bl print_uart0
.loc 1 65 5
ldr r0, [fp, #-28]
bl print_uart0
.loc 1 66 5
ldr r0, .L10+28
bl print_uart0
.loc 1 69 5
ldr r0, .L10+48
bl print_uart0
.loc 1 70 18
sub r2, fp, #140
ldr r3, [fp, #-12]
str r2, [r3]
.loc 1 71 19
sub r2, fp, #240
ldr r3, [fp, #-16]
str r2, [r3]
.loc 1 72 15
ldr r3, [fp, #-20]
mov r2, #0
str r2, [r3]
.loc 1 73 10
nop
.L9:
.loc 1 73 11 discriminator 1
ldr r3, [fp, #-20]
ldr r3, [r3]
.loc 1 73 10 discriminator 1
cmp r3, #3
bne .L9
.loc 1 74 29
ldr r3, [fp, #-16]
ldr r3, [r3]
.loc 1 74 10
str r3, [fp, #-28]
.loc 1 75 5
ldr r0, .L10+52
bl print_uart0
.loc 1 76 5
ldr r0, [fp, #-28]
bl print_uart0
.loc 1 77 5
ldr r0, .L10+28
bl print_uart0
.loc 1 78 1
nop
sub sp, fp, #4
.cfi_def_cfa 13, 8
@ sp needed
pop {fp, lr}
.cfi_restore 14
.cfi_restore 11
.cfi_def_cfa_offset 0
bx lr
.L11:
.align 2
.L10:
.word 270487552
.word 270487556
.word 270487560
.word 270487564
.word .LC0
.word .LC1
.word .LC2
.word .LC3
.word .LC4
.word .LC5
.word .LC6
.word .LC7
.word .LC8
.word .LC9
.cfi_endproc
.LFE1:
.size main, .-main
.Letext0:
.section .debug_info,"",%progbits
.Ldebug_info0:
.4byte 0x14e
.2byte 0x4
.4byte .Ldebug_abbrev0
.byte 0x4
.uleb128 0x1
.4byte .LASF11
.byte 0xc
.4byte .LASF12
.4byte .LASF13
.4byte .Ltext0
.4byte .Letext0-.Ltext0
.4byte .Ldebug_line0
.uleb128 0x2
.4byte .LASF14
.byte 0x1
.byte 0x11
.byte 0x1f
.4byte 0x3d
.uleb128 0x5
.byte 0x3
.4byte UART0DR
.uleb128 0x3
.byte 0x4
.4byte 0x49
.uleb128 0x4
.4byte 0x37
.uleb128 0x5
.byte 0x4
.byte 0x7
.4byte .LASF8
.uleb128 0x6
.4byte 0x42
.uleb128 0x7
.4byte .LASF15
.byte 0x1
.byte 0x1c
.byte 0x6
.4byte .LFB1
.4byte .LFE1-.LFB1
.uleb128 0x1
.byte 0x9c
.4byte 0xee
.uleb128 0x8
.4byte .LASF0
.byte 0x1
.byte 0x1e
.byte 0x1c
.4byte 0x37
.uleb128 0x2
.byte 0x91
.sleb128 -12
.uleb128 0x8
.4byte .LASF1
.byte 0x1
.byte 0x1f
.byte 0x1c
.4byte 0x37
.uleb128 0x2
.byte 0x91
.sleb128 -16
.uleb128 0x8
.4byte .LASF2
.byte 0x1
.byte 0x20
.byte 0x1c
.4byte 0x37
.uleb128 0x2
.byte 0x91
.sleb128 -20
.uleb128 0x8
.4byte .LASF3
.byte 0x1
.byte 0x21
.byte 0x1c
.4byte 0x37
.uleb128 0x2
.byte 0x91
.sleb128 -24
.uleb128 0x9
.ascii "key\000"
.byte 0x1
.byte 0x23
.byte 0x13
.4byte 0xee
.uleb128 0x2
.byte 0x91
.sleb128 -44
.uleb128 0x8
.4byte .LASF4
.byte 0x1
.byte 0x24
.byte 0x14
.4byte 0x105
.uleb128 0x2
.byte 0x91
.sleb128 -28
.uleb128 0x8
.4byte .LASF5
.byte 0x1
.byte 0x25
.byte 0x13
.4byte 0x10b
.uleb128 0x3
.byte 0x91
.sleb128 -144
.uleb128 0x8
.4byte .LASF6
.byte 0x1
.byte 0x26
.byte 0x13
.4byte 0x10b
.uleb128 0x3
.byte 0x91
.sleb128 -244
.uleb128 0x8
.4byte .LASF7
.byte 0x1
.byte 0x27
.byte 0x14
.4byte 0x105
.uleb128 0x2
.byte 0x91
.sleb128 -32
.byte 0
.uleb128 0xa
.4byte 0xfe
.4byte 0xfe
.uleb128 0xb
.4byte 0x42
.byte 0x8
.byte 0
.uleb128 0x5
.byte 0x1
.byte 0x8
.4byte .LASF9
.uleb128 0x3
.byte 0x4
.4byte 0xfe
.uleb128 0xa
.4byte 0xfe
.4byte 0x11b
.uleb128 0xb
.4byte 0x42
.byte 0x63
.byte 0
.uleb128 0xc
.4byte .LASF16
.byte 0x1
.byte 0x13
.byte 0x6
.4byte .LFB0
.4byte .LFE0-.LFB0
.uleb128 0x1
.byte 0x9c
.4byte 0x13f
.uleb128 0xd
.ascii "s\000"
.byte 0x1
.byte 0x13
.byte 0x21
.4byte 0x13f
.uleb128 0x2
.byte 0x91
.sleb128 -12
.byte 0
.uleb128 0x3
.byte 0x4
.4byte 0x14c
.uleb128 0x5
.byte 0x1
.byte 0x8
.4byte .LASF10
.uleb128 0x6
.4byte 0x145
.byte 0
.section .debug_abbrev,"",%progbits
.Ldebug_abbrev0:
.uleb128 0x1
.uleb128 0x11
.byte 0x1
.uleb128 0x25
.uleb128 0xe
.uleb128 0x13
.uleb128 0xb
.uleb128 0x3
.uleb128 0xe
.uleb128 0x1b
.uleb128 0xe
.uleb128 0x11
.uleb128 0x1
.uleb128 0x12
.uleb128 0x6
.uleb128 0x10
.uleb128 0x17
.byte 0
.byte 0
.uleb128 0x2
.uleb128 0x34
.byte 0
.uleb128 0x3
.uleb128 0xe
.uleb128 0x3a
.uleb128 0xb
.uleb128 0x3b
.uleb128 0xb
.uleb128 0x39
.uleb128 0xb
.uleb128 0x49
.uleb128 0x13
.uleb128 0x3f
.uleb128 0x19
.uleb128 0x2
.uleb128 0x18
.byte 0
.byte 0
.uleb128 0x3
.uleb128 0xf
.byte 0
.uleb128 0xb
.uleb128 0xb
.uleb128 0x49
.uleb128 0x13
.byte 0
.byte 0
.uleb128 0x4
.uleb128 0x26
.byte 0
.uleb128 0x49
.uleb128 0x13
.byte 0
.byte 0
.uleb128 0x5
.uleb128 0x24
.byte 0
.uleb128 0xb
.uleb128 0xb
.uleb128 0x3e
.uleb128 0xb
.uleb128 0x3
.uleb128 0xe
.byte 0
.byte 0
.uleb128 0x6
.uleb128 0x35
.byte 0
.uleb128 0x49
.uleb128 0x13
.byte 0
.byte 0
.uleb128 0x7
.uleb128 0x2e
.byte 0x1
.uleb128 0x3f
.uleb128 0x19
.uleb128 0x3
.uleb128 0xe
.uleb128 0x3a
.uleb128 0xb
.uleb128 0x3b
.uleb128 0xb
.uleb128 0x39
.uleb128 0xb
.uleb128 0x11
.uleb128 0x1
.uleb128 0x12
.uleb128 0x6
.uleb128 0x40
.uleb128 0x18
.uleb128 0x2116
.uleb128 0x19
.uleb128 0x1
.uleb128 0x13
.byte 0
.byte 0
.uleb128 0x8
.uleb128 0x34
.byte 0
.uleb128 0x3
.uleb128 0xe
.uleb128 0x3a
.uleb128 0xb
.uleb128 0x3b
.uleb128 0xb
.uleb128 0x39
.uleb128 0xb
.uleb128 0x49
.uleb128 0x13
.uleb128 0x2
.uleb128 0x18
.byte 0
.byte 0
.uleb128 0x9
.uleb128 0x34
.byte 0
.uleb128 0x3
.uleb128 0x8
.uleb128 0x3a
.uleb128 0xb
.uleb128 0x3b
.uleb128 0xb
.uleb128 0x39
.uleb128 0xb
.uleb128 0x49
.uleb128 0x13
.uleb128 0x2
.uleb128 0x18
.byte 0
.byte 0
.uleb128 0xa
.uleb128 0x1
.byte 0x1
.uleb128 0x49
.uleb128 0x13
.uleb128 0x1
.uleb128 0x13
.byte 0
.byte 0
.uleb128 0xb
.uleb128 0x21
.byte 0
.uleb128 0x49
.uleb128 0x13
.uleb128 0x2f
.uleb128 0xb
.byte 0
.byte 0
.uleb128 0xc
.uleb128 0x2e
.byte 0x1
.uleb128 0x3f
.uleb128 0x19
.uleb128 0x3
.uleb128 0xe
.uleb128 0x3a
.uleb128 0xb
.uleb128 0x3b
.uleb128 0xb
.uleb128 0x39
.uleb128 0xb
.uleb128 0x27
.uleb128 0x19
.uleb128 0x11
.uleb128 0x1
.uleb128 0x12
.uleb128 0x6
.uleb128 0x40
.uleb128 0x18
.uleb128 0x2117
.uleb128 0x19
.uleb128 0x1
.uleb128 0x13
.byte 0
.byte 0
.uleb128 0xd
.uleb128 0x5
.byte 0
.uleb128 0x3
.uleb128 0x8
.uleb128 0x3a
.uleb128 0xb
.uleb128 0x3b
.uleb128 0xb
.uleb128 0x39
.uleb128 0xb
.uleb128 0x49
.uleb128 0x13
.uleb128 0x2
.uleb128 0x18
.byte 0
.byte 0
.byte 0
.section .debug_aranges,"",%progbits
.4byte 0x1c
.2byte 0x2
.4byte .Ldebug_info0
.byte 0x4
.byte 0
.2byte 0
.2byte 0
.4byte .Ltext0
.4byte .Letext0-.Ltext0
.4byte 0
.4byte 0
.section .debug_line,"",%progbits
.Ldebug_line0:
.section .debug_str,"MS",%progbits,1
.LASF3:
.ascii "reg_mode\000"
.LASF8:
.ascii "unsigned int\000"
.LASF2:
.ascii "reg_out_addr\000"
.LASF13:
.ascii "/lhome/priyamvad/debian_qemu_arm32/c_application/DE"
.ascii "S\000"
.LASF1:
.ascii "reg_in_addr\000"
.LASF9:
.ascii "unsigned char\000"
.LASF7:
.ascii "pstr\000"
.LASF15:
.ascii "main\000"
.LASF4:
.ascii "plain\000"
.LASF0:
.ascii "reg_key_addr\000"
.LASF11:
.ascii "GNU C17 9.2.1 20191025 (release) [ARM/arm-9-branch "
.ascii "revision 277599] -mcpu=arm7tdmi -mfloat-abi=soft -m"
.ascii "arm -march=armv4t -g\000"
.LASF6:
.ascii "decrypted\000"
.LASF12:
.ascii "des_demo.c\000"
.LASF10:
.ascii "char\000"
.LASF14:
.ascii "UART0DR\000"
.LASF5:
.ascii "cipher\000"
.LASF16:
.ascii "print_uart0\000"
.ident "GCC: (GNU Tools for Arm Embedded Processors 9-2019-q4-major) 9.2.1 20191025 (release) [ARM/arm-9-branch revision 277599]"
[-- Attachment #4: Makefile --]
[-- Type: application/octet-stream, Size: 681 bytes --]
#PREFIX=powerpc-elf
PREFIX=arm-none-eabi
#PREFIX=arm-none-linux-gnueabi
#export LD_LIBRARY_PATH=/home/sunmingze/ppc/ppc_toolchain/lib
#export LD_LIBRARY_PATH=/home/sunmingze/ppc/ppc_toolchain_linux/lib
CC=$(PREFIX)-gcc
AS=$(PREFIX)-as
LD=$(PREFIX)-ld
OBJCOPY=$(PREFIX)-objcopy
OPT=-nostdlib
LD_SCRIPT=test.ld
obj = startup.o test.o
test:$(obj)
$(LD) -T $(LD_SCRIPT) $(obj) -o des_demo.elf
$(OBJCOPY) -O binary des_demo.elf des_demo.bin
startup.o:startup.S
$(AS) -g startup.S -o startup.o -mcpu=arm926ej-s
test.o:test.s
$(AS) -g test.s -o test.o -mcpu=arm926ej-s
test.s:des_demo.c
$(CC) -S -static -nostdlib -g des_demo.c -o test.s
clean:
rm -f *.o *.elf *.bin *.s
[-- Attachment #5: startup.S --]
[-- Type: application/octet-stream, Size: 47 bytes --]
.global _Reset
_Reset:
BL main
.L4:
;b .L4
[-- Attachment #6: test.ld --]
[-- Type: application/octet-stream, Size: 197 bytes --]
ENTRY(_Reset)
SECTIONS
{
. = 0x000;
.startup . : { startup.o(.text) }
.text : { *(.text) }
.data : { *(.data) }
.bss : { *(.bss) }
. = . + 0x1000; /* 4kB of stack memory */
stack_top = .;
}
[-- Attachment #7: des_demo.c --]
[-- Type: text/x-csrc, Size: 2230 bytes --]
/*
* This is a demo program to verify the function of DES device
*/
#define UART0_BASEADDR 0x101f1000
#define DES_BASEADDR 0x101f5000
#define ENCRYPTION_MODE 1
#define DECRYPTION_MODE 0
#define GENERATEKEY_MODE 2
#define DONE_MODE 3
#define REG_KEY_ADDR_OFFSET 0x0000
#define REG_IN_ADDR_OFFSET 0x0004
#define REG_OUT_ADDR_OFFSET 0x0008
#define REG_MODE_OFFSET 0x000C
#define OUT_SIZE_MAX 100
volatile unsigned int * const UART0DR = (unsigned int *) UART0_BASEADDR;
void print_uart0(volatile char *s)
{
while(*s != '\0')
{
*UART0DR = (unsigned int)(*s);
s++;
}
}
void main()
{
volatile unsigned int* reg_key_addr = (volatile unsigned int*)(DES_BASEADDR + REG_KEY_ADDR_OFFSET);
volatile unsigned int* reg_in_addr = (volatile unsigned int*)(DES_BASEADDR + REG_IN_ADDR_OFFSET);
volatile unsigned int* reg_out_addr = (volatile unsigned int*)(DES_BASEADDR + REG_OUT_ADDR_OFFSET);
volatile unsigned int* reg_mode = (volatile unsigned int*)(DES_BASEADDR + REG_MODE_OFFSET);
unsigned char key[9];
unsigned char* plain = "hello, world";
unsigned char cipher[OUT_SIZE_MAX];
unsigned char decrypted[OUT_SIZE_MAX];
unsigned char* pstr;
print_uart0("hello, des\n");
print_uart0("plain text is ");
print_uart0(plain);
print_uart0("\n");
/*Generate key*/
print_uart0("start generating key\n");
*reg_key_addr = key;
*reg_mode = GENERATEKEY_MODE;
while(*reg_mode != DONE_MODE ) {}
pstr = (unsigned char*)(*reg_key_addr);
print_uart0("key is ");
print_uart0(pstr);
print_uart0("\n");
/*Encryption*/
print_uart0("start encrypting\n");
*reg_in_addr = plain;
*reg_out_addr = cipher;
*reg_mode = ENCRYPTION_MODE;
while(*reg_mode != DONE_MODE) {}
pstr = (unsigned char*)(*reg_out_addr);
print_uart0("cipher text is ");
print_uart0(pstr);
print_uart0("\n");
/*Decryption*/
print_uart0("start decryption\n");
*reg_in_addr = cipher;
*reg_out_addr = decrypted;
*reg_mode = DECRYPTION_MODE;
while(*reg_mode != DONE_MODE) {}
pstr = (unsigned char*)(*reg_out_addr);
print_uart0("decrypted text is ");
print_uart0(pstr);
print_uart0("\n");
}
^ permalink raw reply [flat|nested] 12+ messages in thread