int IBE_deserialize_params(params_t params, byte_string_t bs)
//get system parameters from a byte_string
{
byte_string_t *bsa;
int n;
int i, j;
byte_string_decode_array(&bsa, &n, bs);
//TODO: check n is big enough
i = 0;
params->version = charstar_from_byte_string(bsa[i++]);
params->id = charstar_from_byte_string(bsa[i++]);
mpz_init(params->p);
mpz_init(params->q);
mympz_set_byte_string(params->p, bsa[i++]);
mympz_set_byte_string(params->q, bsa[i++]);
initpq(params);
point_init(params->P);
point_init(params->Ppub);
point_set_byte_string(params->P, bsa[i++]);
point_set_byte_string(params->Ppub, bsa[i++]);
point_init(params->PhiPpub);
point_Phi(params->PhiPpub, params->Ppub, params);
params->sharet = int_from_byte_string(bsa[i++]);
params->sharen = int_from_byte_string(bsa[i++]);
params->robustx = (mpz_t *) malloc(params->sharen * sizeof(mpz_t));
params->robustP = (point_t *) malloc(params->sharen * sizeof(point_t));
for (j=0; j<params->sharen; j++) {
mpz_init(params->robustx[j]);
mympz_set_byte_string(params->robustx[j], bsa[i++]);
//TODO: check it's different from others
point_init(params->robustP[j]);
point_set_byte_string(params->robustP[j], bsa[i++]);
}
point_mul_preprocess(params->P, params->curve);
miller_cache_init(params->Ppub_mc, params->curve);
tate_preprocess(params->Ppub_mc, params->Ppub, params->curve);
for(i=0; i<n; i++) {
byte_string_clear(bsa[i]);
}
free(bsa);
return 1;
}
void xnsynch_init(xnsynch_t *synch, xnflags_t flags)
{
initph(&synch->link);
if (flags & XNSYNCH_PIP)
flags |= XNSYNCH_PRIO; /* Obviously... */
synch->status = flags & ~XNSYNCH_CLAIMED;
synch->owner = NULL;
synch->cleanup = NULL; /* Only works for PIP-enabled objects. */
initpq(&synch->pendq);
xnarch_init_display_context(synch);
}
void xnsynch_init(struct xnsynch *synch, xnflags_t flags, xnarch_atomic_t *fastlock)
{
initph(&synch->link);
if (flags & XNSYNCH_PIP)
flags |= XNSYNCH_PRIO | XNSYNCH_OWNER; /* Obviously... */
synch->status = flags & ~XNSYNCH_CLAIMED;
synch->owner = NULL;
synch->cleanup = NULL; /* Only works for PIP-enabled objects. */
#ifdef CONFIG_XENO_FASTSYNCH
if ((flags & XNSYNCH_OWNER) && fastlock) {
synch->fastlock = fastlock;
xnarch_atomic_set(fastlock, XN_NO_HANDLE);
} else
synch->fastlock = NULL;
#endif /* CONFIG_XENO_FASTSYNCH */
initpq(&synch->pendq);
xnarch_init_display_context(synch);
}
int xnthread_init(struct xnthread *thread,
const struct xnthread_init_attr *attr,
struct xnsched *sched,
struct xnsched_class *sched_class,
const union xnsched_policy_param *sched_param)
{
unsigned int stacksize = attr->stacksize;
xnflags_t flags = attr->flags;
struct xnarchtcb *tcb;
int ret;
/* Setup the TCB. */
tcb = xnthread_archtcb(thread);
xnarch_init_tcb(tcb);
flags &= ~XNSUSP;
#ifndef CONFIG_XENO_HW_FPU
flags &= ~XNFPU;
#endif
#ifdef __XENO_SIM__
flags &= ~XNSHADOW;
#endif
if (flags & (XNSHADOW|XNROOT))
stacksize = 0;
else {
if (stacksize == 0) /* Pick a reasonable default. */
stacksize = XNARCH_THREAD_STACKSZ;
/* Align stack size on a natural word boundary */
stacksize &= ~(sizeof(long) - 1);
}
if (flags & XNROOT)
thread->idtag = 0;
else
thread->idtag = ++idtags ?: 1;
#if CONFIG_XENO_OPT_SYS_STACKPOOLSZ == 0
#ifndef __XENO_SIM__
if (stacksize > 0) {
xnlogerr("%s: cannot create kernel thread '%s' (CONFIG_XENO_OPT_SYS_STACKPOOLSZ == 0)\n",
__FUNCTION__, attr->name);
return -ENOMEM;
}
#endif
#else
ret = xnarch_alloc_stack(tcb, stacksize);
if (ret) {
xnlogerr("%s: no stack for kernel thread '%s' (raise CONFIG_XENO_OPT_SYS_STACKPOOLSZ)\n",
__FUNCTION__, attr->name);
return ret;
}
#endif
if (stacksize)
memset(xnarch_stack_base(tcb), 0, stacksize);
if (attr->name)
xnobject_copy_name(thread->name, attr->name);
else
snprintf(thread->name, sizeof(thread->name), "%p", thread);
xntimer_init(&thread->rtimer, attr->tbase, xnthread_timeout_handler);
xntimer_set_name(&thread->rtimer, thread->name);
xntimer_set_priority(&thread->rtimer, XNTIMER_HIPRIO);
xntimer_init(&thread->ptimer, attr->tbase, xnthread_periodic_handler);
xntimer_set_name(&thread->ptimer, thread->name);
xntimer_set_priority(&thread->ptimer, XNTIMER_HIPRIO);
thread->state = flags;
thread->info = 0;
thread->schedlck = 0;
thread->signals = 0;
thread->asrmode = 0;
thread->asrimask = 0;
thread->asr = XNTHREAD_INVALID_ASR;
thread->asrlevel = 0;
thread->ops = attr->ops;
thread->rrperiod = XN_INFINITE;
thread->rrcredit = XN_INFINITE;
thread->wchan = NULL;
thread->wwake = NULL;
thread->wcontext = NULL;
thread->hrescnt = 0;
thread->errcode = 0;
thread->registry.handle = XN_NO_HANDLE;
thread->registry.waitkey = NULL;
memset(&thread->stat, 0, sizeof(thread->stat));
/* These will be filled by xnpod_start_thread() */
thread->imask = 0;
thread->imode = 0;
thread->entry = NULL;
thread->cookie = 0;
inith(&thread->glink);
initph(&thread->rlink);
initph(&thread->plink);
#ifdef CONFIG_XENO_OPT_PRIOCPL
initph(&thread->xlink);
thread->rpi = NULL;
#endif /* CONFIG_XENO_OPT_PRIOCPL */
#ifdef CONFIG_XENO_OPT_SELECT
thread->selector = NULL;
#endif /* CONFIG_XENO_OPT_SELECT */
initpq(&thread->claimq);
thread->sched = sched;
thread->init_class = sched_class;
thread->base_class = NULL; /* xnsched_set_policy() will set it. */
thread->init_schedparam = *sched_param;
ret = xnsched_init_tcb(thread);
if (ret)
goto fail;
/*
* We must set the scheduling policy last; the scheduling
* class implementation code may need the TCB to be fully
* initialized to proceed.
*/
ret = xnsched_set_policy(thread, sched_class, sched_param);
if (ret)
goto fail;
xnarch_init_display_context(thread);
return 0;
fail:
#if CONFIG_XENO_OPT_SYS_STACKPOOLSZ > 0
xnarch_free_stack(tcb);
#endif
return ret;
}
void IBE_setup(params_t params, byte_string_t master, int k, int qk, char *id)
/* generate system parameters
* k = number of bits in p (should be at least 512)
* qk = number of bits in q (size of subgroup, 160 is typical)
* id = system ID
*/
{
mpz_t p, q, r;
mpz_t x;
point_ptr P;
int solinasa, solinasb;
int kqk = k - qk - 4; //lose 4 bits since 12 is a 4-bit no.
unsigned int seed;
mpz_init(p); mpz_init(q); mpz_init(r); mpz_init(x);
//find random k-bit prime p such that
//p = 2 mod 3 and q = (p+1)/12r is prime as well for some r
//now also want q to be a Solinas prime
//we use rand() to help us find one: should be ok
crypto_rand_bytes((unsigned char *) &seed, sizeof(int));
srand(seed);
for(;;) {
//once q was just a random qk-bit prime
//now it must be a Solinas one
mpz_set_ui(q, 0);
solinasa = qk - 1;
mpz_setbit(q, solinasa);
mpz_set_ui(r, 0);
solinasb = rand() % qk;
mpz_setbit(r, solinasb);
if (rand() % 2) {
mpz_add(q, q, r);
} else {
mpz_sub(q, q, r);
solinasb = -solinasb;
}
mpz_set_ui(r, 1);
if (rand() % 2) {
mpz_add(q, q, r);
} else {
mpz_sub(q, q, r);
solinasa = -solinasa;
}
if (!mpz_probab_prime_p(q, 10)) continue;
mympz_randomb(r, kqk);
//p = q * r
mpz_mul(p, q, r);
//r = (((p << 1) + p) << 2) (= 12p)
mpz_mul_2exp(r, p, 1);
mpz_add(r, r, p);
mpz_mul_2exp(r, r, 2);
//p = r - 1
mpz_set_ui(p, 1);
mpz_sub(p, r, p);
if (mpz_probab_prime_p(p, 10)) break;
}
//pick master key x from F_q
mympz_randomm(x, q);
byte_string_set_mpz(master, x);
mpz_init(params->p);
mpz_init(params->q);
mpz_set(params->p, p);
mpz_set(params->q, q);
initpq(params);
//pick random point P of order q from E/F_p
point_init(params->P);
P = params->P;
do {
point_random(P, params->curve);
point_make_order_q(P, params);
} while (P->infinity);
point_init(params->Ppub);
point_mul(params->Ppub, x, P, params->curve);
point_mul_preprocess(P, params->curve);
miller_cache_init(params->Ppub_mc, params->curve);
tate_preprocess(params->Ppub_mc, params->Ppub, params->curve);
point_init(params->PhiPpub);
point_Phi(params->PhiPpub, params->Ppub, params);
params->id = (char *) malloc(strlen(id) + 1);
strcpy(params->id, id);
params->sharet = params->sharen = 0;
params->version = (char *) malloc(strlen(IBE_VERSION) + 1);
strcpy(params->version, IBE_VERSION);
mpz_clear(p); mpz_clear(q); mpz_clear(r); mpz_clear(x);
}