/* * Autodetect onboard DDR SDRAM on 440 platforms * * NOTE: Some of the hardcoded values are hardware dependant, * so this should be extended for other future boards * using this routine! */ long int initdram(int board_type) { int i; int tr1_bank1; for (i=0; i<N_MB0CF; i++) { /* * Disable memory controller. */ mtsdram(mem_cfg0, 0x00000000); /* * Setup some default */ mtsdram(mem_uabba, 0x00000000); /* ubba=0 (default) */ mtsdram(mem_slio, 0x00000000); /* rdre=0 wrre=0 rarw=0 */ mtsdram(mem_devopt, 0x00000000); /* dll=0 ds=0 (normal) */ mtsdram(mem_wddctr, 0x00000000); /* wrcp=0 dcd=0 */ mtsdram(mem_clktr, 0x40000000); /* clkp=1 (90 deg wr) dcdt=0 */ /* * Following for CAS Latency = 2.5 @ 133 MHz PLB */ mtsdram(mem_b0cr, mb0cf[i].reg); mtsdram(mem_tr0, 0x41094012); mtsdram(mem_tr1, 0x80800800); /* SS=T2 SL=STAGE 3 CD=1 CT=0x00*/ mtsdram(mem_rtr, 0x7e000000); /* Interval 15.20µs @ 133MHz PLB*/ mtsdram(mem_cfg1, 0x00000000); /* Self-refresh exit, disable PM*/ udelay(400); /* Delay 200 usecs (min) */ /* * Enable the controller, then wait for DCEN to complete */ mtsdram(mem_cfg0, 0x86000000); /* DCEN=1, PMUD=1, 64-bit */ udelay(10000); if (get_ram_size(0, mb0cf[i].size) == mb0cf[i].size) { /* * Optimize TR1 to current hardware environment */ sdram_tr1_set(0x00000000, &tr1_bank1); mtsdram(mem_tr1, (tr1_bank1 | 0x80800800)); #ifdef CONFIG_SDRAM_ECC ecc_init(0, mb0cf[i].size); #endif /* * OK, size detected -> all done */ return mb0cf[i].size; } } return 0; /* nothing found ! */ }
/**@brief Function for the Peer Manager initialization. * * @param[in] erase_bonds Indicates whether bonding information should be cleared from * persistent storage during initialization of the Peer Manager. */ static void peer_manager_init(bool erase_bonds) { ble_gap_sec_params_t sec_params; ret_code_t err_code; err_code = pm_init(); APP_ERROR_CHECK(err_code); if (erase_bonds) { (void) pm_peers_delete(); } memset(&sec_params, 0, sizeof(ble_gap_sec_params_t)); // Security parameters to be used for all security procedures. sec_params.bond = SEC_PARAMS_BOND; sec_params.mitm = SEC_PARAMS_MITM; sec_params.lesc = SEC_PARAMS_LESC; sec_params.keypress = SEC_PARAMS_KEYPRESS; sec_params.io_caps = SEC_PARAMS_IO_CAPABILITIES; sec_params.oob = SEC_PARAMS_OOB; sec_params.min_key_size = SEC_PARAMS_MIN_KEY_SIZE; sec_params.max_key_size = SEC_PARAMS_MAX_KEY_SIZE; sec_params.kdist_own.enc = 1; sec_params.kdist_own.id = 1; sec_params.kdist_peer.enc = 1; sec_params.kdist_peer.id = 1; err_code = pm_sec_params_set(&sec_params); APP_ERROR_CHECK(err_code); err_code = pm_register(pm_evt_handler); APP_ERROR_CHECK(err_code); err_code = fds_register(fds_evt_handler); APP_ERROR_CHECK(err_code); ecc_init(); #if LESC_DEBUG_MODE memcpy(m_lesc_sk.sk, m_debug_lesc_sk.sk, BLE_GAP_LESC_P256_SK_LEN); err_code = ecc_p256_public_key_compute((uint8_t *) m_lesc_sk.sk, m_lesc_pk.pk); APP_ERROR_CHECK(err_code); #else err_code = ecc_p256_keypair_gen(m_lesc_sk.sk, m_lesc_pk.pk); APP_ERROR_CHECK(err_code); #endif /* Set the public key */ err_code = pm_lesc_public_key_set(&m_lesc_pk); APP_ERROR_CHECK(err_code); }
/* ECC init */ int CRYPT_ECC_Initialize(CRYPT_ECC_CTX* ecc) { if (ecc == NULL) return BAD_FUNC_ARG; ecc->holder = (ecc_key*)XMALLOC(sizeof(ecc_key), NULL, DYNAMIC_TYPE_ECC); if (ecc->holder == NULL) return -1; ecc_init((ecc_key*)ecc->holder); return 0; }
/* reads `count' bytes from `offset' and corrects possible errors without erasure detection, returning the number of corrected bytes in `errors' */ static ssize_t ecc_read(fec_handle *f, uint8_t *dest, size_t count, uint64_t offset, size_t *errors) { check(f); check(dest); check(offset < f->data_size); check(offset + count <= f->data_size); check(errors); debug("[%" PRIu64 ", %" PRIu64 ")", offset, offset + count); rs_unique_ptr rs(NULL, free_rs_char); std::unique_ptr<uint8_t[]> ecc_data; if (ecc_init(f, rs, ecc_data) == -1) { return -1; } uint64_t curr = offset / FEC_BLOCKSIZE; size_t coff = (size_t)(offset - curr * FEC_BLOCKSIZE); size_t left = count; uint8_t data[FEC_BLOCKSIZE]; while (left > 0) { /* there's no erasure detection without verity metadata */ if (__ecc_read(f, rs.get(), data, curr * FEC_BLOCKSIZE, false, ecc_data.get(), errors) == -1) { return -1; } size_t copy = FEC_BLOCKSIZE - coff; if (copy > left) { copy = left; } memcpy(dest, &data[coff], copy); dest += copy; left -= copy; coff = 0; ++curr; } return count; }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD ( startup_process, ev, data ) { PROCESS_BEGIN(); memset ( prKey_alice, 0, NUMWORDS*NN_DIGIT_LEN ); prKey_alice[9] = 0x7b01; prKey_alice[8] = 0x2db7; prKey_alice[7] = 0x681a; prKey_alice[6] = 0x3f28; prKey_alice[5] = 0xb918; prKey_alice[4] = 0x5c8b; prKey_alice[3] = 0x2ac5; prKey_alice[2] = 0xd528; prKey_alice[1] = 0xdecd; prKey_alice[0] = 0x52da; ecc_init(); process_start ( &bob_process, NULL ); PROCESS_END(); }
int main(int argc, char * argv[]) { uint8_t hash[SHA256_DIGEST_LENGTH] = {0}; NN_DIGIT signature_r[NUMWORDS], signature_s[NUMWORDS]; NN_DIGIT privKey[NUMWORDS]; point_t pubKey; uint8_t data [52] = { 1, 2, 3, 4, 5 }; SHA256_CTX ctx; memset(privKey, 0, NUMBYTES); memset(&pubKey, 0, sizeof(pubKey)); memset(signature_r, 0, NUMBYTES); memset(signature_s, 0, NUMBYTES); SHA256_Init(&ctx); SHA256_Update(&ctx, data, 52); SHA256_Final(hash, &ctx); ecc_init(); ecc_gen_private_key(privKey); ecc_gen_pub_key(privKey, &pubKey); ecdsa_init(&pubKey); ecdsa_sign(hash, signature_r, signature_s, privKey); assert(ecdsa_verify(hash, signature_r, signature_s, &pubKey) == 1); signature_r[0] ^= 0xff; assert(ecdsa_verify(hash, signature_r, signature_s, &pubKey) != 1); return 0; }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(startup_process, ev, data) { PROCESS_BEGIN(); memset(prKey_bob, 0, NUMWORDS*NN_DIGIT_LEN); memset(pbkey_bob.x, 0, NUMWORDS*NN_DIGIT_LEN); memset(pbkey_bob.y, 0, NUMWORDS*NN_DIGIT_LEN); /* set public key for Alice */ pbkey_alice.x[5] = 0x00000000; pbkey_alice.x[4] = 0x21961f69; pbkey_alice.x[3] = 0xf02d202b; pbkey_alice.x[2] = 0xa4b41f1a; pbkey_alice.x[1] = 0x0aa08a86; pbkey_alice.x[0] = 0xdf27908d; pbkey_alice.y[5] = 0x00000000; pbkey_alice.y[4] = 0x378e1278; pbkey_alice.y[3] = 0x62836d75; pbkey_alice.y[2] = 0x7acb7ca4; pbkey_alice.y[1] = 0x0dc0ad13; pbkey_alice.y[0] = 0x741e287c; /* Initialize ecc. */ ecc_init(); /* Initialize ecdsa with Alice's public key */ ecdsa_init(&pbkey_alice); button_sensor.configure(SENSORS_ACTIVE, 1); process_start(&bob_process, NULL); printf("signature size %d\n", 2*(NUMWORDS * NN_DIGIT_LEN)); PROCESS_END(); }
static void sun4m_hw_init(const struct sun4m_hwdef *hwdef, MachineState *machine) { const char *cpu_model = machine->cpu_model; unsigned int i; void *iommu, *espdma, *ledma, *nvram; qemu_irq *cpu_irqs[MAX_CPUS], slavio_irq[32], slavio_cpu_irq[MAX_CPUS], espdma_irq, ledma_irq; qemu_irq esp_reset, dma_enable; qemu_irq fdc_tc; qemu_irq *cpu_halt; unsigned long kernel_size; DriveInfo *fd[MAX_FD]; FWCfgState *fw_cfg; unsigned int num_vsimms; /* init CPUs */ if (!cpu_model) cpu_model = hwdef->default_cpu_model; for(i = 0; i < smp_cpus; i++) { cpu_devinit(cpu_model, i, hwdef->slavio_base, &cpu_irqs[i]); } for (i = smp_cpus; i < MAX_CPUS; i++) cpu_irqs[i] = qemu_allocate_irqs(dummy_cpu_set_irq, NULL, MAX_PILS); /* set up devices */ ram_init(0, machine->ram_size, hwdef->max_mem); /* models without ECC don't trap when missing ram is accessed */ if (!hwdef->ecc_base) { empty_slot_init(machine->ram_size, hwdef->max_mem - machine->ram_size); } prom_init(hwdef->slavio_base, bios_name); slavio_intctl = slavio_intctl_init(hwdef->intctl_base, hwdef->intctl_base + 0x10000ULL, cpu_irqs); for (i = 0; i < 32; i++) { slavio_irq[i] = qdev_get_gpio_in(slavio_intctl, i); } for (i = 0; i < MAX_CPUS; i++) { slavio_cpu_irq[i] = qdev_get_gpio_in(slavio_intctl, 32 + i); } if (hwdef->idreg_base) { idreg_init(hwdef->idreg_base); } if (hwdef->afx_base) { afx_init(hwdef->afx_base); } iommu = iommu_init(hwdef->iommu_base, hwdef->iommu_version, slavio_irq[30]); if (hwdef->iommu_pad_base) { /* On the real hardware (SS-5, LX) the MMU is not padded, but aliased. Software shouldn't use aliased addresses, neither should it crash when does. Using empty_slot instead of aliasing can help with debugging such accesses */ empty_slot_init(hwdef->iommu_pad_base,hwdef->iommu_pad_len); } espdma = sparc32_dma_init(hwdef->dma_base, slavio_irq[18], iommu, &espdma_irq, 0); ledma = sparc32_dma_init(hwdef->dma_base + 16ULL, slavio_irq[16], iommu, &ledma_irq, 1); if (graphic_depth != 8 && graphic_depth != 24) { error_report("Unsupported depth: %d", graphic_depth); exit (1); } num_vsimms = 0; if (num_vsimms == 0) { if (vga_interface_type == VGA_CG3) { if (graphic_depth != 8) { error_report("Unsupported depth: %d", graphic_depth); exit(1); } if (!(graphic_width == 1024 && graphic_height == 768) && !(graphic_width == 1152 && graphic_height == 900)) { error_report("Unsupported resolution: %d x %d", graphic_width, graphic_height); exit(1); } /* sbus irq 5 */ cg3_init(hwdef->tcx_base, slavio_irq[11], 0x00100000, graphic_width, graphic_height, graphic_depth); } else { /* If no display specified, default to TCX */ if (graphic_depth != 8 && graphic_depth != 24) { error_report("Unsupported depth: %d", graphic_depth); exit(1); } if (!(graphic_width == 1024 && graphic_height == 768)) { error_report("Unsupported resolution: %d x %d", graphic_width, graphic_height); exit(1); } tcx_init(hwdef->tcx_base, slavio_irq[11], 0x00100000, graphic_width, graphic_height, graphic_depth); } } for (i = num_vsimms; i < MAX_VSIMMS; i++) { /* vsimm registers probed by OBP */ if (hwdef->vsimm[i].reg_base) { empty_slot_init(hwdef->vsimm[i].reg_base, 0x2000); } } if (hwdef->sx_base) { empty_slot_init(hwdef->sx_base, 0x2000); } lance_init(&nd_table[0], hwdef->le_base, ledma, ledma_irq); nvram = m48t59_init(slavio_irq[0], hwdef->nvram_base, 0, 0x2000, 8); slavio_timer_init_all(hwdef->counter_base, slavio_irq[19], slavio_cpu_irq, smp_cpus); slavio_serial_ms_kbd_init(hwdef->ms_kb_base, slavio_irq[14], display_type == DT_NOGRAPHIC, ESCC_CLOCK, 1); /* Slavio TTYA (base+4, Linux ttyS0) is the first QEMU serial device Slavio TTYB (base+0, Linux ttyS1) is the second QEMU serial device */ escc_init(hwdef->serial_base, slavio_irq[15], slavio_irq[15], serial_hds[0], serial_hds[1], ESCC_CLOCK, 1); cpu_halt = qemu_allocate_irqs(cpu_halt_signal, NULL, 1); if (hwdef->apc_base) { apc_init(hwdef->apc_base, cpu_halt[0]); } if (hwdef->fd_base) { /* there is zero or one floppy drive */ memset(fd, 0, sizeof(fd)); fd[0] = drive_get(IF_FLOPPY, 0, 0); sun4m_fdctrl_init(slavio_irq[22], hwdef->fd_base, fd, &fdc_tc); } else { fdc_tc = *qemu_allocate_irqs(dummy_fdc_tc, NULL, 1); } slavio_misc_init(hwdef->slavio_base, hwdef->aux1_base, hwdef->aux2_base, slavio_irq[30], fdc_tc); if (drive_get_max_bus(IF_SCSI) > 0) { fprintf(stderr, "qemu: too many SCSI bus\n"); exit(1); } esp_init(hwdef->esp_base, 2, espdma_memory_read, espdma_memory_write, espdma, espdma_irq, &esp_reset, &dma_enable); qdev_connect_gpio_out(espdma, 0, esp_reset); qdev_connect_gpio_out(espdma, 1, dma_enable); if (hwdef->cs_base) { sysbus_create_simple("SUNW,CS4231", hwdef->cs_base, slavio_irq[5]); } if (hwdef->dbri_base) { /* ISDN chip with attached CS4215 audio codec */ /* prom space */ empty_slot_init(hwdef->dbri_base+0x1000, 0x30); /* reg space */ empty_slot_init(hwdef->dbri_base+0x10000, 0x100); } if (hwdef->bpp_base) { /* parallel port */ empty_slot_init(hwdef->bpp_base, 0x20); } kernel_size = sun4m_load_kernel(machine->kernel_filename, machine->initrd_filename, machine->ram_size); nvram_init(nvram, (uint8_t *)&nd_table[0].macaddr, machine->kernel_cmdline, machine->boot_order, machine->ram_size, kernel_size, graphic_width, graphic_height, graphic_depth, hwdef->nvram_machine_id, "Sun4m"); if (hwdef->ecc_base) ecc_init(hwdef->ecc_base, slavio_irq[28], hwdef->ecc_version); fw_cfg = fw_cfg_init(0, 0, CFG_ADDR, CFG_ADDR + 2); fw_cfg_add_i16(fw_cfg, FW_CFG_MAX_CPUS, (uint16_t)max_cpus); fw_cfg_add_i32(fw_cfg, FW_CFG_ID, 1); fw_cfg_add_i64(fw_cfg, FW_CFG_RAM_SIZE, (uint64_t)ram_size); fw_cfg_add_i16(fw_cfg, FW_CFG_MACHINE_ID, hwdef->machine_id); fw_cfg_add_i16(fw_cfg, FW_CFG_SUN4M_DEPTH, graphic_depth); fw_cfg_add_i16(fw_cfg, FW_CFG_SUN4M_WIDTH, graphic_width); fw_cfg_add_i16(fw_cfg, FW_CFG_SUN4M_HEIGHT, graphic_height); fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_ADDR, KERNEL_LOAD_ADDR); fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_SIZE, kernel_size); if (machine->kernel_cmdline) { fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_CMDLINE, CMDLINE_ADDR); pstrcpy_targphys("cmdline", CMDLINE_ADDR, TARGET_PAGE_SIZE, machine->kernel_cmdline); fw_cfg_add_string(fw_cfg, FW_CFG_CMDLINE_DATA, machine->kernel_cmdline); fw_cfg_add_i32(fw_cfg, FW_CFG_CMDLINE_SIZE, strlen(machine->kernel_cmdline) + 1); } else { fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_CMDLINE, 0); fw_cfg_add_i32(fw_cfg, FW_CFG_CMDLINE_SIZE, 0); } fw_cfg_add_i32(fw_cfg, FW_CFG_INITRD_ADDR, INITRD_LOAD_ADDR); fw_cfg_add_i32(fw_cfg, FW_CFG_INITRD_SIZE, 0); // not used fw_cfg_add_i16(fw_cfg, FW_CFG_BOOT_DEVICE, machine->boot_order[0]); qemu_register_boot_set(fw_cfg_boot_set, fw_cfg); }
/* * Autodetect onboard DDR SDRAM on 440 platforms * * NOTE: Some of the hardcoded values are hardware dependant, * so this should be extended for other future boards * using this routine! */ phys_size_t initdram(int board_type) { int i; int tr1_bank1; #if defined(CONFIG_440GX) || defined(CONFIG_440EP) || \ defined(CONFIG_440GR) || defined(CONFIG_440SP) /* * Soft-reset SDRAM controller. */ mtsdr(SDR0_SRST, SDR0_SRST_DMC); mtsdr(SDR0_SRST, 0x00000000); #endif for (i=0; i<N_MB0CF; i++) { /* * Disable memory controller. */ mtsdram(SDRAM0_CFG0, 0x00000000); /* * Setup some default */ mtsdram(SDRAM0_UABBA, 0x00000000); /* ubba=0 (default) */ mtsdram(SDRAM0_SLIO, 0x00000000); /* rdre=0 wrre=0 rarw=0 */ mtsdram(SDRAM0_DEVOPT, 0x00000000); /* dll=0 ds=0 (normal) */ mtsdram(SDRAM0_WDDCTR, CONFIG_SYS_SDRAM0_WDDCTR); mtsdram(SDRAM0_CLKTR, 0x40000000); /* clkp=1 (90 deg wr) dcdt=0 */ /* * Following for CAS Latency = 2.5 @ 133 MHz PLB */ mtsdram(SDRAM0_B0CR, mb0cf[i].reg); mtsdram(SDRAM0_TR0, CONFIG_SYS_SDRAM0_TR0); mtsdram(SDRAM0_TR1, 0x80800800); /* SS=T2 SL=STAGE 3 CD=1 CT=0x00*/ mtsdram(SDRAM0_RTR, CONFIG_SYS_SDRAM0_RTR); mtsdram(SDRAM0_CFG1, 0x00000000); /* Self-refresh exit, disable PM*/ udelay(400); /* Delay 200 usecs (min) */ /* * Enable the controller, then wait for DCEN to complete */ mtsdram(SDRAM0_CFG0, CONFIG_SYS_SDRAM0_CFG0); udelay(10000); if (get_ram_size(0, mb0cf[i].size) == mb0cf[i].size) { phys_size_t size = mb0cf[i].size; /* * Optimize TR1 to current hardware environment */ sdram_tr1_set(0x00000000, &tr1_bank1); mtsdram(SDRAM0_TR1, (tr1_bank1 | 0x80800800)); /* * OK, size detected. Enable second bank if * defined (assumes same type as bank 0) */ #ifdef CONFIG_SDRAM_BANK1 mtsdram(SDRAM0_CFG0, 0); mtsdram(SDRAM0_B1CR, mb0cf[i].size | mb0cf[i].reg); mtsdram(SDRAM0_CFG0, CONFIG_SYS_SDRAM0_CFG0); udelay(10000); /* * Check if 2nd bank is really available. * If the size not equal to the size of the first * bank, then disable the 2nd bank completely. */ if (get_ram_size((long *)mb0cf[i].size, mb0cf[i].size) != mb0cf[i].size) { mtsdram(SDRAM0_CFG0, 0); mtsdram(SDRAM0_B1CR, 0); mtsdram(SDRAM0_CFG0, CONFIG_SYS_SDRAM0_CFG0); udelay(10000); } else { /* * We have two identical banks, so the size * is twice the bank size */ size = 2 * size; } #endif #ifdef CONFIG_SDRAM_ECC ecc_init(0, size); #endif /* * OK, size detected -> all done */ return size; } } return 0; /* nothing found ! */ }
static void sun4m_hw_init(const struct hwdef *hwdef, int RAM_size, const char *boot_device, DisplayState *ds, const char *kernel_filename, const char *kernel_cmdline, const char *initrd_filename, const char *cpu_model) { CPUState *env, *envs[MAX_CPUS]; unsigned int i; void *iommu, *espdma, *ledma, *main_esp, *nvram; qemu_irq *cpu_irqs[MAX_CPUS], *slavio_irq, *slavio_cpu_irq, *espdma_irq, *ledma_irq; qemu_irq *esp_reset, *le_reset; unsigned long prom_offset, kernel_size; int ret; char buf[1024]; BlockDriverState *fd[MAX_FD]; int index; /* init CPUs */ if (!cpu_model) cpu_model = hwdef->default_cpu_model; for(i = 0; i < smp_cpus; i++) { env = cpu_init(cpu_model); if (!env) { fprintf(stderr, "qemu: Unable to find Sparc CPU definition\n"); exit(1); } cpu_sparc_set_id(env, i); envs[i] = env; if (i == 0) { qemu_register_reset(main_cpu_reset, env); } else { qemu_register_reset(secondary_cpu_reset, env); env->halted = 1; } register_savevm("cpu", i, 3, cpu_save, cpu_load, env); cpu_irqs[i] = qemu_allocate_irqs(cpu_set_irq, envs[i], MAX_PILS); env->prom_addr = hwdef->slavio_base; } for (i = smp_cpus; i < MAX_CPUS; i++) cpu_irqs[i] = qemu_allocate_irqs(dummy_cpu_set_irq, NULL, MAX_PILS); /* allocate RAM */ if ((uint64_t)RAM_size > hwdef->max_mem) { fprintf(stderr, "qemu: Too much memory for this machine: %d, maximum %d\n", (unsigned int)RAM_size / (1024 * 1024), (unsigned int)(hwdef->max_mem / (1024 * 1024))); exit(1); } cpu_register_physical_memory(0, RAM_size, 0); /* load boot prom */ prom_offset = RAM_size + hwdef->vram_size; cpu_register_physical_memory(hwdef->slavio_base, (PROM_SIZE_MAX + TARGET_PAGE_SIZE - 1) & TARGET_PAGE_MASK, prom_offset | IO_MEM_ROM); if (bios_name == NULL) bios_name = PROM_FILENAME; snprintf(buf, sizeof(buf), "%s/%s", bios_dir, bios_name); ret = load_elf(buf, hwdef->slavio_base - PROM_VADDR, NULL, NULL, NULL); if (ret < 0 || ret > PROM_SIZE_MAX) ret = load_image(buf, phys_ram_base + prom_offset); if (ret < 0 || ret > PROM_SIZE_MAX) { fprintf(stderr, "qemu: could not load prom '%s'\n", buf); exit(1); } prom_offset += (ret + TARGET_PAGE_SIZE - 1) & TARGET_PAGE_MASK; /* set up devices */ slavio_intctl = slavio_intctl_init(hwdef->intctl_base, hwdef->intctl_base + 0x10000ULL, &hwdef->intbit_to_level[0], &slavio_irq, &slavio_cpu_irq, cpu_irqs, hwdef->clock_irq); if (hwdef->idreg_base != (target_phys_addr_t)-1) { stl_raw(phys_ram_base + prom_offset, 0xfe810103); cpu_register_physical_memory(hwdef->idreg_base, sizeof(uint32_t), prom_offset | IO_MEM_ROM); } iommu = iommu_init(hwdef->iommu_base, hwdef->iommu_version, slavio_irq[hwdef->me_irq]); espdma = sparc32_dma_init(hwdef->dma_base, slavio_irq[hwdef->esp_irq], iommu, &espdma_irq, &esp_reset); ledma = sparc32_dma_init(hwdef->dma_base + 16ULL, slavio_irq[hwdef->le_irq], iommu, &ledma_irq, &le_reset); if (graphic_depth != 8 && graphic_depth != 24) { fprintf(stderr, "qemu: Unsupported depth: %d\n", graphic_depth); exit (1); } tcx_init(ds, hwdef->tcx_base, phys_ram_base + RAM_size, RAM_size, hwdef->vram_size, graphic_width, graphic_height, graphic_depth); if (nd_table[0].model == NULL || strcmp(nd_table[0].model, "lance") == 0) { lance_init(&nd_table[0], hwdef->le_base, ledma, *ledma_irq, le_reset); } else if (strcmp(nd_table[0].model, "?") == 0) { fprintf(stderr, "qemu: Supported NICs: lance\n"); exit (1); } else { fprintf(stderr, "qemu: Unsupported NIC: %s\n", nd_table[0].model); exit (1); } nvram = m48t59_init(slavio_irq[0], hwdef->nvram_base, 0, hwdef->nvram_size, 8); slavio_timer_init_all(hwdef->counter_base, slavio_irq[hwdef->clock1_irq], slavio_cpu_irq, smp_cpus); slavio_serial_ms_kbd_init(hwdef->ms_kb_base, slavio_irq[hwdef->ms_kb_irq], nographic); // Slavio TTYA (base+4, Linux ttyS0) is the first Qemu serial device // Slavio TTYB (base+0, Linux ttyS1) is the second Qemu serial device slavio_serial_init(hwdef->serial_base, slavio_irq[hwdef->ser_irq], serial_hds[1], serial_hds[0]); if (hwdef->fd_base != (target_phys_addr_t)-1) { /* there is zero or one floppy drive */ fd[1] = fd[0] = NULL; index = drive_get_index(IF_FLOPPY, 0, 0); if (index != -1) fd[0] = drives_table[index].bdrv; sun4m_fdctrl_init(slavio_irq[hwdef->fd_irq], hwdef->fd_base, fd); } if (drive_get_max_bus(IF_SCSI) > 0) { fprintf(stderr, "qemu: too many SCSI bus\n"); exit(1); } main_esp = esp_init(hwdef->esp_base, espdma, *espdma_irq, esp_reset); for (i = 0; i < ESP_MAX_DEVS; i++) { index = drive_get_index(IF_SCSI, 0, i); if (index == -1) continue; esp_scsi_attach(main_esp, drives_table[index].bdrv, i); } slavio_misc = slavio_misc_init(hwdef->slavio_base, hwdef->power_base, slavio_irq[hwdef->me_irq]); if (hwdef->cs_base != (target_phys_addr_t)-1) cs_init(hwdef->cs_base, hwdef->cs_irq, slavio_intctl); kernel_size = sun4m_load_kernel(kernel_filename, kernel_cmdline, initrd_filename); nvram_init((m48t59_t *)nvram, (uint8_t *)&nd_table[0].macaddr, kernel_cmdline, boot_device, RAM_size, kernel_size, graphic_width, graphic_height, graphic_depth, hwdef->machine_id, "Sun4m"); if (hwdef->ecc_base != (target_phys_addr_t)-1) ecc_init(hwdef->ecc_base, hwdef->ecc_version); }
void bench_eccKeyAgree(void) { ecc_key genKey, genKey2; double start, total, each, milliEach; int i, ret; byte shared[1024]; byte sig[1024]; byte digest[32]; word32 x = 0; ecc_init(&genKey); ecc_init(&genKey2); ret = InitRng(&rng); if (ret < 0) { printf("InitRNG failed\n"); return; } ret = ecc_make_key(&rng, 32, &genKey); if (ret != 0) { printf("ecc_make_key failed\n"); return; } ret = ecc_make_key(&rng, 32, &genKey2); if (ret != 0) { printf("ecc_make_key failed\n"); return; } /* 256 bit */ start = current_time(1); for(i = 0; i < agreeTimes; i++) { x = sizeof(shared); ret = ecc_shared_secret(&genKey, &genKey2, shared, &x); if (ret != 0) { printf("ecc_shared_secret failed\n"); return; } } total = current_time(0) - start; each = total / agreeTimes; /* per second */ milliEach = each * 1000; /* millisconds */ printf("EC-DHE key agreement %6.3f milliseconds, avg over %d" " iterations\n", milliEach, agreeTimes); /* make dummy digest */ for (i = 0; i < (int)sizeof(digest); i++) digest[i] = (byte)i; start = current_time(1); for(i = 0; i < agreeTimes; i++) { x = sizeof(sig); ret = ecc_sign_hash(digest, sizeof(digest), sig, &x, &rng, &genKey); if (ret != 0) { printf("ecc_sign_hash failed\n"); return; } } total = current_time(0) - start; each = total / agreeTimes; /* per second */ milliEach = each * 1000; /* millisconds */ printf("EC-DSA sign time %6.3f milliseconds, avg over %d" " iterations\n", milliEach, agreeTimes); start = current_time(1); for(i = 0; i < agreeTimes; i++) { int verify = 0; ret = ecc_verify_hash(sig, x, digest, sizeof(digest), &verify, &genKey); if (ret != 0) { printf("ecc_verify_hash failed\n"); return; } } total = current_time(0) - start; each = total / agreeTimes; /* per second */ milliEach = each * 1000; /* millisconds */ printf("EC-DSA verify time %6.3f milliseconds, avg over %d" " iterations\n", milliEach, agreeTimes); ecc_free(&genKey2); ecc_free(&genKey); }
int main(int argc, char **argv) { int fd,port=3533, infd, pid; struct sockaddr_in s; socklen_t size = sizeof(s); int c; // Set is set for single shot mode - no forking is performed int single = 0; ecc_init(); while (1) { int option_index = 0; static struct option long_options[] = { {"port", 1, 0, 'p'}, {"single", 0, 0, 's'}, {"help", 0, 0, 'h'}, {0, 0, 0, 0} }; c = getopt_long (argc, argv, "p:hs", long_options, &option_index); if(c==-1) break; switch (c) { // We need to save the results to a file: case 'p': { port = atoi(optarg); break; }; case 's': single = 1; break; case 'h': default: usage(argv); }; }; fd = socket (PF_INET, SOCK_STREAM, 0); if(fd<0) { RAISE(E_IOERROR,NULL,"Cant create socket"); }; if(setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, &s, sizeof (s))<0) RAISE(E_IOERROR,NULL,"Set Sockopt failed"); s.sin_family=AF_INET; s.sin_addr.s_addr=INADDR_ANY; s.sin_port=htons(port); if(bind(fd,(struct sockaddr *)&s,sizeof(s))<0) RAISE(E_IOERROR,NULL,"Unable to bind to port %u",port); if(listen(fd,1)<0) RAISE(E_IOERROR,NULL,"Unable to listen"); while(1) { infd=accept(fd,(struct sockaddr *)&s,&size); // Handle a single connection and then quit if(single) { handle_connection(infd); exit(0); }; pid=fork(); // Child handles the connection if(!pid) { handle_connection(infd); exit(0); }; }; return 0; }
/* reads `count' bytes from `offset', corrects possible errors with erasure detection, and verifies the integrity of read data using verity hash tree; returns the number of corrections in `errors' */ static ssize_t verity_read(fec_handle *f, uint8_t *dest, size_t count, uint64_t offset, size_t *errors) { check(f); check(dest); check(offset < f->data_size); check(offset + count <= f->data_size); check(f->verity.hash); check(errors); debug("[%" PRIu64 ", %" PRIu64 ")", offset, offset + count); rs_unique_ptr rs(NULL, free_rs_char); std::unique_ptr<uint8_t[]> ecc_data; if (f->ecc.start && ecc_init(f, rs, ecc_data) == -1) { return -1; } uint64_t curr = offset / FEC_BLOCKSIZE; size_t coff = (size_t)(offset - curr * FEC_BLOCKSIZE); size_t left = count; uint8_t data[FEC_BLOCKSIZE]; uint64_t max_hash_block = (f->verity.hash_data_blocks * FEC_BLOCKSIZE - SHA256_DIGEST_LENGTH) / SHA256_DIGEST_LENGTH; while (left > 0) { check(curr <= max_hash_block); uint8_t *hash = &f->verity.hash[curr * SHA256_DIGEST_LENGTH]; uint64_t curr_offset = curr * FEC_BLOCKSIZE; bool expect_zeros = is_zero(f, curr_offset); /* if we are in read-only mode and expect to read a zero block, skip reading and just return zeros */ if (f->mode & O_RDONLY && expect_zeros) { memset(data, 0, FEC_BLOCKSIZE); goto valid; } /* copy raw data without error correction */ if (!raw_pread(f, data, FEC_BLOCKSIZE, curr_offset)) { error("failed to read: %s", strerror(errno)); return -1; } if (likely(verity_check_block(f, hash, data))) { goto valid; } /* we know the block is supposed to contain zeros, so return zeros instead of trying to correct it */ if (expect_zeros) { memset(data, 0, FEC_BLOCKSIZE); goto corrected; } if (!f->ecc.start) { /* fatal error without ecc */ error("[%" PRIu64 ", %" PRIu64 "): corrupted block %" PRIu64, offset, offset + count, curr); return -1; } else { debug("[%" PRIu64 ", %" PRIu64 "): corrupted block %" PRIu64, offset, offset + count, curr); } /* try to correct without erasures first, because checking for erasure locations is slower */ if (__ecc_read(f, rs.get(), data, curr_offset, false, ecc_data.get(), errors) == FEC_BLOCKSIZE && verity_check_block(f, hash, data)) { goto corrected; } /* try to correct with erasures */ if (__ecc_read(f, rs.get(), data, curr_offset, true, ecc_data.get(), errors) == FEC_BLOCKSIZE && verity_check_block(f, hash, data)) { goto corrected; } error("[%" PRIu64 ", %" PRIu64 "): corrupted block %" PRIu64 " (offset %" PRIu64 ") cannot be recovered", offset, offset + count, curr, curr_offset); dump("decoded block", curr, data, FEC_BLOCKSIZE); errno = EIO; return -1; corrected: /* update the corrected block to the file if we are in r/w mode */ if (f->mode & O_RDWR && !raw_pwrite(f, data, FEC_BLOCKSIZE, curr_offset)) { error("failed to write: %s", strerror(errno)); return -1; } valid: size_t copy = FEC_BLOCKSIZE - coff; if (copy > left) { copy = left; } memcpy(dest, &data[coff], copy); dest += copy; left -= copy; coff = 0; ++curr; } return count; }
void modem_init() { ecc_init(); buffer_init(&g_frames, g_frames_data, sizeof(g_frames_data)); }
int main(int argc, const char *argv[]) { int cert_fd, issuer_fd; int nwrites; s_certificate cert, issuer; if (argc != 2 && argc != 3) { print_usage(argv[0]); exit(EXIT_FAILURE); } ecc_init(); /* for critically secure code, you would need a better seed */ srand(time(NULL)); memset(&cert, 0, sizeof(cert)); memset(&issuer, 0, sizeof(cert)); /* open the new file */ cert_fd = open(argv[1], O_WRONLY | O_CREAT, S_IRUSR|S_IWUSR); if (cert_fd == -1) { fprintf(stderr, "unable to open %s\n", argv[1]); perror("open"); exit(EXIT_FAILURE); } /* generate the certificate */ generate_certificate(&cert); if (argc == 3) { int nreads = 0; /* open the issuer certificate */ issuer_fd = open(argv[2], O_RDONLY); if (issuer_fd == -1) { fprintf(stderr, "unable to open %s\n", argv[2]); perror("open"); goto cleanup; } nreads = read(issuer_fd, &issuer, sizeof(issuer)); if (nreads != sizeof(issuer)) { fprintf(stderr, "'%s' does not contain a valid certificate\n", argv[2]); perror("read"); goto cleanup; } /* sign the new certificate */ sign_certificate(&issuer, &cert); if (verify_certificate(&issuer.pub_cert, &cert.pub_cert)) { fprintf(stderr, "unable to verify generated signature\n"); goto cleanup; } close(issuer_fd); } /* store the certificate */ nwrites = write(cert_fd, &cert, sizeof(cert)); if (nwrites != sizeof(cert)) { fprintf(stderr, "unable to write the certificate\n"); perror("write"); goto cleanup; } close(cert_fd); return 0; cleanup: unlink(argv[2]); close(cert_fd); exit(EXIT_FAILURE); }